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

# Tutoriel : gestion des versions d’une application

> Découvrez comment utiliser un Model Weave pour suivre votre application et ses paramètres, et en gérer les versions

Le suivi des [entrées, sorties et métadonnées](/fr/products/wandb/weave/quickstart), ainsi que des [données qui circulent dans votre application](/fr/products/wandb/weave/tutorial-tracing_2), est essentiel pour comprendre les performances de votre système. Il est tout aussi important de gérer les versions de votre application au fil du temps, car cela permet de voir l’incidence des modifications de votre code ou de vos paramètres sur vos sorties. La classe `Model` de Weave assure ce suivi pour vous.

Ce tutoriel s’adresse aux développeurs qui souhaitent comparer et reproduire des résultats d’une version à l’autre d’une application LLM. À l’issue de ce tutoriel, vous disposerez d’un `Model` Weave versionné qui capture les paramètres et le code de votre application. Vous saurez également récupérer et réutiliser une version précédente.

Dans ce tutoriel, vous apprendrez :

* Comment utiliser un `Model` Weave pour suivre votre application et ses paramètres, et en gérer les versions.
* Comment exporter, modifier et réutiliser un `Model` Weave déjà journalisé.

<h2 id="use-weavemodel">
  Utiliser `weave.Model`
</h2>

<Warning>
  La classe `weave.Model` est uniquement prise en charge en Python.
</Warning>

Lorsque vous utilisez des `Model` Weave, Weave stocke et versionne les paramètres tels que les ID de fournisseur de modèle, les prompts, la température, etc., à chaque modification.

Pour créer un `Model` dans Weave, vous avez besoin des éléments suivants :

* Une classe qui hérite de `weave.Model`.
* Des définitions de type pour tous les champs de la classe.
* Une fonction `invoke` typée avec le décorateur `@weave.op()`.

Lorsque vous modifiez les champs de la classe ou le code qui définit votre modèle, Weave journalise ces modifications et met à jour la version. Vous pouvez ainsi comparer les générations entre les différentes versions de votre application.

Dans l’exemple suivant, Weave suit et versionne le nom du modèle, la température et le prompt système :

<Tabs>
  <Tab title="Python">
    ```python lines {26,33-34} theme={"system"}
    import json
    from openai import OpenAI

    import weave

    @weave.op()
    def extract_dinos(wmodel: weave.Model, sentence: str) -> dict:
        response = wmodel.client.chat.completions.create(
            model=wmodel.model_name,
            temperature=wmodel.temperature,
            messages=[
                {
                    "role": "system",
                    "content": wmodel.system_prompt
                },
                {
                    "role": "user",
                    "content": sentence
                }
                ],
                response_format={ "type": "json_object" }
            )
        return response.choices[0].message.content

    # Sous-classe de weave.Model
    class ExtractDinos(weave.Model):
        client: OpenAI = None
        model_name: str
        temperature: float
        system_prompt: str

        # Assurez-vous que votre fonction s’appelle `invoke` ou `predict`
        @weave.op()
        def invoke(self, sentence: str) -> dict:
            dino_data  = extract_dinos(self, sentence)
            return json.loads(dino_data)
    ```
  </Tab>

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

Vous pouvez maintenant instancier le modèle et l’appeler avec `invoke` :

<Tabs>
  <Tab title="Python">
    ```python lines {7,18} theme={"system"}
    weave.init('jurassic-park')
    client = OpenAI()

    system_prompt = """Extract any dinosaur `name`, their `common_name`, \
    names and whether its `diet` is a herbivore or carnivore, in JSON format."""

    dinos = ExtractDinos(
        client=client,
        model_name='gpt-4o',
        temperature=0.4,
        system_prompt=system_prompt
    )

    sentence = """I watched as a Tyrannosaurus rex (T. rex) chased after a Triceratops (Trike), \
    both carnivore and herbivore locked in an ancient dance. Meanwhile, a gentle giant \
    Brachiosaurus (Brachi) calmly munched on treetops, blissfully unaware of the chaos below."""

    result = dinos.invoke(sentence)
    print(result)
    ```
  </Tab>

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

Après l’appel à `.invoke()`, la trace dans Weave suit les paramètres du modèle ainsi que le code des fonctions du modèle décorées avec `weave.op()`. Le modèle est également versionné (ici, `v21`). Cliquez sur le modèle pour afficher tous les appels ayant utilisé cette version.

<img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/tutorial-model_invoke3.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=9fdbffd1e5837823322919a24c541e08" alt="Réutilisation d’un modèle Weave" width="1664" height="1292" data-path="products/wandb/weave/_media/tutorial-model_invoke3.png" />

Remarques sur l’utilisation de `weave.Model` :

* Si vous le préférez, vous pouvez nommer la fonction de votre `Model` Weave `predict` au lieu de `invoke`.
* Pour suivre d’autres méthodes de classe avec Weave, encapsulez-les dans `weave.op()`.
* Weave ignore les paramètres commençant par un trait de soulignement et ne les journalise pas.

<h2 id="export-and-reuse-a-logged-weavemodel">
  Exporter et réutiliser un `weave.Model` journalisé
</h2>

Maintenant que votre modèle est versionné dans Weave, vous pouvez récupérer n’importe quelle version antérieure et l’exécuter de nouveau, sans avoir à le redéfinir dans votre code. C’est utile pour reproduire des résultats passés ou pour partager une version précise d’un modèle avec d’autres personnes.

Comme Weave stocke et versionne les Models que vous avez invoqués, vous pouvez les exporter et les réutiliser.

<h3 id="get-the-model-ref">
  Obtenir la réf. du Model
</h3>

Dans l’interface de Weights & Biases, vous pouvez obtenir la réf. du Model pour une version donnée.

<h3 id="use-the-model">
  Utiliser le Model
</h3>

Une fois que vous disposez de l’URI de l’objet Model, vous pouvez l’exporter et le réutiliser. Le modèle exporté est déjà initialisé et prêt à l’emploi :

<Tabs>
  <Tab title="Python">
    ```python lines {2} theme={"system"}
    # Le modèle Weave exporté est déjà initialisé et prêt à être appelé.
    new_dinos = weave.ref("weave://morgan/jurassic-park/object/ExtractDinos:ey4udBU2MU23heQFJenkVxLBX4bmDsFk7vsGcOWPjY4").get()

    # Définir à nouveau le client sur le client OpenAI.
    new_dinos.client = client

    new_sentence = """I also saw an Ankylosaurus grazing on giant ferns"""
    new_result = new_dinos.invoke(new_sentence)
    print(new_result)
    ```
  </Tab>

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

Vous pouvez maintenant constater que la nouvelle entrée utilise la même version du Model (v21) :

<img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/tutorial-model_re-use.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=f962108efde0d0dde004de5ab442183f" alt="Réutilisation d’un modèle Weave" width="1260" height="1120" data-path="products/wandb/weave/_media/tutorial-model_re-use.png" />

Vous disposez désormais d’un `Model` Weave versionné que vous pouvez faire évoluer, récupérer et réutiliser d’une version à l’autre de votre application.

<h2 id="whats-next">
  Étapes suivantes
</h2>

* Suivez le tutoriel [Créer un pipeline d’Évaluation](/fr/products/wandb/weave/tutorial-eval) pour commencer à améliorer vos applications de manière itérative.