Notas de estudio de Tensorflow: depuración del conjunto de entrenamiento de escritura a mano de Mnist, la solución para la precisión de 0.1 y cómo aumentar la precisión a más del 98%

Intenta mejorar la precisión de la red neuronal

La primera es aumentar la cantidad de capas ocultas, lo que ayuda a mejorar la no linealidad de los resultados. Agregué aquí una capa intermedia de 100 neuronas. El objetivo del entrenamiento es aumentar la precisión a más del 95%, lo cual no es un requisito muy alto. Los hechos han demostrado Agregar una capa es suficiente.

#构建神经网络784-100-10
w_L1=tf.Variable(tf.zeros([784,100]))
b_L1=tf.Variable(tf.zeros([1,100]))
wx_plus_b_L1=tf.matmul(x,w_L1)+b_L1
l1=tf.nn.relu(wx_plus_b_L1)


#输出层
w_L2=tf.Variable(tf.zeros([100,10]))
b_L2=tf.Variable(tf.zeros([10]))
prediction=tf.nn.softmax(tf.matmul(l1,w_L2)+b_L2)

Pero después de agregar de esta manera, no importa cómo se ajuste la función de activación o el número de tiempos de entrenamiento, la tasa de precisión es 0.1135. La
razón radica en la configuración de peso de primer nivel. Si se cambia a un valor aleatorio de la distribución normal, entonces el problema está resuelto.

Cambiar al peso de la distribución normal:

w_L1=tf.Variable(tf.truncated_normal(([784,100]),stddev=0.1))

Entrenamiento 20 veces cambio de precisión:
Iter20 Exactitud de prueba 0.9314
Entrenamiento 30 veces cambio de precisión:
Iter30 Exactitud de prueba 0.9399
Si continúa aumentando el número de entrenamiento, la tasa de precisión debería alcanzar el 95%

Mejore la precisión: reduzca el tamaño del lote para cada entrenamiento

Si el tamaño de lote se ajusta de 100 a 50, la tasa de precisión aumentará significativamente.
La precisión del entrenamiento 30 veces cuando batch_size = 50.
Precisión de la prueba Iter30 0.9567

¿Qué pasa si se aumenta el tamaño de lote?
batch_size = 200
Iter30Test Accuracy 0.9236 Se
puede ver que la tasa de precisión ha disminuido, por lo que cuanto menor sea el tamaño del lote, mayor será la tasa de precisión. Esto puede estar relacionado con el número de optimizaciones. Cuanto más pequeños sean los datos del lote cada vez, más iteraciones se necesitan para recorrer todos los datos. Más, mejor será el efecto de optimización

Mejore la precisión: use la entropía cruzada

Cuando la función de activación es la función sigmo, la entropía cruzada se puede utilizar para obtener un mejor efecto de entrenamiento. El método de utilizar la función de entropía cruzada en la función de pérdida es:

tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction)

Cabe señalar aquí que cuando se pasa el parámetro logits, el valor de predicción es:

prediction=tf.nn.softmax(tf.matmul(l1,w_L2)+b_L2)

Si el valor de softmax se utiliza como valor entrante, la tasa de precisión después de entrenar 30 veces es:

Exactitud de la prueba Iter 30 0.9642

Pero si no solicita softmax y pasa directamente el valor calculado, ¿cuál será el efecto?

prediction=tf.matmul(l1,w_L2)+b_L2

ITER 0 prueba la precisión .9336
tasa de precisión inicial de 0,93.
Después de 10 ciclos de entrenamiento
Iter9 prueba la precisión 0,9747

La tasa de precisión se incrementó directamente a 0,97 y la tasa de precisión final se mantuvo alrededor de 0,97.

Por lo tanto, para la entropía cruzada, el valor entrante de logits debe ser el mejor sin procesar softmax Alguien aquí explica porque la función softmax se calcula para logits una vez en la entropía cruzada. Combinado con la velocidad de entrenamiento más rápida al procesar los datos de la capa L1 sin softmax, la última explicación debería ser confiable.

Cambiar el optimizador y la tasa de aprendizaje

En primer lugar, la velocidad de convergencia del método de descenso de gradiente estocástico es relativamente lenta. Se necesitan muchas iteraciones para alcanzar el punto más bajo y no puede escapar del plano del punto bajo del sillín para el problema de la superficie del sillín. Aquí se recomiendan varios optimizadores. Optimizadores Adadelta, Adagrad y NAG.
Entre ellos, Adadelta y Adagrad tienen la velocidad de convergencia más rápida, y NAG es el optimizador de impulso optimizado, y la velocidad también es aceptable.
En TensorFlow, los métodos de los tres se pueden llamar fácilmente.

train_step=tf.train.AdadeltaOptimizer(1e-3).minimize(loss)
train_step=tf.train.AdagradOptimizer(1e-3).minimize(loss)
train_step=tf.train.AdamOptimizer(1e-3).minimize(loss)

Después de usar AdamOptimizer, la tasa de aprendizaje se establece en 0,001 inicial y, después de cada iteración, después de multiplicar la tasa de aprendizaje por 0,95, el entrenamiento se realiza 30 veces y la tasa de precisión es superior al 98%.

lr=tf.Variable(0.001,dtype=tf.float32)

Segunda mitad del código

train_step=tf.train.AdamOptimizer(lr).minimize(loss)
    #初始变量

init=tf.global_variables_initializer()

#求准确率
with tf.name_scope('accuracy'):
    with tf.name_scope('correct_prediction'):
        correct_prediction=tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))
    with tf.name_scope('accuracy'):
        accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
        tf.summary.scalar('accuracy',accuracy)
        
#合并所有指标


#训练
with tf.Session() as sess:
    sess.run(init)
    for epoch in range(51):
        sess.run(tf.assign(lr,0.001*0.95**(epoch)))
        for batch in range(n_batch):
            batch_xs,batch_ys=mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})
        learning_rate=sess.run(lr)
        test_acc=sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print('Iter'+str(epoch)+'Test Accuracy'+str(test_acc)+'Learning rate='+str(learning_rate))

resumen

Aumentar la cantidad de neuronas en una sola capa (por ejemplo, 1000) o agregar una capa intermedia puede mejorar la precisión, pero desea aumentarla a más del 98% (tenga en cuenta que la inicialización del valor de peso y sesgo se modifica, aquí está Distribución normal truncada), la función de pérdida y el optimizador deben ajustarse. La función de pérdida se modifica para cruzar la entropía para mejorar la precisión. Finalmente, mediante el uso de un mejor optimizador combinado con una tasa de aprendizaje adaptativo (que se reduce continuamente en las iteraciones posteriores) La tasa de aprendizaje) puede hacer que la función de pérdida caiga lo más posible al punto más bajo sin salir corriendo del mejor punto y causar oscilación.