[PYTHON] Fassen wir die Grundfunktionen von TensorFlow zusammen, indem wir ein neuronales Netzwerk erstellen, das XOR-Gatter lernt.

Ich habe die TensorFlow-Funktion nicht gut verstanden, daher [dieses Buch](https://www.amazon.co.jp/gp/product/4839962510/ref=s9u_simh_gw_i1? & pf_rd_r = 4J4CEBWSM45D5K2A5SGW & pf_rd_t = 36701 & pf_rd_p = d4802771-73ad-49b1-a154-90aaec384d3e & pf_rd_i = desktop).

Verwirklichen Sie xor gate mit TensorFlow. In der folgenden Wahrheitstabelle beträgt die Dimension der Eingabeschicht 2 und die Dimension der Ausgabeschicht 1.

Programmablauf

① Bibliothek importieren

import numpy as np
import tensorflow as tf

② XOR-Datenaufbereitung

X = np.array([[0,0],[0,1],[1,0],[1,1]])
Y = np.array([[0],[1],[1],[0]])

③ Geben Sie einen Behälter für das richtige Antwortetikett ein und bereiten Sie ihn vor

x = tf.placeholder(tf.float32, shape=[None,2])
t = tf.placeholder(tf.float32, shape=[None,1])

tf.placeholder() Wie ein Container zum Speichern von Daten sein. Bei der Definition eines Modells werden nur die Dimensionen festgelegt, und es ist möglich, die tatsächliche Formel zu bewerten, indem Werte zu dem Zeitpunkt eingegeben werden, zu dem Daten tatsächlich benötigt werden, z. B. Modelltraining. shape = [None, 2] gibt an, dass die Dimension des Eingabevektors 2 ist, und None ist ein Container, der verwendet werden kann, auch wenn die Anzahl der Daten variabel ist. None Teil ← Kurz gesagt, zum Zeitpunkt von xor gate gibt es 4 Daten von 00, 01, 10, 11, aber in Wirklichkeit ist die Anzahl der Daten möglicherweise nicht bekannt, sodass sie zu None werden.

④ Modelldefinition (Eingabeebene-versteckte Ebene)

x: Eingabe h: Versteckte Ebene Ausgabe W: Gewicht b: Vorspannung

h = Wx + b

W = tf.Variable(tf.truncated_normal([2,2]))
b = tf.Variable(tf.zeros([2]))
h = tf.nn.sigmoid(tf.matmul(x,W) + b)

tf.Variable() Erforderlich, um Variablen zu generieren. Behandeln Sie Daten mit dem einzigartigen Typ TensorFlow Der content tf.zeros () entspricht dem np.zeros () in Numpy. tf.truncated_normal () ist eine Methode, die Daten generiert, die einer Schnittnormalverteilung folgen. Wenn Sie mit "0" initialisieren, wird der Fehler möglicherweise nicht richtig wiedergegeben.

⑤ Modelldefinition (versteckte Ebene - Ausgabeebene)

h: Eingabe in die Ausgabeebene (Ausgabe der verborgenen Ebene) y: Ausgabe V: Gewicht c: Vorspannung

y = Vh + c

V = tf.Variable(tf.truncated_normal([2,1]))
c = tf.Variable(tf.zeros([1]))
y = tf.nn.sigmoid(tf.matmul(h,V) + c)

Die Erklärung ist dieselbe wie ④

⑥ Fehlerfunktion

cross_entropy = -tf.reduce_sum(t * tf.log(y) + (1-t) * tf.log(1-y))

Da es sich diesmal um eine binäre Klassifikation handelt, verwenden wir die Kreuzentropiefunktion

-tf.reduce_sum(t * tf.log(y) + (1-t) * tf.log(1-y)) Die Berechnung der Kreuzentropiefehlerfunktion kann gemäß der Formel geschrieben werden. tf.reduce_sum () entspricht np.sum ()

⑦ Probabilistische Gradientenabstiegsmethode

train_step = tf.train.GradientDescentOptimizer(0.1).minimize(cross_entropy)

Anwendung der probabilistischen Gradientenabstiegsmethode Das Argument "0.1" von "GradientDescentOptimizer ()" ist die Lernrate

⑧ Bestätigung der Ergebnisse nach dem Lernen

correct_prediction = tf.equal(tf.to_float(tf.greater(y, 0.5)), t)

Implementierung, um zu überprüfen, ob das Ergebnis nach dem Training korrekt ist Das Neuron feuert bei "y> = 0,5". Vergleichen Sie es mit der korrekten Bezeichnung "t" und geben Sie "True" oder "False" zurück

⑨ Sitzungsvorbereitung

init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

In TensorFlow werden Berechnungen immer im Datenaustauschfluss durchgeführt, der als Sitzung bezeichnet wird. Zum ersten Mal wird der Ausdruck der in der Modelldefinition deklarierten Variablen initialisiert.

⑩ Lernen

for epoch in range(4000):
    sess.run(train_step, feed_dict={
        x:X,
        t:Y
    })

    if epoch % 1000 == 0:
        print('epoch:', epoch)

sess.run (train_step) Dies wird durch die Gradientenabstiegsmethode gelernt Zuweisen von Werten zu "x", "t", die "Platzhalter" in "feed_dict" sind Geben Sie den Wert genau in den Platzhalter ein

⑪ Bestätigung des Lernergebnisses (Vergleich mit korrektem Antwortetikett)

classified = correct_prediction.eval(session=sess, feed_dict={
    x:X,
    t:Y
})

eval() Wird verwendet, um zu überprüfen, ob Neuronen in der Lage sind, richtig zu klassifizieren, ob sie feuern oder nicht Kurz gesagt, hier verwenden wir es, um den Wert von "korrekt_prediction" zu überprüfen

⑫ Bestätigung des Lernergebnisses (Ausgabewahrscheinlichkeit)

prob = y.eval(session=sess, feed_dict={
    x:X,
    t:Y
})

Sie können die Ausgabewahrscheinlichkeit für jede Eingabe erhalten Kurz gesagt, Sie können den Wert von y überprüfen

⑫ Anzeige

print('classified:')
print(classified)
print()
print('output probability:')
print(prob)

Ergebnis

Ausgabe

epoch: 0
epoch: 1000
epoch: 2000
epoch: 3000
classified:
[[ True]
 [ True]
 [ True]
 [ True]]

output probability:
[[ 0.00661706]
 [ 0.99109781]
 [ 0.99389231]
 [ 0.00563505]]

Referenz

] = & pf_rd_r = 4J4CEBWSM45D5K2A5SGW & pf_rd_t = 36701 & pf_rd_p = d4802771-73ad-49b1-a154-90aaec384d3e & pf_rd_i = desktop)