Wie in 2-Ebenen neuronales Netz mit TensorFlow und python auf dem MNIST-Daten

Ich bin ein Neuling in der Maschine zu lernen, und ich bin nach tensorflow tutorial zu erstellen einige einfache Neuronale Netze, die lernen, die MNIST-Daten.

Ich gebaut haben eine single-layer-Netzwerk (nach dem tutotial), Genauigkeit war über 0.92, das ist ok für mich. Aber dann fügte ich eine weitere Ebene, die Genauigkeit reduziert, 0.113, das ist sehr schlecht.

Unten ist die Beziehung zwischen 2 Schichten:

import tensorflow as tf
x = tf.placeholder(tf.float32, [None, 784])

#layer 1
W1 = tf.Variable(tf.zeros([784, 100]))
b1 = tf.Variable(tf.zeros([100]))
y1 = tf.nn.softmax(tf.matmul(x, W1) + b1)

#layer 2
W2 = tf.Variable(tf.zeros([100, 10]))
b2 = tf.Variable(tf.zeros([10]))
y2 = tf.nn.softmax(tf.matmul(y1, W2) + b2)

#output
y = y2
y_ = tf.placeholder(tf.float32, [None, 10])

Ist meine Struktur in Ordnung? Was ist der Grund dafür, dass macht es so schlecht? Wie sollte ich ändern mein Netzwerk?

InformationsquelleAutor Tai Christian | 2016-07-01

9

Die Eingabe der 2. Schicht ist die softmax von der Ausgabe der ersten Schicht. Sie wollen nicht, das zu tun.

Sind Sie zu zwingen aus der Summe dieser Werte werden 1. Wenn einige Wert tf.matmul(x, W1) + b1 ist, die 0 (und einige sind sicherlich) die softmax-Betrieb sinkt dieser Wert auf 0 ein. Ergebnis: du bist die Tötung der gradient und es kann nichts fließen Trog diese Neuronen.

Wenn Sie entfernen die softmax zwischen den Schichten (aber leve es die softmax auf der output-Ebene, wenn Sie wollen, betrachten die Werte als Wahrscheinlichkeit) Ihr Netzwerk funktioniert Prima.

Tl;dr:
```
import tensorflow as tf
x = tf.placeholder(tf.float32, [None, 784])

#layer 1
W1 = tf.Variable(tf.zeros([784, 100]))
b1 = tf.Variable(tf.zeros([100]))
y1 = tf.matmul(x, W1) + b1 #remove softmax

#layer 2
W2 = tf.Variable(tf.zeros([100, 10]))
b2 = tf.Variable(tf.zeros([10]))
y2 = tf.nn.softmax(tf.matmul(y1, W2) + b2)

#output
y = y2
y_ = tf.placeholder(tf.float32, [None, 10])
```
- Danke @nessuno, du hast Recht! Jetzt Ersetze ich es durch aufgrund der Kr und es funktioniert sehr gut ^^
InformationsquelleAutor nessuno
0

Kam in genau dem gleichen problem, die Steigungen gingen und bekam ein paar nan für die vorhergesagten y. Umgesetzt, was vorgeschlagen von nessuno, leider, die divergierenden Verläufe noch nicht fest.

Stattdessen hab ich versucht sigmoid wie die Aktivierung der Funktion für layer 1, es funktionierte! Aber für relu funktionierte nicht, wenn initiieren W1 und W2 als null-Matrizen, die Genauigkeit ist nur 0.1135 . Um beide relu und sigmoid arbeiten, besser in zufälliger Initialisierung der W1 und W2. Hier ist der geänderte code
```
import tensorflow as tf

x = tf.placeholder(tf.float32, [None, 784])

# layer 1
with tf.variable_scope('layer1'):
    W1 = tf.get_variable('w1',[784,200],
                         initializer=tf.random_normal_initializer())
    b1 = tf.get_variable('b1',[1,],
                         initializer=tf.constant_initializer(0.0))
    y1 = tf.nn.sigmoid(tf.matmul(x, W1) + b1)
#   y1 = tf.nn.relu(tf.matmul(x, W1) + b1) # alternative choice for activation

# layer 2
with tf.variable_scope('layer2'):
    W2 = tf.get_variable('w2',[200,10],
                     initializer= tf.random_normal_nitializer())
    b2 = tf.get_variable('b2',[1,],
                         initializer=tf.constant_initializer(0.0))
    y2 = tf.nn.softmax(tf.matmul(y1, W2) + b2)

# output
y = y2
y_ = tf.placeholder(tf.float32, [None, 10])
```
Fand ich dieser link ist hilfreich, siehe Frage 2, Teil (c), die RÜCKFÜHRUNG von Derivaten, die für eine grundlegende 2-layer neural network. Meiner Meinung nach, wenn der Benutzer nicht geben Sie alle acivation-Funktion, nur für lineare Strömung in der Ebene 1, wird am Ende mit backprograting einen Verlauf sieht etwas wie (sth)*W2^T*W1^T, und als wir initilize beide W1 und W2 zu Nullen, Ihr Produkt ist wahrscheinlich sehr klein, nahe null, das Ergebnis in verschwindenden Gradienten.

UPDATE

Dies ist von den Quora-Antwort Ofir gepostet über erste gute GEWICHTE in einem neuronalen Netzwerk.

Den häufigsten Initialisierungen sind zufällige Initialisierung und Xavier
die Initialisierung. Zufällige Initialisierung nur Proben jedes Gewicht aus
standard-distribution (oft Normalverteilung) mit niedrigen
Abweichung. Die geringe Abweichung ermöglicht es Ihnen, bias-Netzwerk in Richtung
die 'simple' - 0-Lösung, ohne die schlechten Folgen des eigentlich
die Initialisierung der GEWICHTE zu 0.

InformationsquelleAutor GabrielChu

Ich versuchte, die code-snippets oben. Ergebnisse unter 90% wurde verworfen und ich nie wirklich das Gefühl, sicher, dass ich Tat, was die Kommentare oben hatte. Hier ist mein vollständiger code.

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
x = tf.placeholder(tf.float32, [None, 784])

#layer 1
W1 = tf.get_variable('w1', [784, 100], initializer=tf.random_normal_initializer())
b1 = tf.get_variable('b1', [1,], initializer=tf.random_normal_initializer())
y1 = tf.nn.sigmoid(tf.matmul(x, W1) + b1) 

#layer 2
W2 = tf.get_variable('w2',[100,10], initializer= 
tf.random_normal_initializer())
b2 = tf.get_variable('b2',[1,], initializer=tf.random_normal_initializer())
y2 = tf.nn.softmax(tf.matmul(y1, W2) + b2)

#output
y = y2
y_ = tf.placeholder(tf.float32, [None, 10])

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), 
reduction_indices=[1]))
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(cross_entropy)
sess = tf.InteractiveSession()
tf.global_variables_initializer().run()

for _ in range(10000):
  batch_xs, batch_ys = mnist.train.next_batch(100)
  sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: 
mnist.test.labels}))

Durch die änderung 10000 -> 200000 ich erreichte 95,5%.

Ich arbeitete ein bisschen mehr und auch die Wiederholung 95,5% hart war. Das wäre sehr nett von einigen professionellen könnte kommentieren. Das Ergebnis ist weit unter der erwarteten. Die Variationen, die ich ausprobiert habe sind die Steigungs-parameter, Anzahl der Wiederholungen, die schrittweise reduziert den Gradienten-parameter. Da es in der Nähe von 80000 variabels in das raster ein fast perfektes Ergebnis, was ich erwartet hatte. Ich bin mir bewusst, über tensorflow.org/get_started/mnist/pros, aber das schließt eine große Anzahl von aufschlussreichen Verwendungen. Um etwas zu sehen, das einfach behoben helfen würde, mehr für mich sowieso.
Sie können auch bessere Ergebnisse erzielen, indem die Initialisierung der GEWICHTE so: W = tf.Variable(tf.random_uniform([784,100], -0.01, 0.01)). Klingt nicht nach viel, aber die Initialisierung der GEWICHTE nahe 0 tatsächlich hilft in diesem Fall.
ich denke, es peaks bei 20k ein zwei-Schicht

InformationsquelleAutor Kåre Jonsson

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.