np.polyfit () – Raccordo curva con NumPy Polyfit

Il.polyfit() funzione, accetta tre diversi valori di input: x, y e il grado polinomiale. Gli argomenti x e y corrispondono ai valori dei punti dati che vogliamo adattare, rispettivamente sugli assi x e y. Il terzo parametro specifica il grado della nostra funzione polinomiale. Ad esempio, per ottenere un adattamento lineare, utilizzare il grado 1.

Che cosa è curva raccordo?

Curve fitting consiste nella costruzione di una funzione matematica in grado di adattarsi ad alcuni punti dati specifici. Il più delle volte, l’equazione di fitting è soggetta a vincoli; inoltre, è anche possibile fare un’ipotesi iniziale per fornire punti di partenza utili per la stima dei parametri di fitting, quest’ultima procedura ha il vantaggio di abbassare il lavoro computazionale. In questo articolo esploreremo la funzione NumPy .polyfit(), che consente di creare funzioni di adattamento polinomiale in modo molto semplice e immediato.

Misura lineare

Il tipo più semplice di misura è la misura lineare (una funzione polinomiale di primo grado), in cui i punti di dati sono montati usando una linea retta. L’equazione generale di una retta è:

y = mx + q

Dove “m” è chiamato coefficiente angolare e intercetta “q”. Quando applichiamo un adattamento lineare, stiamo fondamentalmente cercando i valori per i parametri “m” e ” q ” che producono la misura migliore per i nostri punti dati. In Numpy, la funzione np.polyfit() è uno strumento molto intuitivo e potente per il montaggio di datapoints; vediamo come adattare una serie casuale di punti dati con una linea retta.

Nell’esempio seguente, vogliamo applicare un adattamento lineare ad alcuni punti dati, descritti dagli array xe y. Il .polyfit() funzione, accetta tre diversi valori di input: x, y e il grado polinomiale. Mentre x e y corrispondono ai valori dei punti dati che vogliamo adattare, rispettivamente sugli assi x e y; il terzo parametro specifica il grado della nostra funzione polinomiale. Poiché vogliamo un adattamento lineare, specificheremo un grado uguale a 1. Gli output della funzione polyfit() saranno una lista contenente i parametri di fitting; il primo è quello che nella funzione viene moltiplicato per il termine di grado più alto; gli altri seguono quindi questo ordine.

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()

Come accennato in precedenza, la variabile fit conterrà i parametri di fitting. Il primo è il coefficiente angolare, l’ultimo l’intercetta. A questo punto, per tracciare il nostro fit, dobbiamo costruire i valori dell’asse y dai parametri ottenuti, usando i valori originali dell’asse X. Nell’esempio, questo passaggio è descritto dalla definizione della variabile fit_eq. L’ultima cosa che rimane è tracciare i dati e l’equazione di adattamento. Il risultato è:

Adattamento polinomiale di secondo grado

In questo secondo esempio, creeremo un adattamento polinomiale di secondo grado. Le funzioni polinomiali di questo tipo descrivono una curva parabolica nel piano xy; la loro equazione generale è:

y = ax2 + bx + c

dove a, b e c sono i parametri dell’equazione che stimiamo quando generiamo una funzione di adattamento. I punti dati che inseriremo in questo esempio, rappresentano la traiettoria di un oggetto che è stato lanciato da un’altezza sconosciuta. Sfruttando la funzione .polyfit(), inseriremo la traiettoria dell’oggetto in caduta e otterremo anche una stima per la sua velocità iniziale nella direzione x, 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()

Una volta inizializzati gli array x e y che definiscono la traiettoria dell’oggetto, applichiamo la funzione .polyfit(), questa volta inserendo “2” come grado della funzione di adattamento polinomiale. Questo perché la traiettoria di un oggetto che cade può essere descritta da un polinomio di secondo grado; nel nostro caso la relazione tra il x e y coordinate è dato da:

y = y0 – ½ (g/ v02)x2

dove y0 è la posizione iniziale (l’altezza da cui l’oggetto è stato buttato), g l’accelerazione di gravità ( 9,81 m/s2) e v0 la velocità iniziale (m/s) in direzione x (visita: https://en.wikipedia.org/wiki/Equations_for_a_falling_body per ulteriori dettagli). Assegniamo quindi alle variabili a, b e c il valore dei 3 parametri di fitting e definiamo fit_equation, l’equazione polinomiale che verrà tracciata; il risultato è:

Se ora stampiamo i tre parametri di montaggio, a, b e c, otteniamo i seguenti valori: a = -0.100 , b = 0.038, c = 24.92. Nell’equazione che descrive la traiettoria di un corpo in caduta non c’è b termine; poiché la forma è sempre un’approssimazione del reale risultato, ci sarà sempre un valore per tutti i parametri; tuttavia si deve notare che il valore del nostro b termine è molto più piccolo rispetto agli altri e può essere in qualche modo trascurato, quando si confrontano la nostra forma con l’equazione che descrive la fisica del problema. Il termine c rappresenta l’altezza iniziale (y0) mentre il termine a descrive la quantità – ½ (g/ v02). Quindi, la velocità iniziale v0 è data da:

v0=2-g2a

Ottenendo il valore finale di v0 = 6.979 m / s.