Ingebouwde AI-beoordelaars

Belangrijk

Deze functie is beschikbaar als openbare preview.

In dit artikel worden de details besproken van elk van de AI-rechters die zijn ingebouwd in Mosaic AI Agent Evaluatie, met inbegrip van de vereiste invoer en uitvoermetingen.

Zie ook:

• Hoe kwaliteit, kosten en latentie worden beoordeeld door evaluatie door agenten
• AI-rechters aanpassen
• Aanroepbare juryleden python SDK-verwijzing

Overzicht van AI-rechters

Notitie

Niet alle rechters hebben grondwaarheidslabels nodig. Rechters die geen labels nodig hebben, zijn nuttig wanneer u slechts een set aanvragen hebt om uw agent te evalueren.

Naam van de rechter	Kwaliteitsaspect dat de rechter beoordeelt	Vereiste invoer	Vereist grondwaarheid
global_guideline_adherence	Voldoet het gegenereerde antwoord aan de algemene richtlijnen?	request, response, global_guidelines (uit de evaluator_config)	Nee, maar vereist global_guidelines
guideline_adherence	Voldoet het gegenereerde antwoord aan de opgegeven richtlijnen per vraag?	request, response, guidelines	Ja
correctness	Is het gegenereerde antwoord nauwkeurig (vergeleken met de grondwaar)?	response, expected_facts[] of expected_response	Ja
relevance_to_query	Is het antwoord relevant voor de aanvraag van de gebruiker?	response, request	Nee
context_sufficiency	heeft de retriever documenten met voldoende informatie gevonden om het verwachte antwoord te produceren?	retrieved_context, expected_response	Ja
safety	Is er schadelijke of giftige inhoud in het antwoord?	response	Nee
chunk_relevance	heeft de retriever segmenten gevonden die nuttig (relevant) zijn bij het beantwoorden van de aanvraag van de gebruiker? Opmerking: Deze beoordelingsmethode wordt afzonderlijk toegepast op elk opgehaald segment, waardoor een score en rationale voor elk segment wordt geproduceerd. Deze scores worden geaggregeerd in een chunk_relevance/precision score voor elke rij die het percentage van segmenten vertegenwoordigt dat relevant is.	retrieved_context, request	Nee
groundedness	Is het gegenereerde antwoord gebaseerd op de opgehaalde context (zonder hallucinaties)?	response, trace[retrieved_context]	Nee
document_recall	Hoeveel van de bekende relevante documenten heeft de retriever gevonden?	retrieved_context, expected_retrieved_context[].doc_uri	Ja

Notitie

Voor gesprekken met meerdere beurten evalueren AI-rechters alleen de laatste bijdrage in het gesprek.

AI-rechterlijke uitspraken

Elke rechter die in de evaluatie wordt gebruikt, levert de volgende kolommen op:

Gegevensveld	Type	Beschrijving
response/llm_judged/{judge_name}/rating	string	yes als de rechter slaagt, no als de rechter uitvalt.
response/llm_judged/{judge_name}/rationale	string	De schriftelijke redenering van LLM voor yes of no.
response/llm_judged/{judge_name}/error_message	string	Als er een fout is opgetreden bij het berekenen van deze evaluatie, vindt u hier details van de fout. Als er geen fout optreedt, is dit NULL.

Elke beoordelaar zal ook een statistische maatstaf voor de hele uitvoering opstellen.

Naam van meetwaarde	Type	Beschrijving
response/llm_judged/{judge_name}/rating/average	float, [0, 1]	Percentage van alle evaluaties die als yeswerden beoordeeld.

Naleving van richtlijn

Definitie: Voldoet het antwoord aan de opgegeven richtlijnen?

Vereist grondwaarheid: Nee bij gebruik van global_guidelines. Ja wanneer u per rij guidelinesgebruikt.

De naleving van de richtlijn evalueert of het antwoord van de agent specifieke beperkingen of instructies in de richtlijnen volgt.

Richtlijnen kunnen op een van de volgende manieren worden gedefinieerd:

• Per rij: Het antwoord voor een specifieke aanvraag moet voldoen aan de richtlijnen die voor die evaluatierij gedefinieerd zijn.
• wereldwijd: Alle antwoorden voor elke aanvraag moeten voldoen aan algemene richtlijnen.

Vereiste invoer

De invoerevaluatieset moet de volgende kolommen hebben:

• request
• response als u de parameter model niet hebt opgegeven voor mlflow.evaluate().
• per rij guidelines of global_guidelines, gedefinieerd in de configuratie.

Voorbeelden

Gebruik richtlijnnaleving per rij uit een evaluatieset:

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris.",
  # You can also just pass an array of guidelines directly to guidelines, but Databricks recommends naming them with a dictionary.
  "guidelines": {
    "english": ["The response must be in English"],
    "clarity": ["The response must be clear, coherent, and concise"],
  }
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["guideline_adherence"]
      }
  }
)

Gebruik naleving van globale richtlijnen vanuit een evaluatieset:

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris.",
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["guideline_adherence"],
          "global_guidelines": ["The response must be in English", "The response must be concise"]
      }
  }
)

Gebruik richtlijnnaleving met de callable judge SDK:

from databricks.agents.evals import judges

assessment = judges.guideline_adherence(
  request="What is the capital of France?",
  response="The capital of France is Paris.",
  # You can also just pass an array of guidelines directly to guidelines, but Databricks recommends naming them with a dictionary.
  guidelines={
    "english": ["The response must be in English"],
    "clarity": ["The response must be clear, coherent, and concise"],
  },
)
print(assessment)

Wat moet u doen wanneer het antwoord niet aan de richtlijnen voldoet?

Wanneer het antwoord in strijd is met de richtlijnen:

• Bepaal welke richtlijn is geschonden en analyseer waarom de agent zich niet aan deze richtlijn heeft gehouden.
• Pas de prompt aan om de naleving van specifieke richtlijnen te benadrukken of het model opnieuw te trainen met aanvullende voorbeelden die overeenkomen met het gewenste gedrag.
• Voor globale richtlijnen moet u ervoor zorgen dat deze correct zijn opgegeven in de configuratie van de evaluator.

Correctheid

Definitie: Heeft de agent met een feitelijk nauwkeurig antwoord gereageerd?

Vereist grondwaarheid: Ja, expected_facts[] of expected_response.

Juistheid vergelijkt de werkelijke reactie van de agent met een grondwaarheidslabel en is een goede manier om feitelijke fouten te detecteren.

Vereiste invoer

De invoerevaluatieset moet de volgende kolommen hebben:

• request
• response als u de parameter model niet hebt opgegeven voor mlflow.evaluate().
• verwachte_feiten of verwachte_reactie

Belangrijk

Databricks raadt aan om expected_facts[] te gebruiken in plaats van expected_response. expected_facts[] stelt de minimale set feiten voor die vereist zijn in een juiste reactie en die gemakkelijker samen te stellen zijn voor deskundigen.

Als u expected_responsemoet gebruiken, dient deze alleen , de minimale feitenset te bevatten die nodig zijn voor een correcte reactie. Als u een antwoord van een andere bron kopieert, bewerkt u het antwoord om tekst te verwijderen die niet is vereist om een antwoord als correct te beschouwen.

Door alleen de vereiste informatie op te geven en informatie weg te laten die niet strikt vereist is in het antwoord, kan agentevaluatie een robuuster signaal over de uitvoerkwaliteit bieden.

Voorbeelden

De juistheid van een evaluatieset gebruiken:

import mlflow

eval_set = [{
  "request": "What is the difference between reduceByKey and groupByKey in Spark?",
  "response": "reduceByKey aggregates data before shuffling, whereas groupByKey shuffles all data, making reduceByKey more efficient.",
  "expected_facts": [
    "reduceByKey aggregates data before shuffling",
    "groupByKey shuffles all data",
  ]
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["correctness"]
      }
  }
)

Zorg voor correctheid met de callable judge-SDK:

from databricks.agents.evals import judges

assessment = judges.correctness(
  request="What is the difference between reduceByKey and groupByKey in Spark?",
  response="reduceByKey aggregates data before shuffling, whereas groupByKey shuffles all data, making reduceByKey more efficient.",
  expected_facts=[
    "reduceByKey aggregates data before shuffling",
    "groupByKey shuffles all data",
  ]
)
print(assessment)

Wat moet u doen wanneer een antwoord onjuist is?

Wanneer een agent reageert met een feitelijk onnauwkeurig antwoord, moet u het volgende doen:

• Begrijpen of enige context die door de agent wordt opgehaald, niet relevant of onnauwkeurig is. Voor RAG-toepassingen kunt u de contextvoorwaarde rechter gebruiken om te bepalen of de context voldoende is om de expected_facts of expected_responsete genereren.
• Als er voldoende context is, past u de prompt aan om relevante informatie op te nemen.

Relevantie voor de query

Definitie: Is het antwoord relevant voor de invoeraanvraag?

vereist grond-waarheid: Nee.

Relevantie zorgt ervoor dat het antwoord van de agent rechtstreeks de invoer van de gebruiker beantwoordt zonder af te wijken van niet-gerelateerde onderwerpen.

Vereiste invoer

De invoerevaluatieset moet de volgende kolommen hebben:

• request
• response als u de parameter model niet hebt opgegeven voor mlflow.evaluate().

Voorbeelden

Relevantie gebruiken vanuit een evaluatieset:

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris."
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["relevance_to_query"]
      }
  }
)

Relevantie gebruiken met de aanroepbare rechter-SDK:

from databricks.agents.evals import judges

assessment = judges.relevance_to_query(
  request="What is the capital of France?",
  response="The capital of France is Paris."
)
print(assessment)

Wat moet u doen wanneer een antwoord niet relevant is?

Houd rekening met de volgende stappen wanneer de agent een irrelevant antwoord geeft:

• Evalueer het begrip van het model van het verzoek en pas indien nodig de retriever, trainingsgegevens of instructies aan.

Contextsufficiëntie

Definitie: Zijn de opgehaalde documenten voldoende om het verwachte antwoord te produceren?

Vereist gronddataset: Ja, expected_facts of expected_response.

Contextsufficiëntie evalueert of de opgehaalde documenten alle benodigde informatie bevatten om het verwachte antwoord te genereren.

Vereiste invoer

De invoerevaluatieset moet de volgende kolommen hebben:

• request
• response als u de parameter model niet hebt opgegeven voor mlflow.evaluate().
• expected_facts of expected_response. Zie expected_facts richtlijnen en expected_response richtlijnen.
• retrieved_context[].content als u de parameter model niet hebt opgegeven voor mlflow.evaluate().

Voorbeelden

Contextsufficiëntie uit een evaluatieset gebruiken:

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris.",
  "retrieved_context": [
    {"content": "Paris is the capital city of France."}
  ],
  "expected_facts": [
    "Paris"
  ]
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["context_sufficiency"]
      }
  }
)

Gebruik voldoende context met de aanroepbare beoordelings-SDK :

from databricks.agents.evals import judges

assessment = judges.context_sufficiency(
  request="What is the capital of France?",
  retrieved_context=[
    {"content": "Paris is the capital city of France."}
  ]
)
print(assessment)

Wat moet u doen wanneer de context onvoldoende is?

Wanneer de context onvoldoende is:

• Verbeter het ophaalmechanisme om ervoor te zorgen dat alle benodigde documenten worden opgenomen.
• Wijzig de modelprompt om expliciet naar ontbrekende informatie te verwijzen of prioriteit te geven aan relevante context.

Veiligheid

definitie: voorkomt het antwoord schadelijke of giftige inhoud?

vereist grond-waarheid: Nee.

Veiligheid zorgt ervoor dat de reacties van de agent geen schadelijke, aanstootgevende of giftige inhoud bevatten.

Vereiste invoer

De invoerevaluatieset moet de volgende kolommen hebben:

• request
• response als u de parameter model niet hebt opgegeven voor mlflow.evaluate().

Voorbeelden

Gebruik veiligheid van een evaluatieset:

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris."
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["safety"]
      }
  }
)

Gebruik veiligheid met de aanroepbare rechter-SDK:

from databricks.agents.evals import judges

assessment = judges.safety(
  request="What is the capital of France?",
  response="The capital of France is Paris."
)
print(assessment)

Wat moet u doen wanneer het antwoord onveilig is?

Wanneer het antwoord schadelijke inhoud bevat:

• Analyseer de aanvraag om te bepalen of deze per ongeluk kan leiden tot onveilige reacties. Wijzig indien nodig de invoer.
• Verfijn het model of vraag om expliciet te voorkomen dat schadelijke of giftige inhoud wordt gegenereerd.
• Gebruik aanvullende veiligheidsmechanismen, zoals inhoudsfilters, om onveilige reacties te onderscheppen voordat ze de gebruiker bereiken.

Gegrondheid

Definitie: Is het antwoord feitelijk consistent met de opgehaalde context?

vereist grond-waarheid: Nee.

Gefundeerdheid beoordeelt of het antwoord van de agent is afgestemd op de informatie in de opgehaalde context.

Vereiste invoer

De invoerevaluatieset moet de volgende kolommen hebben:

• request
• response als u de parameter model niet hebt opgegeven voor mlflow.evaluate().
• retrieved_context[].content als u het argument model niet gebruikt in de aanroep van mlflow.evaluate().

Voorbeelden

Gebruik van de onderbouwing van een evaluatieset:

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris.",
  "retrieved_context": [
    {"content": "Paris is the capital city of France."}
  ]
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["groundedness"]
      }
  }
)

Gebruik onderbouwing met de aanroepbare beoordelings-SDK

from databricks.agents.evals import judges

assessment = judges.groundedness(
  request="What is the capital of France?",
  response="The capital of France is Paris.",
  retrieved_context=[
    {"content": "Paris is the capital city of France."}
  ]
)
print(assessment)

Wat te doen wanneer het antwoord niet gefundeerd is?

Wanneer het antwoord niet gefundeerd is

• Controleer de opgehaalde context om ervoor te zorgen dat deze de benodigde informatie bevat om het verwachte antwoord te genereren.
• Als de context onvoldoende is, verbetert u het ophaalmechanisme of de gegevensset om relevante documenten op te nemen.
• Wijzig de prompt om het model te instrueren om prioriteit te geven aan het gebruik van de opgehaalde context bij het genereren van antwoorden.

Segmentrelevantie

Definitie: Zijn de opgehaalde segmenten relevant voor de invoeraanvraag?

vereist grond-waarheid: Nee.

Relevantie van segmenten meet of elk segment relevant is voor de invoeraanvraag.

Vereiste invoer

De invoerevaluatieset moet de volgende kolommen hebben:

• request
• retrieved_context[].content als u de parameter model niet hebt opgegeven voor mlflow.evaluate().

Als u het argument model niet gebruikt in de aanroep van mlflow.evaluate(), moet u ook retrieved_context[].content of traceopgeven.

Voorbeelden

In dit voorbeeld wordt de relevantie van segmenten gebruikt met een aangepaste precisiemetrie om een precisiescore op rijniveau te berekenen. Zie Aangepaste metrische gegevens voor meer informatie over aangepaste metrische gegevens

import mlflow
from mlflow.evaluation import Assessment

eval_set = [{
  "request": "What is the capital of France?",
  "response": "The capital of France is Paris.",
  "retrieved_context": [
    {"content": "Paris is the capital city of France."},
    {"content": "The best baguettes are in Nice."},
    {"content": "Mount Everest is  the highest mountain in the world."},
  ],
}]

def judged_precision_at_k(request, retrieved_context, k):
  judged_precisions = [judges.chunk_relevance(request, [doc]) for doc in retrieved_context[:k]]
  precision_at_k = sum([1 if judgement[0].value =='yes' else 0 for judgement in judged_precisions]) / k

  rationales = [
    f"""## Chunk ID {i+1}: `{retrieved_context[i]['doc_uri']}`
    - **{judged_precisions[i][0].value}**: `{judged_precisions[i][0].rationale}`"""
    for i in range(0, k-1)]

  return Assessment(name=f'judged_precision_at_{k}', value=precision_at_k, rationale='\n'.join(rationales))

@metric
def judged_precision_at_3(request, retrieved_context):
  k = 3
  return judged_precision_at_k(request=request, retrieved_context=retrieved_context,  k=k)

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["chunk_relevance"]
      }
  },
  extra_metrics=[judged_precision_at_3]
)

Gebruik chunk_relevance met de callable judge SDK:

from databricks.agents.evals import judges

# NOTE: This callable judge returns an assessment per item in the retrieved context.
assessments = judges.chunk_relevance(
  request="What is the capital of France?",
  retrieved_context=[
    {"content": "Paris is the capital city of France."},
    {"content": "The chicken crossed the road."},
  ]
)
print(assessments)

Wat moet u doen wanneer opgehaalde segmenten irrelevant zijn?

Wanneer irrelevante segmenten worden opgehaald:

• Evalueer de configuratie van de retriever en pas parameters aan om prioriteit te geven aan relevantie.
• Verfijn de trainingsgegevens van de retriever om diversere of nauwkeurige voorbeelden op te nemen.

Documentherroeping

Definitie: Hoeveel van de bekende relevante documenten heeft de retriever gevonden?

Vereist grondwaarheid: Ja, expected_retrieved_context[].doc_uri.

Document recall meet de proportie van relevante documenten volgens de grondwaarheidsdata die zijn opgehaald, vergeleken met het totale aantal relevante documenten in de grondwaarheidsdata.

Vereiste invoer

De invoerevaluatieset moet de volgende kolom hebben:

• expected_retrieved_context[].doc_uri

Als u het argument in de aanroep model niet gebruikt, moet u ook retrieved_context[].doc_uri of trace opgeven.

Voorbeelden

Maak gebruik van documentherinnering uit een evaluatieset.

import mlflow

eval_set = [{
  "request": "What is the capital of France?",
  "expected_retrieved_context": [
    {"doc_uri": "doc_123"},
    {"doc_uri": "doc_456"}
  ],
  "retrieved_context": [
    {"doc_uri": "doc_123"}
  ]
}]

mlflow.evaluate(
  data=eval_set,
  model_type="databricks-agent",
  evaluator_config={
      "databricks-agent": {
          "metrics": ["document_recall"]
      }
  }
)

Er is geen aanroepbare rechter-SDK voor deze metrische waarde omdat er geen AI-rechter wordt gebruikt.

Wat moet u doen wanneer het intrekken van documenten laag is?

Wanneer de herinnering laag is:

• Controleer of de grondwaarheidsgegevens correct de relevante documenten weerspiegelen.
• Verbeter de retriever of pas de zoekparameters aan om de relevantie te verhogen.

Op maat gemaakte AI-rechters

U kunt ook een aangepaste rechter maken om evaluaties uit te voeren die specifiek zijn voor uw use-case.

Zie deze artikelen voor meer informatie:

• Creëer AI-rechters vanuit richtlijnen.
• converteer make_genai_metric_from_prompt naar aangepaste metriek.
• Controleren of de opgehaalde context geen PII- heeft