Tutoriel : gestion des versions d’une application

Le suivi des entrées, sorties et métadonnées, ainsi que des données qui circulent dans votre application, 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é.

Utiliser `weave.Model`

La classe weave.Model est uniquement prise en charge en Python.

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 :

Python
TypeScript

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)

Cette fonctionnalité n’est pas encore disponible en TypeScript.

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

Python
TypeScript

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)

Cette fonctionnalité n’est pas encore disponible en TypeScript.

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.

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.

Exporter et réutiliser un `weave.Model` journalisé

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.

Obtenir la réf. du Model

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

Utiliser le Model

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 :

Python
TypeScript

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

Cette fonctionnalité n’est pas encore disponible en TypeScript.

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

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.

Étapes suivantes

Suivez le tutoriel Créer un pipeline d’Évaluation pour commencer à améliorer vos applications de manière itérative.

​Utiliser weave.Model

​Exporter et réutiliser un weave.Model journalisé

​Obtenir la réf. du Model

​Utiliser le Model

​Étapes suivantes

Utiliser `weave.Model`

Exporter et réutiliser un `weave.Model` journalisé

Obtenir la réf. du Model

Utiliser le Model

Étapes suivantes