LangChain 101 Parte 2c. Ajuste fino de LLMs con PEFT, LORA y RL

Ajuste y perfección de LLMs con PEFT, LORA y RL en LangChain 101 Parte 2c

Para comprender mejor este artículo, echa un vistazo a la parte anterior, donde discuto sobre los grandes modelos de lenguaje:

LangChain 101: Parte 2ab. Todo lo que necesitas saber sobre (grandes modelos de lenguaje)

Esta es la parte 2ab del curso LangChain 101. Se recomienda fuertemente revisar la primera parte para comprender el…

pub.towardsai.net

Si te interesa langchain y los grandes modelos de lenguaje, considera visitar la primera parte de la serie:

• Análisis avanzado de datos con GPT-4 Guía para principiantes sobre gráficos y mapas
• ChatGPT es increíble pero sobrevalorado
• Potenciando los juegos a otro nivel Sports Vision AI, una startup para transmitir atletismo en todo el mundo

LangChain 101: Parte 1. Construyendo una aplicación sencilla de preguntas y respuestas

En este artículo, te introduciré a los conceptos básicos de LangChain, un marco para crear aplicaciones con grandes…

pub.towardsai.net

Sigue al autor para no perderte la siguiente parte 🙂

En aprendizaje automático y ciencia de datos, un modelo oscuro que hace predicciones a menudo se denomina modelo. Existen diferentes modelos y uno de ellos es un modelo de lenguaje. Los modelos de lenguaje existían desde hace algún tiempo, pero no fueron tan populares como lo son actualmente desde que apareció ChatGPT. Una de las razones es que el modelo GPT-1 fue entrenado con una pequeña cantidad de datos. A medida que los números después de GPT crecieron, también lo hizo la cantidad de datos, lo que llevó a la aparición de los modelos de lenguaje grandes, o LLM, como se les llama con más frecuencia.

Ajuste Fino del Modelo

El ajuste fino del modelo, también conocido como transfer learning, es una técnica de aprendizaje automático utilizada para mejorar el rendimiento de un modelo preexistente en una tarea específica mediante su entrenamiento adicional con nuevos datos relacionados con esa tarea. El ajuste fino se utiliza comúnmente en escenarios donde un modelo pre-entrenado ha aprendido representaciones valiosas de un dominio general (en nuestro caso, el lenguaje natural) y se adapta para funcionar bien en una tarea más estrecha y específica.

He escuchado muchas preguntas: ¿vale la pena ajustar fino un modelo de lenguaje grande? ¿Por qué no usar prompts – parecen estar bien. ¿Puedo utilizar vectores en su lugar? Y otras preguntas relacionadas con el tema…

Imagina la siguiente situación: tienes que ir al dentista. ¿A quién preferirías?:

• Una persona que se presenta como dentista (prompt: “Imagina que eres un dentista…”)
• Una persona que ha leído toda la literatura sobre el cuidado dental (usando vectores)
• Un dentista que ha sido entrenado para realizar operaciones dentales (modelo ajustado finamente)

El público a quien le hablé, definitivamente eligió la última opción (PyData y encuentros de ciencia de datos)

PEFT: El Ajuste Fino Eficiente de Parámetros

PEFT, o Ajuste Fino Eficiente de Parámetros, es un método que mejora el rendimiento de los modelos de lenguaje pre-entrenados sin ajustar fino todos los parámetros del modelo. Esto lo convierte en una forma mucho más eficiente y rentable de ajustar fino los LLM, especialmente para modelos grandes con cientos de miles de millones o billones de parámetros.

PEFT funciona congelando algunas de las capas del modelo pre-entrenado y solo ajustando fino las últimas capas específicas para la tarea a realizar. Esto se basa en la observación de que las capas inferiores de los LLM tienden a ser más generales y menos específicas de la tarea, mientras que las capas superiores son más especializadas para la tarea en la que se entrenó el LLM. Es el clásico aprendizaje por transferencia.

Aquí tienes un ejemplo de cómo PEFT se puede usar para ajustar finamente un LLM para una tarea de clasificación de texto:

1. Congela las primeras capas del LLM pre-entrenado.
2. Ajusta finamente las capas descongeladas del LLM en un conjunto de datos más pequeño de texto etiquetado.
3. El modelo se ajusta finamente y se puede probar en datos invisibles.

LoRa – La Adaptación de Bajo Rango de la que Todos Hablan

LoRa, o Low-Rank Adaptation, es una técnica de ajuste fino que puede adaptar modelos de lenguaje grandes (LLMs) a tareas o dominios específicos sin entrenar todos los parámetros del modelo. LoRa no modifica la arquitectura del transformador actual de ninguna forma fundamental. LoRa congela los pesos del modelo pre-entrenado e inyecta matrices de descomposición de rango entrenables en cada capa de la arquitectura del transformador.

LORA funciona adaptando los pesos de un modelo de transformador pre-entrenado a una tarea o dominio específico mediante la descomposición de la diferencia entre los pesos originales pre-entrenados y los pesos ajustados finamente deseados en dos matrices más pequeñas de bajo rango. Estas dos matrices se ajustan finamente en lugar del conjunto completo de parámetros del modelo. Esto puede reducir el número de parámetros entrenables en 10,000 veces, logrando aún un rendimiento comparable al ajuste fino de parámetros completos. Durante el ajuste fino, LORA actualiza los pesos de las capas de incrustación y proyección de bajo rango, como es habitual en la ciencia de datos, minimizando la función de pérdida.

Ahora, ¿cuál es la diferencia entre PEFT y LoRa? PEFT es un método que emplea diversas técnicas, incluido LoRa, para ajustar finamente modelos de lenguaje grandes de manera eficiente.

Este enfoque tiene varias ventajas:

1. Es más eficiente en tiempo que el ajuste fino de parámetros completos, especialmente para modelos de transformador grandes.
2. Es más eficiente en memoria, lo que permite el ajuste fino de modelos en dispositivos con memoria limitada.
3. Es más controlado el ajuste fino, ya que las matrices de bajo rango codifican conocimientos o restricciones específicas.

Aprendizaje por Reforzamiento

El aprendizaje por reforzamiento (RL) es otra forma de ajustar finamente modelos. Requiere dos copias del modelo original. Una copia es el modelo activo, entrenado para realizar la tarea deseada. La otra copia es el modelo de referencia, que se utiliza para generar logits (la salida no normalizada del modelo) que restringen el entrenamiento del modelo activo.

¿Cómo Genera Texto un LLM?

Este artículo no discutirá los transformadores ni cómo se entrenan los modelos de lenguaje grandes. En cambio, nos concentraremos en el uso…

pub.towardsai.net

El requisito de tener dos copias del modelo puede ser un desafío, especialmente para modelos grandes en términos de GPU. Sin embargo, esta restricción es necesaria para evitar que el modelo activo se desvíe demasiado de su comportamiento original, ya que los algoritmos de RL pueden dar lugar a modelos que generan salidas inesperadas o dañinas.

Recorramos el proceso de ajuste fino:

1. El modelo de referencia se inicializa con los parámetros del modelo de lenguaje pre-entrenado.
2. El modelo activo comienza a entrenar utilizando el aprendizaje por refuerzo.
3. En cada paso de optimización, se calculan los logitos de los modelos activo y de referencia (log-probs).
4. A continuación, se calcula la función de pérdida utilizando los logitos de los modelos activo y de referencia (métrica KL).
5. Los parámetros del modelo activo se actualizan utilizando los gradientes de la función de pérdida o la optimización de políticas proximal.

¡Hora de codificar!

El código completo está disponible en GitHub.

Comenzaremos importando peft y preparándolo para ajuste fino.

from peft import prepare_model_for_kbit_trainingpretrained_model.gradient_checkpointing_enable()model = prepare_model_for_kbit_training(pretrained_model)

Configuraremos los parámetros de LoraConfig y utilizaremos el método get_peft_model para crear un PeftModel:

• r: El rango de las matrices de baja rango representa la diferencia entre los pesos pre-entrenados originales y los pesos ajustados fino deseados. Un valor más alto de r permite que LORA aprenda relaciones más complejas entre los parámetros, pero también será más computacionalmente costoso.
• lora_alpha: Un hiperparámetro que controla el compromiso entre la función de pérdida para la tarea posterior y la función de pérdida para preservar los pesos pre-entrenados originales. Un valor más alto de lora_alpha dará más peso a la función de pérdida para proteger los pesos pre-entrenados iniciales.
• target_modules: Una lista de los nombres de los módulos en el modelo que deben ajustarse fino con LORA.
• lora_dropout: La tasa de abandono a aplicar a las matrices de baja rango durante el entrenamiento.
• bias: El tipo de sesgo a utilizar en las matrices de baja rango. Las opciones válidas son “none”, “shared” e “individual”.
• task_type: El tipo de tarea para la que se está ajustando fino el modelo. Las opciones válidas son “CAUSAL_LM” y “CLASSIFICATION”.

from peft import LoraConfig, get_peft_modelconfig = LoraConfig(    r=16,    lora_alpha=32,    target_modules=["query_key_value"],    lora_dropout=0.05,    bias="none",    task_type="CAUSAL_LM",)model = get_peft_model(model, config)

Ahora es el momento de configurar la clase Trainer:

• data_collator: Una función que se utiliza para agrupar los datos de entrenamiento en lotes.
• per_device_train_batch_size: El tamaño del lote por GPU.
• gradient_accumulation_steps: El número de pasos para acumular gradientes antes de actualizar los parámetros del modelo. Esto se puede utilizar para reducir el uso de memoria y mejorar la velocidad de entrenamiento.
• warmup_ratio: La proporción de pasos de entrenamiento dedicados a un calentamiento lineal de la tasa de aprendizaje.
• fp16: Si se debe utilizar entrenamiento de precisión de 16 punto flotante (FP16). Esto puede mejorar la velocidad de entrenamiento y reducir el uso de memoria.
• logging_steps: El número de pasos de entrenamiento entre actualizaciones de registro.
• output_dir: El directorio donde se guardarán el modelo entrenado y otros artefactos de entrenamiento.
• optim: El optimizador a utilizar para entrenar el modelo. Las opciones válidas son “adamw”, “sgd” y “paged_adamw_8bit”.
• lr_scheduler_type: El programador de la tasa de aprendizaje a utilizar. Las opciones válidas son “cosine”, “linear” y “constant”.

trainer = transformers.Trainer(    model=model,    train_dataset=train_dataset,    # eval_dataset=val_dataset,    args=transformers.TrainingArguments(num_train_epochs=10, per_device_train_batch_size=8, gradient_accumulation_steps=4, warmup_ratio=0.05, max_steps=40, learning_rate=2.5e-4, fp16=True, logging_steps=1, output_dir="outputs", optim="paged_adamw_8bit", lr_scheduler_type="cosine",), data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),)

Todo lo que nos queda es empezar el entrenamiento:

trainer.train()

Ahora podemos usar el modelo de inmediato con input_ids tokenizados o guardarlo para su uso posterior:

trained_model = (    trainer.model.module if hasattr(trainer.model, "module") else trainer.model)  # Cuidar del entrenamiento distribuido/paralelotrained_model.generate(input_ids)# Guardar el modelotrained_model.save_pretrained("outputs")

Recordatorio: El código completo está disponible en GitHub.

Es el fin de la Parte 2c. La siguiente parte (de) estará dedicada a afinar modelos utilizando retroalimentación humana.

LangChain 101: Parte 1. Construyendo una Aplicación de Preguntas y Respuestas Simple

En este artículo, te presentaré los conceptos básicos de LangChain, un marco de trabajo para construir aplicaciones con grandes…

pub.towardsai.net

LangChain 101: Parte 2ab. Todo lo que Necesitas Saber sobre (Grandes Modelos de Lenguaje)

Esta es la parte 2ab del curso LangChain 101. Se recomienda encarecidamente revisar la primera parte para entender los…

pub.towardsai.net

Aplaudir y seguirme, ya que esto me motiva a escribir nuevos artículos y te permite saber cuándo se publica la siguiente parte.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!