Avalie grandes modelos de linguagem usando o MLflow de código aberto

Este artigo descreve como usar o código aberto MLflow LLM funcionalidade de avaliação mlflow.evaluate(). Este artigo também descreve o que é necessário para avaliar seu LLM usando o código aberto MLflow e quais métricas de avaliação são suportadas.

O que é a avaliação do MLflow LLM?

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

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

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

Requisitos

• MLflow 2.8 e acima.
• Para avaliar seu LLM com mlflow.evaluate(), seu LLM deve ser um dos seguintes:

  • Uma instância mlflow.pyfunc.PyFuncModel ou um URI que aponta para um modelo mlflow.pyfunc.PyFuncModel de registros.

  • Uma função Python personalizada que recebe entradas de strings e gera uma única string. Seu callable deve corresponder à assinatura de mlflow.pyfunc.PyFuncModel.predict sem um argumento params. A função deve:

    • Tem data como único argumento, que pode ser um pandas.Dataframe, numpy.ndarray, lista Python, dicionário ou matriz scipy.
    • Retorne uma das seguintes opções: pandas.DataFrame, pandas.Series, numpy.ndarray ou list.

  • Um site estático dataset.

Avaliar com um modelo MLflow

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

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

nota

Para ter êxito em log um modelo voltado para o serviço Azure OpenAI, o senhor 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.

Python

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. pacote seu LLM como um modelo MLflow e log para o servidor MLflow usando log_model. Cada variante (opeanai, pytorch, ...) tem sua própria API log_model, como mlflow.openai.log_model():

   Python

   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 dos modelos registrados como a instância do modelo em mlflow.evaluate():

   Python

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

Avalie com uma função personalizada

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

O senhor também precisa configurar a autenticação da OpenAI para executar o seguinte código:

Python

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 sistema estático dataset

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

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

Se estiver usando um Pandas DataFrame, o senhor deve especificar o nome da coluna que contém a saída do modelo usando o parâmetro de nível superior predictions em mlflow.evaluate():

Python

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 do LLM

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

• métricas que dependem de modelos SaaS, como o OpenAI, para pontuação como mlflow.metrics.genai.answer_relevance. Essas métricas são criadas usando o site mlflow.metrics.genai.make_genai_metric(). 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.
  • Insira dados ou contexto.
  • Saída do modelo.
  • [opcional] Verdade fundamental.

• 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, mlflow.metrics.rougeL, ou Flesch Kincaid,mlflow.metrics.flesch_kincaid_grade_level. Essas métricas são semelhantes às métricas tradicionais.

Selecione métricas para avaliar seu LLM

O senhor pode selecionar quais métricas avaliarão seu modelo. A referência completa das métricas de avaliação compatíveis pode ser encontrada na documentação do MLflow evaluate.

Você também pode:

• Use as default métricas predefinidas para seu tipo de modelo.
• Usar uma lista personalizada de métricas.

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

Python

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

A tabela resume os tipos de modelos compatíveis do LLM e as métricas associadas do default.

question-answering	text-summarization	text
combinação exata	VERMELHO †	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 do pacote, maçarico e transformadores.

** Requer o pacote textstat.

† Requer pacote evaluate, nltk e rouge-score.

Usar uma lista personalizada de métricas

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

Para adicionar métricas adicionais à lista default métricas de tipo de modelo predefinido, mantenha o parâmetro model_type e adicione suas métricas a extra_metrics. A seguir, o senhor avalia seu modelo usando todas as métricas do modelo question-answering e mlflow.metrics.latency().

Python

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

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

Python

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

métricas com LLM como juiz

O senhor também pode adicionar métricas pré-planejadas que usam o LLM como juiz para o argumento extra_metrics em mlflow.evaluate(). Para obter uma lista dessas métricas LLM como juiz, consulte métricas com LLM como juiz.

nota

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

Python

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

visualizar os resultados da avaliação

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

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

• metrics: Armazena os resultados agregados, como a média ou a variação da avaliação dataset. A seguir, o senhor faz uma segunda análise do exemplo de código acima e se concentra na impressão dos resultados agregados.

  Python

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

  Python

  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 Avaliação com exemplo Notebook MLflow

A seguinte avaliação do LLM com o Notebook de exemplo MLflow é um exemplo orientado a casos de uso.

LLM Avaliação com MLflow exemplo Notebook

Open notebook in new tab