Interpolate de scipy

L'interpolation est ce dont nous allons discuter aujourd'hui. Le concept d'interpolation peut être défini comme une méthode de calcul d'une valeur ou d'un nombre entre deux points sur une ligne ou même une courbe. Ce concept peut utiliser les données dans 1, 2 ou même des dimensions plus élevées, car il existe plusieurs capacités générales disponibles dans SCIPY pour l'interpolation ainsi que la douceur. Que les données ne soient pas structurées, unidimensionnelles ou fournies sur une grille structurée, il détermine quelle méthode d'interpolation est utilisée. La douceur requise de l'interpolateur est une autre considération. Les méthodes suggérées pour l'interpolation se présentent sous une variété de formes. Avec des explications et des exemples adéquats, nous discuterons de l'interpolation de Scipy dans cet article.

Interpolation dans Scipy

Scipy propose un module nommé Scipy.Interpolate qui dispose d'une large gamme de fonctions liées à l'interpolation. Une méthode de création des points de données entre les points de données existants est appelé interpolation. Il existe des classes, des fonctions spline et des classes d'interpolation univariées et multivariées dans le module Scipy, Scipy.interpoler.

Types d'interpolation

Il existe de nombreuses façons d'interpoler, dont certaines incluent:

• • Interpolation 1-D
  • Interpolation spline
  • Interpolation de spline univariée
  • Interpolation RBF

Discutons de tous ces types en détail et avec des exemples de programmation pour voir les résultats.

Interpolation 1-D

Une distribution avec une seule variable peut être interpolée à l'aide de la fonction interp1d (). Il nécessite l'entrée de deux points, X et Y, et publie une fonction appelable qui, lorsqu'elle est appelée avec un nouveau x, renvoie le Y approprié.

Voici sa syntaxe complète:

Expliquons le concept d'interpolation 1-D avec l'exemple suivant:

Exemple:

Disons que vous souhaitez utiliser les valeurs X_Range et Y_Range pour créer une fonction linéaire avec la formule Y_Range = F (X_Range).

Cet exemple montre comment créer une fonction qui utilise déjà deux variables X_Range et Y_Range bien connues pour estimer les points de données d'une ligne à l'aide du Scipy.interpoler.Méthode interp1d (). Le terme «INTERP1D» fait référence à l'interpolation sur une seule dimension, comme une ligne, en utilisant uniquement les axes X_Range et Y_Range. L'ensemble du code est fourni ici.

La première section du code montre que nous importons les modules requis. Ce sont des matplotlib.Pypllot, Numpy, Scipy et Interp1d. La section suivante montre la génération des points aléatoires pour X_Range et Y_Range et l'utilisation de ces deux valeurs, X_Range et Y_Range. Il comprend également l'exécution du scipy.interpoler.Méthode interp1d () dans laquelle les valeurs X_Range et Y_Range sont passées sous forme de paramètres. Après cela, de nouveaux points aléatoires sont générés pour X_Range et Y_Range. Les quatre instructions d'impression qui sont utilisées ici affichent les points générés par la fonction linéaire.

La dernière section du code est l'endroit où un graphique est tracé à l'aide des valeurs X_Range, Y_Range et les valeurs X_RES et Y_RES résultant.

Importer Matplotlib.pypllot comme plt
Importer Numpy
importer scipy
de Scipy.Interpolate Import Interp1d
x_Range = Numpy.Arange (12,20)
print ('x:', x_range)
Y_Range = Numpy.Exp (-x_range / 10)
print ('y:', y_range)
func_linear = scipy.interpoler.INTERP1D (X_RANGE, Y_RANGE)
x_res = Numpy.Arange (12,19,0.1)
y_res = func_linear (x_res)
print ('new_x:', x_res)
print ('new_y:', y_res)
PLT.disperser (x_range, y_range, color = 'rouge')
PLT.tracé (x_res, y_res, color = 'orange')
PLT.xlabel ("x")
PLT.ylabel ("y")
PLT.Titre ("Interpolation 1-D")
PLT.montrer()
PLT.SaveFig ('Résultat / graphique.png ')

Il s'agit de l'écran résultant où vous pouvez voir la mise en œuvre de l'interpolation 1-D sur l'écran:

Interpolation spline

Cet exemple concerne l'interpolation spline.

Dans les champs d'ingénierie informatique de la modélisation assistée par ordinateur et des graphiques informatiques, une courbure polynomiale (paramétrique) par morceaux est plus fréquemment appelée une spline. En raison de leur simplicité dans la construction, la simplicité et la précision de l'évaluation, et la capacité de prédire des formes complexes grâce à un ajustement de courbe et à une conception de courbe hautement interactive, les splines sont fréquemment utilisées dans une variété de champs.

L'interpolation spline utilise des splines terminées aux polynômes pour construire une fonction par morceaux, par opposition à une interpolation 1D, où les points sont installés pour une seule courbe.

La méthode UnivariaSpline () accepte deux paramètres, Xs et YS, et génère une fonction appelable qui peut être invoquée avec une nouvelle valeur pour XS. Voir le code ci-joint suivant:

Le code est très similaire à l'exemple précédent, sauf que nous utilisons les différentes valeurs d'entrée ici. Ensuite, l'interpolate.La fonction splev () est utilisée sur ces valeurs. Différentes valeurs sont générées pour x, y et t. Ces valeurs sont tracées à l'écran avec une ligne de code dans la dernière section de l'image ci-jointe:

Importer Numpy
Importer Matplotlib.pypllot comme plt
à partir de Scipy Import Interpolate
x = numpy.Arange (0, 12)
y = Numpy.cos (x ** 3)
t = interpoler.splrep (x, y, s = 0)
x = numpy.Arange (0, Numpy.pi ** 2, Numpy.pi / 100)
y = interpoler.Splev (x, t, der = 0)
PLT.chiffre()
PLT.Plot (x, y, '*', x, y, x, numpy.cos (x),
x, y, 'b', color = "red")
PLT.légende ([«linéaire», «spline cubique», «vrai»])
PLT.axe ([- 0.2, 5.6, -1.3, 1.2])
PLT.Titre («Exemple d'interpolation cubique»)
PLT.montrer()

Ce qui suit est le graphique généré qui explique le concept d'interpolation cubique:

Interpolation de spline univariée

Nous parlerons de la spline univariée ici. Il s'adapte à un ensemble spécifique de points de données et est une spline de lissage 1D. Les données d'entrée X Val et Y Val sont ajustées à une spline de k degré en utilisant le scipy.interpoler.Univariatespliples. Le scipy.interpoler.La méthode UnivariaSpline a un autre argument, S, qui définit le nombre de nœuds en spécifiant une condition de lissage. La spline.Set Smoothing Factor () Fonction Calcule la spline à l'aide du facteur de lissage spécifié et des nœuds identifiés par l'appel précédent.

Importer Numpy
Importer Matplotlib.pypllot comme plt
de Scipy.Interpoler l'importation univariatesplin
x_Val = Numpy.lispace (-3, 3, 40)
y_val = Numpy.exp (-x_val ** 2) + 0.1 * Numpy.aléatoire.Randn (40)
PLT.Titre ("Spline univariée")
PLT.tracé (x_val, y_val, 'g.', ms = 8)
spline_shape = UnivariaSpline (x_val, y_val)
xs_shape = Numpy.Linspace (-3, 3, 2000)
PLT.Plot (xs_shape, spline_shape (xs_shape), 'jaune', lw = 3)
spline_shape.set_smoothing_factor (0.5)
PLT.Plot (xs_shape, spline_shape (xs_shape), color = 'orange', lw = 3)
PLT.montrer()

Ce qui suit est le graphique généré du code précédent:

Interpolation de fonction de base radiale (RBF)

Dans ce dernier exemple, nous nous concentrerons sur la fonction de base radiale (RBF) pour l'interpolation. Le scipy interpolé.RBF est utilisé pour l'interpolation de la dimension N des données dispersées. Selon sa définition, la fonction de base radiale correspond à un point de données de référence constant. Le scipy.interpoler.La classe RBF est utilisée pour interpoler les fonctions directement des données diffusées N-D à un domaine M-D avec l'utilisation des fonctions de base radiale.

La capture d'écran ci-jointe suivante montre le code complet. Ici, nous importons les modules RBF et Numpy. Après cela, les valeurs sont générées pour XS_Val et YS_Val en utilisant l'Arange () et Numpy.Méthodes sin (). Une déclaration d'impression est utilisée pour afficher le message «ici vous pouvez voir le résultat». Une variable «res» est créée dans laquelle la méthode RBF est utilisée et le XS_VAL et YS_VAL générés sont passés comme paramètres. Après cela, ZZ peut être vu dans lequel une liste de nombres est générée pour la plage spécifiée. Enfin, le résultat est affiché.

de Scipy.Interpoler l'importation RBF
Importer Numpy
xs_val = Numpy.Arange (8)
ys_val = xs_val ** 3 + numpy.sin (xs_val) + 2
imprimer ("Ici, vous pouvez voir le résultat:")
res = RBF (XS_VAL, YS_VAL)
zz = res (Numpy.Arange (2.1, 3, 0.1))
Imprimer (ZZ)

Ce qui suit est la sortie où une série de nombres est générée à partir du code précédent dans lequel la méthode RBF est utilisée.

Conclusion

Dans cet article, nous avons discuté de ce qu'est le concept d'interpolate Scipy. Ses types de base et les détails globaux sont couverts ici. Vous pouvez facilement trouver toutes les exigences concernant ledit sujet en détail avec des exemples de programmation. Nous avons discuté séparément de tous ses types (interpolation 1-D, interpolation de spline, interpolation de spline univariée et interpolation RBF) avec des explications et des exemples appropriés afin que vous puissiez mieux comprendre le concept entier.