Ocena dużych modeli językowych za pomocą biblioteki MLflow

W tym artykule przedstawiono funkcję oceny MLflow LLM, funkcję oceny dużego modelu językowego (LLM) platformy MLflow spakowane w pliku mlflow.evaluate. W tym artykule opisano również, co jest potrzebne do oceny usługi LLM i obsługiwanych metryk oceny.

Co to jest MLflow LLM Evaluate?

Ocena wydajności usługi LLM różni się nieco od tradycyjnych modeli uczenia maszynowego, ponieważ bardzo często nie ma jednej podstawowej prawdy do porównania. Rozwiązanie MLflow udostępnia interfejs API, mlflow.evaluate() aby pomóc ocenić swoje maszyny LLM.

Funkcja oceny LLM MLflow składa się z trzech głównych składników:

• Model do oceny: może to być model MLflow, ramka danych z kolumną przewidywania, identyfikator URI wskazujący jeden zarejestrowany model MLflow pyfunc lub dowolny element wywołujący język Python reprezentujący model, taki jak potok podsumowania tekstu HuggingFace.
• Metryki: metryki do obliczenia, ocena llM używa metryk LLM.
• Dane oceny: dane, na których jest oceniany model, mogą to być ramki danych Pandas, listy języka Python, numpy tablicy lub mlflow.data.dataset.Dataset wystąpienia.

Wymagania

• MLflow 2.8 i nowsze.
• Aby ocenić usługę LLM za pomocą mlflow.evaluate()polecenia , twój moduł LLM musi być jednym z następujących elementów:
  • mlflow.pyfunc.PyFuncModel Wystąpienie lub identyfikator URI wskazujący zarejestrowany mlflow.pyfunc.PyFuncModel model.
  • Niestandardowa funkcja języka Python, która pobiera dane wejściowe ciągów i generuje pojedynczy ciąg. Element wywołujący musi być zgodny z mlflow.pyfunc.PyFuncModel.predict podpisem bez argumentu params . Funkcja powinna:
    • Mają data jako jedyny argument, który może być macierzą , numpy.ndarray, listą języka Python, słownikiem pandas.Dataframelub scipy.
    • Zwróć jedną z następujących wartości: pandas.DataFrame, pandas.Serieslub numpy.ndarray listy.
  • Statyczny zestaw danych.

Ocena za pomocą modelu MLflow

Możesz ocenić model LLM jako model MLflow. Aby uzyskać szczegółowe instrukcje dotyczące sposobu konwertowania modelu na mlflow.pyfunc.PyFuncModel wystąpienie, zobacz jak utworzyć niestandardowy model pyfunc.

Aby ocenić model jako model MLflow, usługa Databricks zaleca wykonanie następujących kroków:

Uwaga

Aby pomyślnie zarejestrować model przeznaczony dla usługi Azure OpenAI Service, należy określić następujące zmienne środowiskowe na potrzeby uwierzytelniania i funkcjonalności. Aby uzyskać więcej informacji, zobacz dokumentację interfejsu OpenAI z platformą 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. Spakuj model LLM jako model MLflow i zarejestruj go na serwerze MLflow przy użyciu polecenia log_model. Każdy smak (opeanai, pytorch, ...) ma własny log_model interfejs API, taki jak 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. Użyj identyfikatora URI zarejestrowanego modelu jako wystąpienia modelu w programie mlflow.evaluate():

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

Ocena za pomocą funkcji niestandardowej

W środowisku MLflow 2.8.0 lub nowszym mlflow.evaluate() obsługuje ocenę funkcji języka Python bez konieczności rejestrowania modelu w usłudze MLflow. Jest to przydatne, gdy nie chcesz rejestrować modelu i po prostu chcesz go ocenić. W poniższym przykładzie użyto mlflow.evaluate() metody do oceny funkcji.

Należy również skonfigurować uwierzytelnianie OpenAI, aby uruchomić następujący kod:

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

Ocena przy użyciu statycznego zestawu danych

W przypadku platformy MLflow 2.8.0 lub nowszej mlflow.evaluate() obsługuje ocenę statycznego zestawu danych bez określania modelu. Jest to przydatne podczas zapisywania danych wyjściowych modelu w kolumnie w ramce danych Biblioteki Pandas lub bibliotece MLflow PandasDataset i chcesz ocenić statyczny zestaw danych bez ponownego uruchamiania modelu.

Ustaw model=Nonewartość , i umieść dane wyjściowe modelu w argumencie data . Ta konfiguracja ma zastosowanie tylko wtedy, gdy dane są ramką danych Biblioteki Pandas.

Jeśli używasz ramki danych Pandas, musisz określić nazwę kolumny, która zawiera dane wyjściowe modelu przy użyciu parametru najwyższego poziomu predictions w pliku mlflow.evaluate():

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

Typy metryk oceny llM

W usłudze MLflow istnieją dwa typy metryk oceny usługi LLM:

• Metryki korzystające z modeli SaaS, takich jak OpenAI, do oceniania, takich jak mlflow.metrics.genai.answer_relevance. Te metryki są tworzone przy użyciu polecenia mlflow.metrics.genai.make_genai_metric(). Dla każdego rekordu danych te metryki wysyłają jeden monit zawierający następujące informacje do modelu SaaS i wyodrębnij wynik z odpowiedzi modelu.
  • Definicja metryk.
  • Kryteria klasyfikacji metryk.
  • Przykłady odwołań.
  • Dane wejściowe lub kontekst.
  • Dane wyjściowe modelu.
  • [opcjonalnie] Prawda naziemna.
• Metryki na podstawie funkcji na wiersz. Te metryki obliczają wynik dla każdego rekordu danych (wiersz pod względem biblioteki Pandas lub Spark DataFrame) na podstawie niektórych funkcji, takich jak Rouge, mlflow.metrics.rougeLlub Flesch Kincaid,mlflow.metrics.flesch_kincaid_grade_level . Te metryki są podobne do tradycyjnych metryk.

Wybieranie metryk w celu oceny usługi LLM

Możesz wybrać metryki do oceny modelu. Pełną dokumentację dotyczącą obsługiwanych metryk oceny można znaleźć w dokumentacji oceny platformy MLflow.

Można:

• Użyj domyślnych metryk, które są wstępnie zdefiniowane dla typu modelu.
• Użyj niestandardowej listy metryk.

Aby użyć metryk domyślnych dla wstępnie wybranych zadań, określ model_type argument w mlflow.evaluatepliku , jak pokazano w poniższym przykładzie:

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

Tabela zawiera podsumowanie obsługiwanych typów modeli LLM i skojarzonych domyślnych metryk.

question-answering	text-summarization	text
dokładne dopasowanie	ROUGE†	Toksyczności*
Toksyczności*	Toksyczności*	ari_grade_level**
ari_grade_level**	ari_grade_level**	flesch_kincaid_grade_level**
flesch_kincaid_grade_level**	flesch_kincaid_grade_level**

*Wymaga oceny, pochodni i transformatorów pakietu.

**Wymaga parametru textstat pakietu.

†Wymaga oceny pakietu, nltk i rouge-score.

Używanie niestandardowej listy metryk

Możesz określić niestandardową listę metryk w argumencie w mlflow.evaluatepliku extra_metrics .

Aby dodać dodatkowe metryki do domyślnej listy metryk wstępnie zdefiniowanego typu modelu, zachowaj model_type parametr i dodaj metryki do elementu extra_metrics. Poniżej przedstawiono ocenę modelu przy użyciu wszystkich metryk dla question-answering modelu i mlflow.metrics.latency().

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

Aby wyłączyć domyślne obliczenie metryk i obliczyć tylko wybrane metryki, usuń model_type argument i zdefiniuj żądane metryki.

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

Metryki z funkcją LLM jako sędzia

Do argumentu w elememencie można również dodać metryki wstępnie w puszkach, które używają funkcji LLM jako sędziego do argumentu w pliku extra_metricsmlflow.evaluate(). Aby uzyskać listę tych funkcji LLM jako metryki sędziego, zobacz Metryki z llm jako sędzia.

Uwaga

Możesz również utworzyć niestandardowe metryki oceny llM jako sędziego i heurystycznego.

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

Wyświetlanie wyników oceny

mlflow.evaluate() zwraca wyniki oceny jako mlflow.models.EvaluationResult wystąpienie.

Aby wyświetlić wynik dla wybranych metryk, możesz sprawdzić następujące atrybuty wyniku oceny:

• metrics: Przechowuje zagregowane wyniki, takie jak średnia lub wariancja w zestawie danych oceny. Poniższy kod przyjmuje drugie przekazanie powyższego przykładu kodu i koncentruje się na drukowaniu zagregowanych wyników.

  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']: przechowuje wyniki oceny poszczególnych wierszy.

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

Przykładowa ocena llM za pomocą przykładowego notesu MLflow

Poniższy przykład oceny LLM z przykładowym notesem MLflow jest przykładem przypadku użycia.

Przykładowa ocena llM za pomocą przykładowego notesu MLflow

Pobierz notes