Passer au contenu principal
W&B Weave propose plusieurs évaluateurs prédéfinis pour évaluer vos applications d’IA, comme la détection des hallucinations et la qualité des résumés. 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.
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.

​
Installation

Pour utiliser les évaluateurs prédéfinis de Weave, installez certaines dépendances supplémentaires : 
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.

​
HallucinationFreeScorer

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. 
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 pour associer context à la colonne du dataset.
L’exemple suivant utilise HallucinationFreeScorer dans le cadre d’une évaluation : 
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': ...}}

​
SummarizationScorer

Utilisez un LLM pour comparer une synthèse au texte d’origine et en évaluer la qualité. 
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.
  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 si votre dataset utilise un autre nom.
L’exemple suivant utilise SummarizationScorer dans le cadre d’une évaluation : 
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': ...}}

​
OpenAIModerationScorer

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. 
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 : 
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': ...}}

​
EmbeddingSimilarityScorer

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. 
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 : 
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': ...}}

​
ValidJSONScorer

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é. 
from weave.scorers import ValidJSONScorer

json_scorer = ValidJSONScorer()
L’exemple suivant utilise ValidJSONScorer dans le cadre d’une évaluation : 
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': ...}}

​
ValidXMLScorer

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. 
from weave.scorers import ValidXMLScorer

xml_scorer = ValidXMLScorer()
L’exemple suivant utilise ValidXMLScorer dans le cadre d’une évaluation : 
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': ...}}

​
PydanticScorer

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. 
from weave.scorers import PydanticScorer
from pydantic import BaseModel

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

pydantic_scorer = PydanticScorer(model=FinancialReport)

​
RAGAS - ContextEntityRecallScorer

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

​
RAGAS - ContextRelevancyScorer

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. 
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 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 : 
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 : 
from weave.scorers import SummarizationScorer

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