[PYTHON] Perceptron denkt im Covector

Wir werden die Idee des inneren Produkts durch Tabellenberechnung und des Covektors durch Funktion überprüfen und die logische Operation von Perceptron unter diesem Gesichtspunkt betrachten. Fügen Sie die Berechnung mit NumPy hinzu.

Dies ist eine Reihe von Artikeln.

  1. Internes Produkt nach Schätzung berücksichtigt
  2. Covector, um mit Funktion zu denken
  3. Matrix zum Denken mit Funktion
  4. Dualität in der Funktion
  5. Perceptron Denken mit Covector ← Dieser Artikel

Dieser Artikel wurde mit der Absicht verfasst, die folgenden Bücher zu unterstützen:

Berechnung berechnen

Ich werde das vorherige Beispiel erneut veröffentlichen.

Produktname Stückpreis(Firma A.) Menge Zwischensumme
Bleistift 30 12 360
Radiergummi 50 10 500
Hinweis 150 5 750
Gesamtsumme 1,610

Wenn Sie den Stückpreis und die Menge als Vektor umschreiben, ist dies die Berechnung des inneren Produkts.

\overbrace{\left(\begin{matrix}30 \\ 50 \\150\end{matrix}\right)}^{Stückpreis}\cdot
\overbrace{\left(\begin{matrix}12 \\ 10 \\ 5\end{matrix}\right)}^{Menge}
=\overbrace{30×12}^{Zwischensumme}+\overbrace{50×10}^{Zwischensumme}+\overbrace{150×5}^{Zwischensumme}
=\overbrace{1610}^{Gesamtsumme}

NumPy

Hier ist die Berechnung in NumPy.

>>> from numpy import *
>>> dot([30,50,150],[12,10,5])
1610

Fragen Sie nicht sofort nach der Gesamtsumme, sondern finden Sie die Zwischensumme des Adamal-Produkts.

>>> array([30,50,150])*[12,10,5]
array([360, 500, 750])

Die Summe der Zwischensummen ergibt die Summe.

>>> sum(array([30,50,150])*[12,10,5])
1610

Funktionalisierung durch Covector

Durch Zuweisen des Einheitspreises von Unternehmen A zu einem horizontalen Vektor (Covector) namens "A" kann die Aufnahme des inneren Produkts mit der Bewertung der Funktion gleichgesetzt werden.

>>> A=[30,50,150]
>>> dot(A,[12,10,5])
1610
A
 \left(\begin{matrix}12 \\ 10 \\ 5\end{matrix}\right)
=\left(\begin{matrix}30 &  50 &  150\end{matrix}\right)
 \left(\begin{matrix}12 \\ 10 \\ 5\end{matrix}\right)
=1610

Vergleich der Anzahl

Stellen Sie sich einen Fall vor, in dem die Nummer geändert und verglichen wird.

Produktname Stückpreis Menge ① Nummer ② Zwischensumme ① Zwischensumme ②
Bleistift 30 12 9 360 270
Radiergummi 50 10 13 500 650
Hinweis 150 5 4 750 600
Gesamtsumme 1,610 1,520

Bei der Berechnung mit covector können Sie sofort berechnen, indem Sie eine Matrix übergeben, in der der Vektor des Arguments nebeneinander angeordnet ist.

>>> dot(A,array([[12,10,5],[9,13,4]]).T)
array([1610, 1520])
\begin{align}
A\left(\begin{array}{c|c}12 & 9 \\ 10 & 13 \\ 5 & 4\end{array}\right)
&=\left(\begin{matrix}
    A\left(\begin{matrix}12 \\ 10 \\ 5\end{matrix}\right) &
    A\left(\begin{matrix} 9 \\ 13 \\ 4\end{matrix}\right)
  \end{matrix}\right) \\
&=\left(\begin{matrix}1610 & 1520\end{matrix}\right)
\end{align}

Dies ist die Bewertung.

AND

Betrachten Sie "UND" als logische Operation. Zeigt die Produkttabelle an.

A B A&B
0 0 0
0 1 0
1 0 0
1 1 1

Dies ist eine Art Berechnung, die vom Covector nicht ausgedrückt werden kann. Daher wird die Nachbearbeitung hinzugefügt.

Die Idee ist, A und B hinzuzufügen, herauszufinden, ob es größer als 1 ist, und wenn es wahr ist, ist es 1.

A B A+B >1 A&B
0 0 0 F 0
0 1 1 F 0
1 0 1 F 0
1 1 2 T 1

Der Teil, in dem A und B hinzugefügt werden, wird durch den Covektor "And0" dargestellt, der Größenvergleich wird hinzugefügt und Null wird zur Quantifizierung hinzugefügt.

>>> And0=[1,1]
>>> (dot(And0,array([[0,0],[0,1],[1,0],[1,1]]).T)>1)+0
array([0, 0, 0, 1])

Dieser Covector $ (1 \ 1) $ heißt ** weight ** $ w $, und > 1 $ 1 $ heißt Schwelle $ θ $.

Perzeptron

Die Berechnung basierend auf Gewichten und Schwellenwerten heißt Perceptron. Definiert eine Funktion von Perceptron.

>>> def perceptron(w, th, x):
...     return (dot(w, x) > th) + 0
...

Verwenden Sie dies, um AND zu berechnen.

>>> perceptron(And0, 1, [0,1])
0

Wie Covektoren akzeptiert es mehrere Argumente.

>>> perceptron(And0, 1, array([[0,0],[0,1],[1,0],[1,1]]).T)
array([0, 0, 0, 1])

Recommended Posts

Perceptron denkt im Covector
Covector, um in Funktion zu denken
Implementierte Perceptron-Lernregeln in Python
Perzeptron