Scipy interpolieren

Interpolation ist das, was wir heute diskutieren werden. Das Konzept der Interpolation kann als Methode zur Berechnung eines Wertes oder der Anzahl zwischen zwei Punkten in einer Linie oder sogar einer Kurve definiert werden. Dieses Konzept kann die Daten in 1, 2 oder sogar höheren Dimensionen verwenden. Unabhängig davon. Die erforderliche Glätte des Interpolators ist eine weitere Überlegung. Die Methoden, die für die Interpolation vorgeschlagen werden. Mit angemessener Erklärung und Beispielen werden wir über Scipys Interpolation in diesem Artikel diskutieren.

Interpolation in Scipy

Scipy bietet ein Modul namens Scipy an.Interpolieren Sie eine Vielzahl von interpolationsbedingten Funktionen. Eine Methode zum Erstellen der Datenpunkte zwischen vorhandenen Datenpunkten wird als Interpolation bezeichnet. Es gibt Klassen, Spline -Funktionen sowie univariate und multivariate Interpolationsklassen im Scipy -Modul Scipy, Scipy.interpolieren.

Interpolationstypen

Es gibt zahlreiche Möglichkeiten zu interpolieren, von denen einige gehören:

• • 1-D-Interpolation
  • Spline -Interpolation
  • Univariate Spline Interpolation
  • RBF -Interpolation

Lassen Sie uns alle diese Typen detailliert und mit Programmierbeispielen diskutieren, um die Ergebnisse anzuzeigen.

1-D-Interpolation

Eine Verteilung mit nur einer Variablen kann mit der Funktion interp1d () interpoliert werden. Es erfordert die Eingabe von zwei Punkten, x und y, und gibt eine aufrufbare Funktion aus, die, wenn sie mit einem neuen x aufgerufen wird, das entsprechende y zurückgibt.

Hier ist die vollständige Syntax:

Erklären wir das Konzept der 1-D-Interpolation mit dem folgenden Beispiel:

Beispiel:

Angenommen, Sie möchten die Werte x_Range und y_range verwenden, um eine lineare Funktion mit der Formel y_range = f (x_range) zu erstellen.

Dieses Beispiel zeigt, wie Sie eine Funktion erstellen, die bereits zwei bekannte X_Range- und Y_Range-Variablen verwendet, um die Datenpunkte einer Zeile mithilfe der Scipy abzuschätzen.interpolieren.Interp1d () Methode. Der Begriff „Interp1d“ bezieht sich auf die Interpolation in einer einzelnen Dimension, z. Der gesamte Code wird hier bereitgestellt.

Der erste Abschnitt des Codes zeigt, dass wir die erforderlichen Module importieren. Dies sind Matplotlib.Pyplot, Numpy, Scipy und Interp1d. Der nächste Abschnitt zeigt die Erzeugung der Zufallspunkte für X_Range und Y_Range sowie die Verwendung dieser beiden Werte x_Range und y_range. Es enthält auch die Ausführung der Skipei.interpolieren.Interp1d () -Methode, bei der die Werte x_Range und y_range als Parameter übergeben werden. Danach werden neue Zufallspunkte für X_Range und Y_Range generiert. Die vier hier verwendeten Druckanweisungen zeigen die von der linearen Funktion generierten Punkte an.

Im letzten Abschnitt des Code wird ein Diagramm unter Verwendung der X_Range, Y_Range und den resultierenden X_RES- und Y_RES -Werten gezeichnet.

Matplotlib importieren.Pyplot als PLT
Numpy importieren
Skipie importieren
von Scipy.Interpolieren importieren 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.interpolieren.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.Streuung (x_Range, y_range, color = 'rot')
PLT.Diagramm (x_res, y_res, color = 'orange')
PLT.xlabel ("x")
PLT.Ylabel ("y")
PLT.Titel ("1-D-Interpolation")
PLT.zeigen()
PLT.SaveFig ('Ergebnis/Graph.png ')

Dies ist der resultierende Bildschirm, auf dem Sie die Implementierung der 1-D-Interpolation auf dem Bildschirm sehen können:

Spline -Interpolation

In diesem Beispiel geht es um die Spline -Interpolation.

In den Bereichen Computer Engineering von computergestützten Modellierung und Computergrafik wird eine stückweise polynomiale (parametrische) Krümmung häufiger als Spline bezeichnet. Aufgrund ihrer Einfachheit in Bezug auf Konstruktion, Einfachheit und Genauigkeit bei der Bewertung und der Fähigkeit, komplexe Formen durch Kurvenanpassung und hoch interaktives Kurvenendesign vorherzusagen, werden häufig Splines in einer Vielzahl von Feldern verwendet.

Die Spline-Interpolation verwendet Polynome, um eine stückweise Funktion zu erstellen, im Gegensatz zu 1D-Interpolation, wo Punkte für eine einzelne Kurve geeignet sind.

Die Univariatespline () -Methode akzeptiert zwei Parameter, XS und YS und generiert eine aufrufbare Funktion, die mit einem neuen Wert für XS aufgerufen werden kann. Siehe den folgenden Code:

Der Code ist dem vorherigen Beispiel sehr ähnlich, außer dass wir hier die verschiedenen Eingabewerte verwenden. Dann der Interpolieren.Die Splev () -Funktion wird für diese Werte verwendet. Für x, y und t werden verschiedene Werte erzeugt. Diese Werte werden auf dem Bildschirm mit einer Codezeile im letzten Abschnitt des beigefügten Bildes aufgezeichnet:

Numpy importieren
Matplotlib importieren.Pyplot als PLT
vom Scipy -Import -Interpolieren
x = numpy.Arange (0, 12)
y = numpy.cos (x ** 3)
t = interpolieren.splrep (x, y, s = 0)
x = numpy.Arange (0, Numpy.pi ** 2, numpy.pi/100)
y = interpolieren.Splev (x, t, der = 0)
PLT.Figur()
PLT.Diagramm (x, y, '*', x, y, x, numpy.cos (x),
x, y, 'b', color = "rot")
PLT.Legende (['linear', 'kubischer Spline', 'wahr'])
PLT.Achse ([-0).2, 5.6, -1.3, 1.2]))
PLT.Titel ('Cubic-Spline Interpolation Beispiel')
PLT.zeigen()

Das Folgende ist die generierte Grafik, die das Konzept der Kubikspline-Interpolation erklärt:

Univariate Spline Interpolation

Wir werden hier über den univariaten Spline sprechen. Es passt zu einem bestimmten Satz von Datenpunkten und ist ein 1-D-Glättungsspline. Die X Val- und Y Val -Eingangsdaten werden unter Verwendung der Scipy bis zu einem K -Grad K -Grad angepasst.interpolieren.Univariatespline. Die Skipie.interpolieren.Die Univariatespline -Methode hat ein weiteres Argument, s, das die Anzahl der Knoten durch Angeben einer Glättungsbedingung festlegt. Der Spline.Setzen Sie die Funktion des Glättungsfaktors () rechnen die Spline mit dem angegebenen Glättungsfaktor und den durch den vorherigen Aufruf identifizierten Knoten.

Numpy importieren
Matplotlib importieren.Pyplot als PLT
von Scipy.Interpolieren Sie die Import univariatespline importieren
x_val = numpy.Linspace (-3, 3, 40)
y_val = numpy.exp (-x_val ** 2) + 0.1 * Numpy.willkürlich.Randn (40)
PLT.Titel ("univariate Spline")
PLT.Plot (x_val, y_val, 'g.', MS = 8)
spline_shape = univariatespline (x_val, y_val)
XS_SHAPE = Numpy.Linspace (-3, 3, 2000)
PLT.Plot (xs_shape, spline_shape (xs_shape), 'gelb', lw = 3)
spline_shape.set_smoothing_factor (0.5)
PLT.Plot (xs_shape, spline_shape (xs_shape), color = 'orange', lw = 3)
PLT.zeigen()

Das Folgende ist die generierte Grafik des vorherigen Code:

RBF -Interpolation (radiale Basisfunktion)

In diesem letzten Beispiel werden wir uns auf die radiale Basisfunktion (RBF) für die Interpolation konzentrieren. Die Interpolat -Scipy.RBF wird zur n-dimensionalen Interpolation von verstreuten Daten verwendet. Nach seiner Definition entspricht die radiale Basisfunktion einem konstanten Referenzdatenpunkt. Die Skipie.interpolieren.Die RBF-Klasse wird verwendet, um die Funktionen direkt von n-D-gestreuten Daten in eine M-D-Domäne unter Verwendung der radialen Basisfunktionen zu interpolieren.

Der folgende beigefügte Screenshot zeigt den vollständigen Code an. Hier importieren wir die RBF- und Numpy -Module. Danach werden die Werte für XS_VAL und YS_VAL mithilfe der Arange () und Numpy erzeugt.SIN () Methoden. Eine Print -Anweisung wird verwendet, um die Nachricht „Hier sehen Sie das Ergebnis“ anzuzeigen. Es wird eine "Res" -Variable erstellt, bei der die RBF -Methode verwendet wird und die generierten XS_VAL und YS_VAL als Parameter übergeben werden. Danach ist ZZ zu sehen, in dem eine Liste von Zahlen für den angegebenen Bereich generiert wird. Schließlich wird das Ergebnis angezeigt.

von Scipy.Import RBF interpolieren
Numpy importieren
XS_VAL = Numpy.Arange (8)
ys_val = xs_val ** 3 + numpy.sin (xs_val) + 2
print ("Hier sehen Sie das Ergebnis:")
res = rbf (xs_val, ys_val)
zz = res (Numpy.Arange (2.1, 3, 0.1)))
Druck (ZZ)

Das Folgende ist die Ausgabe, bei der eine Reihe von Zahlen aus dem vorherigen Code generiert wird, in dem die RBF -Methode verwendet wird.

Abschluss

In diesem Artikel haben wir diskutiert, was das Scipy Interpolar -Konzept ist. Die Grundtypen und die Gesamtdetails werden hier behandelt. Sie können problemlos alle Anforderungen zu diesem Thema mit Programmierbeispielen im Detail finden. Wir diskutierten alle ihre Typen (1-D-Interpolation, Spline-Interpolation, univariate Spline-Interpolation und RBF-Interpolation) mit geeigneten Erklärungen und Beispielen, damit Sie das gesamte Konzept besser verstehen können.