Torchtune : Un outil puissant pour fine-tuner les LLM
PyTorch vient de dévoiler Torchtune, une nouvelle bibliothèque native en phase alpha qui va révolutionner le fine-tuning des grands modèles de langage (LLM)[1][2]. Cette boîte à outils flexible et modulaire permet aux développeurs de personnaliser facilement des modèles pour leurs besoins spécifiques, même sur des GPU grand public comme les NVIDIA 3090/4090[2].
Caractéristiques principales
Torchtune se distingue par plusieurs aspects clés :
Facilité d’extension : Les développeurs peuvent modifier et adapter les méthodes de fine-tuning à leurs besoins grâce à une philosophie de conception Python ouverte[1].
Démocratisation du fine-tuning : L’outil est accessible aux utilisateurs de tous niveaux, des débutants aux experts[1].
Interopérabilité : Torchtune s’intègre parfaitement à l’écosystème open-source des LLM, offrant une grande flexibilité d’utilisation[1][2].
Intégrations notables
Torchtune s’interface avec de nombreux outils populaires :
- Hugging Face Hub pour l’accès aux modèles et datasets
- PyTorch FSDP pour l’entraînement distribué
- Weights & Biases pour le suivi et la journalisation
- EleutherAI’s LM Evaluation Harness pour l’évaluation des modèles
- ExecuTorch pour l’inférence efficace
- Torchao pour la quantification des modèles[1]
pip install torch torchtune
Torchtune représente une avancée significative dans le domaine du fine-tuning des LLM. En démocratisant l’accès à ces techniques avancées et en favorisant la collaboration au sein de la communauté open-source, Torchtune ouvre la voie à de nouvelles innovations dans le développement de LLM puissants et adaptables[1].
Citations:
[1] https://favtutor.com/articles/pytorch-torchtune/
[2] https://korben.info/pytorch-devoile-torchtune-pour-dompter-les-llm.html
Recettes de fine-tuning
LoRA (Low-Rank Adaptation)
LoRA est une technique de fine-tuning qui permet d’adapter efficacement les grands modèles de langage (LLM) :
- Au lieu d’ajuster tous les poids du modèle, LoRA ajoute de petites matrices de rang faible aux couches d’attention.
- Ces matrices sont entraînées sur la tâche spécifique, tandis que les poids originaux restent figés.
- Avantages : réduction significative du nombre de paramètres à entraîner, économie de mémoire, et prévention du surapprentissage.
QLoRA (Quantized LoRA)
QLoRA est une version optimisée de LoRA qui pousse encore plus loin l’efficacité mémoire :
- Le modèle de base est chargé en mémoire GPU avec une quantification 4-bit.
- Seuls les adaptateurs LoRA sont entraînés en précision complète.
- Permet le fine-tuning de très grands modèles sur des GPU grand public avec une qualité préservée.
Utilisation de Torchtune pour créer un modèle compatible Ollama
Pour utiliser Torchtune et produire un modèle compatible avec Ollama :
- Effectuez le fine-tuning avec Torchtune :
Ce code effectue les étapes suivantes :
- Il extrait le texte de tous les fichiers PDF dans le dossier spécifié.
- Il utilise ce texte comme données d’entraînement pour le fine-tuning.
- Il configure une recette de fine-tuning utilisant LoRA.
- Il initialise le Tuner avec cette recette et lance le processus de fine-tuning.
- Enfin, il sauvegarde le modèle fine-tuné.
import os
from torchtune import Tuner, Recipe
from PyPDF2 import PdfReader
# Fonction pour extraire le texte des PDFs
def extract_text_from_pdfs(pdf_dir):
text_data = []
for file in os.listdir(pdf_dir):
if file.endswith('.pdf'):
reader = PdfReader(os.path.join(pdf_dir, file))
for page in reader.pages:
text_data.append(page.extract_text())
return ' '.join(text_data)
# Chemin vers le dossier contenant les PDFs
pdf_dir = '~/Astroport/IA/PDF/'
# Extraction du texte des PDFs
training_data = extract_text_from_pdfs(pdf_dir)
# Configuration de la recette de fine-tuning avec LoRA
recipe = Recipe(
model="llama2", # Spécifiez ici le modèle de base que vous souhaitez utiliser
dataset=training_data,
lora_config={
"r": 8,
"alpha": 16,
"target_modules": ["q_proj", "v_proj"]
}
)
# Initialisation du Tuner et lancement du fine-tuning
tuner = Tuner(recipe)
tuner.tune()
# Sauvegarde du modèle fine-tuné
tuner.save_model('mon_modele_fine_tune')
- Convertissez le modèle au format GGUF (compatible Ollama) :
python -m transformers.models.llama.convert_llama_weights_to_gguf \
--input_dir chemin/vers/mon_modele_fine_tune \
--output_file mon_modele.gguf \
--model_size 7B
- Créez un fichier Modelfile pour Ollama :
FROM mon_modele.gguf
PARAMETER stop "Human:"
PARAMETER stop "Assistant:"
SYSTEM Vous êtes un assistant IA utile et amical.
- Importez le modèle dans Ollama :
ollama create mon_modele_custom -f Modelfile
- Utilisez votre modèle personnalisé :
ollama run mon_modele_custom
En suivant ces étapes, vous pouvez utiliser Torchtune pour fine-tuner votre modèle avec LoRA ou QLoRA, puis le rendre compatible avec Ollama pour une utilisation locale. N’oubliez pas que la conversion au format GGUF et la création du Modelfile sont des étapes cruciales pour assurer la compatibilité avec Ollama[6][7].
Citations:
[1] https://www.databricks.com/blog/efficient-fine-tuning-lora-guide-llms
[2] https://www.linkedin.com/pulse/in-depth-guide-fine-tuning-llms-lora-qlora-enhancing-mba-ms-phd-btnoc
[3] https://github.com/artidoro/qlora/actions
[4] https://infohub.delltechnologies.com/en-us/p/fine-tuning-llama-3-using-torchtune-a-new-pytorch-native-library-on-the-dell-poweredge-xe9680-server/
[5] https://wandb.ai/byyoung3/mlnews2/reports/Fine-Tuning-Llama-3-with-LoRA-TorchTune-vs-HuggingFace--Vmlldzo3NjE3NzAz
[6] https://github.com/ollama/ollama/issues/2515
[7] https://github.com/ollama/ollama/issues/335
[8] https://github.com/ollama/ollama/issues/4016
Torchtune
Un outil puissant pour fine-tuner les LLM