8.2 Creación del Modelo

En esta sección, nos centraremos en crear el modelo autoregresivo para nuestro proyecto de generación de texto. Usaremos el modelo GPT-2, un modelo bien conocido basado en Transformers, que ha demostrado ser altamente efectivo para tareas de generación de texto. Aprovecharemos la biblioteca Hugging Face Transformers para cargar y configurar el modelo GPT-2 según nuestras necesidades específicas.

8.2.1 Cargando el Modelo GPT-2 Preentrenado

El primer paso en la creación del modelo es cargar un modelo GPT-2 preentrenado. Usar un modelo preentrenado nos permite beneficiarnos de las vastas cantidades de datos con las que el modelo ya ha sido entrenado, facilitando su ajuste fino para nuestra tarea específica.

Ejemplo: Cargando el Modelo GPT-2 Preentrenado

from transformers import GPT2LMHeadModel, GPT2Tokenizer

# Load the GPT-2 tokenizer and model
tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
model = GPT2LMHeadModel.from_pretrained("gpt2")

# Print the model architecture
model.summary()

8.2.2 Configuración del Modelo para el Ajuste Fino

Para adaptar el modelo GPT-2 a nuestra tarea de generación de texto, necesitamos configurarlo para el ajuste fino. Esto implica configurar los parámetros de entrenamiento y asegurarnos de que la arquitectura del modelo se alinee con nuestros datos.

Configuraciones Clave:

Tasa de Aprendizaje: Determina qué tan rápido el modelo ajusta sus pesos durante el entrenamiento.
Tamaño del Lote: Número de muestras de entrenamiento utilizadas en una iteración.
Número de Épocas: Número de veces que el modelo recorrerá todo el conjunto de datos de entrenamiento.

Ejemplo: Configuración del Modelo para el Ajuste Fino

from transformers import Trainer, TrainingArguments

# Define training arguments
training_args = TrainingArguments(
    output_dir='./results',
    overwrite_output_dir=True,
    num_train_epochs=3,
    per_device_train_batch_size=2,
    save_steps=10_000,
    save_total_limit=2,
    logging_dir='./logs',
)

# Print training arguments to verify configuration
print(training_args)

El código utiliza la clase TrainingArguments de la biblioteca 'transformers' para definir varios parámetros de entrenamiento importantes:

output_dir especifica el directorio donde se almacenarán las salidas del entrenamiento (como el modelo entrenado).
overwrite_output_dir es un parámetro booleano que, cuando se establece en 'True', permite que el script sobrescriba los archivos existentes en el directorio de salida.
num_train_epochs determina el número de pasadas (épocas) sobre todos los datos de entrenamiento.
per_device_train_batch_size define el número de ejemplos por lote de datos para el entrenamiento. Esto puede afectar tanto la velocidad del entrenamiento como la calidad del modelo.
save_steps determina después de cuántos pasos se guardará el punto de control del modelo.
save_total_limit limita la cantidad total de puntos de control que se pueden mantener en el disco.
logging_dir es el directorio para almacenar los registros generados durante el entrenamiento.

Después de definir estos argumentos, el script los imprime para verificar sus valores antes de proceder con el entrenamiento. Esto ayuda a asegurar que los parámetros estén configurados como se pretende y puede ser particularmente útil al solucionar problemas u optimizar el proceso de entrenamiento.

8.2.3 Creación de un Conjunto de Datos Personalizado para el Ajuste Fino

Para ajustar finamente el modelo, necesitamos crear un conjunto de datos personalizado que se pueda alimentar en la API Trainer proporcionada por la biblioteca Hugging Face Transformers. Este conjunto de datos utilizará los datos de texto preprocesados que preparamos anteriormente.

Ejemplo: Creación de un Conjunto de Datos Personalizado

import torch
from torch.utils.data import Dataset

class TextDataset(Dataset):
    def __init__(self, sequences):
        self.sequences = sequences

    def __len__(self):
        return len(self.sequences)

    def __getitem__(self, idx):
        item = torch.tensor(self.sequences[idx])
        return {"input_ids": item, "labels": item}

# Create an instance of the custom dataset
train_dataset = TextDataset(training_sequences)

# Print the first example from the dataset
print(train_dataset[0])

Este ejemplo importa las bibliotecas necesarias y define una clase de conjunto de datos de texto personalizada utilizando PyTorch. La clase, TextDataset, recibe una lista de secuencias como entrada. Tiene tres métodos principales: __init__, __len__ y __getitem__.

__init__ inicializa la clase con la entrada de secuencias. __len__ devuelve el número total de secuencias en el conjunto de datos. __getitem__ permite que la clase sea indexada, devolviendo un diccionario con las claves 'input_ids' y 'labels', ambas con el mismo tensor de secuencia como valor.

Después de la definición de la clase, se crea una instancia del conjunto de datos usando 'training_sequences' y se imprime el primer elemento del conjunto de datos.

8.2.4 Inicialización del Entrenador

La API Trainer simplifica el proceso de entrenamiento al manejar muchos de los detalles involucrados en el entrenamiento y la evaluación del modelo. Inicializaremos el Trainer con nuestro modelo, argumentos de entrenamiento y conjunto de datos personalizado.

Ejemplo: Inicialización del Entrenador

# Initialize the Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
)

# Print the Trainer configuration to verify initialization
print(trainer)

8.2.5 Ajuste Fino del Modelo

Con el Trainer inicializado, ahora podemos ajustar finamente el modelo GPT-2 en nuestro conjunto de datos personalizado. El ajuste fino implica entrenar el modelo con los nuevos datos mientras se aprovechan los pesos preentrenados para mejorar el rendimiento en la tarea específica.

Ejemplo: Ajuste Fino del Modelo

# Fine-tune the GPT-2 model
trainer.train()