Integrierte KI-Richter (MLflow 2)

Dieser Artikel behandelt die Details der einzelnen KI-Richter, die in die KI-Agent-Auswertung von Mosaic integriert sind, einschließlich der erforderlichen Ein- und Ausgabemetriken.

Siehe auch:

• Wie Qualität, Kosten und Latenz von Agent Evaluation (MLflow 2) bewertet werden
• Anpassen von KI-Richtern (MLflow 2)
• Referenz zum Python SDK für aufrufbare Richter

Übersicht über KI-Richter

Ausgaben des KI-Richters

Jeder Richter, der in der Auswertung verwendet wird, gibt die folgenden Spalten aus:

Jeder Richter erzeugt außerdem eine Aggregatmetrik für den gesamten Lauf:

Richtlinientreue

Definition: Entspricht die Antwort den bereitgestellten Richtlinien?

Erfordert Grundwahrheit: Nein, wenn global_guidelines verwendet wird. Ja, wenn pro Zeile guidelinesverwendet wird.

Die Einhaltung der Richtlinien bewertet, ob die Reaktion des Agenten bestimmte Einschränkungen oder Anweisungen in den Richtlinien befolgt.

Richtlinien können auf eine der folgenden Arten definiert werden:

• pro Zeile: Die Antwort einer bestimmten Anforderung muss den Richtlinien entsprechen, die in dieser Auswertungszeile definiert sind.
• global: Alle Antworten für jede Anforderung müssen globalen Richtlinien entsprechen.

Erforderliche Eingaben

Der Eingabeauswertungssatz muss die folgenden Spalten aufweisen:

• request
• response wenn Sie den Parameter model für mlflow.evaluate() nicht angegeben haben.
• guidelines pro Zeile oder global_guidelines, wie in der Konfiguration definiert.
• [Nur anrufbare Richter] guidelines_context um dem Richter beliebigen Kontext bereitzustellen.
  • Dieses Feature erfordert databricks-agents>=0.20.0.

Beispiele

Verwenden der Richtlinieneinhaltung pro Zeile aus einem Bewertungssatz.

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

Verwenden der globalen Richtlinieneinhaltung aus einem Bewertungssatz.

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

Verwenden der Richtlinieneinhaltung mit dem SDK für aufrufbare Richter:

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)

Was ist zu tun, wenn die Antwort nicht den Richtlinien entspricht?

Wenn die Antwort gegen die Richtlinien verstößt:

• Ermitteln Sie, welche Richtlinie verletzt wurde, und analysieren Sie, warum der Agent sie nicht einhalten konnte.
• Passen Sie die Eingabeaufforderung an, um die Einhaltung bestimmter Richtlinien hervorzuheben, oder trainieren Sie das Modell mit zusätzlichen Beispielen, die dem gewünschten Verhalten entsprechen.
• Stellen Sie für globale Richtlinien sicher, dass sie in der Evaluator-Konfiguration richtig angegeben sind.

Korrektheit

Definition: Hat der Agent mit einer sachlich genauen Antwort geantwortet?

Erfordert Grundwahrheit: Ja, expected_facts[] oder expected_response.

Korrektheit vergleicht die tatsächliche Antwort des Agenten mit einer Kennzeichnung der Grundwahrheit und ist eine gute Möglichkeit, sachliche Fehler zu erkennen.

Erforderliche Eingaben

Der Eingabeauswertungssatz muss die folgenden Spalten aufweisen:

• request
• response wenn Sie den Parameter model für mlflow.evaluate() nicht angegeben haben.
• erwartete_Fakten oder erwartete_Antwort

Beispiele

Verwenden der Korrektheit aus einem Auswertungssatz.

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

Verwenden der Korrektheit mit dem SDK für aufrufbare Richter:

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)

Was ist zu tun, wenn eine Antwort falsch ist?

Wenn ein Agent mit einer sachlich ungenauen Antwort antwortet, sollten Sie:

• Verstehen Sie, ob ein Kontext, der vom Agenten abgerufen wird, irrelevant oder ungenau ist. Für RAG-Anwendungen können Sie den Kontextbeurteiler verwenden, um zu ermitteln, ob der Kontext ausreicht, um das expected_facts oder das expected_response zu generieren.
• Wenn genügend Kontext vorhanden ist, passen Sie die Eingabeaufforderung an, um relevante Informationen einzuschließen.

Relevanz für Abfrage

Definition: Ist die Antwort für die Eingabeanforderung relevant?

Erfordert Grundwahrheit: Nein.

Die Relevanz stellt sicher, dass die Antwort des Agents die Eingabe des Benutzers direkt adressiert, ohne in nicht verwandte Themen zu abweichen.

Erforderliche Eingaben

Der Eingabeauswertungssatz muss die folgenden Spalten aufweisen:

• request
• response wenn Sie den Parameter model für mlflow.evaluate() nicht angegeben haben.

Beispiele

Verwenden der Relevanz aus einem Auswertungssatz:

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

Verwenden der Relevanz mit dem SDK für aufrufbare Richter:

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)

Was ist zu tun, wenn eine Antwort nicht relevant ist?

Wenn der Agent eine irrelevante Antwort bereitstellt, berücksichtigen Sie die folgenden Schritte:

• Bewerten Sie, wie gut das Modell die Anfrage versteht und passen Sie seinen Suchalgorithmus, die Trainingsdaten oder die Anweisungen entsprechend an.

Kontextsuffizienz

Definition: Reichen die abgerufenen Dokumente aus, um die erwartete Antwort zu erzeugen?

Erfordert Grundwahrheit: Ja, expected_facts oder expected_response.

Die Kontextsuffizienz wertet aus, ob die abgerufenen Dokumente alle erforderlichen Informationen bereitstellen, um die erwartete Antwort zu generieren.

Erforderliche Eingaben

Der Eingabeauswertungssatz muss die folgenden Spalten aufweisen:

• request
• response wenn Sie den Parameter model für mlflow.evaluate() nicht angegeben haben.
• expected_facts oder expected_response. Siehe expected_facts Richtlinien und expected_response Richtlinien.
• retrieved_context[].content wenn Sie den Parameter model für mlflow.evaluate() nicht angegeben haben.

Beispiele

Verwenden der Kontextsuffizienz aus einem Auswertungssatz:

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

Verwenden der Kontextsuffizienz mit dem SDK für aufrufbare Richter:

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)

Was ist zu tun, wenn der Kontext nicht ausreicht?

Wenn der Kontext nicht ausreicht:

• Verbessern Sie den Abrufmechanismus, um sicherzustellen, dass alle erforderlichen Dokumente enthalten sind.
• Ändern Sie die Modellaufforderung, um explizit auf fehlende Informationen zu verweisen oder relevanten Kontext zu priorisieren.

Sicherheit

Definition: Vermeidet die Antwort schädliche oder toxische Inhalte?

Erfordert Grundwahrheit: Nein.

Sicherheit stellt sicher, dass die Reaktionen des Agenten keine schädlichen, anstößigen oder toxischen Inhalte enthalten.

Erforderliche Eingaben

Der Eingabeauswertungssatz muss die folgenden Spalten aufweisen:

• request
• response wenn Sie den Parameter model für mlflow.evaluate() nicht angegeben haben.

Beispiele

Verwenden Sie Sicherheitsfunktionen aus einem Evaluierungsset.

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

Verwenden der Sicherheit mit dem SDK für aufrufbare Richter:

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)

Was ist zu tun, wenn die Antwort unsicher ist?

Wenn die Antwort schädliche Inhalte enthält:

• Analysieren Sie die Anforderung, um festzustellen, ob sie versehentlich zu unsicheren Antworten führen kann. Ändern Sie die Eingabe bei Bedarf.
• Verfeinern Sie das Modell, oder fordern Sie auf, das Generieren schädlicher oder toxischer Inhalte explizit zu vermeiden.
• Verwenden Sie zusätzliche Sicherheitsmechanismen, z. B. Inhaltsfilter, um unsichere Antworten abzufangen, bevor sie den Benutzer erreichen.

Quellenübereinstimmung

Definition: Entspricht die Antwort tatsächlich dem abgerufenen Kontext?

Erfordert Grundwahrheit: Nein.

Die Fundiertheit bewertet, ob die Antwort des Agenten mit den im abgerufenen Kontext bereitgestellten Informationen übereinstimmt.

Erforderliche Eingaben

Der Eingabeauswertungssatz muss die folgenden Spalten aufweisen:

• request
• response wenn Sie den Parameter model für mlflow.evaluate() nicht angegeben haben.
• retrieved_context[].content, wenn Sie das Argument model im Aufruf von mlflow.evaluate() nicht verwenden.

Beispiele

Verwenden der Fundiertheit aus einem Auswertungssatz:

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

Verwenden der Fundiertheit mit dem SDK für aufrufbare Richter:

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)

Was zu tun ist, wenn die Antwort an Geerdetheit fehlt?

Wenn die Antwort unbegründet ist:

• Überprüfen Sie den abgerufenen Kontext, um sicherzustellen, dass er die erforderlichen Informationen enthält, um die erwartete Antwort zu generieren.
• Wenn der Kontext nicht ausreicht, verbessern Sie den Abrufmechanismus oder das Dataset, um relevante Dokumente einzuschließen.
• Ändern Sie die Eingabeaufforderung, um das Modell anzuweisen, beim Generieren von Antworten den abgerufenen Kontext zu priorisieren.

Blockrelevanz

Definition: Sind die abgerufenen Blöcke für die Eingabeanforderung relevant?

Erfordert Grundwahrheit: Nein.

Chunk-Relevanz misst, ob jeder Block für die Eingabeanforderung relevant ist.

Erforderliche Eingaben

Der Eingabeauswertungssatz muss die folgenden Spalten aufweisen:

• request
• retrieved_context[].content wenn Sie den Parameter model für mlflow.evaluate() nicht angegeben haben.

Wenn Sie das model-Argument im Aufruf von mlflow.evaluate() nicht verwenden, müssen Sie entweder retrieved_context[].content oder trace angeben.

Beispiele

In diesem Beispiel wird der Richter für Blockrelevanz mit einer benutzerdefinierten Genauigkeitsmetrik verwendet, um eine Genauigkeitsbewertung auf Zeilenebene zu berechnen. Weitere Informationen zu benutzerdefinierten Metriken finden Sie unter "Benutzerdefinierte Metriken" (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]
)

Verwenden von chunk_relevance mit dem SDK für aufrufbare Richter:

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)

Was ist zu tun, wenn abgerufene Blöcke irrelevant sind?

Wenn irrelevante Blöcke abgerufen werden:

• Bewerten Sie die Konfiguration des Retrievers, und passen Sie Parameter an, um die Relevanz zu priorisieren.
• Verfeinern Sie die Schulungsdaten des Retrievers, um vielfältigere oder genauere Beispiele einzuschließen.

Dokumenterinnerung

Definition: Wie viele der bekannten relevanten Dokumente hat der Retriever gefunden?

Erfordert Grundwahrheit: Ja, expected_retrieved_context[].doc_uri.

Die Dokumenterinnerung misst den Anteil der relevanten Dokumente der Grundwahrheit, die abgerufen wurden, im Vergleich zur Gesamtzahl der relevanten Dokumente in der Grundwahrheit.

Erforderliche Eingaben

Der Eingabeauswertungssatz muss die folgende Spalte aufweisen:

• expected_retrieved_context[].doc_uri

Wenn Sie das model-Argument im Aufruf von mlflow.evaluate() nicht verwenden, müssen Sie außerdem entweder retrieved_context[].doc_uri oder trace bereitstellen.

Beispiele

Verwenden der Dokumenterinnerung aus einem Auswertungssatz:

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

Für diese Metrik gibt es kein aufrufbares Richter-SDK, da kein KI-Richter verwendet wird.

Was ist zu tun, wenn die Dokumenterinnerung gering ist?

Wenn die Erinnerung schwach ist:

• Vergewissern Sie sich, dass die Boden-Wahrheitsdaten relevante Dokumente korrekt widerspiegeln.
• Verbessern Sie den Abruf, oder passen Sie Suchparameter an, um die Erinnerung zu erhöhen.

Benutzerdefinierte KI-Richter

Sie können auch einen benutzerdefinierten Richter erstellen, um für Ihren Anwendungsfall spezifische Bewertungen durchzuführen.

Ausführliche Informationen finden Sie hier:

• Erstellen Sie KI-Richter anhand von Richtlinien.
• Konvertieren make_genai_metric_from_prompt in eine benutzerdefinierte Metrik.
• Stellen Sie sicher, dass der abgerufene Kontext keine PII aufweist.