Scipy optimiser curve_fit

La fonction de mappage curve_fit () permet la flexibilité et offre le contrôle pour définir le type de courbe où le processus d'optimisation est effectué pour trouver certains paramètres de fonction optimisés. La méthode Curve Fit () fournie par Scipy sera couverte dans cet article. Ensuite, avec l'aide d'exemples, nous verrons comment utiliser la fonction Curve Fit ().

À la fin de ce tutoriel, nous découvrirons comment effectuer le montage de la courbe dans Python et comment l'ajustement de la courbe utilise les paramètres optimisés dans une fonction qui mappe les exemples d'entrée à la sortie. Mais d'abord, nous familiariser avec les bases de curve_fit ().

Python Scipy Optimiser la fonction d'ajustement de la courbe utilisée pour?

La fonction Python Scipy Optimize Curve Curve est largement utilisée pour obtenir les paramètres les mieux ajustés. La fonction curve_fit () est une fonction d'optimisation qui est utilisée pour trouver l'ensemble de paramètres optimisé pour une fonction indiquée qui s'adapte parfaitement à l'ensemble de données fourni.

La fonction Curve Fit () dans Scipy est une bibliothèque open source, utilisée pour ajuster les courbes à l'aide des moindres carrés non linéaires. Comme argument, le curve_fit () prend les mêmes données d'entrée, les données de sortie et le nom de la fonction de mappage qui doit être utilisé. La fonction de mappage doit accepter des échantillons de données d'entrée ainsi qu'un ensemble de paramètres.

Contrairement à l'apprentissage supervisé, la fonction d'ajustement de la courbe vous a besoin pour définir les fonctions qui mappent parfaitement les entrées dans les sorties. La fonction de cartographie peut simplement être une ligne droite comme une régression linéaire ou une ligne incurvée comme une régression polynomiale, ou cela pourrait être autre chose.

Syntaxe de Python Scipy.optimiser.curve_fit ()

La syntaxe Scipy Curve Fit () est fournie ci-dessous.

# scipy.optimiser.curve_fit (f, x-data, y-data, sigma = aucun, p0 = aucun)

Le curve_fit () prend quelques paramètres requis et certains paramètres facultatifs. Le «F» est une fonction modèle, f (a,…). Le premier argument qu'il prend doit être la variable indépendante, et les arguments restants doivent être les paramètres à adapter.

Le paramètre «x-data» est un paramètre de type tableau, qui est une variable indépendante où les données sont mesurées. Le «y-data» est un autre paramètre de type tableau, qui est une variable dépendante également connue sous le nom de sortie de la fonction.

Le «Sigma» est un paramètre facultatif qui détermine l'incertitude dans les «données y». La valeur de «Sigma» pourrait être simple «aucun», «séquence de longueur m ou« array mxm ». Le paramètre 'P0' est une supposition initiale de la longueur N pour les paramètres. Il s'agit d'un paramètre facultatif, et donc, s'il n'est pas fourni, la valeur initiale sera 1.

La fonction curve_fit () renvoie les deux valeurs; Popt et PCOV. Le «Popt» est un tableau qui représente les valeurs optimales pour les paramètres afin de minimiser la somme des résidus carrés. Dans le même temps, le «PCOV» est le tableau 2D qui représente la covariance estimée de «Popt».

De plus, il augmente les trois exceptions; Erreur de valeur, erreur d'exécution et avertissement d'optimisation. L'erreur de valeur est lancée lorsque des données X ou des données y contient des NANS, ou si une méthode incompatible est utilisée.

«L'erreur d'exécution» est lancée lorsque la moindre minimisation carrée échoue. Et «l'avertissement d'optimisation» est soulevé lorsque la covariance du paramètre ne peut être estimée.

Exemple 1:

Dans le premier exemple, nous tracerons une ligne droite qui convient à nos données fournies pour représenter l'expression du modèle linéaire. Après avoir importé les bibliothèques Python requises, nous avons utilisé Res2 = un * Res1 + deux équations pour créer un ensemble de données de 30 points.

Pour rendre l'ensemble de données plus réaliste, nous avons ajouté du bruit gaussien aux valeurs RES2. Ensuite, nous avons utilisé le scipy.optimiser.Technique Curve Fit () pour estimer les valeurs des paramètres «un» et «deux». Voici le code de programmation complet du modèle que vous pouvez suivre.

importer numpy comme p
Importer Matplotlib.Pypllot comme MTB
importer scipy
à partir de Scipy Import Optimize
def func (res1, un, deux):
retourner un * res1 + deux
res1 = p.lispace (start = -40, stop = 12, num = 30)
res2 = func (res1, 4, 2)
p.aléatoire.graine (4)
bruit = 10 * p.aléatoire.normal (taille = res2.taille)
res2 = res2 + bruit
Popt, Cov = Scipy.optimiser.curve_fit (func, res1, res2)
un, deux = popt
x_new_value = p.arange (min (res1), 20, 5)
y_new_value = func (x_new_value, un, deux)
VTT.disperser (res1, res2, color = "red")
VTT.tracé (x_new_value, y_new_value, color = "violet")
VTT.xlabel ('x')
VTT.ylabel ('y')
Print ("Valeur estimée de un:" + str (un))
Print ("Valeur estimée de deux:" + str (deux))
VTT.montrer()

Ci-dessous, vous pouvez trouver le résultat du code joint ci-dessus. Les points rouges de l'écran résultant représentent les points de données réels de l'ensemble de données.

D'un autre côté, la ligne violette est la courbe qui est montée sur l'ensemble de données en utilisant le scipy.optimiser.Méthode Curve Fit (). De plus, il fournit également la valeur estimée des deux paramètres «un» et «deux», qui est également calculé par Scipy.optimiser.Technique Curve Fit ().

Exemple 2:

Dans le deuxième exemple, nous expliquerons l'utilisation du Scipy.optimiser.Curve_fit () Méthode pour tracer la courbe exponentielle qui correspond à nos données.

Ici, nous avons utilisé res2 = un * res2 + une équation pour créer un ensemble de données de différents points. Le code restant du programme est le même que l'exemple ci-dessus. Voici le code pour tracer la courbe exponentielle avec la fonction curve_fit ().

Importer numpy comme p
Importer Matplotlib.Pypllot comme MTB
importer scipy
à partir de Scipy Import Optimize
def func (res1, un, deux):
retourner un * p.Exp (deux * res1)
res1 = p.lispace (12, 20, 30)
res2 = func (res1, 0.4, 0.3)
imprimer (res2)
bruit = 100 * p.aléatoire.normal (taille = res2.taille)
res2 = res2 + bruit
imprimer (res2)
Popt, Cov = Scipy.optimiser.curve_fit (func, res1, res2)
un, deux = popt
x_new_value = p.arange (min (res1), max (res1), 1)
y_new_value = func (x_new_value, un, deux)
VTT.disperser (res1, res2, color = ”vert»)
VTT.tracé (x_new_value, y_new_value, color = ”bleu")
VTT.xlabel ('x')
VTT.ylabel ('y')
Impression («Valeur estimée d'un:« + str (un))
Impression («valeur estimée de deux:« + str (deux))
VTT.montrer()

Voyons la sortie.

Ici, vous pouvez voir la représentation graphique.

Exemple 3:

Dans le troisième exemple, nous tracons les deux courbes simultanément autour de la ligne réelle pour voir la différence entre les deux valeurs. Voir le code ci-dessous.

Dans le code, nous avons importé les modules et défini la fonction (indiquée comme func_one). Après cela, nous avons défini les valeurs et appelé la fonction curve_fit pour tracer ces valeurs sur le graphique.

Importer Matplotlib.Pypllot comme MTB
importer numpy comme p
de Scipy.Optimiser l'importation curve_fit
def func_one (res1, un, deux, trois):
retourner un * p.exp (-Two * res1) + trois
res1_data = p.lispace (0, 2, 40)
res2 = func_one (res1_data, 1.5, 1.2, 0.6)
rng = p.aléatoire.default_rng ()
res2_noise = 0.2 * RNG.normal (size = res1_data.taille)
res2_data = res2 + res2_noise
VTT.tracé (res1_data, res2_data, 'b-', label = 'data')
popt, pcov = curve_fit (func_one, res1_data, res2_data)
popt
VTT.tracé (res1_data, func_one (res1_data, * popt), 'r-',
label = 'ajustement: un =% 5.3f, deux =% 5.3f, trois =% 5.3f '% tuple (popt))
popt, pcov = curve_fit (func_one, res1_data, res2_data, bounds = (0, [3., 1., 0.5]))
popt
VTT.tracé (res1_data, func_one (res1_data, * popt), 'g--',
label = 'ajustement: un =% 5.3f, deux =% 5.3f, trois =% 5.3f '% tuple (popt))
VTT.xlabel ('x')
VTT.ylabel ('y')
VTT.légende()
VTT.montrer()

La sortie est ci-dessous où vous pouvez voir les courbes résultantes.

Conclusion

Dans cet article, nous vous avons donné tous les détails sur l'utilisation de la fonction cuver_fit () fournie par Scipy. Nous avons commencé avec l'introduction de la fonction curve_fit (), puis nous avons appris la syntaxe de la fonction curve_fit (). Après cela, nous avons vu des exemples utiles de la façon dont la fonction curve_fit () est utilisée pour tracer les lignes et les courbes en python. Vous pouvez exécuter ces exemples par vous-même pour voir la sortie vous-même et une meilleure compréhension globale de l'ensemble du concept.