Perché l'esempio TensorFlow ha esito negativo quando si aumentano le dimensioni del batch?

Question

Stavo guardando il Tensorflow MNIST example for beginners e ha scoperto che in questa parte:

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

cambiare la dimensione del lotto da 100 a essere al di sopra 204 fa sì che il modello di non riuscire a convergere. Funziona fino a 204, ma a 205 e qualsiasi numero più alto ho provato, la precisione sarebbe finita a < 10%. È un bug, qualcosa sull'algoritmo, qualcos'altro?

Questo sta eseguendo l'installazione binaria per OS X, sembra essere la versione 0.5.0.

Answer 1

Stai utilizzando il modello lineare di base nell'esempio per principianti?

Ecco un trucco per eseguire il debug - guardare il cross-entropia come si aumenta la dimensione del lotto (la prima linea è l'esempio, la seconda ho solo aggiunto):

cross_entropy = -tf.reduce_sum(y_*tf.log(y)) 
cross_entropy = tf.Print(cross_entropy, [cross_entropy], "CrossE") 

Ad una dimensione del lotto di 204, si vedrà:

I tensorflow/core/kernels/logging_ops.cc:64] CrossE[92.37558] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[90.107414] 

Ma a 205, vedrete una sequenza come questo, fin dall'inizio:

I tensorflow/core/kernels/logging_ops.cc:64] CrossE[472.02966] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[475.11697] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[1418.6655] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[1546.3833] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[1684.2932] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[1420.02] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[1796.0872] 
I tensorflow/core/kernels/logging_ops.cc:64] CrossE[nan] 

Ack - NaN sta mostrando. Fondamentalmente, la grande dimensione del batch sta creando un gradiente così grande che il tuo modello sta andando fuori controllo in modo vertiginoso - gli aggiornamenti che sta applicando sono troppo grandi e superano la direzione in cui dovrebbe andare con un enorme margine.

In pratica, ci sono alcuni modi per risolvere questo problema. È possibile ridurre il tasso di apprendimento da 0,01 a, ad esempio, 0,005, il che si traduce in una precisione finale di 0,92.

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

Oppure si potrebbe usare un più sofisticato algoritmo di ottimizzazione (Adam, Momentum, etc.) che cerca di fare di più per capire la direzione del gradiente. Oppure potresti usare un modello più complesso che ha più parametri liberi su cui disperdere quel grande gradiente.

Answer 2

@dga ha dato un'ottima risposta, ma volevo espandermi un po '.

Quando ho scritto il tutorial principianti, ho implementato la funzione di costo in questo modo:

cross_entropy = -tf.reduce_sum (y_ * tf.log (y))

ho scritto in questo modo perché sembra più simile alla definizione matematica di cross-entropy. Ma potrebbe in realtà essere meglio fare qualcosa di simile:

cross_entropy = -tf.reduce_mean (y_ * tf.log (y))

Perché potrebbe essere più bello di utilizzare un mezzo invece di una somma? Bene, se sommiamo, raddoppiando la dimensione del lotto raddoppiamo il costo e raddoppiamo anche la magnitudo del gradiente. A meno che non aggiustiamo il nostro tasso di apprendimento (o usiamo un algoritmo che lo regola per noi, come suggerito da @dga) il nostro addestramento esploderà! Ma se usiamo una media, allora il nostro tasso di apprendimento diventa indipendente dalla nostra dimensione del lotto, che è bello.

Ti incoraggio a controllare Adam (tf.train.AdamOptimizer()). Spesso è più tollerante a manipolare cose che SGD.

Answer 3

@dga ha ben spiegato la ragione di tale comportamento (la cross_entropy diventa troppo grande) e quindi l'algoritmo non sarà in grado di convergere. Ci sono un paio di modi per risolvere questo problema. Ha già suggerito di diminuire il tasso di apprendimento.

La discesa dei gradienti è l'algoritmo più semplice. Quasi tutti gli altri optimizers lavorerà correttamente:

train_step = tf.train.AdagradOptimizer(0.01).minimize(cross_entropy) 
train_step = tf.train.AdamOptimizer().minimize(cross_entropy) 
train_step = tf.train.FtrlOptimizer(0.01).minimize(cross_entropy) 
train_step = tf.train.RMSPropOptimizer(0.01, 0.1).minimize(cross_entropy) 

Un altro approccio è quello di utilizzare tf.nn.softmax_cross_entropy_with_logits che gestisce instabilità numerici.

Answer 4

Nan si verifica quando (0) si verifica 0 * log:

sostituire:

cross_entropy = -tf.reduce_sum(y_*tf.log(y)) 

con:

cross_entropy = -tf.reduce_sum(y_*tf.log(y + 1e-10))