Ausführen einer Auswertung und Anzeigen der Ergebnisse (MLflow 2)

Dieser Artikel beschreibt, wie Sie bei der Entwicklung Ihrer KI-Anwendung eine Evaluierung ausführen und sich die Ergebnisse ansehen können. Informationen zum Überwachen der bereitgestellten Agents finden Sie unter Monitor GenAI in der Produktion.

Zum Auswerten eines Agents müssen Sie einen Auswertungssatz angeben. Ein Auswertungssatz besteht mindestens aus einer Reihe von Anforderungen an Ihre Anwendung, die entweder aus einem kuratierten Satz von Auswertungsanforderungen oder aus Ablaufverfolgungen von benutzenden Personen des Agents stammen können. Weitere Informationen finden Sie unter Evaluation Sets (MLflow 2) und Agent Evaluation Input Schema (MLflow 2).

Ausführen einer Auswertung

Um eine Evaluierung auszuführen, verwenden Sie die Methode mlflow.evaluate() aus der MLflow-API. Geben Sie dabei model_type als databricks-agent an, um die Agenten-Evaluierung auf Databricks und integrierte KI-Judges zu aktivieren.

Im folgenden Beispiel wird eine Reihe globaler Antwortrichtlinien für den KI-Richter für globale Richtlinien angegeben, durch die bei der Auswertung ein Fehler auftritt, wenn Antworten nicht den Richtlinien entsprechen. Sie müssen keine Kennzeichnungen pro Anfrage sammeln, um Ihren Agenten mit diesem Ansatz zu evaluieren.

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

Ergebnisse sind auf der Registerkarte Ablaufverfolgungen der Seite „MLflow-Ausführung“ verfügbar:

In diesem Beispiel werden die folgenden Judges ausgeführt, die keine Kennzeichnungen für die Grundrichtigkeit benötigen: Einhaltung von Richtlinien, Relevanz für Abfrage, Sicherheit.

Wenn Sie einen Agenten mit einem Retriever verwenden, werden die folgenden Judges ausgeführt: Grundrichtigkeit, Relevanz für Abfrage

mlflow.evaluate() berechnet außerdem Latenz- und Kostenmetriken für jeden Auswertungsdatensatz und aggregiert Ergebnisse für alle Eingaben für eine bestimmte Ausführung. Diese werden als Auswertungsergebnisse bezeichnet. Die Ergebnisse der Evaluierung werden in der einschließenden Ausführung protokolliert, zusammen mit Informationen, die von anderen Befehlen protokolliert werden, wie z. B. die Modellparameter. Wenn Sie mlflow.evaluate() außerhalb einer MLflow-Ausführung aufrufen, wird eine neue Ausführung erstellt.

Evaluierung mit Grundrichtigkeits-Kennzeichnungen

Im folgenden Beispiel werden die Kennzeichnungen für die Grundrichtigkeit pro Zeile angegeben: expected_facts und guidelines, die die Judges für Korrektheit bzw. Richtlinien ausführen. Einzelne Auswertungen werden mithilfe von Grundwahrheitsbezeichnungen separat pro Zeile behandelt.

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

In diesem Beispiel werden die gleichen Judges wie oben ausgeführt, zusätzlich zu den folgenden: Korrektheit, Relevanz, Sicherheit

Wenn Sie einen Agent mit einem Abrufer verwenden, wird der folgende Richter ausgeführt: Zulänglichkeit des Kontexts

Anforderungen

Partnergestützte KI-Features müssen für Ihren Arbeitsbereich aktiviert sein.

Bereitstellen von Eingaben für einen Auswertungslauf

Es gibt zwei Möglichkeiten zum Bereitstellen von Eingaben für einen Auswertungslauf:

• Stellen Sie zuvor generierte Ausgaben bereit, die mit dem Auswertungssatz verglichen werden sollen. Diese Option wird empfohlen, wenn Sie die Ergebnisse einer Anwendung auswerten möchten, die bereits in der Produktion bereitgestellt wurde, oder wenn Sie die Evaluierungsergebnisse zwischen verschiedenen Evaluierungskonfigurationen vergleichen möchten.

  Mit dieser Option legen Sie ein Evaluierung-Set fest, wie im folgenden Code gezeigt. Der Auswertungssatz muss zuvor generierte Ausgaben enthalten. Ausführlichere Beispiele finden Sie unter Beispiel: Übergeben zuvor generierter Ausgaben an die Agent-Auswertung.

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

• Übergeben Sie die Anwendung als Eingabeargument. mlflow.evaluate() ruft die Anwendung für jede Eingabe im Auswertungssatz auf und meldet Qualitätsbewertungen sowie andere Metriken für jede generierte Ausgabe. Diese Option wird empfohlen, wenn Ihre Anwendung mithilfe von MLflow mit aktivierter MLflow-Ablaufverfolgung protokolliert wurde oder wenn Ihre Anwendung als Python-Funktion in einem Notizbuch implementiert wird. Diese Option wird nicht empfohlen, wenn Ihre Anwendung außerhalb von Databricks entwickelt wurde oder außerhalb von Databricks bereitgestellt wird.

  Mit dieser Option legen Sie das Evaluierungs-Set und die Anwendung im Funktionsaufruf fest, wie im folgenden Code gezeigt. Ausführlichere Beispiele finden Sie unter Beispiel: Übergabe einer Anwendung an die Agentenevaluierung.

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

Ausführliche Informationen zum Bewertungssatzschema finden Sie unter Agent Evaluation Input Schema (MLflow 2).

Auswertungsausgaben

Die Agent-Auswertung gibt ihre Ausgaben von mlflow.evaluate() als Datenrahmen zurück und protokolliert diese Ausgaben auch in der MLflow-Ausführung. Sie können die Ausgaben im Notizbuch oder von der Seite der entsprechenden MLflow-Ausführung überprüfen.

Überprüfen der Ausgabe im Notebook

Der folgende Code zeigt einige Beispiele zum Überprüfen der Ergebnisse einer Auswertung aus Ihrem Notizbuch.

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

Der per_question_results_df-Dataframe enthält alle Spalten des Eingabeschemas und alle Evaluierungsergebnisse, die für jede Anfrage spezifisch sind. Weitere Informationen zu den berechneten Ergebnissen finden Sie unter Wie Qualität, Kosten und Latenz durch die Agentenbewertung beurteilt werden (MLflow 2).

Überprüfen der Ausgabe mithilfe der MLflow-Benutzeroberfläche

Die Ergebnisse der Evaluierung sind auch in der MLflow-Benutzeroberfläche verfügbar. Um auf die MLflow-Benutzeroberfläche zuzugreifen, klicken Sie auf das Symbol in der rechten Seitenleiste des Notizbuchs und anschließend auf den entsprechenden Lauf oder auf die Links, die in den Ergebnissen der Zelle angezeigt werden, in der Sie die Ausführung durchgeführt haben mlflow.evaluate().

Überprüfen der Auswertungsergebnisse für eine einzelne Ausführung

In diesem Abschnitt wird beschrieben, wie Sie die Ergebnisse der Evaluierung für eine einzelne Ausführung überprüfen können. Um die Ergebnisse verschiedener Ausführungen zu vergleichen, lesen Sie Vergleichen der die Evaluierungsergebnisse verschiedener Ausführungen.

Übersicht über Qualitätsbewertungen durch LLM-Richter

Richterbewertungen pro Anfrage sind in databricks-agents Version 0.3.0 und höher verfügbar.

Um eine Übersicht über die LLM-bewertete Qualität jeder Anforderung im Evaluierungssatz anzuzeigen, klicken Sie auf der Seite „MLflow-Ausführung“ auf die Registerkarte Ablaufverfolgungen.

)

Diese Übersicht zeigt die Bewertungen verschiedener Richter für jede Anforderung und den Qualitätspass-/Fail-Status jeder Anforderung basierend auf diesen Bewertungen.

Klicken Sie für weitere Details auf eine Zeile in der Tabelle, um die Detailseite für diese Anforderung anzuzeigen. Auf der Detailseite können Sie auf Detaillierte Ablaufverfolgungsansicht anzeigen klicken.

Aggregation der Ergebnisse für das gesamte Evaluierungs-Set

Um die aggregierten Ergebnisse des gesamten Evaluierungs-Sets zu sehen, klicken Sie auf die Registerkarte Übersicht (für numerische Werte) oder die Registerkarte Modellmetriken (für Diagramme).

Vergleichen von Auswertungsergebnissen über Ausführungen hinweg

Es ist wichtig, auswertungsübergreifende Ergebnisse zu vergleichen, um zu sehen, wie Ihre agentische Anwendung auf Änderungen reagiert. Ein Vergleich der Ergebnisse kann Ihnen helfen zu verstehen, ob sich Ihre Änderungen positiv auf die Qualität auswirken, oder Ihnen bei der Fehlerbehebung helfen, wenn sich das Verhalten ändert.

Verwenden Sie die Seite "MLflow Experiment", um ergebnisseübergreifend zu vergleichen. Um auf die Experimentseite zuzugreifen, klicken Sie auf das Symbol " in der rechten Randleiste des Notizbuchs, oder klicken Sie auf die Links, die in den Zellenergebnissen für die Notizbuchzelle angezeigt werden, in der Sie ausgeführt haben mlflow.evaluate().

Vergleichen von Ergebnissen pro Anforderung bei allen Ausführungen

Zum Vergleichen von Daten für jede einzelne Anforderung über verschiedene Ausführungen hinweg klicken Sie auf das in folgendem Screenshot gezeigte Symbol der Artefaktauswertungsansicht. Eine Tabelle zeigt jede Frage im Auswertungssatz an. Verwenden Sie die Dropdownmenüs, um die anzuzeigenden Spalten auszuwählen. Klicken Sie auf eine Zelle, um den vollständigen Inhalt anzuzeigen.

Aggregierte Ergebnisse über mehrere Ausführungen hinweg vergleichen

Wenn Sie aggregierte Ergebnisse für eine Ausführung oder unterschiedliche Läufe vergleichen möchten, klicken Sie auf das Diagrammansichtssymbol, das im folgenden Screenshot gezeigt wird. Dies bietet Ihnen die Möglichkeit, die aggregierten Ergebnisse für die ausgewählte Ausführung zu visualisieren und mit früheren Ausführungen zu vergleichen.

Ausgeführte Richter

Standardmäßig wendet Mosaic KI Agent Evaluation für jede Untermenge von Judges an, die am besten zu den im Datensatz vorhandenen Informationen passt. Dies gilt insbesondere in folgenden Fällen:

• Wenn der Datensatz eine Grundwahrheitsantwort enthält, wendet die Agent-Auswertung die Richter context_sufficiency, groundedness, correctness, safety und guideline_adherence an.
• Enthält der Datensatz keine Grundwahrheit-Antwort, wendet die Agentenevaluation die chunk_relevance, groundedness, relevance_to_query, safety und guideline_adherence Judges an.

Weitere Informationen finden Sie unter:

• Ausführen einer Teilmenge der integrierten Richter
• Benutzerdefinierte KI-Richter
• Wie Qualität, Kosten und Latenz von Agent Evaluation (MLflow 2) bewertet werden

Informationen in Bezug auf die Vertrauensstellung und Sicherheit der LLM-Richter finden Sie unter Informationen zu den Modellen, auf denen die LLM-Richter basieren.

Beispiel: Übergeben einer Anwendung an die Agent-Auswertung

Um eine Anwendung an mlflow_evaluate() übergeben, verwenden Sie das Argument model. Es gibt 5 Optionen für die Übergabe einer Anwendung im model-Argument.

• Ein in Unity Catalog registriertes Modell.
• Ein in MLflow protokolliertes Modell im aktuellen MLflow-Experiment.
• Ein PyFunc-Modell, das im Notebook geladen ist.
• Eine lokale Funktion im Notebook.
• Ein bereitgestellter Agent-Endpunkt.

In den folgenden Abschnitten finden Sie Code-Beispiele, die die einzelnen Optionen veranschaulichen.

Option 1: Im Unity-Katalog registriertes Modell

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

Option 2. Protokolliertes MLflow-Modell im aktuellen MLflow-Experiment

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

Option 3. PyFunc-Modell, das in das Notebook geladen wird

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

Option 4. Lokale Funktion im Notebook

Die Funktion erhält eine Eingabe, die wie folgt formatiert ist:

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

Die Funktion muss einen Wert in einer einfachen Zeichenfolge oder einem serialisierbaren Wörterbuch (z. B Dict[str, Any]. ) zurückgeben. Für optimale Ergebnisse mit den integrierten Richtern empfiehlt Databricks die Verwendung eines Chatformats wie z. B. ChatCompletionResponse. Zum Beispiel:

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

Das folgende Beispiel verwendet eine lokale Funktion, um einen Endpunkt des Basismodells zu verpacken und zu evaluieren:

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

Option 5. Bereitgestellter Agent-Endpunkt

Diese Option funktioniert nur, wenn Sie Agentendpunkte verwenden, die mit databricks.agents.deploy und mit databricks-agents sdk-Version 0.8.0 oder höher bereitgestellt wurden. Für Basismodelle oder ältere SDK-Versionen verwenden Sie Option 4, um das Modell in eine lokale Funktion zu verpacken.

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

So legen Sie das Evaluierungsset fest, wenn die Anwendung in den mlflow_evaluate()-Aufruf eingebunden ist

Im folgenden Code ist data ein Pandas-DataFrame mit Ihrem Auswertungssatz. Dies sind einfache Beispiele. Siehe das Eingabeschema für weitere Details.

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

Beispiel: Übergeben zuvor erstellter Ausgaben an die Agent-Auswertung

In diesem Abschnitt wird beschrieben, wie zuvor generierte Ausgaben im mlflow_evaluate()-Aufruf übergeben werden. Informationen zum erforderlichen Evaluierungsschema finden Sie unter Agent Evaluation Input Schema (MLflow 2).

Im folgenden Code ist data ein Pandas-DataFrame mit Ihrem Auswertungssatz und Ausgaben, die von der Anwendung generiert werden. Dies sind einfache Beispiele. Siehe das Eingabeschema für weitere Details.

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

Beispiel: Verwenden Sie eine angepasste Funktion, um Antworten von LangGraph zu verarbeiten

LangGraph-Agenten, insbesondere solche mit Chat-Funktionalität, können mehrere Nachrichten für einen einzigen Ableitungsaufruf zurückgeben. Es liegt in der Verantwortung des Benutzers, die Antwort des Agents in ein Format zu konvertieren, das die Agentauswertung unterstützt.

Eine Möglichkeit besteht darin, eine angepasste Funktion zu verwenden, um die Antwort zu verarbeiten. Das folgende Beispiel zeigt eine angepasste Funktion, die die letzte Chat-Nachricht aus einem LangGraph-Modell extrahiert. Diese Funktion wird dann in mlflow.evaluate() verwendet, um eine einzelne Zeichenfolge als Antwort zurückzugeben, die mit der Spalte ground_truth verglichen werden kann.

Der Code des Beispiels geht von den folgenden Annahmen aus:

• Das Modell akzeptiert Eingaben im Format {"Nachrichten": [{"Rolle": "benutzende Person", "Inhalt": "hello"}]}.
• Das Modell gibt eine Liste von Zeichenfolgen im Format [“response 1”, “response 2”] zurück.

Der folgende Code sendet die verketteten Antworten in diesem Format an den Judge: “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)

Erstellen eines Dashboards mit Metriken

Wenn Sie sich mit der Qualität Ihres Agenten beschäftigen, möchten Sie Ihren Interessengruppen vielleicht ein Dashboard zur Verfügung stellen, das zeigt, wie sich die Qualität im Laufe der Zeit verbessert hat. Sie können die Metriken aus Ihren MLflow-Evaluierungsausführungen extrahieren, die Werte in einer Delta-Tabelle speichern und ein Dashboard erstellen.

Das folgende Beispiel zeigt, wie Sie die Werte der Metriken aus dem letzten Evaluierungslauf in Ihr Notebook extrahieren und speichern:

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

Das folgende Beispiel zeigt, wie Sie Metrik-Werte für vergangene Ausführungsläufe, die Sie in Ihrem MLflow-Experiment gespeichert haben, extrahieren und speichern können.

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

Mit diesen Daten können Sie nun ein Dashboard erstellen.

Der folgende Code definiert die Funktion append_metrics_to_table, die in den vorherigen Beispielen verwendet wird.

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

Informationen zu den Modellen, die die LLM-Richter unterstützen

• LLM-Richter verwenden möglicherweise Dienste von Drittanbietern, um Ihre GenAI-Anwendungen zu bewerten, einschließlich Azure OpenAI, betrieben von Microsoft.
• Für Azure OpenAI ist in Databricks die Missbrauchsüberwachung deaktiviert, sodass keine Prompts oder Antworten in Azure OpenAI gespeichert werden.
• Für Arbeitsbereiche der Europäischen Union (EU) verwenden LLM-Richter Modelle, die in der EU gehostet werden. Alle anderen Regionen verwenden Modelle, die in den USA gehostet werden.
• Das Deaktivieren partnergestützter KI-Features verhindert, dass der LLM-Richter Partnermodelle aufruft. Sie können LLM-Richter weiterhin verwenden, indem Sie Ihr eigenes Modell bereitstellen.
• LLM-Richter sollen Kunden helfen, ihre GenAI-Agenten/Anwendungen zu bewerten, und LLM-Beurteilungsergebnisse sollten nicht verwendet werden, um eine LLM zu trainieren, zu verbessern oder zu optimieren.