Ejercicio sobre redes LSTM

Autor: | Última modificación: 12 de abril de 2024 | Tiempo de Lectura: 3 minutos
Temas en este post: ,

Algunos de nuestros reconocimientos:

Premios KeepCoding

Las redes LSTM (del inglés Long Short-Term Memory) son un tipo de red neuronal recurrente que se utiliza para procesar y modelar secuencias de datos. A continuación veremos la primera parte de un ejercicio sobre redes LSTM, donde realizaremos los algoritmos para determinar todas las combinaciones o patterns posibles.

En este post encontrarás: ocultar

Redes LSTM

#Ejercicio sobre redes LSTM
import string
import numpy as np

Lo primero que haremos será cargar los datos. Posteriormente, los separaremos en frases y eliminamos la puntuación:

#Ejercicio sobre redes LSTM
file = open ("merged_clean.txt", 'r', encoding = 'utf - 8').read ()
sentences = file.split ("\n")
table = str.maketrans (' ', ' ', string.punctuation)

for index, sentence in enumerate (sentences):
      if sentence == "":
            del sentences [index]

Trabajaremos con 1/9 parte de los datos, ya que nuestro dataset es muy grande y trabajarlo todo implicaría una labor de días enteros:

#Ejercicio sobre redes LSTM
size = int (len (sentences) / 9)
sentences = sentences [:size]

Ahora nos vamos a quedar con cada línea del dataset y en cada una de ellas vamos a quitar toda la puntuación que tenemos con el word translate. También convertiremos todo el texto a minúsculas.

#Ejercicio sobre redes LSTM
lines = [line.split () for line in sentences]

for line_index, line in enumerate (lines):
      for word_index, word in enumerate (line):
            lines [line_index] [word_index] = word.translate (table)

words = [word.lower () for line in lines for word in line]

Lo siguiente que haremos es generar el vocabulario y organizarlo en orden alfabético. Después, realizaremos una función que nos permita convertir los caracteres a enteros. Recordemos que las redes LSTM generan las predicciones tanto a nivel de palabra como a nivel de carácter. En este caso, las va a generar a nivel de palabra.

Los pasos siguientes son:

  • Calcular el número de caracteres .
  • Calcular el tamaño del vocabulario que tenemos.

Ahora solo nos resta ejecutar lo que llevamos:

#Ejercicio sobre redes LSTM
chars = sorted (list (set (words)))
char_to_int = dict ((c, i) for i, c in enumerate (chars))

#summarize the loaded data
n_chars = len (words)
n_vocab = len (chars)
print (f"Total Characters: {n_chars}")
print (f"Total Vocab: {n_vocab}")
Ejercicio sobre redes LSTM

Este es un vocabulario bastante reducido, si lo comparamos con otros con los que hemos trabajado; no obstante, es necesario trabajar con uno de este tamaño.

Ahora lo que haremos será generar los datos de entrenamiento y las etiquetas. Este paso es muy importante, porque es diferente a los algoritmos hechos con otros modelos, como el HMM. Lo que vamos a generar como dato X son las secuencias de datos del dataset en el tamaño de secuencia que nosotros digamos; en este caso, el tamaño es 20. ¿Qué significa este 20? Que vamos a generar datos de entrada de 20 palabras, o sea que con 20 palabras vamos a alimentar a la red para que haga sus iteraciones en las proyecciones.

Los datos de Y van a ser los propios datos de X, solo que los vamos a desplazar hacia la derecha. Al final lo que estamos intentando predecir es cuál será la siguiente palabra, de modo que nuestra etiqueta para un tiempo T va a ser la palabra de T +1, y así sucesivamente hasta los 20 caracteres. La palabra siguiente es la que vamos a usar como dato de entrada:

#Ejercicio sobre redes LSTM
seq_length = 20

data_X = [  ]
data_Y = [  ]

for i in range (0, n_chars - seq_length, 1):
      seq_in = words [ i : i + seq_length]
      seq_out = words [ i + seq_length]      
      data_X.append ([char_to_int [char] for char in seq_in])
      data_Y.append (char_to_int [seq_out])
Ejercicio sobre redes LSTM
#Ejercicio sobre redes LSTM
print (data_X [0])
print (data_Y [0])
redes LSTM

Aquí vemos que tenemos nuestro conjunto de 20 palabras y lo mismo sería para las etiquetas.

#Ejercicio sobre redes LSTM
n_patterns = len (data_X)
print (f"Total patterns: {n_patterns}")
Ejercicio sobre redes LSTM

Tenemos 271 mil patterns, es decir, de un dataset partido entre 9, dividido entre 20, lo que obtenemos son 271 mil combinaciones.

El siguiente paso sería generar la red.

¿Qué sigue?

Ahora que sabes qué son las redes LSTM y has visto su funcionamiento por medio de un ejercicio, es el momento de seguir formándote en alguna de las numerosas temáticas que tiene el demandado ámbito del Big Data. En KeepCoding te ofrecemos la posibilidad de aprender con los mejores profesionales, que te guiarán a través de la teoría y la práctica para que, en pocos meses, te transformes en un gran profesional. Échale un vistazo al temario de nuestro Big Data, Inteligencia Artificial & Machine Learning Full Stack Bootcamp y descubre esta formación intensiva e íntegra de alta calidad. ¡Solicita ya más información y da el paso que impulsará tu vida!

¡CONVOCATORIA ABIERTA!

Big Data, IA & Machine Learning

Full Stack Bootcamp

Clases en Directo | Profesores en Activo | Temario 100% actualizado