Típicamente hay tres etapas diferentes de entrenamiento para los modelos de lenguaje a gran escala:

1. Preentrenamiento: En esta etapa, el modelo se entrena en un gran corpus de datos de texto sin procesar para aprender a predecir el siguiente token o palabra. El resultado es un modelo base que ha adquirido mucho conocimiento general del texto, pero aún no es muy útil para tareas específicas.

2. Ajuste Fino Supervisado: Para hacer que el modelo base sea más útil, la segunda etapa es el ajuste fino supervisado. En esta etapa, el modelo se entrena en pares de preguntas-respuestas o pares de instrucciones-respuestas. La entrada es una pregunta o instrucción, y la salida es la respuesta o resultado deseado. Esta etapa permite que el modelo aprenda conocimientos y capacidades específicos de la tarea.

3. Alineación de Preferencias: La tercera etapa opcional es la alineación de preferencias, donde se entrena al modelo para aprender las preferencias del usuario en términos de respuestas, o para alinear el modelo con ciertos principios. Esto a menudo se hace utilizando técnicas como el Aprendizaje por Refuerzo a partir de Retroalimentación Humana (RLHF) o la Optimización de Políticas de Debate (DPO).

El objetivo de este video es centrarse en la etapa de ajuste fino supervisado, específicamente cómo ajustar el modelo Llama 3.1 utilizando la biblioteca Unsloth. El video cubrirá diferentes técnicas de ajuste fino, como el ajuste fino completo, LoRA y QLoRA, y discutirá los intercambios entre ellas en términos de rendimiento y requisitos de memoria.

Hay tres opciones populares para el ajuste fino supervisado:

1. Ajuste Fino Completo: En este enfoque, tomas el modelo original y actualizas los pesos con el conjunto de datos de ajuste fino de instrucciones. Esto te dará el mejor rendimiento, pero el requisito de VRAM será alto.

2. LoRA (Adaptación de Rango Bajo): En lugar de actualizar directamente los pesos, agregas adaptadores externos al modelo. El número de parámetros en estos adaptadores externos se puede controlar. Las actualizaciones de pesos para estos adaptadores se realizan con precisión de 16 bits y luego se fusionan de vuelta en los pesos originales del modelo. Este enfoque proporciona un entrenamiento rápido, pero sigue siendo costoso debido a las operaciones de 16 bits.

3. QLoRA (LoRA Cuantizado): Esto es similar a LoRA, pero las actualizaciones de pesos se realizan con precisión de 4 bits, y los pesos del modelo también se mantienen en 4 bits. Esto requiere menos VRAM, pero el rendimiento puede no ser tan bueno como LoRA o el ajuste fino completo.

Unsloth admite tanto LoRA como QLoRA para el ajuste fino. El rango de los adaptadores LoRA, el alfa de LoRA y el dropout de LoRA son hiperparámetros importantes que controlan el número de parámetros y la contribución de los adaptadores a los pesos finales del modelo.

Para configurar los adaptadores LoRA, hay algunos parámetros clave a considerar:

1. Rango: El rango de los adaptadores LoRA controla la cantidad de parámetros que se actualizarán durante el ajuste fino. Un rango más bajo significa menos parámetros, lo que reduce los requisitos de VRAM, pero también puede limitar la capacidad del modelo para adaptarse. Por el contrario, un rango más alto permite una mayor flexibilidad, pero requiere más VRAM.

2. Alfa de LoRA: Este parámetro controla la contribución de los adaptadores LoRA a los pesos finales del modelo. Un valor de alfa de LoRA más alto significa que los adaptadores LoRA tendrán una influencia más fuerte, mientras que un valor más bajo significa que tendrán una influencia más débil.

3. Dropout de LoRA: Este parámetro controla la tasa de dropout aplicada a los adaptadores LoRA durante el entrenamiento. Aumentar la tasa de dropout puede ayudar a prevenir el sobreajuste, pero también puede reducir el rendimiento del modelo.

Ajustando estos parámetros, puedes encontrar el equilibrio adecuado entre los requisitos de VRAM, la velocidad de entrenamiento y el rendimiento del modelo para tu caso de uso específico.

Para preparar los datos para el ajuste fino, necesitamos configurar la plantilla de indicación y especificar el token de fin de secuencia.

La plantilla de indicación es crucial, ya que define el formato de los datos de entrada con los que se entrenará el modelo. Para la familia Llama 3.1, utilizaremos la plantilla de indicación de Alpaca, que incluye una instrucción y una entrada que proporciona más contexto. Se espera que el modelo genere una respuesta apropiada.

# Plantilla de indicación de Alpaca
prompt_template = "A continuación se muestra una instrucción que describe una tarea junto con una entrada que proporciona más contexto. Responde con una salida relevante.\n\nInstrucción: {instruction}\nEntrada: {input}\nSalida:"

Además, necesitamos especificar el token de fin de secuencia para evitar que el modelo genere texto indefinidamente. Este es un paso importante que muchas personas han encontrado problemas al usar las versiones cuantizadas de los modelos con LamaCPP.

# Establecer el token de fin de secuencia
end_token = "</s>"

Al configurar la plantilla de indicación y el token de fin de secuencia, nos aseguramos de que los datos estén correctamente formateados para el proceso de ajuste fino, lo cual es un paso crucial para obtener buenos resultados.

Para entrenar el modelo, utilizaremos el Entrenador SFT (Ajuste Fino Supervisado) del paquete TRL, que es creado y mantenido por Hugging Face.

Primero, proporcionamos nuestro modelo, tokenizador y el conjunto de datos al Entrenador SFT. En este caso, estamos utilizando la columna text del conjunto de datos, ya que hemos configurado nuestra plantilla de indicación para usar este campo.

También establecemos la longitud máxima de la secuencia, que debe basarse en los ejemplos de tus datos de entrenamiento. Ten en cuenta que una mayor longitud de secuencia aumentará los requisitos de VRAM.

A continuación, configuramos los argumentos de entrenamiento, como el dispositivo (en este caso, una GPU T4 en Google Colab con aproximadamente 15GB de VRAM) y el número de pasos de entrenamiento.

Finalmente, ejecutamos el entrenador y puedes observar la pérdida decreciente, lo que es una buena indicación del progreso del entrenamiento.

El entrenamiento tardó aproximadamente 8 minutos, y la memoria reservada máxima fue de alrededor de 8GB, que es aproximadamente el 53% de la VRAM disponible en la GPU T4. Esto demuestra la eficiencia del enfoque de Unsloth, que permite el ajuste fino con un requisito de VRAM relativamente bajo.

Para realizar inferencia, podemos usar la clase o el método for_inference de la clase FastLanguageModel. Debemos proporcionar el modelo entrenado y el indicador de entrada en el formato de Alpaca. También podemos establecer el número máximo de tokens a generar.

# Realizar inferencia
input_prompt = alpaca_prompt(instruction, input)
output = model.for_inference(input_prompt, max_new_tokens=256)
print(output)

Para habilitar el streaming, podemos crear un objeto Streamer y pasarlo al método for_inference. Esto mostrará las respuestas un token a la vez.

# Habilitar el streaming
streamer = Streamer()
output = model.for_inference(input_prompt, max_new_tokens=256, streamer=streamer)

Con esto, ahora puedes realizar inferencia en tu modelo ajustado y, incluso, habilitar el streaming para una experiencia más interactiva.

Para guardar el modelo ajustado y el tokenizador, puedes usar la función save_pretrained() en el modelo y el tokenizador:

model.save_pretrained("ruta/para/guardar/modelo")
tokenizer.save_pretrained("ruta/para/guardar/tokenizador")

Esto guardará los pesos del modelo y el tokenizador en los directorios especificados como un conjunto de archivos JSON.

Para cargar el modelo y el tokenizador guardados, puedes usar la misma clase FastLanguageModel y proporcionar los directorios locales:

model = FastLanguageModel.from_pretrained("ruta/para/guardar/modelo")
tokenizer = FastLanguageModel.from_pretrained("ruta/para/guardar/tokenizador")

Esto cargará el modelo y el tokenizador desde los archivos guardados.

Otra gran característica de Unsloth es la capacidad de guardar los modelos en diferentes formatos, como precisión de punto flotante de 16 bits para VLLM o directamente en formato GGUF para LamaCPP. Esto permite una implementación y integración sencillas con varias plataformas y marcos de trabajo.

Unsloth también introduce una nueva interfaz de usuario basada en Gradio, que te permite ejecutar los modelos entrenados usando Unsloth y participar en sesiones de chat interactivas. Puedes clonar el repositorio de Unsloth Studio y ejecutar el cuaderno de Colab proporcionado para experimentar esta función.

Unsloth ha introducido una nueva interfaz de chat basada en la biblioteca Radish, que te permite interactuar fácilmente con los modelos de lenguaje entrenados usando Unsloth. Esta interfaz de chat proporciona una interfaz de usuario amigable para chatear con los modelos y explorar sus capacidades.

Para usar la interfaz de chat, puedes clonar el repositorio de Unsloth Studio y ejecutar el cuaderno de Google Colab proporcionado. Esto configurará el entorno necesario y lanzará la interfaz de chat, donde podrás comenzar a conversar con el modelo de lenguaje.

La interfaz de chat admite funciones como respuestas en streaming, lo que te permite ver la salida del modelo a medida que se genera. Esto puede ser útil para observar el proceso de pensamiento del modelo y cómo genera las respuestas.

Además, la interfaz de chat de Unsloth te permite guardar y cargar tus modelos ajustados, lo que facilita continuar trabajando con tus modelos de lenguaje personalizados. También puedes exportar tus modelos en varios formatos, como precisión de punto flotante de 16 bits para VLLM o formato GGUF para LamaCPP, lo que brinda flexibilidad en cómo utilizas y despliegas tus modelos.

En general, la nueva interfaz de chat de Unsloth es una herramienta valiosa para interactuar y explorar las capacidades de los modelos de lenguaje entrenados usando el marco de trabajo de Unsloth.