> ## 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.

# Suivre et versionner des objets

> Suivez et versionnez n’importe quel objet sérialisable en JSON dans W&B Weave

Cette page explique comment publier, récupérer, supprimer et référencer des objets versionnés dans W\&B Weave. Consultez-la lorsque vous devez suivre des données structurées, comme des datasets, des modèles ou des prompts, d’un run à l’autre et dans le temps.

<h2 id="objects">
  Objets
</h2>

Un **objet** est une donnée versionnée et sérialisable. Weave versionne automatiquement les objets à chaque modification et en conserve un historique immuable. Les objets comprennent :

* **Datasets** : collections d’exemples destinées à l’évaluation
* **Modèles** : configurations et paramètres de votre logique LLM
* **Prompts** : modèles de prompts versionnés

```python lines theme={"system"}
dataset = weave.Dataset(
    name="test-cases",
    rows=[
        {"input": "What is 2+2?", "expected": "4"},
        {"input": "What is the capital of France?", "expected": "Paris"},
    ]
)
weave.publish(dataset)
```

<h2 id="publish-an-object">
  Publier un objet
</h2>

La couche de sérialisation de Weave enregistre et versionne les objets.

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    import weave
    weave.init("your-team-name/your-project-name")
    # Enregistrer une liste sous le nom 'cat-names'
    weave.publish(['felix', 'jimbo', 'billie'], 'cat-names')
    ```
  </Tab>

  <Tab title="TypeScript">
    La prise en charge de la publication en TypeScript est limitée. Tous les objets ne sont pas pris en charge.

    ```typescript twoslash lines theme={"system"}
    // @noErrors
    import * as weave from 'weave'

    const client = await weave.init("your-team-name/your-project-name")

    // Enregistrer un tableau sous le nom 'cat-names'
    client.publish(['felix', 'jimbo', 'billie'], 'cat-names')
    ```
  </Tab>
</Tabs>

Lorsque vous enregistrez un objet sous un nom donné, Weave crée la première version de cet objet s’il n’existe pas encore.

<h2 id="get-an-object-back">
  Récupérer un objet
</h2>

Une fois l’objet publié, vous pouvez le récupérer à l’aide de sa référence.

<Tabs>
  <Tab title="Python">
    `weave.publish()` renvoie une Ref. Appelez `.get()` sur n’importe quelle Ref pour récupérer l’objet.

    Vous pouvez également construire une réf., puis récupérer l’objet correspondant.

    ```python lines theme={"system"}
    weave.init("your-team-name/your-project-name")
    cat_names = weave.ref('cat-names').get()
    ```
  </Tab>

  <Tab title="TypeScript">
    ```plaintext lines theme={"system"}
    Cette fonctionnalité n’est pas encore disponible en TypeScript.
    ```
  </Tab>
</Tabs>

<h2 id="delete-an-object">
  Supprimer un objet
</h2>

Si vous n’avez plus besoin d’une version spécifique d’un objet, vous pouvez la supprimer à l’aide de sa réf.

<Tabs>
  <Tab title="Python">
    Pour supprimer une version d’un objet, appelez `.delete()` sur la réf. de l’objet.

    ```python lines theme={"system"}
    weave.init("your-team-name/your-project-name")
    cat_names_ref = weave.ref('cat-names:v1')
    cat_names_ref.delete()
    ```

    Toute tentative d’accès à un objet supprimé renvoie une erreur. La résolution d’un objet qui fait référence à un objet supprimé renvoie un `DeletedRef` à la place de ce dernier.
  </Tab>

  <Tab title="TypeScript">
    ```plaintext theme={"system"}
    This feature isn't available in TypeScript yet.
    ```
  </Tab>
</Tabs>

<h2 id="construct-object-refs">
  Construire des réf. d'objet
</h2>

Les réf. identifient de manière unique un objet stocké et sa version. Les sections suivantes décrivent la structure de l'URI et les différentes façons de construire une réf.

Dans Weave, une URI de réf. d'objet complète se présente comme suit :

```text theme={"system"}
weave:///[YOUR-TEAM-NAME]/[YOUR-PROJECT-NAME]/object/[OBJECT-NAME]:[OBJECT-VERSION]
```

* `[YOUR-TEAM-NAME]` : entity W\&B (nom d’utilisateur ou nom d’équipe)
* `[YOUR-PROJECT-NAME]` : projet Weights & Biases
* `[OBJECT-NAME]` : nom de l’objet
* `[OBJECT-VERSION]` : un hash de version, une chaîne telle que `v0` ou `v1`, ou un alias tel que `:latest`. Tous les objets possèdent l’alias `:latest`. Voir [Organiser les versions d’objets avec des tags et des alias](#organize-object-versions-with-tags-and-aliases) pour créer vos propres alias.

Vous pouvez construire des réf. de plusieurs manières :

* `weave.ref([NAME])` : récupère la version `:latest` d’un objet. Nécessite d’appeler `weave.init(...)`.
* `weave.ref([NAME]:[VERSION])` : récupère la version spécifiée d’un objet. Nécessite d’appeler `weave.init(...)`.
* `weave.ref([FULLY-QUALIFIED-REF-URI])` : récupère l’objet situé à l’URI de réf. d’objet complète indiquée. Ne nécessite pas d’appeler `weave.init()`.

<h2 id="organize-object-versions-with-tags-and-aliases">
  Organiser les versions d’objets avec des tags et des alias
</h2>

Utilisez des **tags** et des **alias** pour étiqueter des versions spécifiques de n’importe quel objet Weave, notamment `Dataset`, `Model`, `Prompt` ou tout autre objet que vous publiez avec `weave.publish`. Ces étiquettes fonctionnent avec n’importe quel `ObjectRef` : les mêmes API s’appliquent donc à tous les types d’objets.

* **Alias :** un nom unique qui pointe vers une seule version. Vous pouvez à tout moment déplacer un alias vers une autre version, ce qui le rend pratique pour des références stables comme `production` ou `staging`. Chaque objet dispose automatiquement d’un alias `:latest` qui pointe vers la version la plus récente.
* **Tag :** une étiquette descriptive jointe à une version. Une version peut avoir plusieurs tags, et un même tag peut figurer sur plusieurs versions. Utilisez les tags pour catégoriser et filtrer les versions, par exemple `reviewed` ou `passed-eval`.

Pour résoudre un alias ou une version spécifique, ajoutez-le au nom de l’objet dans une réf. :

L’exemple suivant publie deux versions d’un dataset, puis attribue et met à jour des tags et des alias sur chaque version.

<CodeGroup>
  ```python Python lines theme={"system"}
  import weave

  client = weave.init("[YOUR-TEAM-NAME]/[YOUR-PROJECT-NAME]")

  # Publier deux versions d’un objet.
  dataset_v0 = weave.publish(
      weave.Dataset(name="test-cases", rows=[{"input": "ping", "expected": "pong"}]),
  )
  dataset_v1 = weave.publish(
      weave.Dataset(name="test-cases", rows=[{"input": "ping", "expected": "pong!"}]),
  )

  # Définir des alias sur une version.
  client.set_aliases(dataset_v0, "staging")
  client.set_aliases(dataset_v1, "production")

  # Récupérer un objet à l’aide de son alias
  dataset = weave.ref("test-cases:production").get()

  # Lister tous les alias du projet.
  client.list_aliases()

  # --- Tags : étiquettes sur une version spécifique. ---

  # Ajouter des tags à une version.
  client.add_tags(dataset_v0, ["reviewed", "passed-eval"])
  client.add_tags(dataset_v1, ["reviewed", "needs-improvement"])

  # Obtenir les tags d’une version.
  client.get_tags(dataset_v0)  # ["passed-eval", "reviewed"]

  # Lister tous les tags distincts du projet.
  client.list_tags()
  ```

  ```plaintext TypeScript lines theme={"system"}
  Cette fonctionnalité n’est pas encore disponible dans le SDK TypeScript.
  ```
</CodeGroup>


## Related topics

- [Collecter et suivre des datasets](/fr/products/wandb/weave/guides/core-types/datasets.md)