Pular para o conteúdo principal

executar uma avaliação e view os resultados

info

Visualização

Esse recurso está em Public Preview.

Este artigo descreve como executar uma avaliação e view os resultados à medida que o senhor desenvolve seu aplicativo AI. Para obter informações sobre como monitorar a qualidade dos agentes implantados no tráfego de produção, consulte Como monitorar a qualidade do seu agente no tráfego de 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 pode vir de um conjunto selecionado de solicitações de avaliação ou de rastreamentos de usuários do agente. Para obter mais detalhes, consulte Conjuntos de avaliação e esquema de entrada de avaliação do agente.

execução e avaliação​

Para executar uma avaliação, use a função mlflow.evaluate() do site MLflow API, especificando o model_type como databricks-agent para habilitar a Avaliação do Agente em Databricks e integrar os juízes de AI.

O exemplo a seguir especifica um conjunto de diretrizes de resposta global para o juiz de AI de diretrizes globais que faz com que a avaliação falhe quando as respostas não aderem às diretrizes. O senhor não precisa coletar rótulo por solicitação para avaliar seu agente com essa 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
      }
    }
  )

O exemplo acima cria a seguinte UI de resultados de avaliação do MLFlow:

UI do MLFlow mostrando os resultados do exemplo acima

Este exemplo executa os seguintes juízes que não precisam de rótulo de verdade fundamental: Adesão às diretrizes, Relevância para a consulta, Segurança.

Se o senhor usar um agente com um retriever, os seguintes juízes serão executados: Fundamentação, Relevância do pedaço

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

Avaliar com o rótulo ground-truth​

O exemplo a seguir especifica o rótulo ground-truth por linha: expected_facts e guidelines que executarão os juízes de correção e diretrizes, respectivamente. As avaliações individuais são tratadas separadamente usando o rótulo de verdade terrestre 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 o acima, além dos seguintes: Correção, Relevância, Segurança

Se o senhor usar um agente com um retriever, o juiz a seguir é a execução: Suficiência de contexto

Requisitos​

parceiros-powered AI recurso assistivo deve estar habilitado para o seu workspace.

Fornecer insumos para uma execução de avaliação​

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

  • Forneça resultados gerados anteriormente para comparar com o conjunto de avaliação. Essa opção é recomendada se o senhor quiser avaliar os resultados de um aplicativo que já foi 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 resultados gerados anteriormente. Para obter exemplos mais detalhados, consulte Exemplo: Como passar saídas geradas anteriormente para a Avaliação do Agente.

    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",
    )

  • Passe o aplicativo como 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 é recomendada se o aplicativo tiver sido registrado usando MLflow com MLflow Tracing ativado ou se o aplicativo tiver sido implementado como uma função Python em um Notebook. Essa opção não é recomendada se o seu aplicativo tiver sido desenvolvido fora da Databricks ou for implantado fora da Databricks.

    Com essa 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 obter exemplos mais detalhados, consulte Exemplo: Como passar um aplicativo para o 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 da Avaliação do Agente.

Resultados da avaliação​

O Agent Evaluation retorna seus resultados de mlflow.evaluate() como dataframes e também logs esses resultados para a execução MLflow. O senhor pode inspecionar os resultados no Notebook ou na página do site correspondente MLflow execução.

Revisar os resultados 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 da avaliação específicos de cada solicitação. Para obter mais detalhes sobre os resultados da computação, consulte Como a qualidade, o custo e a latência são avaliados pela Avaliação de agentes.

Revisar a saída usando a UI 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 MLflow, clique no ícone Experiment Í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 do Notebook em que o senhor executou mlflow.evaluate().

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

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

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

As avaliações de juízes por solicitação estão disponíveis em databricks-agents versão 0.3.0 e acima.

Para ver uma visão geral da qualidade julgada LLMde cada solicitação no conjunto de avaliação, clique em Resultados da avaliação tab na página de execução MLflow. Esta página mostra uma tabela de resumo de cada execução de avaliação. Para obter mais detalhes, clique na ID de avaliação de uma execução.

visão geral\ _judges

Essa visão geral mostra as avaliações de diferentes juízes para cada solicitação, o status de qualidade de aprovação/reprovação de cada solicitação com base nessas avaliações e a causa básica da falha nas solicitações. Ao clicar em uma linha na tabela, você será direcionado para a página de detalhes dessa solicitação, que inclui o seguinte:

  • Saída do modelo: a resposta gerada pelo aplicativo agente e seu rastreamento, se incluído.
  • Saída esperada: a resposta esperada para cada solicitação.
  • Avaliações detalhadas: As avaliações dos juízes do LLM sobre esses dados. Clique em Ver detalhes para exibir as justificativas fornecidas pelos juízes.

detalhes\ _juízes

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

Para ver os resultados agregados em todo o conjunto de avaliação, clique em Overview tab (para valores numéricos) ou em Model métricas tab (para gráficos).

Métricas de avaliação, valores

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

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

É importante comparar os resultados da avaliação entre as execuções para ver como o aplicativo agêntico responde às mudanças. A comparação dos resultados pode ajudá-lo a entender se suas mudanças estão impactando positivamente a qualidade ou ajudá-lo a solucionar problemas de mudança de comportamento.

Comparar os resultados por solicitação em toda a execução​

Para comparar os dados de cada solicitação individual entre as execuções, clique em Evaluation (Avaliação) tab na página Experiment (Experimento). Uma tabela mostra cada pergunta no conjunto de avaliação. Use os menus suspensos para selecionar as colunas para view.

Perguntas individuais no conjunto de avaliação

Comparar resultados agregados em toda a execução​

O senhor pode acessar os mesmos resultados agregados na página Experiment, que também permite comparar os resultados entre diferentes execuções. Para acessar a página Experiment, clique no ícone Experiment Ícone Experimentar na barra lateral direita do Notebook ou clique nos links que aparecem nos resultados da célula do Notebook na qual o senhor executou mlflow.evaluate().

Na página Experimentar, clique em ícone do gráfico de exibição. Isso permite que o senhor visualize os resultados agregados para a execução selecionada e compare com as execuções anteriores.

resultados agregados

Quais juízes estão executando​

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

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

Para mais detalhes, consulte:

Para LLM obter informações sobre a LLMconfiança e a segurança dos juízes do site, consulte as informações sobre os modelos que alimentam os juízes do site.

Exemplo: Como passar uma inscriçã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 MLflow modelos registrados no atual experimento MLflow.
  • 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. MLflow modelos registrados 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 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 forma:

Python
{
  "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 integrados, o site Databricks recomenda o uso de um formato de bate-papo como ChatCompletionResponse. Por exemplo:

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

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

Python
  %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. agente implantado endpoint​

Essa opção só funciona quando o senhor usa um endpoint de agente que foi implantado usando databricks.agents.deploy e com databricks-agents SDK versão 0.8.0 ou acima. Para modelos básicos ou versões mais antigas do SDK, use a Opção 4 para envolver o modelo em uma função local.

Python
%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 no conjunto de avaliação quando o aplicativo é incluído na chamada mlflow_evaluate()​

No código a seguir, data é um Pandas DataFrame com seu conjunto de avaliação. Esses 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 a Avaliação do Agente​

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

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

Python
%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: use 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 bate-papo de um modelo LangGraph. Essa função é então usada em mlflow.evaluate() para retornar uma única resposta de cadeia de caracteres, que pode ser comparada com a coluna ground_truth.

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

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

O código a seguir envia as respostas concatenadas ao juiz neste formato: “resposta 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 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 de controle com métricas​

Ao repetir a qualidade do seu agente, talvez você queira compartilhar um painel com as partes interessadas que mostre como a qualidade melhorou com o tempo. O senhor pode extrair as métricas de sua execução de avaliação MLflow, salvar os valores em uma tabela Delta e criar um painel de controle.

O exemplo a seguir mostra como extrair e salvar os valores métricos da execução da avaliação mais recente em 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 métricos de execuções anteriores que o senhor 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 esses 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 alimentam 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.
  • AI A desativação do recurso assistido por parceiros impede que o LLM juiz do chame os modelos alimentados por parceiros.
  • Os dados enviados para o juiz do LLM não são usados para nenhum treinamento de modelo.
  • Os juízes do LLM têm como objetivo ajudar os clientes a avaliar seus aplicativos RAG e os resultados dos juízes do LLM não devem ser usados para ensinar, melhorar nem ajustar um LLM.
Última atualização em