Spuštění vyhodnocení a zobrazení výsledků

Důležité

Tato funkce je ve verzi Public Preview.

Tento článek popisuje, jak spustit vyhodnocení a zobrazit výsledky při vývoji aplikace AI. Informace o tom, jak monitorovat kvalitu nasazených agentů v produkčním provozu, najdete v tématu Jak monitorovat kvalitu agenta v produkčním provozu.

Pokud chcete vyhodnotit agenta, musíte zadat sadu vyhodnocení. Minimálně hodnotící sada je sada požadavků na vaši aplikaci, která může pocházet buď z kurátorované sady hodnotících žádostí, nebo záznamů interakcí od uživatelů agenta. Podrobnosti naleznete v tématu Vyhodnocovací sady a Vstupní schéma hodnocení agenta.

Proveďte vyhodnocení

Pokud chcete spustit vyhodnocení, použijte metodu mlflow.evaluate() z rozhraní API MLflow a zadejte jako , aby bylo možné povolit hodnocení agentů v Databricks a integrovaných porotců AI.

Následující příklad určuje sadu globálních pokynů pro odpovědi pro globální pokyny AI soudce, které způsobují selhání vyhodnocení, když odpovědi nedodržují pokyny. K vyhodnocení agenta tímto přístupem nemusíte shromažďovat popisky jednotlivých požadavků.

import mlflow
from mlflow.deployments import get_deploy_client

# The guidelines below will be used to evaluate any response of the agent.
global_guidelines = [
  "If the request is unrelated to Databricks, the response must should be a rejection of the request",
  "If the request is related to Databricks, the response must should be concise",
  "If the request is related to Databricks and question about API, the response must have code",
  "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
      }
    }
  )

Tento příklad spouští následující hodnotící kritéria, která nepotřebují referenční data: Dodržování zásad, Relevance k dotazu, Bezpečnost.

Pokud používáte agenta s vyhledávačem, spustí se následující hodnotitele: uzemněnost, relevance bloku dat

mlflow.evaluate() také vypočítá latenci a metriky nákladů pro každý záznam vyhodnocení a agreguje výsledky napříč všemi vstupy pro dané spuštění. Tyto výsledky se označují jako výsledky vyhodnocení. Výsledky vyhodnocení se protokolují v uzavřeném spuštění spolu s informacemi protokolovanými jinými příkazy, jako jsou parametry modelu. Pokud voláte mlflow.evaluate() mimo probíhající běh MLflow, vytvoří se nový běh.

Vyhodnocení pomocí popisků základní pravdy

Následující příklad určuje popisky základní pravdy pro jednotlivé řádky: expected_facts a guidelines, které spustí správnost a pokyny soudce. Jednotlivá vyhodnocení se zpracovávají samostatně pomocí popisků referenční pravdy pro každý řádek.

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

Tento příklad spouští stejné soudce jako výše, a navíc i následující: správnost, relevance, bezpečnost.

Pokud používáte agenta s vyhledávačem, provede se následující hodnocení: Kontextová dostatečnost

Požadavky

Pro váš pracovní prostor musí být povolené funkce usnadnění AI využívající Azure AI.

Zadání vstupů do zkušebního spuštění

Existují dva způsoby, jak zadat vstup do zkušebního spuštění:

• Zadejte dříve vygenerované výstupy pro porovnání s vyhodnocovací sadou. Tato možnost se doporučuje, pokud chcete vyhodnotit výstupy z aplikace, která je už nasazená do produkčního prostředí, nebo pokud chcete porovnat výsledky vyhodnocení mezi konfiguracemi vyhodnocení.

  Pomocí této možnosti zadáte sadu vyhodnocení, jak je znázorněno v následujícím kódu. Sada vyhodnocení musí obsahovat dříve vygenerované výstupy. Podrobnější příklady najdete v tématu Příklad: Jak předat dříve vygenerované výstupy do vyhodnocení agenta.

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

• Předejte aplikaci jako vstupní argument. mlflow.evaluate() volá aplikaci pro každý vstup v evaluační sadě a hlásí hodnocení kvality a další metriky pro každý vygenerovaný výstup. Tato možnost se doporučuje, pokud byla vaše aplikace protokolována pomocí MLflow s povoleným trasováním MLflow nebo pokud je vaše aplikace implementovaná jako funkce Pythonu v poznámkovém bloku. Tato možnost se nedoporučuje, pokud byla vaše aplikace vyvinuta mimo Databricks nebo je nasazená mimo Databricks.

  Pomocí této možnosti zadáte testovací sadu a aplikaci ve volání funkce, jak je znázorněno v následujícím kódu. Podrobnější příklady najdete v tématu Příklad: Jak předat aplikaci do vyhodnocení agenta.

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

Podrobnosti o schématu sady vyhodnocení naleznete v tématu Vstupní schéma vyhodnocení agenta.

Výstupy vyhodnocení

Vyhodnocení agenta vrátí výstupy z mlflow.evaluate() datových rámců a také tyto výstupy zapíše do spuštění MLflow. Můžete zkontrolovat výstupy v poznámkovém bloku nebo na stránce odpovídajícího spuštění MLflow.

Kontrola výstupu v poznámkovém bloku

Následující kód ukazuje několik příkladů, jak zkontrolovat výsledky zkušebního spuštění z poznámkového bloku.

%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()

Datový rámec per_question_results_df zahrnuje všechny sloupce ve vstupním schématu a všechny výsledky vyhodnocení specifické pro každý požadavek. Další podrobnosti o vypočítaných výsledcích najdete v tématu Hodnocení agenta v tématu Jak se hodnotí kvalita, náklady a latence.

Kontrola výstupu pomocí uživatelského rozhraní MLflow

Výsledky vyhodnocení jsou k dispozici také v uživatelském rozhraní MLflow. Pokud chcete získat přístup k uživatelskému rozhraní MLflow, klikněte na ikonu Experiment v pravém bočním panelu poznámkového bloku a potom na příslušném spuštění nebo klikněte na odkazy, které se zobrazí ve výsledcích buňky pro buňku poznámkového bloku, ve které jste spustili mlflow.evaluate().

Kontrola výsledků vyhodnocení pro jedno spuštění

Tato část popisuje, jak zkontrolovat výsledky vyhodnocení jednotlivých spuštění. Pokud chcete porovnat výsledky napříč spuštěními, přečtěte si téma Porovnání výsledků vyhodnocení napříč běhy.

Přehled hodnocení kvality porotců LLM

Hodnocení soudce na žádost jsou k dispozici ve databricks-agents verzi 0.3.0 a vyšší.

Pokud chcete zobrazit přehled kvality jednotlivých požadavků v evaluační sadě, klikněte na kartu Výsledky vyhodnocení na stránce spuštění MLflow. Tato stránka zobrazuje souhrnnou tabulku každého zkušebního spuštění. Další podrobnosti získáte kliknutím na ID vyhodnocení spuštění.

Tento přehled ukazuje hodnocení různých porotců pro každou žádost, stav ověření kvality/selhání každého požadavku na základě těchto posouzení a hlavní příčinu neúspěšných požadavků. Kliknutím na řádek v tabulce přejdete na stránku podrobností pro danou žádost, která obsahuje následující:

• Výstup modelu: Vygenerovaná odpověď z agentické aplikace a její trasování, pokud je součástí.
• Očekávaný výstup: Očekávaná odpověď pro každý požadavek.
• Podrobná hodnocení: Hodnocení porotců LLM o těchto datech. Kliknutím na Zobrazit podrobnosti zobrazíte odůvodnění poskytovaná soudcem.

Agregované výsledky v celé sadě vyhodnocení

Pokud chcete zobrazit agregované výsledky v celé sadě vyhodnocení, klikněte na kartu Přehled (pro číselné hodnoty) nebo na kartu Metriky modelu (pro grafy).

Porovnání výsledků vyhodnocení napříč spuštěními

Je důležité porovnat výsledky vyhodnocení napříč běhy a zjistit, jak vaše agentská aplikace reaguje na změny. Porovnání výsledků vám může pomoct pochopit, jestli vaše změny mají pozitivní vliv na kvalitu, nebo vám pomůžou vyřešit potíže se změnou chování.

Porovnání výsledků jednotlivých požadavků napříč spuštěními

Pokud chcete porovnat data pro jednotlivé žádosti napříč spuštěními, klikněte na kartu Vyhodnocení na stránce Experiment. Tabulka zobrazuje jednotlivé otázky v sadě vyhodnocení. Pomocí rozevíracích nabídek vyberte sloupce, které chcete zobrazit.

sady hodnocení

Porovnání agregovaných výsledků napříč spuštěními

Na stránce Experiment můžete přistupovat ke stejným agregovaným výsledkům, které vám také umožní porovnat výsledky napříč různými spuštěními. Pokud chcete získat přístup na stránku Experiment, klikněte na ikonu Experiment v pravém bočním panelu poznámkového bloku nebo klikněte na odkazy, které se zobrazí ve výsledcích buňky pro buňku poznámkového bloku, ve které jste spustili mlflow.evaluate().

Na stránce Experiment klikněte na . To vám umožní vizualizovat agregované výsledky pro vybrané spuštění a porovnat s minulými spuštěními.

Kteří porotci jsou spuštěni

Ve výchozím nastavení pro každý záznam vyhodnocení použije hodnocení agenta Mosaic AI podmnožinu porotců, které nejlépe odpovídají informacím přítomným v záznamu. Konkrétně:

• Pokud záznam obsahuje odpověď založenou na skutečnosti, použije vyhodnocení agenta kritéria hodnocení context_sufficiency, groundedness, correctness, safetya guideline_adherence.
• Pokud záznam neobsahuje odpověď základní pravdy, použije vyhodnocení agenta chunk_relevance, groundedness, relevance_to_query, safetya guideline_adherence soudce.

Další podrobnosti najdete tady:

• Spustit podmnožinu předdefinovaných porotců
• vlastní porotci umělé inteligence
• Jak jsou kvalita, náklady a latence hodnoceny Agentem pro hodnocení

Informace o důvěře a bezpečnosti LLM soudce najdete v tématu Informace o modelech, které pohánějí LLM soudce.

Příklad: Předání aplikace do vyhodnocení agenta

Pokud chcete předat aplikaci mlflow_evaluate(), použijte model argument. Existuje 5 možností předání aplikace v argumentu model .

• Model zaregistrovaný v katalogu Unity
• Model protokolování MLflow v aktuálním experimentu MLflow.
• Model PyFunc načtený do poznámkového bloku
• Místní funkce v poznámkovém bloku
• Koncový bod nasazeného agenta.

Příklady kódu ilustrující jednotlivé možnosti najdete v následujících částech.

Možnost 1. Model zaregistrovaný v katalogu 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",
)

Možnost 2. Protokolovaný model MLflow v aktuálním experimentu 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",
)

Možnost 3. Model PyFunc načtený v poznámkovém bloku

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

Možnost 4. Místní funkce v poznámkovém bloku

Funkce obdrží vstup formátovaný následujícím způsobem:

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

Funkce musí vrátit hodnotu v jednom z následujících tří podporovaných formátů:

• Prostý řetězec obsahující odpověď modelu.

• Slovník ve ChatCompletionResponse formátu. Příklad:

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

• Slovník ve StringResponse formátu, například { "content": "MLflow is a machine learning toolkit.", ... }.

Následující příklad používá místní funkci k zabalení základního koncového bodu modelu a jeho vyhodnocení:

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

Možnost 5. Nasazený koncový bod agenta

Tato možnost funguje jenom v případě, že používáte koncové body agenta nasazené pomocí databricks.agents.deploy a s databricks-agents verzí 0.8.0 sady SDK nebo vyšší. V případě základních modelů nebo starších verzí sady SDK použijte možnost 4 k zabalení modelu do místní funkce.

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

Jak úspěšně projít vyhodnocovací sadou, když je aplikace zahrnuta do volání mlflow_evaluate().

V následujícím kódu data je datový rámec pandas s vaší testovací sadou. Jedná se o jednoduché příklady. Podrobnosti najdete ve vstupním schématu .

# 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()

Příklad: Předání dříve vygenerovaných výstupů do vyhodnocení agenta

Tato část popisuje, jak předat dříve vygenerované výstupy ve mlflow_evaluate() volání. Pro požadované schéma sady hodnocení se podívejte na Vstupní schéma hodnocení agenta.

V následujícím kódu je data datový rámec pandas s vaší testovací sadou a výstupy vygenerovanými aplikací. Jedná se o jednoduché příklady. Podrobnosti najdete ve vstupním schématu .

%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",
            },
        ],
        "guidelines": [
          "The response must be in English",
        ]
    }]

# 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()

Příklad: Použití vlastní funkce ke zpracování odpovědí z LangGraphu

Agenti langgraphu, zejména ti, kteří mají funkci chatu, můžou vrátit více zpráv pro jedno volání odvozování. Je zodpovědností uživatele převést odpověď agenta na formát, který hodnocení agenta podporuje.

Jedním z přístupů je použití vlastní funkce ke zpracování odpovědi. Následující příklad ukazuje vlastní funkci, která extrahuje poslední chatovou zprávu z modelu LangGraph. Tato funkce se pak použije v mlflow.evaluate() k vrácení jedné řetězcové odpovědi, která se dá porovnat s ground_truth sloupcem.

Ukázkový kód provede následující předpoklady:

• Model přijímá vstup ve formátu {"messages": [{"role": "user", "content": "hello"}]}.
• Model vrátí seznam řetězců ve formátu ["response 1", "response 2"].

Následující kód odešle zřetězené odpovědi soudce v tomto formátu: "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)

Vytvoření řídicího panelu s metrikami

Při iteraci kvality agenta můžete chtít sdílet řídicí panel se zúčastněnými stranami, které ukazují, jak se kvalita v průběhu času zlepšila. Metriky můžete extrahovat ze spuštění vyhodnocení MLflow, uložit hodnoty do tabulky Delta a vytvořit řídicí panel.

Následující příklad ukazuje, jak extrahovat a uložit hodnoty metrik z posledního testovacího spuštění v poznámkovém bloku:

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

Následující příklad ukazuje, jak extrahovat a uložit hodnoty metrik pro minulé spuštění, která jste uložili v experimentu 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}")

Teď můžete pomocí těchto dat vytvořit řídicí panel.

Následující kód definuje funkci append_metrics_to_table , která se používá v předchozích příkladech.

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

Informace o modelech, které nutí soudce LLM

• Porotci LLM můžou k vyhodnocení aplikací GenAI, včetně Azure OpenAI provozovaných Microsoftem, používat služby třetích stran.
• Pro Azure OpenAI se Databricks odhlásila z monitorování zneužití, takže se v Azure OpenAI neukládají žádné výzvy ani odpovědi.
• V případě pracovních prostorů Evropské unie (EU) používají porotci LLM modely hostované v EU. Všechny ostatní oblasti používají modely hostované v USA.
• Zakázání funkcí usnadnění AI využívajících Azure AI brání soudce LLM v volání modelů využívajících Azure AI.
• Data odesílaná do soudce LLM se nepoužívají pro trénování modelu.
• Porotci LLM mají pomoct zákazníkům vyhodnotit jejich aplikace RAG a výstupy soudce LLM by neměly být použity k trénování, zlepšování nebo vyladění LLM.