Integrovaná porota AI

Důležité

Tato funkce je ve verzi Public Preview.

Tento článek se zabývá podrobnostmi jednotlivých hodnotitelů umělé inteligence, kteří jsou integrováni do vyhodnocení agenta Mosaic AI, včetně potřebných vstupů a výstupních metrik.

Viz také:

• Jak kvalitu, náklady a latenci posuzuje agentní hodnocení
• přizpůsobení systémů rozhodování umělé inteligence
• Referenční příručka Python SDK pro volání

Přehled porotců AI

Poznámka

Ne všichni porotci vyžadují popisky základní pravdy. Hodnotitelé, kteří nevyžadují popisky, jsou užiteční, když máte pouze sadu požadavků k vyhodnocení agenta.

Jméno soudce	Aspekt kvality, který soudce posuzuje	Požadované vstupy	Vyžaduje základní pravdu.
global_guideline_adherence	Dodržuje vygenerovaná odpověď globální pokyny?	request, response, global_guidelines (z evaluator_config)	Ne, ale vyžaduje global_guidelines
guideline_adherence	Dodržuje vygenerovaná odpověď zadané pokyny pro jednotlivé otázky?	request, response, guidelines	Ano
correctness	Je vygenerovaná odpověď přesná (v porovnání se základní pravdou)?	response, expected_facts[] nebo expected_response	Ano
relevance_to_query	Je adresa odpovědi (relevantní pro) žádost uživatele?	response, request	Ne
context_sufficiency	Našel retriever dokumenty s dostatečnými informacemi k vytvoření očekávané odpovědi?	retrieved_context, expected_response	Ano
safety	Je v odpovědi škodlivý nebo toxický obsah?	response	Ne
chunk_relevance	Našel správce bloky dat, které jsou užitečné (relevantní) při odpovídání na žádost uživatele? Poznámka: Tento hodnotitel je aplikován samostatně na každý načtený blok, čímž se vytvoří skóre a odůvodnění & pro každý blok. Tato skóre se agregují do skóre chunk_relevance/precision pro každý řádek, který představuje % bloků dat, které jsou relevantní.	retrieved_context, request	Ne
groundedness	Je vygenerovaná odpověď zakotvena v načteném kontextu (nefantazíruje)?	response, trace[retrieved_context]	Ne
document_recall	Kolik známých relevantních dokumentů našel retriever?	retrieved_context, expected_retrieved_context[].doc_uri	Ano

Poznámka

U konverzací s vícero výměnami hodnotí AI pouze poslední příspěvek v konverzaci.

výstupy soudce AI

Každý soudce, zapojený do vyhodnocení, zaznamenával následující sloupce:

Datové pole	Typ	Popis
response/llm_judged/{judge_name}/rating	string	yes, pokud soudce projde, no, pokud soudce selže.
response/llm_judged/{judge_name}/rationale	string	Písemné odůvodnění LLM pro yes nebo no.
response/llm_judged/{judge_name}/error_message	string	Pokud při výpočtu tohoto posouzení došlo k chybě, podrobnosti o této chybě jsou tady. Pokud se žádná chyba nezobrazí, jedná se o hodnotu NULL.

Každý porotce také vytvoří agregovanou metriku pro celý běh.

Název metriky	Typ	Popis
response/llm_judged/{judge_name}/rating/average	float, [0, 1]	Podíl všech hodnocení, která byla posouzena jako yes.

Dodržování zásad

definice: Dodržuje odpověď uvedené pokyny?

Vyžaduje základnípravdy: Ne při použití global_guidelines. Ano při použití guidelinespro jednotlivé řádky .

Dodržování zásad vyhodnocuje, jestli odpověď agenta dodržuje konkrétní omezení nebo pokyny uvedené v pokynech.

Pokyny je možné definovat jedním z následujících způsobů:

• pro každý řádek: Odpověď konkrétního požadavku musí odpovídat pokynům definovaným na daném řádku vyhodnocení.
• globálně: Všechny odpovědi na všechny žádosti musí dodržovat globální pokyny.

Požadované vstupy

Vstupní sada vyhodnocení musí mít následující sloupce:

• request
• response, pokud jste nezadáli parametr model k mlflow.evaluate().
• guidelines pro jednotlivé řádky nebo global_guidelines definované v konfiguraci.

Příklady

Používejte dodržování zásad pro každou řádku z hodnotící sady.

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

Použití globálního dodržování zásad ze sady vyhodnocení:

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

Použijte dodržování pokynů pomocí volatelné sady 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)

Co dělat, když odpověď nevyhovuje pokynům?

Když odpověď porušuje pokyny:

• Určete, který pokyn byl porušen, a analyzujte, proč se agentovi nepodařilo jej dodržet.
• Upravte výzvu, abyste zdůraznili dodržování konkrétních pokynů nebo model přetrénujte pomocí dalších příkladů, které odpovídají požadovanému chování.
• V případě globálních pokynů se ujistěte, že jsou v konfiguraci vyhodnocovače správně zadané.

Korektnost

Definice: Odpověděl agent fakticky přesně?

Vyžaduje referenční pravdu: Ano, expected_facts[] nebo expected_response.

Správnost porovnává skutečnou odpověď agenta s referenční hodnotou a je dobrým způsobem, jak detekovat faktické chyby.

Požadované vstupy

Vstupní sada vyhodnocení musí mít následující sloupce:

• request
• response, pokud jste nezadáli parametr model k mlflow.evaluate().
• expected_facts nebo expected_response

Důležité

Databricks doporučuje místo expected_responsepoužívat expected_facts[] . expected_facts[] představují minimální sadu faktů nezbytných pro správnou odpověď a odborníci na danou problematiku je mohou snáze spravovat.

Pokud je nutné použít expected_response, měla by obsahovat pouze minimální sadu faktů, které jsou požadovány pro správnou odpověď. Pokud zkopírujete odpověď z jiného zdroje, upravte odpověď tak, aby se odebral veškerý text, který není nutný k tomu, aby odpověď byla považována za správnou.

Zahrnutím pouze požadovaných informací a vynechání informací, které nejsou v odpovědi výhradně vyžadovány, umožňuje vyhodnocení agenta poskytovat robustnější signál o kvalitě výstupu.

Příklady

Použijte správnost ze sady vyhodnocení:

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

Používejte správně sadu SDK volatelného soudce

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)

Co dělat, když je odpověď nesprávná?

Když agent odpoví fakticky nepřesnou odpovědí, měli byste:

• Zjistěte, zda je nějaký kontext získaný agentem irelevantní nebo nepřesný. Pro aplikace RAG můžete použít kontextovou dostatek určit, zda kontext stačí k vygenerování expected_facts nebo expected_response.
• Pokud je k dispozici dostatečný kontext, upravte výzvu tak, aby obsahovala relevantní informace.

relevance pro dotaz

definice: Je odpověď relevantní pro vstupní požadavek?

Vyžaduje základní pravdu: Ne.

Relevance zajišťuje, že odpověď agenta přímo řeší vstup uživatele, aniž by se odchýlila do nesouvisejících témat.

Požadované vstupy

Vstupní sada vyhodnocení musí mít následující sloupce:

• request
• response, pokud jste nezadáli parametr model k mlflow.evaluate().

Příklady

Použití relevance ze sady vyhodnocení:

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

Použijte relevanci se sadu SDK volatelnou pro soudce:

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)

Co dělat, když odpověď není relevantní?

Pokud agent poskytne irelevantní odpověď, zvažte následující kroky:

• Vyhodnoťte, jak model rozumí žádosti, a případně upravte jeho načítač, trénovací data nebo pokyny.

Dostatek kontextu

definice: Jsou načtené dokumenty dostatečné k vytvoření očekávané odpovědi?

Vyžaduje ověření základu: Ano, expected_facts nebo expected_response.

Kontextová efektivita vyhodnocuje, jestli načtené dokumenty poskytují všechny potřebné informace pro vygenerování očekávané odpovědi.

Požadované vstupy

Vstupní sada vyhodnocení musí mít následující sloupce:

• request
• response, pokud jste nezadáli parametr model k mlflow.evaluate().
• expected_facts nebo expected_response. Viz pokyny expected_facts a expected_response pokyny.
• retrieved_context[].content, pokud jste nezadáli parametr model k mlflow.evaluate().

Příklady

Využijte dostatečnost kontextu ze souboru pro hodnocení:

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

Používejte kontextovou přiměřenost s vyvolatelnou sadou 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)

Co dělat, když kontext není dostatečný?

Pokud kontext není dostatečný:

• Vylepšete mechanismus načítání, abyste zajistili, že budou zahrnuty všechny potřebné dokumenty.
• Upravte výzvu modelu tak, aby explicitně odkazovala na chybějící informace nebo upřednostňovala relevantní kontext.

Bezpečnost

definice: Vyhýbá se odpověď škodlivému nebo toxickému obsahu?

Vyžaduje základní pravdu: Ne.

Bezpečnost zajišťuje, že odpovědi agenta neobsahují škodlivý, urážlivý nebo toxický obsah.

Požadované vstupy

Vstupní sada vyhodnocení musí mít následující sloupce:

• request
• response, pokud jste nezadáli parametr model k mlflow.evaluate().

Příklady

Použijte bezpečnostní opatření z hodnotící sady:

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

Dbejte na bezpečnost při používání volatelné sady SDK pro soudce :

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)

Co dělat, když je odpověď nebezpečná?

Pokud odpověď obsahuje škodlivý obsah:

• Analyzujte požadavek, abyste zjistili, jestli může neúmyslně vést k nebezpečným odpovědím. V případě potřeby upravte vstup.
• Upřesněte model nebo výzvu, abyste se explicitně vyhnuli vzniku škodlivého nebo toxického obsahu.
• Použijte další bezpečnostní mechanismy, jako jsou filtry obsahu, abyste zachytili nebezpečné odpovědi dříve, než se dostanou k uživateli.

Zakořeněnost

definice: Je odpověď fakticky konzistentní s načteným kontextem?

Vyžaduje základní pravdu: Ne.

Opodstatněnost posuzuje, jestli je odpověď agenta v souladu s informacemi poskytnutými v získaném kontextu.

Požadované vstupy

Vstupní sada vyhodnocení musí mít následující sloupce:

• request
• response, pokud jste nezadáli parametr model k mlflow.evaluate().
• retrieved_context[].content, pokud nepoužíváte argument model ve volání mlflow.evaluate().

Příklady

Použití uzemnění ze sady vyhodnocení:

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

Použijte ukotvení pomocí volatelné sady 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)

Co dělat, když odpověď postrádá pevný základ?

Pokud odpověď není uzemněna:

• Zkontrolujte načtený kontext a ujistěte se, že obsahuje potřebné informace pro vygenerování očekávané odpovědi.
• Pokud kontext není dostatečný, vylepšete mechanismus načítání nebo datovou sadu tak, aby zahrnovaly relevantní dokumenty.
• Upravte výzvu tak, aby model při generování odpovědí řídil prioritu pomocí načteného kontextu.

Relevance bloku

definice: Jsou načtené bloky dat relevantní pro vstupní požadavek?

Vyžaduje základní pravdu: Ne.

Relevance bloků dat měří, jestli je každý blok relevantní pro vstupní požadavek.

Požadované vstupy

Vstupní sada vyhodnocení musí mít následující sloupce:

• request
• retrieved_context[].content, pokud jste nezadáli parametr model k mlflow.evaluate().

Pokud ve volání mlflow.evaluate()nepoužíváte argument model , musíte také zadat retrieved_context[].content nebo trace.

Příklady

Tento příklad používá posuzovač relevantnosti bloků s vlastní metrikou přesnosti k výpočtu skóre přesnosti na úrovni řádků. Další podrobnosti o vlastních metrikách najdete v tématu vlastní metriky

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

Použijte chunk_relevance s volatelnou soudcovskou sadou 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)

Co dělat, když načtené bloky dat nejsou relevantní?

Při načtení irelevantních bloků dat:

• Vyhodnoťte konfiguraci retrieveru a upravte parametry, aby bylo možné určit prioritu relevance.
• Zpřesněte trénovací data načítáče tak, aby obsahovala různorodější nebo přesnější příklady.

Odvolání dokumentu

definice: Kolik známých relevantních dokumentů našel vyhledávač?

Vyžaduje základní: Ano, expected_retrieved_context[].doc_uri.

Míra zpětného vyhledání dokumentů měří podíl relevantních dokumentů, které byly načteny ve srovnání s celkovým počtem relevantních dokumentů ve skutečných datech.

Požadované vstupy

Vstupní sada vyhodnocení musí mít následující sloupec:

• expected_retrieved_context[].doc_uri

Kromě toho, pokud ve volání mlflow.evaluate() nepoužíváte argument model, musíte také zadat buď retrieved_context[].doc_uri, nebo trace.

Příklady

Použití vyhledání dokumentu ze sady pro vyhodnocení:

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

Pro tuto metriku neexistuje žádná volatelná sada SDK pro soudce, protože nepoužívá soudce AI.

Co dělat, když je odvolání dokumentu nízké?

Když je úplnost nízká:

• Ověřte, že podkladová pravdivá data přesně odrážejí relevantní dokumenty.
• Vylepšete vyhledávač nebo upravte parametry hledání, aby se zvýšila úplnost.

vlastních porotců umělé inteligence

Můžete také vytvořit vlastní soudce, který provede posouzení specifická pro váš případ použití.

Podrobnosti najdete tady:

• vytvářet soudce umělé inteligence podle pokynů.
• Převést make_genai_metric_from_prompt na vlastní metriku.
• Ujistěte se, že načtený kontext neobsahuje žádné osobní údaje.