El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Proyecto de Procesamiento de Lenguaje Natural

Siguiente ►
►

En este módulo, aplicaremos los conocimientos adquiridos en los módulos anteriores para construir un proyecto de procesamiento de lenguaje natural (NLP) utilizando PyTorch. Este proyecto se centrará en la clasificación de texto, una tarea común en NLP.

Objetivos del Proyecto

  1. Preprocesamiento de Datos de Texto: Aprender a limpiar y preparar datos de texto para su uso en modelos de NLP.
  2. Construcción de un Modelo de Clasificación de Texto: Crear y entrenar una red neuronal para clasificar texto.
  3. Evaluación del Modelo: Evaluar el rendimiento del modelo utilizando métricas adecuadas.
  4. Implementación y Uso del Modelo: Guardar el modelo entrenado y utilizarlo para hacer predicciones en nuevos datos.

Paso 1: Preprocesamiento de Datos de Texto

1.1 Carga de Datos

Primero, necesitamos un conjunto de datos de texto. Para este proyecto, utilizaremos el conjunto de datos de comentarios de películas de IMDb, que contiene comentarios etiquetados como positivos o negativos.

import pandas as pd

# Cargar el conjunto de datos
url = "https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz"
df = pd.read_csv(url, compression='gzip', header=0, sep='\t', quotechar='"')

# Mostrar las primeras filas del conjunto de datos
print(df.head())

1.2 Limpieza de Datos

El siguiente paso es limpiar los datos de texto. Esto incluye la eliminación de caracteres especiales, la conversión a minúsculas y la eliminación de palabras irrelevantes (stop words).

import re
import nltk
from nltk.corpus import stopwords

nltk.download('stopwords')
stop_words = set(stopwords.words('english'))

def clean_text(text):
    # Eliminar caracteres especiales y convertir a minúsculas
    text = re.sub(r'\W', ' ', text)
    text = text.lower()
    # Eliminar stop words
    text = ' '.join([word for word in text.split() if word not in stop_words])
    return text

df['cleaned_text'] = df['text'].apply(clean_text)
print(df['cleaned_text'].head())

1.3 Tokenización y Vectorización

Convertimos el texto limpio en una representación numérica que pueda ser utilizada por el modelo. Utilizaremos la técnica de Bag of Words para este propósito.

from sklearn.feature_extraction.text import CountVectorizer

vectorizer = CountVectorizer(max_features=5000)
X = vectorizer.fit_transform(df['cleaned_text']).toarray()
y = df['label'].values

print(X.shape)
print(y.shape)

Paso 2: Construcción de un Modelo de Clasificación de Texto

2.1 Definición del Modelo

Definimos una red neuronal simple utilizando PyTorch.

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

class TextClassifier(nn.Module):
    def __init__(self, input_dim):
        super(TextClassifier, self).__init__()
        self.fc1 = nn.Linear(input_dim, 100)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(100, 2)
    
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

input_dim = X.shape[1]
model = TextClassifier(input_dim)

2.2 Entrenamiento del Modelo

Entrenamos el modelo utilizando el conjunto de datos preprocesado.

# Convertir los datos a tensores
X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.long)

# Crear DataLoader
dataset = TensorDataset(X_tensor, y_tensor)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# Definir la función de pérdida y el optimizador
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Entrenar el modelo
num_epochs = 5
for epoch in range(num_epochs):
    for inputs, labels in dataloader:
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

Paso 3: Evaluación del Modelo

3.1 Evaluación en el Conjunto de Prueba

Evaluamos el rendimiento del modelo en un conjunto de prueba separado.

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

# Dividir los datos en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Convertir los datos de prueba a tensores
X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
y_test_tensor = torch.tensor(y_test, dtype=torch.long)

# Evaluar el modelo
model.eval()
with torch.no_grad():
    outputs = model(X_test_tensor)
    _, predicted = torch.max(outputs.data, 1)
    accuracy = accuracy_score(y_test_tensor, predicted)
    print(f'Accuracy: {accuracy:.4f}')
    print(classification_report(y_test_tensor, predicted))

Paso 4: Implementación y Uso del Modelo

4.1 Guardar el Modelo

Guardamos el modelo entrenado para su uso futuro.

torch.save(model.state_dict(), 'text_classifier.pth')

4.2 Cargar y Usar el Modelo

Cargamos el modelo guardado y lo utilizamos para hacer predicciones en nuevos datos.

# Cargar el modelo
model = TextClassifier(input_dim)
model.load_state_dict(torch.load('text_classifier.pth'))
model.eval()

# Predecir en nuevos datos
new_text = ["This movie was fantastic! I loved it."]
new_text_cleaned = [clean_text(text) for text in new_text]
new_text_vectorized = vectorizer.transform(new_text_cleaned).toarray()
new_text_tensor = torch.tensor(new_text_vectorized, dtype=torch.float32)

with torch.no_grad():
    outputs = model(new_text_tensor)
    _, predicted = torch.max(outputs.data, 1)
    print(f'Predicted label: {predicted.item()}')

Conclusión

En este proyecto, hemos cubierto los pasos esenciales para construir un modelo de clasificación de texto utilizando PyTorch. Desde la carga y preprocesamiento de datos hasta la construcción, entrenamiento y evaluación del modelo, hemos aplicado técnicas fundamentales de NLP y aprendizaje profundo. Este proyecto proporciona una base sólida para abordar problemas más complejos en el campo del procesamiento de lenguaje natural.

Resumen de Conceptos Clave

  • Preprocesamiento de Datos de Texto: Limpieza, tokenización y vectorización.
  • Construcción de Modelos: Definición y entrenamiento de una red neuronal simple.
  • Evaluación del Modelo: Uso de métricas de rendimiento para evaluar la precisión del modelo.
  • Implementación del Modelo: Guardar y cargar modelos para su uso en predicciones futuras.

Próximos Pasos

  • Experimentar con diferentes arquitecturas de redes neuronales.
  • Probar técnicas avanzadas de NLP como Word Embeddings y Transformers.
  • Aplicar el modelo a diferentes conjuntos de datos y tareas de NLP.

¡Felicidades por completar este proyecto de procesamiento de lenguaje natural con PyTorch!

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados