Como facer o axuste fino dun LLM [e cando usar RAG ou prompts no seu lugar]

Facer o axuste fino dun modelo de linguaxe de gran tamaño (LLM) consiste en refinar un LLM preadestrado cun conxunto de datos pequeno e específico para unha tarefa, de modo que xere resultados que non se poden obter só con prompts.

O axuste fino implica reunir pares de exemplo de entrada/saída que mostren o comportamento que buscas, executar pasadas de adestramento que acheguen os pesos do modelo a eses exemplos e comparar o resultado coas saídas do modelo orixinal. Os métodos eficientes en parámetros, como LoRA, abaratan o proceso o suficiente para executalo nunha soa GPU.

Se non estás satisfeito cos resultados do LLM, perfecciona primeiro os teus prompts e a xeración aumentada por recuperación (RAG). O axuste fino cambia a forma en que se comporta o LLM. Cando necesites que use información recente ou propietaria, os prompts e a RAG adoitan ser unha opción mellor.

A continuación explicamos como facer o axuste fino dun LLM paso a paso, cales son os principais métodos de axuste fino (LoRA e QLoRA) e que retos e erros poden botar a perder o proceso.

Que é o axuste fino de LLM e en que se diferencia do preadestramento de LLM

O preadestramento dun LLM constrúe desde cero a capacidade lingüística xeral dun modelo a partir dun corpus enorme, mentres que o axuste fino dun LLM adapta un modelo preadestrado cun conxunto de datos pequeno para unha única tarefa.

O preadestramento de LLM é a fase que máis recursos consome e da que sae un modelo base. O modelo aprende dun amplo corpus de texto, o que lle proporciona gramática, coñecementos e capacidade de razoamento xerais, pero ningunha especialización para a túa tarefa.

O axuste fino de LLM continúa o adestramento do modelo base cun conxunto de datos pequeno e seleccionado coidadosamente para que produza os resultados desexados nunha tarefa ou caso de uso concretos. Pensa nun formato coherente, unha voz ou un ton de marca, patróns específicos dun dominio ou chamadas fiables a ferramentas e funcións.

Cando facer o axuste fino dun LLM e cando recorrer no seu lugar aos prompts ou á RAG

Para mellorar o rendemento dun LLM, sube chanzo a chanzo: prompts -> RAG -> axuste fino.

Perfecciona os teus prompts con instrucións máis detalladas e usa a RAG para darlle ao modelo información actualizada. Recorre ao axuste fino só cando as melloras nos prompts e na recuperación non dean resultado.

Cando uns prompts mellores superan o axuste fino e cando non abondan

Os prompts son a panca máis rápida e barata. En moitos casos, uns prompts máis precisos e detallados conseguen os cambios de comportamento desexados.

Porén, os prompts máis longos ralentizan o traballo e encarecen o proceso, e non poden superar as limitacións existentes do modelo.

Sinais de que os prompts poden ter chegado ao seu límite:

• Seguen aparecendo novos casos extremos que estragan a saída: Por exemplo, o modelo devolve prosa cando necesitas JSON ou desvíase do ton, e tes que parchear o prompt para cada caso novo.
• O prompt do sistema non para de medrar: O prompt chega a centos ou miles de liñas e resulta difícil de xestionar.
• Págalo en cada chamada: O prompt vólvese enviar e procesar en cada solicitude, polo que o custo en tokens e a latencia aumentan.
• Os cambios xa non marcan a diferenza: As novas instrucións non melloran os resultados.

Aínda así, proba primeiro as solucións máis baratas no propio prompt. Usa exemplos few-shot para mostrarlle o patrón ao modelo (pares de entrada/saída), o encadeamento de prompts para dividir tarefas complexas en pasos máis pequenos ou ganchos de chamada a funcións para delegar buscas exactas ou cálculos.

Cando ten máis sentido a RAG que o axuste fino do modelo

A RAG cambia o que sabe o LLM, mentres que o axuste fino cambia como se comporta. Se a carencia é de coñecemento, sobre todo dun coñecemento que cambia a miúdo ou que está nos teus propios documentos, a solución é a RAG. Se a carencia é de comportamento, fai un axuste fino.

O axuste fino tamén modifica o que sabe un modelo, pero calquera dato que absorba queda conxelado no momento do adestramento e perde vixencia axiña en campos que avanzan rápido. Ademais, a información queda incorporada nos pesos do modelo, que non gardan ningún rexistro da súa orixe.

Actualizar os documentos de orixe que usa unha capa de recuperación é máis rápido e barato, e esta pode citar as fontes exactas que utilizou. Isto convértea nunha opción mellor cando necesitas información actualizada e defendible.

O inconveniente da RAG? É unha capa adicional que hai que construír e manter, e engade latencia.

Na práctica, a miúdo necesitarás as dúas cousas. Os sistemas en produción combinan modelos con axuste fino e RAG: usan os primeiros para lograr un comportamento coherente e a segunda para os datos actuais.

Trampas, riscos e retos habituais do axuste fino

Mesmo cando o axuste fino é a ferramenta axeitada, ten custos e riscos:

• Custo e tempo: Reunir datos de adestramento limpos e representativos custa caro, e a computación necesaria para o adestramento tamén.
• Esquecemento catastrófico: Ao adestralo cun conxunto de datos limitado, un modelo pode perder capacidades xerais e adquirir novos modos de fallo, o que provoca erros que o modelo base non cometía.
• Sobreaxuste: Con moi poucos datos ou datos demasiado repetitivos, o modelo memoriza os teus exemplos de adestramento en lugar de aprender patróns, polo que funciona ben coas súas mostras de adestramento pero mal con entradas reais.
• Desfasamento: O coñecemento incorporado nos pesos quédase desfasado axiña, así que tes que volver adestrar o modelo con datos novos.
• Obsolescencia: Cando sae un modelo máis potente, adoita superar de serie o teu modelo axustado, e tes que repetir o traballo.
• Retos de avaliación e reprodución: Demostrar que o modelo axustado supera o modelo base é difícil. Ademais, dúas execucións de adestramento en GPU coa mesma configuración poden producir modelos lixeiramente diferentes.
• Gobernanza de datos: Adestrar con datos propietarios ou sensibles suscita cuestións de privacidade e licenzas; máis adiante, un modelo pode revelar fragmentos dos datos cos que foi adestrado.

Principais métodos de axuste fino

Os principais tipos de axuste fino de LLM diferéncianse pola parte do modelo que modifican: o axuste fino completo volve adestrar o modelo enteiro, mentres que os métodos de axuste fino eficiente en parámetros (PEFT), como LoRA e QLoRA, só actualizan algúns pesos. Os métodos PEFT consomen unha fracción da memoria que require o axuste fino completo e, coa configuración axeitada, poden igualar os seus resultados.

O axuste fino completo actualiza todos os pesos do modelo. É o método máis caro e o que comporta o maior risco de esquecemento catastrófico. Resérvao para grandes cambios de comportamento cando dispoñas dos datos e da capacidade de computación necesarios.

A alternativa é o axuste fino eficiente en parámetros, ou PEFT. É un termo xenérico para os métodos que conxelan a maior parte do modelo e só adestran un pequeno conxunto de parámetros. Usa moita menos memoria e é menos propenso ao esquecemento, xa que o modelo base permanece intacto.

Con rangos baixos, PEFT aprende menos ca un axuste fino completo, pero aumentar o rango e axustar a taxa de aprendizaxe reduce a maior parte da diferenza en tarefas de axuste por instrucións.

Entre os métodos PEFT están:

• LoRA (Low-Rank Adaptation, adaptación de rango baixo): É o punto de partida habitual. Conxela os pesos orixinais e adestra un pequeno conxunto de parámetros de adaptador engadidos, a miúdo menos do 1 % do total, polo que funciona nunha soa GPU de consumo.
• QLoRA (Quantized Low-Rank Adaptation, adaptación de rango baixo cuantizada): Comprime o modelo base a unha precisión de 4 bits antes de aplicar LoRA, o que permite facer o axuste fino dun modelo grande nunha soa GPU.

Ademais destes, usamos métodos de axuste por instrucións e por preferencias, desde RLHF (Reinforcement Learning from Human Feedback, aprendizaxe por reforzo a partir de retroalimentación humana) ata alternativas máis lixeiras, como Direct Preference Optimization (DPO) e Odds Ratio Preference Optimization (ORPO), para modelar como segue un modelo as instrucións e como se axusta ás preferencias humanas.

Como facer o axuste fino dun LLM paso a paso

Unha vez que decidas que o axuste fino dun LLM é a opción correcta, este é o fluxo de traballo.

Ampliar

Paso 1: Define a tarefa e como medirás o éxito

Decide que comportamento queres do LLM e como saberás que o conseguiches.

Indica a tarefa concreta que queres que realice o modelo axustado; por exemplo, clasificar incidencias de soporte, resumir contratos nun formato fixo ou xerar código co estilo propio da túa empresa.

Despois, define que é o éxito. Entre as opcións habituais están:

• Validez da saída: Por exemplo, o resultado pódese analizar como JSON válido ou coincide coa estrutura Markdown que necesitas?
• Puntuacións automatizadas: Usa métricas como BLEU ou ROUGE, que comparan o texto xerado con respostas de referencia, ou a precisión na tarefa sobre un conxunto etiquetado.
• Valoracións humanas: Unha rúbrica con puntuación ou de apto/non apto para calidades que un script avalía mal, como o ton ou a utilidade.
• Fiabilidade con entradas difíciles: Xestiona ben as entradas pouco habituais que facían fallar o modelo base?

Paso 2: Prepara o teu conxunto de datos

A calidade dos datos determina o éxito do axuste fino, así que esfórzate en reunir o conxunto de datos de axuste fino axeitado.

Dálles formato aos teus datos como pares de instrución/resposta en JSONL, onde cada liña contén a entrada (máis calquera contexto) e a saída exacta que queres obter.

Por exemplo, bota unha ollada a conxuntos de datos públicos de instrucións xerais, como Alpaca-cleaned ou Dolly de Databricks, ou a outros específicos para unha tarefa, como banking77, que inclúe máis de 13.000 consultas reais de soporte etiquetadas en 77 intencións.

Para unha tarefa concreta, entre uns centos e uns poucos miles de exemplos limpos e variados poden cambiar o comportamento, sempre que os exemplos reflictan entradas reais de produción, incluídos os casos extremos, e teñan un formato coherente.

Aínda non tes pares de entrada/saída? Crea o conxunto a partir dos datos que xa tes, como incidencias de soporte e as súas mellores respostas, ou documentos e os seus resumos.

Se só tes as saídas, usa un modelo máis potente para xerar unha entrada plausible para cada unha, ou escribe a man un pequeno conxunto inicial e amplíao cun modelo «mestre» máis grande; despois, queda cos mellores pares.

Para rematar, divide os datos en conxuntos de adestramento, validación e proba, para poder medir con exemplos que o modelo non viu.

Paso 3: Escolle un modelo base e un método

Comeza cun modelo pequeno de código aberto, de entre 3.000 e 7.000 millóns de parámetros, e un método de axuste fino eficiente en parámetros, como LoRA ou QLoRA.

Familias abertas como Llama, Mistral e Qwen ofrécenche unha base sólida que podes aloxar ti mesmo, e os métodos PEFT manteñen baixos os requisitos de hardware: QLoRA cuantiza a base a 4 bits, polo que o axuste fino dun modelo 7B só require unha tarxeta gráfica de consumo de 16-24 GB. O axuste fino completo do mesmo modelo necesita moitas veces esa cantidade de memoria.

Paso 4: Configura os hiperparámetros de adestramento

Estes son os principais parámetros de axuste fino de LLM e os intervalos iniciais suxeridos:

• A taxa de aprendizaxe controla o tamaño de cada actualización dos pesos. Un estudo de 2024 de Biderman et al. descubriu que as mellores taxas de LoRA eran aproximadamente dez veces máis altas que as do axuste fino completo: normalmente, de 5e-5 a 5e-4, fronte ao intervalo de 1e-5 a 5e-5. O estudo recomenda probar valores de 1e-5 a 5e-4 e usar o máis alto que permita un adestramento estable.
• O tamaño do lote é o número de exemplos dos que aprende o modelo antes de cada actualización dos pesos. Nunha soa GPU, usa un lote pequeno por dispositivo, de entre 1 e 8, e acumulación de gradientes para acadar un lote efectivo de entre 16 e 64, aproximadamente.
• O número de épocas indica cantas veces ve o modelo o conxunto de datos completo. Cando adestras o modelo para realizar tarefas específicas, entre 1 e 3 é unha boa regra xeral, pero as execucións con LoRA adoitan necesitar máis.
• O rango de LoRA (r) define a capacidade do adaptador, é dicir, canto pode aprender. Comeza con valores de entre 8 e 32 para tarefas máis sinxelas e auméntao para as máis complexas: no estudo sobre LoRA de Biderman et al. citado anteriormente, o axuste por instrucións dun modelo de 7B con código necesitou un rango de 256 para igualar o axuste fino completo, mentres que un rango de 64 quedou preto en matemáticas.
• A lonxitude máxima de secuencia é a entrada máis longa que procesará a execución. Axústaa para que abranga os teus exemplos máis longos, ata o límite da xanela de contexto do modelo, xa que todo o que sexa máis longo quedará truncado.
• O quecemento e a planificación controlan como aumenta e cambia a taxa de aprendizaxe ao longo da execución. Un quecemento curto e un decaemento de tipo coseno son os valores predeterminados habituais. Porén, o estudo sobre modelos pequenos de Pareja et al. descubriu que prescindir do quecemento non empeoraba as puntuacións finais.

Toma estes valores como puntos de partida para un varrido de parámetros, non como axustes fixos.

Paso 5: Adestra e supervisa a perda

Mentres se executa o adestramento, observa as curvas de perda de adestramento e de validación para comprobar se funciona.

A perda mide canto se afastan as saídas do modelo dos teus exemplos, e debería baixar de forma gradual conforme avanza a execución. A perda de adestramento abrangue os datos dos que aprende o modelo. A perda de validación calcúlase sobre os exemplos reservados.

Se a perda de adestramento e a de validación baixan á vez, o modelo está a aprender a xeneralizar. Se a perda de adestramento segue baixando pero a de validación estabilízase ou sobe, o modelo está a memorizar o conxunto de adestramento en lugar de aprender o patrón (sobreaxuste).

Ampliar

Paso 6: Avalía e despois desprega

Unha perda de adestramento baixa non garante que as saídas sexan correctas, así que avalía o modelo axustado segundo os criterios que estableciches no paso 1.

Cando supere a avaliación, tes dúas formas de despregalo:

• Serve o adaptador sobre o modelo base e carga ambos durante a execución; así, o adaptador segue sendo intercambiable.
• Fusiona o adaptador cos pesos base para obter un único modelo independente que resulta máis sinxelo de aloxar.

Usa Perplexity para darlle ao teu LLM acceso a información actualizada

O axuste fino é a opción axeitada cando queres adaptar o comportamento do modelo ás túas necesidades.

Se o teu modelo necesita información actual, especialmente información que cambia rapidamente, necesitas un sistema RAG ou unha ferramenta de busca de terceiros fiable.

Unha pila de recuperación personalizada funciona mellor con conxuntos de datos propios, como a túa wiki interna, o historial de atención ao cliente, os contratos ou a documentación dos produtos.

Cando o coñecemento que queres usar é público, non fai falta construír unha capa de recuperación a medida. Perplexity é un motor de respostas que ofrece respostas con citas integradas nas que se pode facer clic, procedentes dun índice web actualizado en tempo real. A súa Agent API proporciona esas respostas baseadas na web e con citas nunha soa chamada, para que a túa aplicación poida recorrer a fontes actuais.

Preguntas frecuentes sobre o axuste fino de LLM

Pódese facer o axuste fino dun LLM de balde?

Si, podes facer o axuste fino dun LLM aberto pequeno de balde. Por exemplo, o nivel gratuíto de Google Colab ofrece GPU dabondo para executar QLoRA nun modelo de entre 3B e 8B, o que é máis que suficiente para unha tarefa concreta. Comezas a pagar cando necesitas máis memoria, execucións máis longas ou un modelo base máis grande do que admite o nivel gratuíto.

Necesitas a túa propia GPU ou podes facer o axuste fino na nube?

Non necesitas ter unha GPU propia para facer o axuste fino de LLM. Os servizos xestionados e os provedores de GPU na nube alugan o hardware por horas, polo que unha soa GPU alugada abonda para unha execución de QLoRA cun modelo pequeno. Mercar unha GPU só compensa se fas axuste fino a miúdo ou se tes que manter todos os teus datos nas túas propias máquinas.

Canto tempo leva o axuste fino de LLM?

Cun LLM pequeno, unha execución pode rematar en minutos ou en poucas horas, dependendo do tamaño do conxunto de datos e do hardware. Oumi, por exemplo, fixo o axuste fino completo dun modelo de 0,8B en pouco máis dunha hora na súa plataforma aloxada.

Os modelos máis grandes ou as decenas de miles de exemplos alongan ese tempo ata un día ou máis: as execucións con LoRA de Emburse nun modelo de 7B levaron 8 horas para 5.000 exemplos e unhas 30 horas para 50.000 nunha soa GPU de 40 GB.

Pódese seguir actualizando un modelo axustado conforme cambian os teus datos?

Podes volver facer o axuste fino con datos novos, pero cada rolda consome recursos de cómputo e comporta risco de esquecemento catastrófico. Para coñecemento que cambia a miúdo, RAG adoita ser a mellor solución, xa que actualizas os documentos de orixe en lugar de volver adestrar o modelo.