Pular para o conteúdo principal
Última atualização em

Realize uma execução de avaliação e view os resultados (MLflow 2)

importante

A Databricks recomenda usar o MLflow 3 para a avaliação e monitoramento de aplicativos GenAI. Esta página descreve o MLflow 2 Agent Evaluation.

Este artigo descreve como realizar a execução de uma avaliação e view os resultados à medida que você desenvolve seu aplicativo de AI. Para informações sobre como monitorar agentes implantados, consulte Monitorar aplicativos 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 selecionado 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 da Agent Evaluation (MLflow 2).

Execução de uma avaliação​

Para realizar uma execução de avaliação, use o mlflow.evaluate() método da API do MLflow, especificando model_type como databricks-agent para habilitar a Agent Evaluation no Databricks e juízes de AI integrada.

O exemplo a seguir especifica um conjunto de diretrizes de resposta globais para o juiz de AI de diretrizes globais que faz com que a avaliação falhe quando as respostas não aderem às diretrizes. Você não precisa coletar rótulos por solicitação para avaliar seu agente com esta abordagem.

Python
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 tab Traces da página de execução do MLflow:

Interface do usuário do MLFlow mostrando os resultados do exemplo acima

Este exemplo realiza a execução dos seguintes juízes que não precisam de rótulos de verdade fundamental: Aderência à diretriz, Relevância para a consulta, Segurança.

Se for utilizado um agente com um recuperador, os seguintes juízes passam por execução: Fundamentação, Relevância do bloco

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

Avalie com rótulos de verdade fundamental​

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

Python
%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 juízes que acima, além dos seguintes: Correção, Relevância, Segurança

Se um agente com um recuperador for usado, é feita a execução do seguinte juiz: Suficiência de contexto

Requisitos​

Recursos de IA desenvolvidos por parceiros devem ser habilitados para seu workspace.

Forneça entradas para uma execução de avaliação​

Há duas maneiras de apresentar informações para uma execução de avaliação:

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

    Com esta 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 exemplos mais detalhados, consulte Exemplo: Como passar saídas geradas anteriormente para o Agent Evaluation.

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

  • Passar a aplicação como argumento de entrada. mlflow.evaluate() chama a aplicação para cada entrada no conjunto de avaliação e relata as avaliações de qualidade e outras métricas para cada saída gerada. Esta opção é recomendada se sua aplicação foi registrada utilizando MLflow com MLflow Tracing habilitado, ou se sua aplicação é implementada como uma função Python em um Notebook. Esta opção não é recomendada se sua aplicação foi desenvolvida fora da Databricks ou está implantada fora da Databricks.

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

    Python
    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 esquema de entrada do Agent Evaluation (MLflow 2).

Saídas da avaliação​

A Agent Evaluation retorna suas saídas de mlflow.evaluate() como dataframes e também registra essas saídas na execução do MLflow. É possível inspecionar as saídas no Notebook ou na página da execução do MLflow correspondente.

Revisar a saída no Notebook​

O código a seguir mostra alguns exemplos de como revisar os resultados de uma avaliação executada em seu Notebook.

Python
%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 dataframe per_question_results_df inclui todas as colunas no esquema de entrada e todos os resultados de avaliação específicos para cada solicitação. Para mais detalhes sobre os resultados compute, consulte Como a qualidade, o custo e a latência são avaliados pelo Agent Evaluation (MLflow 2).

Revise a saída usando a interface do usuário do MLflow​

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

Revisar os resultados da avaliação para uma única execução​

Esta seção descreve como revisar os resultados da avaliação para uma execução individual. Para comparar os resultados entre execuções, consulte Comparar os resultados da avaliação entre execuções.

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

Avaliações de juízes por solicitação estão disponíveis na versão 0,3,0 de databricks-agents e acima.

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

visão_geral_judges)

Esta visão geral mostra as avaliações de diferentes juízes para cada solicitação e o status de aprovação/reprovação 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 view detalhada do rastreamento .

detalhes_judges

Resultados agregados em todo o conjunto de avaliação​

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

Métricas de avaliação, valores

Métricas de avaliação, gráficos

Compare os resultados da avaliação entre execuções​

É importante comparar os resultados da avaliação entre execuções para ver como seu aplicativo agêntico responde às mudanças. Comparar resultados pode ajudar você a entender se suas alterações estão impactando positivamente a qualidade ou ajudar a solucionar problemas de comportamento em mudança.

Use a página do experimento MLflow para comparar resultados entre execuções. Para acessar a página Experimento, clique no ícone Experimento Ícone Experimentar na barra lateral direita do Notebook, ou clique nos links que aparecem nos resultados da célula para a célula do Notebook na qual você fez a mlflow.evaluate() execução.

Compare os resultados por solicitação entre execuções​

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

Perguntas individuais no conjunto de avaliação

Compare os resultados agregados entre execuções​

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

resultados agregados

Quais juízes estão em execução​

Por default, para cada registro de avaliação, o Agent Evaluation aplica o subconjunto de juízes que melhor corresponde às informações presentes no registro. Especificamente:

  • Se o registro inclui uma resposta de verdade fundamental, o Agent Evaluation aplica os juízes context_sufficiency, groundedness, correctness, safety e guideline_adherence.
  • Se o registro não incluir uma resposta de verdade fundamental, o Agent Evaluation aplicará os juízes chunk_relevance, groundedness, relevance_to_query, safety e guideline_adherence.

Para mais detalhes, consulte:

Para obter informações de confiança e segurança do juiz LLM, consulte Informações sobre os modelos que impulsionam os juízes LLM.

Exemplo: Como passar uma aplicação para a Agent Evaluation​

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

  • Um modelo registrado no Unity Catalog.
  • Um modelo MLflow logged no experimento MLflow atual.
  • Um modelo PyFunc que é carregado no Notebook.
  • Uma função local no Notebook.
  • Um endpoint de 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 Unity Catalog​

Python
%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 logged do MLflow no experimento MLflow atual.​

Python
%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 que é carregado no Notebook​

Python
%pip install databricks-agents==0.16.0 pandas==2.2.3
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 forma:

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

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

Python
{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models.",
      },
      ...
    }
  ],
  ...,
}

O exemplo a seguir usa uma função local para encapsular um endpoint de modelo básico e avaliá-lo:

Python
  %pip install databricks-agents==0.16.0 pandas==2.2.3
  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-3-70b-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 de 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 0.8.0 ou acima do SDK databricks-agents. Para modelos base ou versões mais antigas do SDK, use a Opção 4 para encapsular o modelo em uma função local.

Python
%pip install databricks-agents==0.16.0 pandas==2.2.3
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 no conjunto de avaliação quando o aplicativo estiver 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.

Python
# 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 Agent Evaluation​

Esta seção descreve como passar outputs gerados anteriormente na chamada mlflow_evaluate(). Para o esquema do conjunto de avaliação necessário, consulte Esquema de entrada do Agent Evaluation (MLflow 2).

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

Python
%pip install databricks-agents==0.16.0 pandas==2.2.3
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: Use uma função personalizada para processar respostas do LangGraph​

Agentes LangGraph, especialmente aqueles com funcionalidade de chat, podem retornar várias mensagens para uma única chamada de inferência. É responsabilidade do usuário converter a resposta do agente para um formato compatível com Agent Evaluation.

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. Esta função é então usada em mlflow.evaluate() para retornar uma única resposta de string, que pode ser comparada à coluna ground_truth.

O código de exemplo faz as seguintes premissas:

  • O modelo aceita entrada no formato {"messages": [{"role": "user", "content": "hello"}]}.
  • O modelo retorna uma lista de strings no formato [“resposta 1”, “resposta 2”].

O código a seguir envia as respostas concatenadas para o juiz neste formato: “response 1nresponse2”

Python
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 the largest open source AI engineering platform for agents, LLMs, and ML models. MLflow enables teams of all sizes to debug, evaluate, monitor, and optimize their AI applications while controlling costs and managing access to models and data. With over 30 million monthly downloads, thousands of organizations rely on MLflow each day to ship AI to production with confidence.",
            "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)

Crie um painel com métricas​

Ao iterar na qualidade do seu agente, poderá desejar compartilhar um painel com seus stakeholders 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 das métricas da execução de avaliação mais recente no seu Notebook:

Python
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étricas para execuções anteriores que você salvou em seu experimento MLflow.

Python
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 estes dados.

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

Python
# 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 capacitam os juízes do LLM​

  • Os juízes do LLM podem utilizar serviços de terceiros para avaliar suas aplicações GenAI, incluindo o Azure OpenAI operado pela Microsoft.
  • Para o Azure OpenAI, a Databricks optou por não utilizar o Abuse Monitoring, portanto nenhum prompt ou resposta é armazenado com o Azure OpenAI.
  • Para os espaços de trabalho da União Europeia (UE), os juízes do LLM utilizam modelos hospedados na UE. Todas as outras regiões utilizam modelos hospedados nos EUA.
  • Desativar os recursos de IA desenvolvidos por parceiros impede que o juiz do LLM ligue para modelos desenvolvidos por parceiros. Ainda é possível usar juízes LLM fornecendo seu próprio modelo.
  • Os juízes de LLM destinam-se a ajudar os clientes a avaliar seus agentes/aplicativos de GenAI, e as saídas dos juízes de LLM não devem ser usadas para ensinar, melhorar ou ajustar um LLM.
Nesta página