Dualité en fonction

Les vecteurs et co-vecteurs sont égaux et leurs rôles peuvent être échangés. C'est ce qu'on appelle la dualité. Vérifions avec un exemple. Joindre le calcul par NumPy.

Ceci est une série d'articles.

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

On suppose que NumPy est importé comme suit.

>>> from numpy import *

Dualité

Auparavant, j'ai considéré le calcul du tableau suivant.

Nom du produit Prix unitaire(Société A) Prix unitaire(Société B) Quantité total(Société A) total(Société B)
crayon 30 25 12 360 300
la gomme 50 60 10 500 600
Remarque 150 120 5 750 600
Somme finale 1,610 1,500

Pour calculer cela, préparez une matrice et un vecteur.

>>> A=array([[30,50,150],[25,60,120]]).T
>>> A
array([[ 30,  25],
       [ 50,  60],
       [150, 120]])
>>> X=array([[12,10,5]]).T
>>> X
array([[12],
       [10],
       [ 5]])
A=\left(\begin{matrix} 30 & 25 \\ 50 & 60 \\ 150 & 120 \end{matrix}\right),
X=\left(\begin{matrix} 12 \\ 10 \\ 5 \end{matrix}\right)

Notez qu'il a la même forme que le calcul de la table. Si vous retournez le côté gauche, vous pouvez obtenir le même numéro même si vous modifiez l'ordre.

>>> dot(A.T,X)
array([[1610],
       [1500]])
>>> dot(X.T,A)
array([[1610, 1500]])
A^{\top}X
=\left(\begin{matrix} 30 & 50 & 150 \\ 25 & 60 & 120 \end{matrix}\right)
 \left(\begin{matrix} 12 \\ 10 \\ 5 \end{matrix}\right)
=\left(\begin{matrix} 1610 \\ 1500 \end{matrix}\right) \\
X^{\top}A
=\left(\begin{matrix} 12 & 10 & 5 \end{matrix}\right)
 \left(\begin{matrix} 30 & 25 \\ 50 & 60 \\ 150 & 120 \end{matrix}\right)
=\left(\begin{matrix} 1610 & 1500 \end{matrix}\right) \\

Ceci est interprété comme un échange des rôles de vecteur et de covecteur. Si vous passez un vecteur comme argument, un vecteur sera retourné, et si vous passez un covecteur, un covecteur sera retourné.

Formellement, lorsque le tout est transposé, l'ordre est inversé et le tout est transposé individuellement.

(A^{\top}X)^{\top}=X^{\top}A

Cela revient à inverser le signe du tout par soustraction, mais l'ordre n'est pas inversé si le signe est inversé individuellement.

\begin{align*}
-(3-2)
&=2-3 \\
&=(-3)-(-2)
\end{align*}

Nombre d'entrées / sorties

Le flux de calcul est inversé pour les vecteurs et les co-vecteurs.

\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)} \\
\overbrace{\left(\begin{matrix}f_{11} & f_{12} & f_{13} \\ f_{21} & f_{22} & f_{23} \end{matrix}\right)}^{Nombre de sorties 3}
 \quad\scriptsize{Nombre d'entrées 3}\normalsize{\Biggr\{
  \left(\begin{matrix}g_1 \\ g_2 \\ g_3 \end{matrix}\right)}
=\underbrace{FG}_{Synthétique}

Si vous supprimez le nombre d'éléments intermédiaires, seules les entrées et les sorties restent.

\underbrace{1}_{production}×\underbrace{3←3}_{Suppression}×\underbrace{2}_{contribution} \\
\underbrace{2}_{contribution}×\underbrace{3→3}_{Suppression}×\underbrace{1}_{production}

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 図4.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} \\
\underbrace{\left(\begin{matrix}x_1 & x_2\end{matrix}\right)}_{contribution}
\xrightarrow{F}
\underbrace{\left(\begin{matrix}t_1 & t_2 & t_3\end{matrix}\right)}_{Valeur au milieu}
\xrightarrow{G}
\underbrace{y}_{production}

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

図2.png 図5.png

Notez la connexion entre $ 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 \\
x_1 \xrightarrow{f_{12}} t_2 \\

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

Recommended Posts

Dualité en fonction
Exécuter des fonctions en parallèle
Fonction générateur même en JavaScript
Covector pour penser en fonction
Utiliser la fonction de rappel en Python
Implémenter la fonction de minuterie dans pygame
Modélisation de fonctions non linéaires en Python
Dessiner la fonction Yin en python
Fonction immédiate (lie) en python
Implémenter la fonction power.prop.test de R en python
Créer une fonction d'authentification utilisateur dans Airflow
Avertissement de tri dans la fonction pd.concat
Définition du type d'argument de fonction en python
Notation inclusive dans l'argument de la fonction Python
Implémentation de la fonction de connexion dans Django
Ecrire une fonction AWS Lambda en Python
Mesurer le temps d'exécution de la fonction en Python
fonction python ①
Précautions lors du décapage d'une fonction en python
[Python] fonction
Prenez la somme logique de List en Python (fonction zip)
Définir des actions personnalisées dans JupyterHub (fonction hook)
Fonction en fonction
Différence de sortie de la fonction de fenêtre de longueur paire
Fonction récursive
Fonction en fonction
fonction python ②
Examen des fonctions
La fonction _authenticate_with_backend était obsolète dans django auth.autenticate
Dessiner un graphique d'une fonction quadratique en Python
Enregistrer automatiquement les arguments de fonction dans argparse en Python
Récupérer l'appelant d'une fonction en Python
[Neta] Fonction de tri de veille thread-safe en Python (threading)
Correction des arguments de la fonction utilisée dans map
J'ai essayé d'implémenter la fonction gamma inverse en python
Échec d'assertion Python: size.width> 0 && size.height> 0 dans la fonction imshow
Comment se moquer d'une fonction publique dans Pytest
dlopen () ltrace un appel de fonction dans une bibliothèque partagée