Un guide complet pour affiner les grands modèles de langage

Grands modèles de langage (LLM) comme GPT-4, LaMDA, PaLM et d'autres ont pris d'assaut le monde grâce à leur capacité remarquable à comprendre et à générer du texte de type humain sur une vaste gamme de sujets. Ces modèles sont pré-entraînés sur des ensembles de données massifs comprenant des milliards de mots provenant d'Internet, de livres et d'autres sources.

Cette phase de pré-formation confère aux modèles des connaissances générales approfondies sur le langage, les sujets, les capacités de raisonnement et même certains biais présents dans les données de formation. Cependant, malgré leur incroyable diversité, ces LLM pré-formés manquent d’expertise spécialisée dans des domaines ou des tâches spécifiques.

C'est là qu'intervient le réglage fin : le processus d'adaptation d'un LLM pré-formé pour exceller dans une application ou un cas d'utilisation particulier. En entraînant davantage le modèle sur un ensemble de données plus petit et spécifique à une tâche, nous pouvons ajuster ses capacités pour les aligner sur les nuances et les exigences de ce domaine.

La mise au point équivaut au transfert des vastes connaissances d'un généraliste hautement qualifié pour former un expert en la matière spécialisé dans un domaine donné. Dans ce guide, nous explorerons le quoi, le pourquoi et le comment du réglage fin des LLM.

Affiner les grands modèles de langage

Qu'est-ce que le réglage fin ?

En son coeur, réglage fin implique de prendre un grand modèle pré-entraîné et de mettre à jour ses paramètres à l'aide d'une deuxième phase de formation sur un ensemble de données adapté à votre tâche ou domaine cible. Cela permet au modèle d’apprendre et d’intérioriser les nuances, les modèles et les objectifs spécifiques à ce domaine plus restreint.

Alors que la pré-formation permet d'acquérir une compréhension linguistique large à partir d'un corpus de textes vaste et diversifié, le réglage fin spécialise cette compétence générale. Cela revient à prendre un homme de la Renaissance et à en faire un expert de l’industrie.

Les poids du modèle pré-entraîné, qui codent ses connaissances générales, sont utilisés comme point de départ ou d'initialisation pour le processus de réglage fin. Le modèle est ensuite entraîné davantage, mais cette fois sur des exemples directement pertinents pour l'application finale.

En exposant le modèle à cette distribution de données spécialisée et en ajustant les paramètres du modèle en conséquence, nous rendons le LLM plus précis et plus efficace pour le cas d'utilisation cible, tout en bénéficiant des vastes capacités pré-entraînées comme base.

Pourquoi affiner les LLM ?

Il existe plusieurs raisons principales pour lesquelles vous souhaiterez peut-être affiner un modèle de langage étendu :

1. Personnalisation du domaine: Chaque domaine, du droit à la médecine en passant par le génie logiciel, a ses propres conventions linguistiques, jargon et contextes nuancés. Le réglage fin vous permet de personnaliser un modèle général pour comprendre et produire un texte adapté au domaine spécifique.
2. Spécialisation des tâches: Les LLM peuvent être ajustés pour diverses tâches de traitement du langage naturel telles que le résumé de texte, la traduction automatique, la réponse aux questions, etc. Cette spécialisation améliore les performances sur la tâche cible.
3. Conformité des données: Les secteurs hautement réglementés comme la santé et la finance ont des exigences strictes en matière de confidentialité des données. Le réglage fin permet de former les LLM sur des données organisationnelles propriétaires tout en protégeant les informations sensibles.
4. Données étiquetées limitées: Obtenir de grands ensembles de données étiquetés pour les modèles de formation à partir de zéro peut s'avérer difficile. Le réglage fin permet d'obtenir de solides performances de tâches à partir d'exemples supervisés limités en tirant parti des capacités du modèle pré-entraîné.
5. Mise à jour du modèle: À mesure que de nouvelles données deviennent disponibles au fil du temps dans un domaine, vous pouvez affiner davantage les modèles pour intégrer les dernières connaissances et capacités.
6. Atténuer les préjugés: Les LLM peuvent détecter les préjugés sociétaux à partir de vastes données préalables à la formation. Un réglage fin des ensembles de données sélectionnés peut aider à réduire et à corriger ces biais indésirables.

Essentiellement, le réglage fin comble le fossé entre un modèle général et large et les exigences ciblées d’une application spécialisée. Il améliore la précision, la sécurité et la pertinence des résultats du modèle pour les cas d'utilisation ciblés.

Affiner les grands modèles de langage

Approches de réglage fin

Il existe deux stratégies principales lorsqu'il s'agit d'affiner de grands modèles de langage :

1) Mise au point complète du modèle

Dans l'approche de réglage fin complet, tous les paramètres (poids et biais) du modèle pré-entraîné sont mis à jour lors de la deuxième phase d'entraînement. Le modèle est exposé à l'ensemble de données étiqueté spécifique à la tâche, et le processus de formation standard optimise l'ensemble du modèle pour cette distribution de données.

Cela permet au modèle de procéder à des ajustements plus complets et de s'adapter de manière holistique à la tâche ou au domaine cible. Cependant, un réglage complet présente certains inconvénients :

• Cela nécessite des ressources de calcul et du temps de formation importants, similaires à la phase de pré-formation.
• Les exigences de stockage sont élevées, car vous devez conserver une copie affinée distincte du modèle pour chaque tâche.
• Il existe un risque « d’oubli catastrophique », où un réglage fin fait perdre au modèle certaines capacités générales acquises lors de la pré-formation.

Malgré ces limitations, le réglage fin reste une technique puissante et largement utilisée lorsque les ressources le permettent et que la tâche cible s'écarte considérablement du langage général.

2) Méthodes de réglage efficaces

Pour surmonter les défis informatiques liés au réglage fin complet, les chercheurs ont développé des stratégies efficaces qui ne mettent à jour qu'un petit sous-ensemble des paramètres du modèle lors du réglage fin. Ces techniques paramétriquement efficaces établissent un équilibre entre spécialisation et réduction des besoins en ressources.

Certaines méthodes de réglage efficaces et populaires incluent :

Réglage du préfixe: Ici, un petit nombre de vecteurs ou « préfixes » spécifiques à une tâche sont introduits et entraînés pour conditionner l'attention du modèle pré-entraîné pour la tâche cible. Seuls ces préfixes sont mis à jour lors du réglage fin.

LoRA (Adaptation de bas rang): LoRA injecte des matrices de bas rang entraînables dans chaque couche du modèle pré-entraîné lors du réglage fin. Ces petits ajustements de classement aident à spécialiser le modèle avec beaucoup moins de paramètres pouvant être entraînés qu'un réglage fin complet.

Bien sûr, je peux fournir une explication détaillée de LoRA (Low-Rank Adaptation) ainsi que la formulation mathématique et des exemples de code. LoRA est une technique populaire de réglage fin efficace des paramètres (PEFT) qui a gagné en popularité dans le domaine de l'adaptation de grands modèles de langage (LLM).

Qu’est-ce que LoRA ?

LoRA est une méthode de réglage fin qui introduit un petit nombre de paramètres pouvant être entraînés dans le LLM pré-entraîné, permettant une adaptation efficace aux tâches en aval tout en préservant la majorité des connaissances du modèle d'origine. Au lieu d'affiner tous les paramètres du LLM, LoRA injecte des matrices de bas rang spécifiques à une tâche dans les couches du modèle, permettant ainsi d'importantes économies de calcul et de mémoire pendant le processus de réglage fin.

Formulation mathématique

LoRA (Low-Rank Adaptation) est une méthode de réglage fin pour les grands modèles de langage (LLM) qui introduit une mise à jour de bas rang des matrices de poids. Pour une matrice de poids 0∈W0 ∈Rd×k, LoRA ajoute une matrice de bas rang $BA$, avec A∈Rr×k et B∈Rd×r, Où $r$ est le rang. Cette approche réduit considérablement le nombre de paramètres pouvant être entraînés, permettant une adaptation efficace aux tâches en aval avec un minimum de ressources de calcul. La matrice de poids mise à jour est donnée par W=W0 +B⋅A.

Cette mise à jour de bas rang peut être interprétée comme une modification de la matrice de poids d'origine $W_{0}$ en ajoutant une matrice de bas rang $BA$. Le principal avantage de cette formulation est qu'au lieu de mettre à jour tous les paramètres $d \times k$ dans $W_{0}$, LoRA n'a besoin que d'optimiser les paramètres $r \times (d + k)$ dans $A$ et $B. $, réduisant considérablement le nombre de paramètres pouvant être entraînés.

Voici un exemple en Python utilisant le peft bibliothèque pour appliquer LoRA à un LLM pré-entraîné pour la classification de texte :

</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="">

Dans cet exemple, nous chargeons un modèle BERT pré-entraîné pour la classification de séquences et définissons une configuration LoRA. Le r le paramètre spécifie le rang de la mise à jour de bas rang, et lora_alpha est un facteur d'échelle pour la mise à jour. Le target_modules Le paramètre indique quelles couches du modèle doivent recevoir les mises à jour de bas rang. Après avoir créé le modèle compatible LoRA, nous pouvons procéder au processus de réglage fin en utilisant la procédure de formation standard.

Couches d'adaptateur: Semblable à LoRA, mais au lieu de mises à jour de bas rang, de fines couches « d'adaptateur » sont insérées dans chaque bloc de transformateur du modèle pré-entraîné. Seuls les paramètres de ces quelques nouvelles couches compactes sont entraînés.

Réglage rapide: Cette approche maintient le modèle pré-entraîné complètement gelé. Au lieu de cela, des intégrations « invites » pouvant être entraînées sont introduites comme entrée pour activer les connaissances pré-entraînées du modèle pour la tâche cible.

Ces méthodes efficaces peuvent fournir des réductions de calcul jusqu'à 100 fois supérieures à celles d'un réglage fin complet, tout en permettant d'obtenir des performances compétitives sur de nombreuses tâches. Ils réduisent également les besoins de stockage en évitant la duplication complète du modèle.

Cependant, leurs performances peuvent être en retard par rapport à une mise au point complète pour des tâches très différentes du langage général ou nécessitant une spécialisation plus holistique.

Le processus de réglage fin

Quelle que soit la stratégie de mise au point, le processus global de spécialisation d'un LLM suit un cadre général :

1. Préparation du jeu de données: Vous devrez obtenir ou créer un ensemble de données étiqueté qui mappe les entrées (invites) aux sorties souhaitées pour votre tâche cible. Pour les tâches de génération de texte telles que le résumé, il s'agirait d'un texte d'entrée dans des paires de sorties résumées.
2. Fractionnement de l'ensemble de données : En suivant les bonnes pratiques, divisez votre ensemble de données étiqueté en ensembles d'entraînement, de validation et de test. Cela sépare les données pour la formation du modèle, le réglage des hyperparamètres et l'évaluation finale.
3. Réglage des hyperparamètres: Des paramètres tels que le taux d'apprentissage, la taille du lot et le calendrier de formation doivent être ajustés pour un réglage plus efficace de vos données. Cela implique généralement un petit ensemble de validation.
4. Formation modèle: À l'aide des hyperparamètres réglés, exécutez le processus d'optimisation de réglage fin sur l'ensemble d'entraînement complet jusqu'à ce que les performances du modèle sur l'ensemble de validation cessent de s'améliorer (arrêt anticipé).
5. Evaluation: Évaluez les performances du modèle affiné sur l'ensemble de tests retenu, comprenant idéalement des exemples réels pour le cas d'utilisation cible, afin d'estimer l'efficacité du monde réel.
6. Déploiement et surveillance: Une fois satisfaisant, le modèle affiné peut être déployé pour l'inférence sur de nouvelles entrées. Il est crucial de surveiller ses performances et sa précision au fil du temps pour détecter toute dérive conceptuelle.

Bien que cela décrit le processus global, de nombreuses nuances peuvent avoir un impact sur le succès de l'optimisation d'un LLM ou d'une tâche particulière. Des stratégies telles que l'apprentissage du programme, le réglage précis de plusieurs tâches et les invites à quelques tirs peuvent encore améliorer les performances.

De plus, les méthodes de réglage efficaces impliquent des considérations supplémentaires. Par exemple, LoRA nécessite des techniques telles que le conditionnement des sorties du modèle pré-entraîné via une couche de combinaison. Le réglage rapide nécessite des invites soigneusement conçues pour activer les bons comportements.

Mise au point avancée : intégration des commentaires humains

Bien que le réglage fin supervisé standard à l’aide d’ensembles de données étiquetés soit efficace, une frontière passionnante consiste à former les LLM directement en utilisant les préférences et les commentaires humains. Cette approche humaine dans la boucle exploite les techniques de l'apprentissage par renforcement :

OPP (Optimisation de stratégie proximale): Ici, le LLM est traité comme un agent d’apprentissage par renforcement, dont les résultats sont des « actions ». Un modèle de récompense est formé pour prédire les évaluations humaines ou les scores de qualité pour ces résultats. PPO optimise ensuite le LLM pour générer des résultats maximisant les scores du modèle de récompense.

RLHF (Apprentissage par renforcement à partir de la rétroaction humaine): Cela étend le PPO en intégrant directement les commentaires humains dans le processus d'apprentissage. Au lieu d'un modèle de récompense fixe, les récompenses proviennent d'évaluations humaines itératives sur les résultats du LLM lors de la mise au point.

Bien que gourmandes en calcul, ces méthodes permettent de façonner plus précisément le comportement du LLM en fonction des caractéristiques souhaitées évaluées par les humains, au-delà de ce qui peut être capturé dans un ensemble de données statiques.

Des entreprises comme Anthropic ont utilisé RLHF pour imprégner leurs modèles de langage comme Claude d'une véracité, d'une éthique et d'une sensibilisation à la sécurité améliorées au-delà de la simple compétence professionnelle.

Risques potentiels et limites

Bien qu’immensément puissants, la mise au point des LLM n’est pas sans risques qui doivent être soigneusement gérés :

Amplification de biais: Si les données de réglage précis contiennent des préjugés sociétaux concernant le sexe, la race, l'âge ou d'autres attributs, le modèle peut amplifier ces préjugés indésirables. Il est crucial de conserver des ensembles de données représentatifs et débiaisés.

Dérive factuelle: Même après avoir affiné des données de haute qualité, les modèles de langage peuvent « halluciner » des faits incorrects ou des résultats incompatibles avec les exemples de formation au cours de conversations ou d'invites plus longues. Des méthodes de récupération des faits peuvent être nécessaires.

Défis d'évolutivité: Le réglage fin complet de modèles énormes comme GPT-3 nécessite d'immenses ressources de calcul qui peuvent être irréalisables pour de nombreuses organisations. Un réglage fin efficace atténue en partie ce problème, mais comporte des compromis.

Oubli catastrophique: Lors d'un réglage fin complet, les modèles peuvent subir un oubli catastrophique, où ils perdent certaines capacités générales acquises lors de la pré-formation. Un apprentissage multitâche peut être nécessaire.

Risques liés à la propriété intellectuelle et à la confidentialité: Les données exclusives utilisées pour le réglage fin peuvent s'infiltrer dans les sorties du modèle de langage rendu public, ce qui présente des risques. Les techniques différentielles d’atténuation des risques liés à la confidentialité et à l’information sont des domaines de recherche actifs.

Dans l'ensemble, bien qu'extrêmement utile, le réglage fin est un processus nuancé qui nécessite une attention particulière à la qualité des données, aux considérations d'identité, à l'atténuation des risques et à l'équilibre entre les performances et l'efficacité en fonction des exigences des cas d'utilisation.

L'avenir : personnalisation des modèles de langage à grande échelle

À l’avenir, les progrès dans les techniques de réglage fin et d’adaptation des modèles seront cruciaux pour libérer tout le potentiel des grands modèles de langage dans diverses applications et domaines.

Des méthodes plus efficaces permettant d’affiner des modèles encore plus grands comme PaLM avec des ressources limitées pourraient démocratiser l’accès. L’automatisation des pipelines de création d’ensembles de données et l’ingénierie rapide pourraient rationaliser la spécialisation.

Les techniques auto-supervisées permettant d'affiner les données brutes sans étiquettes peuvent ouvrir de nouvelles frontières. Et des approches compositionnelles visant à combiner des sous-modèles affinés formés sur différentes tâches ou données pourraient permettre de construire des modèles hautement personnalisés à la demande.

En fin de compte, à mesure que les LLM deviennent omniprésents, la capacité de les personnaliser et de les spécialiser de manière transparente pour chaque cas d'utilisation imaginable sera essentielle. Le réglage fin et les stratégies d'adaptation des modèles associées sont des étapes cruciales dans la réalisation de la vision des grands modèles de langage en tant qu'assistants d'IA flexibles, sûrs et puissants augmentant les capacités humaines dans tous les domaines et activités.