> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-hivemind-launch.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Aperçu des scorers

> Évaluez les sorties de l’IA et renvoyez des métriques d’évaluation avec les scorers Weave

Dans Weave, les scorers servent à évaluer les sorties de l’IA et à renvoyer des métriques d’évaluation. Ils prennent la sortie de l’IA, l’analysent et renvoient un dictionnaire de résultats. Les scorers peuvent utiliser vos données d’entrée comme référence si nécessaire et produire également des informations supplémentaires, comme des explications ou le raisonnement issu de l’évaluation.

<Tabs>
  <Tab title="Python">
    Les scorers sont transmis à un objet `weave.Evaluation` pendant l’évaluation. Il existe deux types de scorers dans Weave :

    1. **scorers basés sur des fonctions :** fonctions Python simples décorées avec `@weave.op`.
    2. **scorers basés sur des classes :** classes Python qui héritent de `weave.Scorer` pour des évaluations plus complexes.

    Les scorers doivent renvoyer un dictionnaire et peuvent renvoyer plusieurs métriques, des métriques imbriquées et des valeurs non numériques, comme du texte renvoyé par un LLM-scorer sur son raisonnement.
  </Tab>

  <Tab title="TypeScript">
    Les scorers sont des ops spéciales transmises à un objet `weave.Evaluation` pendant l’évaluation.
  </Tab>
</Tabs>

<div id="create-your-own-scorers">
  ## Créez vos propres évaluateurs
</div>

<Tip>
  **Évaluateurs prêts à l'emploi**
  Bien que ce guide vous montre comment créer des évaluateurs personnalisés, Weave propose plusieurs [évaluateurs prédéfinis](./builtin_scorers) et [évaluateurs SLM locaux](./weave_local_scorers) que vous pouvez utiliser immédiatement, notamment :

  * [Détection des hallucinations](./builtin_scorers#hallucinationfreescorer)
  * [Qualité de résumé](./builtin_scorers#summarizationscorer)
  * [Similarité d'embeddings](./builtin_scorers#embeddingsimilarityscorer)
  * [Détection de la toxicité (local)](./weave_local_scorers#weavetoxicityscorerv1)
  * [Évaluation de la pertinence du contexte (local)](./weave_local_scorers#weavecontextrelevancescorerv1)
  * Et plus encore !
</Tip>

<div id="function-based-scorers">
  ### évaluateurs basés sur des fonctions
</div>

<Tabs>
  <Tab title="Python">
    Il s’agit de fonctions décorées avec `@weave.op` qui renvoient un dictionnaire. Elles conviennent parfaitement à des évaluations simples comme :

    ```python lines theme={null}
    import weave

    @weave.op
    def evaluate_uppercase(text: str) -> dict:
        return {"text_is_uppercase": text.isupper()}

    my_eval = weave.Evaluation(
        dataset=[{"text": "HELLO WORLD"}],
        scorers=[evaluate_uppercase]
    )
    ```

    Lors de l’exécution de l’évaluation, `evaluate_uppercase` vérifie si le texte est entièrement en majuscules.
  </Tab>

  <Tab title="TypeScript">
    Il s’agit de fonctions encapsulées avec `weave.op` qui acceptent un objet contenant `modelOutput` et, éventuellement, `datasetRow`. Elles conviennent parfaitement à des évaluations simples comme :

    ```typescript lines theme={null}
    import * as weave from 'weave'

    const evaluateUppercase = weave.op(
        ({modelOutput}) => modelOutput.toUpperCase() === modelOutput,
        {name: 'textIsUppercase'}
    );

    const myEval = new weave.Evaluation({
        dataset: [{text: 'HELLO WORLD'}],
        scorers: [evaluateUppercase],
    })
    ```
  </Tab>
</Tabs>

<div id="class-based-scorers">
  ### évaluateurs basés sur des classes
</div>

<Tabs>
  <Tab title="Python">
    Pour des évaluations plus avancées, en particulier lorsque vous devez suivre des métadonnées supplémentaires associées au scorer, essayer différents prompts pour vos évaluateurs LLM ou effectuer plusieurs appels de fonction, vous pouvez utiliser la classe `Scorer`.

    **Exigences :**

    1. Héritez de `weave.Scorer`.
    2. Définissez une méthode `score` décorée avec `@weave.op`.
    3. La méthode `score` doit renvoyer un dictionnaire.

    Exemple :

    ```python lines {7} theme={null}
    import weave
    from openai import OpenAI
    from weave import Scorer

    llm_client = OpenAI()

    class SummarizationScorer(Scorer):
        model_id: str = "gpt-4o"
        system_prompt: str = "Evaluate whether the summary is good."

        @weave.op
        def some_complicated_preprocessing(self, text: str) -> str:
            processed_text = "Original text: \n" + text + "\n"
            return processed_text

        @weave.op
        def call_llm(self, summary: str, processed_text: str) -> dict:
            res = llm_client.chat.completions.create(
                messages=[
                    {"role": "system", "content": self.system_prompt},
                    {"role": "user", "content": (
                        f"Analyze how good the summary is compared to the original text."
                        f"Summary: {summary}\n{processed_text}"
                    )}])
            return {"summary_quality": res}

        @weave.op
        def score(self, output: str, text: str) -> dict:
            """Évaluez la qualité de la synthèse.

            Arguments:
                output: La synthèse générée par un système d’IA
                text: Le texte original en cours de synthèse
            """
            processed_text = self.some_complicated_preprocessing(text)
            eval_result = self.call_llm(summary=output, processed_text=processed_text)
            return {"summary_quality": eval_result}

    evaluation = weave.Evaluation(
        dataset=[{"text": "The quick brown fox jumps over the lazy dog."}],
        scorers=[summarization_scorer])
    ```

    Cette classe évalue la qualité d’un résumé en le comparant au texte original.
  </Tab>

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

<div id="how-scorers-work">
  ## Fonctionnement des évaluateurs
</div>

<div id="scorer-keyword-arguments">
  ### Arguments par mot-clé du scorer
</div>

<Tabs>
  <Tab title="Python">
    Les évaluateurs peuvent accéder à la fois à la sortie de votre système d’IA et aux données d’entrée de la ligne du jeu de données.

    * **Entrée :** Si vous voulez que votre scorer utilise des données de la ligne de votre jeu de données, comme une colonne "label" ou "target", vous pouvez facilement les mettre à sa disposition en ajoutant un argument par mot-clé `label` ou `target` à la définition de votre scorer.

    Par exemple, si vous vouliez utiliser une colonne appelée "label" de votre jeu de données, votre fonction de scorer (ou votre méthode de classe `score`) aurait une liste de paramètres comme celle-ci :

    ```python lines theme={null}
    @weave.op
    def my_custom_scorer(output: str, label: int) -> dict:
        ...
    ```

    Lorsqu’une `Evaluation` Weave est exécutée, la sortie du système d’IA est transmise au paramètre `output`. L’`Evaluation` essaie aussi automatiquement de faire correspondre les noms des arguments supplémentaires du scorer avec les colonnes de votre jeu de données. Si vous ne pouvez pas personnaliser les arguments de votre scorer ou les colonnes du jeu de données, vous pouvez utiliser un mapping de colonnes — voir ci-dessous pour en savoir plus.

    * **Sortie :** Incluez un paramètre `output` dans la signature de la fonction de votre scorer pour accéder à la sortie du système d’IA.

    ### Mapper les noms de colonnes avec `column_map`

    Il arrive que les noms d’arguments des méthodes `score` ne correspondent pas aux noms de colonnes de votre jeu de données. Vous pouvez résoudre ce problème avec `column_map`.

    Si vous utilisez un scorer basé sur une classe, transmettez un dictionnaire à l’attribut `column_map` de `Scorer` lorsque vous initialisez votre classe de scorer. Ce dictionnaire fait correspondre les noms d’arguments de votre méthode `score` aux noms de colonnes du jeu de données, selon le format suivant : `{scorer_keyword_argument: dataset_column_name}`.

    Exemple :

    ```python lines theme={null}
    import weave
    from weave import Scorer

    # Un jeu de données avec des articles de presse à résumer
    dataset = [
        {"news_article": "The news today was great...", "date": "2030-04-20", "source": "Bright Sky Network"},
        ...
    ]

    # Classe de scorer
    class SummarizationScorer(Scorer):

        @weave.op
        def score(self, output, text) -> dict:
            """
                output: synthèse de sortie d’un système de synthèse par LLM
                text: le texte en cours de synthèse
            """
            ...  # évaluer la qualité de la synthèse

    # créer un scorer avec un mapping de colonne qui associe l’argument `text` à la colonne de données `news_article`
    scorer = SummarizationScorer(column_map={"text" : "news_article"})
    ```

    Désormais, l’argument `text` de la méthode `score` recevra les données de la colonne `news_article` du jeu de données.

    **Notes :**

    * Une autre option équivalente pour mapper vos colonnes consiste à sous-classer `Scorer` et à surcharger la méthode `score` en faisant explicitement correspondre les colonnes.

    ```python lines theme={null}
    import weave
    from weave import Scorer

    class MySummarizationScorer(SummarizationScorer):

        @weave.op
        def score(self, output: str, news_article: str) -> dict:  # Ajout d’annotations de type
            # surcharge la méthode score et mappe les colonnes manuellement
            return super().score(output=output, text=news_article)
    ```
  </Tab>

  <Tab title="TypeScript">
    Les évaluateurs peuvent accéder à la fois à la sortie de votre système d’IA et au contenu de la ligne du jeu de données.

    Vous pouvez facilement accéder aux colonnes pertinentes de la ligne du jeu de données en ajoutant un argument par mot-clé `datasetRow` à la définition de votre scorer.

    ```typescript lines theme={null}
    const myScorer = weave.op(
        ({modelOutput, datasetRow}) => {
            return modelOutput * 2 === datasetRow.expectedOutputTimesTwo;
        },
        {name: 'myScorer'}
    );
    ```

    ### Mapper les noms de colonnes avec `columnMapping`

    <Warning>
      En TypeScript, cette fonctionnalité se trouve actuellement sur l’objet `Evaluation`, et non sur les scorers individuels.
    </Warning>

    Il arrive que les clés de votre `datasetRow` ne correspondent pas exactement à la convention de nommage du scorer, tout en ayant le même sens. Vous pouvez mapper les colonnes à l’aide de l’option `columnMapping` de l’`Evaluation`.

    Le mapping se fait toujours du point de vue du scorer, c’est-à-dire `{scorer_key: dataset_column_name}`.

    Exemple :

    ```typescript lines theme={null}
    const myScorer = weave.op(
        ({modelOutput, datasetRow}) => {
            return modelOutput * 2 === datasetRow.expectedOutputTimesTwo;
        },
        {name: 'myScorer'}
    );

    const myEval = new weave.Evaluation({
        dataset: [{expected: 2}],
        scorers: [myScorer],
        columnMapping: {expectedOutputTimesTwo: 'expected'}
    });
    ```
  </Tab>
</Tabs>

<div id="access-variables-from-your-ops-in-scoring-prompts">
  ### Accéder aux variables de vos ops dans les prompts de scoring
</div>

Dans les prompts de scoring pour les scorers LLM-as-a-judge, vous pouvez faire référence à des variables de votre op. Ces valeurs sont automatiquement extraites lorsque le scorer s’exécute.

Pour une fonction comme :

```python theme={null}
@weave.op
def summarize_article(article: str, max_length: int) -> str:
    # Votre logique de synthèse ici
    return summary
```

Les variables suivantes sont disponibles :

| Variable       | Description                                         |
| -------------- | --------------------------------------------------- |
| `{article}`    | La valeur de l’argument d’entrée `article`          |
| `{max_length}` | La valeur de l’argument d’entrée `max_length`       |
| `{inputs}`     | Un dictionnaire JSON de tous les arguments d’entrée |
| `{output}`     | Le résultat renvoyé par votre op                    |

Exemple de prompt d’évaluation :

```text theme={null}
Évaluez la qualité de ce résumé.

Article original : {article}
Résumé : {output}
Longueur maximale demandée : {max_length}

Évaluez le résumé sur une échelle de 1 à 10 selon les critères suivants :
- Exactitude : représente-t-il fidèlement l'article ?
- Exhaustivité : couvre-t-il les points clés ?
- Concision : est-il suffisamment bref ?

Renvoyez un objet JSON avec votre note et votre justification.
```

<div id="final-summarization-of-the-scorer">
  ### Résumé final du scorer
</div>

<Tabs>
  <Tab title="Python">
    Pendant l'évaluation, le scorer est calculé pour chaque ligne de votre jeu de données. Pour produire un score final pour l'évaluation, nous utilisons `auto_summarize`, qui dépend du type de retour de la sortie.

    * Les moyennes sont calculées pour les colonnes numériques
    * Le nombre et la proportion pour les colonnes booléennes
    * Les autres types de colonnes sont ignorés

    Vous pouvez redéfinir la méthode `summarize` de la classe `Scorer` et fournir votre propre manière de calculer les scores finaux. La fonction `summarize` attend :

    * Un seul paramètre, `score_rows` : il s'agit d'une liste de dictionnaires, où chaque dictionnaire contient les scores renvoyés par la méthode `score` pour une ligne de votre jeu de données.
    * Elle doit renvoyer un dictionnaire contenant les scores récapitulatifs.

    **Pourquoi est-ce utile ?**

    Lorsque vous devez scorer toutes les lignes avant de pouvoir déterminer la valeur finale du score pour le jeu de données.

    ```python lines theme={null}
    class MyBinaryScorer(Scorer):
        """
        Renvoie True si la sortie complète correspond à la cible, False sinon
        """

        @weave.op
        def score(self, output, target):
            return {"match": output == target}

        def summarize(self, score_rows: list) -> dict:
            full_match = all(row["match"] for row in score_rows)
            return {"full_match": full_match}
    ```

    > Dans cet exemple, `auto_summarize` aurait renvoyé par défaut le nombre et la proportion de valeurs True.

    Si vous voulez en savoir plus, consultez l'implémentation de [CorrectnessLLMJudge](/fr/weave/tutorial-rag#optional-defining-a-scorer-class).
  </Tab>

  <Tab title="TypeScript">
    Pendant l'évaluation, le scorer est calculé pour chaque ligne de votre jeu de données. Pour produire un score final, nous utilisons une fonction interne, `summarizeResults`, qui agrège les résultats selon le type de sortie.

    * Les moyennes sont calculées pour les colonnes numériques
    * Le nombre et la proportion pour les colonnes booléennes
    * Les autres types de colonnes sont ignorés

    Nous ne prenons pas encore en charge la récapitulation personnalisée.
  </Tab>
</Tabs>

<div id="applying-scorers-to-a-call">
  ### Appliquer des évaluateurs à un appel
</div>

Pour appliquer des évaluateurs à vos ops Weave, vous devez utiliser la méthode `.call()`, qui vous donne accès à la fois au résultat de l’opération et à ses informations de suivi. Cela vous permet d’associer les résultats des évaluateurs à des appels spécifiques dans la base de données de Weave.

Pour plus d’informations sur l’utilisation de la méthode `.call()`, consultez le guide [Calling Ops](../tracking/tracing#calling-ops#getting-a-handle-to-the-call-object-during-execution).

<Tabs>
  <Tab title="Python">
    Voici un exemple simple :

    ```python lines theme={null}
    # Obtenir à la fois le résultat et l’objet Call
    result, call = generate_text.call("Say hello")

    # Appliquer un évaluateur
    score = await call.apply_scorer(MyScorer())
    ```

    Vous pouvez également appliquer plusieurs évaluateurs au même appel :

    ```python lines theme={null}
    # Appliquer plusieurs évaluateurs en parallèle
    await asyncio.gather(
        call.apply_scorer(quality_scorer),
        call.apply_scorer(toxicity_scorer)
    )
    ```

    **Notes :**

    * Les résultats des évaluateurs sont automatiquement stockés dans la base de données de Weave
    * Les évaluateurs s’exécutent de manière asynchrone une fois l’opération principale terminée
    * Vous pouvez consulter les résultats des évaluateurs dans l’interface utilisateur ou les interroger via l’API

    Pour plus d’informations sur l’utilisation des évaluateurs comme garde-fous ou moniteurs, y compris les bonnes pratiques en production et des exemples complets, consultez notre guide [Guardrails and Monitors](./monitors).
  </Tab>

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

<div id="use-preprocess_model_input">
  ### Utiliser `preprocess_model_input`
</div>

Vous pouvez utiliser le paramètre `preprocess_model_input` pour modifier les exemples du jeu de données avant qu’ils n’atteignent votre modèle pendant l’évaluation.

<Important>
  La fonction `preprocess_model_input` transforme uniquement les entrées avant leur transmission à la fonction de prédiction du modèle.

  Les fonctions `scorer` reçoivent toujours les exemples originaux du jeu de données, sans prétraitement.
</Important>

Pour plus d’informations sur l’utilisation et pour un exemple, voir [Utiliser `preprocess_model_input` pour mettre en forme les lignes du jeu de dataset avant l’évaluation](../core-types/evaluations#using-preprocess_model_input-to-format-dataset-rows-before-evaluating).

<div id="score-analysis">
  ## Analyse des scores
</div>

Dans cette section, nous vous montrons comment analyser les scores pour un seul Appel, plusieurs appels et tous les appels évalués par un scorer spécifique.

<div id="analyze-a-single-calls-scores">
  ### Analyser les scores d’un Appel unique
</div>

<div id="single-call-api">
  #### API pour un appel unique
</div>

Pour récupérer les appels associés à un appel donné, vous pouvez utiliser la méthode `get_call`.

```python lines theme={null}
client = weave.init("my-project")

# Obtenir un appel unique
call = client.get_call("call-uuid-here")

# Obtenir le feedback de l'appel, qui contient les scores
feedback = list(call.feedback)
```

<div id="single-call-ui">
  #### UI d’un appel individuel
</div>

<Frame>
  <img src="https://mintcdn.com/wb-21fd5541-docs-hivemind-launch/HbhUDAG_r2i2K_Pk/weave/guides/evaluation/img/call_scores_tab.png?fit=max&auto=format&n=HbhUDAG_r2i2K_Pk&q=85&s=4d42bc041f61f8ab78b597c2ae5ca5ec" alt="Onglet Scores d’un appel" width="4112" height="2328" data-path="weave/guides/evaluation/img/call_scores_tab.png" />
</Frame>

Les scores d’un appel individuel s’affichent dans le panneau des détails de l’appel, sous l’onglet « Scores ».

<div id="analyze-multiple-calls-scores">
  ### Analyser les scores de plusieurs Appels
</div>

<div id="multiple-calls-api">
  #### API des appels multiples
</div>

Pour récupérer plusieurs appels, vous pouvez utiliser la méthode `get_calls`.

```python lines theme={null}
client = weave.init("my-project")

# Obtenir plusieurs appels - utilisez les filtres de votre choix et incluez le feedback
calls = client.get_calls(..., include_feedback=True)

# Itérer sur les appels et accéder au feedback qui contient les scores
for call in calls:
    feedback = list(call.feedback)
```

<div id="multiple-calls-ui">
  #### Interface des appels multiples
</div>

<Frame>
  <img src="https://mintcdn.com/wb-21fd5541-docs-hivemind-launch/HbhUDAG_r2i2K_Pk/weave/guides/evaluation/img/traces_table_scores.png?fit=max&auto=format&n=HbhUDAG_r2i2K_Pk&q=85&s=a83322a5ef4fd70860fc1c0ebaa41fae" alt="Onglet Appels multiples" width="4112" height="2328" data-path="weave/guides/evaluation/img/traces_table_scores.png" />
</Frame>

Les scores de plusieurs appels sont affichés dans le tableau des traces, dans la colonne « Scores ».

<div id="analyze-all-calls-scored-by-a-specific-scorer">
  ### Analyser tous les Appels évalués par un scorer spécifique
</div>

<div id="all-calls-by-scorer-api">
  #### API de tous les appels par scorer
</div>

Pour récupérer tous les appels notés par un scorer spécifique, vous pouvez utiliser la méthode `get_calls`.

```python lines theme={null}
client = weave.init("my-project")

# Pour obtenir tous les appels évalués par n'importe quelle version d'un scorer, utilisez le nom du scorer (généralement le nom de la classe)
calls = client.get_calls(scored_by=["MyScorer"], include_feedback=True)

# Pour obtenir tous les appels évalués par une version spécifique d'un scorer, utilisez la référence complète
# Les références peuvent être obtenues depuis l'objet scorer ou via l'interface utilisateur.
calls = client.get_calls(scored_by=[myScorer.ref.uri()], include_feedback=True)

# Parcourir les appels et accéder aux feedback contenant les scores
for call in calls:
    feedback = list(call.feedback)
```

<div id="all-calls-by-scorer-ui">
  #### Tous les appels d’un Scorer dans l’UI
</div>

Enfin, si vous souhaitez voir tous les appels évalués par un Scorer, accédez à l’onglet Scorers dans l’UI et sélectionnez l’onglet "Programmatic Scorer". Cliquez sur votre Scorer pour ouvrir la page de détails du Scorer.

<Frame>
  <img src="https://mintcdn.com/wb-21fd5541-docs-hivemind-launch/HbhUDAG_r2i2K_Pk/weave/guides/evaluation/img/scorer_detail_page.png?fit=max&auto=format&n=HbhUDAG_r2i2K_Pk&q=85&s=af67652705e83c0badaff1cec24e9347" alt="Page de détails du Scorer" width="1919" height="946" data-path="weave/guides/evaluation/img/scorer_detail_page.png" />
</Frame>

Ensuite, cliquez sur le bouton `View Traces` sous `Scores` pour voir tous les appels évalués par votre Scorer.

<Frame>
  <img src="https://mintcdn.com/wb-21fd5541-docs-hivemind-launch/HbhUDAG_r2i2K_Pk/weave/guides/evaluation/img/filtered_calls_to_scorer_version.png?fit=max&auto=format&n=HbhUDAG_r2i2K_Pk&q=85&s=214a0be29fb6ca62dbd7e14560bf1475" alt="Appels filtrés sur la version du Scorer" width="1919" height="946" data-path="weave/guides/evaluation/img/filtered_calls_to_scorer_version.png" />
</Frame>

Par défaut, cela affiche la version sélectionnée du Scorer. Vous pouvez supprimer le filtre de version pour voir tous les appels évalués par n’importe quelle version du Scorer.

<Frame>
  <img src="https://mintcdn.com/wb-21fd5541-docs-hivemind-launch/HbhUDAG_r2i2K_Pk/weave/guides/evaluation/img/filtered_calls_scorer_name.png?fit=max&auto=format&n=HbhUDAG_r2i2K_Pk&q=85&s=533b0eaa2fb9bec794be25f43edc4b6f" alt="Appels filtrés sur le nom du Scorer" width="1919" height="946" data-path="weave/guides/evaluation/img/filtered_calls_scorer_name.png" />
</Frame>