Ejercicio de deep learning con GRU y RNN

En artículos pasados hemos trabajado algunos ejercicios de deep learning relacionados con el análisis de sentimientos. Existen diferentes modelos que podemos utilizar para realizar estos ejercicios y, en este post, te mostraremos cómo resolverlos por medio de un modelo de deep learning con GRU y RNN.

Deep learning con GRU y RNN: ejercicio

Modelo GRU

En este caso, para hacer la arquitectura con este modelo no tenemos que aplicar ningún cambio, simplemente cambiamos la arquitectura que usamos para la capa; en vez de usar 100 neuronas de LSTM, usaremos 100 de GRU.

Generamos una única Dense, porque estamos haciendo la predicción de sentimiento. También usamos el many to one y el accuracy, sumado al cross entropy.

#Ejercicio de deep learning con GRU y RNN
embedding_size = 32
model_gru = Sequential ()
model_gru.add (Embedding (vocabulary_size, embedding_size, input_length = max_words))
model_gru.add (GRUV2 (100))
model_gru.add (Dense (1, activation = 'sigmoid'))

print (model_gru.summary ())

Si nos fijamos, el número de parámetros en GRU es de 40200. El modelo LSTM tenía 53200 parámetros. Esto sucede porque LSTM tiene puertas de más dentro de cada neurona, lo cual hace que tenga muchos parámetros extra (en este caso, son poco más de 13 mil). Esto, por supuesto, provoca que el entrenamiento sea más pesado, ya que son más parámetros a optimizar.

Así pues, con el modelo GRU nos ahorramos parámetros de optimización, lo que puede marcar la diferencia en algún punto del camino.

#Ejercicio de deep learning con GRU y RNN
model_gru.compile (loss = 'binary_crossentropy', optimizer = 'adam', metrics = ['accuracy'])

Hacemos el mismo entrenamiento. Aquí vamos a reducir el num epochs a 1 para que se ejecute más rápido.

#Ejercicio de deep learning con GRU y RNN
batch_size = 64
num_epochs = 1

X_valid, y_valid = X_train [:batch_size], y_train [:batch_size] #first batch size samples
X_train2, y_train2 = X_train [:batch_size], y_train [:batch_size] #rest for training

model_gru.fit (X_train2, y_train2, validation_data = (X_valid, y_valid), batch_size = batch_size, epochs = num_epochs)

Si nos fijamos bien, el tiempo de entrenamiento se ha reducido un minuto por la reducción de parámetros a optimizar que mencionamos más arriba.

Ya veremos qué resultado nos da este performance y si la reducción de parámetros tiene algún impacto o diferencia muy notable en el resultado, o si, por el contrario, ambos resultados son similares.

Habiendo terminado el modelo GRU, el resultado sería el siguiente:

#Ejercicio de deep learning con GRU y RNN
model_file = "gru_model.h5" #HDF5 file
model_gru.save (os.path.join (cache_dir, model_file))

#Ejercicio de deep learning con GRU y RNN
scores = model_gru.evaluate (X_test, y_test, verbose = 0) #Returns loss and other metrics specified in model.compile ()
print ("Test accurary: ", scores [1]) #Scores [1] should correspond to accuracy if you passed in metrics = ['accuracy']

Test accuracy: 0.8521199822425842

Modelo RNN

Aquí lo que utilizamos es la arquitectura básica de una red recurrente, pero al final la estructura es la misma:

#Ejercicio de deep learning con GRU y RNN
embedding_size = 32
model_rnn = Sequential ()
model_rnn.add (Embedding (vocabulary_size, embedding_size, input_length = max_words))
model_rnn.add (SimpleleRNN (100))
model_rnn.add (Dense (1, activation = 'sigmoid'))

print (model_rnn.summary ())

Hacemos el compile:

#Ejercicio de deep learning con GRU y RNN
model_rnn.compile (loss = 'binary_crossentropy', optimizer = 'adam', metrics = ['accuracy'])

#Ejercicio de deep learning con GRU y RNN
batch_size = 64
num_epochs = 1

X_valid, y_valid = X_train [:batch_size], y_train [:batch_size] #first batch size samples
X_train2, y_train2 = X_train [:batch_size], y_train [:batch_size] #rest for training

model_rnn.fit (X_train2, y_train2, validation_data = (X_valid, y_valid), batch_size = batch_size, epochs = num_epochs)

#Ejercicio de deep learning con GRU y RNN
model_file = "rnn_model.h5" #HDF5 file
model_rnn.save (os.path.join (cache_dir, model_file))

#Ejercicio de deep learning con GRU y RNN
scores = model_rnn.evaluate (X_test, y_test, verbose = 0) #Returns loss and other metrics specified in model.compile ()
print ("Test accurary: ", scores [1]) #Scores [1] should correspond to accuracy if you passed in metrics = ['accuracy']

La GRU tiene un accuracy de 0.85; el LSTM tiene un accuracy de 0.84. Este es un resultado bastante alentador, porque significa que, aunque hayamos reducido parámetros de optimización, el performance es bueno. De hecho, es mucho mejor con GRU que con LSTM, que es con el que hemos trabajado en otros artículos.

¿Quieres seguir avanzando?

Ahora que hemos visto nuestro ejercicio de deep learning con GRU y RNN sobre análisis de sentimientos, podemos dar el siguiente paso en nuestro proceso formativo y continuar aprendiendo.

Para acceder a las opciones laborales del Big Data, una de las áreas tecnológocas mejor pagadas y con mayor demanda, tenemos para ti el Big Data, Inteligencia Artificial & Machine Learning Full Stack Bootcamp. Con esta formación íntegra, intensiva y de alta calidad adquirirás los conocimientos imprescindibles para conseguir tu trabajo perfecto en pocos meses. ¡No esperes más para impulsar tu vida y solicita información ahora!