Intelligence artificielle

Guide complet pour le fine-tuning des grands modèles de langage

Publié le 25 mars 2024

Mis à jour le 22 mai 2026

Par

Aayush Mittal Mittal

Les grands modèles de langage (LLM) comme GPT-4, LaMDA, PaLM et d’autres ont pris le monde d’assaut avec leur capacité remarquable à comprendre et générer du texte similaire à celui des humains sur une vaste gamme de sujets. Ces modèles sont pré-entraînés sur des ensembles de données massifs composés de milliards de mots issus d’Internet, de livres et d’autres sources.

Cette phase de pré-entraînement imprègne les modèles d’une connaissance générale étendue sur la langue, les sujets, les capacités de raisonnement et même de certains biais présents dans les données d’entraînement. Cependant, malgré leur incroyable étendue, ces LLM pré-entraînés manquent d’expertise spécialisée pour des domaines ou des tâches spécifiques.

C’est là que le fine-tuning intervient – le processus d’adaptation d’un LLM pré-entraîné pour exceller dans une application ou une tâche particulière. En formant davantage le modèle sur un ensemble de données plus petit et spécifique à la tâche, nous pouvons ajuster ses capacités pour qu’elles correspondent aux nuances et aux exigences de ce domaine.

Le fine-tuning est analogue au transfert des connaissances d’un généraliste très instruit pour créer un expert en la matière spécialisé dans un domaine spécifique. Dans ce guide, nous allons explorer les aspects, les raisons et les méthodes du fine-tuning des LLM.

Fine-tuning des grands modèles de langage

Qu’est-ce que le fine-tuning ?

À son cœur, le fine-tuning implique de prendre un grand modèle pré-entraîné et de mettre à jour ses paramètres à l’aide d’une deuxième phase d’entraînement sur un ensemble de données conçu pour votre tâche ou domaine cible. Cela permet au modèle d’apprendre et d’internaliser les nuances, les modèles et les objectifs spécifiques à cette zone plus étroite.

Alors que le pré-entraînement capture une compréhension générale de la langue à partir d’un énorme et diversifié corpus de texte, le fine-tuning spécialise cette compétence générale. C’est comme prendre un homme de la Renaissance et le façonner en un expert de l’industrie.

Les poids du modèle pré-entraîné, qui encodent sa connaissance générale, sont utilisés comme point de départ ou initialisation pour le processus de fine-tuning. Le modèle est ensuite formé 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 efficace pour la tâche cible, tout en bénéficiant toujours des capacités pré-entraînées comme fondation.

Pourquoi fine-tuner les LLM ?

Il existe plusieurs raisons clés pour lesquelles vous pourriez vouloir fine-tuner un grand modèle de langage :

Personnalisation de domaine : Chaque domaine, de la loi à la médecine en passant par l’ingénierie logicielle, a ses propres conventions linguistiques nuancées, jargon et contextes. Le fine-tuning permet de personnaliser un modèle général pour qu’il comprenne et produise du texte adapté au domaine spécifique.
Spécialisation de tâche : Les LLM peuvent être fine-tunés pour diverses tâches de traitement automatique des langues comme la résumé de texte, la traduction automatique, la réponse à des questions, etc. Cette spécialisation améliore les performances sur la tâche cible.
Conformité des données : Les industries hautement réglementées comme les soins de santé et la finance ont des exigences strictes en matière de confidentialité des données. Le fine-tuning permet de former les LLM sur des données propriétaires de l’organisation tout en protégeant les informations sensibles.
Données étiquetées limitées : L’obtention de grands ensembles de données étiquetées pour former des modèles à partir de zéro peut être difficile. Le fine-tuning permet d’obtenir de solides performances sur la tâche en utilisant des exemples supervisés limités en exploitant les capacités du modèle pré-entraîné.
Mise à jour du modèle : Lorsque de nouvelles données deviennent disponibles au fil du temps dans un domaine, vous pouvez fine-tuner les modèles davantage pour incorporer les connaissances et les capacités les plus récentes.
Atténuation des biais : Les LLM peuvent acquérir des biais sociétaux à partir des données de pré-entraînement larges. Le fine-tuning sur des ensembles de données soigneusement sélectionnés peut aider à réduire et à corriger ces biais indésirables.

En essence, le fine-tuning comble le fossé entre un modèle général 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 sorties de modèle pour les cas d’utilisation ciblés.

Fine-tuning des grands modèles de langage

Le diagramme fourni décrit le processus de mise en œuvre et d’utilisation de grands modèles de langage (LLM), notamment pour les applications d’entreprise. Initialement, un modèle pré-entraîné comme T5 est alimenté avec des données d’entreprise structurées et non structurées, qui peuvent provenir de divers formats tels que CSV ou JSON. Ces données subissent des processus de fine-tuning supervisés, non supervisés ou de transfert, améliorant ainsi la pertinence du modèle par rapport aux besoins spécifiques de l’entreprise.

Une fois le modèle fine-tuné avec les données de l’entreprise, ses poids sont mis à jour en conséquence. Le modèle formé itère ensuite à travers des cycles de formation supplémentaires, améliorant continuellement ses réponses au fil du temps avec de nouvelles données d’entreprise. Le processus est itératif et dynamique, le modèle apprenant et se réadaptant pour s’adapter aux modèles de données évolutifs.

La sortie de ce modèle formé – des jetons et des embeddings représentant des mots – est ensuite déployée pour diverses applications d’entreprise. Ces applications peuvent aller des chatbots aux soins de santé, chacune nécessitant que le modèle comprenne et réponde à des requêtes spécifiques à l’industrie. Dans le domaine financier, les applications incluent la détection de fraude et l’analyse de menaces ; dans les soins de santé, les modèles peuvent aider les patients à répondre à des questions et à effectuer des diagnostics.

La capacité du modèle formé à traiter et à répondre à de nouvelles données d’entreprise au fil du temps assure que son utilité est maintenue et croît. Par conséquent, les utilisateurs d’entreprise peuvent interagir avec le modèle via des applications, poser des questions et recevoir des réponses éclairées qui reflètent la formation et le fine-tuning du modèle sur des données spécifiques au domaine.

Cette infrastructure prend en charge un large éventail d’applications d’entreprise, mettant en évidence la polyvalence et l’adaptabilité des LLM lorsqu’ils sont correctement mis en œuvre et maintenus dans un contexte commercial.

Approches de fine-tuning

Il existe deux stratégies principales lorsqu’il s’agit de fine-tuner des grands modèles de langage :

1) Fine-tuning complet du modèle

Dans l’approche de fine-tuning complet, tous les paramètres (poids et biais) du modèle pré-entraîné sont mis à jour pendant 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 d’entraînement standard optimise l’ensemble du modèle pour cette distribution de données.

Cela permet au modèle d’effectuer des ajustements plus complets et de s’adapter de manière holistique à la tâche ou au domaine cible. Cependant, le fine-tuning complet a certains inconvénients :

Il nécessite des ressources et du temps de calcul importants pour l’entraînement, similaires à la phase de pré-entraînement.
Les exigences de stockage sont élevées, car vous devez maintenir une copie fine-tunée distincte du modèle pour chaque tâche.
Il existe un risque d’« oubli catastrophique », où le fine-tuning cause le modèle à perdre certaines capacités générales acquises pendant le pré-entraînement.

Malgré ces limitations, le fine-tuning complet reste une technique puissante et largement utilisée lorsque les ressources le permettent et que la tâche cible diverge considérablement du langage général.

2) Méthodes de fine-tuning efficaces

Pour surmonter les défis de calcul du fine-tuning 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 pendant le fine-tuning. Ces techniques paramétriquement efficaces équilibrent la spécialisation et la réduction des exigences en ressources.

Certaines méthodes de fine-tuning efficaces populaires incluent :

Prefix-Tuning : Ici, un petit nombre de vecteurs ou de « préfixes » spécifiques à la tâche sont introduits et formés pour conditionner l’attention du modèle pré-entraîné pour la tâche cible. Seuls ces préfixes sont mis à jour pendant le fine-tuning.

LoRA (Low-Rank Adaptation) : LoRA injecte des matrices de rang faible formables dans chaque couche du modèle pré-entraîné pendant le fine-tuning. Ces ajustements de rang faible aident à spécialiser le modèle avec beaucoup moins de paramètres formables que le fine-tuning 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 de fine-tuning (PEFT) très populaire qui a gagné une grande attention dans le domaine de l’adaptation des grands modèles de langage (LLM).

Qu’est-ce que LoRA ?

LoRA est une méthode de fine-tuning qui introduit un petit nombre de paramètres formables 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 de fine-tuner tous les paramètres du LLM, LoRA injecte des matrices de rang faible spécifiques à la tâche dans les couches du modèle, permettant ainsi des économies de calcul et de mémoire importantes pendant le processus de fine-tuning.

Formulation mathématique

LoRA (Low-Rank Adaptation) est une méthode de fine-tuning pour les grands modèles de langage (LLM) qui introduit une mise à jour de rang faible dans les matrices de poids. Pour une matrice de poids $W_{0} \in R^{d \times k}, LoRA ajoute une matrice de rang faible B A, avec A \in R^{r \times k} et B \in R^{d \times r}, où r est le rang. Cette approche réduit considérablement le nombre de paramètres formables, permettant ainsi 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 = W_{0} + B \cdot A .$

Cette mise à jour de rang faible peut être interprétée comme la modification de la matrice de poids d’origine $W_{0}$ en ajoutant une matrice de rang faible $BA$. L’avantage clé de cette formulation est que plutôt que de mettre à jour tous les $d \times k$ paramètres de $W_{0}$, LoRA n’a besoin de optimiser que $r \times (d + k)$ paramètres dans $A$ et $B$, réduisant ainsi considérablement le nombre de paramètres formables.

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

&amp;lt;/div&amp;gt;
&amp;lt;div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;from&amp;lt;/span&amp;gt; transformers &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;import&amp;lt;/span&amp;gt; AutoModelForSequenceClassification
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;from&amp;lt;/span&amp;gt; peft &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;import&amp;lt;/span&amp;gt; get_peft_model&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; LoraConfig&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; TaskType
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Charger le modèle pré-entraîné&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;model &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt; AutoModelForSequenceClassification&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;.&amp;lt;/span&amp;gt;from_pretrained&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;(&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&quot;bert-base-uncased&quot;&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; num_labels&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;2&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;)&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Définir la configuration LoRA&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;peft_config &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt; LoraConfig&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;(&amp;lt;/span&amp;gt;task_type&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt;TaskType&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;.&amp;lt;/span&amp;gt;SEQ_CLS&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;, &amp;lt;/span&amp;gt;r&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;8&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Rang de la mise à jour de rang faible&amp;lt;/span&amp;gt;
lora_alpha&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;16&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt;&amp;lt;/code&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Facteur d'échelle pour la mise à jour de rang faible&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt; target_modules&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;[&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&quot;q_lin&quot;&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&quot;v_lin&quot;&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;]&amp;lt;/span&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Appliquer LoRA aux couches de requête et de valeur&amp;lt;/span&amp;gt;
&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;)&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Créer le modèle LoRA&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;model &amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;=&amp;lt;/span&amp;gt; get_peft_model&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;(&amp;lt;/span&amp;gt;model&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;,&amp;lt;/span&amp;gt; peft_config&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;)&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# Fine-tuner le modèle avec LoRA&amp;lt;/span&amp;gt;
&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;div class=&quot;code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;code class=&quot;language-python&quot; data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;&amp;lt;span class=&quot;token&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;# ... (code d'entraînement omis pour la brièveté)&amp;lt;/span&amp;gt;&amp;lt;/code&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;/div&amp;gt;
&amp;lt;div data-darkreader-inline-bgimage=&quot;&quot; data-darkreader-inline-bgcolor=&quot;&quot; data-darkreader-inline-color=&quot;&quot;&amp;gt;

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 paramètre r spécifie le rang de la mise à jour de rang faible, et lora_alpha est un facteur d’échelle pour la mise à jour. Le paramètre target_modules indique quelles couches du modèle doivent recevoir les mises à jour de rang faible. Après avoir créé le modèle LoRA, nous pouvons procéder au fine-tuning en utilisant la procédure d’entraînement standard.

Couches d’adaptation : Similaires à LoRA, mais au lieu de mises à jour de rang faible, des couches d’adaptation minces sont insérées à l’intérieur de chaque bloc de transformation du modèle pré-entraîné. Seuls les paramètres de ces quelques nouvelles couches compactes sont formés.

Accord de prompt : Cette approche garde le modèle pré-entraîné complètement gelé. Au lieu de cela, des embeddings de prompt formables sont introduits 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 jusqu’à 100 fois de réduction de calcul par rapport au fine-tuning complet, tout en atteignant des performances concurrentielles sur de nombreuses tâches. Elles réduisent également les besoins de stockage en évitant la duplication complète du modèle.

Cependant, leurs performances peuvent être inférieures à celles du fine-tuning complet pour les tâches qui sont très différentes du langage général ou qui nécessitent une spécialisation plus holistique.

Le processus de fine-tuning

Quelle que soit la stratégie de fine-tuning, le processus global pour spécialiser un LLM suit un cadre général :

Préparation des données : Vous aurez besoin d’obtenir ou de créer un ensemble de données étiqueté qui mappe les entrées (prompts) aux sorties souhaitées pour votre tâche cible. Pour les tâches de génération de texte comme la résumé, ce serait des paires d’entrée de texte et de sortie résumée.
Division de l’ensemble de données : Suivant les meilleures 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 l’entraînement du modèle, le réglage des hyperparamètres et l’évaluation finale.
Réglage des hyperparamètres : Les paramètres comme le taux d’apprentissage, la taille du lot et le calendrier d’entraînement doivent être réglés pour le fine-tuning le plus efficace sur vos données. Cela implique généralement un petit ensemble de validation.
Entraînement du modèle : En utilisant les hyperparamètres réglés, exécutez le processus d’optimisation du fine-tuning 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é).
Évaluation : Évaluez les performances du modèle fine-tuné sur l’ensemble de test mis de côté, idéalement composé d’exemples du monde réel pour la tâche cible, pour estimer l’efficacité dans le monde réel.
Déploiement et surveillance : Une fois satisfaisant, le modèle fine-tuné 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 les changements de concept.

Bien que cela décrive le processus général, de nombreuses nuances peuvent avoir un impact sur le succès du fine-tuning pour un LLM ou une tâche particulière. Les stratégies comme l’apprentissage par curriculum, le fine-tuning multi-tâche et le prompt à quelques exemples peuvent encore améliorer les performances.

De plus, les méthodes de fine-tuning efficaces impliquent des considérations supplémentaires. Par exemple, LoRA nécessite des techniques comme le conditionnement des sorties du modèle pré-entraîné via une couche de combinaison. L’accord de prompt nécessite des prompts soigneusement conçus pour activer les comportements souhaités.

Fine-tuning avancé : Intégration de la rétroaction humaine

Alors que le fine-tuning supervisé standard à l’aide d’ensembles de données étiquetés est efficace, une frontière passionnante est l’entraînement des LLM directement à l’aide de préférences et de rétroactions humaines. Cette approche homme-dans-la-boucle utilise des techniques d’apprentissage par renforcement :

PPO (Proximal Policy Optimization) : Ici, le LLM est traité comme un agent d’apprentissage par renforcement, avec ses sorties étant des « actions ». Un modèle de récompense est formé pour prédire les évaluations humaines ou les scores de qualité pour ces sorties. PPO optimise ensuite le LLM pour générer des sorties qui maximisent les scores du modèle de récompense.

RLHF (Reinforcement Learning from Human Feedback) : Cela étend PPO en incorporant directement la rétroaction humaine 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 sorties du LLM pendant le fine-tuning.

Bien que cela soit intensif en calcul, ces méthodes permettent de façonner le comportement du LLM de manière plus précise en fonction de caractéristiques souhaitées évaluées par les humains, au-delà de ce qui peut être capturé dans un ensemble de données statique.

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 conscience de la sécurité améliorées, au-delà de la simple compétence en tâche.

Risques et limites potentiels

Bien que puissants, le fine-tuning des LLM comporte des risques qui doivent être soigneusement gérés :

Amplification des biais : Si les données de fine-tuning contiennent des biais sociétaux autour du sexe, de la race, de l’âge ou d’autres attributs, le modèle peut amplifier ces biais indésirables. La sélection soigneuse des ensembles de données représentatifs et débiaisés est cruciale.

Dérive factuelle : Même après le fine-tuning sur des données de haute qualité, les modèles de langage peuvent « halluciner » des faits incorrects ou des sorties incohérentes avec les exemples de formation sur des conversations ou des prompts plus longs. Des méthodes de récupération de faits peuvent être nécessaires.

Défis de scalabilité : Le fine-tuning complet de modèles énormes comme GPT-3 nécessite des ressources de calcul immenses qui peuvent être inaccessibles à de nombreuses organisations. Les méthodes de fine-tuning efficaces atténuent partiellement cela, mais ont des compromis.

Oubli catastrophique : Lors du fine-tuning complet, les modèles peuvent subir un oubli catastrophique, où ils perdent certaines capacités générales acquises pendant le pré-entraînement. L’apprentissage multi-tâche peut être nécessaire.

Risques de propriété intellectuelle et de confidentialité : Les données propriétaires utilisées pour le fine-tuning peuvent fuir dans les sorties publiques des modèles de langage, posant des risques. Les techniques de confidentialité différentielle et d’atténuation des risques d’information sont des domaines de recherche actifs.

Dans l’ensemble, bien que très utile, le fine-tuning est un processus nuancé qui nécessite de l’attention sur la qualité des données, les considérations d’identité, l’atténuation des risques et l’équilibre des compromis entre performances et efficacité en fonction des exigences de la tâche.

Le futur : Personnalisation du modèle de langage à grande échelle

En regardant vers l’avenir, les progrès dans le fine-tuning et les techniques d’adaptation de modèle seront cruciaux pour débloquer le plein potentiel des grands modèles de langage à travers diverses applications et domaines.

Des méthodes plus efficaces permettant le fine-tuning de 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 de données et l’ingénierie de prompt pourraient rationaliser la spécialisation.

Des techniques d’auto-apprentissage pour fine-tuner à partir de données brutes sans étiquettes pourraient ouvrir de nouvelles frontières. Et des approches compositionnelles pour combiner des sous-modèles fine-tunés formés sur différentes tâches ou données pourraient permettre la construction de modèles hautement personnalisés sur demande.

En fin de compte, à mesure que les LLM deviennent plus omniprésents, la capacité de les personnaliser et de les spécialiser sans heurt pour chaque cas d’utilisation imaginable sera cruciale. Le fine-tuning et les stratégies d’adaptation de modèle connexes sont des étapes essentielles pour réaliser la vision des grands modèles de langage en tant qu’outils d’IA flexibles, sûrs et puissants qui augmentent les capacités humaines dans tous les domaines et entreprises.

Aayush Mittal, Mittal

J'ai passé les cinq dernières années à plonger dans le monde fascinant de l'apprentissage automatique et du deep learning. Ma passion et mon expertise m'ont conduit à contribuer à plus de 50 projets de génie logiciel divers, avec un focus particulier sur l'IA/ML. Ma curiosité continue m'a également attiré vers le traitement automatique des langues, un domaine que je suis impatient d'explorer plus en profondeur.