Giudici di intelligenza artificiale integrati

Importante

Questa funzionalità è disponibile in anteprima pubblica.

Questo articolo illustra i dettagli di ognuno dei giudici di intelligenza artificiale integrati in Mosaic AI Agent Evaluation, inclusi gli input necessari e le metriche di output.

Vedere anche:

• Come la valutazione degli agenti valuta la qualità, i costi e la latenza
• Personalizzare i giudici di intelligenza artificiale
• Riferimento SDK di Python per callable judges

Panoramica dei giudici di intelligenza artificiale

Nota

Non tutti i giudici richiedono etichette di verità fondamentale. I giudici che non richiedono etichette sono utili quando si dispone solo di un set di richieste per valutare l'agente.

Nome del giudice	Aspetto di qualità valutato dal giudice	Input necessari	Richiede la verità di base
global_guideline_adherence	La risposta generata è conforme alle linee guida globali?	request, response, global_guidelines (dal evaluator_config)	No, ma richiede global_guidelines
guideline_adherence	La risposta generata è conforme alle linee guida fornite per ogni domanda?	request, response, guidelines	Sì
correctness	La risposta generata è corretta (rispetto alla verità di riferimento)?	response, expected_facts[] o expected_response	Sì
relevance_to_query	L'indirizzo di risposta (è rilevante per) la richiesta dell'utente?	response, request	No
context_sufficiency	Il recuperatore ha trovato documenti con informazioni sufficienti per produrre la risposta prevista?	retrieved_context, expected_response	Sì
safety	c'è contenuto dannoso o tossico nella risposta?	response	No
chunk_relevance	Il retriever ha trovato blocchi utili (rilevanti) per rispondere alla richiesta dell'utente? Nota: Questo giudizio viene applicato separatamente a ciascun blocco recuperato, producendo un punteggio razionale del tipo & per ogni blocco. Questi punteggi vengono aggregati in un punteggio chunk_relevance/precision per ogni riga che rappresenta il % di blocchi rilevanti.	retrieved_context, request	No
groundedness	La risposta generata è basata sul contesto recuperato (non è frutto di allucinazione)?	response, trace[retrieved_context]	No
document_recall	Quanti dei documenti rilevanti noti ha trovato lo strumento di recupero?	retrieved_context, expected_retrieved_context[].doc_uri	Sì

Nota

Per le conversazioni a più turni, i giudici dell'intelligenza artificiale valutano solo l'ultima parte della conversazione.

risultati dei giudizi di intelligenza artificiale

Ogni giudice usato nella valutazione restituisce le colonne seguenti:

Campo dati	Tipo	Descrizione
response/llm_judged/{judge_name}/rating	string	yes se il giudice passa, no se il giudice fallisce.
response/llm_judged/{judge_name}/rationale	string	Ragionamento scritto di LLM per yes o no.
response/llm_judged/{judge_name}/error_message	string	Se si è verificato un errore durante il calcolo di questa valutazione, i dettagli dell'errore sono disponibili qui. Se non viene visualizzato alcun errore, questo valore è NULL.

Ogni giudice produrrà anche una metrica aggregata per l'intero percorso.

Nome della metrica	Tipo	Descrizione
response/llm_judged/{judge_name}/rating/average	float, [0, 1]	Percentuale di tutte le valutazioni che sono state giudicate essere yes.

Conformità alle linee guida

Definizione: la risposta è conforme alle linee guida fornite?

Richiede un dato di riferimento quando si utilizza global_guidelines: No. Sì quando si usa per singola riga guidelines.

La conformità alle linee guida valuta se la risposta dell'agente segue vincoli specifici o istruzioni fornite nelle linee guida.

Le linee guida possono essere definite in uno dei modi seguenti:

• per riga: la risposta di una richiesta specifica deve rispettare le linee guida definite nella riga di valutazione.
• globalmente: tutte le risposte per qualsiasi richiesta devono rispettare le linee guida globali.

Input necessari

Il set di valutazione di input deve avere le colonne seguenti:

• request
• response se non è stato specificato il parametro model per mlflow.evaluate().
• per riga guidelines o global_guidelines definiti nella configurazione.

Esempi

Utilizzare la conformità alle linee guida per riga a partire da un set di valutazione.

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

Utilizzare l'aderenza alle linee guida globali da un set di valutazione.

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

Usare la conformità alle linee guida con l'SDK del giudice chiamabile :

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)

Cosa fare quando la risposta non rispetta le linee guida?

Quando la risposta viola le linee guida:

• Identificare le linee guida violate e analizzare il motivo per cui l'agente non è riuscito a rispettarlo.
• Modificare la richiesta per evidenziare la conformità a linee guida specifiche o ripetere il training del modello con altri esempi allineati al comportamento desiderato.
• Per le linee guida globali, assicurarsi che siano specificate correttamente nella configurazione dell'analizzatore.

Correttezza

definizione: l'agente ha risposto con una risposta effettivamente accurata?

richiede la verità di base: Sì, expected_facts[] o expected_response.

La correttezza confronta la risposta effettiva dell'agente a un'etichetta di veridicità ed è un buon modo per rilevare errori concreti.

Dati richiesti

Il set di valutazione di input deve avere le colonne seguenti:

• request
• response se non è stato specificato il parametro model per mlflow.evaluate().
• fatti_previsti o risposta_prevista

Importante

Databricks consiglia di usare expected_facts[] anziché expected_response. expected_facts[] rappresentano il set minimo di fatti necessari in una risposta corretta e sono più facili da gestire per gli esperti di materia.

Se è necessario usare expected_response, deve includere solo il set minimo di fatti necessari per una risposta corretta. Se copi una risposta da un'altra fonte, modifica la risposta per rimuovere qualsiasi testo non necessario affinché una risposta venga considerata corretta.

Includendo solo le informazioni necessarie e lasciando le informazioni non strettamente necessarie nella risposta, consente alla valutazione dell'agente di fornire un segnale più affidabile sulla qualità dell'output.

Esempi

Usare la correttezza di un set di valutazione:

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

Usare correttamente l'SDK del giudice richiamabile :

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)

Cosa fare quando una risposta non è corretta?

Quando un agente risponde con una risposta effettivamente imprecisa, è necessario:

• Comprendere se un contesto recuperato dall'agente è irrilevante o innacurato. Per le applicazioni RAG, puoi utilizzare il giudice di sufficienza del contesto per determinare se il contesto è sufficiente a generare il expected_facts o il expected_response.
• Se è presente un contesto sufficiente, modificare il prompt per includere le informazioni pertinenti.

Pertinenza alla query

definizione: la risposta è pertinente alla richiesta di input?

Richiede verità fondamentale: No.

La pertinenza garantisce che la risposta dell'agente indirizzi direttamente l'input dell'utente senza deviare in argomenti non correlati.

Input necessari

Il set di valutazione di input deve avere le colonne seguenti:

• request
• response se non è stato specificato il parametro model per mlflow.evaluate().

Esempi

Utilizzare i risultati rilevanti di un set di valutazione.

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

Usa la pertinenza con il Callable Judge 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)

Cosa fare quando una risposta non è rilevante?

Quando l'agente fornisce una risposta irrilevante, prendere in considerazione i passaggi seguenti:

• Valuta la comprensione della richiesta da parte del modello e modifica di conseguenza il suo retriever, i dati di addestramento o le istruzioni del prompt.

Sufficienza del contesto

Definizione: i documenti recuperati sono sufficienti per produrre la risposta prevista?

richiede la verità di base: Sì, expected_facts o expected_response.

La sufficienza del contesto valuta se i documenti recuperati forniscono tutte le informazioni necessarie per generare la risposta prevista.

Dati richiesti

Il set di valutazione di input deve avere le colonne seguenti:

• request
• response se non è stato specificato il parametro model per mlflow.evaluate().
• expected_facts o expected_response. Vedere linee guida expected_facts e linee guida expected_response.
• retrieved_context[].content se non è stato specificato il parametro model per mlflow.evaluate().

Esempi

Usare la sufficienza del contesto da un set di valutazione:

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

Utilizzare la sufficienza contestuale con l'SDK del giudice invocabile :

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)

Cosa fare quando il contesto non è sufficiente?

Quando il contesto non è sufficiente:

• Migliorare il meccanismo di recupero per assicurarsi che siano inclusi tutti i documenti necessari.
• Modificare il prompt del modello per fare riferimento in modo esplicito a informazioni mancanti o definire la priorità del contesto pertinente.

Sicurezza

Definizione: la risposta evita contenuto dannoso o tossico?

"richiede la verifica della verità di base: No."

La sicurezza garantisce che le risposte dell'agente non contengano contenuto dannoso, offensivo o tossico.

Input necessari

Il set di valutazione di input deve avere le colonne seguenti:

• request
• response se non è stato specificato il parametro model per mlflow.evaluate().

Esempi

Applicare le misure di sicurezza da un set di valutazione.

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

Adotta misure di sicurezza con il SDK di giudizio invocabile :

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)

Cosa fare quando la risposta non è sicura?

Quando la risposta include contenuto dannoso:

• Analizzare la richiesta per identificare se potrebbe causare inavvertitamente risposte non sicure. Modificare l'input, se necessario.
• Perfezionare il modello o richiedere in modo esplicito di evitare di generare contenuto dannoso o tossico.
• Usare meccanismi di sicurezza aggiuntivi, ad esempio filtri di contenuto, per intercettare le risposte non sicure prima di raggiungere l'utente.

Radicamento

Definizione: la risposta è effettivamente coerente con il contesto recuperato?

"Richiede la verifica dei dati di base: No."

La radicatezza valuta se la risposta dell'agente è allineata alle informazioni fornite nel contesto recuperato.

Dati richiesti

Il set di valutazione di input deve avere le colonne seguenti:

• request
• response se non è stato specificato il parametro model per mlflow.evaluate().
• retrieved_context[].content se l'argomento model non viene utilizzato nella chiamata a mlflow.evaluate().

Esempi

Usare la solidità di un set di valutazione.

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

Utilizza l'approccio basato su con l'SDK del giudice richiamabile :

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)

Cosa fare quando la risposta manca di terreno?

Quando la risposta non è fondata:

• Esaminare il contesto recuperato per assicurarsi che includa le informazioni necessarie per generare la risposta prevista.
• Se il contesto non è sufficiente, migliorare il meccanismo di recupero o il set di dati per includere documenti pertinenti.
• Modificare il prompt per indicare al modello di assegnare priorità usando il contesto recuperato durante la generazione di risposte.

Pertinenza dei blocchi

Definizione: i blocchi recuperati sono rilevanti per la richiesta di input?

Verità di fondo richiesta: No.

La pertinenza dei blocchi valuta se ogni blocco è rilevante per la richiesta di input.

Input richiesti

Il set di valutazione di input deve avere le colonne seguenti:

• request
• retrieved_context[].content se non è stato specificato il parametro model per mlflow.evaluate().

Se non si usa l'argomento model nella chiamata a mlflow.evaluate(), è necessario specificare anche retrieved_context[].content o trace.

Esempi

Questo esempio usa il giudice di pertinenza del blocco con una metrica di precisione personalizzata per calcolare un punteggio di precisione a livello di riga. Per altre informazioni sulle metriche personalizzate, vedere metriche personalizzate

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

Usare chunk_relevance con l'SDK del giudice richiamabile:

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)

Cosa fare quando i blocchi recuperati sono irrilevanti?

Quando vengono recuperati blocchi irrilevanti:

• Valutare la configurazione del retriever e regolare i parametri per classificare in ordine di priorità la pertinenza.
• Perfezionare i dati di training del retriever per includere esempi più diversificati o accurati.

Richiamo del documento

Definizione: quanti dei documenti rilevanti già noti sono stati trovati dal sistema di recupero?

richiede dati di riferimento: Sì, expected_retrieved_context[].doc_uri.

Il recall dei documenti misura la percentuale di documenti rilevanti nel set di verità che sono stati recuperati rispetto al numero totale di documenti rilevanti nel set di verità.

Dati richiesti

Il set di valutazione di input deve avere la colonna seguente:

• expected_retrieved_context[].doc_uri

Inoltre, se non si usa l'argomento model nella chiamata a mlflow.evaluate(), è necessario specificare anche retrieved_context[].doc_uri o trace.

Esempi

Usare il richiamo del documento da un set di valutazione:

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

Per questa metrica non è disponibile alcun SDK per il giudice chiamabile perché non usa un giudice di intelligenza artificiale.

Cosa fare quando il richiamo dei documenti è scarso?

Quando il richiamo è basso:

• Verificare che i dati di verità sul terreno riflettano accuratamente i documenti pertinenti.
• Migliorare il retriever o modificare i parametri di ricerca per aumentare il richiamo.

giudici di intelligenza artificiale personalizzati

È anche possibile creare un giudice personalizzato per eseguire valutazioni specifiche del caso d'uso.

Per informazioni dettagliate, vedere:

• Creare giudici di intelligenza artificiale dalle linee guida.
• Convertire make_genai_metric_from_prompt in una metrica personalizzata.
• Verificare che il contesto recuperato non disponga di informazioni personali