Beim letzten Mal habe ich gesehen, dass Covektoren verwendet werden können, um mehrere Funktionen zu kombinieren, die Skalare zurückgeben. Dieses Mal wird die Funktion, die einen Vektor zurückgibt, durch eine Matrix dargestellt. [Dual Vector Space](https://ja.wikipedia.org/wiki/%E5%8F%8C%E5%AF%BE%E3%83%99%E3%82%AF%E3%83%88%E3 Der Zweck besteht darin, das Bild von% 83% AB% E7% A9% BA% E9% 96% 93) zu vermitteln. Python wird als Programmiersprache zum Vergleich verwendet, und das Ergebnis von NumPy wird der Berechnung beigefügt.

Dies ist eine Reihe von Artikeln.

Internes Produkt, das nach Schätzung zu denken ist
Covector, um mit Funktion zu denken
Matrix nach Funktion betrachtet ← Dieser Artikel
Dualität in der Funktion
Perceptron Thinking in Covector

Covector-Funktion

Ich werde den Covector erneut veröffentlichen, der den Wert zurückgibt, der aus den drei zuletzt eingeführten Argumenten angegeben wurde.

Im Folgenden wird "Import" weggelassen.

>>> from numpy import *
>>> GetX = [1, 0, 0]
>>> GetY = [0, 1, 0]
>>> GetZ = [0, 0, 1]
>>> dot(GetX, [1, 2, 3])
1
>>> dot(GetY, [1, 2, 3])
2
>>> dot(GetZ, [1, 2, 3])
3

\begin{align}
GetX
&\left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
=\left(\begin{matrix}1 &  0 &  0\end{matrix}\right)
 \left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
=1 \\
GetY
&\left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
=\left(\begin{matrix}0 &  1 &  0\end{matrix}\right)
 \left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
=2 \\
GetZ
&\left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
=\left(\begin{matrix}0 &  0 &  1\end{matrix}\right)
 \left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
=3
\end{align}

Viele zu einem

Beim letzten Mal habe ich gesehen, dass Sie dasselbe Argument an mehrere Funktionen übergeben können. Ich werde es mit der vorherigen Funktion versuchen.

>>> dot([GetX,GetY,GetZ],[1,2,3])
array([1, 2, 3])

\begin{align}
\left(\begin{matrix}GetX \\ GetY \\ GetZ\end{matrix}\right)
\left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
&=\left(\begin{array}{r}
    GetX \left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right) \\
    GetY \left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right) \\
    GetZ \left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
  \end{array}\right) \\
&=\left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
\end{align}

Wenn Sie den gesamten Rückgabewert als einen einzelnen Vektor betrachten, werden Sie feststellen, dass die Argumente so zurückgegeben werden, wie sie sind. Dies ist ein natürliches Ergebnis, da die aus Covektoren bestehende Matrix zu einer Einheitsmatrix wird.

\left(\begin{matrix}GetX \\ GetY \\ GetZ\end{matrix}\right)
=\left(\begin{matrix}1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{matrix}\right)

Funktion nach Matrix

Wenn Sie sich das vorherige Beispiel als ein Ergebnis einer Funktion vorstellen, können Sie sich die aus Covektoren bestehende Matrix als eine Funktion vorstellen.

>>> Id=[GetX,GetY,GetZ]
>>> dot(Id,[1,2,3])
array([1, 2, 3])

Id
 \left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
=\left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)

Sie können auch eine Funktion zum Wechseln erstellen, indem Sie die Anordnung verschieben.

>>> Rotate=[GetY,GetZ,GetX]
>>> dot(Rotate,[1,2,3])
array([2, 3, 1])

Rotate
 \left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
=\left(\begin{matrix}2 \\ 3 \\ 1\end{matrix}\right)

Auf diese Weise können Sie sich eine Matrix als Funktion vorstellen und sie nach Bedarf in Covektoren unterteilen.

Zusammenhalt

Es ist auch möglich, es zweimal hintereinander zu verschieben.

>>> dot(Rotate,dot(Rotate,[1,2,3]))
array([3, 1, 2])

Rotate\left(Rotate
 \left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)\right)
=\left(\begin{matrix}3 \\ 1 \\ 2\end{matrix}\right)

Es ist möglich, das Produkt von Rotates zuerst zu berechnen, genauso wie das Ergebnis das gleiche ist, selbst wenn Sie die zuerst zu berechnende Kombination ändern, z. B. $ a (bc) = (ab) c $ durch Multiplikation.

>>> dot(dot(Rotate,Rotate),[1,2,3])
array([3, 1, 2])

\left\{(Rotate)(Rotate)\right\}
 \left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
=\left(\begin{matrix}3 \\ 1 \\ 2\end{matrix}\right)

Die Tatsache, dass sich das Ergebnis auch dann nicht ändert, wenn die Berechnungsreihenfolge auf diese Weise geändert wird, wird als ** Konnektivität ** bezeichnet. Die Methode zur Berechnung des Matrizenprodukts soll die Konnektivität sicherstellen.

Funktionssynthese

Es ist möglich, das Produkt von Funktionen durch eine Matrix als ** Funktionszusammensetzung ** zu betrachten und es einer neuen Funktion zuzuweisen.

>>> Rotate2=dot(Rotate,Rotate)
>>> dot(Rotate2,[1,2,3])
array([3, 1, 2])

Rotate2
 \left(\begin{matrix}1 \\ 2 \\ 3\end{matrix}\right)
=\left(\begin{matrix}3 \\ 1 \\ 2\end{matrix}\right)

Wenn Sie dreimal drehen, kehrt es zum Original zurück, aber Sie können sehen, dass das Ergebnis der Funktionssynthese eine Einheitsmatrix ist.

>>> Rotate3=dot(Rotate2,Rotate)
>>> dot(Rotate3,[1,2,3])
array([1, 2, 3])
>>> Rotate3
array([[1, 0, 0],
       [0, 1, 0],
       [0, 0, 1]])

(Rotate2)(Rotate)
=\left(\begin{matrix}1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{matrix}\right)

Anzahl der Ein- / Ausgänge

Wenn Sie sich eine Matrix als Funktion vorstellen, können Sie interpretieren, dass die Größe der Matrix die Anzahl der Elemente im Argument (Anzahl der Eingaben) und die Anzahl der Elemente im Rückgabewert (Anzahl der Ausgaben) darstellt.

`Eingang → Funktion → Ausgang`


(X, X)    -> F -> (X, X, X)
(X, X, X) -> G ->  X

\begin{align}
F&:\quad\scriptsize{Anzahl der Ausgänge 3}\normalsize{\Biggr\{
  \overbrace{\left(\begin{matrix}f_{11} & f_{12} \\ f_{21} & f_{22} \\ f_{31} & f_{32}\end{matrix}\right)}^{Anzahl der Eingänge 2}} \\
G&:\quad\scriptsize{Anzahl der Ausgänge 1}\normalsize{\{
  \overbrace{\left(\begin{matrix}g_1 & g_2 & g_3\end{matrix}\right)}^{Anzahl der Eingänge 3}}
\end{align}

Bei der nachfolgenden Berechnung von $ F $ und $ G $ muss die Anzahl der zuerst berechneten Ausgaben von $ F $ mit der Anzahl der Eingaben der nachfolgenden $ G $ übereinstimmen.

F→
\underbrace{\left(\begin{matrix}t_1 \\ t_2 \\ t_3\end{matrix}\right)}_{Wert in der Mitte}
→G

Überprüfen Sie die Komponentenanzeige, um festzustellen, in welcher Situation $ F $ und $ G $ zu $ GF $ kombiniert sind.

Beachten Sie, dass die Reihenfolge der Funktionszusammensetzung $ GF $ die Umkehrung der Berechnungsreihenfolge $ F $ → $ G $ ist.

\underbrace{GF}_{Synthetik}
=\overbrace{\left(\begin{matrix}g_1 & g_2 & g_3\end{matrix}\right)}^{Anzahl der Eingänge 3}
 \quad\scriptsize{Anzahl der Ausgänge 3}\normalsize{\Biggr\{
  \left(\begin{matrix}f_{11} & f_{12} \\ f_{21} & f_{22} \\ f_{31} & f_{32}\end{matrix}\right)}

Berechnungsablauf

Der Berechnungsfluss einschließlich Eingabe und Ausgabe wird angezeigt. Die rote Zahl steht für die Anzahl der Elemente.

図1.png

Schematisieren Sie, indem Sie sich auf den Wert konzentrieren.

\underbrace{y}_{Ausgabe}
\xleftarrow{G}
\underbrace{\left(\begin{matrix}t_1 \\ t_2 \\ t_3\end{matrix}\right)}_{Wert in der Mitte}
\xleftarrow{F}
\underbrace{\left(\begin{matrix}x_1 \\ x_2\end{matrix}\right)}_{Eingang}

Zeichnen Sie eine Figur im Stil von Perceptron. Der Berechnungsfluss erfolgt gemäß der Matrixnotation von rechts nach links.

図2.png

Beachten Sie die Verbindungslinie zwischen $ t $ und $ x $. Am Beispiel von $ f_ {21} $ können wir sehen, dass die Interpretation des Index als $ 2 ← 1 $ dem Index des durch die Linie verbundenen Knotens $ t_2 ← x_1 $ entspricht. Das Schema ist wie folgt.

t_2 \xleftarrow{f_{21}} x_1

Stellen Sie sicher, dass die anderen Linien das gleiche Muster haben.

Tensolfluss

Dieser Abschnitt ist eine Seite. Du musst es nicht wissen.

Wenn die Indizes der Knoten als Variablen verwendet und als $ x_i, t_j $ geschrieben werden, lautet die Verbindungslinie $ f_ {ji} $.

t_j \xleftarrow{f_{ji}} x_i

Wenn Sie den letzten Schritt einschließen, ist der Ablauf wie folgt.

y \xleftarrow{g_j} t_j \xleftarrow{f_{ji}} x_i

** Tensolalgebra ** drückt diese Beziehung mit der folgenden Formel aus.

t_j=f_{ji}x_i \\
y=g_jt_j=g_jf_{ji}x_i

Die Darstellung der Tensoralgebra ist das Hinzufügen von tiefgestellten Beziehungen zur Matrix.

\boldsymbol{t}=\boldsymbol{Fx} \\
y=\boldsymbol{Gt}=\boldsymbol{GFx}

In der Tensol-Algebra [Einsteins Kontraktionsnotation](https://ja.wikipedia.org/wiki/%E3%82%A2%E3%82%A4%E3%83%B3%E3%82%B7%E3 % 83% A5% E3% 82% BF% E3% 82% A4% E3% 83% B3% E3% 81% AE% E7% B8% AE% E7% B4% 84% E8% A8% 98% E6% B3 Bei Verwendung von% 95) sieht es bis auf Matrixausdrücke und Indizes gleich aus. Details werden weggelassen, da dies den Rahmen dieser Zeit sprengt.

Wenn Sie den Wert eines Knotens in der Tensoralgebra ausdrücken, können Sie den Tensorfluss sehen.

\underbrace{g_jf_{ji}x_i}_{Ausgabe}
\xleftarrow{g_j}
\underbrace{f_{ji}x_i}_{Wert in der Mitte}
\xleftarrow{f_{ji}}
\underbrace{x_i}_{Eingang}

図3.png

[PYTHON] Matrix nach Funktion betrachtet