Inbyggda AI-domare

Viktigt!

Den här funktionen finns som allmänt tillgänglig förhandsversion.

Den här artikeln beskriver information om var och en av AI-domarna som är inbyggda i Mosaic AI Agent Evaluation, inklusive nödvändiga indata och utdatamått.

Se även:

• Hur kvalitet, kostnad och svarstid utvärderas av Agentutvärdering
• Anpassa AI-domare
• Callable bedömer Python SDK-referens

Översikt över AI-domare

Notera

Inte alla domare kräver mark-sanningsetiketter. Domare som inte kräver etiketter är användbara när du bara har en uppsättning begäranden för att utvärdera din agent.

Domarens namn	Kvalitetsaspekt som domaren bedömer	Obligatoriska indata	Kräver grundsanning
global_guideline_adherence	Följer det genererade svaret de globala riktlinjerna?	request, response, global_guidelines (från evaluator_config)	Nej, men kräver global_guidelines
guideline_adherence	Följer det genererade svaret de angivna riktlinjerna per fråga?	request, response, guidelines	Ja
correctness	Är det genererade svaret korrekt (jämfört med grundsanningen)?	response, expected_facts[] eller expected_response	Ja
relevance_to_query	Besvarar svaret (är det relevant för) användarens förfrågan?	response, request	Nej
context_sufficiency	Hittade hämtaren dokument med tillräcklig information för att generera det förväntade svaret?	retrieved_context, expected_response	Ja
safety	Finns det skadligt eller giftigt innehåll i svaret?	response	Nej
chunk_relevance	Hittade hämtaren segment som är användbara (relevanta) för att besvara användarens begäran? Obs! Den här bedömningen tillämpas separat på varje hämtat segment och ger en motivering med poäng & för varje segment. Dessa poäng aggregeras till en chunk_relevance/precision poäng för varje rad som representerar % av segment som är relevanta.	retrieved_context, request	Nej
groundedness	Är det genererade svaret grundat i den hämtade kontexten (inte hallucinerande)?	response, trace[retrieved_context]	Nej
document_recall	Hur många av de kända relevanta dokumenten hittade hämtaren?	retrieved_context, expected_retrieved_context[].doc_uri	Ja

Notera

För konversationer med flera turer utvärderar AI-domare endast den sista posten i konversationen.

AI-domare resultat

Varje domare som används i utvärderingen matar ut följande kolumner:

Datafält	Typ	Beskrivning
response/llm_judged/{judge_name}/rating	string	yes om domaren klarar sig, no om domaren misslyckas.
response/llm_judged/{judge_name}/rationale	string	LLM:s skriftliga resonemang för yes eller no.
response/llm_judged/{judge_name}/error_message	string	Om det uppstod ett fel vid beräkning av den här utvärderingen finns information om felet här. Om inget fel uppstår är detta NULL.

Varje domare skapar också ett aggregerat mått för hela loppet.

Metriknamn	Typ	Beskrivning
response/llm_judged/{judge_name}/rating/average	float, [0, 1]	Andelen av alla utvärderingar som bedömdes som yes.

Riktlinjeefterlevnad

Definition: Följer svaret de angivna riktlinjerna?

Kräver: Nej vid användning av global_guidelines. Ja när du använder guidelinesper rad.

Riktlinjeefterlevnad utvärderar om agentens svar följer specifika begränsningar eller instruktioner som anges i riktlinjerna.

Riktlinjer kan definieras på något av följande sätt:

• per rad: Svaret för en specifik begäran måste följa de riktlinjer som definierats på den utvärderingsraden.
• globalt: Alla svar för alla begäranden måste följa globala riktlinjer.

Obligatoriska indata

Indatautvärderingsuppsättningen måste ha följande kolumner:

• request
• response om du inte har angett parametern model till mlflow.evaluate().
• per rad guidelines eller global_guidelines definieras i konfigurationen.

Exempel

Använd riktlinjeefterlevnad per rad från en utvärderingsuppsättning:

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"]
      }
  }
)

Använd global riktlinjeefterlevnad från en utvärderingsuppsättning:

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"]
      }
  }
)

Använd riktlinjeefterlevnad med anropsbar domare 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)

Vad ska jag göra när svaret inte följer riktlinjerna?

När svaret bryter mot riktlinjerna:

• Identifiera vilken riktlinje som överträddes och analysera varför agenten inte följde den.
• Justera uppmaningen för att betona efterlevnaden av specifika riktlinjer eller träna om modellen med ytterligare exempel som överensstämmer med önskat beteende.
• Se till att de anges korrekt i utvärderarkonfigurationen för globala riktlinjer.

Korrekthet

Definition: Svarade agenten med ett sakligt korrekt svar?

Kräver grunddata för: Ja, expected_facts[] eller expected_response.

Korrekthet jämför agentens faktiska svar med en referensetikett och är ett bra sätt att upptäcka faktafel.

Obligatoriska indata

Indatautvärderingsuppsättningen måste ha följande kolumner:

• request
• response om du inte har angett parametern model till mlflow.evaluate().
• expected_facts eller expected_response

Viktigt!

Databricks rekommenderar att du använder expected_facts[] i stället för expected_response. expected_facts[] representerar den minimala uppsättningen av fakta som krävs i ett korrekt svar och är lättare för ämnesexperter att hantera.

Om du måste använda expected_responseska den innehålla endast den minimala uppsättning fakta som krävs för ett korrekt svar. Om du kopierar ett svar från en annan källa redigerar du svaret för att ta bort all text som inte krävs för att ett svar ska anses vara korrekt.

Genom att endast inkludera nödvändig information och utelämna information som inte är strikt nödvändig i svaret kan agentutvärderingen ge en mer robust signal om utdatakvaliteten.

Exempel

Använd noggrannhet från ett utvärderingsset:

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"]
      }
  }
)

Använd korrekthetskontroll med anropsbar SDK för domare:

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)

Vad ska jag göra när ett svar är felaktigt?

När en agent svarar med ett sakligt felaktigt svar bör du:

• Förstå om någon kontext som hämtas av agenten är irrelevant eller felaktig. För RAG-applikationer kan du använda kontexttillräcklighetsbedömare för att avgöra om kontexten räcker för att generera expected_facts eller expected_response.
• Om det finns tillräckligt med kontext justerar du uppmaningen så att den innehåller relevant information.

relevans för fråga

Definition: Är svaret relevant för indatabegäran?

Kräver grundsanning: Nej.

Relevans säkerställer att agentens svar direkt åtgärdar användarens indata utan att avvika från orelaterade ämnen.

Obligatoriska indata

Indatautvärderingsuppsättningen måste ha följande kolumner:

• request
• response om du inte har angett parametern model till mlflow.evaluate().

Exempel

Använd relevans från en utvärderingsuppsättning:

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"]
      }
  }
)

Använd relevans med SDK för anropsbar bedömning:

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)

Vad ska man göra när ett svar inte är relevant?

När agenten ger ett irrelevant svar bör du överväga följande steg:

• Utvärdera modellens förståelse av begäran och justera dess hämtnings-, träningsdata- eller promptinstruktioner i enlighet med detta.

Tillräcklighet av sammanhang

Definition: Räcker de hämtade dokumenten för att generera det förväntade svaret?

Kräver verklighetsdata: Ja, expected_facts eller expected_response.

Kontextens tillräcklighet utvärderar om de hämtade dokumenten ger all nödvändig information för att generera det förväntade svaret.

Obligatoriska indata

Indatautvärderingsuppsättningen måste ha följande kolumner:

• request
• response om du inte har angett parametern model till mlflow.evaluate().
• expected_facts eller expected_response. Se expected_facts riktlinjer och expected_response riktlinjer.
• retrieved_context[].content om du inte har angett parametern model till mlflow.evaluate().

Exempel

Använd kontextsufficiens från en utvärderingsuppsättning:

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"]
      }
  }
)

Använd tillräckligt med kontext med den anropbara domar-SDK:n :

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)

Vad ska man göra när kontexten inte räcker till?

När kontexten inte är tillräcklig:

• Förbättra hämtningsmekanismen för att säkerställa att alla nödvändiga dokument inkluderas.
• Ändra modellprompten för att uttryckligen referera till information som saknas eller prioritera relevant kontext.

Säkerhet

Definition: Undviker svaret skadligt eller giftigt innehåll?

Kräver grundsanning: Nej.

Säkerhet säkerställer att agentens svar inte innehåller skadligt, stötande eller giftigt innehåll.

Obligatoriska indata

Indatautvärderingsuppsättningen måste ha följande kolumner:

• request
• response om du inte har angett parametern model till mlflow.evaluate().

Exempel

Använd säkerhet från en utvärderingsuppsättning:

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"]
      }
  }
)

Använd säkerhetsfunktionerna med den anropsbara domar-SDK:n :

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)

Vad ska jag göra när svaret är osäkert?

När svaret innehåller skadligt innehåll:

• Analysera begäran för att identifiera om den oavsiktligt kan leda till osäkra svar. Ändra indata om det behövs.
• Förfina modellen eller fråga för att uttryckligen undvika att generera skadligt eller giftigt innehåll.
• Använd ytterligare säkerhetsmekanismer, till exempel innehållsfilter, för att fånga upp osäkra svar innan de når användaren.

Jordnära

Definition: Är svaret faktiskt konsekvent med den hämtade kontexten?

Kräver grundsanning: Nej.

Groundedness värderar om agentens svar är i linje med den information som tillhandahålls i den hämtade kontexten.

Obligatoriska indata

Indatautvärderingsuppsättningen måste ha följande kolumner:

• request
• response om du inte har angett parametern model till mlflow.evaluate().
• retrieved_context[].content om du inte använder argumentet model i anropet till mlflow.evaluate().

Exempel

Använd grundval från ett utvärderingsset:

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"]
      }
  }
)

Använd grundlighet med anropsbar domardk-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)

Vad ska man göra när svaret saknar grund?

När svaret inte är förankrat:

• Granska den hämtade kontexten för att se till att den innehåller nödvändig information för att generera det förväntade svaret.
• Om kontexten inte räcker till kan du förbättra hämtningsmekanismen eller datamängden så att den innehåller relevanta dokument.
• Ändra uppmaningen för att instruera modellen att prioritera med hjälp av den hämtade kontexten när svar genereras.

Klumprelevans

Definition: Är de hämtade segmenten relevanta för indatabegäran?

Kräver grundsanning: Nej.

Segmentrelevans mäter om varje segment är relevant för indatabegäran.

Obligatoriska indata

Indatautvärderingsuppsättningen måste ha följande kolumner:

• request
• retrieved_context[].content om du inte har angett parametern model till mlflow.evaluate().

Om du inte använder argumentet model i anropet till mlflow.evaluate()måste du även ange antingen retrieved_context[].content eller trace.

Exempel

I det här exemplet används segmentrelevansdomaren med ett anpassat precisionsmått för att beräkna en precisionspoäng på radnivå. Mer information om anpassade mått finns i Anpassade mått

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

Använd chunk_relevance med anropsbar domare 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)

Vad ska man göra när hämtade segment är irrelevanta?

När irrelevanta segment hämtas:

• Utvärdera inhämtarens konfiguration och justera parametrar för att prioritera relevans.
• Förfina hämtarens träningsdata så att de innehåller mer varierande eller korrekta exempel.

Återkallande av dokument

Definition: Hur många av de kända relevanta dokumenten hittade hämtaren?

Kräver grundsanning: Ja, expected_retrieved_context[].doc_uri.

Dokumentåterkallelse mäter andelen relevanta dokument för grundsanning som hämtades jämfört med det totala antalet relevanta dokument i grund sanning.

Obligatoriska indata

Indatautvärderingsuppsättningen måste ha följande kolumn:

• expected_retrieved_context[].doc_uri

Om du inte använder model argumentet i anropet till mlflow.evaluate()måste du också ange antingen retrieved_context[].doc_uri eller trace.

Exempel

Använd dokumentåterkallelse från en utvärderingsuppsättning:

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"]
      }
  }
)

Det finns ingen anropsbar domar-SDK för det här måttet eftersom det inte använder en AI-domare.

Vad ska jag göra när dokumentåterkallelsen är låg?

När minnet är lågt:

• Kontrollera att grund sanningsdata korrekt återspeglar relevanta dokument.
• Förbättra hämtningen eller justera sökparametrarna för att öka återkallandet.

Anpassade AI-domare

Du kan också skapa en anpassad domare för att utföra utvärderingar som är specifika för ditt användningsfall.

Mer information finns i:

• Skapa AI-domare från riktlinjer.
• Konvertera make_genai_metric_from_prompt till ett anpassat mått.
• Kontrollera att den hämtade kontexten inte har någon PII-