np.polyfit () – kurve montering med NumPy Polyfit

den .polyfit() funktion, accepterer tre forskellige inputværdier: x, y og polynomgraden. Argumenter x og y svarer til værdierne for de datapunkter, som vi ønsker at passe på henholdsvis akserne x og y. Den tredje parameter angiver graden af vores polynomfunktion. For eksempel, for at opnå en lineær pasform, brug grad 1.

Hvad er Curve Fitting?

kurvetilpasning består i at opbygge en matematisk funktion, der er i stand til at passe til nogle specifikke datapunkter. De fleste gange udsættes den passende ligning for begrænsninger; desuden er det også muligt at lave indledende gæt for at give nyttige udgangspunkt til estimering af monteringsparametrene, denne sidstnævnte procedure har fordelen ved at sænke beregningsarbejdet. I denne artikel vil vi undersøge numpy-funktionen .polyfit(), som gør det muligt at oprette polynomiske tilpasningsfunktioner på en meget enkel og øjeblikkelig måde.

lineær pasform

den enkleste type pasform er den lineære pasform (en første graders polynomfunktion), hvor datapunkterne monteres ved hjælp af en lige linje. Den generelle ligning for en lige linje er:

y = MH + k

hvor “m” kaldes vinkelkoefficient og “K” aflytning. Når vi anvender en lineær tilpasning, søger vi grundlæggende værdierne for parametrene” m “og” K”, der giver den bedste pasform til vores datapunkter. I Numpy er funktionen np.polyfit() et meget intuitivt og kraftfuldt værktøj til montering af datapunkter; lad os se, hvordan du passer til en tilfældig række datapunkter med en lige linje.

i det følgende eksempel ønsker vi at anvende en lineær tilpasning til nogle datapunkter, beskrevet af arrays x og y. Den .polyfit() funktion, accepterer tre forskellige inputværdier: x, y og polynomgraden. Mens x og y svarer til værdierne for de datapunkter, som vi ønsker at passe, på henholdsvis x og y akserne; den tredje parameter specificerer graden af vores polynomfunktion. Da vi ønsker en lineær pasform, specificerer vi en grad svarende til 1. Outputene fra polyfit() – funktionen vil være en liste, der indeholder tilpasningsparametrene; den første er den, der i funktionen ganges med den højeste grad sigt; de andre følger derefter denne rækkefølge.

import numpy as npfrom numpy import random #it will be useful for generating some random noise (on purpose) in the data points that we want to fitimport matplotlib.pyplot as plt #for plotting the data#---LINEAR FIT----#generate the x arrayx = np.linspace(0,60,60) # generate an array of 60 equally space points#generate the y array exploiting the random.randint() function to introduce some random noisey = np.array() #each element is a random number with value between +-2 the respective x axis value#Applying a linear fit with .polyfit()fit = np.polyfit(x,y,1)ang_coeff = fitintercept = fitfit_eq = ang_coeff*x + intercept #obtaining the y axis values for the fitting function#Plotting the datafig = plt.figure()ax = fig.subplots()ax.plot(x, fit_eq,color = 'r', alpha = 0.5, label = 'Linear fit')ax.scatter(x,y,s = 5, color = 'b', label = 'Data points') #Original data pointsax.set_title('Linear fit example')ax.legend()plt.show()

som nævnt før vil variablen fit indeholde monteringsparametrene. Den første er vinkelkoefficienten, den sidste er aflytningen. På dette tidspunkt er vi nødt til at bygge y-akseværdierne ud fra de opnåede parametre ved hjælp af de originale h-akseværdier for at plotte vores pasform. I eksemplet beskrives dette trin ved definitionen af fit_eq variablen. Den sidste resterende ting er at plotte dataene og den passende ligning. Resultatet er:

polynomisk pasform af anden grad

i dette andet eksempel opretter vi en anden grad polynomisk pasform. Deres generelle ligning er:

y = aks2 + BK + c

hvor A, b og c er ligningsparametrene, som vi estimerer, når vi genererer en passende funktion. De datapunkter, som vi vil passe i dette eksempel, repræsenterer banen for et objekt, der er kastet fra en ukendt højde. Ved at udnytte .polyfit() – funktionen passer vi til det faldende objekts bane, og vi får også et skøn for dets indledende hastighed i h-retningen, v0.

#-----POLYNOMIAL FIT----x = np.array() # x coordinatesy = np.array() # y coordinatesfit = np.polyfit(x, y, 2)a = fitb = fitc = fitfit_equation = a * np.square(x) + b * x + c#Plottingfig1 = plt.figure()ax1 = fig1.subplots()ax1.plot(x, fit_equation,color = 'r',alpha = 0.5, label = 'Polynomial fit')ax1.scatter(x, y, s = 5, color = 'b', label = 'Data points')ax1.set_title('Polynomial fit example')ax1.legend()plt.show()

når initialiseret x og y arrays definerer objektbanen, anvender vi funktionen .polyfit(), denne gang indsætter “2” som grad af polynomisk pasform funktion. Dette skyldes, at banen til et faldende objekt kan beskrives ved et andet graders polynom; i vores tilfælde er forholdet mellem koordinaterne x og y givet af:

y = y0 – liter (g/ v02)H2

hvor y0 er startpositionen (den højde, hvorfra objektet er kastet), g tyngdeaccelerationen ( 9,81 m/s2) og v0 starthastigheden (m/s) i h-retningen (besøg: https://en.wikipedia.org/wiki/Equations_for_a_falling_body for flere detaljer). Vi tildeler derefter ved variablerne a, b og c værdien af de 3 monteringsparametre, og vi definerer fit_equation, polynomligningen, der vil blive tegnet; resultatet er:

hvis vi nu udskriver de tre monteringsparametre, a,b og c, opnår vi følgende værdier: a = -0.100 , b = 0.038, c = 24.92. I ligningen, der beskriver banen for et faldende legeme, er der ingen B-udtryk; da pasformen altid er en tilnærmelse af det reelle resultat, vil vi altid få en værdi for alle parametrene; dog skal vi bemærke, at værdien af vores b-udtryk er meget mindre end de andre og på en eller anden måde kan forsømmes, når vi sammenligner vores pasform med ligningen, der beskriver problemets fysik. C-udtrykket repræsenterer den oprindelige højde (y0), mens A – udtrykket beskriver mængden-liter (g/ v02). Derfor er den indledende hastighed v0 givet ved:

v0=2-g2a

giver den endelige værdi af v0 = 6.979 m/s.