Le np.polyfit() fonction, accepte trois valeurs d'entrée différentes :x , y et le degré polynomial. Arguments x et y correspondent aux valeurs des points de données que nous voulons ajuster, sur le x et y axes, respectivement. Le troisième paramètre spécifie le degré de notre fonction polynomiale. Par exemple, pour obtenir un ajustement linéaire, utilisez le degré 1.
Qu'est-ce que l'ajustement de courbe ?
L'ajustement de courbe consiste à construire une fonction mathématique capable d'ajuster certains points de données spécifiques. La plupart du temps, l'équation d'ajustement est soumise à des contraintes; de plus, il est également possible de faire une estimation initiale pour fournir des points de départ utiles pour l'estimation des paramètres d'ajustement, cette dernière procédure a l'avantage de réduire le travail de calcul. Dans cet article, nous allons explorer la fonction NumPy .polyfit() , qui permet de créer des fonctions d'ajustement polynomial de manière très simple et immédiate.
Ajustement linéaire
Le type d'ajustement le plus simple est l'ajustement linéaire (une fonction polynomiale du premier degré), dans lequel les points de données sont ajustés à l'aide d'une ligne droite. L'équation générale d'une droite est :
y =mx + q
Où "m" est appelé coefficient angulaire et "q" intercepter . Lorsque nous appliquons un ajustement linéaire, nous recherchons essentiellement les valeurs des paramètres "m" et "q" qui donnent le meilleur ajustement pour nos points de données. Dans Numpy, la fonction np.polyfit() est un outil très intuitif et puissant pour ajuster les points de données ; Voyons comment ajuster une série aléatoire de points de données avec une ligne droite.
Dans l'exemple suivant, nous souhaitons appliquer un ajustement linéaire à certains points de données, décrits par les tableaux x et y . Le .polyfit() fonction, accepte trois valeurs d'entrée différentes :x , y et le degré polynomial. Alors que x et y correspondent aux valeurs des points de données que nous voulons ajuster, sur le x et y axes, respectivement ; le troisième paramètre spécifie le degré de notre fonction polynomiale. Puisque nous voulons un ajustement linéaire, nous spécifierons un degré égal à 1. Les sorties du polyfit() fonction sera une liste contenant les paramètres d'ajustement ; le premier est celui qui dans la fonction est multiplié par le terme de plus haut degré; les autres suivent alors cet ordre.
import numpy as np
from numpy import random #it will be useful for generating some random noise (on purpose) in the data points that we want to fit
import matplotlib.pyplot as plt #for plotting the data
#---LINEAR FIT----
#generate the x array
x = 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 noise
y = np.array([random.randint(i-2, i+2) for i in x]) #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 = fit[0]
intercept = fit[1]
fit_eq = ang_coeff*x + intercept #obtaining the y axis values for the fitting function
#Plotting the data
fig = 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 points
ax.set_title('Linear fit example')
ax.legend()
plt.show()
Comme mentionné précédemment, la variable fit contiendra les paramètres d'ajustement. Le premier est le coefficient angulaire, le dernier l'ordonnée à l'origine. À ce stade, afin de tracer notre ajustement, nous devons construire les valeurs de l'axe des y à partir des paramètres obtenus, en utilisant les valeurs de l'axe des x d'origine. Dans l'exemple, cette étape est décrite par la définition du fit_eq variable. La dernière chose qui reste est de tracer les données et l'équation d'ajustement. Le résultat est :
Ajustement polynomial du second degré
Dans ce deuxième exemple, nous allons créer un ajustement polynomial du second degré. Les fonctions polynomiales de ce type décrivent une courbe parabolique en xy avion; leur équation générale est :
y =ax
2
où un , b et c sont les paramètres d'équation que nous estimons lors de la génération d'une fonction d'ajustement. Les points de données que nous allons ajuster dans cet exemple représentent la trajectoire d'un objet qui a été lancé d'une hauteur inconnue. Exploitation du .polyfit() fonction, nous ajusterons la trajectoire de l'objet qui tombe et nous obtiendrons également une estimation de sa vitesse initiale dans la direction x, v0 .
#-----POLYNOMIAL FIT----
x = np.array([1.2,2.5,3.4,4.0,5.4,6.1,7.2,8.1,9.0,10.1,11.2,12.3,13.4,14.1,15.0]) # x coordinates
y = np.array([24.8,24.5,24.0,23.3,22.4,21.3,20.0,18.5,16.8,14.9,12.8,10.5,8.0,5.3,2.4]) # y coordinates
fit = np.polyfit(x, y, 2)
a = fit[0]
b = fit[1]
c = fit[2]
fit_equation = a * np.square(x) + b * x + c
#Plotting
fig1 = 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()
Une fois initialisé le x et y tableaux définissant la trajectoire de l'objet, on applique la fonction .polyfit() , en insérant cette fois "2" comme degré de la fonction d'ajustement polynomial. En effet, la trajectoire d'un objet qui tombe peut être décrite par un polynôme du second degré; dans notre cas la relation entre le x et y coordonnées sont données par :
y =y 0 – ½ (g/v 0 2 )x 2
où y0 est la position initiale (la hauteur à partir de laquelle l'objet a été lancé), g l'accélération de la pesanteur ( ̴9.81 m/s
2
) et v0 la vitesse initiale (m/s) dans la direction x (visitez :https://en.wikipedia.org/wiki/Equations_for_a_falling_body pour plus de détails). On affecte ensuite aux variables a , b et c la valeur des 3 paramètres d'ajustement et on définit fit_equation , l'équation polynomiale qui sera tracée ; le résultat est :
Si nous imprimons maintenant les trois paramètres d'ajustement, a,b et c , on obtient les valeurs suivantes :a =-0.100 , b =0.038, c =24.92. Dans l'équation décrivant la trajectoire d'un corps qui tombe, il n'y a pas de b terme; puisque l'ajustement est toujours une approximation du résultat réel, nous obtiendrons toujours une valeur pour tous les paramètres ; cependant on remarquera que la valeur de notre b terme est beaucoup plus petit que les autres et peut être en quelque sorte négligé, lorsque l'on compare notre ajustement avec l'équation décrivant la physique du problème. Le c terme représente la hauteur initiale (y 0 ) tandis que le un terme décrit la quantité – ½ (g/ v 0 2 ) . Par conséquent, la vitesse initiale v 0 est donné par :
v0=2-g2a
Donner la valeur finale de v0 =6.979 m/s.
Humour de programmeur
❓ Question :Pourquoi les programmeurs confondent-ils toujours Halloween et Noël ?
❗ Répondre : Parce que le 31 octobre est égal au 25 décembre.
(Si vous ne l'avez pas compris, lisez nos articles sur le oct() et int() Fonctions intégrées Python !)
