Partilhar via

Avalie modelos de linguagem grandes com MLflow

  • Artigo

Este artigo apresenta o MLflow LLM Evaluate, a funcionalidade de avaliação de modelo de linguagem grande (LLM) do MLflow empacotada em mlflow.evaluate. Este artigo também descreve o que é necessário para avaliar seu LLM e quais métricas de avaliação são suportadas.

O que é o MLflow LLM Evaluate?

A avaliação do desempenho do LLM é ligeiramente diferente dos modelos tradicionais de ML, pois muitas vezes não há uma única verdade de base para comparar. O MLflow fornece uma API mlflow.evaluate() para ajudar a avaliar seus LLMs.

A funcionalidade de avaliação LLM do MLflow consiste em três componentes principais:

  • Um modelo para avaliar: pode ser um modelo MLflow, um DataFrame com uma coluna de previsões, um URI que aponta para um modelo MLflow pyfunc registrado ou qualquer Python chamável que represente seu modelo, como um pipeline de resumo de texto HuggingFace.
  • Métricas: as métricas para calcular, LLM avaliar usa métricas LLM.
  • Dados de avaliação: os dados em que o seu modelo é avaliado, podem ser um Pandas DataFrame, uma lista Python, uma matriz ou uma mlflow.data.dataset.Datasetnumpy instância.

Requisitos

  • MLflow 2.8 e superior.
  • Para avaliar o seu LLM com mlflow.evaluate()o , o seu LLM tem de ser um dos seguintes:
    • Uma mlflow.pyfunc.PyFuncModel instância ou um URI apontando para um modelo registrado mlflow.pyfunc.PyFuncModel .
    • Uma função Python personalizada que recebe entradas e saídas de cadeia de caracteres em uma única cadeia de caracteres. O seu chamável deve corresponder à assinatura de mlflow.pyfunc.PyFuncModel.predict sem argumento params . A função deve:
      • Tenha data como único argumento, que pode ser uma pandas.Dataframenumpy.ndarray, , lista Python, dicionário ou matriz scipy.
      • Retornar uma das seguintes opções: pandas.DataFrame, , pandas.Seriesnumpy.ndarray ou lista.
    • Um conjunto de dados estático.

Avaliar com um modelo MLflow

Você pode avaliar seu LLM como um modelo MLflow. Para obter instruções detalhadas sobre como converter seu modelo em uma mlflow.pyfunc.PyFuncModel instância, consulte como criar um modelo pyfunc personalizado.

Para avaliar seu modelo como um modelo MLflow, o Databricks recomenda seguir estas etapas:

Nota

Para registrar com êxito um modelo direcionado ao Serviço OpenAI do Azure, você deve especificar as seguintes variáveis de ambiente para autenticação e funcionalidade. Consulte a documentação do OpenAI com MLflow para obter mais detalhes.

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. Empacote seu LLM como um modelo MLflow e registre-o no servidor MLflow usando log_modelo . Cada sabor (opeanai, , ...) tem sua própria log_model API, pytorchcomomlflow.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. Use o URI do modelo registrado como a instância do modelo em mlflow.evaluate():

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

Avaliar com uma função personalizada

No MLflow 2.8.0 e superior, mlflow.evaluate() suporta a avaliação de uma função Python sem exigir que o modelo seja registrado no MLflow. Isso é útil quando você não quer registrar o modelo e apenas deseja avaliá-lo. O exemplo a seguir usa mlflow.evaluate() para avaliar uma função.

Você também precisa configurar a autenticação OpenAI para executar o seguinte código:

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

Avaliar com um conjunto de dados estático

Para MLflow 2.8.0 e superior, mlflow.evaluate() suporta a avaliação de um conjunto de dados estático sem especificar um modelo. Isso é útil quando você salva a saída do modelo em uma coluna em um Pandas DataFrame ou um MLflow PandasDataset e deseja avaliar o conjunto de dados estático sem executar novamente o modelo.

Defina model=Nonee coloque as saídas do data modelo no argumento. Esta configuração só é aplicável quando os dados são um Pandas DataFrame.

Se você estiver usando um Pandas DataFrame, deverá especificar o nome da coluna que contém a saída do modelo usando o parâmetro de nível predictions superior em 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}")

Tipos de métricas de avaliação LLM

Existem dois tipos de métricas de avaliação LLM no MLflow:

  • Métricas que dependem de modelos SaaS, como OpenAI, para pontuação, como mlflow.metrics.genai.answer_relevance. Essas métricas são criadas usando mlflow.metrics.genai.make_genai_metric()o . Para cada registro de dados, essas métricas enviam um prompt que consiste nas seguintes informações para o modelo SaaS e extraem a pontuação da resposta do modelo.
    • Definição de métricas.
    • Critérios de classificação de métricas.
    • Exemplos de referência.
    • Dados de entrada ou contexto.
    • Saída do modelo.
    • [opcional] Fundamentar a verdade.
  • Métricas por linha baseadas em funções. Essas métricas calculam uma pontuação para cada registro de dados (linha em termos de Pandas ou Spark DataFrame), com base em determinadas funções, como Rouge, ou Flesch Kincaid,mlflow.metrics.rougeLmlflow.metrics.flesch_kincaid_grade_level. Essas métricas são semelhantes às métricas tradicionais.

Selecione métricas para avaliar seu LLM

Você pode selecionar quais métricas avaliar seu modelo. A referência completa para métricas de avaliação suportadas pode ser encontrada na documentação de avaliação MLflow.

Pode:

  • Use as métricas padrão predefinidas para o seu tipo de modelo.
  • Use uma lista personalizada de métricas.

Para usar métricas padrão para tarefas pré-selecionadas, especifique o model_type argumento em mlflow.evaluate, conforme mostrado pelo exemplo abaixo:

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

A tabela resume os tipos de modelo LLM suportados e as métricas padrão associadas.

question-answering text-summarization text
correspondência-exata ROUGE† toxicidade*
toxicidade* toxicidade* ari_grade_level**
ari_grade_level** ari_grade_level** flesch_kincaid_grade_level**
flesch_kincaid_grade_level** flesch_kincaid_grade_level**

*Requer avaliação de pacote, lanterna e transformadores.

**Requer textstat do pacote.

†Requer avaliação de pacote, nltk e rouge-score.

Usar uma lista personalizada de métricas

Você pode especificar uma lista personalizada de métricas no extra_metrics argumento em mlflow.evaluate.

Para adicionar métricas adicionais à lista de métricas padrão do tipo de modelo predefinido, mantenha o model_type parâmetro e adicione suas métricas ao extra_metrics. O seguinte avalia seu modelo usando todas as métricas para o question-answering modelo e mlflow.metrics.latency().

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

Para desativar o cálculo de métricas padrão e calcular apenas as métricas selecionadas, remova o model_type argumento e defina as métricas desejadas.

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

Métricas com LLM como juiz

Você também pode adicionar métricas pré-definidas que usam LLM como juiz ao extra_metrics argumento em mlflow.evaluate(). Para obter uma lista desses LLM como as métricas do juiz, consulte Métricas com LLM como o juiz.

Nota

Você também pode criar LLM personalizado como o juiz e métricas de avaliação baseadas em heurística.

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

Ver resultados da avaliação

mlflow.evaluate() Devolve os resultados da avaliação como uma mlflow.models.EvaluationResult instância.

Para ver a pontuação nas métricas selecionadas, você pode verificar os seguintes atributos do resultado da avaliação:

  • metrics: Isso armazena os resultados agregados, como média ou variância em todo o conjunto de dados de avaliação. O seguinte faz uma segunda passagem no exemplo de código acima e se concentra na impressão dos resultados agregados.

    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']: Armazena os resultados da avaliação por linha.

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

Avaliação LLM com notebook de exemplo MLflow

A avaliação LLM a seguir com o notebook de exemplo MLflow é um exemplo orientado a casos de uso.

Avaliação LLM com notebook de exemplo MLflow

Obter o bloco de notas