# Démarrage rapide

Exécutez votre code Python sur les CPU et GPU de Hugging Face. Dans ce guide, vous exécuterez une commande simple sur un CPU, puis générerez du texte avec un petit modèle de langage sur un GPU.

Vous aurez besoin d'un compte Hugging Face avec des [crédits prépayés](https://huggingface.co/settings/billing). Consultez [Pricing and Billing](./jobs-pricing) pour les coûts de calcul.

## 1. Configurer l’interface en ligne de commande

[Installer le CLI Hugging Face](https://huggingface.co/docs/huggingface_hub/en/guides/cli#getting-started), puis vous connecter à votre compte :

```bash
>>> hf auth login
```

## 2. Exécuter Hello World

Exécutez cette commande dans votre terminal :

```bash
>>> hf jobs uv run python -c 'print("Hello from the cloud!")'
```

`hf jobs uv run` exécute la commande dans un environnement Python sur l’infrastructure Hugging Face. Il utilise un CPU par défaut et transmet les journaux du Job à votre terminal. Après le démarrage, vous verrez :

```text
Hello from the cloud!
```

La CLI affiche également l'ID de votre Job et un lien vers sa page. Ouvrez le lien pour consulter son statut et ses journaux dans votre navigateur. Vous pouvez retrouver vos Jobs sur votre [page Jobs](https://huggingface.co/settings/jobs), ou utiliser l'ID avec les commandes CLI ci-dessous.

Les jobs peuvent également exécuter une commande dans n'importe quelle image Docker :

```bash
>>> hf jobs run ubuntu echo 'Hello from the cloud!'
```

Le reste de ce guide utilise `hf jobs uv run`. Consultez [Utilisation des images Docker](./jobs-images) pour savoir quand et comment utiliser une image.

## 3. Exécuter un modèle sur un GPU

Exécutez ce script préparé pour générer un nom de robot. Vous pouvez [le consulter sur GitHub](https://github.com/huggingface/hub-docs/blob/main/examples/jobs/hello_gpu.py) ou lire le code ci-dessous.

```bash
hf jobs uv run \
    --flavor t4-small \
    --timeout 5m \
    https://raw.githubusercontent.com/huggingface/hub-docs/main/examples/jobs/hello_gpu.py
```

- `--flavor t4-small` sélectionne une machine équipée d’un GPU NVIDIA T4.
- `--timeout 5m` définit une limite de cinq minutes pour le Job.

Le Job télécharge le modèle et affiche sa réponse dans les journaux. Par exemple :

```text
RoboLearnbot
```

Voici le script complet :

```python
# /// script
# dependencies = ["torch", "transformers"]
# ///

from transformers import pipeline

generator = pipeline(
    "text-generation",
    model="HuggingFaceTB/SmolLM2-360M-Instruct",
    dtype="float16",
)
messages = [{
    "role": "user",
    "content": "Suggest a name for a robot that helps people learn Python. Answer with only the name.",
}]
outputs = generator(messages, max_new_tokens=48, do_sample=False, return_full_text=False)
print(outputs[0]["generated_text"])
```

L'[en-tête de dépendances](https://docs.astral.sh/uv/guides/scripts/#declaring-script-dependencies) indique à uv d'installer `torch` et `transformers` dans le Job. Vous pouvez également spécifier des dépendances avec `--with`. Vous n'avez besoin que du CLI `hf` localement.

Le script exécute [SmolLM2-360M-Instruct](https://huggingface.co/HuggingFaceTB/SmolLM2-360M-Instruct) sur le GPU du Job. `max_new_tokens` limite la longueur de la réponse.

Le temps de démarrage varie en fonction de la disponibilité du matériel, de l’installation des dépendances et des téléchargements de modèles.

> [!TIP]
> Appuyer sur Ctrl+C arrête le flux des journaux ; le Job continue de s’exécuter. Pour arrêter le Job, utilisez `hf jobs cancel JOB_ID` en remplaçant `JOB_ID` par l’ID affiché par le CLI.

Vous pouvez également lancer le même Job depuis Python avec le client [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/guides/jobs) :

```python
from huggingface_hub import run_uv_job

job = run_uv_job(
    "https://raw.githubusercontent.com/huggingface/hub-docs/main/examples/jobs/hello_gpu.py",
    flavor="t4-small",
    timeout="5m",
)
print(job.url)
```

## 4. Vérifiez votre résultat

Utilisez l’ID du Job GPU pour vérifier son statut et relire ses journaux :

```bash
>>> hf jobs inspect JOB_ID
>>> hf jobs logs JOB_ID
```

Une exécution réussie a le statut `COMPLETED`, et ses journaux contiennent la réponse générée.

La réponse reste disponible dans les journaux du Job après son achèvement. Lorsque vous adaptez le script pour produire des fichiers, [enregistrez ces résultats dans un bucket ou un dépôt Hub](./jobs-manage#persist-your-results) afin qu’ils survivent au Job.

## Essayez votre propre script (facultatif)

Copiez le code ci-dessus dans `hello_gpu.py`, modifiez le prompt dans `messages` et exécutez votre fichier local :

```bash
hf jobs uv run --flavor t4-small --timeout 5m hello_gpu.py
```

La CLI télécharge automatiquement votre script modifié. Remplacez `hello_gpu.py` par son chemin d’accès si vous l’avez enregistré ailleurs.

## Étapes suivantes

Construisez sur cet exemple avec une charge de travail plus importante :

- [Annoter un jeu de données avec de l'OCR, de la classification ou de l'inférence par lots](./jobs-examples#uv-scripts).
- [Entraîner ou affiner un modèle](./jobs-training) et l'enregistrer sur le Hub.
- [Lire des jeux de données ou des buckets et enregistrer les résultats traités](./jobs-large-datasets).
- [Exécuter des commandes dans des images Docker](./jobs-configuration#docker-jobs).
- [Utiliser des Jobs depuis un agent de codage](./jobs-examples#coding-agent-skills).