Notebook d’introduction

Guide de démarrage rapide de Weave avec TypeScript

Vous pouvez utiliser W&B Weave avec TypeScript pour :

• Journaliser et déboguer les entrées, les sorties et les traces des modèles de langage
• Créer des évaluations rigoureuses et directement comparables pour les cas d’utilisation des modèles de langage
• Organiser toutes les informations générées tout au long du flux de travail LLM, de l’expérimentation aux évaluations puis à la production

Pour plus d’informations, voir la documentation Weave.

Suivi des fonctions

Pour utiliser Weave dans votre code TypeScript, initialisez un nouveau projet Weave et ajoutez le wrapper weave.op aux fonctions que vous souhaitez suivre.

Après avoir ajouté weave.op et appelé la fonction, consultez le tableau de bord W&B pour la voir apparaître dans votre projet.

Votre code est suivi automatiquement - consultez l’onglet Code dans l’UI !

async function initializeWeaveProject() {
    const PROJECT = 'weave-examples';
    await weave.init(PROJECT);
}

const stripUserInput = weave.op(function stripUserInput(userInput: string): string {
    return userInput.trim();
});

L’exemple suivant montre comment fonctionne le suivi de base des fonctions.

async function demonstrateBasicTracking() {
    const result = await stripUserInput("    hello    ");
    console.log('Basic tracking result:', result);
}

Intégration à OpenAI

Weave suit automatiquement tous les appels à OpenAI, notamment :

• Utilisation des tokens
• Coûts de l’API
• Paires requête-réponse
• Configurations des modèles

En plus d’OpenAI, Weave prend en charge l’enregistrement automatique d’autres fournisseurs de LLM, comme Anthropic et Mistral. Pour la liste complète, voir les fournisseurs de LLM dans la documentation sur les intégrations.

function initializeOpenAIClient() {
    return weave.wrapOpenAI(new OpenAI({
        apiKey: process.env.OPENAI_API_KEY
    }));
}

async function demonstrateOpenAITracking() {
    const client = initializeOpenAIClient();
    const result = await client.chat.completions.create({
        model: "gpt-4-turbo",
        messages: [{ role: "user", content: "Hello, how are you?" }],
    });
    console.log('OpenAI tracking result:', result);
}

Suivi imbriqué des fonctions

Weave vous permet de suivre des flux de travail complexes en combinant plusieurs fonctions suivies et des appels LLM, tout en préservant l’intégralité de la trace d’exécution. Cela offre notamment les avantages suivants :

• Visibilité complète sur le flux logique de votre application
• Débogage simplifié des chaînes d’opérations complexes
• Possibilités d’optimisation des performances

async function demonstrateNestedTracking() {
    const client = initializeOpenAIClient();
    
    const correctGrammar = weave.op(async function correctGrammar(userInput: string): Promise<string> {
        const stripped = await stripUserInput(userInput);
        const response = await client.chat.completions.create({
            model: "gpt-4-turbo",
            messages: [
                {
                    role: "system",
                    content: "You are a grammar checker, correct the following user input."
                },
                { role: "user", content: stripped }
            ],
            temperature: 0,
        });
        return response.choices[0].message.content ?? '';
    });

    const grammarResult = await correctGrammar("That was so easy, it was a piece of pie!");
    console.log('Nested tracking result:', grammarResult);
}

Gestion des jeux de données

Vous pouvez créer et gérer des jeux de données avec Weave à l’aide de la classe weave.Dataset. À l’instar des Weave Models, weave.Dataset permet de :

• Suivre et versionner vos données
• Organiser les cas de test
• Partager des jeux de données entre les membres de l’équipe
• Prendre en charge des évaluations systématiques

interface GrammarExample {
    userInput: string;
    expected: string;
}

function createGrammarDataset(): weave.Dataset<GrammarExample> {
    return new weave.Dataset<GrammarExample>({
        id: 'grammar-correction',
        rows: [
            {
                userInput: "That was so easy, it was a piece of pie!",
                expected: "That was so easy, it was a piece of cake!"
            },
            {
                userInput: "I write good",
                expected: "I write well"
            },
            {
                userInput: "LLM's are best",
                expected: "LLM's are the best"
            }
        ]
    });
}

Framework d’évaluation

Weave prend en charge le développement piloté par l’évaluation avec la classe Evaluation. Les évaluations vous aident à itérer de manière fiable sur votre application de GenAI. La classe Evaluation permet de :

• Évaluer les performances du Model sur un Dataset
• Appliquer des fonctions de scoring personnalisées
• Générer des rapports détaillés sur les performances
• Comparer les versions de modèles

Vous trouverez un tutoriel complet sur l’évaluation à l’adresse http://wandb.me/weave_eval_tut

class OpenAIGrammarCorrector {
    private oaiClient: ReturnType<typeof weave.wrapOpenAI>;
    
    constructor() {
        this.oaiClient = weave.wrapOpenAI(new OpenAI({
            apiKey: process.env.OPENAI_API_KEY
        }));
        this.predict = weave.op(this, this.predict);
    }

    async predict(userInput: string): Promise<string> {
        const response = await this.oaiClient.chat.completions.create({
            model: 'gpt-4-turbo',
            messages: [
                { 
                    role: "system", 
                    content: "You are a grammar checker, correct the following user input." 
                },
                { role: "user", content: userInput }
            ],
            temperature: 0
        });
        return response.choices[0].message.content ?? '';
    }
}

async function runEvaluation() {
    const corrector = new OpenAIGrammarCorrector();
    const dataset = createGrammarDataset();
    
    const exactMatch = weave.op(
        function exactMatch({ modelOutput, datasetRow }: { 
            modelOutput: string; 
            datasetRow: GrammarExample 
        }): { match: boolean } {
            return { match: datasetRow.expected === modelOutput };
        },
        { name: 'exactMatch' }
    );

    const evaluation = new weave.Evaluation({
        dataset,
        scorers: [exactMatch],
    });

    const summary = await evaluation.evaluate({
        model: weave.op((args: { datasetRow: GrammarExample }) => 
            corrector.predict(args.datasetRow.userInput)
        )
    });
    console.log('Résumé de l\'évaluation :', summary);
}

La fonction main suivante exécute toutes les démonstrations :

async function main() {
    try {
        await initializeWeaveProject();
        await demonstrateBasicTracking();
        await demonstrateOpenAITracking();
        await demonstrateNestedTracking();
        await runEvaluation();
    } catch (error) {
        console.error('Erreur lors de l\'exécution des démonstrations :', error);
    }
}