Una guía completa para ajustar modelos de lenguajes grandes

Grandes modelos de idiomas (LLM) como GPT-4, LaMDA, PaLM y otros han conquistado el mundo con su notable capacidad para comprender y generar texto similar al humano sobre una amplia gama de temas. Estos modelos están previamente entrenados en conjuntos de datos masivos que comprenden miles de millones de palabras de Internet, libros y otras fuentes.

Esta fase de preentrenamiento dota a los modelos de un amplio conocimiento general sobre el lenguaje, temas, habilidades de razonamiento e incluso ciertos sesgos presentes en los datos de entrenamiento. Sin embargo, a pesar de su increíble amplitud, estos LLM previamente capacitados carecen de experiencia especializada para dominios o tareas específicas.

Aquí es donde entra en juego el ajuste: el proceso de adaptar un LLM previamente capacitado para sobresalir en una aplicación o caso de uso particular. Al entrenar aún más el modelo en un conjunto de datos más pequeño y específico para una tarea, podemos ajustar sus capacidades para alinearlas con los matices y requisitos de ese dominio.

El ajuste fino es análogo a transferir el amplio conocimiento de un generalista altamente capacitado para crear un experto en la materia especializado en un campo determinado. En esta guía, exploraremos el qué, el porqué y el cómo de perfeccionar los LLM.

Ajuste de modelos de lenguaje grandes

¿Qué es el ajuste fino?

En su centro, sintonia FINA Implica tomar un modelo grande previamente entrenado y actualizar sus parámetros mediante una segunda fase de entrenamiento en un conjunto de datos adaptado a su tarea o dominio objetivo. Esto permite que el modelo aprenda e interiorice los matices, patrones y objetivos específicos de esa área más limitada.

Si bien la capacitación previa captura una comprensión amplia del lenguaje a partir de un corpus de texto enorme y diverso, el ajuste especializa esa competencia general. Es como tomar a un hombre del Renacimiento y convertirlo en un experto de la industria.

Los pesos del modelo previamente entrenado, que codifican su conocimiento general, se utilizan como punto de partida o inicialización para el proceso de ajuste. Luego, el modelo se entrena más, pero esta vez con ejemplos directamente relevantes para la aplicación final.

Al exponer el modelo a esta distribución de datos especializada y ajustar los parámetros del modelo en consecuencia, hacemos que el LLM sea más preciso y efectivo para el caso de uso objetivo, sin dejar de beneficiarnos de las amplias capacidades previamente capacitadas como base.

¿Por qué perfeccionar los LLM?

Hay varias razones clave por las que es posible que desee ajustar un modelo de lenguaje grande:

1. Personalización del dominio: Cada campo, desde el derecho hasta la medicina y la ingeniería de software, tiene sus propias convenciones de lenguaje, jerga y contextos matizados. El ajuste fino le permite personalizar un modelo general para comprender y producir texto adaptado al dominio específico.
2. Especialización de tareas: Los LLM se pueden ajustar para diversas tareas de procesamiento del lenguaje natural, como resúmenes de texto, traducción automática, respuesta a preguntas, etc. Esta especialización aumenta el rendimiento en la tarea objetivo.
3. Cumplimiento de datos: Las industrias altamente reguladas, como la atención médica y las finanzas, tienen requisitos estrictos de privacidad de datos. El ajuste permite capacitar a los LLM sobre datos organizacionales patentados y al mismo tiempo proteger la información confidencial.
4. Datos etiquetados limitados: Obtener grandes conjuntos de datos etiquetados para entrenar modelos desde cero puede resultar un desafío. El ajuste permite lograr un sólido desempeño en tareas a partir de ejemplos supervisados ​​limitados aprovechando las capacidades del modelo previamente entrenado.
5. Actualización del modelo: A medida que con el tiempo aparecen nuevos datos disponibles en un dominio, puede ajustar aún más los modelos para incorporar los últimos conocimientos y capacidades.
6. Mitigar los sesgos: Los LLM pueden detectar sesgos sociales a partir de datos amplios previos a la capacitación. El ajuste de conjuntos de datos seleccionados puede ayudar a reducir y corregir estos sesgos indeseables.

En esencia, el ajuste fino cierra la brecha entre un modelo amplio y general y los requisitos específicos de una aplicación especializada. Mejora la precisión, la seguridad y la relevancia de los resultados del modelo para casos de uso específicos.

Ajuste de modelos de lenguaje grandes

Enfoques de ajuste

Existen dos estrategias principales cuando se trata de ajustar modelos de lenguaje grandes:

1) Ajuste completo del modelo

En el enfoque de ajuste completo, todos los parámetros (pesos y sesgos) del modelo previamente entrenado se actualizan durante la segunda fase de entrenamiento. El modelo está expuesto al conjunto de datos etiquetados de tarea específica y el proceso de entrenamiento estándar optimiza todo el modelo para esa distribución de datos.

Esto permite que el modelo realice ajustes más completos y se adapte de manera integral a la tarea o dominio objetivo. Sin embargo, un ajuste completo tiene algunas desventajas:

• Requiere importantes recursos computacionales y tiempo para entrenar, similar a la fase de preentrenamiento.
• Los requisitos de almacenamiento son altos, ya que es necesario mantener una copia separada y ajustada del modelo para cada tarea.
• Existe el riesgo de un "olvido catastrófico", donde el ajuste fino hace que el modelo pierda algunas capacidades generales aprendidas durante el entrenamiento previo.

A pesar de estas limitaciones, el ajuste completo sigue siendo una técnica poderosa y ampliamente utilizada cuando los recursos lo permiten y la tarea objetivo difiere significativamente del lenguaje general.

2) Métodos eficientes de ajuste

Para superar los desafíos computacionales del ajuste completo, los investigadores han desarrollado estrategias eficientes que solo actualizan un pequeño subconjunto de los parámetros del modelo durante el ajuste. Estas técnicas paramétricamente eficientes logran un equilibrio entre la especialización y la reducción de los requisitos de recursos.

Algunos métodos populares de ajuste eficiente incluyen:

Ajuste de prefijo: Aquí, se introduce y entrena una pequeña cantidad de vectores o "prefijos" específicos de la tarea para condicionar la atención del modelo previamente entrenado a la tarea objetivo. Sólo estos prefijos se actualizan durante el ajuste fino.

LoRA (adaptación de bajo rango): lora inyecta matrices entrenables de bajo rango en cada capa del modelo previamente entrenado durante el ajuste fino. Estos pequeños ajustes de rango ayudan a especializar el modelo con muchos menos parámetros entrenables que el ajuste fino completo.

Claro, puedo proporcionar una explicación detallada de LoRA (adaptación de bajo rango) junto con la formulación matemática y ejemplos de código. LoRA es una técnica popular de ajuste fino eficiente en parámetros (PEFT) que ha ganado un impulso significativo en el campo de la adaptación de modelos de lenguaje grande (LLM).

¿Qué es LoRA?

LoRA es un método de ajuste fino que introduce una pequeña cantidad de parámetros entrenables en el LLM previamente entrenado, lo que permite una adaptación eficiente a las tareas posteriores y al mismo tiempo preserva la mayor parte del conocimiento del modelo original. En lugar de ajustar todos los parámetros del LLM, LoRA inyecta matrices de bajo rango específicas de la tarea en las capas del modelo, lo que permite importantes ahorros computacionales y de memoria durante el proceso de ajuste.

Formulación matemática

LoRA (adaptación de bajo rango) es un método de ajuste fino para modelos de lenguaje grandes (LLM) que introduce una actualización de bajo rango en las matrices de peso. Para una matriz de peso 0∈W0 ∈Rd×k, LoRA agrega una matriz de bajo rango $BA$, con las A∈Rr×k y B∈Rd×r, Donde $r$ es el rango. Este enfoque reduce significativamente la cantidad de parámetros entrenables, lo que permite una adaptación eficiente a tareas posteriores con recursos computacionales mínimos. La matriz de peso actualizada está dada por W=W0 +B⋅A.

Esta actualización de rango bajo se puede interpretar como una modificación de la matriz de peso original $W_{0}$ agregando una matriz de rango bajo $BA$. La ventaja clave de esta formulación es que en lugar de actualizar todos los parámetros $d \times k$ en $W_{0}$, LoRA solo necesita optimizar los parámetros $r \times (d + k)$ en $A$ y $B. $, lo que reduce significativamente la cantidad de parámetros entrenables.

Aquí hay un ejemplo en Python usando el peft Biblioteca para aplicar LoRA a un LLM previamente capacitado para clasificación de texto:

</div>
<div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color="">from</span> transformers <span class="token" data-darkreader-inline-color="">import</span> AutoModelForSequenceClassification
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color="">from</span> peft <span class="token" data-darkreader-inline-color="">import</span> get_peft_model<span class="token" data-darkreader-inline-color="">,</span> LoraConfig<span class="token" data-darkreader-inline-color="">,</span> TaskType
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Load pre-trained model</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">model <span class="token" data-darkreader-inline-color="">=</span> AutoModelForSequenceClassification<span class="token" data-darkreader-inline-color="">.</span>from_pretrained<span class="token" data-darkreader-inline-color="">(</span><span class="token" data-darkreader-inline-color="">"bert-base-uncased"</span><span class="token" data-darkreader-inline-color="">,</span> num_labels<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">2</span><span class="token" data-darkreader-inline-color="">)</span>
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Define LoRA configuration</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">peft_config <span class="token" data-darkreader-inline-color="">=</span> LoraConfig<span class="token" data-darkreader-inline-color="">(</span>task_type<span class="token" data-darkreader-inline-color="">=</span>TaskType<span class="token" data-darkreader-inline-color="">.</span>SEQ_CLS<span class="token" data-darkreader-inline-color="">, </span>r<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">8</span><span class="token" data-darkreader-inline-color="">,</span>  <span class="token" data-darkreader-inline-color=""># Rank of the low-rank update</span>
lora_alpha<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">16</span><span class="token" data-darkreader-inline-color="">,</span></code><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Scaling factor for the low-rank update</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">    target_modules<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">[</span><span class="token" data-darkreader-inline-color="">"q_lin"</span><span class="token" data-darkreader-inline-color="">,</span> <span class="token" data-darkreader-inline-color="">"v_lin"</span><span class="token" data-darkreader-inline-color="">]</span><span class="token" data-darkreader-inline-color="">,</span>  <span class="token" data-darkreader-inline-color=""># Apply LoRA to the query and value layers</span>
<span class="token" data-darkreader-inline-color="">)</span>
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Create the LoRA-enabled model</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">model <span class="token" data-darkreader-inline-color="">=</span> get_peft_model<span class="token" data-darkreader-inline-color="">(</span>model<span class="token" data-darkreader-inline-color="">,</span> peft_config<span class="token" data-darkreader-inline-color="">)</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Fine-tune the model with LoRA</span>
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># ... (training code omitted for brevity)</span></code></div>
</div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">

En este ejemplo, cargamos un modelo BERT previamente entrenado para la clasificación de secuencias y definimos una configuración LoRA. El r El parámetro especifica el rango de la actualización de rango bajo, y lora_alpha es un factor de escala para la actualización. El target_modules El parámetro indica qué capas del modelo deben recibir las actualizaciones de bajo rango. Después de crear el modelo habilitado para LoRA, podemos continuar con el proceso de ajuste utilizando el procedimiento de capacitación estándar.

Capas adaptadoras: Similar a LoRA, pero en lugar de actualizaciones de bajo rango, se insertan capas delgadas de "adaptadores" dentro de cada bloque transformador del modelo previamente entrenado. Solo se entrenan los parámetros de estas pocas capas compactas nuevas.

Sintonización rápida: Este enfoque mantiene el modelo previamente entrenado congelado por completo. En su lugar, se introducen incorporaciones “rápidas” entrenables como entrada para activar el conocimiento previamente entrenado del modelo para la tarea objetivo.

Estos métodos eficientes pueden proporcionar reducciones informáticas de hasta 100 veces en comparación con un ajuste fino completo, y al mismo tiempo lograr un rendimiento competitivo en muchas tareas. También reducen las necesidades de almacenamiento al evitar la duplicación completa del modelo.

Sin embargo, su desempeño puede ir a la zaga de un ajuste completo para tareas que son muy diferentes del lenguaje general o que requieren una especialización más holística.

El proceso de ajuste fino

Independientemente de la estrategia de ajuste, el proceso general para especializar un LLM sigue un marco general:

1. Preparación del conjunto de datos: Necesitará obtener o crear un conjunto de datos etiquetados que asigne entradas (solicitudes) a las salidas deseadas para su tarea objetivo. Para tareas de generación de texto como el resumen, esto sería texto de entrada en pares de salida resumidos.
2. División de conjuntos de datos: Siguiendo las mejores prácticas, divida su conjunto de datos etiquetados en conjuntos de entrenamiento, validación y prueba. Esto separa los datos para el entrenamiento del modelo, el ajuste de hiperparámetros y la evaluación final.
3. Ajuste de hiperparámetros: Es necesario ajustar parámetros como la tasa de aprendizaje, el tamaño del lote y el programa de capacitación para lograr el ajuste más efectivo de sus datos. Por lo general, esto implica un pequeño conjunto de validación.
4. Entrenamiento de modelos: utilizando los hiperparámetros ajustados, ejecute el proceso de optimización de ajuste fino en el conjunto de entrenamiento completo hasta que el rendimiento del modelo en el conjunto de validación deje de mejorar (detención anticipada).
5. Evaluación: Evalúe el rendimiento del modelo ajustado en el conjunto de pruebas disponible, que idealmente comprende ejemplos del mundo real para el caso de uso objetivo, para estimar la eficacia en el mundo real.
6. Implementación y monitoreo: Una vez satisfactorio, el modelo ajustado se puede implementar para realizar inferencias sobre nuevas entradas. Es crucial monitorear su desempeño y precisión a lo largo del tiempo para detectar cambios de concepto.

Si bien esto describe el proceso general, muchos matices pueden afectar el éxito del ajuste para un LLM o tarea en particular. Estrategias como el aprendizaje curricular, el ajuste de múltiples tareas y las indicaciones breves pueden mejorar aún más el rendimiento.

Además, los métodos de ajuste eficientes implican consideraciones adicionales. Por ejemplo, LoRA requiere técnicas como condicionar los resultados del modelo previamente entrenado a través de una capa de combinación. La sintonización rápida necesita indicaciones cuidadosamente diseñadas para activar los comportamientos correctos.

Ajuste avanzado: incorporación de la retroalimentación humana

Si bien el ajuste estándar supervisado utilizando conjuntos de datos etiquetados es efectivo, una frontera interesante es capacitar a los LLM directamente utilizando preferencias y comentarios humanos. Este enfoque humano-in-the-loop aprovecha técnicas del aprendizaje por refuerzo:

OPP (Optimización de políticas proximales): Aquí, el LLM se trata como un agente de aprendizaje por refuerzo, y sus resultados son "acciones". Se entrena un modelo de recompensa para predecir calificaciones humanas o puntajes de calidad para estos resultados. Luego, PPO optimiza el LLM para generar resultados que maximicen las puntuaciones del modelo de recompensa.

RLHF (Aprendizaje por refuerzo a partir de la retroalimentación humana): Esto amplía PPO al incorporar directamente la retroalimentación humana en el proceso de aprendizaje. En lugar de un modelo de recompensa fija, las recompensas provienen de evaluaciones humanas iterativas de los resultados del LLM durante el ajuste.

Si bien requieren un uso intensivo de computación, estos métodos permiten moldear el comportamiento de LLM con mayor precisión en función de las características deseadas evaluadas por los humanos, más allá de lo que se puede capturar en un conjunto de datos estáticos.

Empresas como Anthropic utilizaron RLHF para dotar a sus modelos lingüísticos como Claude de mayor veracidad, ética y conciencia de seguridad más allá de la simple competencia en la tarea.

Riesgos potenciales y limitaciones

Si bien los LLM son inmensamente poderosos, el ajuste fino no está exento de riesgos que deben gestionarse cuidadosamente:

Amplificación de polarización: Si los datos de ajuste contienen sesgos sociales en torno al género, la raza, la edad u otros atributos, el modelo puede amplificar estos sesgos indeseables. Es fundamental seleccionar conjuntos de datos representativos y no sesgados.

Deriva fáctica: Incluso después de realizar ajustes con datos de alta calidad, los modelos de lenguaje pueden "alucinar" hechos incorrectos o resultados inconsistentes con los ejemplos de entrenamiento en conversaciones o indicaciones más largas. Es posible que se necesiten métodos de recuperación de hechos.

Desafíos de escalabilidad: El ajuste completo de modelos enormes como GPT-3 requiere inmensos recursos informáticos que pueden resultar inviables para muchas organizaciones. Un ajuste eficiente mitiga parcialmente esto, pero tiene sus ventajas y desventajas.

Olvido catastrófico: Durante el ajuste completo, los modelos pueden experimentar un olvido catastrófico, donde pierden algunas capacidades generales aprendidas durante el entrenamiento previo. Es posible que sea necesario el aprendizaje multitarea.

Riesgos de propiedad intelectual y privacidad: Los datos de propiedad utilizados para el ajuste pueden filtrarse en los resultados del modelo de lenguaje publicados públicamente, lo que plantea riesgos. Las técnicas diferenciales de mitigación de riesgos de información y privacidad son áreas activas de investigación.

En general, si bien es excepcionalmente útil, el ajuste es un proceso matizado que requiere atención a la calidad de los datos, consideraciones de identidad, mitigación de riesgos y equilibrio entre rendimiento y eficiencia en función de los requisitos del caso de uso.

El futuro: personalización del modelo de lenguaje a escala

De cara al futuro, los avances en las técnicas de ajuste y adaptación de modelos serán cruciales para desbloquear todo el potencial de los grandes modelos de lenguaje en diversas aplicaciones y dominios.

Métodos más eficientes que permitan ajustar modelos aún más grandes como PaLM con recursos limitados podrían democratizar el acceso. La automatización de los procesos de creación de conjuntos de datos y la ingeniería rápida podrían agilizar la especialización.

Las técnicas autosupervisadas para realizar ajustes a partir de datos sin procesar y sin etiquetas pueden abrir nuevas fronteras. Y los enfoques compositivos para combinar submodelos ajustados entrenados en diferentes tareas o datos podrían permitir la construcción de modelos altamente personalizados bajo demanda.

En última instancia, a medida que los LLM se vuelvan más ubicuos, la capacidad de personalizarlos y especializarlos sin problemas para cada caso de uso imaginable será fundamental. El ajuste y las estrategias de adaptación de modelos relacionados son pasos fundamentales para hacer realidad la visión de grandes modelos de lenguaje como asistentes de IA flexibles, seguros y potentes que aumentan las capacidades humanas en todos los dominios y esfuerzos.