Pipeline de avaliação baseado em computação

É possível avaliar o desempenho dos modelos de base e dos modelos de IA generativa ajustados na Vertex AI. Os modelos são avaliados usando um conjunto de métricas em relação a um conjunto de dados de avaliação fornecido por você. Nesta página, explicamos como funciona a avaliação de modelos baseada em computação por meio do serviço de pipeline de avaliação, como criar e formatar o conjunto de dados de avaliação e como executar a avaliação usando o console do Google Cloud, a API Vertex AI ou o SDK da Vertex AI para Python.

Como funciona a avaliação de modelo baseado em computação

Para avaliar o desempenho de um modelo, primeiro você cria um conjunto de dados de avaliação que contém prompts e pares de informações empíricas. Para cada par, a entrada é a que você quer avaliar, e a informação empírica é a resposta ideal para ela. Durante a avaliação, o comando em cada par do conjunto de dados de avaliação é transmitido ao modelo para produzir uma saída. A saída gerada pelo modelo e as informações empíricas do conjunto de dados de avaliação são usadas para calcular as métricas de avaliação.

O tipo de métrica usada para avaliação depende da tarefa que você está avaliando. A tabela a seguir mostra as tarefas compatíveis e as métricas usadas para avaliar cada tarefa:

Tarefa Métrica
Classificação Micro-F1, Macro-F1, por classe F1
Geração de resumos ROUGE-L
Respostas a perguntas Correspondência exata
Geração de texto BLEU, ROUGE-L

Modelos compatíveis

A avaliação de modelo é compatível com as versões base e ajustada de text-bison.

Preparar conjunto de dados de avaliação

O conjunto de dados usado para avaliar o modelo inclui pares de comandos e informações empíricas que se alinham à tarefa que você quer avaliar. Seu conjunto de dados precisa incluir no mínimo um par de comandos e informações empíricas e pelo menos 10 pares para métricas significativas. Quanto mais exemplos, mais significativos serão os resultados.

Formato do conjunto de dados

O conjunto de dados de avaliação precisa estar emLinhas JSON (JSONL), em que cada linha contém um único par de prompt e de informações empíricas especificado no input_text e output_text respectivamente. O campo input_text contém o comando que você quer avaliar, e o campo output_text contém a resposta ideal para esse comando.

O tamanho máximo do token para input_text é 8.192, e o comprimento máximo do token para output_text é 1.024.

Fazer upload do conjunto de dados de avaliação para o Cloud Storage

É possível criar um novo bucket do Cloud Storage ou usar um atual para armazenar o arquivo do conjunto de dados. O bucket precisa estar na mesma região que o gatilho.

Quando o bucket estiver pronto, faça o upload do arquivo do conjunto de dados para o bucket.

Fazer avaliação de modelo.

É possível avaliar modelos usando a API REST ou o console do Google Cloud.

REST

Para criar um job de avaliação de modelo, envie uma solicitação POST usando o método pipelineJobs.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_ID: o projeto do Google Cloud que executa os componentes do pipeline.
  • PIPELINEJOB_DISPLAYNAME: um nome de exibição do pipelineJob.
  • LOCATION: a região para executar os componentes do pipeline. Atualmente, somente us-central1 é aceito.
  • DATASET_URI: o URI do Cloud Storage do conjunto de dados de referência. É possível especificar um ou vários URIs. Esse parâmetro é compatível com caracteres curinga. Para saber mais sobre esse parâmetro, consulte InputConfig.
  • OUTPUT_DIR: o URI do Cloud Storage para armazenar a saída da avaliação.
  • MODEL_NAME: especifique um modelo de editor ou um recurso de modelo ajustado da seguinte maneira:
    • Modelo do editor: publishers/google/models/MODEL@MODEL_VERSION

      Exemplo: publishers/google/models/text-bison@001

    • Modelo ajustado: projects/PROJECT_NUMBER/locations/LOCATION/models/ENDPOINT_ID

      Exemplo: projects/123456789012/locations/us-central1/models/1234567890123456789

    O job de avaliação não afeta as implantações atuais do modelo ou os recursos dele.

  • EVALUATION_TASK: a tarefa em que você quer avaliar o modelo. O job de avaliação calcula um conjunto de métricas relevantes para essa tarefa específica. Os valores aceitáveis são os seguintes:
    • summarization
    • question-answering
    • text-generation
    • classification
  • INSTANCES_FORMAT: o formato do conjunto de dados. Atualmente, somente jsonl é aceito. Para saber mais sobre esse parâmetro, consulte InputConfig.
  • PREDICTIONS_FORMAT: o formato da saída da avaliação. Atualmente, somente jsonl é aceito. Para saber mais sobre esse parâmetro, consulte InputConfig.
  • MACHINE_TYPE: (opcional) o tipo de máquina para executar o job de avaliação. O valor padrão é e2-highmem-16. Para uma lista de tipos de máquina compatíveis, consulte Tipos de máquina.
  • SERVICE_ACCOUNT: (opcional) a conta de serviço a ser usada para executar o job de avaliação. Para saber como criar uma conta de serviço personalizada, consulte Configurar uma conta de serviço com permissões granulares. Se não for especificado, será usado o agente de serviço de código personalizado da Vertex AI.
  • NETWORK: (opcional) o nome totalmente qualificado da rede do Compute Engine para fazer o peering do job de avaliação. O formato do nome da rede é projects/PROJECT_NUMBER/global/networks/NETWORK_NAME. Se você especificar esse campo, será necessário ter um peering de rede VPC para a Vertex AI. Se não for especificado, o job de avaliação não fará peering com nenhuma rede.
  • KEY_NAME: (opcional) o nome da chave de criptografia gerenciada pelo cliente (CMEK, na sigla em inglês). Se configurados, os recursos criados pelo job de avaliação são criptografados usando a chave de criptografia fornecida. O formato do nome da chave é projects/PROJECT_ID/locations/REGION/keyRings/KEY_RING/cryptoKeys/KEY. A chave precisa estar na mesma região que o job de avaliação.

Método HTTP e URL: 

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/pipelineJobs

Corpo JSON da solicitação:

{
  "displayName": "PIPELINEJOB_DISPLAYNAME",
  "runtimeConfig": {
    "gcsOutputDirectory": "gs://OUTPUT_DIR",
    "parameterValues": {
      "project": "PROJECT_ID",
      "location": "LOCATION",
      "batch_predict_gcs_source_uris": ["gs://DATASET_URI"],
      "batch_predict_gcs_destination_output_uri": "gs://OUTPUT_DIR",
      "model_name": "MODEL_NAME",
      "evaluation_task": "EVALUATION_TASK",
      "batch_predict_instances_format": "INSTANCES_FORMAT",
      "batch_predict_predictions_format: "PREDICTIONS_FORMAT",
      "machine_type": "MACHINE_TYPE",
      "service_account": "SERVICE_ACCOUNT",
      "network": "NETWORK",
      "encryption_spec_key_name": "KEY_NAME"
    }
  },
  "templateUri": "https://us-kfp.pkg.dev/vertex-evaluation/pipeline-templates/evaluation-llm-text-generation-pipeline/1.0.1"
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/pipelineJobs"

PowerShell

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/pipelineJobs" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a seguinte. Observe que pipelineSpec foi truncado para economizar espaço.

Exemplo de comando curl

PROJECT_ID=myproject
REGION=us-central1
MODEL_NAME=publishers/google/models/text-bison@001
TEST_DATASET_URI=gs://my-gcs-bucket-uri/dataset.jsonl
OUTPUT_DIR=gs://my-gcs-bucket-uri/output

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
"https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${REGION}/pipelineJobs" -d \
$'{
  "displayName": "evaluation-llm-text-generation-pipeline",
  "runtimeConfig": {
    "gcsOutputDirectory": "'${OUTPUT_DIR}'",
    "parameterValues": {
      "project": "'${PROJECT_ID}'",
      "location": "'${REGION}'",
      "batch_predict_gcs_source_uris": ["'${TEST_DATASET_URI}'"],
      "batch_predict_gcs_destination_output_uri": "'${OUTPUT_DIR}'",
      "model_name": "'${MODEL_NAME}'",
    }
  },
  "templateUri": "https://us-kfp.pkg.dev/vertex-evaluation/pipeline-templates/evaluation-llm-text-generation-pipeline/1.0.1"
}'

Python

Para saber como instalar ou atualizar o Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API Python. 


from google.auth import default
import vertexai
from vertexai.preview.language_models import (
    EvaluationTextClassificationSpec,
    TextGenerationModel,
)

# Set credentials for the pipeline components used in the evaluation task
credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])

def evaluate_model(
    project_id: str,
    location: str,
) -> object:
    """Evaluate the performance of a generative AI model."""

    vertexai.init(project=project_id, location=location, credentials=credentials)

    # Create a reference to a generative AI model
    model = TextGenerationModel.from_pretrained("text-bison@002")

    # Define the evaluation specification for a text classification task
    task_spec = EvaluationTextClassificationSpec(
        ground_truth_data=[
            "gs://cloud-samples-data/ai-platform/generative_ai/llm_classification_bp_input_prompts_with_ground_truth.jsonl"
        ],
        class_names=["nature", "news", "sports", "health", "startups"],
        target_column_name="ground_truth",
    )

    # Evaluate the model
    eval_metrics = model.evaluate(task_spec=task_spec)
    print(eval_metrics)

    return eval_metrics

Console

Para criar um job de avaliação de modelo usando o console do Google Cloud, execute as seguintes etapas:

  1. No console do Google Cloud, acesse a página do Vertex AI Model Registry.

    Acessar o Vertex AI Model Registry

  2. Clique no nome do modelo que você quer avaliar.
  3. Na guia Avaliar, clique em Criar avaliação e configure da seguinte maneira:
    • Objetivo: selecione a tarefa que você quer avaliar.
    • Coluna ou campo de destino: (apenas classificação) insira a coluna de destino para previsão. Exemplo: ground_truth.
    • Caminho de origem: insira ou selecione o URI do conjunto de dados de avaliação.
    • Formato de saída: insira o formato da saída da avaliação. Atualmente, somente jsonl é aceito.
    • Caminho do Cloud Storage: insira ou selecione o URI para armazenar a saída da avaliação.
    • Nomes de classes: (apenas classificação) digite a lista de possíveis nomes de classes.
    • Número de nós de computação: digite o número de nós de computação para executar o job de avaliação.
    • Tipo de máquina: selecione um tipo de máquina a ser usado para executar o job de avaliação.
  4. Clique em Iniciar avaliação.

Visualizar os resultados da avaliação

Encontre os resultados da avaliação no diretório de saída do Cloud Storage especificado ao criar o job de avaliação. O nome do arquivo é evaluation_metrics.json.

Para modelos ajustados, também é possível conferir os resultados da avaliação no console do Google Cloud:

  1. Na seção "Vertex AI" do console do Google Cloud, acesse a página Vertex AI Model Registry.

    Acessar o Vertex AI Model Registry

  2. Clique no nome do modelo para visualizar as métricas de avaliação.

  3. Na guia Avaliar, clique no nome da execução da avaliação que você quer visualizar.

A seguir