🦙Tutoriel : comment affiner Llama-3 et l'utiliser dans Ollama

Guide du débutant pour créer un assistant personnel personnalisé (comme ChatGPT) à exécuter localement sur Ollama

À la fin de ce tutoriel, vous créerez un chatbot personnalisé en affinant Llama-3 avec Unsloth gratuitement. Il peut s’exécuter localement via Ollama sur votre PC, ou dans une instance GPU gratuite via Google Colab. Vous pourrez interagir avec le chatbot de manière interactive comme ci-dessous :

Unsloth rend l’affinage beaucoup plus facile, et peut exporter automatiquement le modèle affiné vers Ollama avec création automatique intégrée de Modelfile ! Si vous avez besoin d’aide, vous pouvez rejoindre notre serveur Discord : https://discord.com/invite/unsloth

Si vous souhaitez copier ou enregistrer le code, tout est disponible dans notre cahier Colab Ollama. Vous pouvez l’utiliser directement là-bas ou l’adapter à votre configuration locale : https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_(8B)-Ollama.ipynb

1. Qu’est-ce qu’Unsloth ?

Unsloth rend l’affinage des LLM comme Llama-3, Mistral, Phi-3 et Gemma 2x plus rapide, utilise 70 % de mémoire en moins, et sans aucune dégradation de la précision ! Nous utiliserons Google Colab, qui fournit un GPU gratuit pendant ce tutoriel. Vous pouvez accéder à nos cahiers gratuits ci-dessous :

• Ollama Llama-3 Alpaca (cahier que nous utiliserons)

• Guide CSV/Excel Ollama

Vous devrez également vous connecter à votre compte Google !

2. Qu’est-ce qu’Ollama ?

Ollama vous permet d’exécuter des modèles de langage depuis votre propre ordinateur de manière rapide et simple ! Il lance discrètement un programme pouvant exécuter un modèle de langage comme Llama-3 en arrière-plan. Si vous souhaitez soudainement poser une question au modèle de langage, il vous suffit d’envoyer une requête à Ollama, et il vous renverra rapidement les résultats ! Nous utiliserons Ollama comme moteur d’inférence !

3. Installer Unsloth

Si vous n’avez jamais utilisé un cahier Colab, voici une brève introduction au cahier lui-même :

1. Bouton Lecture sur chaque « cellule ». Cliquez dessus pour exécuter le code de cette cellule. Vous ne devez sauter aucune cellule et vous devez exécuter chaque cellule dans l’ordre chronologique. Si vous rencontrez des erreurs, relancez simplement la cellule que vous n’aviez pas exécutée auparavant. Vous pouvez aussi appuyer sur CTRL + ENTRÉE si vous ne voulez pas cliquer sur le bouton Lecture.

2. Bouton Runtime dans la barre d’outils supérieure. Vous pouvez aussi utiliser ce bouton et cliquer sur « Run all » pour exécuter tout le cahier en une seule fois. Cela sautera toutes les étapes de personnalisation, et peut être un bon premier essai.

3. Bouton Connecter / Reconnecter T4. Vous pouvez cliquer ici pour des statistiques système plus avancées.

La première cellule d’installation ressemble à ceci : n’oubliez pas de cliquer sur le bouton LECTURE dans les crochets [ ]. Nous récupérons notre paquet open source Github, et installons quelques autres paquets.

4. Sélectionner un modèle à affiner

Sélectionnons maintenant un modèle à affiner ! Nous avons choisi par défaut Llama-3 de Meta / Facebook, qui a été entraîné sur la bagatelle de 15 000 milliards de « jetons ». Supposons qu’un jeton soit comme un mot anglais. Cela représente environ 350 000 encyclopédies épaisses ! Parmi les autres modèles populaires figurent Mistral, Phi-3 (entraîné à l’aide des sorties de GPT-4) et Gemma de Google (13 000 milliards de jetons !).

Unsloth prend en charge ces modèles et bien plus encore ! En fait, tapez simplement un modèle du hub de modèles Hugging Face pour voir s’il fonctionne ! Nous afficherons une erreur si cela ne fonctionne pas.

Il y a 3 autres paramètres que vous pouvez modifier :

1. max_seq_length = 2048

   Cela détermine la longueur de contexte du modèle. Gemini, par exemple, a une longueur de contexte de plus de 1 million, tandis que Llama-3 a une longueur de contexte de 8192. Nous vous permettons de sélectionner N’IMPORTE quel nombre — mais nous recommandons de le régler sur 2048 à des fins de test. Unsloth prend également en charge l’affinage sur des contextes très longs, et nous montrons que nous pouvons fournir des longueurs de contexte 4x plus longues que le meilleur.

2. dtype = None

   Conservez cette valeur à None, mais vous pouvez sélectionner torch.float16 ou torch.bfloat16 pour les GPU plus récents.

3. load_in_4bit = True

   Nous effectuons l’affinage en quantification 4 bits. Cela réduit l’utilisation de la mémoire par 4x, ce qui nous permet réellement d’effectuer l’affinage sur un GPU gratuit de 16 Go de mémoire. La quantification 4 bits convertit essentiellement les poids en un ensemble limité de nombres afin de réduire l’utilisation de la mémoire. L’inconvénient est une dégradation de la précision de 1 à 2 %. Réglez cette valeur sur False sur des GPU plus puissants comme les H100 si vous souhaitez ce petit gain supplémentaire en précision.

Si vous exécutez la cellule, vous obtiendrez quelques affichages de la version d’Unsloth, du modèle que vous utilisez, de la quantité de mémoire de votre GPU, et d’autres statistiques. Ignorez cela pour le moment.

5. Paramètres d’affinage

Pour personnaliser maintenant votre affinage, vous pouvez modifier les nombres ci-dessus, mais vous pouvez l’ignorer, car nous sélectionnons déjà des valeurs tout à fait raisonnables.

Le but est de modifier ces nombres pour augmenter la précision, mais aussi de contrer le surapprentissage. Le surapprentissage se produit lorsque vous faites mémoriser à un modèle de langage un jeu de données, au lieu de lui permettre de répondre à de nouvelles questions inédites. Nous voulons qu’un modèle final réponde à des questions non vues, et non qu’il mémorise.

1. r = 16, # Choisissez n’importe quel nombre > 0 ! Suggestions : 8, 16, 32, 64, 128

   Le rang du processus d’affinage. Un nombre plus élevé utilise plus de mémoire et sera plus lent, mais peut augmenter la précision sur des tâches plus difficiles. Nous suggérons généralement des nombres comme 8 (pour des affinages rapides), et jusqu’à 128. Des nombres trop élevés peuvent provoquer un surapprentissage, nuisant à la qualité de votre modèle.

2. target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj",],

   Nous sélectionnons tous les modules à affiner. Vous pouvez en retirer certains pour réduire l’utilisation de la mémoire et accélérer l’entraînement, mais nous le déconseillons fortement. Entraînez simplement tous les modules !

3. lora_alpha = 16,

   Le facteur d’échelle pour l’affinage. Un nombre plus élevé fera apprendre davantage le jeu de données à l’affinage, mais peut favoriser le surapprentissage. Nous suggérons de le fixer égal au rang rou le doubler.

4. lora_dropout = 0, # Prend en charge n’importe quelle valeur, mais = 0 est optimisé

   Laissez cette valeur à 0 pour un entraînement plus rapide ! Peut réduire le surapprentissage, mais pas beaucoup.

5. bias = "none",    # Prend en charge n’importe quelle valeur, mais = "none" est optimisé

   Laissez cette valeur à 0 pour un entraînement plus rapide et avec moins de surapprentissage !

6. use_gradient_checkpointing = "unsloth", # True ou "unsloth" pour un contexte très long

   Les options incluent True, False et "unsloth". Nous suggérons "unsloth" car nous réduisons l’utilisation de la mémoire de 30 % supplémentaires et prenons en charge des affinages sur des contextes extrêmement longs. Vous pouvez en lire plus ici : https://unsloth.ai/blog/long-context pour plus de détails.

7. random_state = 3407,

   Le nombre permettant de déterminer des exécutions déterministes. L’entraînement et l’affinage nécessitent des nombres aléatoires, donc définir ce nombre rend les expériences reproductibles.

8. use_rslora = False,  # Nous prenons en charge LoRA stabilisé par rang

   Fonction avancée pour définir lora_alpha = 16 automatiquement. Vous pouvez utiliser cela si vous le souhaitez !

9. loftq_config = None, # Et LoftQ

   Fonction avancée pour initialiser les matrices LoRA avec les vecteurs singuliers principaux r des poids. Peut améliorer quelque peu la précision, mais peut faire exploser l’utilisation de la mémoire au départ.

6. Jeu de données Alpaca

Nous allons maintenant utiliser le jeu de données Alpaca créé en appelant GPT-4 lui-même. Il s’agit d’une liste de 52 000 instructions et sorties, qui était très populaire lors de la sortie de Llama-1, car elle permettait à un LLM de base affiné d’être compétitif avec ChatGPT lui-même.

Vous pouvez accéder ici à la version GPT4 du jeu de données Alpaca : https://huggingface.co/datasets/vicgalle/alpaca-gpt4. Une version plus ancienne du jeu de données se trouve ici : https://github.com/tatsu-lab/stanford_alpaca. Ci-dessous figurent quelques exemples du jeu de données :

Vous pouvez voir qu’il y a 3 colonnes dans chaque ligne — une instruction, une entrée et une sortie. Nous combinons essentiellement chaque ligne en un grand prompt comme ci-dessous. Nous l’utilisons ensuite pour affiner le modèle de langage, et cela l’a rendu très similaire à ChatGPT. Nous appelons ce processus l’affinage supervisé par instructions.

7. Plusieurs colonnes pour l’affinage

Mais un gros problème est que pour les assistants de type ChatGPT, nous n’autorisons qu’une seule instruction / un seul prompt, et non plusieurs colonnes / entrées. Par exemple dans ChatGPT, on voit qu’il faut soumettre 1 prompt, et non plusieurs prompts.

Cela signifie essentiellement que nous devons « fusionner » plusieurs colonnes en un seul grand prompt pour que l’affinage fonctionne réellement !

Par exemple, le très célèbre jeu de données Titanic comporte de nombreuses colonnes. Votre tâche consistait à prédire si un passager a survécu ou est mort en fonction de son âge, de sa classe de passager, du prix du billet, etc. Nous ne pouvons pas simplement envoyer cela à ChatGPT, mais nous devons plutôt « fusionner » ces informations en un seul grand prompt.

Par exemple, si nous interrogeons ChatGPT avec notre unique prompt « fusionné » qui inclut toutes les informations concernant ce passager, nous pouvons alors lui demander de deviner ou de prédire si le passager est mort ou a survécu.

D’autres bibliothèques d’affinage exigent que vous prépariez manuellement votre jeu de données pour l’affinage, en fusionnant toutes vos colonnes en un seul prompt. Dans Unsloth, nous fournissons simplement la fonction appelée to_sharegpt qui fait cela en une seule fois !

Pour accéder au cahier d’affinage Titanic ou si vous souhaitez téléverser un fichier CSV ou Excel, allez ici : https://colab.research.google.com/drive/1VYkncZMfGFkeCEgN2IzbZIKEDkyQuJAS?usp=sharing

C’est maintenant un peu plus compliqué, car nous permettons beaucoup de personnalisation, mais il y a quelques points :

• Vous devez encadrer toutes les colonnes avec des accolades {}. Ce sont les noms de colonnes dans le fichier CSV / Excel réel.

• Les composants textuels facultatifs doivent être encadrés par [[]]. Par exemple, si la colonne "input" est vide, la fonction de fusion n’affichera pas le texte et passera cet élément. C’est utile pour les jeux de données contenant des valeurs manquantes.

• Sélectionnez la colonne de sortie ou la colonne cible / prédiction dans output_column_name. Pour le jeu de données Alpaca, ce sera output.

Par exemple, dans le jeu de données Titanic, nous pouvons créer un grand format de prompt fusionné comme ci-dessous, où chaque colonne / fragment de texte devient facultatif.

Par exemple, imaginez que le jeu de données ressemble à ceci avec beaucoup de données manquantes :

Embarqué	Âge	Tarif
S	23
	18	7.25

Alors, nous ne voulons pas que le résultat soit :

1. Le passager a embarqué à S. Son âge est 23. Son tarif est VIDE.

2. Le passager a embarqué à VIDE. Son âge est 18. Son tarif est 7,25 $.

Au lieu de cela, en encadrant facultativement les colonnes avec [[]], nous pouvons exclure entièrement cette information.

1. [[Le passager a embarqué à S.]] [[Son âge est 23.]] [[Son tarif est VIDE.]]

2. [[Le passager a embarqué à VIDE.]] [[Son âge est 18.]] [[Son tarif est 7,25 $.]]

devient :

1. Le passager a embarqué à S. Son âge est 23.

2. Son âge est 18. Son tarif est 7,25 $.

8. Conversations multi-tours

Un problème, si vous ne l’avez pas remarqué, est que le jeu de données Alpaca est en un seul tour, alors que souvenez-vous que l’utilisation de ChatGPT était interactive et que vous pouviez lui parler en plusieurs tours. Par exemple, à gauche se trouve ce que nous voulons, mais à droite, qui est le jeu de données Alpaca, ne fournit que des conversations uniques. Nous voulons que le modèle de langage affiné apprenne d’une manière ou d’une autre à faire des conversations multi-tours, tout comme ChatGPT.

Nous avons donc introduit le conversation_extension paramètre, qui sélectionne essentiellement certaines lignes aléatoires dans votre jeu de données à un seul tour, et les fusionne en une seule conversation ! Par exemple, si vous le réglez sur 3, nous sélectionnons aléatoirement 3 lignes et les fusionnons en une seule ! Les définir trop long peut rendre l’entraînement plus lent, mais peut rendre votre chatbot et votre affinage final bien meilleurs !

Puis réglez output_column_name sur la colonne de prédiction / sortie. Pour le jeu de données Alpaca, ce serait la colonne de sortie.

Nous utilisons ensuite la fonction standardize_sharegpt pour simplement mettre le jeu de données dans un format correct pour l’affinage ! Appelez toujours cette fonction !

9. Modèles de chat personnalisables

Nous pouvons maintenant spécifier le modèle de chat pour l’affinage lui-même. Le très célèbre format Alpaca est ci-dessous :

Mais rappelez-vous que nous avons dit que c’était une mauvaise idée, car les affinages de type ChatGPT nécessitent seulement 1 prompt ? Puisque nous avons réussi à fusionner toutes les colonnes du jeu de données en une seule grâce à Unsloth, nous pouvons essentiellement créer le modèle de chat de style ci-dessous avec 1 colonne d’entrée (instruction) et 1 sortie :

Nous exigeons simplement que vous mettiez un {INPUT} champ pour l’instruction et un {OUTPUT} champ pour le champ de sortie du modèle. En fait, nous autorisons aussi un champ {SYSTEM} facultatif, utile pour personnaliser un prompt système comme dans ChatGPT. Par exemple, voici quelques exemples sympas pour lesquels vous pouvez personnaliser le modèle de chat :

Pour le format ChatML utilisé dans les modèles OpenAI :

Ou vous pouvez utiliser le modèle Llama-3 lui-même (qui ne fonctionne qu’en utilisant la version instruct de Llama-3) : Nous autorisons en fait aussi un champ {SYSTEM} facultatif, utile pour personnaliser un prompt système comme dans ChatGPT.

Ou dans la tâche de prédiction Titanic où vous deviez prédire si un passager est mort ou a survécu dans ce cahier Colab qui inclut le téléversement CSV et Excel : https://colab.research.google.com/drive/1VYkncZMfGFkeCEgN2IzbZIKEDkyQuJAS?usp=sharing

10. Entraîner le modèle

Entraînons maintenant le modèle ! Nous suggérons généralement de ne pas modifier ce qui suit, sauf si vous souhaitez affiner pendant plus d’étapes ou entraîner avec de grandes tailles de lot.

Nous ne suggérons généralement pas de modifier les paramètres ci-dessus, mais pour expliquer certains d’entre eux :

1. per_device_train_batch_size = 2,

   Augmentez la taille de lot si vous souhaitez mieux utiliser la mémoire de votre GPU. Augmentez-la aussi pour rendre l’entraînement plus fluide et éviter le surapprentissage. Nous ne le suggérons généralement pas, car cela peut en réalité ralentir l’entraînement à cause des problèmes de remplissage. Nous vous demandons généralement plutôt d’augmenter gradient_accumulation_steps qui effectue simplement davantage de passes sur le jeu de données.

2. gradient_accumulation_steps = 4,

   Équivalent à augmenter la taille de lot ci-dessus elle-même, mais sans impact sur la consommation de mémoire ! Nous suggérons généralement d’augmenter cela si vous souhaitez des courbes de perte d’entraînement plus fluides.

3. max_steps = 60, # num_train_epochs = 1,

   Nous définissons les étapes à 60 pour un entraînement plus rapide. Pour des entraînements complets qui peuvent prendre des heures, commentez plutôt max_steps, et remplacez-le par num_train_epochs = 1. Le régler à 1 signifie un passage complet sur votre jeu de données. Nous suggérons généralement 1 à 3 passages, pas plus, sinon vous surapprendrez votre affinage.

4. learning_rate = 2e-4,

   Réduisez le taux d’apprentissage si vous souhaitez ralentir le processus d’affinage, mais aussi probablement converger vers un résultat de meilleure précision. Nous suggérons généralement comme valeurs à essayer 2e-4, 1e-4, 5e-5, 2e-5.

Vous verrez un journal de nombres pendant l’entraînement. Il s’agit de la perte d’entraînement, qui montre à quel point le modèle apprend bien à partir de votre jeu de données. Dans beaucoup de cas, une perte autour de 0,5 à 1,0 est bon signe, mais cela dépend de votre jeu de données et de votre tâche. Si la perte ne baisse pas, vous devrez peut-être ajuster vos paramètres. Si la perte tombe à 0, cela peut signifier un surapprentissage, donc il est important de vérifier aussi la validation.

11. Inférence / exécution du modèle

Maintenant exécutons le modèle après avoir terminé le processus d’entraînement ! Vous pouvez modifier la partie soulignée en jaune ! En fait, parce que nous avons créé un chatbot multi-tours, nous pouvons maintenant aussi appeler le modèle comme s’il avait vu des conversations dans le passé, comme ci-dessous :

Rappel : Unsloth fournit lui-même une inférence 2x plus rapide nativement également, donc n’oubliez jamais d’appeler FastLanguageModel.for_inference(model). Si vous voulez que le modèle produise des réponses plus longues, réglez max_new_tokens = 128 sur une valeur plus grande comme 256 ou 1024. Notez que vous devrez aussi attendre plus longtemps pour le résultat !

12. Enregistrer le modèle

Nous pouvons maintenant enregistrer le modèle affiné sous la forme d’un petit fichier de 100 Mo appelé adaptateur LoRA, comme ci-dessous. Vous pouvez également le pousser vers le hub Hugging Face si vous souhaitez téléverser votre modèle ! N’oubliez pas d’obtenir un jeton Hugging Face via https://huggingface.co/settings/tokens et ajoutez votre jeton !

Après avoir enregistré le modèle, nous pouvons à nouveau utiliser Unsloth pour exécuter le modèle lui-même ! Utilisez FastLanguageModel à nouveau pour l’appeler en inférence !

13. Exporter vers Ollama

Enfin, nous pouvons exporter notre modèle affiné vers Ollama lui-même ! D’abord, nous devons installer Ollama dans le notebook Colab :

Ensuite, nous exportons le modèle affiné que nous devons convertir aux formats GGUF de llama.cpp comme ci-dessous :

Rappel de convertir False en True pour 1 ligne, et ne pas changer chaque ligne en True, sinon vous allez attendre très longtemps ! Nous recommandons normalement de définir la première ligne sur True, afin que nous puissions exporter rapidement le modèle affiné vers le format Q8_0 (quantification en 8 bits). Nous vous permettons également d’exporter vers toute une liste de méthodes de quantification, l’une des plus populaires étant q4_k_m.

Rendez-vous sur https://github.com/ggml-org/llama.cpp pour en savoir plus sur GGUF. Nous avons également ici des instructions manuelles sur la façon d’exporter vers GGUF si vous le souhaitez : https://github.com/unslothai/unsloth/wiki#manually-saving-to-gguf

Vous verrez une longue liste de texte comme ci-dessous - veuillez attendre 5 à 10 minutes !!

Et enfin, tout à la fin, cela ressemblera à ceci :

Ensuite, nous devons exécuter Ollama lui-même en arrière-plan. Nous utilisons subprocess parce que Colab n’aime pas les appels asynchrones, mais normalement on exécute simplement ollama serve dans le terminal / l’invite de commande.

14. Automatique Modelfile création

L’astuce qu’Unsloth fournit est que nous créons automatiquement un Modelfile dont Ollama a besoin ! C’est simplement une liste de paramètres et elle inclut le modèle de chat que nous avons utilisé pour le processus de fine-tuning ! Vous pouvez aussi afficher le Modelfile généré comme ci-dessous :

Ensuite, nous demandons à Ollama de créer un modèle compatible avec Ollama, en utilisant Modelfile

15. Inférence Ollama

Et nous pouvons maintenant appeler le modèle en inférence si vous voulez appeler le serveur Ollama lui-même, qui s’exécute sur votre propre machine locale / dans le notebook Colab gratuit en arrière-plan. N’oubliez pas que vous pouvez modifier la partie jaune soulignée.

16. Chat interactif de style ChatGPT

Mais pour réellement exécuter le modèle affiné comme un ChatGPT, nous devons faire un peu plus ! D’abord, cliquez sur l’icône du terminal et un terminal apparaîtra. Il se trouve dans la barre latérale gauche.

Ensuite, vous devrez peut-être appuyer deux fois sur ENTRÉE pour supprimer une sortie étrange dans la fenêtre du terminal. Attendez quelques secondes et tapez ollama run unsloth_model puis appuyez sur ENTRÉE.

Et enfin, vous pouvez interagir avec le modèle affiné comme avec un vrai ChatGPT ! Appuyez sur CTRL + D pour quitter le système, puis sur ENTRÉE pour converser avec le chatbot !

Vous l’avez fait !

Vous avez réussi à affiner un modèle de langage et à l’exporter vers Ollama avec Unsloth 2x plus rapide et avec 70 % de VRAM en moins ! Et tout cela gratuitement dans un cahier Google Colab !

Si vous voulez apprendre à faire du modelage de récompense, du pré-entraînement continu, à exporter vers vLLM ou GGUF, à faire de la complétion de texte, ou à en apprendre davantage sur les astuces et conseils d’affinage, rendez-vous sur notre Github.

Si vous avez besoin d’aide pour l’affinage, vous pouvez aussi rejoindre notre serveur Discord ici. Si vous voulez de l’aide avec Ollama, vous pouvez aussi rejoindre leur serveur ici.

Et enfin, nous tenons à vous remercier d’avoir lu et suivi jusqu’ici ! Nous espérons que cela vous a aidé à comprendre certains des rouages de l’affinage des modèles de langage, et nous espérons que cela vous a été utile !

Pour accéder à notre exemple de jeu de données Alpaca, cliquez ici, et notre guide d’affinage CSV / Excel est ici.