> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/notions-de-base/inference-and-deployment/deploying-llms-with-hugging-face-jobs.md).

# Déployer des LLM avec Hugging Face Jobs

Utiliser Hugging Face Jobs et Skills pour fine-tuner LFM avec Codex / Claude Code à l'aide d'un SKILL.

Ce guide explique comment utiliser [Unsloth](https://github.com/unslothai/unsloth) et [Liquid LFM2.5](/docs/fr/modeles/tutorials/lfm2.5.md) pour un fine-tuning rapide des LLM via des agents de codage comme [Claude Code](/docs/fr/notions-de-base/claude-code.md). Unsloth offre un entraînement \~2x plus rapide et \~60 % d'utilisation de VRAM en moins par rapport aux méthodes standard.

### Vous aurez besoin de

* Un [Hugging Face](https://huggingface.co) compte (requis pour HF Jobs)
* Un token Hugging Face avec des permissions d'écriture
* Un agent de codage (Open Code, Claude Code, Codex)
* Lisez notre [Claude Code](/docs/fr/notions-de-base/claude-code.md) guide sur leur configuration.

### Installation de la compétence

#### Claude Code

Claude Code découvre les compétences via son [système de plugins](https://code.claude.com/docs/en/discover-plugins).

1. Ajoutez la place de marché :

```bash
/plugin marketplace add huggingface/skills
```

2. Parcourez les compétences disponibles dans l'onglet **Découvrir** :

```bash
/plugin
```

3. Installez la compétence d'entraînement de modèle :

```bash
/plugin install hugging-face-model-trainer@huggingface-skills
```

Pour plus de détails, consultez la [documentation des plugins de Claude Code](https://code.claude.com/docs/en/discover-plugins) et les [documentation des compétences](https://code.claude.com/docs/en/skills).

#### Codex

Codex découvre les compétences via les [`AGENTS.md`](https://developers.openai.com/codex/guides/agents-md) fichiers et [`.agents/skills/`](https://developers.openai.com/codex/skills) répertoires.

**Installez des compétences individuelles avec `$skill-installer`**

{% code overflow="wrap" %}

```bash
$skill-installer install https://github.com/huggingface/skills/tree/main/skills/hugging-face-model-trainer
```

{% endcode %}

Pour plus de détails, consultez la [documentation des compétences Codex](https://developers.openai.com/codex/skills) et les [guide AGENTS.md](https://developers.openai.com/codex/guides/agents-md).

### Démarrage rapide

Une fois la compétence installée, demandez à votre agent de codage d'entraîner un modèle. Nous utilisons [Liquid LFM2.5](/docs/fr/modeles/tutorials/lfm2.5.md)

{% code overflow="wrap" %}

```
Train LiquidAI/LFM2.5-1.2B-Instruct sur trl-lib/Capybara en utilisant Unsloth sur HF Jobs
```

{% endcode %}

L'agent générera un script d'entraînement basé sur un [exemple dans la compétence](https://github.com/huggingface/skills/blob/main/skills/hugging-face-model-trainer/scripts/unsloth_sft_example.py), soumettra l'entraînement à HF Jobs et fournira un lien de suivi via Trackio.

### Utilisation de Hugging Face Jobs

Les jobs d'entraînement s'exécuteront sur [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs) — des GPU cloud entièrement gérés. Si vous connaissez les crédits Google Colab, Hugging Face Jobs propose aussi un système de crédits similaire. Il s'agit d'une formule Pay As You Go, ou vous pouvez obtenir des crédits à l'avance. L'agent :

1. Génère un script UV avec des dépendances intégrées
2. Le soumet à HF Jobs via le `hf` CLI
3. Indique l'ID du job et l'URL de suivi
4. Le modèle entraîné est poussé vers votre dépôt Hugging Face Hub

#### Exemple de script d'entraînement

La compétence génère des scripts comme celui-ci :

{% code expandable="true" %}

```py
# /// script
# dependencies = ["unsloth", "trl>=0.12.0", "datasets", "trackio"]
# ///

from unsloth import FastLanguageModel
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset

model, tokenizer = FastLanguageModel.from_pretrained(
    "Qwen/Qwen2.5-0.5B",
    load_in_4bit=True,
    max_seq_length=2048,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    lora_alpha=32,
    lora_dropout=0,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
)

dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    args=SFTConfig(
        output_dir="./output",
        push_to_hub=True,
        hub_model_id="username/my-model",
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        num_train_epochs=1,
        learning_rate=2e-4,
        report_to="trackio",
    ),
)

trainer.train()
trainer.push_to_hub()
```

{% endcode %}

Le coût de l'entraînement avec Hugging Face Jobs est indiqué ci-dessous :

| Taille du modèle      | GPU recommandé | Coût approximatif/heure |
| --------------------- | -------------- | ----------------------- |
| <1 Md de paramètres   | `t4-small`     | \~$0.40                 |
| 1-3 Md de paramètres  | `t4-medium`    | \~$0.60                 |
| 3-7 Md de paramètres  | `a10g-small`   | \~$1.00                 |
| 7-13 Md de paramètres | `a10g-large`   | \~$3.00                 |

Pour un aperçu complet de la tarification des espaces Hugging Face, consultez le guide [ici](https://huggingface.co/docs/hub/en/spaces-overview#hardware-resources).

### Conseils pour travailler avec des agents de codage

* Soyez précis sur le modèle et le jeu de données à utiliser et incluez les identifiants Hub (par ex., `Qwen/Qwen2.5-0.5B`, `trl-lib/Capybara`). Les agents rechercheront et valideront ces combinaisons.
* Mentionnez explicitement Unsloth si vous voulez qu'il soit utilisé. Sinon, l'agent choisira le framework en fonction du modèle et du budget.
* Demandez des estimations de coût avant de lancer de gros jobs
* Demandez un suivi Trackio pour des courbes de perte en temps réel
* Vérifiez l'état du job en demandant à l'agent d'inspecter les journaux après la soumission

### Ressources

* [Dépôt des compétences Hugging Face](https://github.com/huggingface/skills)

{% embed url="<https://youtu.be/Gh5P4niIFNA>" %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/fr/notions-de-base/inference-and-deployment/deploying-llms-with-hugging-face-jobs.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.