3D-Interpolation in Python

1. Bedeutung der Interpolation
2. Installieren Sie SciPy für die Interpolation in Python
3. Verwenden Sie die interpn()-Methode von SciPy für die 3D-Interpolation in Python
4. Verwenden Sie RegularGridInterpolator für die 3D-Interpolation in Python
5. Abschluss

Interpolation ist die Methode zum Konstruieren neuer Datenpunkte innerhalb eines definierten Bereichs eines diskreten Satzes. Interpolation bedeutet, Werte zwischen Punkten oder Kurven zu finden.

Aus mathematischer Sicht erhält man durch Interpolation den Wert bestimmter unbekannter Datenpunkte, die sich zwischen anderen bekannten Datenpunkten befinden.

Bedeutung der Interpolation

Interpolation ist ein leistungsstarkes Werkzeug für Vorhersagen, Datenanalysen und viele andere Anwendungen. Es prognostiziert unbekannte Werte für geografisch bezogene Daten wie Geräuschpegel, Niederschlag, Höhe usw.

Interpolation hat viele Verwendungen. Beim maschinellen Lernen (ML) haben wir es oft mit fehlenden Daten in einem Datensatz zu tun, und diese Werte werden oft durch Interpolation ersetzt.

Installieren Sie SciPy für die Interpolation in Python

Um die Interpolation in Python zu verwenden, müssen wir die SciPy-Kernbibliothek und insbesondere das Modul interpolation verwenden.

SciPy bietet viele wertvolle Funktionen zur mathematischen Verarbeitung und Optimierung der Datenanalyse. Es bietet nützliche Funktionen zum Erhalten einer eindimensionalen, zweidimensionalen und dreidimensionalen Interpolation.

Wir müssen wissen, wie die SciPy-Bibliothek in Python installiert wird, um voranzukommen.

Um SciPy zu installieren, gehen Sie zu Ihrer Befehlszeilenschnittstelle und geben Sie den folgenden Befehl ein.

pip install scipy

Nach erfolgreicher Installation können wir es mit dem Schlüsselwort import in unser Python-Programm importieren.

Verwenden Sie die interpn()-Methode von SciPy für die 3D-Interpolation in Python

Wir können eine 3D-Interpolation mit der Methode interpn() der SciPy-Bibliothek durchführen. Das bedeutet, dass wir mit Hilfe dieser Methode drei oder höhere Dimensionen finden können.

Syntax der Funktion interpn():

scipy.interpolate.interpn(
    points, values, xi, method="linear", bounds_error=True, fill_value=nan
)

Parameter der Funktion interpn():

1. points: Tupel von ndarray von float, mit Formen (m1, ),…,(mn, ).

   Durch diese Punkte wird ein regelmässiges Gitter in n Dimensionen definiert. Die Punkte in jeder Dimension (d. h. jedes Element des Punktetupels) müssen streng aufsteigend oder absteigend sein.

2. Werte: Array-artig, Form (m1,…,mn,…).

   Die Daten befinden sich auf dem regulären Gitter in n Dimensionen. Komplexe Daten können akzeptabel sein.

3. xi : ndarray der Form (…,ndim).

   Hier befinden sich die Koordinaten zum Abtasten der gerasterten Daten.

4. Methode: str, optional

   Die Interpolationsmethoden sind linear, nearest und splinef2d. splinef2d wird nur für 2D-Daten unterstützt.

5. bounds_error: bool, optional

Wenn es wahr ist, wird ein `ValueError` ausgelöst, wenn interpolierte Werte von außerhalb des Bereichs der Eingabedaten angefordert werden. Wenn es falsch ist, wird `fill_value` verwendet.

6. fill_value: Zahl, optional

Wenn wir eine Zahl angeben, kann die Funktion Punkte außerhalb des Interpolationsbereichs verwenden; bei None werden die Werte ausserhalb der Domäne extrapoliert. Die Extrapolation wird von der Methode splinef2d nicht unterstützt.

Die Methode interpn() gibt values_x: ndarray, shape xi.shape[:-1] + values.shape[ndim:] zurück. Das interpolierte values.ndarray ist ein mehrdimensionaler Container, in dem die Formlänge jeder Dimension und ndim die Anzahl der Dimensionen ist.

Jetzt haben wir die Funktion interpn() und ihre Parameter verstanden. Lassen Sie uns ein praktisches Beispiel dafür geben.

In diesem Beispiel übergeben wir drei Argumente an die Methode interpn().

Beispielcode:

# import libraries
from scipy.interpolate import interpn
import numpy as np

# define a function to get the value


def v_function_3d(x, y, z):
    return 3 * x + 4 * y - z


# the np.linspace() function returns the interval between the given numbers.
x = np.linspace(0, 4, 5)
y = np.linspace(0, 5, 6)
z = np.linspace(0, 6, 7)

# in three dimensions, a point's coordinates are treated collectively as a single object.
points = (x, y, z)

# meshgrid, it changes NumPy arrays into coordinate matrices or grids of values
values = v_function_3d(*np.meshgrid(*points, indexing="ij"))

# coordinates to sample the gridded data are
point = np.array([2.21, 3.12, 1.15])

# evaluate the 3d interpolating function at a point
print(interpn(points, values, point))

Ausgang:

[17.96]

Verwenden Sie RegularGridInterpolator für die 3D-Interpolation in Python

Die Interpolation auf einem regelmäßigen oder geradlinigen Gitter in beliebig vielen Dimensionen erfolgt mit der Klasse RegularGridInterpolator.

Zum Definieren der Daten ist ein geradliniges Gitter oder ein rechteckiges Gitter mit regelmäßigen oder ungleichmäßigen Abständen erforderlich. Es unterstützt lineare, Nächste-Nachbar- und Spline-Interpolationen.

Wir können eine Interpolationsmethode auswählen, nachdem wir das Interpolatorobjekt eingerichtet haben.

Wir verwenden RegularGridInterpolator, wenn wir die umliegenden Gitterpunkte linear interpolieren, um zu interpolieren. Eingabedaten in regelmäßigen Abständen.

Das folgende Beispiel erklärt die Verwendung von RegularGridInterpolator für die Interpolation.

# import libraries
import scipy.interpolate as reg_grid
import numpy as np

# define a function to get value


def v_function_3d(x, y, z):
    return 2 * x + 3 * y - z


# define an interpolating function
RGI = reg_grid.RegularGridInterpolator

# arrays constituting the 3d grid
x = np.linspace(0, 50, 50)
y = np.linspace(0, 50, 50)
z = np.linspace(0, 50, 50)

# in three dimensions, a point is a number (coordinates) that are treated collectively as a single object.
points = (x, y, z)

# meshgrid, it changes NumPy arrays into coordinate matrices or grids of values
vals = v_function_3d(*np.meshgrid(*points, indexing="ij"))

# make the interpolator
rgi = RGI(points, values=vals)
pnt = (2.5, 3.5, 1.5)
print(rgi(pnt))

Ausgang:

13.999999999999998

Abschluss

Wir können die 3D-Interpolation in Python mit Hilfe der scipy-Bibliothek und ihrer Methode interpn() oder RegularGridInterpolator verwenden. Wir können leicht Vorhersagen, Datenanalysen und viele andere Anwendungen machen.

Die Interpolation hilft Benutzern festzustellen, welche Daten außerhalb der gesammelten Daten vorhanden sein könnten.