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

# Utiliser les évaluateurs intégrés

> Utilisez les évaluateurs prédéfinis de Weave pour évaluer vos applications d'IA

W\&B Weave propose plusieurs évaluateurs prédéfinis pour évaluer vos applications d'IA, comme la [détection des hallucinations](#hallucinationfreescorer) et la [qualité des résumés](#summarizationscorer). Ils peuvent être utiles pour définir rapidement une évaluation et attribuer un score aux sorties de votre application. Cette page décrit chaque évaluateur intégré, ce qu'il mesure et comment l'utiliser dans une évaluation.

<Note>
  Les évaluateurs locaux sont disponibles uniquement 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).
</Note>

<div id="installation">
  ## Installation
</div>

Pour utiliser les évaluateurs prédéfinis de Weave, installez certaines dépendances supplémentaires :

```bash theme={null}
pip install weave[scorers]
```

**Évaluateurs LLM**

Les évaluateurs prédéfinis qui utilisent des LLM s’intègrent automatiquement à litellm. Vous n’avez pas besoin de passer un client LLM. Définissez plutôt `model_id`. Voir les [modèles pris en charge](https://docs.litellm.ai/docs/providers).

<div id="hallucinationfreescorer">
  ## `HallucinationFreeScorer`
</div>

Ce scorer vérifie si la sortie de votre système d'IA contient des hallucinations, sur la base des données d'entrée.

```python lines theme={null}
from weave.scorers import HallucinationFreeScorer

scorer = HallucinationFreeScorer()
```

**Personnalisation**

* Personnalisez les champs `system_prompt` et `user_prompt` du scorer pour définir ce que signifie « hallucination » dans votre cas.

**Remarques**

* La méthode `score` attend une colonne d'entrée nommée `context`. Si votre dataset utilise un autre nom, [utilisez l'attribut `column_map`](#use-column-mapping) pour associer `context` à la colonne du dataset.

L'exemple suivant utilise `HallucinationFreeScorer` dans le cadre d'une évaluation :

```python lines theme={null}
import asyncio
import weave
from weave.scorers import HallucinationFreeScorer

# Initialisez le scorer avec un mappage de colonnes si nécessaire.
hallucination_scorer = HallucinationFreeScorer(
    model_id="openai/gpt-4o", # ou tout autre modèle pris en charge par litellm
    column_map={"context": "input", "output": "other_col"}
)

# Créez le dataset
dataset = [
    {"input": "John likes various types of cheese."},
    {"input": "Pepe likes various types of cheese."},
]

@weave.op
def model(input: str) -> str:
    return "The person's favorite cheese is cheddar."

# Lancez l'évaluation
evaluation = weave.Evaluation(
    dataset=dataset,
    scorers=[hallucination_scorer],
)
result = asyncio.run(evaluation.evaluate(model))
print(result)
# Exemple de sortie :
# {'HallucinationFreeScorer': {'has_hallucination': {'true_count': 2, 'true_fraction': 1.0}}, 'model_latency': {'mean': ...}}
```

***

<div id="summarizationscorer">
  ## `SummarizationScorer`
</div>

Utilisez un LLM pour comparer une synthèse au texte d’origine et en évaluer la qualité.

```python lines theme={null}
from weave.scorers import SummarizationScorer

scorer = SummarizationScorer(
    model_id="openai/gpt-4o"  # ou tout autre modèle pris en charge par litellm
)
```

**Fonctionnement**

Ce scorer évalue les synthèses de deux manières :

1. **Densité d'entités :** vérifie le ratio entre les entités uniques (telles que des noms, des lieux ou des objets) mentionnées dans la synthèse et le nombre total de mots qu'elle contient afin d'estimer sa "densité d'information". Il utilise un LLM pour extraire les entités. Cette approche est similaire à la manière dont la densité d'entités est utilisée dans l'[article Chain of Density](https://arxiv.org/abs/2309.04269).
2. **Évaluation de la qualité :** un évaluateur LLM classe la synthèse comme `poor`, `ok` ou `excellent`. Ces évaluations sont ensuite converties en scores (0.0 pour poor, 0.5 pour ok et 1.0 pour excellent) pour l'évaluation agrégée des performances.

**Personnalisation**

* Ajustez `summarization_evaluation_system_prompt` et `summarization_evaluation_prompt` pour personnaliser le processus d'évaluation.

**Notes**

* Le scorer utilise litellm en interne.
* La méthode `score` suppose que le texte original (le texte à synthétiser) est présent dans la colonne `input`. [Utilisez l'attribut `column_map`](#use-column-mapping) si votre dataset utilise un autre nom.

L'exemple suivant utilise `SummarizationScorer` dans le cadre d'une évaluation :

```python lines theme={null}
import asyncio
import weave
from weave.scorers import SummarizationScorer

class SummarizationModel(weave.Model):
    @weave.op()
    async def predict(self, input: str) -> str:
        return "This is a summary of the input text."

# Initialiser le scorer
summarization_scorer = SummarizationScorer(
    model_id="openai/gpt-4o"  # or any other model supported by litellm
)
# Créer le dataset
dataset = [
    {"input": "The quick brown fox jumps over the lazy dog."},
    {"input": "Artificial Intelligence is revolutionizing various industries."}
]
# Lancer l'évaluation
evaluation = weave.Evaluation(dataset=dataset, scorers=[summarization_scorer])
results = asyncio.run(evaluation.evaluate(SummarizationModel()))
print(results)
# Exemple de sortie :
# {'SummarizationScorer': {'is_entity_dense': {'true_count': 0, 'true_fraction': 0.0}, 'summarization_eval_score': {'mean': 0.0}, 'entity_density': {'mean': 0.0}}, 'model_latency': {'mean': ...}}
```

***

<div id="openaimoderationscorer">
  ## `OpenAIModerationScorer`
</div>

Le `OpenAIModerationScorer` utilise l’API Moderation d’OpenAI pour vérifier si la sortie du système d’IA contient du contenu non autorisé, comme des discours haineux ou du contenu explicite.

```python lines theme={null}
from weave.scorers import OpenAIModerationScorer

scorer = OpenAIModerationScorer()
```

**Fonctionnement**

* Envoie la sortie de l’IA au point de terminaison OpenAI Moderation et renvoie une réponse structurée indiquant si le contenu a été signalé.

L’exemple suivant utilise `OpenAIModerationScorer` dans le cadre d’une évaluation :

```python lines theme={null}
import asyncio
import weave
from weave.scorers import OpenAIModerationScorer

class MyModel(weave.Model):
    @weave.op
    async def predict(self, input: str) -> str:
        return input

# Initialiser le scorer
moderation_scorer = OpenAIModerationScorer()

# Créer le dataset
dataset = [
    {"input": "I love puppies and kittens!"},
    {"input": "I hate everyone and want to hurt them."}
]

# Lancer l'évaluation
evaluation = weave.Evaluation(dataset=dataset, scorers=[moderation_scorer])
results = asyncio.run(evaluation.evaluate(MyModel()))
print(results)
# Exemple de sortie :
# {'OpenAIModerationScorer': {'flagged': {'true_count': 1, 'true_fraction': 0.5}, 'categories': {'violence': {'true_count': 1, 'true_fraction': 1.0}}}, 'model_latency': {'mean': ...}}
```

***

<div id="embeddingsimilarityscorer">
  ## `EmbeddingSimilarityScorer`
</div>

`EmbeddingSimilarityScorer` calcule la similarité cosinus entre les embeddings de la sortie du système d’IA et un texte cible de votre jeu de données. Utilisez-le pour mesurer le degré de similarité entre la sortie de l’IA et un texte de référence.

```python lines theme={null}
from weave.scorers import EmbeddingSimilarityScorer

similarity_scorer = EmbeddingSimilarityScorer(
    model_id="openai/text-embedding-3-small",  # ou tout autre modèle pris en charge par litellm
    threshold=0.4  # le seuil de similarité cosinus
)
```

**Paramètres**

* `threshold` (float) : Le score minimal de similarité cosinus (entre -1 et 1) requis pour considérer que les deux textes sont similaires (valeur par défaut : `0.5`).

L’exemple suivant utilise `EmbeddingSimilarityScorer` dans le cadre d’une évaluation :

```python lines theme={null}
import asyncio
import weave
from weave.scorers import EmbeddingSimilarityScorer

# Initialiser le scorer
similarity_scorer = EmbeddingSimilarityScorer(
    model_id="openai/text-embedding-3-small",  # ou tout autre modèle pris en charge par litellm
    threshold=0.7
)
# Créer le dataset
dataset = [
    {
        "input": "He's name is John",
        "target": "John likes various types of cheese.",
    },
    {
        "input": "He's name is Pepe.",
        "target": "Pepe likes various types of cheese.",
    },
]
# Définir le modèle
@weave.op
def model(input: str) -> str:
    return "John likes various types of cheese."

# Lancer l'évaluation
evaluation = weave.Evaluation(
    dataset=dataset,
    scorers=[similarity_scorer],
)
result = asyncio.run(evaluation.evaluate(model))
print(result)
# Exemple de sortie :
# {'EmbeddingSimilarityScorer': {'is_similar': {'true_count': 1, 'true_fraction': 0.5}, 'similarity_score': {'mean': 0.844851403}}, 'model_latency': {'mean': ...}}
```

***

<div id="validjsonscorer">
  ## `ValidJSONScorer`
</div>

Le `ValidJSONScorer` vérifie si la sortie du système d’IA est un JSON valide. Ce scorer est utile lorsque vous attendez une sortie au format JSON et devez en vérifier la validité.

```python lines theme={null}
from weave.scorers import ValidJSONScorer

json_scorer = ValidJSONScorer()
```

L’exemple suivant utilise `ValidJSONScorer` dans le cadre d’une évaluation :

```python lines theme={null}
import asyncio
import weave
from weave.scorers import ValidJSONScorer

class JSONModel(weave.Model):
    @weave.op()
    async def predict(self, input: str) -> str:
        # Il s'agit d'un espace réservé.
        # Dans un scénario réel, cela générerait du JSON.
        return '{"key": "value"}'

model = JSONModel()
json_scorer = ValidJSONScorer()

dataset = [
    {"input": "Generate a JSON object with a key and value"},
    {"input": "Create an invalid JSON"}
]

evaluation = weave.Evaluation(dataset=dataset, scorers=[json_scorer])
results = asyncio.run(evaluation.evaluate(model))
print(results)
# Exemple de sortie :
# {'ValidJSONScorer': {'json_valid': {'true_count': 2, 'true_fraction': 1.0}}, 'model_latency': {'mean': ...}}
```

***

<div id="validxmlscorer">
  ## `ValidXMLScorer`
</div>

Le `ValidXMLScorer` vérifie si la sortie du système d’IA est un document XML valide. Utilisez-le lorsque vous attendez des sorties au format XML.

```python lines theme={null}
from weave.scorers import ValidXMLScorer

xml_scorer = ValidXMLScorer()
```

L’exemple suivant utilise `ValidXMLScorer` dans le cadre d’une évaluation :

```python lines theme={null}
import asyncio
import weave
from weave.scorers import ValidXMLScorer

class XMLModel(weave.Model):
    @weave.op()
    async def predict(self, input: str) -> str:
        # Ceci est un espace réservé. Dans un scénario réel, cela générerait du XML.
        return '<root><element>value</element></root>'

model = XMLModel()
xml_scorer = ValidXMLScorer()

dataset = [
    {"input": "Generate a valid XML with a root element"},
    {"input": "Create an invalid XML"}
]

evaluation = weave.Evaluation(dataset=dataset, scorers=[xml_scorer])
results = asyncio.run(evaluation.evaluate(model))
print(results)
# Exemple de sortie :
# {'ValidXMLScorer': {'xml_valid': {'true_count': 2, 'true_fraction': 1.0}}, 'model_latency': {'mean': ...}}
```

***

<div id="pydanticscorer">
  ## `PydanticScorer`
</div>

Le `PydanticScorer` valide la sortie du système d’IA par rapport à un modèle Pydantic afin de garantir qu’elle respecte un schéma ou une structure de données donnés.

```python lines theme={null}
from weave.scorers import PydanticScorer
from pydantic import BaseModel

class FinancialReport(BaseModel):
    revenue: int
    year: str

pydantic_scorer = PydanticScorer(model=FinancialReport)
```

***

<div id="ragas-contextentityrecallscorer">
  ## RAGAS - `ContextEntityRecallScorer`
</div>

Le `ContextEntityRecallScorer` estime le rappel du contexte en extrayant les entités à la fois de la sortie du système d’IA et du contexte fourni, puis en calculant le score de rappel. Il s’appuie sur la bibliothèque d’évaluation Retrieval Augmented Generation Assessment ([RAGAS](https://github.com/explodinggradients/ragas)).

```python lines theme={null}
from weave.scorers import ContextEntityRecallScorer

entity_recall_scorer = ContextEntityRecallScorer(
    model_id="openai/gpt-4o"
)
```

**Fonctionnement**

* Utilise un LLM pour extraire les entités uniques de la sortie et du contexte, puis calcule le rappel.
* Le **rappel** indique la proportion d'entités importantes du contexte présentes dans la sortie.
* Renvoie un dictionnaire contenant le score de rappel.

**Notes**

* Nécessite une colonne `context` dans votre dataset. [Utilisez l'attribut `column_map`](#use-column-mapping) si le nom de la colonne est différent.

***

<div id="ragas-contextrelevancyscorer">
  ## RAGAS - `ContextRelevancyScorer`
</div>

Le `ContextRelevancyScorer` évalue la pertinence du contexte fourni par rapport à la sortie du système d’IA. Il est basé sur la bibliothèque d’évaluation RAGAS.

```python lines theme={null}
from weave.scorers import ContextRelevancyScorer

relevancy_scorer = ContextRelevancyScorer(
    model_id="openai/gpt-4o",  # ou tout autre modèle pris en charge par litellm
    relevancy_prompt="""
Given the following question and context, rate the relevancy of the context to the question on a scale from 0 to 1.

Question: {question}
Context: {context}
Relevancy Score (0-1):
"""
)
```

**Fonctionnement**

* Utilise un LLM pour évaluer la pertinence du contexte par rapport à la sortie sur une échelle de 0 à 1.
* Renvoie un dictionnaire contenant le `relevancy_score`.

**Remarques**

* Nécessite une colonne `context` dans votre dataset. [Utilisez l’attribut `column_map`](#use-column-mapping) si le nom de la colonne est différent.
* Personnalisez `relevancy_prompt` pour définir la manière dont la pertinence est évaluée.

L’exemple suivant utilise `ContextEntityRecallScorer` et `ContextRelevancyScorer` ensemble dans le cadre d’une évaluation :

```python lines theme={null}
import asyncio
from textwrap import dedent
import weave
from weave.scorers import ContextEntityRecallScorer, ContextRelevancyScorer

class RAGModel(weave.Model):
    @weave.op()
    async def predict(self, question: str) -> str:
        "Retrieve relevant context"
        return "Paris is the capital of France."

# Définir les prompts
relevancy_prompt: str = dedent("""
    Given the following question and context, rate the relevancy of the context to the question on a scale from 0 to 1.

    Question: {question}
    Context: {context}
    Relevancy Score (0-1):
    """)
# Initialiser les évaluateurs
entity_recall_scorer = ContextEntityRecallScorer()
relevancy_scorer = ContextRelevancyScorer(relevancy_prompt=relevancy_prompt)
# Créer le dataset
dataset = [
    {
        "question": "What is the capital of France?",
        "context": "Paris is the capital city of France."
    },
    {
        "question": "Who wrote Romeo and Juliet?",
        "context": "William Shakespeare wrote many famous plays."
    }
]
# Lancer l'évaluation
evaluation = weave.Evaluation(
    dataset=dataset,
    scorers=[entity_recall_scorer, relevancy_scorer]
)
results = asyncio.run(evaluation.evaluate(RAGModel()))
print(results)
# Exemple de sortie :
# {'ContextEntityRecallScorer': {'recall': {'mean': ...}}, 
# 'ContextRelevancyScorer': {'relevancy_score': {'mean': ...}}, 
# 'model_latency': {'mean': ...}}
```

**Remarque :** Les évaluateurs intégrés sont calibrés à l’aide de modèles OpenAI, tels que `openai/gpt-4o` et `openai/text-embedding-3-small`. Pour utiliser un autre fournisseur, mettez à jour le champ `model_id`. Par exemple, pour utiliser un modèle Anthropic :

```python lines theme={null}
from weave.scorers import SummarizationScorer

# Passer au modèle Claude d'Anthropic
summarization_scorer = SummarizationScorer(
    model_id="anthropic/claude-3-5-sonnet-20240620"
)
```