Inbyggda AI-domare (MLflow 2)

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 (MLflow 2)
• Anpassa AI-domare (MLflow 2)
• Referens för Callable judges Python SDK

Översikt över AI-domare

AI-domare resultat

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

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

Riktlinjeefterlevnad

Definition: Följer svaret de angivna riktlinjerna?

Kräver grundsanning: Nej när du använder 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.
• [Endast anropbara domare] guidelines_context för att tillhandahålla valfri kontext till domaren.
  • Den här funktionen kräver databricks-agents>=0.20.0.

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 det anropbara domar-SDK:et:

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"],
    "grounded": ["The response must be grounded in the tool call result"],
  },
  # `guidelines_context` requires `databricks-agents>=0.20.0`
  guidelines_context={
    "tool_call_result": "{'country': 'France', 'capital': 'Paris'}",
  },
)
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 grundsanning: Ja eller expected_facts[]expected_response.

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

Obligatoriska indata

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

• request
• response om du inte har angett parametern model till mlflow.evaluate().
• förväntade_fakta eller förväntat_svar

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 korrekthet med det anropbara domar-SDK:et:

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-program kan du använda kontextens tillräcklighetsdomare 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 det anropbara domar-SDK:et:

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 grundsanning: Ja eller expected_factsexpected_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äkerhetsåtgärder 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 förenligt med den hämtade kontexten?

Kräver grundsanning: Nej.

Groundedness utvärderar om agentens svar är i linje med den informationen 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 grund för den anropbara domar-SDK:en:

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 (MLflow 2)

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 det anropbara domar-SDK:et:

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 retrievermodellens träningsdata så att de omfattar fler varierade 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 utifrån riktlinjer.
• Konvertera make_genai_metric_from_prompt till ett anpassat mått.
• Kontrollera att den hämtade kontexten inte har någon PII