+ datos de clasificación del carácter RNN tensorflow-BasicLSTMCell mnist manuscritas de la serie completa + código de GitHub
En primer lugar, la parte principal
Para obtener más información acerca de RNN, véase Bowen
detallada recurrente red neuronal RNN + tensorflow poner en práctica los principios
de LSTM:
Sabemos RNN incluye de entrada en cualquier momento antes, pero esto va a provocar la desaparición del gradiente o explosión gradiente, pero no puede ser una característica buena de aprendizaje por lo tanto usando LSTM
de la entrada (x, h) de control (a través de la [0-1] se multiplica por el SIGMOD decimal) (1.);
(2) antes de que el control de "acumulación" requerido por el estado grado olvidado;
(3) el control de la hora actual la necesidad de una mayor salida.
Para lograr un control más flexible.
Diagrama es el siguiente:
Consulte las siguientes dos entradas del blog, cuenta con gran detalle.
BasicLSTMCell en NUM_UNITS parámetros explicar
el siguiente artículo sobre la clase tf.nn.rnn_cell.BasicLSTMCell sobre cómo obtener la variable de proceso se muestra arriba explicación es clara.
notas de estudio de profundidad 2: Explicación de la entrada de la red neuronal y de salida LSTM
En segundo lugar, código detallado
1, el análisis de código
Un total de dos archivos
uno es RNN_LSTM_Classfication.py
uno simple_RNN.py
RNN_LSTM_Classfication.py
Los archivos de cabecera y la carga de datos, carga de datos y se explican en Bowen Algunos corren convolución red neuronal ERROR tensorflow
from tensorflow import keras, Session, transpose, global_variables_initializer
from modular.simple_RNN import simple_RNN
from modular.compute_accuracy import compute_accuracy
from modular.random_choose import corresponding_choose
(train_x_image, train_y), (test_x_image, test_y) = keras.datasets.mnist.load_data(path='/home/xiaoshumiao/.keras/datasets/mnist.npz')
train_y = keras.utils.to_categorical(train_y)
test_y=keras.utils.to_categorical(test_y)
ajustes de parámetros
epochs = 1000
n_classes = 10
batch_size = 200#number
chunk_size = 28
n_chunk = 28
rnn_size = 128#the lenth of a hidden_neural_layer or the number of hidden_neural
learning_rate = 0.001
RNN instancia de una clase de su propia definición
rnn = simple_RNN(chunk_size, n_chunk, rnn_size, batch_size, n_classes, learning_rate)
Sessa ()
with Session() as sess:
sess.run(global_variables_initializer())
for i in range(epochs):
train_data = corresponding_choose(train_x_image, batch_size, m=0)
train_x_betch = train_data.row_2(train_x_image) / 255.
train_y_betch = train_data.row(train_y)
sess.run(rnn.train,feed_dict={rnn.X:train_x_betch,rnn.y:train_y_betch})
if i % 20 ==0:
test_data = corresponding_choose(test_x_image, 200, m=0)
test_x_betch = test_data.row_2(test_x_image) / 255.
test_y_betch = test_data.row(test_y)
b = sess.run(rnn.result, feed_dict={rnn.X: test_x_betch})
c = sess.run(compute_accuracy(b, transpose(test_y_betch)))
print(c)
simple_RNN.py
importación de archivos de cabecera
from tensorflow import placeholder,float32,transpose, nn, reduce_mean, multiply, log, reduce_sum, train
from add_layer import add_layer
from tensorflow.python.ops.rnn import dynamic_rnn
Introducción de datos
class simple_RNN(object):
def __init__(self,chunk_size,n_chunk,hidden_chunk_size, batch_size, n_class, learning_rate):
self.X = placeholder(float32,[None,n_chunk,chunk_size])#200,28,28
self.y = placeholder(float32,[None, n_class])
Define una célula
valor de estado de inicialización (véase la estructura anteriormente dos enlaces)
calculado Construcción RNN figura última etapa de tiempo y para obtener una salida.
self.LSTM_cell = nn.rnn_cell.BasicLSTMCell(hidden_chunk_size, forget_bias=1.0, state_is_tuple=True)
self.init_state = self.LSTM_cell.zero_state(batch_size, float32)
self.output, self.states = dynamic_rnn(self.LSTM_cell, self.X, initial_state=self.init_state, dtype=float32)
Después de obtener un conector de salida capas totalmente conectadas, para dar salida 10-dimensional.
self.result = add_layer(transpose(self.states[1]), hidden_chunk_size, n_class, activation_function=nn.softmax)
Un método para la formación de una capa de conexión de salida completo entrenamiento de la red completamente conectada
self.loss = reduce_mean(-reduce_sum(multiply(transpose(self.y),log(self.result)),reduction_indices=[0]))
self.train = train.AdamOptimizer(learning_rate).minimize(self.loss)
2, la resolución de problemas
(1),
la primera pregunta también preocupado por el problema durante mucho tiempo, porque estaba cansado de Mo según RNN aprender sus lecciones de acuerdo con Mo problemas pitón, primero calcula manualmente capa vectorial 128 dimensiones, porque entonces en la célula. Pero miré Bowen encontró, NUM_UNITS es el número de nervios (las dimensiones de esta capa de vectores de salida debido) Función Yuan tf.nn.rnn_cell.BasicLSTMCell definido en la capa oculta, y cuando la construcción de un mapa de computación RNN dynamic_rnn, necesitamos de entrada es datos en bruto. También se refiere a la relación por encima de dos blog, la entrada es LSTM neuronas ocultas y los datos en bruto de salida en un momento. En resumen, por lo tanto, que no alcanzan los resultados calcular manualmente las neuronas de la capa oculta.
Al mismo tiempo, se puede encontrar en tf.nn.rnn_cell.BasicLSTMCell
por lo tanto, no es necesario para procesar los datos de entrada.
(2),
test_data = corresponding_choose(test_x_image, 200, m=0)
En el comienzo de las muestras batch_size muestra de ensayo y de formación no cumplen, por lo que creó 200, o se puede cambiar de nuevo.
(3),
inicializar variables, no utilice cualquier otra cosa, para ser honesto con
global_variables_initializer ()
En tercer lugar, los resultados experimentales + github
Para lograr los siguientes resultados:
En general, los resultados todavía considerables.
El código completo (otra escritura sus propias llamadas de biblioteca), y otros comentarios del programa, es necesario prestar atención al lugar, todos juntos en github, necesidad puede echar un vistazo.
https://github.com/wangjunhe8127/tensorflow-BasicLSTMCell-mnist
¡Que la fuerza esté con usted!
