Auswerten großer Sprachmodelle mit MLflow

In diesem Artikel wird MLflow LLM Evaluate, eine Funktion von MLflow für die Auswertung großer Sprachmodelle (Large Language Model, LLM) vorgestellt, die in mlflow.evaluate verpackt ist. In diesem Artikel wird außerdem beschrieben, was für die Auswertung Ihrer LLM erforderlich ist und welche Auswertungsmetriken unterstützt werden.

Was ist MLflow LLM Evaluate?

Die Auswertung der LLM-Leistung unterscheidet sich geringfügig von herkömmlichen ML-Modellen, da es oft keine einzige Grundwahrheit gibt, mit der verglichen werden kann. MLflow stellt die API mlflow.evaluate() für die Auswertung Ihrer LLMs bereit.

Die LLM-Auswertungsfunktion von MLflow besteht aus drei Hauptkomponenten:

• Auszuwertendes Modell: Es kann sich um ein MLflow-pyfunc-Modell, einen Datenrahmen mit einer Vorhersagespalte, einen URI, der auf ein registriertes MLflow-Modell verweist, oder ein aufrufbares Python-Element handeln, das Ihr Modell darstellt, z. B. eine HuggingFace-Textzusammenfassungspipeline.
• Metriken: Die zu berechnenden Metriken. Von LLM werden für die Auswertung LLM-Metriken verwendet.
• Auswertungsdaten: Die Daten, anhand derer Ihr Modell ausgewertet wird. Es kann es sich dabei um einen Pandas-Datenrahmen, eine Python-Liste, ein numpy-Array oder eine mlflow.data.dataset.Dataset-Instanz handeln.

Anforderungen

• MLflow 2.8 und höher
• Damit Ihr LLM mit mlflow.evaluate() ausgewertet werden kann, muss es sich bei Ihrem LLM um Folgendes handeln:
  • Eine mlflow.pyfunc.PyFuncModel-Instanz oder ein URI, der auf ein protokolliertes mlflow.pyfunc.PyFuncModel-Modell verweist
  • Eine benutzerdefinierte Python-Funktion, die Zeichenfolgeneingaben akzeptiert und eine einzelne Zeichenfolge ausgibt. Ihr aufrufbares Element muss mit der Signatur von mlflow.pyfunc.PyFuncModel.predict ohne params-Argument übereinstimmen. Für die Funktion muss Folgendes gelten:
    • Sie muss data als einziges Argument enthalten (kann pandas.Dataframe, numpy.ndarray, eine Python-Liste, ein Wörterbuch oder eine SciPy-Matrix sein).
    • Sie gibt einen der folgende Werte zurück: pandas.DataFrame, pandas.Series, numpy.ndarray oder eine Liste.
  • Ein statisches Dataset

Auswerten mit einem MLflow-Modell

Sie können Ihr LLM als MLflow-Modell auswerten. Ausführliche Anweisungen zum Konvertieren ihres Modells in eine mlflow.pyfunc.PyFuncModel-Instanz finden Sie unter Erstellen eines benutzerdefinierten Pyfunc-Modells.

Um Ihr Modell als MLflow-Modell auszuwerten, empfiehlt Databricks die folgenden Schritte:

Hinweis

Um ein Modell für den Azure OpenAI Service erfolgreich zu protokollieren, müssen Sie die folgenden Umgebungsvariablen für Authentifizierung und Funktionalität angeben. Weitere Details finden Sie in der Dokumentation zu OpenAI mit MLflow.

os.environ["OPENAI_API_TYPE"] = "azure"
os.environ["OPENAI_API_VERSION"] = "2023-05-15"
os.environ["OPENAI_API_BASE"] = "https://<>.<>.<>.com/"
os.environ["OPENAI_DEPLOYMENT_NAME"] = "deployment-name"

1. Packen Sie Ihr LLM als MLflow-Modell, und protokollieren Sie es mithilfe von log_model auf dem MLflow-Server. Jede Variante (opeanai, pytorch, …) hat eine eigene log_model-API, z. B. mlflow.openai.log_model():

   with mlflow.start_run():
       system_prompt = "Answer the following question in two sentences"
       # Wrap "gpt-3.5-turbo" as an MLflow model.
       logged_model_info = mlflow.openai.log_model(
           model="gpt-3.5-turbo",
           task=openai.ChatCompletion,
           artifact_path="model",
           messages=[
               {"role": "system", "content": system_prompt},
               {"role": "user", "content": "{question}"},
           ],
       )
   

2. Verwenden Sie den URI des protokollierten Modells als Modellinstanz in mlflow.evaluate():

   results = mlflow.evaluate(
       logged_model_info.model_uri,
       eval_data,
       targets="ground_truth",
       model_type="question-answering",
   )
   

Auswerten mit einer benutzerdefinierten Funktion

In MLflow 2.8.0 und höher unterstützt mlflow.evaluate() die Auswertung einer Python-Funktion, ohne dass das Modell in MLflow protokolliert werden muss. Dies ist nützlich, wenn Sie das Modell nicht protokollieren, sondern nur auswerten möchten. Im folgenden Beispiel wird mlflow.evaluate() zum Auswerten einer Funktion verwendet.

Sie müssen auch die OpenAI-Authentifizierung einrichten, um den folgenden Code auszuführen:

eval_data = pd.DataFrame(
    {
        "inputs": [
            "What is MLflow?",
            "What is Spark?",
        ],
        "ground_truth": [
            "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 openai_qa(inputs):
    answers = []
    system_prompt = "Please answer the following question in formal language."
    for index, row in inputs.iterrows():
        completion = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": "{row}"},
            ],
        )
        answers.append(completion.choices[0].message.content)

    return answers

with mlflow.start_run() as run:
    results = mlflow.evaluate(
        openai_qa,
        eval_data,
        model_type="question-answering",
    )

Auswerten mit einem statischen Dataset

Für MLflow 2.8.0 und höher unterstützt mlflow.evaluate() die Auswertung eines statischen Datasets ohne Angabe eines Modells. Dies ist nützlich, wenn Sie die Modellausgabe in einer Spalte in einem Pandas-Datenrahmen oder MLflow PandasDataset speichern und das statische Dataset auswerten möchten, ohne das Modell erneut auszuführen.

Legen Sie model=None fest, und platzieren Sie die Modellausgabe im Argument data. Diese Konfiguration gilt nur, wenn es sich bei den Daten um einen Pandas-Datenrahmen handelt.

Wenn Sie einen Pandas-Datenrahmen verwenden, müssen Sie den Spaltennamen angeben, der die Modellausgabe enthält, indem Sie den Parameter predictions der obersten Ebene in mlflow.evaluate() verwenden:

import mlflow
import pandas as pd

eval_data = pd.DataFrame(
    {
        "inputs": [
            "What is MLflow?",
            "What is Spark?",
        ],
        "ground_truth": [
            "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",
        ],
        "predictions": [
            "MLflow is an open-source platform that provides handy tools to manage Machine Learning workflow "
            "lifecycle in a simple way",
            "Spark is a popular open-source distributed computing system designed for big data processing and analytics.",
        ],
    }
)

with mlflow.start_run() as run:
    results = mlflow.evaluate(
        data=eval_data,
        targets="ground_truth",
        predictions="predictions",
        extra_metrics=[mlflow.metrics.genai.answer_similarity()],
        evaluators="default",
    )
    print(f"See aggregated evaluation results below: \n{results.metrics}")

    eval_table = results.tables["eval_results_table"]
    print(f"See evaluation table below: \n{eval_table}")

Typen von LLM-Auswertungsmetriken

Es gibt zwei Typen von LLM-Auswertungsmetriken in MLflow:

• Metriken, die sich bei der Bewertung auf SaaS-Modelle wie OpenAI stützen, z. B. mlflow.metrics.genai.answer_relevance. Diese Metriken werden mithilfe von mlflow.metrics.genai.make_genai_metric() erstellt. Diese Metriken senden für jeden Datensatz einen Prompt, der aus den folgenden Informationen besteht, an das SaaS-Modell und extrahieren den Score aus der Modellantwort.
  • Metrikdefinition
  • Bewertungskriterien für Metriken
  • Referenzbeispiele
  • Eingabedaten oder Kontext
  • Modellausgabe
  • [optional] Grundwahrheit
• Funktionsbasierte Metriken pro Zeile. Diese Metriken berechnen einen Score für jeden Datensatz (Zeile in Bezug auf Pandas- oder Spark-Datenrahmen) basierend auf bestimmten Funktionen wie Rouge (mlflow.metrics.rougeL) oder Flesch Kincaid (mlflow.metrics.flesch_kincaid_grade_level). Diese Metriken ähneln herkömmlichen Metriken.

Auswählen von Metriken zum Auswerten Ihres LLM

Sie können auswählen, welche Metriken Ihr Modell auswerten sollen. Die vollständige Referenz zu unterstützten Auswertungsmetriken finden Sie in der MLflow Evaluate-Dokumentation.

Sie haben folgende Möglichkeiten:

• Verwenden Sie die Standardmetriken, die für Ihren Modelltyp vordefiniert sind.
• Verwenden Sie eine benutzerdefinierte Liste mit Metriken.

Um Standardmetriken für vorausgewählte Vorgänge zu verwenden, geben Sie das Argument model_type in mlflow.evaluate an, wie im folgenden Beispiel gezeigt:

results = mlflow.evaluate(
    model,
    eval_data,
    targets="ground_truth",
    model_type="question-answering",
)

In der Tabelle werden die unterstützten LLM-Modelltypen und die zugehörigen Standardmetriken zusammengefasst.

question-answering	text-summarization	text
exact-match	ROUGE†	toxicity*
toxicity*	toxicity*	ari_grade_level**
ari_grade_level**	ari_grade_level**	flesch_kincaid_grade_level**
flesch_kincaid_grade_level**	flesch_kincaid_grade_level**

* Erfordert die Pakete evaluate, torch und transformers.

** Erfordert das Paket textstat.

† Erfordert die Pakete evaluate, nltk und rouge-score.

Verwenden einer benutzerdefinierten Liste mit Metriken

Sie können eine benutzerdefinierte Liste mit Metriken im Argument extra_metrics in mlflow.evaluate angeben.

Wenn Sie der Standardmetrikliste des vordefinierten Modelltyps zusätzliche Metriken hinzufügen möchten, behalten Sie den Parameter model_type bei, und fügen Sie die Metriken zu extra_metrics hinzu. Im Folgenden wird Ihr Modell mit allen Metriken für das question-answering-Modell und mlflow.metrics.latency() ausgewertet.

results = mlflow.evaluate(
    model,
    eval_data,
    targets="ground_truth",
    model_type="question-answering",
    extra_metrics=[mlflow.metrics.latency()],
)

Um die Berechnung von Standardmetriken zu deaktivieren und nur die ausgewählten Metriken zu berechnen, entfernen Sie das Argument model_type, und definieren Sie die gewünschten Metriken.

results = mlflow.evaluate(model,
                          eval_data,
                          targets="ground_truth",
                          extra_metrics=[mlflow.metrics.toxicity(), mlflow.metrics.latency()],
                        )

Metriken mit LLM als Beurteilung

Sie können auch vorkonfigurierte Metriken hinzufügen, die LLM als Beurteilung für das Argument extra_metrics in mlflow.evaluate() verwenden. Eine Liste dieser LLM als Beurteilungsmetriken finden Sie unter Metriken mit LLM als Beurteilung.

Hinweis

Sie können auch benutzerdefinierte LLM als Beurteilung und Auswertungsmetriken auf Heuristikbasis erstellen.

from  mlflow.metrics.genai import answer_relevance

answer_relevance_metric = answer_relevance(model="openai:/gpt-4")

eval_df = pd.DataFrame() # Index(['inputs', 'predictions', 'context'], dtype='object')

eval_results = mlflow.evaluate(
    data = eval_df, # evaluation data
    model_type="question-answering",
    predictions="predictions", # prediction column_name from eval_df
    extra_metrics=[answer_relevance_metric]
)

Anzeigen der Auswertungsergebnisse

mlflow.evaluate() gibt die Auswertungsergebnisse als mlflow.models.EvaluationResult-Instanz zurück.

Um den Score für ausgewählte Metriken anzuzeigen, können Sie die folgenden Attribute des Auswertungsergebnisses überprüfen:

• metrics: Damit werden die aggregierten Ergebnisse wie Durchschnitt oder Varianz im Auswertungsdatensatz gespeichert. Im Folgenden wird das obige Codebeispiel ein zweites Mal durchlaufen, wobei der Schwerpunkt auf der Ausgabe der aggregierten Ergebnisse liegt.

  with mlflow.start_run() as run:
      results = mlflow.evaluate(
          data=eval_data,
          targets="ground_truth",
          predictions="predictions",
          extra_metrics=[mlflow.metrics.genai.answer_similarity()],
          evaluators="default",
      )
      print(f"See aggregated evaluation results below: \n{results.metrics}")
  

• tables['eval_results_table']: Damit werden die Auswertungsergebnisse pro Zeile gespeichert.

  with mlflow.start_run() as run:
      results = mlflow.evaluate(
          data=eval_data,
          targets="ground_truth",
          predictions="predictions",
          extra_metrics=[mlflow.metrics.genai.answer_similarity()],
          evaluators="default",
      )
      print(
          f"See per-data evaluation results below: \n{results.tables['eval_results_table']}"
      )
  

LLM-Auswertung mit MLflow-Beispiel-Notebook

Die folgende LLM-Auswertung mit MLflow-Beispielnotebook ist ein anwendungsorientiertes Beispiel.

LLM-Auswertung mit MLflow-Beispiel-Notebook

Notebook abrufen