Was ist Perceptron?

Perceptron empfängt mehrere Signale als Ein- und Ausgänge eines Signals. Das Perceptron-Signal ist ein Binärwert von 1 oder 0. Dieses Mal werde ich es so beschreiben, dass es nicht 0 und 1 fließt.

Tortyp

AND

x1	x2	y
0	0	0
1	0	0
0	1	0
1	1	1

NAND

x1	x2	y
0	0	1
1	0	1
0	1	1
1	1	0

x1	x2	y
0	0	0
1	0	1
0	1	1
1	1	1

Implementierung von Perceptron

Einfache Implementierung

UND-Funktion definieren

def AND(x1, x2)
    w1, w2, theta = 0.5, 0.5, 0.7
    temp = x1*w1+x2*w2
    if tmp <= theta:
        return 0
    elif tmp > theta:
        return 1

Die Parameter w1, w2 und Theta werden in der Funktion initialisiert und geben 1 zurück, wenn die Summe der gewichteten Eingaben den Schwellenwert überschreitet, andernfalls 0. Überprüfen wir dann, ob die Ausgabe wie in Abbildung 2-2 dargestellt ist.

AND(0, 0) # 0
AND(1, 0) # 0
AND(0, 1) # 0
AND(1, 1) # 1

Ich habe das erwartete Verhalten.

In ähnlicher Weise können sowohl NAND als auch OR implementiert werden.

Einführung von Gewichten und Vorurteilen

y = 0(b+w1x1+w2x2 <= 0)
    1(b+w1x1+w2x2 >  0)

>>>import numpy as np
>>>x = np.array([0,1])
>>>w = np.array([0.5, 0.5])
>>>b = -0.7
>>>w*x
>>>array([0. , 0.5])
>>>np.sum(w*x)
0.5
>>>np.sum(w*x) + b
-0.19999999996

Umsetzung nach Gewicht und Voreingenommenheit

def AND(x1, x2):
   x = np.array([x1, x2])
   w = np.array([0.5, 0.5])
   b = -0.7
   tmp = np.sum(w*x) + b
   if tmp <= 0:
       return 0
   else:
       return 1

def NAND(x1, x2):
   x = np.array([x1, x2])
   w = np.array([-0.5, -0.5])
   b = 0.7
   tmp = np.sum(w*x) + b
   if tmp <= 0
      return 0
   else:
      return 1

def OR(x1, x2):
   x = np.array([x1, x2])
   w = np.array([0.5, 0.5])
   b = -0.2
   tmp = np.sum(w*x) + b
   if tmp <= 0
       return 0
   else:
       return 1

XOR-Gatter

Das XOR-Gatter ist eine Logikschaltung, die auch als exklusive Summe von Logik bezeichnet wird.

x1	x2	y
0	0	0
1	0	1
0	1	1
1	1	0

Es ist schwierig, dieses Ergebnis in einer Gleichung auszudrücken.

Mehrschichtiges Perceptron

Perceptron konnte das XOR-Gatter nicht darstellen. Dies ist jedoch durch Stapeln von Schichten möglich.

Kombination bestehender Tore

Das XOR-Gatter kann durch den Wert der Kombination von NAND und OR und AND dargestellt werden.

XOR |x1|x2|s1|s2|y| |---|---|---| |0|0|1|0|0| |1|0|1|1|1| |0|1|1|1|1| |1|1|0|1|0|

Implementierung von XOR

def XOR(x1, x2):
    s1 = NAND(x1, x2)
    s2 = OR(x1, x2)
    y = AND(s1, s2)

XOR(0, 0) # 0
XOR(1, 0) # 1
XOR(0, 1) # 1
XOR(1, 1) # 0

XOR ist ein zweischichtiges Perzeptron. Mehrere gestapelte Perzeptrone werden manchmal als mehrschichtige Perzeptrone bezeichnet. Es ist möglich, durch Stapeln von Schichten flexibler auszudrücken.

Zusammenfassung

--Perceptron ist ein Algorithmus mit Eingabe und Ausgabe. Bei einer bestimmten Eingabe wird ein fester Wert ausgegeben.

In Perceptron werden [Gewicht] und [Vorspannung] als Parameter festgelegt.
Wenn Sie Perceptron verwenden, können Sie Logikschaltungen wie UND- und ODER-Gatter ausdrücken.
Das XOR-Gatter kann nicht durch ein einphasiges Perzeptron dargestellt werden.
Das XOR-Gatter kann mit einem zweischichtigen Perzeptron dargestellt werden.
Ein einphasiges Perzeptron kann nur den linearen Bereich darstellen, während ein mehrschichtiges Perzeptron den nichtlinearen Bereich darstellen kann.
Das mehrschichtige Perceptron kann einen Computer darstellen.