> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Évaluer avec des évaluateurs locaux
> De petits modèles de langage qui s’exécutent localement pour évaluer la sécurité et la qualité des systèmes d’IA
Les évaluateurs locaux de Weave constituent une suite de petits modèles de langage qui s’exécutent localement sur votre machine avec une latence minimale. Ces modèles évaluent la sécurité et la qualité des entrées, du contexte et des sorties de votre système d’IA.
Cette page explique comment évaluer la sécurité et la qualité de votre système d’IA à l’aide des évaluateurs locaux de Weave, et présente chaque évaluateur disponible avec des notes d’utilisation et des exemples. Utilisez ce guide pour choisir un évaluateur adapté à votre cas d’usage, installer les dépendances et ajouter des évaluateurs aux entrées, au contexte ou aux sorties de votre système d’IA.
W\&B effectue le fine-tuning de certains de ces modèles, tandis que d’autres sont des modèles open source de pointe entraînés par la communauté. W\&B Reports documente le processus d’entraînement et d’évaluation. Pour tous les détails, voir cette [liste de W\&B Reports](https://wandb.ai/c-metrics/weave-scorers/reports/Weave-Scorers-v1--VmlldzoxMDQ0MDE1OA).
Les poids des modèles sont accessibles publiquement dans W\&B Artifacts et sont automatiquement téléchargés lorsque vous instanciez la classe de l’évaluateur. Vous trouverez ici les chemins des Artifacts si vous souhaitez les télécharger vous-même : `weave.scorers.default_models`
L’objet renvoyé par ces évaluateurs contient un attribut booléen `passed` indiquant si le texte d’entrée est sûr ou de haute qualité, ainsi qu’un attribut `metadata` fournissant plus de détails, comme le score brut du modèle.
Vous pouvez exécuter des évaluateurs locaux sur CPU, mais W\&B recommande d’utiliser des GPU pour obtenir les meilleures performances.
Les évaluateurs locaux sont uniquement disponibles pour le SDK Python de Weave. Ils ne sont pas encore disponibles pour le SDK TypeScript de Weave.
Pour utiliser les évaluateurs Weave en TypeScript, voir les [évaluateurs basés sur des fonctions](/fr/weave/guides/evaluation/scorers#function-based-scorers).
## Prérequis
Avant de pouvoir utiliser les évaluateurs locaux de Weave, installez des dépendances supplémentaires qui incluent les bibliothèques d’évaluateurs requises :
```bash theme={null}
pip install weave[scorers]
```
Une fois les dépendances installées, vous pouvez choisir un évaluateur pour votre évaluation.
## Sélectionner un évaluateur
Les évaluateurs locaux suivants sont disponibles. Sélectionnez un évaluateur selon votre cas d’usage, puis passez à la section correspondante ci-dessous pour consulter les notes d’utilisation et un exemple.
| Scorer | Scénario |
| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [WeaveToxicityScorerV1](#weavetoxicityscorerv1) | Identifier le contenu toxique ou dangereux dans les entrées et les sorties de votre système d’IA, y compris les discours haineux ou les menaces. |
| [WeaveBiasScorerV1](#weavebiasscorerv1) | Détecter le contenu biaisé ou stéréotypé dans les entrées et les sorties de votre système d’IA. Utile pour réduire les biais nocifs dans le texte généré. |
| [WeaveHallucinationScorerV1](#weavehallucinationscorerv1) | Identifier si votre système RAG génère des hallucinations dans sa sortie à partir de l’entrée et du contexte fournis. |
| [WeaveContextRelevanceScorerV1](#weavecontextrelevancescorerv1) | Mesurer si la sortie du système d’IA est pertinente au regard de l’entrée et du contexte fournis. |
| [WeaveCoherenceScorerV1](#weavecoherencescorerv1) | Évaluer la cohérence et la structure logique de la sortie du système d’IA. |
| [WeaveFluencyScorerV1](#weavefluencyscorerv1) | Mesurer si la sortie du système d’IA est fluide. |
| [WeaveTrustScorerV1](#weavetrustscorerv1) | Combiner les évaluateurs de toxicité, d’hallucination, de pertinence du contexte, de fluidité et de cohérence en un signal de confiance unique. |
| [PresidioScorer](#presidioscorer) | Détecter des informations personnelles identifiables (PII) dans les entrées et les sorties de votre système d’IA à l’aide de la bibliothèque Presidio de Microsoft. |
## `WeaveBiasScorerV1`
Ce scorer évalue les biais liés au genre et à la race/à l’origine selon deux dimensions :
* Race et origine : racisme et biais envers un pays ou une région d’origine, le statut migratoire ou l’origine ethnique.
* Genre et sexualité : sexisme, misogynie, homophobie, transphobie ou harcèlement sexuel.
`WeaveBiasScorerV1` utilise un modèle [deberta-small-long-nli](https://huggingface.co/tasksource/deberta-small-long-nli) affiné. Pour plus de détails sur le modèle, le jeu de données et le processus d’étalonnage, voir le [rapport W\&B WeaveBiasScorerV1](https://wandb.ai/c-metrics/bias-benchmark/reports/Bias-Scorer--VmlldzoxMDM2MTgzNw).
### Notes d’utilisation
* La méthode `score` attend une chaîne de caractères dans le paramètre `output`.
* Un score plus élevé indique une prédiction plus forte de biais dans le texte.
* Le paramètre `threshold` est défini, mais peut aussi être remplacé lors de l’initialisation.
### Exemple d’utilisation
```python lines theme={null}
import weave
from weave.scorers import WeaveBiasScorerV1
bias_scorer = WeaveBiasScorerV1()
result = bias_scorer.score(output="Martian men are terrible at cleaning")
print(f"The text is biased: {not result.passed}")
print(result)
```
***
## `WeaveToxicityScorerV1`
Ce scorer évalue la toxicité du texte fourni en entrée selon cinq dimensions :
* Race et origine : racisme et biais à l'encontre d'un pays ou d'une région d'origine, du statut migratoire ou de l'origine ethnique.
* Genre et sexualité : sexisme, misogynie, homophobie, transphobie ou harcèlement sexuel.
* Religion : biais ou stéréotypes liés à la religion d'une personne.
* Capacité : biais liés aux capacités ou au handicap physique, mental ou intellectuel d'une personne.
* Violence et abus : descriptions excessivement explicites de violence, menaces de violence ou incitation à la violence.
Le `WeaveToxicityScorerV1` utilise le modèle open source [Celadon](https://huggingface.co/PleIAs/celadon) de PleIAs. Pour plus d'informations, voir le [W\&B rapport WeaveToxicityScorerV1](https://wandb.ai/c-metrics/toxicity-benchmark/reports/Toxicity-Scorer--VmlldzoxMDMyNjc0NQ).
### Notes d’utilisation
* La méthode `score` attend qu’une chaîne de caractères soit passée au paramètre `output`.
* Le modèle renvoie des scores de `0` à `3` dans cinq catégories différentes :
* Si la somme de ces scores dépasse `total_threshold` (valeur par défaut : `5`), l’entrée est signalée comme toxique.
* Si une catégorie obtient à elle seule un score supérieur à `category_threshold` (par défaut : `2`), l’entrée est signalée comme toxique.
* Pour rendre le filtrage plus agressif, remplacez `category_threshold` ou `total_threshold` lors de l’initialisation.
### Exemple d’utilisation
```python lines theme={null}
import weave
from weave.scorers import WeaveToxicityScorerV1
toxicity_scorer = WeaveToxicityScorerV1()
result = toxicity_scorer.score(output="people from the south pole of Mars are the worst")
print(f"Input is toxic: {not result.passed}")
print(result)
```
***
## `WeaveHallucinationScorerV1`
Ce scorer vérifie si la sortie de votre système d'IA contient des hallucinations en fonction des données d'entrée.
Le `WeaveHallucinationScorerV1` utilise le [modèle HHEM 2.1 open source](https://huggingface.co/vectara/hallucination_evaluation_model) de Vectara. Pour plus d'informations, voir le [rapport W\&B WeaveHallucinationScorerV1](https://wandb.ai/c-metrics/hallucination/reports/Hallucination-Scorer--VmlldzoxMDM3NDA3MA).
### Notes d’utilisation
* La méthode `score` attend des valeurs pour les paramètres `query` et `output`.
* Le contexte doit être passé au paramètre `output` (sous forme de chaîne ou de liste de chaînes).
* Un score de sortie plus élevé indique une probabilité plus forte d’hallucination dans la sortie.
* Le paramètre `threshold` est défini, mais peut être redéfini lors de l’initialisation.
### Exemple d’utilisation
```python lines theme={null}
import weave
from weave.scorers import WeaveHallucinationScorerV1
hallucination_scorer = WeaveHallucinationScorerV1()
result = hallucination_scorer.score(
query="What is the capital of Antarctica?",
context="People in Antarctica love the penguins.",
output="While Antarctica is known for its sea life, penguins aren't liked there."
)
print(f"Output is hallucinated: {not result.passed}")
print(result)
```
***
## `WeaveContextRelevanceScorerV1`
Utilisez ce scorer pour évaluer les systèmes RAG. Il évalue la pertinence du contexte par rapport à la requête.
Le `WeaveContextRelevanceScorerV1` utilise un modèle [deberta-small-long-nli](https://huggingface.co/tasksource/deberta-small-long-nli) affiné sur tasksource. Pour plus de détails, voir le [W\&B rapport WeaveContextRelevanceScorerV1](https://wandb.ai/c-metrics/context-relevance-scorer/reports/Context-Relevance-Scorer--VmlldzoxMDYxNjEyNA).
### Notes d’utilisation
* La méthode `score` attend des valeurs pour `query` et `output`.
* Le contexte doit être transmis dans le paramètre `output` (chaîne ou liste de chaînes).
* Un score plus élevé indique plus fortement que le contexte est pertinent pour la requête.
* Vous pouvez passer `verbose=True` à la méthode `score` pour obtenir des scores pour chaque segment.
### Exemple d’utilisation
```python lines theme={null}
import weave
from weave.scorers import WeaveContextRelevanceScorerV1
context_relevance_scorer = WeaveContextRelevanceScorerV1()
result = context_relevance_scorer.score(
query="What is the capital of Antarctica?",
output="The Antarctic has the happiest penguins." # le contexte est transmis au paramètre output
)
print(f"Output is relevant: {result.passed}")
print(result)
```
***
## `WeaveCoherenceScorerV1`
Ce scorer vérifie si le texte d’entrée est cohérent.
`WeaveCoherenceScorerV1` utilise un modèle [deberta-small-long-nli](https://huggingface.co/tasksource/deberta-small-long-nli) affiné de tasksource. Pour plus d'informations, voir le [W\&B rapport de WeaveCoherenceScorerV1](https://wandb.ai/c-metrics/coherence_scorer/reports/Coherence-Scorer--VmlldzoxMDI5MjA1MA).
### Notes d’utilisation
* La méthode `score` attend du texte dans les paramètres `query` et `output`.
* Plus le score de sortie est élevé, plus la prédiction de cohérence est forte.
### Exemple d’utilisation
```python lines theme={null}
import weave
from weave.scorers import WeaveCoherenceScorerV1
coherence_scorer = WeaveCoherenceScorerV1()
result = coherence_scorer.score(
query="What is the capital of Antarctica?",
output="but why not monkey up day"
)
print(f"Output is coherent: {result.passed}")
print(result)
```
***
## `WeaveFluencyScorerV1`
Ce scorer vérifie si le texte d'entrée est fluide (lisible et proche du langage humain naturel). Il évalue la grammaire, la syntaxe et la lisibilité globale.
Le `WeaveFluencyScorerV1` utilise un modèle [ModernBERT-base](https://huggingface.co/answerdotai/ModernBERT-base) affiné par AnswerDotAI. Pour plus d'informations, voir le [rapport W\&B WeaveFluencyScorerV1](https://wandb.ai/c-metrics/fluency-eval/reports/Fluency-Scorer--VmlldzoxMTA3NzE2Ng).
### Notes d’utilisation
* La méthode `score` attend qu’un texte soit transmis au paramètre `output`.
* Un score plus élevé en sortie indique une meilleure fluidité.
### Exemple d’utilisation
```python lines theme={null}
import weave
from weave.scorers import WeaveFluencyScorerV1
fluency_scorer = WeaveFluencyScorerV1()
result = fluency_scorer.score(
output="The cat did stretching lazily into warmth of sunlight."
)
print(f"Output is fluent: {result.passed}")
print(result)
```
***
## `WeaveTrustScorerV1`
Utilisez cet évaluateur lorsque vous souhaitez un signal de confiance unique qui combine plusieurs évaluateurs au lieu de les exécuter individuellement.
Le `WeaveTrustScorerV1` est un scorer composite pour les systèmes RAG. Il évalue la fiabilité des résultats du modèle en regroupant d'autres évaluateurs en deux catégories : Critical et Advisory. En fonction du score composite, il renvoie un niveau de confiance :
* `high` : Aucun problème détecté.
* `medium` : Seuls des problèmes Advisory sont détectés.
* `low` : Des problèmes Critical sont détectés ou l'entrée est vide.
Toute entrée qui ne satisfait pas un évaluateur Critical entraîne un niveau de confiance `low`. Si un évaluateur Advisory n'est pas satisfait, le niveau de confiance est `medium`.
* **Critical:**
* `WeaveToxicityScorerV1`
* `WeaveHallucinationScorerV1`
* `WeaveContextRelevanceScorerV1`
* **Advisory:**
* `WeaveFluencyScorerV1`
* `WeaveCoherenceScorerV1`
### Notes d’utilisation
* Utilisez ce scorer pour évaluer les pipelines RAG.
* Il nécessite les clés `query`, `context` et `output` pour calculer correctement le score.
### Exemple d’utilisation
```python lines theme={null}
import weave
from weave.scorers import WeaveTrustScorerV1
trust_scorer = WeaveTrustScorerV1()
def print_trust_scorer_result(result):
print()
print(f"Output is trustworthy: {result.passed}")
print(f"Trust level: {result.metadata['trust_level']}")
if not result.passed:
print("Triggered scorers:")
for scorer_name, scorer_data in result.metadata['raw_outputs'].items():
if not scorer_data.passed:
print(f" - {scorer_name} did not pass")
print()
print(f"WeaveToxicityScorerV1 scores: {result.metadata['scores']['WeaveToxicityScorerV1']}")
print(f"WeaveHallucinationScorerV1 scores: {result.metadata['scores']['WeaveHallucinationScorerV1']}")
print(f"WeaveContextRelevanceScorerV1 score: {result.metadata['scores']['WeaveContextRelevanceScorerV1']}")
print(f"WeaveCoherenceScorerV1 score: {result.metadata['scores']['WeaveCoherenceScorerV1']}")
print(f"WeaveFluencyScorerV1: {result.metadata['scores']['WeaveFluencyScorerV1']}")
print()
result = trust_scorer.score(
query="What is the capital of Antarctica?",
context="People in Antarctica love the penguins.",
output="The cat stretched lazily in the warm sunlight."
)
print_trust_scorer_result(result)
print(result)
```
***
## `PresidioScorer`
Ce scorer utilise la [bibliothèque Presidio](https://github.com/microsoft/presidio) pour détecter les personally identifiable information (PII) dans les `inputs` et les sorties de votre système d’IA.
### Notes d’utilisation
* Pour détecter certains types d’entités, comme les adresses e-mail ou les numéros de téléphone, passez une liste d’entités Presidio au paramètre `selected_entities`. Sinon, Presidio détecte tous les types d’entités de sa liste par défaut.
* Vous pouvez passer des recognizers personnalisés via le paramètre `custom_recognizers`, sous la forme d’une liste d’instances `presidio.EntityRecognizer`.
* Pour traiter du texte non anglais, utilisez le paramètre `language` pour préciser la langue.
### Exemple d’utilisation
```python lines theme={null}
import weave
from weave.scorers import PresidioScorer
presidio_scorer = PresidioScorer()
result = presidio_scorer.score(
output="Mary Jane is a software engineer at XYZ company and her email is mary.jane@xyz.com."
)
print(f"Output contains PII: {not result.passed}")
print(result)
```