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

> Créez et enregistrez un W&B Artifact. Découvrez comment ajouter un ou plusieurs fichiers ou une référence URI à un Artifact.

# Créer un artifact

Utilisez le W\&B Python SDK pour créer des Artifacts à partir de [W\&B Runs](/fr/models/ref/python/experiments/run). Vous pouvez ajouter [des fichiers, des répertoires, des URI et des fichiers issus de runs parallèles aux Artifacts](#add-files-to-an-artifact). Après avoir ajouté un fichier à un Artifact, enregistrez l'Artifact sur le serveur W\&B ou sur [votre propre serveur privé](/fr/platform/hosting/hosting-options/self-managed). Chaque Artifact est associé à un run.

Pour savoir comment suivre des fichiers externes, tels que des fichiers stockés dans Amazon S3, voir la page [Suivre les fichiers externes](./track-external-files).

<div id="construct-an-artifact">
  ## Construire un artifact
</div>

Construisez un [W\&B Artifact](/fr/models/ref/python/experiments/artifact) en trois étapes :

1. [Créer un objet Python d'artifact avec `wandb.Artifact()`](/fr/models/artifacts/construct-an-artifact#create-an-artifact-python-object-with-wandb-artifact)
2. [Ajouter un ou plusieurs fichiers à l'artifact](/fr/models/artifacts/construct-an-artifact#add-one-or-more-files-to-the-artifact)
3. [Enregistrer votre artifact sur le serveur W\&B](/fr/models/artifacts/construct-an-artifact#save-your-artifact-to-the-w\&b-server)

<div id="create-an-artifact-python-object-with-wandbartifact">
  ### Créez un objet artifact Python avec `wandb.Artifact()`
</div>

Initialisez la classe [`wandb.Artifact()`](/fr/models/ref/python/experiments/artifact) pour créer un objet artifact. Spécifiez les paramètres suivants :

* **Nom** : le nom de votre artifact. Il doit être unique, descriptif et mémorable.
* **Type** : le type de l'artifact. Il doit être simple, descriptif et correspondre à une seule étape de votre pipeline de machine learning. Parmi les types d'artifact courants, on trouve `'dataset'` ou `'model'`.

<Note>
  W\&B utilise le "nom" et le "type" que vous fournissez pour créer un graphe orienté acyclique dans l'application W\&B. Voir [Explore and traverse artifact graphs](./explore-and-traverse-an-artifact-graph) pour plus
  d'informations.
</Note>

<Warning>
  Les Artifacts ne peuvent pas avoir le même nom, quel que soit leur type. En d'autres termes, vous ne pouvez pas créer un artifact nommé `cats` de type `dataset` et un autre artifact portant le même nom de type `model`.
</Warning>

Vous pouvez aussi fournir une description et des métadonnées lorsque vous initialisez un objet artifact. Pour plus d'informations sur les attributs et paramètres disponibles, consultez la définition de la classe [`wandb.Artifact`](/fr/models/ref/python/experiments/artifact) dans le guide de Référence du SDK Python.

Copiez-collez l'extrait de code suivant pour créer un objet artifact. Remplacez les espaces réservés `<name>` et `<type>` par vos propres valeurs :

```python theme={null}
import wandb

# Créer un objet artifact
artifact = wandb.Artifact(name="<name>", type="<type>")
```

<div id="add-one-or-more-files-to-the-artifact">
  ### Ajoutez un ou plusieurs fichiers à l'artifact
</div>

[Ajoutez des fichiers, des répertoires, des références URI externes (comme Amazon S3), etc.](/fr/models/artifacts/construct-an-artifact#add-files-to-an-artifact) à votre objet artifact.

Pour ajouter un seul fichier, utilisez la méthode [`Artifact.add_file()`](/fr/models/ref/python/experiments/artifact#add_file) de l'objet artifact :

```python theme={null}
artifact.add_file(local_path="path/to/file.txt", name="<name>")
```

Pour ajouter un répertoire, utilisez la méthode [`Artifact.add_dir()`](/fr/models/ref/python/experiments/artifact#add_dir) :

```python theme={null}
artifact.add_dir(local_path="path/to/directory", name="<name>")
```

Voir la section suivante, [Ajouter des fichiers à un artifact](/fr/models/artifacts/construct-an-artifact#add-files-to-an-artifact), pour en savoir plus sur l’ajout de différents types de fichiers à un artifact.

<div id="save-your-artifact-to-the-wb-server">
  ### Enregistrez votre artifact sur le serveur W\&B
</div>

Enregistrez votre artifact sur le serveur W\&B. Utilisez la méthode [`wandb.Run.log_artifact()`](/fr/models/ref/python/experiments/run#log_artifact) de l'objet run pour enregistrer l'artifact.

```python theme={null}
with wandb.init(project="<project>", job_type="<job-type>") as run:
    run.log_artifact(artifact)
```

<Tip>
  **Quand utiliser `wandb.Run.log_artifact()` ou `Artifact.save()`**

  * Utilisez `wandb.Run.log_artifact()` pour créer un nouvel artifact et l’associer à un run spécifique.
  * Utilisez `Artifact.save()` pour mettre à jour un artifact existant sans créer de nouveau run.
</Tip>

Pour récapituler, l’extrait de code suivant montre comment créer un artifact de jeu de données, y ajouter un fichier et enregistrer l’artifact dans W\&B :

```python theme={null}
import wandb

artifact = wandb.Artifact(name="<name>", type="<type>")
artifact.add_file(local_path="path/to/file.txt", name="<name>")
artifact.add_dir(local_path="path/to/directory", name="<name>")

with wandb.init(project="<project>", job_type="<job-type>") as run:
    run.log_artifact(artifact)
```

Chaque fois que vous enregistrez un artifact avec le même nom et le même type, W\&B crée une nouvelle version de cet artifact. Pour plus d'informations, voir [Créer une nouvelle version d'artifact](/fr/models/artifacts/create-a-new-artifact-version).

<Warning>
  W\&B effectue les appels `wandb.Run.log_artifact()` de manière asynchrone afin d'optimiser les téléversements. Cela peut entraîner un comportement inattendu lors de l'enregistrement d'artifacts dans une boucle. Par exemple :

  ```python theme={null}
  with wandb.init() as run:
      for i in range(10):
          a = wandb.Artifact(name = "race",
              type="dataset",
              metadata={
                  "index": i,
              },
          )
          # ... ajouter des fichiers à l'artifact a ...
          run.log_artifact(a)
  ```

  Il est possible que la version d'artifact **v0** n'ait pas un index de 0 dans ses métadonnées, car les artifacts peuvent être enregistrés dans un ordre arbitraire.
</Warning>

<div id="add-files-to-an-artifact">
  ## Ajouter des fichiers à un artifact
</div>

Les sections suivantes montrent comment ajouter différents types d’objets à un artifact. Supposons que vous disposiez d’un répertoire présentant la structure suivante à mesure que vous parcourez les exemples :

```text theme={null}
root-directory
| - hello.txt
| - images/
| -- | cat.png
| -- | dog.png
| - checkpoints/
| -- | model.h5
| - models/
| -- | model.h5
```

<div id="add-a-single-file">
  ### Ajouter un seul fichier
</div>

Utilisez [`wandb.Artifact.add_file()`](/fr/models/ref/python/experiments/artifact#method-artifact-add-file) pour ajouter un fichier local à un artifact. Indiquez le chemin local du fichier dans le paramètre `local_path` :

```python theme={null}
import wandb

# Initialiser un objet artifact
artifact = wandb.Artifact(name="<name>", type="<type>")

# Ajouter un seul fichier
artifact.add_file(local_path="path/file.format")
```

Par exemple, supposons que vous ayez un fichier appelé `'hello.txt'` dans votre répertoire de travail local.

```python theme={null}
artifact.add_file("hello.txt")
```

L'artifact contient désormais le contenu suivant :

```text theme={null}
hello.txt
```

Vous pouvez également passer un autre nom au paramètre `name` pour renommer le fichier au sein de l’objet artifact lui-même. En reprenant l’exemple précédent :

```python theme={null}
artifact.add_file(
    local_path="hello.txt", 
    name="new/path/hello_world.txt"
    )
```

L'artifact est stocké sous la forme suivante :

```text theme={null}
new/path/hello_world.txt
```

Le tableau suivant montre comment différents appels d’API génèrent des contenus d’artifact différents :

| Appel d’API                                               | artifact obtenu     |
| --------------------------------------------------------- | ------------------- |
| `artifact.new_file('hello.txt')`                          | `hello.txt`         |
| `artifact.add_file('model.h5')`                           | `model.h5`          |
| `artifact.add_file('checkpoints/model.h5')`               | `model.h5`          |
| `artifact.add_file('model.h5', name='models/mymodel.h5')` | `models/mymodel.h5` |

<div id="add-multiple-files">
  ### Ajouter plusieurs fichiers
</div>

Utilisez la méthode [`wandb.Artifact.add_dir()`](/fr/models/ref/python/experiments/artifact#method-artifact-add-dir) pour ajouter plusieurs fichiers d’un répertoire local à un artifact. Spécifiez le chemin local du répertoire à l’aide du paramètre `local_path`.

```python theme={null}
import wandb

# Initialiser un objet artifact
artifact = wandb.Artifact(name="<name>", type="<type>")

# Ajouter un répertoire local à l'artifact
artifact.add_dir(local_path="path/file.format", name="optional-prefix")
```

Le tableau suivant montre comment différents appels d’API génèrent des contenus d’artifact différents :

| Appel d’API                                 | artifact obtenu                                                      |
| ------------------------------------------- | -------------------------------------------------------------------- |
| `artifact.add_dir('images')`                | <p><code>cat.png</code></p><p><code>dog.png</code></p>               |
| `artifact.add_dir('images', name='images')` | <p><code>images/cat.png</code></p><p><code>images/dog.png</code></p> |

<div id="add-a-uri-reference">
  ### Ajouter une référence URI
</div>

Artifacts suivent les sommes de contrôle et d'autres informations pour assurer la reproductibilité si l'URI utilise un schéma pris en charge par la bibliothèque W\&B.

Ajoutez une référence URI externe à un artifact avec la méthode [`wandb.Artifact.add_reference()`](/fr/models/ref/python/experiments/artifact#method-artifact-add-reference). Remplacez la chaîne `'uri'` par votre propre URI. Vous pouvez également indiquer, pour le paramètre nom, le chemin souhaité dans l'artifact.

```python theme={null}
# Ajouter une référence URI
artifact.add_reference(uri="uri", name="optional-name")
```

Les Artifacts prennent actuellement en charge les schémas d’URI suivants :

* `http(s)://` : chemin d’accès vers un fichier accessible via HTTP. L’artifact suit les sommes de contrôle sous forme d’ETags et les métadonnées de taille si le serveur HTTP prend en charge les en-têtes de réponse `ETag` et `Content-Length`.
* `s3://` : chemin d’accès vers un objet ou un préfixe d’objet dans S3. L’artifact suit les sommes de contrôle et les informations de gestion des versions (si la gestion des versions des objets est activée pour le bucket) des objets référencés. Les préfixes d’objet sont étendus pour inclure les objets qu’ils contiennent, dans la limite de 10 000 objets.
* `gs://` : chemin d’accès vers un objet ou un préfixe d’objet dans GCS. L’artifact suit les sommes de contrôle et les informations de gestion des versions (si la gestion des versions des objets est activée pour le bucket) des objets référencés. Les préfixes d’objet sont étendus pour inclure les objets qu’ils contiennent, dans la limite de 10 000 objets.

Le tableau suivant montre comment différents appels d’API génèrent différents contenus d’artifact :

| Appel d’API                                                                   | Contenu de l’artifact obtenu                                         |
| ----------------------------------------------------------------------------- | -------------------------------------------------------------------- |
| `artifact.add_reference('s3://my-bucket/model.h5')`                           | `model.h5`                                                           |
| `artifact.add_reference('s3://my-bucket/checkpoints/model.h5')`               | `model.h5`                                                           |
| `artifact.add_reference('s3://my-bucket/model.h5', name='models/mymodel.h5')` | `models/mymodel.h5`                                                  |
| `artifact.add_reference('s3://my-bucket/images')`                             | <p><code>cat.png</code></p><p><code>dog.png</code></p>               |
| `artifact.add_reference('s3://my-bucket/images', name='images')`              | <p><code>images/cat.png</code></p><p><code>images/dog.png</code></p> |

<div id="add-files-to-artifacts-from-parallel-runs">
  ### Ajouter des fichiers à des artefacts depuis des exécutions parallèles
</div>

Pour les jeux de données volumineux ou l'entraînement distribué, plusieurs exécutions parallèles peuvent devoir alimenter un même artefact.

```python theme={null}
import wandb
import time

# Cet exemple utilise Ray pour exécuter des runs en parallèle
# à des fins de démonstration.
import ray

ray.init()

artifact_type = "dataset"
artifact_name = "parallel-artifact"
table_name = "distributed_table"
parts_path = "parts"
num_parallel = 5

# Chaque lot de writers parallèles doit avoir son propre
# nom de groupe unique.
group_name = "writer-group-{}".format(round(time.time()))


@ray.remote
def train(i):
    """
    Our writer job. Each writer will add one image to the artifact.
    """
    with wandb.init(group=group_name) as run:
        artifact = wandb.Artifact(name=artifact_name, type=artifact_type)

        # Ajouter des données à un tableau wandb.
        table = wandb.Table(columns=["a", "b", "c"], data=[[i, i * 2, 2**i]])

        # Ajouter le tableau dans un dossier de l'artifact
        artifact.add(table, "{}/table_{}".format(parts_path, i))

        # L'upsert de l'artifact crée ou ajoute des données à l'artifact
        run.upsert_artifact(artifact)


# Lancer les runs en parallèle
result_ids = [train.remote(i) for i in range(num_parallel)]

# Attendre tous les writers pour s'assurer que leurs fichiers ont
# été ajoutés avant de finaliser l'artifact.
ray.get(result_ids)

# Une fois tous les writers terminés, finaliser l'artifact
# pour le marquer comme prêt.
with wandb.init(group=group_name) as run:
    artifact = wandb.Artifact(artifact_name, type=artifact_type)

    # Créer une "PartitionTable" pointant vers le dossier de tableaux
    # et l'ajouter à l'artifact.
    artifact.add(wandb.data_types.PartitionedTable(parts_path), table_name)

    # finish_artifact finalise l'artifact, interdisant les futurs "upserts"
    # sur cette version.
    run.finish_artifact(artifact)
```

<div id="find-path-for-logged-artifacts-and-other-metadata">
  ## Trouver le chemin d’accès des Artifacts enregistrés et d’autres métadonnées
</div>

L’extrait de code suivant montre comment utiliser l’[API publique W\&B](/fr/models/ref/python/public-api/) pour lister les fichiers d’un run, y compris leur nom et leur URL. Remplacez l’espace réservé `<entity/project/run-id>` par vos propres valeurs :

```python theme={null}
from wandb.apis.public.files import Files
from wandb.apis.public.api import Api

# Exemple d'objet run
run = Api().run("<entity/project/run-id>")

# Créer un objet Files pour itérer sur les fichiers du run
files = Files(api.client, run)

# Itérer sur les fichiers
for file in files:
    print(f"File Name: {file.name}")
    print(f"File URL: {file.url}")
    print(f"Path to file in the bucket: {file.direct_url}")
```

Voir la classe [File](/fr/models/ref/python/public-api/file) pour en savoir plus sur les attributs et méthodes disponibles.