[PYTHON] Erhöhen Sie die Dimension mit np.newaxis und Broadcast-Betrieb

Dies ist ein Artikel, in dem ich mein eigenes Verständnis von der Frage niedergeschrieben habe, was ein 3D-np.array-Bild ist und was np.newaxis ist. Die erste Hälfte des Artikels, der das Image von np.array und die Grundlagen von np.newaxis beschreibt, ist hier. In diesem Artikel werde ich erklären, wie man np.newaxis benutzt. Insbesondere wenn es zwei zweidimensionale Arrays gibt, in denen mehrere zweidimensionale Vektoren angeordnet sind, was erstmals in der ersten Hälfte des Artikels erwähnt wurde, wird das Quadrat des Abstands zwischen den in beiden enthaltenen Vektoren durch Runden berechnet. schauen.

SCHRITT 3. Sendung

Bevor wir uns dem Hauptthema zuwenden, schauen wir uns die Sendung an. Es ist ein Typ, der die Berechnungen zwischen Arrays mit unterschiedlichen Formen durchführt.

>>> x = np.array([1, 2])  #Horizontal 2 vertikal 1 Vektor
>>> A = np.array([[1, 2],
                  [3, 4],
                  [5, 6]])  #Horizontale 2 vertikale 3 Matrix
>>> B = np.array([[1],
                  [2]])  #Horizontale 1 vertikale 2 Matrix
>>> C = np.array([[[1],
                   [2]],

                  [[3],
                   [4]]])  #3D-Array mit 1 horizontalen 2 vertikalen 2 Tiefe

>>> x + A  #Es wird eine Prozession von 2 horizontalen 3
array([[2, 4],
       [4, 6],
       [6, 8]]) 
>>> x + B  #Es wird eine Linie von 2 horizontalen und 2 vertikalen
array([[2, 3],
       [3, 4]])
>>> x + C  #Es wird ein dreidimensionales Array mit 2 horizontalen, 2 vertikalen und 2 Tiefen.
array([[[2, 3],
        [3, 4]],

       [[4, 5],
        [5, 6]]])

SCHRITT 4. Erhöhen Sie die Dimension und führen Sie die Broadcast-Berechnung durch

Zurück zum Hauptthema: Was macht np.newaxis glücklich? Das ist die Geschichte.

Für eindimensionales Array

Wenn Sie sich ein eindimensionales Array als Ausgangspunkt vorstellen, ist es dann möglich, mit np.newaxis "die Round-Robin-Operationsergebnisse jedes Elements von zwei Arrays in einer neuen Achse zu speichern"?

Wenn Sie beispielsweise $ x = [1, 3, 5, 7] $ und $ y = [2, 4, 6] $ haben und eine Round-Robin-Berechnung von $ 4 \ times3 = 12 $ durchführen möchten, verwenden Sie np.newaxis für $ y. Wenn Sie $ in eine Matrix aus vertikal 3 horizontal 1 konvertieren und dann $ x $ berechnen, können Sie durch Senden eine Matrix aus vertikal 3 horizontal 4 erhalten.

>>> x = np.array([1, 3, 5, 7])
>>> y = np.array([2, 4, 6])
>>> x[np.newaxis, :] + y[:, np.newaxis]  #Fügen Sie hinzu, indem Sie die Elemente von x und y runden
array([[  3,  5,  7,  9],
       [  5,  7,  9, 11],
       [  7,  9, 11, 13]])
# x + y[:, np.newaxis]Aber das gleiche

Für zweidimensionales Array

Aber was ist mit zwei Dimensionen? Angenommen, Sie haben zwei vertikal angeordnete horizontale Vektoren mit derselben Dimension (hier zwei Dimensionen), wie unten gezeigt.

>>> A = np.array([[1, 2],
                  [3, 4],
                  [5, 6]])
>>> B = np.array([[1, 1],
                  [2, 2]])

Wenn Sie zu diesem Zeitpunkt np.newaxis gut einführen, können Sie für jede Komponente des Vektors eine Round-Robin-Operation ausführen. Ein Bild der mehrmaligen gleichzeitigen Durchführung einer Round-Robin-Operation eines eindimensionalen Arrays ($ x $ -Komponente und $ y $ -Komponente oben).

>>> A[np.newaxis, :, :] - B[:, np.newaxis, :]  #Round-Robin-Subtraktion von x- und y-Komponenten
array([[[ 0, 1],
        [ 2, 3],
        [ 4, 5]],

      [[[-1, 0],
        [ 1, 2],
        [ 3, 4]]])
# A - B[:, np.newaxis, :]Aber das gleiche

Wenn Sie es so anordnen, dass es ordnungsgemäß gesendet wird, können Sie den gleichen Wert erhalten, auch wenn Sie die Art der Aufnahme einer neuen Achse ändern.

>>> A.T[np.newaxis, :, :] - B[:, :, np.newaxis]  #Round-Robin-Subtraktion von x- und y-Komponenten
array([[[ 0, 2, 4],
        [ 1, 3, 5]],

      [[[-1, 1, 3],
        [ 0, 2, 4]]])
# A.T - B[:, :, np.newaxis]Aber das gleiche

Hauptthema

Wenn das obige Paar zweidimensionaler Vektoren $ A $ und $ B $ gegeben ist, runden wir (Abstand zwischen den Vektoren) $ ^ 2 $ auf. Das Quadrat des Abstands zwischen $ (a_x, a_y) $ und $ (b_x, b_y) $ ist $ (a_x-b_x) ^ 2 + (a_y-b_y) ^ 2 $, also zuerst die $ x $ -Komponenten, die $ y $ -Komponenten Alles, was Sie tun müssen, ist, die Quadrate der Subtraktionen untereinander abzurunden, und das ist genau das Quadrat der Berechnung, die Sie oben durchgeführt haben. Addieren Sie danach das Quadrat der Differenz der $ x $ -Komponente und das Quadrat der Differenz der $ y $ -Komponente = Summe mit der dritten Achse, die nicht zu $ A $ oder $ B $ als neue Achse hinzugefügt wird. (Es ist leichter zu verstehen, wenn Sie es sich mit einem Bild vorstellen).

>>> ((A.T[np.newaxis, :, :] - B[:, :, np.newaxis])**2).sum(axis=1)
array([[ 1, 13, 41],
       [ 1,  5, 25]])
# ((A.T - B[:, :, np.newaxis])**2).sum(axis=1)Vielleicht

Dies entspricht der Formel aus "Essence of Machine Learning" zu Beginn von Last time. Wie wir oben gesehen haben, ist die Position der neuen Achse, die Sie zu $ A $ oder $ B $ hinzufügen, nicht eindeutig, und Sie können das gleiche Ergebnis erzielen, indem Sie folgende Schritte ausführen:

>>> ((A[np.newaxis, :, :] - B[:, np.newaxis, :])**2).sum(axis=2)
array([[ 1, 13, 41],
       [ 1,  5, 25]])
# ((A - B[:, np.newaxis, :])**2).sum(axis=2)Aber ok

>>> ((A.T[:, np.newaxis, :] - B.T[:, :, np.newaxis])**2).sum(axis=0)
array([[ 1, 13, 41],
       [ 1,  5, 25]])

Um den Abstand zwischen Vektoren zu ermitteln, ziehen Sie die Quadratwurzel.