Executar uma avaliação e exibir os resultados (MLflow 2)

Este artigo descreve como executar uma avaliação e exibir os resultados à medida que você desenvolve seu aplicativo de IA. Para obter informações sobre como monitorar agentes implantados, consulte Monitor GenAI em produção.

Para avaliar um agente, você deve especificar um conjunto de avaliação. No mínimo, um conjunto de avaliação é um conjunto de solicitações para seu aplicativo que podem vir de um conjunto coletado de solicitações de avaliação ou rastreamentos de usuários do agente. Para obter mais detalhes, consulte Conjuntos de avaliação (MLflow 2) e esquema de entrada de Avaliação do Agente (MLflow 2).

Executar uma avaliação

Para executar uma avaliação, use o método mlflow.evaluate() da API do MLflow, especificando o model_type como databricks-agent para habilitar a Avaliação do Agente no Databricks e juízes de IA internos.

O exemplo a seguir especifica um conjunto de diretrizes globais de resposta para o avaliador de IA das diretrizes globais que fazem com que a avaliação falhe caso as respostas não atendam às diretrizes. Você não precisa coletar etiquetas por solicitação para avaliar seu agente com essa abordagem.

import mlflow
from mlflow.deployments import get_deploy_client

# The guidelines below will be used to evaluate any response of the agent.
global_guidelines = {
  "rejection": ["If the request is unrelated to Databricks, the response must should be a rejection of the request"],
  "conciseness": ["If the request is related to Databricks, the response must should be concise"],
  "api_code": ["If the request is related to Databricks and question about API, the response must have code"],
  "professional": ["The response must be professional."]
}

eval_set = [{
  "request": {"messages": [{"role": "user", "content": "What is the difference between reduceByKey and groupByKey in Databricks Spark?"}]}
}, {
  "request": "What is the weather today?",
}]

# Define a very simple system-prompt agent.
@mlflow.trace(span_type="AGENT")
def llama3_agent(messages):
  SYSTEM_PROMPT = """
    You are a chatbot that answers questions about Databricks.
    For requests unrelated to Databricks, reject the request.
  """
  return get_deploy_client("databricks").predict(
    endpoint="databricks-meta-llama-3-3-70b-instruct",
    inputs={"messages": [{"role": "system", "content": SYSTEM_PROMPT}, *messages]}
  )

# Evaluate the Agent with the evaluation set and log it to the MLFlow run "system_prompt_v0".
with mlflow.start_run(run_name="system_prompt_v0") as run:
  mlflow.evaluate(
    data=eval_set,
    model=lambda request: llama3_agent(**request),
    model_type="databricks-agent",
    evaluator_config={
      "databricks-agent": {
        "global_guidelines": global_guidelines
      }
    }
  )

Os resultados estão disponíveis na aba Traços na página Execução do MLflow.

Este exemplo executa os seguintes critérios que não precisam de rótulos de verdade fundamental: Adesão às diretrizes, Relevância para a consulta, Segurança.

Se você usar um agente com um recuperador, os seguintes avaliadores serão executados: Fundamentação, Relevância da parte

mlflow.evaluate() também calcula a latência e as métricas de custo para cada registro de avaliação, agregando resultados em todas as entradas para uma determinada execução. Eles são chamados de resultados de avaliação. Os resultados da avaliação são registrados na execução de delimitação, juntamente com informações registradas por outros comandos, como parâmetros de modelo. Se você chamar mlflow.evaluate() fora de uma execução do MLflow, uma nova execução será criada.

Avaliar com rótulos de verdade básica

O seguinte exemplo especifica rótulos de verdade de base por linha: expected_facts e guidelines, que executarão, respectivamente, os juízes de exatidão de diretrizes. As avaliações individuais são tratadas separadamente usando os rótulos de verdade de base por linha.

%pip install databricks-agents
dbutils.library.restartPython()

import mlflow
from mlflow.types.llm import ChatCompletionResponse, ChatCompletionRequest
from mlflow.deployments import get_deploy_client
import dataclasses

eval_set = [{
  "request": "What is the difference between reduceByKey and groupByKey in Databricks Spark?",
  "expected_facts": [
    "reduceByKey aggregates data before shuffling",
    "groupByKey shuffles all data",
  ],
  "guidelines": ["The response must be concice and show a code snippet."]
}, {
  "request": "What is the weather today?",
  "guidelines": ["The response must reject the request."]
}]

# Define a very simple system-prompt agent.
@mlflow.trace(span_type="AGENT")
def llama3_agent(messages):
  SYSTEM_PROMPT = """
    You are a chatbot that answers questions about Databricks.
    For requests unrelated to Databricks, reject the request.
  """
  return get_deploy_client("databricks").predict(
    endpoint="databricks-meta-llama-3-3-70b-instruct",
    inputs={"messages": [{"role": "system", "content": SYSTEM_PROMPT}, *messages]}
  )

# Evaluate the agent with the evaluation set and log it to the MLFlow run "system_prompt_v0".
with mlflow.start_run(run_name="system_prompt_v0") as run:
  mlflow.evaluate(
    data=eval_set,
    model=lambda request: llama3_agent(**request),
    model_type="databricks-agent"
  )

Este exemplo executa os mesmos avaliadores mencionados acima, além dos seguintes: Correção, Relevância, Segurança

Se você usar um agente com um recuperador, o seguinte avaliador será executado: Suficiência de Contexto

Requisitos

Os recursos de IA viabilizados por parceiros devem ser habilitados para seu ambiente de trabalho.

Fornecer entradas para uma execução de avaliação

Há duas maneiras de fornecer entrada para um processo de avaliação:

• Forneça saídas geradas anteriormente para comparar com o conjunto de avaliação. Essa opção será recomendada se você quiser avaliar as saídas de um aplicativo que já estiver implantado na produção, ou se quiser comparar os resultados da avaliação entre as configurações de avaliação.

  Com essa opção, você especifica um conjunto de avaliação, conforme mostrado no código a seguir. O conjunto de avaliação deve incluir saídas geradas anteriormente. Para obter exemplos mais detalhados, consulte Exemplo: Como passar saídas geradas anteriormente para a Avaliação do agente.

  evaluation_results = mlflow.evaluate(
      data=eval_set_with_chain_outputs_df,  # pandas DataFrame with the evaluation set and application outputs
      model_type="databricks-agent",
  )
  

• Passe o aplicativo como um argumento de entrada. mlflow.evaluate() chama o aplicativo para cada entrada no conjunto de avaliação e relata avaliações de qualidade e outras métricas para cada saída gerada. Essa opção será recomendada se o seu aplicativo tiver sido registrado usando o MLflow com o Rastreamento do MLflow habilitado ou se ele for implementado como uma função Python em um notebook. Essa opção não é recomendada se o aplicativo foi desenvolvido ou estiver implantado fora do Databricks.

  Com essa opção, você especifica o conjunto de avaliação e o aplicativo na chamada de função, conforme mostrado no código a seguir. Para obter exemplos mais detalhados, consulte Exemplo: Como passar um aplicativo para a Avaliação do Agente.

  evaluation_results = mlflow.evaluate(
      data=eval_set_df,  # pandas DataFrame containing just the evaluation set
      model=model,  # Reference to the MLflow model that represents the application
      model_type="databricks-agent",
  )
  

Para obter detalhes sobre o esquema do conjunto de avaliação, consulte o esquema de entrada de Avaliação do Agente (MLflow 2).

Saídas de avaliação

A Avaliação do Agente retorna os resultados dele a partir de mlflow.evaluate() como dataframes e também registra esses resultados na execução do MLflow. Você pode inspecionar os resultados no notebook ou na página da execução correspondente do MLflow.

Examinar a saída no notebook

O código a seguir mostra alguns exemplos de como revisar os resultados de uma execução de avaliação a partir de seu notebook.

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

###
# Run evaluation
###
evaluation_results = mlflow.evaluate(..., model_type="databricks-agent")

###
# Access aggregated evaluation results across the entire evaluation set
###
results_as_dict = evaluation_results.metrics
results_as_pd_df = pd.DataFrame([evaluation_results.metrics])

# Sample usage
print(f"The percentage of generated responses that are grounded: {results_as_dict['response/llm_judged/groundedness/percentage']}")

###
# Access data about each question in the evaluation set
###

per_question_results_df = evaluation_results.tables['eval_results']

# Show information about responses that are not grounded
per_question_results_df[per_question_results_df["response/llm_judged/groundedness/rating"] == "no"].display()

O per_question_results_df dataframe inclui todas as colunas no esquema de entrada e todos os resultados de avaliação específicos de cada solicitação. Para obter mais detalhes sobre os resultados computados, consulte Como a qualidade, o custo e a latência são avaliados pela Avaliação do Agente (MLflow 2).

Examinar a saída usando a interface do usuário do MLflow

Os resultados da avaliação também estão disponíveis na interface do usuário do MLflow. Para acessar a interface do usuário do MLflow, clique no na barra lateral direita do notebook e, em seguida, na execução correspondente, ou clique nos links que aparecem nos resultados da célula do notebook na qual você executou mlflow.evaluate().

Examinar os resultados da avaliação de apenas uma execução

Esta seção descreve como revisar os resultados da avaliação de uma execução específica. Para comparar os resultados entre execuções, consulte Comparar resultados de avaliação entre execuções.

Visão geral das avaliações de qualidade realizadas por juízes de LLM

Avaliações de avaliadores por solicitação estão disponíveis em databricks-agents versão 0.3.0 e superior.

Para ver uma visão geral da qualidade avaliada por LLM de cada solicitação no conjunto de avaliação, clique na guia Rastreamentos na página Execução do MLflow.

)

Essa visão geral mostra as avaliações de juízes diferentes para cada solicitação e o status de aprovação/falha de qualidade de cada solicitação com base nessas avaliações.

Para obter mais detalhes, clique em uma linha na tabela para exibir a página de detalhes dessa solicitação. Na página de detalhes, você pode clicar em Ver exibição detalhada de rastreamento.

Resultados agregados em todo o conjunto de avaliação

Para ver os resultados agregados em todo o conjunto de avaliação, clique na guia Visão geral (para valores numéricos) ou na guia Métricas do modelo (para gráficos).

Comparar os resultados da avaliação em diferentes execuções

É importante comparar os resultados da avaliação entre execuções para ver como seu aplicativo agente responde às alterações. Comparar resultados pode ajudá-lo a entender se suas alterações estão afetando positivamente a qualidade ou ajudar você a solucionar problemas de alteração de comportamento.

Use a página Experimento do MLflow para comparar resultados entre execuções. Para acessar a página Experimento, clique no na barra lateral direita do caderno ou clique nos links que aparecem nos resultados da célula do caderno na qual você executou mlflow.evaluate().

Comparar resultados de cada solicitação em diferentes execuções

Para comparar dados de cada solicitação individual entre execuções, clique no ícone de exibição de avaliação do artefato, mostrado na captura de tela a seguir. Uma tabela mostra cada pergunta no conjunto de avaliação. Use os menus suspensos para selecionar as colunas a serem visualizadas. Clique em uma célula para exibir seu conteúdo completo.

Comparar os resultados agregados entre as execuções

Para comparar os resultados agregados para uma execução ou em execuções diferentes, clique no ícone de exibição do gráfico, mostrado na captura de tela a seguir. Isso permite que você visualize os resultados agregados para a execução selecionada e compare com as execuções anteriores.

Quais juízes são executados

Por padrão, para cada registro de avaliação, a ferramenta de Avaliação de Agentes do Mosaic AI aplica o subconjunto de juízes que melhor corresponde às informações presentes no registro. Especificamente:

• Se o registro incluir uma resposta de verdade de base, a Avaliação do Agente aplicará os avaliadores context_sufficiency, groundedness, correctness, safety e guideline_adherence.
• Se o registro não incluir uma resposta de verdade de base, a Avaliação do Agente aplicará os juízes chunk_relevance, groundedness, relevance_to_query, safety e guideline_adherence.

Para obter mais detalhes, consulte:

• Executar um subconjunto de avaliadores embutidos
• Juízes de IA personalizados
• Como a qualidade, o custo e a latência são avaliados pela Avaliação do Agente (MLflow 2)

Para obter informações de confiança e segurança dos juízes LLM, consulte Informações sobre os modelos que dão suporte aos juízes LLM.

Exemplo: Como passar um aplicativo para a Avaliação do Agente

Para passar um aplicativo para mlflow_evaluate(), use o argumento model. Existem cinco opções para passar uma aplicação no argumento model.

• Um modelo registrado no Unity Catalog.
• Um modelo registrado em log no MLflow dentro do experimento atual do MLflow.
• Um modelo PyFunc que é carregado no notebook.
• Uma função local no notebook.
• Um ponto de extremidade do agente implantado.

Consulte as seções a seguir para obter exemplos de código que ilustram cada opção.

Opção 1. Modelo registrado no Catálogo do Unity

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = "models:/catalog.schema.model_name/1"  # 1 is the version number
    model_type="databricks-agent",
)

Opção 2. Modelo registrado do MLflow no experimento atual do MLflow

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

# In the following lines, `6b69501828264f9s9a64eff825371711` is the run_id, and `chain` is the artifact_path that was
# passed with mlflow.xxx.log_model(...).
# If you called model_info = mlflow.langchain.log_model() or mlflow.pyfunc.log_model(), you can access this value using `model_info.model_uri`.
evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = "runs:/6b69501828264f9s9a64eff825371711/chain"
    model_type="databricks-agent",
)

Opção 3. Modelo PyFunc carregado no notebook

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = mlflow.pyfunc.load_model(...)
    model_type="databricks-agent",
)

Opção 4. Função local no notebook

A função recebe uma entrada formatada da seguinte maneira:

{
  "messages": [
    {
      "role": "user",
      "content": "What is MLflow?",
    }
  ],
  ...
}

A função deve retornar um valor em uma cadeia de caracteres simples ou em um dicionário serializável (por exemplo, Dict[str, Any]). Para obter melhores resultados com os juízes internos, o Databricks recomenda usar um formato de chat, como ChatCompletionResponse. Por exemplo:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "MLflow is a machine learning toolkit.",
      },
      ...
    }
  ],
  ...,
}

O exemplo a seguir usa uma função local para encapsular um ponto de extremidade do modelo de base e avaliá-lo:

  %pip install databricks-agents pandas
  dbutils.library.restartPython()

  import mlflow
  import pandas as pd

  def model(model_input):
    client = mlflow.deployments.get_deploy_client("databricks")
    return client.predict(endpoint="endpoints:/databricks-meta-llama-3-1-405b-instruct", inputs={"messages": model_input["messages"]})

  evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = model
    model_type="databricks-agent",
  )

Opção 5. Endpoint do agente implantado

Essa opção só funciona quando você usa endpoints de agente que foram implantados usando databricks.agents.deploy e com a versão databricks-agents ou superior do SDK do 0.8.0. Para modelos de base ou versões mais antigas do SDK, use a Opção 4 para encapsular o modelo em uma função local.

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

# In the following lines, `endpoint-name-of-your-agent` is the name of the agent endpoint.
evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = "endpoints:/endpoint-name-of-your-agent"
    model_type="databricks-agent",
)

Como passar na avaliação definida quando o aplicativo é incluído na chamada mlflow_evaluate()

No código a seguir, data é um DataFrame do pandas com seu conjunto de avaliação. Estes são exemplos simples. Consulte o esquema de entrada para obter detalhes.

# You do not have to start from a dictionary - you can use any existing pandas or Spark DataFrame with this schema.

# Minimal evaluation set
bare_minimum_eval_set_schema = [
    {
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
    }]

# Complete evaluation set
complete_eval_set_schema = [
    {
        "request_id": "your-request-id",
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "expected_retrieved_context": [
            {
                # In `expected_retrieved_context`, `content` is optional, and does not provide any additional functionality.
                "content": "Answer segment 1 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_1",
            },
            {
                "content": "Answer segment 2 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_2",
            },
        ],
        "expected_response": "There's no significant difference.",
    }]

# Convert dictionary to a pandas DataFrame
eval_set_df = pd.DataFrame(bare_minimum_eval_set_schema)

# Use a Spark DataFrame
import numpy as np
spark_df = spark.table("catalog.schema.table") # or any other way to get a Spark DataFrame
eval_set_df = spark_df.toPandas()

Exemplo: Como passar saídas geradas anteriormente para a Avaliação do Agente

Esta seção descreve como passar saídas geradas anteriormente na mlflow_evaluate() chamada. Para o esquema de conjunto de avaliação necessário, consulte o esquema de entrada de Avaliação do Agente (MLflow 2).

Em o código a seguir, data é um DataFrame do pandas com seu conjunto de avaliação e as saídas geradas pelo aplicativo. Estes são exemplos simples. Consulte o esquema de entrada para obter detalhes.

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

evaluation_results = mlflow.evaluate(
    data=eval_set_with_app_outputs_df,  # pandas DataFrame with the evaluation set and application outputs
    model_type="databricks-agent",
)

# You do not have to start from a dictionary - you can use any existing pandas or Spark DataFrame with this schema.

# Minimum required input
bare_minimum_input_schema = [
    {
        "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.",
    }]

# Input including optional arguments
complete_input_schema  = [
    {
        "request_id": "your-request-id",
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "expected_retrieved_context": [
            {
                # In `expected_retrieved_context`, `content` is optional, and does not provide any additional functionality.
                "content": "Answer segment 1 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_1",
            },
            {
                "content": "Answer segment 2 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_2",
            },
        ],
        "expected_response": "There's no significant difference.",
        "response": "reduceByKey aggregates data before shuffling, whereas groupByKey shuffles all data, making reduceByKey more efficient.",
        "retrieved_context": [
            {
                # In `retrieved_context`, `content` is optional. If provided, the Databricks Context Relevance LLM Judge is executed to check the `content`'s relevance to the `request`.
                "content": "reduceByKey reduces the amount of data shuffled by merging values before shuffling.",
                "doc_uri": "doc_uri_2_1",
            },
            {
                "content": "groupByKey may lead to inefficient data shuffling due to sending all values across the network.",
                "doc_uri": "doc_uri_6_extra",
            },
        ],
        # 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"],
        }
    }]

# Convert dictionary to a pandas DataFrame
eval_set_with_app_outputs_df = pd.DataFrame(bare_minimum_input_schema)

# Use a Spark DataFrame
import numpy as np
spark_df = spark.table("catalog.schema.table") # or any other way to get a Spark DataFrame
eval_set_with_app_outputs_df = spark_df.toPandas()

Exemplo: usar uma função personalizada para processar respostas do LangGraph

Os agentes do LangGraph, especialmente aqueles com funcionalidade de bate-papo, podem retornar várias mensagens para uma única chamada de inferência. É responsabilidade do usuário converter a resposta do agente em um formato compatível com a Avaliação do Agente.

Uma abordagem é usar uma função personalizada para processar a resposta. O exemplo a seguir mostra uma função personalizada que extrai a última mensagem de chat de um modelo LangGraph. Essa função é então usada em mlflow.evaluate() para retornar uma string única de resposta, que pode ser comparada à coluna ground_truth.

O código de exemplo faz as seguintes suposições:

• O modelo aceita entrada no formato {"messages": [{"role": "user", "content": "hello" ("olá")}]}.
• O modelo retorna uma lista de cadeias de caracteres no formato ["response 1", "response 2"].

O código a seguir envia as respostas concatenadas ao juiz neste formato: "response 1nresponse2"

import mlflow
import pandas as pd
from typing import List

loaded_model = mlflow.langchain.load_model(model_uri)
eval_data = pd.DataFrame(
    {
        "inputs": [
            "What is MLflow?",
            "What is Spark?",
        ],
        "expected_response": [
            "MLflow is an open-source platform for managing the end-to-end machine learning (ML) lifecycle. It was developed by Databricks, a company that specializes in big data and machine learning solutions. MLflow is designed to address the challenges that data scientists and machine learning engineers face when developing, training, and deploying machine learning models.",
            "Apache Spark is an open-source, distributed computing system designed for big data processing and analytics. It was developed in response to limitations of the Hadoop MapReduce computing model, offering improvements in speed and ease of use. Spark provides libraries for various tasks such as data ingestion, processing, and analysis through its components like Spark SQL for structured data, Spark Streaming for real-time data processing, and MLlib for machine learning tasks",
        ],
    }
)

def custom_langgraph_wrapper(model_input):
    predictions = loaded_model.invoke({"messages": model_input["messages"]})
    # Assuming `predictions` is a list of strings
    return predictions.join("\n")

with mlflow.start_run() as run:
    results = mlflow.evaluate(
        custom_langgraph_wrapper,  # Pass the function defined above
        data=eval_data,
        model_type="databricks-agent",
    )

print(results.metrics)

Criar um painel com métricas

Ao iterar sobre a qualidade do seu agente, talvez você queira compartilhar um painel com as partes interessadas que mostre como a qualidade melhorou ao longo do tempo. Você pode extrair as métricas de suas execuções de avaliação do MLflow, salvar os valores em uma tabela Delta e criar um painel.

O exemplo a seguir mostra como extrair e salvar os valores de métrica da execução de avaliação mais recente em seu notebook:

uc_catalog_name = "catalog"
uc_schema_name = "schema"
table_name = "results"

eval_results = mlflow.evaluate(
    model=logged_agent_info.model_uri, # use the logged Agent
    data=evaluation_set, # Run the logged Agent for all queries defined above
    model_type="databricks-agent", # use Agent Evaluation
)

# The `append_metrics_to_table function` is defined below
append_metrics_to_table("<identifier-for-table>", eval_results.metrics, f"{uc_catalog_name}.{uc_schema_name}.{table_name}")

O exemplo a seguir mostra como extrair e salvar valores de métrica para execuções anteriores que você salvou em seu experimento do MLflow.

import pandas as pd

def get_mlflow_run(experiment_name, run_name):
  runs = mlflow.search_runs(experiment_names=[experiment_name], filter_string=f"run_name = '{run_name}'", output_format="list")

  if len(runs) != 1:
    raise ValueError(f"Found {len(runs)} runs with name {run_name}. {run_name} must identify a single run. Alternatively, you can adjust this code to search for a run based on `run_id`")

   return runs[0]

run = get_mlflow_run(experiment_name ="/Users/<user_name>/db_docs_mlflow_experiment", run_name="evaluation__2024-10-09_02:27:17_AM")

# The `append_metrics_to_table` function is defined below
append_metrics_to_table("<identifier-for-table>", run.data.metrics, f"{uc_catalog_name}.{uc_schema_name}.{table_name}")

Agora você pode criar um painel usando esses dados.

O código a seguir define a função append_metrics_to_table usada nos exemplos anteriores.

# Definition of `append_metrics_to_table`

def append_metrics_to_table(run_name, mlflow_metrics, delta_table_name):
  data = mlflow_metrics.copy()

  # Add identifying run_name and timestamp
  data["run_name"] = run_name
  data["timestamp"] = pd.Timestamp.now()

  # Remove metrics with error counts
  data = {k: v for k, v in mlflow_metrics.items() if "error_count" not in k}

  # Convert to a Spark DataFrame(
  metrics_df = pd.DataFrame([data])
  metrics_df_spark = spark.createDataFrame(metrics_df)

  # Append to the Delta table
  metrics_df_spark.write.mode("append").saveAsTable(delta_table_name)

Informações sobre os modelos que alimentam os avaliadores LLM

• Os avaliadores LLM podem usar serviços de terceiros para avaliar os aplicativos GenAI, incluindo o Azure OpenAI operado pela Microsoft.
• Para o Azure OpenAI, a Databricks optou por não usar o Monitoramento de Abuso, portanto, nenhum prompt ou resposta é armazenado com o Azure OpenAI.
• Para os workspaces da União Europeia (UE), os avaliadores de LLM usam modelos hospedados na Europa. Todas as outras regiões usam modelos hospedados nos EUA.
• Desabilitar recursos de IA potenciados por parceiros impede o juiz LLM de chamar modelos potencializados por parceiros. Você ainda pode usar juízes LLM fornecendo seu próprio modelo.
• Os avaliadores de LLM ajudam os clientes a avaliar agentes/aplicativos de IA generativa, e as saídas de avaliador de LLM não devem ser usadas para treinar, melhorar ou ajustar um LLM.