Journaliser des données d'évaluation depuis votre code

Façon flexible et incrémentielle de journaliser des données d’évaluation à partir de code Python et TypeScript

EvaluationLogger offre un moyen flexible et incrémentiel de journaliser des données d’évaluation directement depuis votre code Python ou TypeScript. Vous n’avez pas besoin d’une connaissance approfondie des types de données internes de Weave : il vous suffit d’instancier un logger et d’utiliser ses méthodes (log_prediction, log_score, log_summary) pour enregistrer les étapes de l’évaluation.

Cette approche est particulièrement utile dans les flux de travail complexes où l’ensemble du jeu de données ou tous les évaluateurs ne sont pas forcément définis à l’avance.

Contrairement à l’objet Evaluation standard, qui nécessite un Dataset prédéfini et une liste d’objets Scorer, EvaluationLogger vous permet de journaliser des prédictions individuelles et les scores associés de façon incrémentielle, à mesure qu’ils deviennent disponibles.

Vous préférez une évaluation plus structurée ?

Si vous préférez un framework d’évaluation plus prescriptif avec des jeux de données et des évaluateurs prédéfinis, Voir le framework Evaluation standard de Weave.

EvaluationLogger offre de la flexibilité, tandis que le framework standard apporte structure et orientation.

​

Flux de travail de base

1. Initialisez le logger : Créez une instance de EvaluationLogger, en fournissant éventuellement des métadonnées sur le modèle et le jeu de données. Les valeurs par défaut seront utilisées si vous les omettez.
   Pour capturer l’utilisation des jetons et le coût des appels LLM (par ex. OpenAI), initialisez EvaluationLogger avant toute invocation de LLM**. Si vous appelez d’abord votre LLM, puis journalisez les prédictions ensuite, les données de jeton et de coût ne seront pas capturées.

2. Journalisez les prédictions : Appelez log_prediction() pour chaque paire entrée/sortie de votre système.
3. Journalisez les scores : Utilisez le ScoreLogger renvoyé pour appeler log_score() pour la prédiction. Plusieurs scores par prédiction sont pris en charge.
4. Terminez la prédiction : Appelez toujours finish() après avoir journalisé les scores d’une prédiction afin de la finaliser.
5. Journalisez le résumé : Une fois toutes les prédictions traitées, appelez log_summary() pour agréger les scores et ajouter des métriques personnalisées facultatives.

Après avoir appelé finish() sur une prédiction, il n’est plus possible d’y journaliser d’autres scores.

Pour voir un exemple de code Python illustrant le flux de travail décrit, consultez le Basic example. Si la sortie et tous les scores sont disponibles immédiatement, les utilisateurs Python peuvent combiner les étapes 2 à 4 en un appel unique à l’aide de log_example().

​

Exemple de base

L’exemple suivant montre comment utiliser EvaluationLogger pour journaliser les prédictions et les scores directement dans votre code existant.

Python

La fonction de modèle user_model est définie puis appliquée à une liste d’entrées. Pour chaque exemple :

• L’entrée et la sortie sont enregistrées à l’aide de log_prediction.
• Un score simple de correction (correctness_score) est enregistré via log_score.
• finish() finalise l’enregistrement pour cette prédiction. Enfin, log_summary enregistre les métriques agrégées et déclenche la synthèse automatique des scores dans Weave.

import weave
from openai import OpenAI
from weave import EvaluationLogger

weave.init('your-team/your-project')

# Initialiser EvaluationLogger AVANT d'appeler le modèle pour garantir le suivi des jetons
eval_logger = EvaluationLogger(
    model="my_model",
    dataset="my_dataset"
)

# Exemple de données d'entrée (peut être n'importe quelle structure de données)
eval_samples = [
    {'inputs': {'a': 1, 'b': 2}, 'expected': 3},
    {'inputs': {'a': 2, 'b': 3}, 'expected': 5},
    {'inputs': {'a': 3, 'b': 4}, 'expected': 7},
]

# Exemple de logique de modèle avec OpenAI
@weave.op
def user_model(a: int, b: int) -> int:
    oai = OpenAI()
    response = oai.chat.completions.create(
        messages=[{"role": "user", "content": f"What is {a}+{b}?"}],
        model="gpt-4o-mini"
    )
    # Utiliser la réponse d'une façon ou d'une autre (ici on retourne simplement a + b pour simplifier)
    return a + b

# Itérer sur les exemples, effectuer des prédictions et journaliser
for sample in eval_samples:
    inputs = sample["inputs"]
    model_output = user_model(**inputs) # Passer les entrées en tant que kwargs

    # Journaliser l'entrée et la sortie de la prédiction
    pred_logger = eval_logger.log_prediction(
        inputs=inputs,
        output=model_output
    )

    # Calculer et journaliser un score pour cette prédiction
    expected = sample["expected"]
    correctness_score = model_output == expected
    pred_logger.log_score(
        scorer="correctness", # Nom simple du scorer sous forme de chaîne
        score=correctness_score
    )

    # Finaliser la journalisation pour cette prédiction spécifique
    pred_logger.finish()

# Journaliser une synthèse finale pour l'ensemble de l'évaluation.
# Weave agrège automatiquement les scores 'correctness' journalisés ci-dessus.
summary_stats = {"subjective_overall_score": 0.8}
eval_logger.log_summary(summary_stats)

print("Evaluation logging complete. View results in the Weave UI.")

TypeScript

Le SDK TypeScript propose deux modèles d’API :

1. API fire-and-forget (recommandée dans la plupart des cas) : utilisez logPrediction() sans await pour une journalisation synchrone et non bloquante
2. API avec attente : utilisez logPredictionAsync() avec await lorsque vous devez vous assurer que les opérations sont terminées avant de continuer

Nous recommandons fire-and-forget dans les cas suivants :

• Débit élevé : traitez plusieurs prédictions en parallèle sans attendre chaque opération de journalisation
• Modification minimale du code : ajoutez la journalisation de l’évaluation sans restructurer votre flux async/await existant
• Simplicité : moins de code passe-partout et une syntaxe plus claire pour la plupart des scénarios d’évaluation

Le modèle fire-and-forget est sûr, car logSummary() attend automatiquement la fin de toutes les opérations en attente avant d’agréger les résultats.

L’exemple suivant évalue les prédictions d’un modèle avec le modèle fire-and-forget. Il configure un journal d’évaluation, exécute un modèle simple sur trois échantillons de test, puis journalise la prédiction sans utiliser await :

import weave, { EvaluationLogger } from "weave"
import OpenAI from "openai"

await weave.init("your-team/your-project")

// Initialiser EvaluationLogger AVANT d'appeler le modèle pour assurer le suivi des jetons
const evalLogger = new EvaluationLogger({
  name: "my-eval",
  model: "my_model",
  dataset: "my_dataset"
})

// Exemples de données d'entrée
const evalSamples = [
  { inputs: { a: 1, b: 2 }, expected: 3 },
  { inputs: { a: 2, b: 3 }, expected: 5 },
  { inputs: { a: 3, b: 4 }, expected: 7 }
]

// Exemple de logique de modèle avec OpenAI
const userModel = weave.op(async function userModel(a: number, b: number): Promise<number> {
  const oai = new OpenAI()
  const response = await oai.chat.completions.create({
    messages: [{ role: "user", content: `What is ${a}+${b}?` }],
    model: "gpt-4o-mini"
  })
  return a + b
})

// Itérer sur les exemples, effectuer des prédictions et journaliser avec le modèle fire-and-forget
for (const sample of evalSamples) {
  const { inputs } = sample
  const modelOutput = await userModel(inputs.a, inputs.b)

  // Fire-and-forget : aucun await nécessaire pour logPrediction
  const scoreLogger = evalLogger.logPrediction(inputs, modelOutput)

  // Calculer et journaliser un score pour cette prédiction
  const correctnessScore = modelOutput === sample.expected

  // Fire-and-forget : aucun await nécessaire pour logScore
  scoreLogger.logScore("correctness", correctnessScore)

  // Fire-and-forget : aucun await nécessaire pour finish
  scoreLogger.finish()
}

// logSummary attend en interne la fin de toutes les opérations en attente
const summaryStats = { subjective_overall_score: 0.8 }
await evalLogger.logSummary(summaryStats)

console.log("Evaluation logging complete. View results in the Weave UI.")

Utilisez l’API awaitable lorsque vous devez vous assurer que chaque opération est terminée avant de continuer, par exemple pour la gestion des erreurs ou des dépendances séquentielles.

Dans l’exemple suivant, au lieu d’appeler logPrediction() sans await, on utilise logPredictionAsync() avec await pour s’assurer que chaque opération est terminée avant de passer à la suivante :

// Utiliser logPredictionAsync à la place de logPrediction
const scoreLogger = await evalLogger.logPredictionAsync(inputs, modelOutput)

// Attendre chaque opération
await scoreLogger.logScore("correctness", correctnessScore)
await scoreLogger.finish()

​

Journalisation simplifiée avec log_example()

Utilisez log_example() pour journaliser des entrées, une sortie et des scores en un seul appel. Cette méthode pratique combine log_prediction(), log_score() et finish() en une seule étape. Elle est utile lorsque vous disposez déjà des entrées, des sorties du modèle et des scores à journaliser, par exemple lors d’évaluations par lot ou hors ligne.

import weave
from weave import EvaluationLogger

weave.init('your-team-name/your-project-name')

eval_logger = EvaluationLogger(
    model="my_model",
    dataset="my_dataset"
)

eval_samples = [
    {'inputs': {'a': 1, 'b': 2}, 'expected': 3},
    {'inputs': {'a': 2, 'b': 3}, 'expected': 5},
    {'inputs': {'a': 3, 'b': 4}, 'expected': 7},
]

for sample in eval_samples:
    inputs = sample['inputs']
    output = inputs['a'] + inputs['b']

    eval_logger.log_example(
        inputs=inputs,
        output=output,
        scores={"correctness": output == sample['expected']}
    )

eval_logger.log_summary({"avg_score": 1.0})

L’appel à log_example() ci-dessus équivaut à :

pred = eval_logger.log_prediction(inputs=inputs, output=output)
pred.log_score(scorer="correctness", score=output == sample['expected'])
pred.finish()

log_example() n’est pas disponible pour le SDK TypeScript de Weave. Les utilisateurs de TypeScript doivent utiliser l’approche logPrediction() et logScore() présentée dans l’exemple de base.

​

Utilisation avancée

EvaluationLogger offre des modes d’utilisation flexibles au-delà du flux de travail de base pour répondre à des scénarios d’évaluation plus complexes. Cette section présente des techniques avancées, notamment l’utilisation de gestionnaires de contexte pour la gestion automatique des ressources, la séparation de l’exécution du modèle et de la journalisation, l’utilisation de données de médias enrichis et la comparaison côte à côte de plusieurs évaluations de modèles.

​

Utilisation des gestionnaires de contexte

EvaluationLogger prend en charge les gestionnaires de contexte (instructions with) pour les prédictions comme pour les scores. Cela permet d’obtenir un code plus propre, un nettoyage automatique des ressources et un meilleur suivi des opérations imbriquées, comme les appels à un juge LLM.

L’utilisation des instructions with dans ce contexte offre les avantages suivants :

• Appels automatiques à finish() à la sortie du contexte
• Meilleur suivi des jetons et des coûts pour les appels LLM imbriqués
• Définition de la sortie après l’exécution du modèle dans le contexte de prédiction

Python

import openai
import weave

weave.init("nested-evaluation-example")
oai = openai.OpenAI()

# Initialiser le logger

ev = weave.EvaluationLogger(
model="gpt-4o-mini",
dataset="joke_dataset"
)

user_prompt = "Tell me a joke"

# Utiliser un gestionnaire de contexte pour la prédiction - inutile d'appeler finish()

with ev.log_prediction(inputs={"user_prompt": user_prompt}) as pred: # Effectuez votre appel au modèle dans ce contexte
result = oai.chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": user_prompt}],
)

    # Définir la sortie après l'appel au modèle
    pred.output = result.choices[0].message.content

    # Journaliser des scores simples
    pred.log_score("correctness", 1.0)
    pred.log_score("ambiguity", 0.3)

    # Utiliser un gestionnaire de contexte imbriqué pour les scores qui nécessitent des appels LLM
    with pred.log_score("llm_judge") as score:
        judge_result = oai.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "Rate how funny the joke is from 1-5"},
                {"role": "user", "content": pred.output},
            ],
        )
        # Définir la valeur du score après le calcul
        score.value = judge_result.choices[0].message.content

# finish() est automatiquement appelé à la sortie du bloc 'with'

ev.log_summary({"avg_score": 1.0})

Cette approche garantit que toutes les opérations imbriquées sont suivies et attribuées à la prédiction parente, ce qui vous fournit des données précises sur l’utilisation des jetons et les coûts dans l’interface Weave.

TypeScript

TypeScript ne dispose pas du modèle d’instruction with de Python pour les gestionnaires de contexte. Utilisez plutôt le modèle fire-and-forget avec des appels explicites à finish().

L’exemple suivant journalise une prédiction, ajoute des scores simples et un score de juge LLM, puis finalise la prédiction avec finish() :

import weave from 'weave';
import OpenAI from 'openai';
import {EvaluationLogger} from 'weave/evaluationLogger';

await weave.init('your-team/your-project');
const oai = new OpenAI();

// Initialiser le logger
const ev = new EvaluationLogger({
  name: 'joke-eval',
  model: 'gpt-4o-mini',
  dataset: 'joke_dataset',
});

const userPrompt = 'Tell me a joke';

// Obtenir la sortie du modèle
const result = await oai.chat.completions.create({
  model: 'gpt-4o-mini',
  messages: [{role: 'user', content: userPrompt}],
});

const modelOutput = result.choices[0].message.content;

// Journaliser la prédiction avec la sortie
const pred = ev.logPrediction({user_prompt: userPrompt}, modelOutput);

// Journaliser des scores simples
pred.logScore('correctness', 1.0);
pred.logScore('ambiguity', 0.3);

// Pour les scores de juge LLM, effectuez l'appel et journalisez le résultat
const judgeResult = await oai.chat.completions.create({
  model: 'gpt-4o-mini',
  messages: [
    {role: 'system', content: 'Rate how funny the joke is from 1-5'},
    {role: 'user', content: modelOutput || ''},
  ],
});
pred.logScore('llm_judge', judgeResult.choices[0].message.content);

// Appeler explicitement finish une fois l'évaluation terminée
pred.finish();

await ev.logSummary({avg_score: 1.0});

Bien que TypeScript ne dispose pas de nettoyage automatique avec les gestionnaires de contexte, logSummary() finalise automatiquement toutes les prédictions inachevées avant d’agréger les résultats. Vous pouvez vous appuyer sur ce comportement si vous préférez ne pas appeler finish() explicitement.

​

Lier à un jeu de données existant

Lorsque vous passez des jeux de données bruts comme inputs à log_prediction, Weave réimporte les données à chaque exécution d’évaluation. Cela stocke des données en double, ce qui peut gaspiller de l’espace si le jeu de données est volumineux ou si un grand nombre d’évaluations le réutilisent.

Pour éviter cette duplication, publiez votre jeu de données dans Weave avant d’exécuter des évaluations, puis passez les lignes du jeu de données publié comme inputs. Weave résout les références aux lignes publiées à l’aide de références internes au lieu de réimporter les données. Cette technique vous offre la même expérience de liaison que le framework d’évaluation standard, où chaque prédiction renvoie à une ligne précise du jeu de données dans l’interface Weave.

L’exemple suivant publie un jeu de données et y crée un lien dans EvaluationLogger, avant de le récupérer et de l’itérer comme n’importe quel autre jeu de données.

Python

import weave
from weave import EvaluationLogger

weave.init("your-team-name/your-project-name")

# Publier le jeu de données (à faire une seule fois)

dataset = weave.Dataset(
name="my_eval_dataset",
rows=[
{"question": "What is the capitol of France?", "expected": "Paris"},
{"question": "What U.S. state is Seattle in?", "expected": "Washington"},
{"question": "In what country is Mount Fuji located in?", "expected": "Japan"},
],
)
weave.publish(dataset)

# Récupérer le jeu de données publié

dataset = weave.ref("my_eval_dataset").get()

TypeScript

import weave, {EvaluationLogger, Dataset} from 'weave';

await weave.init('your-team-name/your-project-name');

// Publier le jeu de données (à faire une seule fois)
const dataset = new Dataset({
  name: 'my_eval_dataset',
  rows: [
    {"question": "What is the capitol of France?", "expected": "Paris"},
    {"question": "What U.S. state is Seattle in?", "expected": "Washington"},
    {"question": "In what country is Mount Fuji located in?", "expected": "Japan"},
  ],
});
const datasetRef = await dataset.save();

// Récupérer le jeu de données publié
const published = await datasetRef.get();

​

Obtenir les sorties avant la journalisation

Vous pouvez d’abord calculer les sorties de votre modèle, puis journaliser séparément les prédictions et les scores. Cela permet de mieux séparer la logique d’évaluation de la logique de journalisation.

Python

# Initialiser EvaluationLogger AVANT d'appeler le modèle afin de garantir le suivi des jetons
ev = EvaluationLogger(
    model="example_model",
    dataset="example_dataset"
)

# Les sorties du modèle (par ex. des appels OpenAI) doivent être générées après l'initialisation du logger pour le suivi des jetons

outputs = [your_output_generator(**inputs) for inputs in your_dataset]
preds = [ev.log_prediction(inputs, output) for inputs, output in zip(your_dataset, outputs)]
for pred, output in zip(preds, outputs):
pred.log_score(scorer="greater_than_5_scorer", score=output > 5)
pred.log_score(scorer="greater_than_7_scorer", score=output > 7)
pred.finish()

ev.log_summary()

TypeScript

L’approche fire-and-forget est particulièrement efficace lorsque vous traitez plusieurs prédictions en parallèle.

L’exemple suivant traite des évaluations par lot en parallèle en créant plusieurs instances simultanées de EvaluationLogger :

// Initialiser EvaluationLogger AVANT d'appeler le modèle afin de garantir le suivi des jetons
const ev = new EvaluationLogger({
  name: 'parallel-eval',
  model: 'example_model',
  dataset: 'example_dataset'
});

// Les sorties du modèle, comme les appels OpenAI, doivent être générées après l'initialisation du logger pour le suivi des jetons
const outputs = await Promise.all(
  yourDataset.map(inputs => yourOutputGenerator(inputs))
);

// Fire-and-forget : traiter toutes les prédictions sans attendre
const preds = yourDataset.map((inputs, i) =>
  ev.logPrediction(inputs, outputs[i])
);

preds.forEach((pred, i) => {
  const output = outputs[i];
  // Fire-and-forget : aucun await nécessaire
  pred.logScore('greater_than_5_scorer', output > 5);
  pred.logScore('greater_than_7_scorer', output > 7);
  pred.finish();
});

// logSummary attend toutes les opérations en attente
await ev.logSummary();

Vous pouvez utiliser l’approche fire-and-forget pour traiter autant d’évaluations en parallèle que vos ressources de calcul le permettent.

​

Journaliser des médias enrichis

Les entrées, les sorties et les scores peuvent inclure des médias enrichis, comme des images, des vidéos, des fichiers audio ou des tableaux structurés. Il vous suffit de passer un dictionnaire ou un objet média aux méthodes log_prediction ou log_score.

Python

import io
import wave
import struct
from PIL import Image
import random
from typing import Any
import weave

def generate_random_audio_wave_read(duration=2, sample_rate=44100):
n_samples = duration \* sample_rate
amplitude = 32767 # amplitude maximale sur 16 bits

    buffer = io.BytesIO()

    # Écrire les données wave dans le tampon
    with wave.open(buffer, 'wb') as wf:
        wf.setnchannels(1)
        wf.setsampwidth(2)  # 16 bits
        wf.setframerate(sample_rate)

        for _ in range(n_samples):
            sample = random.randint(-amplitude, amplitude)
            wf.writeframes(struct.pack('<h', sample))

    # Rembobiner le tampon au début pour pouvoir le lire
    buffer.seek(0)

    # Renvoyer un objet Wave_read
    return wave.open(buffer, 'rb')

rich*media_dataset = [
{
'image': Image.new(
"RGB",
(100, 100),
color=(
random.randint(0, 255),
random.randint(0, 255),
random.randint(0, 255),
),
),
"audio": generate_random_audio_wave_read(),
}
for * in range(5)
]

@weave.op
def your_output_generator(image: Image.Image, audio) -> dict[str, Any]:
return {
"result": random.randint(0, 10),
"image": image,
"audio": audio,
}

ev = EvaluationLogger(model="example_model", dataset="example_dataset")

for inputs in rich_media_dataset:
output = your_output_generator(\*\*inputs)
pred = ev.log_prediction(inputs, output)
pred.log_score(scorer="greater_than_5_scorer", score=output["result"] > 5)
pred.log_score(scorer="greater_than_7_scorer", score=output["result"] > 7)

ev.log_summary()

TypeScript

Le SDK TypeScript prend en charge la journalisation d’images et de données audio à l’aide des fonctions weaveImage et weaveAudio. L’exemple suivant charge des fichiers image et audio, les traite avec un modèle, puis journalise les résultats avec leurs scores.

import weave, {EvaluationLogger} from 'weave';
import * as fs from 'fs';

await weave.init('your-team/your-project');

// Charger des images et des fichiers audio depuis des fichiers
const richMediaDataset = [
  {
    image: weave.weaveImage({data: fs.readFileSync('sample1.png')}),
    audio: weave.weaveAudio({data: fs.readFileSync('sample1.wav')}),
  },
  {
    image: weave.weaveImage({data: fs.readFileSync('sample2.png')}),
    audio: weave.weaveAudio({data: fs.readFileSync('sample2.wav')}),
  },
];

// Modèle qui traite les médias et renvoie les résultats
const yourOutputGenerator = weave.op(
  async (inputs: {image: any; audio: any}) => {
    const result = Math.floor(Math.random() * 10);
    return {
      result,
      image: inputs.image,
      audio: inputs.audio,
    };
  },
  {name: 'yourOutputGenerator'}
);

const ev = new EvaluationLogger({
  name: 'rich-media-eval',
  model: 'example_model',
  dataset: 'example_dataset',
});

for (const inputs of richMediaDataset) {
  const output = await yourOutputGenerator(inputs);

  // Journaliser la prédiction avec des médias enrichis dans les entrées comme dans les sorties
  const pred = ev.logPrediction(inputs, output);
  pred.logScore('greater_than_5_scorer', output.result > 5);
  pred.logScore('greater_than_7_scorer', output.result > 7);
  pred.finish();
}

await ev.logSummary();

​

Journaliser et comparer plusieurs évaluations

Avec EvaluationLogger, vous pouvez journaliser et comparer plusieurs évaluations.

1. Exécutez l’exemple de code ci-dessous.

2. Dans l’interface Weave, accédez à l’onglet Evals.

3. Sélectionnez les evals que vous souhaitez comparer.

4. Cliquez sur le bouton Compare. Dans la vue de comparaison, vous pouvez :

   • Choisir quelles evals ajouter ou supprimer
   • Choisir quelles métriques afficher ou masquer
   • Parcourir des exemples précis pour voir comment différents modèles se sont comportés pour la même entrée dans un jeu de données donné

   Pour plus d’informations sur les comparaisons, voir Comparisons

Python

import weave

models = [
"model1",
"model2",
{"name": "model3", "metadata": {"coolness": 9001}}
]

for model in models: # EvalLogger doit être initialisé avant les appels de modèle pour capturer les jetons
ev = EvaluationLogger(
name="comparison-eval",
model=model,
dataset="example_dataset",
scorers=["greater_than_3_scorer", "greater_than_5_scorer", "greater_than_7_scorer"],
eval_attributes={"experiment_id": "exp_123"}
)
for inputs in your_dataset:
output = your_output_generator(\*\*inputs)
pred = ev.log_prediction(inputs=inputs, output=output)
pred.log_score(scorer="greater_than_3_scorer", score=output > 3)
pred.log_score(scorer="greater_than_5_scorer", score=output > 5)
pred.log_score(scorer="greater_than_7_scorer", score=output > 7)
pred.finish()

    ev.log_summary()

TypeScript

import weave from 'weave';
import {EvaluationLogger} from 'weave/evaluationLogger';
import {WeaveObject} from 'weave/weaveObject';

await weave.init('your-team/your-project');

const models = [
  'model1',
  'model2',
  new WeaveObject({name: 'model3', metadata: {coolness: 9001}})
];

for (const model of models) {
  // EvalLogger doit être initialisé avant les appels de modèle pour capturer les jetons
  const ev = new EvaluationLogger({
    name: 'comparison-eval',
    model: model,
    dataset: 'example_dataset',
    description: 'Évaluation de comparaison de modèles',
    scorers: ['greater_than_3_scorer', 'greater_than_5_scorer', 'greater_than_7_scorer'],
    attributes: {experiment_id: 'exp_123'}
  });

  for (const inputs of yourDataset) {
    const output = await yourOutputGenerator(inputs);

    // Modèle fire-and-forget pour une journalisation simple et efficace
    const pred = ev.logPrediction(inputs, output);
    pred.logScore('greater_than_3_scorer', output > 3);
    pred.logScore('greater_than_5_scorer', output > 5);
    pred.logScore('greater_than_7_scorer', output > 7);
    pred.finish();
  }

  await ev.logSummary();
}

​

Conseils d’utilisation

Python

• Appelez finish() rapidement après chaque prédiction.
• Utilisez log_summary pour enregistrer des métriques qui ne sont pas liées à une prédiction individuelle (par ex., la latence globale).
• La journalisation des médias enrichis est idéale pour l’analyse qualitative.

TypeScript

• Comportement de fin automatique : Bien que nous recommandions d’appeler explicitement finish() pour chaque prédiction par souci de clarté, logSummary() termine automatiquement toutes les prédictions non terminées. En revanche, une fois que le script a appelé finish(), il ne peut plus enregistrer de scores.
• Options de configuration : Utilisez les options de configuration, notamment name, description, dataset, model, scorers et attributes, pour organiser et filtrer vos évaluations dans la Weave UI.