[PYTHON] Mein umgekehrtes Numpy / Scipy-Memo
Reverse Numpy Memo
Es ist hässlich. Ich glaube nicht, dass es dir gefallen wird, bis du dich daran gewöhnt hast. Aber ich werde nicht verlieren. Eh, num, ich möchte dir meine Python zeigen, während sich numpy bewegt. ** * Ich denke, dieser Artikel wird nach und nach überarbeitet. ** ** **
Meine Nebensprache
Das Folgende ist ein Schreibstil, den ich selten in Kommentarartikeln sehe: Ich werde es in diesem Artikel verwenden, weil es für mich fast eine Redewendung ist.
#Machen Sie etwas basierend auf der Gramm-Matrix
# *Ist eine Änderung, um es zu erweitern, wenn es in eine Funktion eingefügt wird
fuga = hoge(*np.meshgrid(x, y))
#Nehmen Sie den Reifen auf der x-Achse der Matrix A heraus
#So etwas wie eine Karte. Aus irgendeinem Grund verwendet jeder die for-Anweisung, aber ist es nicht einfacher zu verstehen, ob numpy wie ein Funktionstyp geschrieben ist?
fuga = np.apply_along_axis(hoge, x, A)
#Es ist eine Redewendung oder normalerweise ein Punktprodukt.
#Warum nicht jeder dieses np benutzen.Ist es nur Punkte? Es ist schön, klar zu schreiben, aber ...
hoge @ fuga
Mach ich
Ich dachte, ich brauche diesen Bereich nicht, aber ich bin überrascht, dass ich gegoogelt habe.
np.eye(5)
Machen Sie einfach eine Gleichheitssequenz
Gleiche Differenzzahlserie mit einer Differenz von 1 von 0 bis 100.
np.arange(0, 100, 1)
Der letzte Wert wird jedoch auf 1 gesetzt, wenn Sie schweigen.
np.arange(100)
Und. Nun, es ist einfach.
Umgekehrte Reihenfolge
np.flip
Verknüpfen
Diejenige, die parallel oder vertikal verbunden ist, ist np.vstack Diejenige, die in Reihe oder horizontal np.hstack verbindet Diese Funktion ist jedoch nicht np.vstack (hoge, fuga) Verwenden Sie es wie np.vstack ((hoge, fuga)). Es gibt auch np.concatenate.
Machen Sie eine Gramm-Matrix
Machen Sie normalerweise eine Gramm-Matrix. In einem solchen Fall ist Meshgrid gut. … Aber Meshgrid selbst bringt mich dazu, es Numpy Art zu nennen Bin ich der einzige, der viel schriftlich kann?
xg, yg = np.meshgrid(x, y)
gram = xg * yg
Sie können aber auch so schreiben. In diesem Fall in dem Sinne, dass es der folgenden Kernel-Methode sehr ähnlich ist. Ich mag dieses, weil es leicht zu verstehen ist. (Die Kernel-Methode ist ein verallgemeinertes inneres Produkt, nicht wahr?)
from operator import mul
gram = mul(*np.meshgrid(x, y))
Kernel-Methode
Vorerst habe ich es mit dem Gaußschen Kernel geschrieben. Alles was Sie tun müssen, ist das Mul in der obigen Gramm-Matrix durch den Kernel zu ersetzen.
def kernel(a: np.ndarray, b: np.ndarray, v: float) -> np.ndarray:
return np.exp(- v * np.square(a - b))
gram = kernel(*np.meshgrid(x, x))
Mit quadratischer Regularisierung
lmd = 0.1 #geeignet
gram = kernel(*np.meshgrid(x, x)) + lmd * np.eye(x.shape[0])
Damit habe ich spielerisch Kernel Return Golf geschrieben.
def solve_kernel(x: np.ndarray, y: np.ndarray,
kernel: Callable, lmd: float) -> np.ndarray:
K = kernel(*np.meshgrid(x, x)) + lmd * np.eye(x.shape[0])
alpha = np.linalg.solve(K, y)
return np.vectorize(lambda xs: np.sum(alpha * kernel(x, xs)))
Die Kernel-Regression kann in nur 4 Zeilen geschrieben werden, auch wenn PEP8 geschützt ist. Numpy ist großartig ...
Versuchen Sie, ein bergähnliches Ding in drei Dimensionen herzustellen
Machen wir einen Gaußschen Berg mit 100 Zeilen und 100 Spalten. Sie können hierfür auch meshgrid verwenden. Es ist traurig, dass es ein bisschen schwarze Magie ist, aber es ist keine große Sache.
def mount(x: int, y: int) -> np.ndarray:
return np.exp(-(np.square(x) + np.square(y)) / 1000)
x_y = 100, 100
g = mount(*np.meshgrid(*(np.arange(-n/2, n/2, 1) for n in x_y)))
Warum hast du das gemacht? Dies ist die, die ich für das Clustering-Experiment geschrieben habe. Die Kombination aus Meshgrid und * kann golden sein oder wegen Verstoßes gegen Codierungskonventionen geschlagen werden.
Wenn Sie keine Aussagen mögen
Es gibt mehrere Möglichkeiten. Nun, Karte und so weiter sind neu, also ist es okay.
Verwenden Sie universelle Funktionen
Sie können eine universelle Funktion erstellen, eine Funktion, die sich wie Numpy verhält. Es gibt also eine Möglichkeit, sie zu verwenden.
A = [[2, 4, 8], [1, 1, 1]]
def test(x):
return x * 2
np.vectorize(test)(A)
>array([[4, 8, 16], [2, 2, 2]])
Übrigens kann es auch als Dekorateur verwendet werden, aber ich weiß nicht, ob es im Sinne von Codierungskonventionen erlaubt ist. Es scheint, dass es verschiedene Dinge gibt, wie zum Beispiel, dass die Anzahl der Argumente nur eine Zahl sein muss, um eine ordnungsgemäße Funktion zu werden.
Verwenden Sie np.apply_along_axis
Diese Methode ist durchaus anwendbar, da Sie die Achse angeben können. Außerdem sagt der Beamte, es sei schnell. Ich weiß nicht, was schneller ist, vektorisieren.
#Auf die gleiche Weise wie oben
np.apply_along_axis(test, 0, A)
Es scheint, dass es einige Maßbeschränkungen gibt, um sich richtig zu bewegen. Es gibt mehrere andere Funktionen. https://numpy.org/devdocs/reference/routines.functional.html
Löse simultane Gleichungen (wenn sie gelöst werden können)
Gewöhnliche simultane Gleichungen. Zum Beispiel:
X = np.linalg.solve(A, Y)
In diesem Fall war die unbekannte Nummer die Variable X. In der Praxis möchten Sie jedoch die Konstante A meistens aus dem gemessenen Wert X kennen. Daher befinden sich A und X hier bei der Methode der kleinsten Quadrate in entgegengesetzten Positionen. Es scheint besser, diese Funktion zu verwenden, ohne die inverse Matrix explizit auszugeben.
Lösen Sie die Methode der kleinsten Quadrate (wenn es keine Lösung gibt)
Für Muster, bei denen es keine Lösung gibt, wird die Methode der kleinsten Quadrate verwendet. "Es gibt keine Lösung" lautet beispielsweise wie folgt.
Es gibt keine Lösung, da diese simultanen Gleichungen einander widersprechen. Da die Lösung der Methode der kleinsten Quadrate die folgende Gleichung ist
A = np.linalg.solve(X.T @ X, X.T @ Y)
Sie können auch eine pseudo-inverse Matrix verwenden.
A = pinv(x) @ y
Da es jedoch bereits eine ordnungsgemäße Funktion gibt, ist das Folgende die richtige Antwort anstelle der obigen.
A = np.linalg.lstsq(X, Y)[0]
Minimum-Square-Methode mit Regularisierung
Ich bin mir nicht sicher, was ich mit Regularisierung anfangen soll.
Ich habe gegoogelt, aber ich konnte die richtige Antwort nicht finden, also frage ich mich, ob ich sie selbst schreiben sollte.
lmd = 1
seisoku = lmd * np.eye(min(X.shape))
A = np.linalg.solve(X.T @ X + seisoku , X.T @ Y)
Löse die kleinste Normlösung (wenn die Lösung unendlich ist)
In einem solchen Fall ist die Lösung unendlich.
A = X.T @ np.linalg.inv(X @ X.T) @ Y
Ist es nicht? Die inverse Matrix von Moore Penrose ist jedoch erstaunlich, so dass ich normal gehen kann.
A = pinv(X) @ Y
Die richtige Antwort lautet jedoch wie folgt.
A = np.linalg.lstsq(X, Y)[0]
Diese Funktion ist erstaunlich.
Minimum-Square-Methode mit Regularisierung (wenn die Lösung unendlich ist)
Ich weiß auch nicht, wie ich das angreifen soll. Die Formel ist jedoch einfach zu erstellen.
lmd = 1
seisoku = lmd * np.eye(min(X.shape))
A = X.T @ np.linalg.inv(X @ X.T + seisoku) @ Y
Hmm ... (･ ั ω ･ ั) Ist es mein Mangel an Studium, den ich bei der Regularisierung nicht finden konnte? Es ist okay, weil es nicht zu schwierig ist ...
Andere verschiedene Optimierungsprobleme
https://docs.scipy.org/doc/scipy/reference/optimize.html#module-scipy.optimize
Mach es schneller
Operatoren wie `**` sind relativ langsam. Sie sollten nicht `` `e ** hoge``` machen, es ist schneller, np.exp zu verwenden.
Das war bei dem von mir geschriebenen Wavelet-Konvertierungspaket der Fall. (Also ist es nicht lesbar ...)
hoge = np.arange(1000)
e ** hoge #langsam
np.exp(hoge) #schnell
hoge ** 2 #langsam
np.square(hoge) #schnell
hoge ** (0.5) #langsam
np.sqart(hoge) #schnell
hoge ** (3) #langsam
np.power(hoge, 3) #schnell
hoge ** (3.4) #langsam
np.float_power(hoge, 3.4) #schnell
Daneben gibt es verschiedene Dinge wie np.power, aber es ist schneller, grundlegende und optimierte Funktionen zu verwenden.
Matrix Produkt
Ich bin mir nicht sicher, warum nicht jeder den @ -Operator verwendet. Ich denke, es ist einfacher zu lesen als np.dot ... Bist du spät?
np.arange(10)[email protected](10)
Komplexe Nummer bezogen
Komplexes Konjugat
np.conj
Realachse imaginäre Achse bezogen
hoge.real, hoge.imag Sie können so schreiben, wenn Sie dieses ersetzen
fuga.real, fuga.imag = hoge.real, hoge.imag
Der Grund, warum ich dies möchte, ist, dass es überraschend ist, dass einige Verarbeitungen nur auf der imaginären Achse und nur auf der realen Achse durchgeführt werden.
Fourier-Transformation
Ich denke, dass die Fourier-Transformation oft scipy verwendet. Es ist auch in numpy.
scipy.fftpack.fft(wave)
Inverse Umwandlung
comp #Es sei eine komplexe Zahlenmatrix nach der Fourier-Transformation
scipy.fftpack.ifft(comp)
Cupy verwandt
In Cupy umwandeln
cp.asarray(numpy_array)
In numpy konvertieren
cp.asnumpy(cupy_array)
Es gibt einige Unterschiede zwischen Cupy selbst und Numpy, seien Sie also vorsichtig.
Geteilter Fall
Verwenden Sie np.where. Wenn x mit dem bedingten Ausdruck übereinstimmt, wird das zweite Argument ausgegeben, und wenn nicht, wird das dritte Argument ausgegeben.
x = np.arange(10)
np.where(x > 5, x * 10, x)
> array([0, 1, 2, 3, 4, 5, 60, 70, 80, 90])
Bedingte Anweisung im Zusammenhang
Wenn der bedingte Ausdruck eingefügt wird, verhält er sich wie R.
x = np.arange(10)
x > 5
> array([False, False, False, False, False, False, True, True, True, True])
Mathematik
np.det(hoge) #Matrixformel
np.norm(hoge) #Norm
Mit Null füllen
hoge ist ein Array Als nächstes müssen Sie den 3. und früheren sowie den 5. Übergang ausfüllen. Konstante bedeutet, mit Konstanten zu füllen. Die letzte ist die Konstante, die mit links und rechts gefüllt werden muss. Es gibt verschiedene andere Modi.
np.pad(hoge, [3, 5], 'constant' ,[0, 0])
Bild hohl
Versuchen Sie, nur das Teil mit einem großen Wert auszuhöhlen. Erstellen Sie wie zuvor ein Array von True und False und hohlen Sie es mit einem bedingten Ausdruck aus. In diesem Beispiel wird nach dem Erstellen eines Berges mit Numpy die Spitze des Berges abgeschnitten. Zu diesem Zeitpunkt wird möglicherweise np.nan benötigt. Dies liegt daran, dass nan durch Imshow von Matplotlib ignoriert wird.
def mount(x: int, y: int) -> np.ndarray:
return np.exp(-(np.square(x) + np.square(y)) / 1000)
#Eine Funktion zum Aushöhlen.
#Eine Matrix, in der Werte eine gewöhnliche Matrix und Cluster eine Bool sind
def make_single_cluster(values, cluster):
img = np.nan * np.zeros_like(values)
img[cluster] = tvalues[cluster]
return img
x_y = 100, 100
#Diesmal habe ich versucht, ein wenig Lärm hinzuzufügen
X = np.random.rand(*x_y) / 100
#Mach einen Berg
X += mount(*np.meshgrid(*(np.arange(-n/2, n/2, 1) for n in x_y)))
plt.imshow(make_single_cluster(X, X > 0.5))
plt.show()
Matlab lesen / schreiben
scipy hat eine Matlab-Lese- / Schreibfunktion.
import scipy.io as sio
sio.loadmat('hoge.mat')
data = {'fuga', np.arange(100)}
sio.savemat(fuga.mat, data)
Leider habe ich Matlab noch nie benutzt, daher bin ich mir nicht sicher.
Integration
Das ist auch lückenhaft Das ist magisch.
from scipy.integrate import quad
def test(x):
return x ** 2 - x
print(quad, test, -5, 5)
Eine andere Sache ist, zweimal zu integrieren. Es ist dblquad
Spezialfunktion
Du magst übrigens Mathematik, oder? Schauen Sie sich diesen Link an. https://docs.scipy.org/doc/scipy/reference/special.html#module-scipy.special
Recommended Posts