TensorFlow / Python: Procesamiento de Lenguaje Natural con Redes Neuronales Recurrentes (RNN)

Este código es un ejemplo básico de cómo construir y entrenar una RNN para tareas de procesamiento de lenguaje natural, en este caso, la clasificación de sentimientos basados en datos de reseñas de películas de IMDB.

import tensorflow as tf
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense
from tensorflow.keras.preprocessing.text import Tokenizer
import numpy as np

# Cargar el conjunto de datos IMDB
num_words = 10000  # Seleccionar las 10,000 palabras más frecuentes
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=num_words)

# Preprocesamiento de datos
max_sequence_length = 100  # Limitar la longitud de las secuencias
x_train = pad_sequences(x_train, maxlen=max_sequence_length)
x_test = pad_sequences(x_test, maxlen=max_sequence_length)

# Construir el modelo
model = Sequential([
    Embedding(input_dim=num_words, output_dim=128, input_length=max_sequence_length),
    LSTM(128),
    Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Entrenar el modelo
model.fit(x_train, y_train, epochs=3, batch_size=64, validation_split=0.2)

# Evaluar el modelo
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Precisión en el conjunto de prueba: {test_acc * 100:.2f}%')

model.save('rnn_sentiment_model.h5')

Probar modelo:

# Cargar el modelo previamente entrenado
model = tf.keras.models.load_model('/content/rnn_sentiment_model.h5')  # Reemplaza 'rnn_sentiment_model.h5' con el nombre de tu archivo de modelo

# Imprimir las 10 primeras listas del conjunto de entrenamiento
for i in range(10):
    print(f"Secuencia {i + 1}: {x_train[i]}")


# Tus propias revisiones de películas
reviews = [
    "This movie was fantastic",
    "solid performances in this straightforward adaption",
    "brilliant documentary",
    "worst mistake of my life",
]

# Tokeniza tus revisiones utilizando el mismo Tokenizer que usaste para el modelo
tokenizer = Tokenizer(num_words=10000)  # Asegúrate de que coincida con el valor que usaste para entrenar el modelo
tokenizer.fit_on_texts(reviews)
sequences = tokenizer.texts_to_sequences(reviews)

# Asegúrate de que todas las secuencias tengan la misma longitud
max_sequence_length = 100  # Asegúrate de que coincida con el valor que usaste para entrenar el modelo
sequences = pad_sequences(sequences, maxlen=max_sequence_length)

# Realiza predicciones en tus propias revisiones
predictions = model.predict(sequences)

# Muestra las predicciones
for i, prediction in enumerate(predictions):
    sentiment = "positivo" if prediction > 0.5 else "negativo"
    print(f"Sentimiento de tu revisión {i + 1}: {sentiment} (Puntuación: {prediction[0]:.4f})")

El código anterior muestra cómo crear, entrenar y evaluar un modelo de análisis de sentimientos utilizando una red neuronal recurrente (RNN) con una capa LSTM en TensorFlow. Aquí una explicación con mas detalles:

  • Importación de bibliotecas: Se importan las bibliotecas necesarias, incluyendo TensorFlow y sus componentes, como datasets, preprocessing, models, y layers. También se importa Tokenizer de TensorFlow para preprocesar los datos y NumPy para manipulación numérica.
  • Carga del conjunto de datos IMDB: Se carga el conjunto de datos IMDB, que contiene revisiones de películas etiquetadas como positivas o negativas. Se limita el número de palabras a las 10,000 palabras más frecuentes utilizando el parámetro num_words.
  • Preprocesamiento de datos: Las secuencias de palabras en el conjunto de datos se ajustan a una longitud máxima de 100 utilizando pad_sequences. Esto asegura que todas las secuencias tengan la misma longitud, lo que es necesario para entrenar el modelo.
  • Construcción del modelo: Se crea un modelo secuencial, que es una secuencia lineal de capas. El modelo consta de las siguientes capas:
  • Embedding: Esta capa se encarga de transformar las secuencias de palabras en vectores densos de palabras. Tiene 10,000 palabras de entrada, cada una representada por un vector de 128 dimensiones.
  • LSTM: La capa LSTM es una capa de memoria a largo plazo que procesa la secuencia de entrada. Tiene 128 unidades (neuronas).
  • Dense: Capa de salida con una sola neurona y función de activación sigmoide, utilizada para predecir la polaridad de la revisión (positiva o negativa).
  • Compilación del modelo: Se compila el modelo especificando el optimizador (‘adam’), la función de pérdida (‘binary_crossentropy’ para problemas de clasificación binaria) y la métrica de precisión.
  • Entrenamiento del modelo: El modelo se entrena en el conjunto de entrenamiento durante 3 épocas con un tamaño de lote de 64. También se utiliza un 20% de los datos como conjunto de validación para evaluar el modelo durante el entrenamiento.
  • Evaluación del modelo: Una vez que el modelo ha sido entrenado, se evalúa su rendimiento en el conjunto de prueba y se muestra la precisión en el conjunto de prueba.
  • Guardado del modelo: El modelo entrenado se guarda en un archivo llamado ‘rnn_sentiment_model.h5’ para su posterior uso.

Es obvio tener en cuenta que el modelo entrenado es una versión básica con fines de demostración y es posible mejorar su precisión mediante varias estrategias, como entrenar con más muestras, ajustar hiperparámetros y utilizar modelos más complejos. Aquí hay algunas formas de mejorar la precisión:

  1. Aumentar el Tamaño del Conjunto de Datos: Entrenar con un conjunto de datos más grande generalmente mejora el rendimiento del modelo.
  2. Ajustar Hiperparámetros: Experimentar con diferentes valores de hiperparámetros, como la tasa de aprendizaje, el tamaño del lote, el número de unidades LSTM y las dimensiones de los vectores de palabras en la capa Embedding.
  3. Usar Modelos más Complejos: Considerar el uso de arquitecturas de modelos más avanzadas, como redes neuronales convolucionales (CNN) o modelos de atención, que pueden capturar características más ricas en los textos.
  4. Pre-entrenamiento de Embeddings: Utilizar embeddings pre-entrenados, como Word2Vec, GloVe o BERT, puede mejorar el rendimiento del modelo.
  5. Más Épocas de Entrenamiento: Entrenar durante más épocas puede permitir que el modelo converja a una solución óptima.

15 thoughts on “TensorFlow / Python: Procesamiento de Lenguaje Natural con Redes Neuronales Recurrentes (RNN)

  1. you are in reality a just right webmaster The site loading velocity is incredible It seems that you are doing any unique trick In addition The contents are masterwork you have performed a wonderful task on this topic

  2. I loved as much as you will receive carried out right here The sketch is tasteful your authored subject matter stylish nonetheless you command get got an edginess over that you wish be delivering the following unwell unquestionably come further formerly again as exactly the same nearly very often inside case you shield this hike

  3. you are in reality a just right webmaster The site loading velocity is incredible It seems that you are doing any unique trick In addition The contents are masterwork you have performed a wonderful task on this topic

  4. I loved as much as youll receive carried out right here The sketch is attractive your authored material stylish nonetheless you command get bought an nervousness over that you wish be delivering the following unwell unquestionably come more formerly again as exactly the same nearly a lot often inside case you shield this hike

Deja un comentario