Ejemplo de TensorFlow - Proyecto de clasificación de texto

La clasificación de texto es una tarea fundamental en el procesamiento del lenguaje natural (NLP), que consiste en clasificar automáticamente documentos de texto en una o más categorías predefinidas. En la práctica, la clasificación de texto se utiliza ampliamente para:

  • Detección de correo no deseado (spam)
  • Análisis de sentimientos
  • Clasificación de noticias
  • Clasificación de diálogos de atención al cliente
  • Clasificación de reseñas de productos

La implementación de clasificación de texto con TensorFlow generalmente incluye los siguientes pasos:

  1. Preparación y preprocesamiento de datos
  2. Vectorización de texto
  3. Construcción del modelo
  4. Entrenamiento del modelo
  5. Evaluación del modelo
  6. Implementación del modelo (deployment)

Preparación del entorno

Antes de comenzar el proyecto, asegúrate de tener instaladas las siguientes bibliotecas de Python:

!pip install tensorflow
!pip install numpy
!pip install pandas
!pip install matplotlib

Importar las bibliotecas necesarias:

Ejemplo

import tensorflow as tf
from tensorflow.keras import layers
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

Verificar la versión de TensorFlow:

Ejemplo

print(tf.__version__)
# Salida de ejemplo: 2.8.0

Preparación del conjunto de datos

Usaremos el conjunto de datos de reseñas de películas de IMDB, que es un conjunto de datos clásico de clasificación binaria que contiene 50,000 reseñas de películas, etiquetadas como positivas (1) o negativas (0).

Cargar el conjunto de datos

Ejemplo

# Cargar los datos de IMDB desde el conjunto de datos de TensorFlow
imdb = tf.keras.datasets.imdb

# Conservar solo las primeras 10000 palabras más frecuentes
(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)

Exploración de datos

Ver el formato de los datos:

Ejemplo

print("Número de muestras de entrenamiento: {}, Número de muestras de prueba: {}".format(len(train_data), len(test_data)))
# Salida: Número de muestras de entrenamiento: 25000, Número de muestras de prueba: 25000

# Ver la primera reseña
print(train_data[0])
# Salida: [1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, ...]

Preprocesamiento de datos

Convertir las secuencias de enteros a codificación multi-hot:

Ejemplo

def vectorize_sequences(sequences, dimension=10000):
    results = np.zeros((len(sequences), dimension))
    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1.
    return results

x_train = vectorize_sequences(train_data)
x_test = vectorize_sequences(test_data)

# Convertir las etiquetas a números de punto flotante
y_train = np.asarray(train_labels).astype('float32')
y_test = np.asarray(test_labels).astype('float32')

Construir el modelo

Arquitectura del modelo

Construiremos una red neuronal totalmente conectada simple:

Ejemplo

model = tf.keras.Sequential([
    layers.Dense(16, activation='relu', input_shape=(10000,)),
    layers.Dense(16, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

Compilación del modelo

Ejemplo

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

Descripción de parámetros:

  • optimizer: Optimizador, controla el proceso de aprendizaje
  • loss: Función de pérdida, mide la diferencia entre las predicciones del modelo y las etiquetas reales
  • metrics: Métrica de evaluación, supervisa los pasos de entrenamiento y prueba

Entrenar el modelo

Crear el conjunto de validación

Ejemplo

x_val = x_train[:10000]
partial_x_train = x_train[10000:]
y_val = y_train[:10000]
partial_y_train = y_train[10000:]

Proceso de entrenamiento

Ejemplo

history = model.fit(partial_x_train,
                    partial_y_train,
                    epochs=20,
                    batch_size=512,
                    validation_data=(x_val, y_val))

Visualización de los resultados del entrenamiento

Ejemplo

history_dict = history.history

# Dibujar la pérdida de entrenamiento y la pérdida de validación
plt.plot(history_dict['loss'], 'bo', label='Training loss')
plt.plot(history_dict['val_loss'], 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()

# Dibujar la precisión de entrenamiento y la precisión de validación
plt.plot(history_dict['accuracy'], 'bo', label='Training acc')
plt.plot(history_dict['val_accuracy'], 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

Evaluación del modelo y predicciones

Evaluar el rendimiento en el conjunto de prueba

Ejemplo

results = model.evaluate(x_test, y_test)
print(results)
# Salida de ejemplo: [0.3245, 0.8732] indica pérdida y precisión

Realizar predicciones

Ejemplo

predictions = model.predict(x_test)
print(predictions[0])  # Probabilidad de predicción de la primera muestra de prueba

Sugerencias para optimizar el modelo

  1. Ajustar la arquitectura de la red:

    • Aumentar o disminuir el número de capas ocultas
    • Probar diferentes cantidades de neuronas
    • Usar diferentes funciones de activación
  2. Técnicas de regularización:

    • Agregar capas de Dropout para evitar el sobreajuste
    • Usar regularización L1/L2
  3. Selección del optimizador:

    • Probar otros optimizadores como Adam, SGD, etc.
    • Ajustar la tasa de aprendizaje
  4. Mejora del preprocesamiento de texto:

    • Usar incrustaciones de palabras (Embedding) en lugar de codificación multi-hot
    • Probar vectores de palabras preentrenados (como Word2Vec, GloVe)

Ejemplo de código completo

Ejemplo

import tensorflow as tf
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt

# Cargar datos
imdb = tf.keras.datasets.imdb
(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)

# Preprocesamiento de datos
def vectorize_sequences(sequences, dimension=10000):
    results = np.zeros((len(sequences), dimension))
    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1.
    return results

x_train = vectorize_sequences(train_data)
x_test = vectorize_sequences(test_data)
y_train = np.asarray(train_labels).astype('float32')
y_test = np.asarray(test_labels).astype('float32')

# Construir el modelo
model = tf.keras.Sequential([
    layers.Dense(16, activation='relu', input_shape=(10000,)),
    layers.Dense(16, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

# Compilar el modelo
model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

# Entrenar el modelo
history = model.fit(x_train, y_train,
                   epochs=4,
                   batch_size=512,
                   validation_data=(x_test, y_test))

# Evaluar el modelo
results = model.evaluate(x_test, y_test)
print("Pérdida y precisión de prueba:", results)

# Realizar predicciones
predictions = model.predict(x_test)
print("Probabilidad de predicción de la primera reseña:", predictions[0])
Otras extensiones