Claude affine des LLM open source avec Hugging Face Skills

Claude affine des LLM open source avec Hugging Face Skills

Nous avons donné à Claude la capacité d'affiner (fine-tuner) des modèles de langage grâce à un nouvel outil appelé Hugging Face Skills. Concrètement, Claude ne se contente pas d'écrire des scripts d'entraînement : il soumet réellement des jobs sur des GPU dans le cloud, suit leur progression et publie les modèles finalisés sur le Hugging Face Hub. Ce tutoriel vous montre précisément comment cela fonctionne et comment l'utiliser vous-même.

Claude Code peut utiliser des « skills », c'est-à-dire des instructions, des scripts et des connaissances métier regroupés en paquets, pour accomplir des tâches spécialisées. Le skill hf-llm-trainer apprend à Claude tout ce qu'il doit savoir sur l'entraînement : quel GPU choisir selon la taille de votre modèle, comment configurer l'authentification au Hub, quand utiliser LoRA plutôt qu'un fine-tuning complet, et comment gérer les dizaines d'autres décisions qui conditionnent la réussite d'un entraînement.

Avec ce skill, vous pouvez dire à Claude des choses comme : Affine Qwen3-0.6B sur le dataset trl-lib/Capybara

Et Claude va :

• Valider le format de votre dataset
• Sélectionner le matériel approprié (t4-small pour un modèle de 0.6B)
• Utiliser et adapter un script d'entraînement avec un suivi Trackio
• Soumettre le job à Hugging Face Jobs
• Vous communiquer l'identifiant du job et son coût estimé
• Vérifier la progression quand vous le lui demandez
• Vous aider à déboguer en cas de problème

Le modèle s'entraîne sur les GPU de Hugging Face pendant que vous faites autre chose. Une fois l'entraînement terminé, votre modèle affiné apparaît sur le Hub, prêt à l'emploi.

Il ne s'agit pas d'une simple démo. Le skill prend en charge les mêmes méthodes d'entraînement que celles utilisées en production : le fine-tuning supervisé, l'optimisation directe des préférences et l'apprentissage par renforcement avec récompenses vérifiables. Vous pouvez entraîner des modèles de 0.5B à 70B paramètres, les convertir au format GGUF pour un déploiement local et exécuter des pipelines en plusieurs étapes qui combinent différentes techniques.

Configuration et installation

Avant de commencer, vous aurez besoin :

• D'un compte Hugging Face avec un abonnement Pro ou Team (Jobs nécessite un abonnement payant)
• D'un token avec droits d'écriture, à créer sur huggingface.co/settings/tokens
• D'un agent de code comme Claude Code, OpenAI Codex ou Gemini CLI de Google

Les Hugging Face Skills sont compatibles avec Claude Code, Codex et Gemini CLI. Des intégrations avec Cursor, Windsurf et Continue sont en préparation.

Claude Code

Enregistrez le dépôt comme marketplace de plugins : /plugin marketplace add huggingface/skills

Pour installer un skill, exécutez : /plugin install <skill-folder>@huggingface-skills

Par exemple : /plugin install hf-llm-trainer@huggingface-skills

Codex

Codex identifie les skills grâce au fichier AGENTS.md. Vous pouvez vérifier que les instructions sont bien chargées avec : codex --ask-for-approval never "Summarize the current instructions."

Pour plus de détails, consultez le guide AGENTS de Codex.

Gemini CLI

Ce dépôt contient un fichier gemini-extension.json pour l'intégration avec Gemini CLI.

Installation en local : gemini extensions install . --consent

ou via l'URL GitHub : gemini extensions install https://github.com/huggingface/skills.git --consent

Pour plus d'aide, consultez la documentation des extensions de Gemini CLI.

Se connecter à Hugging Face

Vous devrez authentifier votre compte Hugging Face avec un token disposant des droits d'écriture, afin que le job puisse créer un dépôt de modèle.

Configurez votre token : hf auth login

ou

export HF_TOKEN=hf_your_write_access_token_here

REMARQUE : configurez le serveur MCP de Hugging Face pour qu'il utilise votre token d'écriture, en l'envoyant soit dans l'en-tête HTTP HF_TOKEN, soit dans l'en-tête Authorization: Bearer.

Votre premier entraînement

Prenons un exemple complet. Nous allons affiner un petit modèle pour découvrir l'ensemble du workflow, puis explorer des fonctionnalités plus avancées.

Donner les instructions à l'agent de code

Commencez par une instruction simple et claire pour affiner un modèle précis : Affine Qwen3-0.6B sur le dataset open-r1/codeforces-cots pour le suivi d'instructions.

L'agent de code analyse votre demande et prépare une configuration d'entraînement. Pour un modèle de 0.6B sur un dataset de démonstration, il sélectionne t4-small : un GPU suffisant pour cette taille de modèle et l'option la moins chère disponible.

Le dataset open-r1/codeforces-cots regroupe des problèmes Codeforces et leurs solutions. C'est un bon dataset pour l'instruction tuning d'un modèle destiné à résoudre des problèmes de programmation difficiles.

Vérifier avant de soumettre

Avant que votre agent de code ne soumette quoi que ce soit, la configuration s'affiche : Je vais affiner Qwen/Qwen3-0.6B sur open-r1/codeforces-cots avec SFT. Configuration :

• Matériel : t4-small (~0,75 $/heure)
• Durée estimée : ~20 minutes
• Coût estimé : ~0,30 $
• Sortie : username/qwen-codeforces-cots-sft Le modèle sera automatiquement publié sur le Hub. Dois-je le soumettre ?

C'est le moment d'ajuster ce que vous voulez. Modifiez le nom du dépôt de sortie, choisissez un autre matériel ou demandez à Claude de modifier les paramètres d'entraînement.

Par exemple, vous pouvez demander à l'agent de faire un essai : Fais un test rapide sur 100 exemples.

Suivre la progression

Une fois le job soumis, vous obtenez ses détails : ✅ Job soumis avec succès ! ID du job : abc123xyz Suivi : https://huggingface.co/jobs/username/abc123xyz Durée prévue : ~20 minutes Coût estimé : ~0,30 $ Métriques en temps réel : https://huggingface.co/spaces/username/trackio

Le skill intègre Trackio, ce qui vous permet de voir la loss d'entraînement diminuer en temps réel. Les jobs s'exécutent de manière asynchrone : vous pouvez fermer votre terminal et revenir plus tard. Lorsque vous voulez un point d'étape : Où en est mon job d'entraînement ?

L'agent récupère alors les logs et résume la progression.

Utiliser votre modèle

Une fois l'entraînement terminé, votre modèle est sur le Hub : from transformers import AutoModelForCausalLM, AutoTokenizer model = AutoModelForCausalLM.from_pretrained("username/qwen-codeforces-cots-sft") tokenizer = AutoTokenizer.from_pretrained("username/qwen-codeforces-cots-sft")

Voilà la boucle complète. Vous avez décrit ce que vous vouliez en langage courant, et l'agent s'est chargé du choix du GPU, de la génération du script, de la soumission du job, de l'authentification et de la persistance. Le tout pour environ trente centimes.

Méthodes d'entraînement

Le skill prend en charge trois approches d'entraînement. Savoir quand utiliser chacune d'elles vous aide à obtenir de meilleurs résultats.

Fine-tuning supervisé (SFT)

Le SFT est le point de départ de la plupart des projets. Vous fournissez des données de démonstration, c'est-à-dire des exemples d'entrées et des sorties attendues, et l'entraînement ajuste le modèle pour qu'il reproduise ces schémas.

Utilisez le SFT lorsque vous disposez d'exemples de qualité du comportement souhaité : conversations de support client, paires de génération de code, Q&R spécialisées, bref tout ce qui permet de montrer au modèle à quoi ressemble un bon résultat.

Affine Qwen3-0.6B sur my-org/support-conversations pendant 3 epochs.

L'agent valide le dataset, sélectionne le matériel (a10g-large avec LoRA pour un modèle de 7B) et configure l'entraînement avec des checkpoints et un suivi.

Pour les modèles de plus de 3B paramètres, l'agent utilise automatiquement LoRA (Low-Rank Adaptation) pour réduire les besoins en mémoire. Il devient ainsi possible d'entraîner des modèles de 7B ou 13B sur un seul GPU tout en conservant l'essentiel de la qualité d'un fine-tuning complet.

Optimisation directe des préférences (DPO)

Le DPO s'entraîne sur des paires de préférences : des réponses dont l'une est « choisie » et l'autre « rejetée ». Cela aligne les sorties du modèle sur les préférences humaines, généralement après une première étape de SFT.

Utilisez le DPO lorsque vous disposez d'annotations de préférence issues d'annotateurs humains ou de comparaisons automatisées. Le DPO optimise directement en faveur de la réponse préférée, sans nécessiter de modèle de récompense distinct.

Lance un DPO sur my-org/preference-data pour aligner le modèle SFT que je viens d'entraîner.

Le dataset comporte des colonnes 'chosen' et 'rejected'.

Le DPO est sensible au format du dataset. Il exige des colonnes nommées exactement chosen et rejected, ou une colonne prompt contenant l'entrée. L'agent le vérifie d'abord et vous montre comment faire correspondre les colonnes si votre dataset utilise d'autres noms.

Group Relative Policy Optimization (GRPO)

Le GRPO est une méthode d'apprentissage par renforcement dont l'efficacité est prouvée sur les tâches vérifiables, comme résoudre des problèmes mathématiques, écrire du code ou toute tâche dotée d'un critère de réussite programmatique.

Entraîne un modèle de raisonnement mathématique avec GRPO sur le dataset openai/gsm8k, à partir de Qwen3-0.6B.

Le modèle génère des réponses, reçoit des récompenses en fonction de leur exactitude et apprend de ces résultats. C'est plus complexe que le SFT ou le DPO, mais la configuration est similaire.

Matériel et coûts

L'agent sélectionne le matériel en fonction de la taille de votre modèle, mais comprendre les compromis vous aide à prendre de meilleures décisions.

Correspondance entre taille de modèle et GPU

• Pour les très petits modèles de moins de 1B paramètres, t4-small fait très bien l'affaire. Ces modèles s'entraînent rapidement : comptez 1 à 2 $ pour un entraînement complet. C'est idéal pour l'apprentissage ou l'expérimentation.
• Pour les petits modèles (1-3B), passez à t4-medium ou a10g-small. L'entraînement prend quelques heures et coûte de 5 à 15 $.
• Pour les modèles moyens (3-7B), il vous faut a10g-large ou a100-large avec LoRA. Un fine-tuning complet ne tient pas en mémoire, mais LoRA rend ces modèles tout à fait entraînables. Prévoyez de 15 à 40 $ pour la production.
• Pour les grands modèles (7B et plus), ce job HF Skills n'est pas adapté.

Démo ou production

Lorsque vous testez un workflow, commencez petit : Fais un test rapide de SFT sur Qwen-0.6B avec 100 exemples de my-org/support-conversations.

L'agent de code configure un entraînement minimal, suffisant pour vérifier que votre pipeline fonctionne sans coût réel.

Pour la production, soyez explicite : Lance un SFT de Qwen-0.6B pour la production sur l'intégralité de my-org/support-conversations. Checkpoints tous les 500 steps, 3 epochs, learning rate cosinus.

Lancez toujours une démo avant de vous engager dans un job de production de plusieurs heures. Une démo à 0,50 $ qui détecte une erreur de format vous évite un entraînement raté à 30 $.

Fonctionnalités avancées

Validation des datasets

Le format du dataset est la cause la plus fréquente d'échec des entraînements. L'agent peut valider les datasets avant que vous ne dépensiez du temps GPU.

Vérifie si my-org/conversation-data convient pour un entraînement SFT.

L'agent effectue une inspection rapide sur CPU (pour une fraction de centime) et indique : Validation du dataset my-org/conversation-data : SFT : ✓ PRÊT Colonne 'messages' trouvée au format conversationnel DPO : ✗ INCOMPATIBLE Colonnes 'chosen' et 'rejected' manquantes

Si votre dataset doit être transformé, l'agent peut vous montrer comment faire : Mon dataset DPO utilise 'good_response' et 'bad_response' au lieu de 'chosen' et 'rejected'. Comment corriger cela ?

L'agent fournit le code de correspondance et peut l'intégrer directement à votre script d'entraînement.

Suivi de l'entraînement

Le suivi en temps réel vous aide à repérer les problèmes tôt. Le skill configure Trackio par défaut : après avoir soumis un job, vous pouvez suivre les métriques sur : https://huggingface.co/spaces/username/trackio

Vous y voyez la loss d'entraînement, le learning rate et les métriques de validation. Un entraînement sain affiche une loss en baisse régulière.

Interrogez l'agent sur l'état du job à tout moment : Quel est l'état de mon job d'entraînement ?

Le job abc123xyz est en cours d'exécution (45 minutes écoulées) Step actuel : 850/1200 Loss d'entraînement : 1.23 (↓ depuis 2.41 au départ) Learning rate : 1.2e-5 Fin estimée : ~20 minutes

En cas de problème, l'agent vous aide à établir le diagnostic. Mémoire insuffisante ? L'agent suggère de réduire la taille des batchs ou de passer à un matériel plus puissant. Erreur de dataset ? L'agent identifie l'incohérence. Délai dépassé ? L'agent recommande une durée plus longue ou des paramètres d'entraînement plus rapides.

Conversion au format GGUF

Après l'entraînement, vous voudrez peut-être exécuter votre modèle en local. Le format GGUF fonctionne avec llama.cpp et les outils qui en dépendent, comme LM Studio, Ollama, etc.

Convertis mon modèle affiné au format GGUF avec une quantification Q4_K_M. Publie-le sur username/my-model-gguf.

L'agent soumet un job de conversion qui fusionne les adaptateurs LoRA, convertit le modèle au format GGUF, applique la quantification et le publie sur le Hub.

Utilisez-le ensuite en local : llama-server -hf <username>/<model-name>:<quantization>

Par exemple, pour exécuter le modèle Qwen3-1.7B-GGUF sur votre machine locale :

llama-server -hf unsloth/Qwen3-1.7B-GGUF:Q4_K_M

Et ensuite ?

Nous avons montré que des agents de code comme Claude Code, Codex ou Gemini CLI peuvent gérer l'ensemble du cycle de vie du fine-tuning d'un modèle : validation des données, choix du matériel, génération des scripts, soumission des jobs, suivi de la progression et conversion des résultats. Ce qui relevait jusqu'ici d'une compétence spécialisée devient accessible par simple conversation.

Quelques idées à essayer :

• Affiner un modèle sur votre propre dataset
• Construire un modèle aligné sur les préférences avec SFT → DPO
• Entraîner un modèle de raisonnement avec GRPO sur des mathématiques ou du code
• Convertir un modèle au format GGUF et l'exécuter avec Ollama

Le skill est open source. Vous pouvez l'enrichir, l'adapter à vos workflows ou vous en servir comme point de départ pour d'autres scénarios d'entraînement.

Ressources

• SKILL.md : documentation complète du skill
• Training Methods : SFT, DPO et GRPO expliqués
• Hardware Guide : choix des GPU et coûts
• TRL Documentation : la bibliothèque d'entraînement sous-jacente
• Hugging Face Jobs : l'infrastructure d'entraînement dans le cloud
• Trackio : suivi de l'entraînement en temps réel