Mit scipy.interpolieren.interpn zur Interpolation in einem N-Dimensionalen array

Angenommen ich habe Daten, die hängt auf 4 Variablen: a, b, c und d.... Ich will interpolieren, um wieder eine 2D-array zurück, das entspricht einem einzelnen Wert von a und b, und ein array von Werten für c und d.... Aber Die array-Größe muss nicht gleich sein. Um genau zu sein, meine Daten stammen aus einem transistor-simulation. Der Strom hängt von 4 Variablen, die hier. Ich möchte zum Plotten eine parametrische variation. Die Anzahl der Punkte auf den parameter ist viel weniger als die Anzahl der Punkte für die horizontale Achse. 

import numpy as np
from scipy.interpolate import interpn
arr = np.random.random((4,4,4,4))
x1 = np.array([0, 1, 2, 3])
x2 = np.array([0, 10, 20, 30])
x3 = np.array([0, 10, 20, 30])
x4 = np.array([0, .1, .2, .30])
points = (x1, x2, x3, x4)

Folgende Werke:

xi = (0.1, 9, np.transpose(np.linspace(0, 30, 4)), np.linspace(0, 0.3, 4))
result = interpn(points, arr, xi)

und so tut dieses:

xi = (0.1, 9, 24, np.linspace(0, 0.3, 4))
result = interpn(points, arr, xi)

aber nicht dieses:

xi = (0.1, 9, np.transpose(np.linspace(0, 30, 3)), np.linspace(0, 0.3, 4))
result = interpn(points, arr, xi)

Wie Sie sehen können, im letzten Fall ist die Größe der letzten beiden arrays in xi ist anders. Ist diese Art von Funktionalität nicht unterstützt, die von scipy oder bin ich mit interpn falsch? Ich brauche diese erstellen Sie einen plot, wo eine der xi's ist ein parameter, während die andere ist die horizontale Achse.

  • Sieht aus wie Sie sind nicht mit interpn richtig... ich gehe davon aus, dass points stellt Ihr Stromnetz, d.h., die "sampling points", die in jeder Ihrer vier Dimensionen für die Werte, die Sie kennen. arr hält diese bekannten Werte. Aber zufällig heißt, es ist hart zu überprüfen, ob oder nicht die interpolation arbeitet. Versuchen Sie, Sie alle gleich sind, stattdessen, oder noch besser, linear in jedem der vier Dimensionen. xi sollten die Koordinaten der Punkte, an denen Sie wollen, um zu wissen, die Werte von arr. xi sollte ein array mit k Zeilen, für die k Punkte, und 4 Spalten (4D-Daten).
  • Dank Praveen! Meine Frage jedoch ist folgende. Angenommen ich habe Daten, die hängt auf 4 Variablen: a, b, c, d.... Ich will interpolieren, um wieder eine 2D-array zurück, das entspricht einem einzelnen Wert von a und b, und ein array von Werten für c und d.... Aber Die array-Größe muss nicht gleich sein. Um genau zu sein, meine Daten stammen aus einem transistor-simulation. Der Strom hängt von 4 Variablen, die hier. Ich möchte zum Plotten eine parametrische variation. Die Anzahl der Punkte auf den parameter ist viel weniger als die Anzahl der Punkte für die horizontale Achse.
  • Beim nächsten mal einfach Bearbeiten Sie Ihre Frage direkt, anstelle der Zugabe eine Menge von Informationen in einem Kommentar
  • By the way, beachten Sie, dass np.transpose(np.linspace(0, 30, 3)) macht es nicht zu einem Spalten-Vektor. Lesen Sie über die 1D-arrays in numpy. Sie müssen sich vorstellen, eine neue dimension, so verwenden Sie np.linspace(0, 30, 3)[:, np.newaxis] statt. Aber in diesem Fall, Sie brauchen nicht dieses, wie ich in meiner Antwort.
  • Ugh der transpose war ein Fehler. Ich war Einmischung, um mit dem code, um zu sehen, was funktionieren würde und es schlich sich in diesem post. Sorry!
InformationsquelleAutor Ashwith Rego | 2016-09-05
  1. 9

    Werde ich versuchen zu erklären, dies für Sie in 2D, so dass Sie eine bessere Vorstellung davon bekommen, was passiert. Zuerst erstellen wir ein linear-array zu testen.

    import numpy as np

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm

# Set up grid and array of values
x1 = np.arange(10)
x2 = np.arange(10)
arr = x1 + x2[:, np.newaxis]

# Set up grid for plotting
X, Y = np.meshgrid(x1, x2)

# Plot the values as a surface plot to depict
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(X, Y, arr, rstride=1, cstride=1, cmap=cm.jet,
                       linewidth=0, alpha=0.8)
fig.colorbar(surf, shrink=0.5, aspect=5)

    Diese uns gibt:
    Mit scipy.interpolieren.interpn zur Interpolation in einem N-Dimensionalen array

    Dann, sagen wir, Sie möchten zu interpolieren entlang einer Linie, d.h., einen Punkt entlang der ersten dimension, aber alle Punkte entlang der zweiten dimension. Diese Punkte werden nicht in den original-arrays (x1, x2) offensichtlich. Nehmen wir an, wir wollen zu interpolieren, um einen Punkt x1 = 3.5, die zwischen zwei Punkte auf der x1-Achse.

    from scipy.interpolate import interpn

interp_x = 3.5           # Only one value on the x1-axis
interp_y = np.arange(10) # A range of values on the x2-axis

# Note the following two lines that are used to set up the
# interpolation points as a 10x2 array!
interp_mesh = np.array(np.meshgrid(interp_x, interp_y))
interp_points = np.rollaxis(interp_mesh, 0, 3).reshape((10, 2))

# Perform the interpolation
interp_arr = interpn((x1, x2), arr, interp_points)

# Plot the result
ax.scatter(interp_x * np.ones(interp_y.shape), interp_y, interp_arr, s=20,
           c='k', depthshade=False)
plt.xlabel('x1')
plt.ylabel('x2')

plt.show()

    Dies gibt Ihnen das Ergebnis wie gewünscht: beachten Sie, dass die schwarzen Punkte richtig liegen auf der Ebene, bei einem x1 den Wert 3.5.
    Mit scipy.interpolieren.interpn zur Interpolation in einem N-Dimensionalen array

    Beachten Sie, dass die meisten der "Magie", und die Antwort auf deine Frage liegt in diesen zwei Zeilen:

    interp_mesh = np.array(np.meshgrid(interp_x, interp_y))
interp_points = np.rollaxis(interp_mesh, 0, 3).reshape((10, 2))

    Ich erklärt haben, die arbeiten dieser anderswo. Kurz gesagt, was es tut, ist, erstellen Sie ein array der Größe 10x2, enthält die Koordinaten der 10 Punkte, die Sie wollen, zu interpolieren arr an. (Der einzige Unterschied zwischen diesem post und diese ist, dass ich geschrieben habe, dass die Erklärung für np.mgrid, die eine Verknüpfung zu schreiben np.meshgrid für eine Reihe von aranges).

    Für Ihre 4x4x4x4 Fall, werden Sie wahrscheinlich benötigen, so etwas wie dieses:

    interp_mesh = np.meshgrid([0.1], [9], np.linspace(0, 30, 3),
                          np.linspace(0, 0.3, 4))
interp_points = np.rollaxis(interp_mesh, 0, 5)
interp_points = interp_points.reshape((interp_mesh.size // 4, 4))
result = interpn(points, arr, interp_points)

    Hoffe, das hilft!

    • Ich denke, über diese für eine Weile. Tolle Antwort.
    • Praveen, ich danke Ihnen so sehr für Ihre Hilfe. Wir entschuldigen uns für die nicht mehr reagiert bevor. Ich habe Zeit, um wieder zu diesem Projekt erst jetzt. Was Sie erklärt, Werke und deine Erklärung war sehr schön.
    • Ich will hinzufügen, dass ich habe müssen einen weiteren Schritt nach dieser zu bekommen, was ich brauchte - ich brauchte, um umzugestalten das Ergebnis, da zum Beispiel in meiner Frage, ich erwarte ein 2-D array, im Allgemeinen habe ich zurückgeben müssen
    • Ich will hinzufügen, dass ich habe müssen einen weiteren Schritt nach dieser zu bekommen, was ich brauchte - ich brauchte, um umzugestalten das Ergebnis, da zum Beispiel in meiner Frage, ich erwarte ein 2-D array, im Allgemeinen muss ich return np.Umformen(result, len(interp_x1), len(interp_x2), len(interp_x3), len(interp_x4))
    InformationsquelleAutor Praveen
Schreibe einen Kommentar