Unslot est un outil incroyable qui vous permet d'affiner efficacement le modèle LLAMA-3 sur votre propre ensemble de données. Voici un guide étape par étape sur la façon de procéder :

1. Installer les packages requis : Commencez par cloner le dépôt GitHub d'Unslot et installez les packages nécessaires en fonction de votre configuration matérielle.

2. Définir les paramètres d'entraînement : Définissez vos paramètres d'entraînement, tels que la longueur de séquence maximale, les types de données et la méthode de quantification. Unslot utilise des adaptateurs Lora pour permettre un affinage efficace.

3. Formater vos données d'entraînement : Assurez-vous que vos données sont structurées dans le format requis, avec des colonnes pour l'instruction, l'entrée et la sortie. Unslot fournit des exemples utilisant le jeu de données Alpaca, mais vous pouvez l'adapter à vos propres données.

4. Configurer le formateur SFT : Créez un objet SFT (Supervised Fine-Tuning) Trainer à partir de la bibliothèque Hugging Face Transformers, en spécifiant le modèle, le tokenizer, le jeu de données et d'autres paramètres d'entraînement.

5. Entraîner le modèle : Appelez la fonction train() sur l'objet SFT Trainer pour démarrer le processus d'affinage. L'utilisation optimisée de la mémoire et la vitesse d'Unslot assurent un entraînement efficace, même avec des ressources GPU limitées.

6. Effectuer des inférences : Après l'entraînement, vous pouvez utiliser la classe FastLanguageModel spécifique à Unslot pour générer des réponses à partir de votre modèle affiné. Unslot fournit également des options pour enregistrer le modèle et charger les adaptateurs Lora pour une utilisation future.

7. Explorer les fonctionnalités supplémentaires : Unslot offre des fonctionnalités avancées, comme la possibilité d'utiliser le modèle avec d'autres frameworks comme PyTorch Lightning et l'option de convertir le modèle au format GGML pour une utilisation avec LLAMA-CPP ou GoLLAMA.

L'approche Unslot pour l'affinage de LLAMA-3 est très efficace, en tirant parti d'une utilisation optimisée de la mémoire et de la vitesse. Il fournit une solution conviviale et complète, en faisant un excellent choix pour l'affinage de modèles de langage de grande taille sur vos propres données.

Tout d'abord, nous devons importer les classes nécessaires de la bibliothèque unslot :

from unslot.models.fast_language_model import FastLanguageModel

Ensuite, nous configurons les paramètres d'entraînement :

• max_sequence_length : La longueur de séquence maximale pour l'entrée. Nous la fixons à 248 tokens, car le jeu de données que nous utilisons a un texte relativement court.
• data_type : Nous utilisons la quantification 4 bits pour un entraînement efficace.

max_sequence_length = 248
data_type = "4bit"

Unslot utilise des adaptateurs Lora pour permettre un affinage efficace. Il y a deux options :

1. Utiliser un modèle préchargé du dépôt Hugging Face d'unslot, qui a déjà les adaptateurs Lora fusionnés.
2. Utiliser un modèle du dépôt Hugging Face et ajouter les adaptateurs Lora vous-même.

Dans ce cas, nous utiliserons le modèle préchargé, donc nous n'avons pas besoin d'étapes supplémentaires.

model = FastLanguageModel.from_pretrained("unslot/alpaca-7b")

Si vous devez utiliser un autre modèle et ajouter les adaptateurs Lora vous-même, vous pouvez décommenter la section suivante et fournir les paramètres nécessaires.

# model_id = "your-hugging-face-model-id"
# model = FastLanguageModel.from_pretrained(model_id)
# model.add_lora_adapters()

Maintenant, nous sommes prêts à passer à l'étape suivante : le formatage des données d'entraînement.

Pour affiner le modèle Lama 3 à l'aide d'Unslot, vous devez formater vos données d'entraînement d'une manière spécifique. Le jeu de données utilisé dans l'exemple a trois colonnes : instruction, entrée et sortie.

La colonne d'instruction contient la description de la tâche que le modèle doit effectuer. La colonne d'entrée fournit un contexte supplémentaire pour la tâche, et la colonne de sortie contient la réponse attendue du modèle.

Lors du formatage de vos propres données, assurez-vous de les structurer de la même manière, avec les colonnes d'instruction, d'entrée et de sortie. Si l'entrée est manquante pour un exemple particulier, ce n'est pas grave, car l'instruction seule peut fournir les informations nécessaires pour que le modèle génère la sortie.

Après avoir téléchargé les données, vous devez transformer les trois colonnes en une seule chaîne de texte qui suit un format spécifique. Ce format inclut des jetons spéciaux pour l'instruction, l'entrée et la réponse. Le code de l'exemple montre comment effectuer cette transformation, en créant une seule colonne qui peut être utilisée pour entraîner le modèle.

Il est important de noter que bien que l'exemple utilise le jeu de données standard Alpaca, vous pouvez également structurer vos données à l'aide d'autres modèles d'invite, comme le format ChatML introduit par OpenAI. Assurez-vous simplement de formater correctement vos exemples d'entrée, car ils seront transmis au modèle de langage pendant l'entraînement.

Tout d'abord, nous devons configurer les paramètres d'entraînement. Nous importerons la classe FastLanguageModel d'Unslot et définirons la longueur de séquence maximale, les types de données et la méthode de quantification.

Ensuite, nous gérerons le cas où nous devons ajouter des adaptateurs Lora au modèle. Si nous utilisons un modèle du dépôt Hugging Face, nous devrons peut-être fournir un jeton pour accepter les conditions d'utilisation.

Maintenant, nous devons formater les données d'entraînement. Le jeu de données doit avoir trois colonnes : instruction, entrée et sortie. Nous téléchargerons les données de Hugging Face et les mapperons à ce format.

Nous configurerons ensuite le formateur Supervised Fine-Tuning à partir de la bibliothèque Hugging Face Transformers. Ce formateur acceptera l'objet modèle, le tokenizer, le jeu de données et d'autres paramètres comme l'optimiseur, le calendrier du taux d'apprentissage et le répertoire de sortie.

Enfin, nous appellerons la fonction train() sur l'objet du formateur. Nous observerons la diminution de la perte d'entraînement, indiquant que le modèle apprend. Notez que nous n'exécutons qu'un petit sous-ensemble des données pour cet exemple, mais vous voudrez le faire tourner pendant au moins une époque ou deux pour obtenir de meilleurs résultats.

Après l'entraînement, nous pouvons enregistrer le modèle et charger les adaptateurs Lora pour l'inférence. Unslot fournit également des options pour utiliser le modèle avec d'autres frameworks comme PyTorch Lightning et TensorFlow.

Une fois le modèle entraîné, vous pouvez l'utiliser pour l'inférence. Unslot fournit une interface simple pour cela :

1. Importez la classe FastLanguageModel d'Unslot.
2. Fournissez le modèle entraîné et dites-lui d'effectuer l'inférence.
3. Tokenisez l'entrée en utilisant le format Alpaca (instruction, entrée et sortie attendue).
4. Déplacez les entrées sur le GPU pour tirer parti des ressources disponibles.
5. Appelez la fonction generate, en fournissant les entrées tokenisées, le nombre maximum de tokens à générer et si vous voulez utiliser la mise en cache.

Le modèle générera alors une réponse en fonction de l'entrée fournie. Vous pouvez également utiliser la classe TextStreamer pour diffuser la réponse textuelle.

Après l'entraînement, vous pouvez enregistrer le modèle de différentes manières :

• Poussez le modèle sur le Hugging Face Hub, ce qui enregistrera les adaptateurs Lora séparément.
• Enregistrez le modèle localement, là encore en enregistrant les adaptateurs Lora séparément.

Pour charger le modèle enregistré pour l'inférence, vous pouvez définir un indicateur pour fusionner les adaptateurs Lora avec le modèle.

Unslot fournit également d'autres options pour l'inférence, comme l'utilisation de la classe AutoModelForCausalLM de la bibliothèque Hugging Face Transformers, qui peut être plus lente mais vous permet d'utiliser le modèle avec d'autres outils comme LLaMA-CPP ou GoLLAMA.

Une fois le modèle entraîné, vous pouvez l'enregistrer de différentes manières pour l'utiliser pour l'inférence plus tard. Unslot fournit plusieurs options pour enregistrer et charger le modèle affiné :

1. Enregistrer sur le Hugging Face Hub : Vous pouvez pousser le modèle affiné sur le Hugging Face Hub, ce qui vous permet de le partager et de l'utiliser avec d'autres. Pour ce faire, vous devez fournir votre jeton Hugging Face.

model.push_to_hub("your-model-name")

2. Enregistrer localement : Vous pouvez également enregistrer le modèle localement, ce qui n'enregistrera que les adaptateurs Lora, pas le modèle complet. Cela vous permet de charger facilement les adaptateurs Lora et de les fusionner avec le modèle de base plus tard.

model.save_pretrained("path/to/save/model")

3. Charger les adaptateurs Lora enregistrés : Lorsque vous voulez utiliser le modèle affiné pour l'inférence, vous pouvez charger les adaptateurs Lora enregistrés et les fusionner avec le modèle de base.

model = FastLLamaForCausalLM.from_pretrained("path/to/base/model")
model.load_adapter("path/to/saved/model")

4. Convertir au format GGML : Unslot fournit également la possibilité de convertir le modèle affiné au format GGML, qui peut être utilisé avec des outils comme Llama-CPP ou GoLlama. Cela vous permet d'utiliser le modèle sur des environnements uniquement CPU.

model.save_pretrained("path/to/save/model", quantization_method="nf16")

En tirant parti de ces options, vous pouvez facilement enregistrer, charger et utiliser le modèle affiné pour diverses utilisations, y compris le déploiement dans différents environnements et le partage avec la communauté.

L'article fournit un guide complet sur la façon d'affiner le modèle Lama 3 à l'aide du package Unslot. Les points clés abordés dans cette section sont :

1. Unslot offre un moyen efficace et optimisé d'affiner Lama 3 et d'autres modèles de langage, avec des fonctionnalités comme une utilisation réduite de la mémoire et un entraînement plus rapide.
2. L'article décrit les étapes pour configurer l'environnement d'entraînement, formater les données et entraîner le modèle à l'aide des classes et méthodes spécifiques à Unslot.
3. Il montre également comment effectuer des inférences à l'aide du modèle affiné, à la fois via l'interface Unslot et en convertissant le modèle à d'autres formats comme ONNX pour une utilisation avec d'autres outils d'inférence.
4. L'auteur souligne les avantages d'Unslot, comme sa capacité à gérer les contraintes GPU et la facilité d'utilisation par rapport à d'autres options d'affinage comme AutoTrain.
5. L'article conclut en encourageant les lecteurs à explorer Unslot et d'autres outils d'affinage, et les invite à contacter en cas de questions ou de problèmes rencontrés.