Image for post Generación de Texto con Hugging Face Transformers: Tu Primer Modelo Generativo en Python

Generación de Texto con Hugging Face Transformers: Tu Primer Modelo Generativo en Python

Escrito por Sergio Márquez

Contexto del Problema

En el mundo actual, la capacidad de las máquinas para generar texto coherente y relevante se ha vuelto fundamental. Desde asistentes virtuales que responden preguntas hasta herramientas que ayudan a redactar correos electrónicos o incluso a crear contenido creativo, la generación de texto impulsada por Inteligencia Artificial (IA) está transformando la forma en que interactuamos con la tecnología y la información.

Sin embargo, para muchos desarrolladores, adentrarse en este campo puede parecer intimidante. Los modelos de lenguaje suelen ser complejos, requieren grandes cantidades de datos y recursos computacionales, y su implementación desde cero es una tarea monumental. Aquí es donde entra en juego Hugging Face Transformers, una librería que ha democratizado el acceso a modelos de lenguaje de última generación, permitiendo a desarrolladores de todos los niveles integrar capacidades de generación de texto en sus aplicaciones con relativa facilidad.

Este artículo te guiará paso a paso para que puedas construir tu primer generador de texto utilizando Python y la librería Hugging Face Transformers, enfocándonos en modelos más pequeños y accesibles para que puedas experimentar sin necesidad de hardware especializado.

Conceptos Clave

Antes de sumergirnos en el código, es importante entender algunos conceptos fundamentales:

  • Modelos de Lenguaje (LLMs): Son modelos de IA entrenados en vastas cantidades de texto para predecir la siguiente palabra en una secuencia. Aprenden patrones gramaticales, sintácticos y semánticos, lo que les permite generar texto que imita el lenguaje humano. Aunque a menudo se habla de Large Language Models (LLMs) que son masivos, existen versiones más pequeñas y eficientes como GPT-2 o DistilGPT-2 que son excelentes para empezar.
  • Transformers: Es una arquitectura de red neuronal que revolucionó el Procesamiento del Lenguaje Natural (NLP). Su característica principal es el mecanismo de auto-atención, que permite al modelo ponderar la importancia de diferentes palabras en la secuencia de entrada al generar una salida, capturando dependencias a largo plazo de manera eficiente.
  • Pre-entrenamiento y Fine-tuning: Los modelos como GPT-2 se pre-entrenan en enormes corpus de texto para aprender una comprensión general del lenguaje. Luego, pueden ser fine-tuneados (ajustados) con datos más específicos para tareas o dominios particulares, aunque para la generación básica no siempre es necesario.
  • Tokenización: Antes de que un modelo de lenguaje pueda procesar texto, este debe ser convertido en una secuencia de números (tokens). Un tokenizer es la herramienta que se encarga de dividir el texto en unidades más pequeñas (palabras, subpalabras o caracteres) y mapearlas a IDs numéricos que el modelo entiende.
  • Librería Hugging Face transformers: Proporciona una interfaz unificada para cargar y usar miles de modelos pre-entrenados para diversas tareas de NLP. Ofrece clases como AutoModelForCausalLM (para modelos generativos) y AutoTokenizer, además de la conveniente función pipeline para tareas comunes.

Implementación Paso a Paso

Vamos a implementar un generador de texto básico utilizando el modelo distilgpt2, una versión más pequeña y rápida de GPT-2, ideal para empezar.

1. Instalación de la librería

Primero, asegúrate de tener Python instalado y luego instala la librería transformers y torch (o tensorflow si lo prefieres, pero usaremos PyTorch en este ejemplo) en tu entorno virtual:


pip install transformers torch

2. Carga del modelo y el tokenizer

Utilizaremos AutoTokenizer y AutoModelForCausalLM para cargar el modelo y su tokenizer asociado. Estos `Auto` clases son muy útiles porque detectan automáticamente la configuración correcta para el modelo que especifiques.


from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# Define el nombre del modelo. DistilGPT2 es una buena opción para empezar por su eficiencia.
model_name = "distilgpt2"

# Carga el tokenizer y el modelo pre-entrenado
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Opcional: Mueve el modelo a la GPU si está disponible para una inferencia más rápida
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

print(f"Modelo '{model_name}' cargado en {device}.")

3. Generación de texto básica

Ahora, vamos a generar texto. Necesitamos un prompt (texto de inicio), tokenizarlo, pasarlo al modelo y luego decodificar la salida.


# Tu prompt inicial
prompt = "Érase una vez en un reino muy lejano,"

# Tokeniza el prompt
input_ids = tokenizer.encode(prompt, return_tensors="pt").to(device)

# Genera texto. Aquí usamos parámetros básicos.
# max_length: longitud máxima del texto generado (incluyendo el prompt).
# num_return_sequences: número de secuencias independientes a generar.
output = model.generate(
    input_ids,
    max_length=50,
    num_return_sequences=1,
    pad_token_id=tokenizer.eos_token_id # Importante para evitar advertencias si el modelo no tiene un pad_token_id por defecto
)

# Decodifica el texto generado
generated_text = tokenizer.decode(output[0], skip_special_tokens=True)

print("--- Texto Generado ---")
print(generated_text)

4. Ajuste de parámetros de generación

La función model.generate() ofrece muchos parámetros para controlar la calidad y el estilo del texto generado.

  • max_length: La longitud máxima del texto generado, incluyendo el prompt.
  • do_sample: Si es True, habilita el muestreo para generar texto más diverso. Si es False, el modelo siempre elegirá la palabra más probable, lo que puede llevar a repeticiones.
  • temperature: Controla la aleatoriedad. Valores más altos (ej. 0.7-1.0) hacen el texto más creativo y menos predecible; valores más bajos (ej. 0.1-0.5) lo hacen más enfocado y conservador.
  • top_k: Limita la selección de la siguiente palabra a las k palabras con mayor probabilidad.
  • top_p (nucleus sampling): Selecciona las palabras cuya probabilidad acumulada suma al menos p. Esto permite una selección más dinámica del vocabulario.
  • num_beams: Utiliza la búsqueda por haces (beam search) para encontrar secuencias de alta probabilidad. Un valor mayor puede producir texto más coherente pero menos diverso.
  • repetition_penalty: Penaliza la repetición de tokens. Valores > 1.0 desalientan la repetición.

# Generación con parámetros avanzados para mayor creatividad y menos repetición
output_creative = model.generate(
    input_ids,
    max_length=100,
    num_return_sequences=1,
    do_sample=True,          # Habilitar muestreo
    temperature=0.9,         # Mayor aleatoriedad
    top_k=50,                # Considerar las 50 palabras más probables
    top_p=0.95,              # Muestreo de núcleo
    repetition_penalty=1.2,  # Penalizar repeticiones
    pad_token_id=tokenizer.eos_token_id
)

generated_text_creative = tokenizer.decode(output_creative[0], skip_special_tokens=True)

print("\n--- Texto Generado (Creativo) ---")
print(generated_text_creative)

5. Uso del pipeline para simplificar

La función pipeline de Hugging Face es una forma aún más sencilla de realizar tareas comunes de NLP, incluyendo la generación de texto.


from transformers import pipeline

# Crea un pipeline de generación de texto
generator = pipeline("text-generation", model=model_name, tokenizer=tokenizer, device=0 if torch.cuda.is_available() else -1)

# Genera texto usando el pipeline
# Puedes pasar los mismos parámetros de generación aquí
prompt_pipeline = "En un futuro no muy lejano,"
output_pipeline = generator(
    prompt_pipeline,
    max_length=80,
    num_return_sequences=1,
    do_sample=True,
    temperature=0.8,
    top_k=50,
    top_p=0.9,
    repetition_penalty=1.1
)

print("\n--- Texto Generado (con Pipeline) ---")
# El pipeline devuelve una lista de diccionarios, cada uno con la clave 'generated_text'
print(output_pipeline[0]['generated_text'])

Mini Proyecto / Aplicación Sencilla: Generador de Ideas para Historias

Crearemos un script de línea de comandos que toma un inicio de historia del usuario y genera varias continuaciones, permitiendo ajustar los parámetros de creatividad.


import argparse
from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
import torch
import os

def main():
    parser = argparse.ArgumentParser(description="Generador de ideas para historias con Hugging Face Transformers.")
    parser.add_argument("--prompt", type=str, required=True, help="El inicio de la historia (prompt).")
    parser.add_argument("--max_length", type=int, default=100, help="Longitud máxima del texto generado.")
    parser.add_argument("--num_sequences", type=int, default=3, help="Número de ideas de historia a generar.")
    parser.add_argument("--temperature", type=float, default=0.9, help="Temperatura para la aleatoriedad (0.1-1.0).")
    parser.add_argument("--top_k", type=int, default=50, help="Considerar las K palabras más probables.")
    parser.add_argument("--top_p", type=float, default=0.95, help="Muestreo de núcleo (probabilidad acumulada).")
    parser.add_argument("--repetition_penalty", type=float, default=1.2, help="Penalización por repetición.")
    parser.add_argument("--model_name", type=str, default="distilgpt2", help="Nombre del modelo a usar (ej. gpt2, distilgpt2).")

    args = parser.parse_args()

    print(f"Cargando modelo '{args.model_name}'...")
    # Carga el tokenizer y el modelo
    tokenizer = AutoTokenizer.from_pretrained(args.model_name)
    model = AutoModelForCausalLM.from_pretrained(args.model_name)

    # Configura el pad_token_id si no está definido para evitar advertencias
    if tokenizer.pad_token is None:
        tokenizer.add_special_tokens({'pad_token': tokenizer.eos_token})
        model.config.pad_token_id = tokenizer.eos_token_id

    # Mueve el modelo a la GPU si está disponible
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    # Crea el pipeline de generación de texto
    generator = pipeline(
        "text-generation",
        model=model,
        tokenizer=tokenizer,
        device=0 if torch.cuda.is_available() else -1 # -1 para CPU, 0 para GPU
    )

    print(f"\nGenerando {args.num_sequences} ideas de historia para el prompt: '{args.prompt}'")
    print("--------------------------------------------------")

    generated_stories = generator(
        args.prompt,
        max_length=args.max_length,
        num_return_sequences=args.num_sequences,
        do_sample=True,
        temperature=args.temperature,
        top_k=args.top_k,
        top_p=args.top_p,
        repetition_penalty=args.repetition_penalty,
        pad_token_id=tokenizer.eos_token_id
    )

    for i, story in enumerate(generated_stories):
        print(f"Idea {i+1}:")
        print(story['generated_text'])
        print("--------------------------------------------------")

if __name__ == "__main__":
    main()

Cómo ejecutar el Mini Proyecto:

Guarda el código anterior como generador_historias.py. Luego, ejecútalo desde tu terminal:


python generador_historias.py --prompt "Un detective privado en una ciudad futurista" --num_sequences 2 --temperature 0.95

Experimenta con diferentes prompts y parámetros para ver cómo cambia la creatividad y coherencia de las historias.

Errores Comunes y Depuración

Al trabajar con modelos de lenguaje, especialmente los generativos, es común encontrarse con algunos desafíos:

  • CUDA out of memory: Este error ocurre cuando intentas cargar un modelo demasiado grande o generar secuencias muy largas en una GPU con memoria limitada.
    • Solución: Reduce max_length, disminuye num_return_sequences, o utiliza un modelo más pequeño (como distilgpt2 en lugar de gpt2). Si estás fine-tuneando, reduce el batch_size.
  • Generación repetitiva o sin sentido: Si el texto generado se repite constantemente o carece de coherencia, es probable que los parámetros de muestreo no estén bien ajustados.
    • Solución: Asegúrate de que do_sample=True. Experimenta con temperature (valores más altos para más creatividad), top_k y top_p. Aumenta repetition_penalty (ej. 1.2 o 1.5).
  • Advertencias sobre pad_token_id: Algunos modelos no tienen un token de padding definido por defecto, lo que puede generar advertencias durante la generación.
    • Solución: Define explícitamente pad_token_id=tokenizer.eos_token_id en la llamada a model.generate() o generator(), o añade un token de padding al tokenizer si es necesario.
  • ImportError o dependencias faltantes: Si te encuentras con errores al importar módulos, es posible que te falten librerías adicionales.
    • Solución: Asegúrate de haber instalado todas las dependencias necesarias. Por ejemplo, algunos modelos pueden requerir sentencepiece o accelerate. Consulta la documentación del modelo específico en Hugging Face Hub.
  • Errores de conexión al descargar modelos: Si estás en un entorno con restricciones de red, la descarga de modelos puede fallar.
    • Solución: Intenta ejecutar en modo offline si los archivos ya están en caché, o verifica tu conexión a internet y la configuración del proxy.

Recuerda que los tracebacks de Python se leen de abajo hacia arriba, y la última línea suele contener la información más relevante sobre el error.

Aprendizaje Futuro / Próximos Pasos

Has dado tus primeros pasos en la generación de texto con Hugging Face. Aquí hay algunas ideas para seguir explorando:

  • Explorar otros modelos: Hugging Face Hub tiene miles de modelos. Prueba con gpt2 (más grande que distilgpt2), facebook/opt-125m, o modelos multilingües. Ten en cuenta que los modelos más grandes requieren más recursos.
  • Fine-tuning de modelos: Para tareas muy específicas (ej. generar reseñas de productos, código), puedes fine-tunear un modelo pre-entrenado con tus propios datos. Esto requiere más conocimiento y recursos, pero puede mejorar drásticamente la relevancia del texto generado.
  • Evaluación de modelos generativos: ¿Cómo saber si un modelo genera buen texto? Existen métricas como BLEU o ROUGE, aunque la evaluación humana sigue siendo crucial para la calidad y coherencia.
  • Integración con frameworks web: Construye una API con FastAPI para exponer tu generador de texto como un servicio web.
  • Consideraciones éticas: La generación de texto plantea importantes cuestiones éticas, como el sesgo en los datos de entrenamiento, la desinformación, la propiedad intelectual y la transparencia. Es crucial ser consciente de estos aspectos al desarrollar y desplegar aplicaciones de IA generativa.

La generación de texto es un campo en constante evolución. ¡Sigue experimentando y construyendo!

Volver al blog