> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-run-filter-ui-updates.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Tutoriel : gestion des versions d’application
> Découvrez comment utiliser Weave Model 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/weave/quickstart), ainsi que des [données circulant dans votre application](/fr/weave/tutorial-tracing_2), est essentiel pour comprendre les performances de votre système. Cependant, **la gestion des versions de votre application au fil du temps** est tout aussi essentielle pour comprendre l’impact des modifications apportées à votre code ou aux paramètres de votre application sur vos sorties. La classe `Model` de Weave vous permet de suivre ces changements dans Weave.
Dans ce tutoriel, vous apprendrez à :
* utiliser le `Model` de Weave pour suivre votre application et ses paramètres, et en gérer les versions.
* exporter, modifier et réutiliser un `Model` de Weave déjà enregistré.
## Utiliser `weave.Model`
La classe `weave.Model` n’est actuellement prise en charge qu’en Python.
Avec les `Model` de Weave, les paramètres tels que les identifiants du fournisseur du modèle, les prompts, la température, etc. sont stockés et versionnés lorsqu’ils changent.
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, **ces modifications seront enregistrées et la version sera mise à jour**. Vous pouvez ainsi comparer les générations entre différentes versions de votre application.
Dans l’exemple ci-dessous, **le nom du modèle, la température et le prompt système seront suivis et versionnés** :
```python lines {26,33-34} theme={null}
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)
```
```plaintext theme={null}
Cette fonctionnalité n'est pas encore disponible en TypeScript. Restez à l’écoute !
```
Vous pouvez maintenant instancier le modèle et l’appeler avec `invoke` :
```python lines {7,18} theme={null}
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)
```
```plaintext theme={null}
Cette fonctionnalité n'est pas encore disponible en TypeScript. Restez à l’écoute !
```
Après avoir appelé `.invoke()`, vous pouvez voir que la trace dans Weave **suit désormais les paramètres du modèle ainsi que le code** des fonctions du modèle décorées avec `weave.op()`. Vous pouvez également voir que le modèle est lui aussi versionné, « v21 » dans ce cas. Si vous cliquez sur le modèle, **vous pouvez voir tous les appels** qui ont utilisé cette version du modèle
**Remarque sur l’utilisation de `weave.Model` :**
* Si vous le préférez, vous pouvez utiliser `predict` au lieu de `invoke` comme nom de fonction dans votre `Model` Weave.
* Si vous souhaitez que d’autres méthodes de classe soient suivies par weave, elles doivent être décorées avec `weave.op()`
* Les paramètres commençant par un trait de soulignement sont ignorés par weave et ne seront pas enregistrés
## Exporter et réutiliser un `weave.Model` enregistré
Comme Weave stocke et versionne les Models qui ont été invoqués, il est possible de les exporter et de les réutiliser.
**Obtenir la référence du Model**
Dans la Weave UI, vous pouvez obtenir la référence du Model pour une version donnée.
**Utiliser le Model**
Une fois que vous avez l’URI de l’objet Model, vous pouvez l’exporter et le réutiliser. Notez que le modèle exporté est déjà initialisé et prêt à être utilisé :
```python lines {2} theme={null}
# 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()
# réassocier le client au 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)
```
```plaintext theme={null}
Cette fonctionnalité n’est pas encore disponible en TypeScript. Restez à l’écoute !
```
Ici, vous pouvez maintenant voir que la version du Model (v21) a été utilisée avec la nouvelle entrée :
## Et ensuite ?
* Suivez le tutoriel [Créer un pipeline d’évaluation](/fr/weave/tutorial-eval) pour commencer à améliorer vos applications de façon itérative.