Matrice considérée par fonction

La dernière fois, j'ai vu que les covecteurs peuvent être utilisés pour combiner plusieurs fonctions qui renvoient des scalaires. Cette fois, la fonction qui renvoie un vecteur est représentée par une matrice. [Espace vectoriel double](https://ja.wikipedia.org/wiki/%E5%8F%8C%E5%AF%BE%E3%83%99%E3%82%AF%E3%83%88%E3 Le but est de véhiculer l'image de% 83% AB% E7% A9% BA% E9% 96% 93). Python est utilisé comme langage de programmation pour la comparaison et le résultat de NumPy est attaché au calcul.

Ceci est une série d'articles.

  1. Produit interne à penser par estimation
  2. Covector pour penser avec fonction
  3. Matrice considérée par fonction ← Cet article
  4. Dualité en fonction
  5. Pensée Perceptron dans Covector

Fonction Covector

Je republierai le covector qui renvoie la valeur spécifiée à partir des trois arguments introduits la dernière fois.

>>> 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}

Plusieurs à un

La dernière fois, j'ai vu que vous pouvez passer le même argument à plusieurs fonctions. Je vais l'essayer avec la fonction précédente.

>>> 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}

Si vous considérez la valeur de retour entière comme un vecteur unique, vous remarquerez qu'il renvoie les arguments tels qu'ils sont. C'est un résultat naturel, sachant que la matrice composée de covecteurs devient une matrice unitaire.

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

Fonction par matrice

Si vous considérez l'exemple précédent comme un résultat d'une fonction, vous pouvez considérer la matrice composée de covecteurs comme une seule fonction.

>>> 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)

Vous pouvez également créer une fonction à faire défiler en décalant la disposition.

>>> 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)

De cette façon, vous pouvez considérer une matrice comme une fonction et la diviser en covecteurs si nécessaire.

Cohésion

Il est également possible de le décaler deux fois de suite.

>>> 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)

Il est possible de calculer le produit de «Rotation» en premier, tout comme le résultat est le même même si vous modifiez la combinaison à calculer en premier, comme $ a (bc) = (ab) c $ par multiplication.

>>> 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)

Le fait que le résultat ne change pas même si l'ordre de calcul est modifié de cette manière est appelé ** connectivité **. La méthode de calcul du produit des matrices est conçue pour assurer la connectivité.

Synthèse fonctionnelle

Il est possible de considérer le produit de fonctions par une matrice comme ** composition de fonction ** et de l'affecter à une nouvelle fonction.

>>> 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)

Si vous «Rotate» trois fois, il reviendra à l'original, mais vous pouvez voir que le résultat de la synthèse de fonction est une matrice unitaire.

>>> 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)

Nombre d'entrées / sorties

Si vous pensez à une matrice comme une fonction, vous pouvez interpréter que la taille de la matrice représente le nombre d'éléments dans l'argument (nombre d'entrées) et le nombre d'éléments dans la valeur de retour (nombre de sorties).

Entrée → Fonction → Sortie


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

\begin{align}
F&:\quad\scriptsize{Nombre de sorties 3}\normalsize{\Biggr\{
  \overbrace{\left(\begin{matrix}f_{11} & f_{12} \\ f_{21} & f_{22} \\ f_{31} & f_{32}\end{matrix}\right)}^{Nombre d'entrées 2}} \\
G&:\quad\scriptsize{Nombre de sorties 1}\normalsize{\{
  \overbrace{\left(\begin{matrix}g_1 & g_2 & g_3\end{matrix}\right)}^{Nombre d'entrées 3}}
\end{align}

Lors du calcul successif de $ F $ et de $ G $, le nombre de sorties de $ F $ calculé en premier doit correspondre au nombre d'entrées des $ G $ suivants.

F→
\underbrace{\left(\begin{matrix}t_1 \\ t_2 \\ t_3\end{matrix}\right)}_{Valeur au milieu}
→G

Vérifiez l'affichage des composants pour voir la situation où $ F $ et $ G $ sont combinés en $ GF $.

\underbrace{GF}_{Synthétique}
=\overbrace{\left(\begin{matrix}g_1 & g_2 & g_3\end{matrix}\right)}^{Nombre d'entrées 3}
 \quad\scriptsize{Nombre de sorties 3}\normalsize{\Biggr\{
  \left(\begin{matrix}f_{11} & f_{12} \\ f_{21} & f_{22} \\ f_{31} & f_{32}\end{matrix}\right)}

Flux de calcul

Le flux de calcul comprenant l'entrée et la sortie est affiché. Le nombre rouge représente le nombre d'éléments.

図1.png

Schématisez en vous concentrant sur la valeur.

\underbrace{y}_{production}
\xleftarrow{G}
\underbrace{\left(\begin{matrix}t_1 \\ t_2 \\ t_3\end{matrix}\right)}_{Valeur au milieu}
\xleftarrow{F}
\underbrace{\left(\begin{matrix}x_1 \\ x_2\end{matrix}\right)}_{contribution}

Dessinez une figure dans le style de Perceptron. Le déroulement du calcul est de droite à gauche selon la notation matricielle.

図2.png

Notez la ligne reliant $ t $ et $ x $. En prenant $ f_ {21} $ comme exemple, nous pouvons voir qu'en interprétant l'indice comme $ 2 ← 1 $, il correspond à l'indice du nœud $ t_2 ← x_1 $ connecté par la ligne. Le schéma est le suivant.

t_2 \xleftarrow{f_{21}} x_1

Assurez-vous que les autres lignes ont le même motif.

Flux Tensol

Si vous utilisez les indices des nœuds comme variables et que vous les écrivez sous la forme $ x_i, t_j $, la ligne qui les relie sera $ f_ {ji} $.

t_j \xleftarrow{f_{ji}} x_i

Si vous incluez la dernière étape, le déroulement sera le suivant.

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

** L'algèbre de Tensol ** exprime cette relation avec la formule suivante.

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

La représentation de l'algèbre tensorielle est l'ajout de relations d'indice à la matrice.

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

Si vous exprimez la valeur d'un nœud en algèbre tensorielle, vous pouvez voir le flux du tenseur.

\underbrace{g_jf_{ji}x_i}_{production}
\xleftarrow{g_j}
\underbrace{f_{ji}x_i}_{Valeur au milieu}
\xleftarrow{f_{ji}}
\underbrace{x_i}_{contribution}

図3.png

Recommended Posts

Matrice considérée par fonction
Quadrants considérés dans la matrice d'expression
Fonction pour enregistrer les images par date [python3]
Détection d'anomalies des données ECG par profil matriciel