> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Premiers pas avec W&B Models

> Découvrez W&B Models en suivant vos expériences, en consignant des métriques et en visualisant les résultats en quelques lignes de code.

Découvrez quand et comment utiliser W\&B pour suivre, partager et gérer des artifacts de modèle dans vos flux de travail de machine learning. Cette page explique comment journaliser des expériences, générer des rapports et accéder aux données journalisées à l’aide de l’API W\&B adaptée à chaque tâche.

Ce tutoriel utilise les éléments suivants :

* [SDK Python W\&B](/fr/products/wandb/ref/python) (`wandb.sdk`) : pour journaliser et surveiller les expériences pendant l’entraînement.
* [API publique de W\&B](/fr/products/wandb/ref/python/public-api) (`wandb.apis.public`) : pour interroger et analyser les données d’expérience journalisées.
* [API W\&B Reports and Workspaces](/fr/products/wandb/ref/wandb_workspaces) (`wandb.wandb-workspaces`) : pour créer un rapport qui synthétise vos constats.

<h2 id="sign-up-and-create-an-api-key">
  S’inscrire et créer une clé API
</h2>

Pour authentifier votre machine auprès de W\&B, vous devez d’abord générer une clé API sur [forge.coreweave.com/settings](https://forge.coreweave.com/settings). Copiez la clé API et conservez-la en lieu sûr.

<h2 id="install-and-import-packages">
  Installer et importer les paquets
</h2>

Installez la bibliothèque W\&B ainsi que les autres paquets nécessaires à ce guide pas à pas.

```python theme={"system"}
pip install wandb
```

Importez le SDK Python W\&B :

```python theme={"system"}
import wandb
```

Indiquez l’entity de votre équipe dans le bloc de code suivant :

```python theme={"system"}
TEAM_ENTITY = "team_entity" # Remplacez par l’entity de votre équipe
PROJECT = "my-awesome-project"
```

<h2 id="train-a-model">
  Entraîner un modèle
</h2>

Le code suivant simule un flux de travail de machine learning de base : entraîner un modèle, consigner des métriques et enregistrer le modèle en tant qu’artifact.

Utilisez le SDK Python W\&B (`wandb.sdk`) pour interagir avec W\&B pendant l’entraînement. Journalisez la perte avec [`wandb.Run.log()`](/fr/products/wandb/ref/python/experiments/run#method-runlog), puis enregistrez le modèle entraîné en tant qu’artifact avec [`wandb.Artifact`](/fr/products/wandb/ref/python/experiments/artifact), et ajoutez enfin le fichier du modèle avec [`Artifact.add_file`](/fr/products/wandb/ref/python/experiments/artifact#add_file).

```python theme={"system"}
import random # Pour simuler des données

def model(training_data: int) -> int:
    """Model simulation for demonstration purposes."""
    return training_data * 2 + random.randint(-1, 1)  

# Simuler les poids et le bruit
weights = random.random() # Initialiser des poids aléatoires
noise = random.random() / 5  # Léger bruit aléatoire pour simuler du bruit

# Hyperparamètres et configuration
config = {
    "epochs": 10,  # Nombre d’époques d’entraînement
    "learning_rate": 0.01,  # Taux d’apprentissage de l’optimiseur
}

# Utiliser un gestionnaire de contexte pour initialiser et fermer les runs W&B
with wandb.init(entity=TEAM_ENTITY, project=PROJECT, config=config) as run:    
    # Simuler la boucle d’entraînement
    for epoch in range(config["epochs"]):
        xb = weights + noise  # Données d’entraînement simulées en entrée
        yb = weights + noise * 2  # Sortie cible simulée (double du bruit en entrée)
        
        y_pred = model(xb)  # Prédiction du modèle
        loss = (yb - y_pred) ** 2  # Perte par erreur quadratique moyenne (MSE)

        print(f"epoch={epoch}, loss={loss}")
        # Journaliser l’époque et la perte dans W&B
        run.log({
            "epoch": epoch,
            "loss": loss,
        })

    # Nom unique de l’artifact de modèle,
    model_artifact_name = f"model-demo"  

    # Chemin local où enregistrer le fichier du modèle simulé
    PATH = "model.txt" 

    # Enregistrer le modèle localement
    with open(PATH, "w") as f:
        f.write(str(weights)) # Enregistrer les poids du modèle dans un fichier

    # Créer un objet artifact
    # Ajouter le modèle enregistré localement à l’objet artifact
    artifact = wandb.Artifact(name=model_artifact_name, type="model", description="My trained model")
    artifact.add_file(local_path=PATH)
    artifact.save()
```

Voici les points essentiels à retenir du bloc de code précédent :

* Utilisez `wandb.Run.log()` pour consigner des métriques pendant l’entraînement.
* Utilisez `wandb.Artifact` pour enregistrer des modèles (ou des jeux de données, etc.) en tant qu’artifact dans votre projet W\&B.

Maintenant que vous avez entraîné un modèle et que vous l’avez enregistré en tant qu’artifact, vous pouvez le publier dans un registre W\&B. Utilisez [`wandb.Run.use_artifact()`](/fr/products/wandb/ref/python/experiments/run#method-runuse_artifact) pour récupérer l’artifact depuis votre projet et le préparer à sa publication dans le registre de modèles. `wandb.Run.use_artifact()` remplit deux fonctions essentielles :

* Il récupère l’objet artifact depuis votre projet.
* Il marque l’artifact comme entrée du run, ce qui garantit la reproductibilité et la traçabilité. Pour plus de détails, consultez [Créer et afficher une carte de traçabilité](/fr/products/registry/lineage).

<h2 id="view-the-training-data-in-the-dashboard">
  Afficher les données d’entraînement dans le tableau de bord
</h2>

Accédez à votre tableau de bord W\&B. Sélectionnez l’onglet **Projects** et recherchez `my-awesome-project` (ou le nom de projet que vous avez choisi ci-dessus). Cliquez dessus pour ouvrir le workspace de votre projet.

Vous y trouverez les détails de chacun de vos runs. Dans cette capture d’écran, le code a été exécuté à plusieurs reprises, ce qui a produit plusieurs runs, chacun doté d’un nom généré aléatoirement.

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/_media/quickstart_image.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=bd51b523b4bce2c7009d3877740b7a96" alt="Page d’un projet W&B présentant plusieurs runs dans une vue en tableau, avec les noms des runs, les métriques et les informations de statut" width="1152" height="653" data-path="products/wandb/_media/quickstart_image.png" />
</Frame>

<h2 id="publish-the-model-to-the-registry">
  Publier le modèle dans le registre
</h2>

Pour partager le modèle avec d’autres membres de votre organisation, publiez-le dans une [collection](/fr/products/registry/create_collection) à l’aide de `wandb.Run.link_artifact()`. Le code suivant associe l’artifact à un [registre](/fr/products/registry) afin de le rendre accessible à votre équipe.

```python theme={"system"}
# Le nom de l’artifact désigne une version précise de l’artifact dans le projet de notre équipe
artifact_name = f'{TEAM_ENTITY}/{PROJECT}/{model_artifact_name}:v0'
print("Artifact name: ", artifact_name)

REGISTRY_NAME = "DemoRegistry" # Nom du registre
COLLECTION_NAME = "DemoModels"  # Nom de la collection dans le registre

# Créer le chemin cible de notre artifact dans le registre
target_path = f"wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}"
print("Target path: ", target_path)

with wandb.init(entity=TEAM_ENTITY, project=PROJECT) as run:
    model_artifact = run.use_artifact(artifact_or_name=artifact_name, type="model")
    run.link_artifact(artifact=model_artifact, target_path=target_path)
```

Après l’exécution de `wandb.Run.link_artifact()`, l’artifact de modèle figure dans la collection `DemoModels` de votre registre. Vous pouvez alors consulter des informations détaillées, comme l’historique des versions, la [carte de traçabilité](/fr/products/registry/lineage) et d’autres [métadonnées](/fr/products/registry/registry_cards).

Pour en savoir plus sur la liaison d’artifacts à un registre, consultez [Lier des artifacts à un registre](/fr/products/registry/link_version).

<h2 id="retrieve-model-artifact-from-registry-for-inference">
  Récupérer un artifact de modèle depuis le registre pour l’inférence
</h2>

Pour utiliser un modèle à des fins d’inférence, récupérez l’artifact publié depuis le registre à l’aide de `wandb.Run.use_artifact()`. Cette méthode renvoie un objet artifact sur lequel vous pouvez ensuite appeler [`wandb.Artifact.download()`](/fr/products/wandb/ref/python/experiments/artifact#method-artifactdownload) pour télécharger l’artifact dans un fichier local.

```python theme={"system"}
REGISTRY_NAME = "DemoRegistry"  # Nom du registre
COLLECTION_NAME = "DemoModels"  # Nom de la collection dans le registre
VERSION = 0 # Version de l’artifact à récupérer

model_artifact_name = f"wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}:v{VERSION}"
print(f"Model artifact name: {model_artifact_name}")

with wandb.init(entity=TEAM_ENTITY, project=PROJECT) as run:
    registry_model = run.use_artifact(artifact_or_name=model_artifact_name)
    local_model_path = registry_model.download()
```

Pour plus d’informations sur la façon de récupérer des artifacts depuis un registre, voir [Télécharger un artifact depuis un registre](/fr/products/registry/download_use_artifact).

Selon votre framework de machine learning, vous devrez peut-être recréer l’architecture du modèle avant de charger les poids. Cette étape n’est pas détaillée ici, car elle dépend du framework et du modèle que vous utilisez.

<h2 id="share-your-findings-with-a-report">
  Partager vos résultats dans un rapport
</h2>

<Note>
  L’API W\&B Report and Workspace est en préversion publique.
</Note>

Créez et partagez un [rapport](/fr/products/wandb/reports) pour synthétiser votre travail. Pour créer un rapport par programmation, utilisez l’[API W\&B Report and Workspace](/fr/products/wandb/ref/wandb_workspaces/reports).

Commencez par installer l’API W\&B Reports :

```bash theme={"system"}
pip install wandb wandb-workspaces -qqq
```

Le bloc de code suivant crée un rapport comportant plusieurs blocs, notamment du markdown, des grilles de panneaux, etc. Vous pouvez personnaliser le rapport en ajoutant d’autres blocs ou en modifiant le contenu des blocs existants.

Le bloc de code affiche en sortie un lien vers l’URL du rapport créé. Ouvrez ce lien dans votre navigateur pour consulter le rapport.

```python theme={"system"}
import wandb_workspaces.reports.v2 as wr

experiment_summary = """This is a summary of the experiment conducted to train a simple model using W&B."""
dataset_info = """The dataset used for training consists of synthetic data generated by a simple model."""
model_info = """The model is a simple linear regression model that predicts output based on input data with some noise."""

report = wr.Report(
    entity=TEAM_ENTITY,
    project=PROJECT,
    title="My Awesome Model Training Report",
    description=experiment_summary,
    blocks= [
        wr.TableOfContents(),
        wr.H2("Experiment Summary"),
        wr.MarkdownBlock(text=experiment_summary),
        wr.H2("Dataset Information"),
        wr.MarkdownBlock(text=dataset_info),
        wr.H2("Model Information"),
        wr.MarkdownBlock(text = model_info),
        wr.PanelGrid(
            panels=[
                wr.LinePlot(title="Train Loss", x="Step", y=["loss"], title_x="Step", title_y="Loss")
                ],
            ),  
    ]

)

# Enregistrer le rapport dans W&B
report.save()
```

Pour plus d’informations sur la création d’un rapport par programmation ou de manière interactive dans l’application W\&B, consultez [Créer un rapport](/fr/products/wandb/reports/create-a-report) dans le guide du développeur de la documentation W\&B.

<h2 id="query-the-registry">
  Interroger le registre
</h2>

Utilisez les [API publiques W\&B](/fr/products/wandb/ref/python/public-api) pour interroger, analyser et gérer les données historiques de W\&B. Elles vous permettent notamment de suivre la traçabilité des artifacts, de comparer différentes versions et d’analyser l’évolution des performances des modèles.

Le bloc de code suivant montre comment interroger le registre de modèles pour obtenir tous les artifacts d’une collection donnée. Il récupère la collection, puis parcourt ses versions en affichant le nom et la version de chaque artifact.

```python theme={"system"}
import wandb

# Initialiser l'API wandb
api = wandb.Api()

# Trouver toutes les versions d'artifact qui contiennent la chaîne `model` et 
# qui ont soit le tag `text-classification`, soit l'alias `latest`
registry_filters = {
    "name": {"$regex": "model"}
}

# Utiliser l'opérateur logique $or pour filtrer les versions d'artifact
version_filters = {
    "$or": [
        {"tag": "text-classification"},
        {"alias": "latest"}
    ]
}

# Renvoie un itérable contenant toutes les versions d'artifact qui correspondent aux filtres
artifacts = api.registries(filter=registry_filters).collections().versions(filter=version_filters)

# Afficher le nom, la collection, les alias, les tags et la date created_at de chaque artifact trouvé
for art in artifacts:
    print(f"artifact name: {art.name}")
    print(f"collection artifact belongs to: { art.collection.name}")
    print(f"artifact aliases: {art.aliases}")
    print(f"tags attached to artifact: {art.tags}")
    print(f"artifact created at: {art.created_at}\n")
```

Pour plus d’informations sur l’interrogation du registre, consultez la section [Interroger les éléments du registre](/fr/products/registry/search_registry#query-registry-items-with-mongodb-style-queries).


## Related topics

- [Aperçu d’Experiments](/fr/products/wandb/track.md)