Il y a généralement trois étapes différentes de formation pour les modèles de langage de grande taille :

1. Pré-entraînement : Dans cette étape, le modèle est entraîné sur un large corpus de données textuelles brutes pour apprendre à prédire le prochain jeton ou mot. Le résultat est un modèle de base qui a acquis beaucoup de connaissances générales à partir du texte, mais qui n'est pas encore très utile pour des tâches spécifiques.

2. Affinage supervisé : Pour rendre le modèle de base plus utile, la deuxième étape est l'affinage supervisé. Dans cette étape, le modèle est entraîné sur des paires de questions-réponses ou d'instructions-réponses. L'entrée est une question ou une instruction, et la sortie est la réponse ou la réponse souhaitée. Cette étape permet au modèle d'apprendre des connaissances et des capacités spécifiques à la tâche.

3. Alignement des préférences : La troisième étape optionnelle est l'alignement des préférences, où le modèle est entraîné pour apprendre ce que l'utilisateur préfère en termes de réponses, ou pour aligner le modèle à certains principes. Cela se fait souvent en utilisant des techniques comme l'apprentissage par renforcement à partir des commentaires des humains (RLHF) ou l'optimisation de la politique de débat (DPO).

Il existe trois options populaires pour l'affinage supervisé :

1. Affinage complet : Dans cette approche, vous prenez le modèle d'origine et mettez à jour les poids avec le jeu de données d'affinage des instructions. Cela vous donnera les meilleures performances, mais l'exigence de VRAM sera élevée.

2. LoRA (Low-Rank Adaptation) : Au lieu de mettre directement à jour les poids, vous ajoutez des adaptateurs externes au modèle. Le nombre de paramètres dans ces adaptateurs externes peut être contrôlé. Les mises à jour de poids pour ces adaptateurs sont effectuées en précision 16 bits, puis fusionnées dans les poids du modèle d'origine. Cette approche offre un entraînement rapide, mais reste coûteuse en raison des opérations 16 bits.

3. QLoRA (Quantized LoRA) : C'est similaire à LoRA, mais les mises à jour de poids sont effectuées en précision 4 bits, et les poids du modèle sont également conservés en 4 bits. Cela nécessite moins de VRAM, mais les performances peuvent ne pas être aussi bonnes que LoRA ou l'affinage complet.

Pour configurer les adaptateurs LoRA, il y a quelques paramètres clés à prendre en compte :

1. Rang : Le rang des adaptateurs LoRA contrôle le nombre de paramètres qui seront mis à jour pendant l'affinage. Un rang plus faible signifie moins de paramètres, ce qui réduit les exigences de VRAM mais peut également limiter la capacité du modèle à s'adapter. Inversement, un rang plus élevé permet plus de flexibilité mais nécessite plus de VRAM.

2. LoRA Alpha : Ce paramètre contrôle la contribution des adaptateurs LoRA aux poids finaux du modèle. Une valeur LoRA Alpha plus élevée signifie que les adaptateurs LoRA auront une influence plus forte, tandis qu'une valeur plus faible signifie qu'ils auront une influence plus faible.

3. LoRA Dropout : Ce paramètre contrôle le taux de dropout appliqué aux adaptateurs LoRA pendant l'entraînement. Augmenter le taux de dropout peut aider à prévenir le surapprentissage, mais peut également réduire les performances du modèle.

Pour préparer les données pour l'affinage, nous devons configurer le modèle de prompt et spécifier le jeton de fin de séquence.

Le modèle de prompt est crucial, car il définit le format des données d'entrée sur lesquelles le modèle sera entraîné. Pour la famille Llama 3.1, nous utiliserons le modèle de prompt Alpaca, qui comprend une instruction et une entrée fournissant un contexte supplémentaire. Le modèle doit ensuite générer une réponse appropriée.

# Modèle de prompt Alpaca
prompt_template = "Voici une instruction décrivant une tâche associée à une entrée fournissant un contexte supplémentaire. Répondez avec une sortie pertinente.\n\nInstruction : {instruction}\nEntrée : {input}\nSortie :"

De plus, nous devons spécifier le jeton de fin de séquence pour empêcher le modèle de générer du texte indéfiniment. C'est une étape importante que de nombreuses personnes ont rencontrée lors de l'utilisation des versions quantifiées des modèles avec LamaCPP.

# Définir le jeton de fin de séquence
end_token = "</s>"

Pour entraîner le modèle, nous utiliserons le formateur SFT (Supervised Fine-Tuning) du package TRL, créé et maintenu par Hugging Face.

Tout d'abord, nous fournissons notre modèle, notre tokenizer et le jeu de données au formateur SFT. Dans ce cas, nous utilisons la colonne text du jeu de données, car nous avons configuré notre modèle de prompt pour utiliser ce champ.

Nous définissons également la longueur de séquence maximale, qui doit être basée sur les exemples de vos données d'entraînement. Gardez à l'esprit qu'une longueur de séquence plus élevée augmentera les exigences de VRAM.

Ensuite, nous configurons les arguments d'entraînement, comme le périphérique (dans ce cas, un GPU T4 sur Google Colab avec environ 15 Go de VRAM) et le nombre d'étapes d'entraînement.

Enfin, nous exécutons le formateur, et vous pouvez observer la diminution de la perte, ce qui est un bon indicateur de la progression de l'entraînement.

L'entraînement a pris environ 8 minutes, et la mémoire réservée maximale était d'environ 8 Go, soit environ 53% de la VRAM disponible sur le GPU T4. Cela démontre l'efficacité de l'approche Unsloth, qui permet l'affinage avec une exigence de VRAM relativement faible.

Pour effectuer des inférences, nous pouvons utiliser la classe ou la méthode for_inference de la classe FastLanguageModel. Nous devons fournir le modèle entraîné et l'invite d'entrée au format Alpaca. Nous pouvons également définir le nombre maximum de jetons à générer.

# Effectuer des inférences
input_prompt = alpaca_prompt(instruction, input)
output = model.for_inference(input_prompt, max_new_tokens=256)
print(output)

Pour activer le streaming, nous pouvons créer un objet Streamer et le passer à la méthode for_inference. Cela affichera les réponses un jeton à la fois.

# Activer le streaming
streamer = Streamer()
output = model.for_inference(input_prompt, max_new_tokens=256, streamer=streamer)

Avec cela, vous pouvez maintenant effectuer des inférences sur votre modèle affiné et même activer le streaming pour une expérience plus interactive.

Pour enregistrer le modèle affiné et le tokenizer, vous pouvez utiliser la fonction save_pretrained() sur le modèle et le tokenizer :

model.save_pretrained("chemin/pour/enregistrer/le/modèle")
tokenizer.save_pretrained("chemin/pour/enregistrer/le/tokenizer")

Cela enregistrera les poids du modèle et le tokenizer dans les répertoires spécifiés sous forme de fichiers JSON.

Pour charger le modèle et le tokenizer enregistrés, vous pouvez utiliser la même classe FastLanguageModel et fournir les répertoires locaux :

model = FastLanguageModel.from_pretrained("chemin/pour/enregistrer/le/modèle")
tokenizer = FastLanguageModel.from_pretrained("chemin/pour/enregistrer/le/tokenizer")

Cela chargera le modèle et le tokenizer à partir des fichiers enregistrés.

Une autre excellente fonctionnalité d'Unsloth est la possibilité d'enregistrer les modèles dans différents formats, comme la précision à virgule flottante 16 bits pour VLLM ou directement au format GGUF pour LamaCPP. Cela permet un déploiement et une intégration faciles avec diverses plateformes et frameworks.

Unsloth introduit également une nouvelle interface utilisateur basée sur Gradio, qui vous permet d'exécuter les modèles entraînés à l'aide d'Unsloth et de participer à des sessions de chat interactives. Vous pouvez cloner le référentiel Unsloth Studio et exécuter le notebook Colab fourni pour découvrir cette fonctionnalité.

Unsloth a introduit une nouvelle interface de chat basée sur la bibliothèque Radish, qui vous permet d'interagir facilement avec les modèles de langage entraînés à l'aide d'Unsloth. Cette interface de chat offre une interface conviviale pour discuter avec les modèles et explorer leurs capacités.

Pour utiliser l'interface de chat, vous pouvez cloner le référentiel Unsloth Studio et exécuter le notebook Google Colab fourni. Cela configurera l'environnement nécessaire et lancera l'interface de chat, où vous pourrez commencer à dialoguer avec le modèle de langage.

L'interface de chat prend en charge des fonctionnalités comme le streaming des réponses, vous permettant de voir la sortie du modèle au fur et à mesure qu'elle est générée. Cela peut être utile pour observer le processus de réflexion du modèle et la façon dont il génère les réponses.

De plus, l'interface de chat d'Unsloth vous permet d'enregistrer et de charger vos modèles affinés, ce qui facilite la poursuite du travail avec vos modèles de langage personnalisés. Vous pouvez également exporter vos modèles dans divers formats, comme la précision à virgule flottante 16 bits pour VLLM ou le format GGUF pour LamaCPP, offrant une flexibilité dans l'utilisation et le déploiement de vos modèles.

Dans l'ensemble, la nouvelle interface de chat d'Unsloth est un outil précieux pour interagir avec les modèles de langage entraînés à l'aide du cadre Unsloth et explorer leurs capacités.