Ajustar modelos de texto usando ajuste supervisionado

O ajuste supervisionado usa exemplos rotulados para ajustar um modelo. Cada exemplo demonstra a saída que você quer do seu modelo de texto durante a inferência. O ajuste supervisionado é uma boa opção quando a saída do modelo não é muito complexa e é fácil de definir.

Orientação passo a passo de ajuste supervisionado do modelo de texto

No tutorial guiado a seguir, você aprenderá a usar o ajuste supervisionado para ajustar um modelo de base de texto no console do Google Cloud.

Para seguir as instruções passo a passo desta tarefa diretamente no console do Google Cloud, clique em Orientação:

Orientações

Fluxo de trabalho para ajuste de modelos supervisionados

O fluxo de trabalho de ajuste de modelos supervisionados na Vertex AI inclui as seguintes etapas:

  1. Prepare o conjunto de dados de ajuste do modelo
  2. Faça o upload do conjunto de dados de ajuste do modelo em um bucket do Cloud Storage.
  3. Criar um job de ajuste de modelo supervisionado.

Depois que o ajuste do modelo é concluído, o modelo ajustado é implantado em um endpoint da Vertex AI. O nome do endpoint é igual ao nome do modelo ajustado. Os modelos ajustados estão disponíveis para seleção no Vertex AI Studio quando você quiser criar um novo comando.

Modelos compatíveis

Os seguintes modelos de fundação são compatíveis com ajustes supervisionados:

  • Geração de texto: text-bison@002 e text-bison-32k
  • Chat de texto: chat-bison@002 e chat-bison-32k
  • Geração de código: code-bison@002 e code-bison-32k
  • Chat de código: codechat-bison@002 e codechat-bison-32k
  • Embeddings de texto: textembedding-gecko@001 (prévia)

Casos de uso do ajuste supervisionado em modelos de texto

Os modelos de texto base funcionam bem quando a saída ou a tarefa esperada pode ser definida de maneira clara e concisa em um prompt e ele produza a saída esperada de maneira consistente. Se você quiser que um modelo aprenda algo nichado ou específico que se desloque dos padrões gerais de linguagem, convém ajustar esse modelo. Por exemplo, é possível usar o ajuste de modelo para ensinar o modelo a seguir:

  • Estruturas ou formatos específicos para gerar resultados.
  • Comportamentos específicos, como quando fornecer uma resposta final ou detalhada.
  • Resultados personalizados específicos para tipos específicos de entradas.

Os exemplos a seguir são casos de uso difíceis de capturar apenas com instruções imediatas:

  • Classificação: a resposta esperada é uma palavra ou frase específica.

    Ajustar o modelo pode impedir que ele gere respostas detalhadas.

  • Resumo: o resumo segue um formato específico. Por exemplo, talvez seja necessário remover informações de identificação pessoal (PII, na sigla em inglês) em um resumo do chat.

    Essa formatação de substituição dos nomes dos falantes por #Person1 e #Person2 é difícil de descrever, e o modelo de fundação pode não produzir naturalmente essa resposta.

  • Resposta de pergunta extrativa: a pergunta é sobre um contexto e a resposta é uma substring do contexto.

    :

    A resposta "Último máximo glacial" é uma frase específica do contexto.

  • Chat: você precisa personalizar a resposta do modelo para seguir um perfil, um papel ou um personagem.

Também é possível ajustar um modelo nas seguintes situações:

  • As solicitações não produzem os resultados esperados com consistência suficiente.
  • A tarefa é muito complicada de ser definida em um prompt. Por exemplo, você quer que o modelo faça clonagem de comportamento para um comportamento difícil de articular em um prompt.
  • Você tem uma intuição complexa sobre uma tarefa que é fácil de provocar, mas difícil de formalizar em um prompt.
  • Você quer reduzir a duração do contexto removendo os exemplos de poucas fotos.

Preparar um conjunto de dados de ajuste supervisionado

O conjunto de dados usado para ajustar um modelo de base precisa incluir exemplos alinhados à tarefa que você quer que o modelo execute. Estruture seu conjunto de dados de treinamento em um formato de texto para texto. Cada registro, ou linha, no conjunto de dados contém o texto de entrada (também chamado de prompt), que é combinado com a saída esperada do modelo. O ajuste supervisionado usa o conjunto de dados para ensinar o modelo a imitar um comportamento ou tarefa necessário, fornecendo a ele centenas de exemplos que ilustram esse comportamento.

Seu conjunto de dados precisa incluir no mínimo 10 exemplos, mas recomendamos pelo menos de 100 a 500 exemplos para ter bons resultados. Quanto mais exemplos você fornecer no conjunto de dados, melhores serão os resultados.

Para conjuntos de dados de amostra, consulte Conjuntos de dados de amostra nesta página.

Formato do conjunto de dados

O conjunto de dados de ajuste de modelos precisa estar no formato linhas JSON (JSONL) em que cada linha contém um único exemplo de ajuste. O formato do conjunto de dados usado para ajustar um modelo de geração de texto é diferente do formato do conjunto de dados usado para ajustar um modelo de chat de texto. Antes de ajustar o modelo, faça upload do conjunto de dados para um bucket do Cloud Storage.

Texto

Cada exemplo é composto por um campo input_text que contém a solicitação para o modelo e um campo output_text que contém uma resposta de exemplo que o modelo ajustado deverá produzir. Campos adicionais de prompts estruturados, como context, são ignorados.

O tamanho máximo do token para input_text é 8.192 e o comprimento máximo do token para output_text é 1.024. Se algum dos campos exceder o tamanho máximo do token, os tokens excedentes serão truncados.

O número máximo de exemplos que um conjunto de dados para um modelo de geração de texto pode conter é 10.000.

Exemplo de conjunto de dados

{"input_text": "question: How many people live in Beijing? context:
With over 21 million residents, Beijing is the world's most populous national
capital city and is China's second largest city after Shanghai. It is
located in Northern China, and is governed as a municipality under the direct
administration of the State Council with 16 urban, suburban, and rural
districts.[14] Beijing is mostly surrounded by Hebei Province with the exception
of neighboring Tianjin to the southeast; together, the three divisions form the
Jingjinji megalopolis and the national capital region of China.",
"output_text": "over 21 million people"}


{"input_text": "question: How many parishes are there in Louisiana? context:
The U.S. state of Louisiana is divided into 64 parishes (French: paroisses) in
the same manner that 48 other states of the United States are divided into
counties, and Alaska is divided into boroughs.", "output_text": "64"}

Incluir instruções em exemplos

Para tarefas como classificação, é possível criar um conjunto de dados de exemplos que não contenham instruções. No entanto, a exclusão de instruções dos exemplos no conjunto de dados leva a um desempenho pior após o ajuste do que a inclusão de instruções, especialmente para conjuntos de dados menores.

Não inclui instruções:

{"input_text": "5 stocks to buy now",
"output_text": "business"}

Inclui instruções:

{"input_text": "Classify the following text into one of the following classes:
[business, entertainment] Text: 5 stocks to buy now",
"output_text": "business"}

Chat

Cada exemplo de conversa em um conjunto de dados de ajuste de chat é composto por um campo messages (obrigatório) e um campo context (opcional).

O campo messages consiste em uma matriz de pares autor-conteúdo. O campo author refere-se ao autor da mensagem e está definido como user ou assistant de maneira alternada. O campo content é o conteúdo da mensagem. Cada exemplo de conversa precisa ter de dois a três pares de mensagens de assistente, que representam uma mensagem do usuário e uma resposta do modelo.

O campo context permite especificar um contexto para o chat. Se você especificar um contexto para um exemplo, ele vai substituir o valor fornecido em default_context.

Para cada exemplo de conversa, o comprimento máximo do token para context e messages combinados é de 8.192 tokens. Além disso, cada campo content para assistant não pode exceder 1.024 tokens.

O número máximo de campos author que os exemplos no conjunto de dados de um modelo de chat de texto podem conter é 10.000. Esse máximo é para a soma de todos os campos author em todos os messages em todos os exemplos.

Exemplo

{
  "context": "You are a pirate dog named Captain Barktholomew.",
  "messages": [
    {
      "author": "user",
      "content": "Hi"
    },
    {
      "author": "assistant",
      "content": "Argh! What brings ye to my ship?"
    },
    {
      "author": "user",
      "content": "What's your name?"
    },
    {
      "author": "assistant",
      "content": "I be Captain Barktholomew, the most feared pirate dog of the seven seas."
    }
  ]
}

Conjuntos de dados de amostra

Use um conjunto de dados de amostra para começar a ajustar o modelo de text-bison@002. Confira a seguir um conjunto de dados de tarefas de classificação que contém amostras de transcrições médicas de várias especialidades diferentes. Os dados são de mtsamples.com e foram disponibilizados no Kaggle.

  • Exemplo de URI do conjunto de dados de ajuste:

    gs://cloud-samples-data/vertex-ai/model-evaluation/peft_train_sample.jsonl

  • Exemplo de URI do conjunto de dados de avaliação:

    gs://cloud-samples-data/vertex-ai/model-evaluation/peft_eval_sample.jsonl

Para usar esses conjuntos de dados, especifique os URIs nos parâmetros aplicáveis ao criar um job de ajuste supervisionado de modelo de texto.

Exemplo:

...
"dataset_uri": "gs://cloud-samples-data/vertex-ai/model-evaluation/peft_train_sample.jsonl",
...
"evaluation_data_uri": "gs://cloud-samples-data/vertex-ai/model-evaluation/peft_eval_sample.jsonl",
...

Manter a consistência com os dados de produção

Os exemplos nos seus conjunto de dados precisam corresponder ao tráfego de produção esperado. Se o conjunto de dados contiver formatação, palavras-chave, instruções ou informações específicas, os dados de produção deverão ser formatados da mesma maneira e conter as mesmas instruções.

Por exemplo, se os exemplos no seu conjunto de dados incluem um "question:" e um "context:", o tráfego de produção também deve ser formatado para incluir um "question:" e um "context:" na mesma ordem em que aparece no exemplos de conjuntos de dados. Se você excluir o contexto, o modelo não reconhecerá o padrão, mesmo que a pergunta exata esteja em um exemplo no conjunto de dados.

Fazer upload de conjuntos de dados de ajuste para o Cloud Storage

Para executar um job de ajuste, é preciso fazer upload de um ou mais conjuntos de dados para um bucket do Cloud Storage. É possível criar um novo bucket do Cloud Storage ou usar um existente para armazenar arquivos de conjuntos de dados. A região do bucket não importa, mas recomendamos que você use um bucket que esteja no mesmo projeto do Google Cloud em que planeja executar o ajuste do modelo.

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

Configurações de região do ajuste supervisionado

É possível especificar três configurações de região do Google Cloud ao configurar um job de ajuste supervisionado. Uma região é onde o pipeline que ajusta o modelo é executado. A outra região é onde o job de ajuste do modelo é executado e o modelo ajustado é transferido.

Região do job do pipeline

A região do job do pipeline é onde esse job é executado. Se a região de upload do modelo opcional não for especificada, o modelo será transferido e implantado na região do job do pipeline. Os dados intermediários, como o conjunto de dados transformados, são armazenados na região do job do pipeline. Para saber quais regiões podem ser usadas como região do job do pipeline, consulte Regiões compatíveis de upload do modelo e job do pipeline. Especifique a região do job do pipeline usando um dos seguintes métodos:

  • Se você usar o SDK da Vertex AI, especifique a região onde o job do pipeline será executado usando o parâmetro tuning_job_location no método tune_model do objeto que representa o modelo que você ajustará (por exemplo, o método TextGenerationModel.tune_model).

  • Se você criar um job de ajuste supervisionado enviando uma solicitação POST com o método pipelineJobs.create, use o URL para especificar a região onde o job do pipeline será executado. No URL a seguir, substitua as duas instâncias de PIPELINE_JOB_REGION pela região onde o pipeline será executado:

     http://PIPELINE_JOB_REGION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/PIPELINE_JOB_REGION/pipelineJobs

  • Se você usar o console do Google Cloud para criar um job de ajuste de modelo supervisionado, especifique a região do job do pipeline no controle Região ao criar o job de ajuste. No console do Google Cloud, o controle Região especifica a região do job do pipeline e a região de upload do modelo. Quando você usa o console do Google Cloud para criar um job de ajuste de modelo supervisionado, as duas regiões são sempre iguais.

Região de upload do modelo

Use o parâmetro opcional tuned_model_location para especificar para onde o modelo ajustado será transferido. Se a região de upload do modelo não for especificada, o modelo ajustado será transferido para a região do job do pipeline. É possível usar uma das Regiões compatíveis de upload do modelo e job do pipeline como região de upload do modelo. É possível especificar a região de upload do modelo usando um dos seguintes métodos:

  • Se você usar o SDK da Vertex AI, o parâmetro tuned_model_location será especificado no método tune_model do objeto que representa o modelo que você ajustará (por exemplo, o método TextGenerationModel.tune_model).

  • Se você criar um job de ajuste de modelo supervisionado enviando uma solicitação POST com o método pipelineJobs, use o parâmetro location para especificar a região de upload do modelo.

  • Se você usar o console do Google Cloud para criar um job de ajuste de modelo supervisionado, especifique a região de upload do modelo no controle Região ao criar o job de ajuste. No console do Google Cloud, o controle Região especifica a região de upload do modelo e a região do job do pipeline. Quando você usa o console do Google Cloud para criar um job de ajuste de modelo supervisionado, as duas regiões são sempre iguais.

Região de ajuste do modelo

A região de ajuste do modelo é onde ocorre o processamento desse modelo. Essa região é determinada pelo tipo de acelerador escolhido. Se você especificar TPU como tipo de acelerador, o processamento do ajuste do modelo acontecerá em europe-west4. Se você especificar GPU como tipo de acelerador, o ajuste do modelo acontecerá em us-central1.

Regiões compatíveis de upload do modelo e job do pipeline

É possível usar uma das regiões a seguir para especificar a região de upload do modelo e a região do job do pipeline:

  • us-central1
  • europe-west4
  • asia-southeast1
  • us-west1
  • europe-west3
  • europe-west2
  • asia-northeast1
  • us-east4
  • us-west4
  • northamerica-northeast1
  • europe-west9
  • europe-west1
  • asia-northeast3

Criar um job de ajuste supervisionado de modelo de texto

É possível criar um job de ajuste de modelo de texto supervisionado usando o console do Google Cloud, a API ou o SDK da Vertex AI para Python. Para orientações sobre configurações de ajuste de modelos, consulte Configurações recomendadas.

REST

Para criar um job de ajuste do modelo, envie uma solicitação POST usando o método pipelineJobs. Alguns dos parâmetros não são compatíveis com todos os modelos. Inclua apenas os parâmetros aplicáveis ao modelo que você está ajustando.

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

  • PIPELINEJOB_DISPLAYNAME: um nome de exibição do pipelineJob.
  • OUTPUT_DIR: o URI do bucket de saída dos artefatos do pipeline.
  • PROJECT_ID: o ID do projeto.
  • MODEL_DISPLAYNAME: um nome de exibição do modelo enviado (criado) pelo pipelineJob.
  • DATASET_URI: URI do arquivo do conjunto de dados.
  • PIPELINE_JOB_REGION: a região onde o job de ajuste do pipeline é executado. Essa também é a região padrão para onde o modelo ajustado é transferido. Se você quiser fazer upload do modelo para uma região diferente, use o parâmetro location para especificar a região de upload do modelo ajustado. Para mais informações, consulte Região de upload do modelo.
  • MODEL_UPLOAD_REGION (opcional): a região para onde o modelo ajustado é transferido. Se você não especificar uma região de upload do modelo, o modelo ajustado será transferido para a mesma região onde o job do pipeline é executado. Para mais informações, consulte Região de upload do modelo.
  • ACCELERATOR_TYPE (opcional, GPU padrão): o tipo de acelerador a ser usado para ajuste do modelo. As opções válidas são:
    • GPU: usa oito GPUs A100 de 80 GB para ajuste. Verifique se você tem cota suficiente. Se você escolher GPU, o VPC‐SC será permitido. A CMEK será permitida se os locais de ajuste e de upload do modelo forem us-centra1. Para mais informações, consulte Configurações de região do ajuste supervisionado. Se você escolher GPU, os processamentos de ajuste do modelo acontecerão na região us-central1.
    • TPU: usa 64 núcleos do pod da TPU v3 para ajuste. Verifique se você tem cota suficiente. A CMEK não é permitida, mas sim o VPC‐SC. Se você escolher TPU, os processamentos de ajuste do modelo acontecerão na região europe-west4.
  • LARGE_MODEL_REFERENCE: nome do modelo de fundação a ser ajustado. As opções são:
    • text-bison@002
    • chat-bison@002
  • DEFAULT_CONTEXT (chat only): o contexto que se aplica a todos os exemplos de ajuste no conjunto de dados de ajuste. Definir o campo context em um exemplo substitui o contexto padrão.
  • STEPS: o número de etapas a serem executadas para o ajuste do modelo. O valor padrão é 300. O tamanho do lote varia de acordo com o local de ajuste e o tamanho do modelo. Para modelos 8k, como text-bison@002, chat-bison@002, code-bison@002 e codechat-bison@002:
    • us-central1 tem um tamanho de lote de 8.
    • europe-west4 tem um tamanho de lote de 24.
    Para modelos 32k, como text-bison-32k, chat-bison-32k, code-bison-32k e codechat-bison-32k:
    • us-central1 tem um tamanho de lote de 8.
    • europe-west4 tem um tamanho de lote de 8.

    Por exemplo, se você treinar text-bison@002 em europe-west4, haverá 240 exemplos em um conjunto de dados de treinamento e você definirá steps como 20, então o número de exemplos de treinamento será o produto de 20 etapas e o tamanho do lote de 24 ou 480 etapas de treinamento. Nesse caso, haverá dois períodos no processo de treinamento porque ele passará pelos exemplos duas vezes. Em us-central1, se houver 240 exemplos em um conjunto de dados de treinamento e você definir steps como 15, o número de exemplos de treinamento será o produto de 15 etapas e o tamanho do lote de 8 ou 120 etapas de treinamento. Nesse caso, haverá 0,5 período porque haverá metade do número de etapas de treinamento que o número de exemplos.

  • LEARNING_RATE_MULTIPLIER: um multiplicador para aplicar à taxa de aprendizado recomendada. Para usar a taxa de aprendizado recomendada, use 1.0.
  • EVAL_DATASET_URI (text only): (opcional) o URI do arquivo JSONL que contém o conjunto de dados de avaliação para previsão e avaliação em lote. Não há suporte à avaliação de chat-bison. Para mais informações, consulte Formato do conjunto de dados para ajustar um modelo de código. O conjunto de dados de avaliação requer de 10 a 250 exemplos.
  • EVAL_INTERVAL (text only): (opcional, 20 padrão) o número de etapas de ajuste entre cada avaliação. Um intervalo de avaliação não é compatível com modelos de chat. Como a avaliação é executada em todo o conjunto de dados de avaliação, um intervalo de avaliação menor resulta em um tempo de ajuste mais longo. Por exemplo, se steps for 200 e EVAL_INTERVAL for 100, você terá apenas dois pontos de dados para as métricas de avaliação. Esse parâmetro exige que a evaluation_data_uri seja definida.
  • ENABLE_EARLY_STOPPING (text only): (opcional, true padrão) uma boolean que, se definida como true, interrompe o ajuste antes de concluir todas as etapas de ajuste, se o desempenho do modelo for medido pela precisão dos tokens previstos, não melhora o suficiente entre as execuções de avaliações. Se false, o ajuste continuará até que todas as etapas de ajuste sejam concluídas. Esse parâmetro exige que a evaluation_data_uri seja definida. A ativação da parada antecipada não é compatível com modelos de chat.
  • TENSORBOARD_RESOURCE_ID: (opcional) o ID de uma instância do TensorBoard da Vertex AI. A instância do Vertex AI TensorBoard é usada para criar um experimento após a conclusão do job de ajuste. A instância do TensorBoard da Vertex AI precisa estar na mesma região do pipeline de ajuste.
  • ENCRYPTION_KEY_NAME: (opcional) o nome totalmente qualificado de uma chave de criptografia gerenciada pelo cliente (CMEK) que você quer usar para criptografia de dados. Uma CMEK está disponível apenas em us-central1. Se você usar us-central1 e não especificar uma CMEK, uma chave de criptografia gerenciada pelo Google será usada. Por padrão, uma chave de criptografia gerenciada pelo Google é usada em todas as outras regiões disponíveis. Para mais informações, consulte Visão geral de CMEK.
  • TEMPLATE_URI: o modelo de ajuste a ser usado depende do modelo que você está ajustando:
    • Modelo de texto: http://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0
    • Modelo de chat: http://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-chat-model/v3.0.0
  • SERVICE_ACCOUNT: (opcional) a conta de serviço que a Vertex AI usa para executar o job do pipeline. Por padrão, é usada a conta de serviço padrão do Compute Engine do projeto (PROJECT_NUMBER‑[email protected]). Saiba mais sobre como anexar uma conta de serviço personalizada.

Método HTTP e URL: 

POST http://PIPELINE_JOB_REGION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/PIPELINE_JOB_REGION/pipelineJobs

Corpo JSON da solicitação:

{
  "displayName": "PIPELINEJOB_DISPLAYNAME",
  "runtimeConfig": {
    "gcsOutputDirectory": "gs://OUTPUT_DIR",
    "parameterValues": {
      "project": "PROJECT_ID",
      "model_display_name": "MODEL_DISPLAYNAME",
      "dataset_uri": "gs://DATASET_URI",
      "location": "MODEL_UPLOAD_REGION",
      "accelerator_type": "ACCELERATOR_TYPE",
      "large_model_reference": "LARGE_MODEL_REFERENCE",
      "default_context": "DEFAULT_CONTEXT (chat only)",
      "train_steps": STEPS,
      "learning_rate_multiplier": LEARNING_RATE_MULTIPLIER,
      "evaluation_data_uri": "gs://EVAL_DATASET_URI (text only)",
      "evaluation_interval": EVAL_INTERVAL (text only),
      "enable_early_stopping": ENABLE_EARLY_STOPPING (text only),
      "enable_checkpoint_selection": "ENABLE_CHECKPOINT_SELECTION (text only)",
      "tensorboard_resource_id": "TENSORBOARD_ID",
      "encryption_spec_key_name": "ENCRYPTION_KEY_NAME"
    }
  },
  "encryptionSpec": {
    "kmsKeyName": "ENCRYPTION_KEY_NAME"
  },
  "serviceAccount": "SERVICE_ACCOUNT",
  "templateUri": "TEMPLATE_URI"
}

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 \
     "http://PIPELINE_JOB_REGION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/PIPELINE_JOB_REGION/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 "http://PIPELINE_JOB_REGION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/PIPELINE_JOB_REGION/pipelineJobs" | Select-Object -Expand Content

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

Python

Para saber como instalar o SDK da Vertex AI para 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 __future__ import annotations

def tuning(
    project_id: str,
) -> None:

    import vertexai
    from vertexai.language_models import TextGenerationModel
    from google.auth import default

    credentials, _ = default(scopes=["http://www.googleapis.com/auth/cloud-platform"])

    # TODO(developer): Update and un-comment below line
    # project_id = "PROJECT_ID"

    vertexai.init(project=project_id, location="us-central1", credentials=credentials)

    model = TextGenerationModel.from_pretrained("text-bison@002")

    tuning_job = model.tune_model(
        training_data="gs://cloud-samples-data/ai-platform/generative_ai/headline_classification.jsonl",
        tuning_job_location="europe-west4",
        tuned_model_location="us-central1",
    )

    print(tuning_job._status)

    return model

Node.js

Antes de testar essa amostra, siga as instruções de configuração para Node.js Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');
const {PipelineServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'europe-west4-aiplatform.googleapis.com',
};
const model = 'text-bison@001';

const pipelineClient = new PipelineServiceClient(clientOptions);

async function tuneLLM() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;

  const parameters = {
    train_steps: helpers.toValue(trainSteps),
    project: helpers.toValue(project),
    location: helpers.toValue('us-central1'),
    dataset_uri: helpers.toValue(datasetUri),
    large_model_reference: helpers.toValue(model),
    model_display_name: helpers.toValue(modelDisplayName),
    accelerator_type: helpers.toValue('GPU'), // Optional: GPU or TPU
  };

  const runtimeConfig = {
    gcsOutputDirectory,
    parameterValues: parameters,
  };

  const pipelineJob = {
    templateUri:
      'http://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0',
    displayName: 'my-tuning-job',
    runtimeConfig,
  };

  const createPipelineRequest = {
    parent,
    pipelineJob,
    pipelineJobId,
  };
  await new Promise((resolve, reject) => {
    pipelineClient.createPipelineJob(createPipelineRequest).then(
      response => resolve(response),
      e => reject(e)
    );
  }).then(response => {
    const [result] = response;
    console.log('Tuning pipeline job:');
    console.log(`\tName: ${result.name}`);
    console.log(
      `\tCreate time: ${new Date(1970, 0, 1)
        .setSeconds(result.createTime.seconds)
        .toLocaleString()}`
    );
    console.log(`\tStatus: ${result.status}`);
  });
}

await tuneLLM();

Java

Antes de testar essa amostra, siga as instruções de configuração para Java Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

import com.google.cloud.aiplatform.v1.CreatePipelineJobRequest;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.PipelineJob;
import com.google.cloud.aiplatform.v1.PipelineJob.RuntimeConfig;
import com.google.cloud.aiplatform.v1.PipelineServiceClient;
import com.google.cloud.aiplatform.v1.PipelineServiceSettings;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class CreatePipelineJobModelTuningSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String location = "europe-west4"; // europe-west4 and us-central1 are the supported regions
    String pipelineJobDisplayName = "PIPELINE_JOB_DISPLAY_NAME";
    String modelDisplayName = "MODEL_DISPLAY_NAME";
    String outputDir = "OUTPUT_DIR";
    String datasetUri = "DATASET_URI";
    int trainingSteps = 300;

    createPipelineJobModelTuningSample(
        project,
        location,
        pipelineJobDisplayName,
        modelDisplayName,
        outputDir,
        datasetUri,
        trainingSteps);
  }

  // Create a model tuning job
  public static void createPipelineJobModelTuningSample(
      String project,
      String location,
      String pipelineJobDisplayName,
      String modelDisplayName,
      String outputDir,
      String datasetUri,
      int trainingSteps)
      throws IOException {
    final String endpoint = String.format("%s-aiplatform.googleapis.com:443", location);
    PipelineServiceSettings pipelineServiceSettings =
        PipelineServiceSettings.newBuilder().setEndpoint(endpoint).build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (PipelineServiceClient client = PipelineServiceClient.create(pipelineServiceSettings)) {
      Map<String, Value> parameterValues = new HashMap<>();
      parameterValues.put("project", stringToValue(project));
      parameterValues.put("model_display_name", stringToValue(modelDisplayName));
      parameterValues.put("dataset_uri", stringToValue(datasetUri));
      parameterValues.put(
          "location",
          stringToValue(
              "us-central1")); // Deployment is only supported in us-central1 for Public Preview
      parameterValues.put("large_model_reference", stringToValue("text-bison@001"));
      parameterValues.put("train_steps", numberToValue(trainingSteps));
      parameterValues.put("accelerator_type", stringToValue("GPU")); // Optional: GPU or TPU

      RuntimeConfig runtimeConfig =
          RuntimeConfig.newBuilder()
              .setGcsOutputDirectory(outputDir)
              .putAllParameterValues(parameterValues)
              .build();

      PipelineJob pipelineJob =
          PipelineJob.newBuilder()
              .setTemplateUri(
                  "http://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0")
              .setDisplayName(pipelineJobDisplayName)
              .setRuntimeConfig(runtimeConfig)
              .build();

      LocationName parent = LocationName.of(project, location);
      CreatePipelineJobRequest request =
          CreatePipelineJobRequest.newBuilder()
              .setParent(parent.toString())
              .setPipelineJob(pipelineJob)
              .build();

      PipelineJob response = client.createPipelineJob(request);
      System.out.format("response: %s\n", response);
      System.out.format("Name: %s\n", response.getName());
    }
  }

  static Value stringToValue(String str) {
    return Value.newBuilder().setStringValue(str).build();
  }

  static Value numberToValue(int n) {
    return Value.newBuilder().setNumberValue(n).build();
  }
}

Console

Para ajustar um modelo de texto com ajuste supervisionado usando o Console do Google Cloud, siga estas etapas:

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

    Acessar o Vertex AI Studio

  2. Clique na guia Ajustar e destilar.
  3. Clique em Criar modelo ajustado.
  4. Clique em Ajuste supervisionado.
  5. Configure os detalhes do modelo:
    • Nome do modelo ajustado: insira um nome para o modelo ajustado.
    • Modelo base: selecione o modelo base que você quer ajustar.
    • Região: selecione a região onde o job de ajuste do pipeline será executado e onde o modelo ajustado será implantado.
    • Diretório de trabalho: insira o local do Cloud Storage em que os artefatos são armazenados quando o modelo é ajustado.
  6. Expanda Opções avançadas para definir configurações avançadas.
    • Treinar etapas: digite o número de etapas a serem executadas para o ajuste do modelo. O valor padrão é 300. O tamanho do lote varia de acordo com o local de ajuste e o tamanho do modelo. Para modelos 8k, como text-bison@002, chat-bison@002, code-bison@002 e codechat-bison@002:
      • us-central1 tem um tamanho de lote de 8.
      • europe-west4 tem um tamanho de lote de 24.
      Para modelos 32k, como text-bison-32k, chat-bison-32k, code-bison-32k e codechat-bison-32k:
      • us-central1 tem um tamanho de lote de 8.
      • europe-west4 tem um tamanho de lote de 8.

      Por exemplo, se você treinar text-bison@002 em europe-west4, haverá 240 exemplos em um conjunto de dados de treinamento e você definirá steps como 20, então o número de exemplos de treinamento será o produto de 20 etapas e o tamanho do lote de 24 ou 480 etapas de treinamento. Nesse caso, haverá dois períodos no processo de treinamento porque ele passará pelos exemplos duas vezes. Em us-central1, se houver 240 exemplos em um conjunto de dados de treinamento e você definir steps como 15, o número de exemplos de treinamento será o produto de 15 etapas e o tamanho do lote de 8 ou 120 etapas de treinamento. Nesse caso, haverá 0,5 período porque haverá metade do número de etapas de treinamento que o número de exemplos.

    • Multiplicador de taxa de aprendizado: digite o tamanho da etapa em cada iteração. O valor padrão é 1.
    • Tipo de acelerador (opcional): insira o tipo de acelerador a ser usado para ajuste do modelo. As opções válidas são:
      • GPU: usa oito GPUs A100 de 80 GB para ajuste. Verifique se você tem cota suficiente. Se você escolher GPU, o VPC‐SC será permitido. A CMEK será permitida se os locais de ajuste e de upload do modelo forem us-centra1. Para mais informações, consulte Configurações de região do ajuste supervisionado. Se você escolher GPU, os processamentos de ajuste do modelo acontecerão na região us-central1.
      • TPU: usa 64 núcleos do pod da TPU v3 para ajuste. Verifique se você tem cota suficiente. A CMEK não é permitida, mas sim o VPC‐SC. Se você escolher TPU, os processamentos de ajuste do modelo acontecerão na região europe-west4.
    • Adicionar uma instância do TensorBoard: (opcional) o ID de uma instância do TensorBoard da Vertex AI. A instância do Vertex AI TensorBoard é usada para criar um experimento após a conclusão do job de ajuste. A instância do TensorBoard da Vertex AI precisa estar na mesma região do pipeline de ajuste.
    • Criptografia (opcional) Use uma chave de criptografia gerenciada pelo Google ou pelo cliente (CMEK). Uma CMEK está disponível para criptografia apenas na região us-central1. Em todas as outras regiões disponíveis, uma chave de criptografia gerenciada pelo Google é usada. Para mais informações, consulte Informações gerais da CMEK.
    • Conta de serviço (opcional): escolha uma conta de serviço gerenciada pelo usuário. Uma conta de serviço determina quais recursos do Google Cloud podem ser acessados com seu código de serviço. Se você não escolher uma conta de serviço, será usada uma conta de serviço gerenciada pelo Google que inclui permissões apropriadas para a maioria dos modelos.
  7. Clique em Continuar.
  8. Se você quiser fazer upload do arquivo do conjunto de dados, selecione  Fazer upload do arquivo JSONL no Cloud Storage. Se o arquivo do conjunto de dados já estiver em um bucket do Cloud Storage, selecione  Arquivo JSONL no Cloud Storage.

    Fazer upload de um arquivo JSONL

    • Em Selecionar arquivo JSONL, clique em Procurar e selecione o arquivo do conjunto de dados.
    • Em Local do conjunto de dados, clique em Procurar e selecione o bucket do Cloud Storage em que você quer armazenar o arquivo do conjunto de dados.

    Usar um arquivo JSONL

    Em Caminho do arquivo do Cloud Storage, clique em Procurar e selecione o bucket do Cloud Storage em que o arquivo do conjunto de dados está localizado.
  9. (Opcional) Para avaliar o modelo ajustado, selecione Ativar avaliação do modelo e configure a avaliação do modelo:
    • Conjunto de dados de avaliação: (opcional) o URI do arquivo JSONL que contém o conjunto de dados de avaliação para previsão e avaliação em lote. Não há suporte à avaliação de chat-bison. Para mais informações, consulte Formato do conjunto de dados para ajustar um modelo de código. O conjunto de dados de avaliação requer de 10 a 250 exemplos.
    • Intervalo de avaliação: (opcional, 20 padrão) o número de etapas de ajuste entre cada avaliação. Um intervalo de avaliação não é compatível com modelos de chat. Como a avaliação é executada em todo o conjunto de dados de avaliação, um intervalo de avaliação menor resulta em um tempo de ajuste mais longo. Por exemplo, se steps for 200 e EVAL_INTERVAL for 100, você terá apenas dois pontos de dados para as métricas de avaliação. Esse parâmetro exige que a evaluation_data_uri seja definida.
    • Ativar parada antecipada: (opcional, padrão true) uma boolean que, se definida como true, interrompe o ajuste antes de concluir todas as etapas de ajuste, se o desempenho do modelo for medido pela acurácia dos tokens previstos, não melhora o suficiente entre as execuções de avaliações. Se false, o ajuste continuará até que todas as etapas de ajuste sejam concluídas. Esse parâmetro exige que a evaluation_data_uri seja definida. A ativação da parada antecipada não é compatível com modelos de chat.
    • Ativar a seleção de checkpoints: quando ativada, a Vertex AI seleciona e retorna o checkpoint com o melhor desempenho de avaliação do modelo de todos os checkpoints criados durante o job de ajuste. Quando desativado, o checkpoint final criado durante o job de ajuste é retornado. Cada checkpoint se refere a um snapshot do modelo durante um job de ajuste.
    • Instância do TensorBoard: (opcional) o ID de uma instância do TensorBoard da Vertex AI. A instância do Vertex AI TensorBoard é usada para criar um experimento após a conclusão do job de ajuste. A instância do TensorBoard da Vertex AI precisa estar na mesma região do pipeline de ajuste.
  10. Clique em Iniciar ajuste.

Exemplo de comando curl

PROJECT_ID=myproject
DATASET_URI=gs://my-gcs-bucket-uri/dataset
OUTPUT_DIR=gs://my-gcs-bucket-uri/output
ACCELERATOR_TYPE=GPU
LOCATION=us-central1

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
"http://europe-west4-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/europe-west4/pipelineJobs?pipelineJobId=tune-large-model-$(date +%Y%m%d%H%M%S)" -d \
$'{
  "displayName": "tune-llm",
  "runtimeConfig": {
    "gcsOutputDirectory": "'${OUTPUT_DIR}'",
    "parameterValues": {
      "project": "'${PROJECT_ID}'",
      "model_display_name": "The display name for your model in the UI",
      "dataset_uri": "'${DATASET_URI}'",
      "location": "'${LOCATION}'",
      "accelerator_type:": "'${ACCELERATOR_TYPE}'",
      "large_model_reference": "text-bison@002",
      "train_steps": 300,
      "learning_rate_multiplier": 1,
      "encryption_spec_key_name": "projects/myproject/locations/us-central1/keyRings/sample-key/cryptoKeys/sample-key"
    }
  },
  "encryptionSpec": {
    "kmsKeyName": "projects/myproject/locations/us-central1/keyRings/sample-key/cryptoKeys/sample-key"
  },
  "templateUri": "http://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0"
}'

A tabela a seguir mostra as configurações recomendadas para ajustar um modelo de base por tarefa:

Tarefa Nº de exemplos no conjunto de dados Etapas de treinamento
Classificação Mais de 100 100-500
Geração de resumos 100-500+ 200-1000
QA extrativa Mais de 100 100-500
Chat Mais de 200 1.000

Nas etapas de treinamento, você pode testar mais de um valor para ter o melhor desempenho em um determinado conjunto de dados, por exemplo, 100, 200, 500.

Ver uma lista de modelos ajustados

É possível visualizar uma lista de modelos no projeto atual, incluindo os modelos ajustados, usando o console do Google Cloud ou o SDK da Vertex AI para Python.

Python

Antes de testar essa amostra, siga as instruções de configuração para Python Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Python.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


import vertexai
from vertexai.language_models import TextGenerationModel

def list_tuned_models(
    project_id: str,
    location: str,
) -> None:
    """List tuned models."""

    vertexai.init(project=project_id, location=location)
    model = TextGenerationModel.from_pretrained("text-bison@002")
    tuned_model_names = model.list_tuned_model_names()
    print(tuned_model_names)

    return tuned_model_names

Console

Para visualizar seus modelos ajustados no console do Google Cloud, acesse a página Registro de modelos da Vertex AI.

Acessar o Vertex AI Model Registry

Carregar um modelo de texto ajustado

O exemplo de código a seguir usa o SDK da Vertex AI para Python para carregar um modelo de geração de texto que foi ajustado usando o ajuste supervisionado:

import vertexai
from vertexai.preview.language_models import TextGenerationModel

model = TextGenerationModel.get_tuned_model(TUNED_MODEL_NAME)

Substitua TUNED_MODEL_NAME pelo nome do recurso qualificado do modelo ajustado. Esse nome está no formato projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID. Encontre o ID do modelo ajustado no Vertex AI Model Registry.

Métricas de ajuste e avaliação

É possível configurar um job de ajuste de modelo para coletar e relatar métricas de ajuste e avaliação de modelos, que podem ser visualizadas usando o TensorBoard da Vertex AI.

Métricas de ajuste de modelos

É possível configurar um job de ajuste de modelo para coletar as seguintes métricas de ajuste para chat-bison, code-bison, codechat-bison e text-bison:
  • /train_total_loss: perda do conjunto de dados de ajuste em uma etapa de treinamento.
  • /train_fraction_of_correct_next_step_preds: a precisão do token em uma etapa de treinamento. Uma única previsão consiste em uma sequência de tokens. Mede a precisão dos tokens previstos quando comparados às informações empíricas no conjunto de dados de ajuste.
  • /train_num_predictions: Número de tokens previstos em uma etapa de treinamento.

Métricas de avaliação de modelo

É possível configurar um job de ajuste de modelo para coletar as seguintes métricas de avaliação para code-bison e text-bison:

  • /eval_total_loss: perda do conjunto de dados de avaliação em uma etapa de avaliação.
  • /eval_fraction_of_correct_next_step_preds: a precisão do token em uma etapa de avaliação. Uma única previsão consiste em uma sequência de tokens. Mede a precisão dos tokens previstos quando comparados às informações empíricas no conjunto de dados de avaliação.
  • /eval_num_predictions: número de tokens previstos em uma etapa de avaliação.

As visualizações de métricas ficam disponíveis após a conclusão do job de ajuste do modelo. Se você especificar apenas um ID de instância do TensorBoard da Vertex AI e não um conjunto de dados de avaliação ao criar o job de ajuste, apenas as visualizações das métricas de ajuste estarão disponíveis.

Solução de problemas

Os tópicos a seguir podem ajudar a resolver problemas no ajuste de um modelo de texto de base usando o ajuste supervisionado.

A tentativa de ajustar um modelo retorna um erro 500 ou Internal error encountered

Se você encontrar esse erro 500 ao tentar ajustar um modelo, tente esta solução alternativa:

Execute o comando cURL a seguir para criar um conjunto de dados vazio da Vertex AI. Verifique se você configurou o ID do projeto no comando.

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
http://europe-west4-aiplatform.googleapis.com/ui/projects/$PROJECT_ID/locations/europe-west4/datasets \
-d '{
    "display_name": "test-name1",
    "metadata_schema_uri": "gs://google-cloud-aiplatform/schema/dataset/metadata/image_1.0.0.yaml",
    "saved_queries": [{"display_name": "saved_query_name", "problem_type": "IMAGE_CLASSIFICATION_MULTI_LABEL"}]
}'

Após a conclusão do comando, aguarde cinco minutos e tente ajustar o modelo novamente.

Erro: a permissão "aiplatform.metadataStores.get" foi negada no recurso "...europe-west4/metadataStores/default".

Verifique se a API Compute Engine está ativada e se a conta de serviço padrão do Compute Engine (PROJECT_NUM‑[email protected]) recebeu os papéis aiplatform.admin e storage.objectAdmin .

Para conceder os papéis aiplatform.admin e storage.objectAdmin à conta de serviço do Compute Engine, faça o seguinte:

  1. No Console do Google Cloud, ative o Cloud Shell.

    Ativar o Cloud Shell

    Na parte inferior do Console do Google Cloud, uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

    Se você preferir usar um terminal na máquina, instale e configure a CLI do Google Cloud.

  2. Anexe o papel aiplatform.admin à conta de serviço do Compute Engine usando o comando gcloud projects add-iam-policy-binding:

    Substitua:

    • PROJECT_ID pelo ID do projeto do Google Cloud.
    • PROJECT_NUM pelo número do projeto do Google Cloud.
    gcloud projects add-iam-policy-binding PROJECT_ID --member serviceAccount:PROJECT_NUM[email protected] --role roles/aiplatform.admin

  3. Anexe o papel storage.objectAdmin à conta de serviço do Compute Engine usando o comando gcloud projects add-iam-policy-binding:

    • PROJECT_ID pelo ID do projeto do Google Cloud.
    • PROJECT_NUM pelo número do projeto do Google Cloud.
    gcloud projects add-iam-policy-binding PROJECT_ID --member serviceAccount:PROJECT_NUM[email protected]  --role roles/storage.objectAdmin

Erro: o Agente de serviço da Vertex AI service-{project-number}@gcp-sa-aiplatform.iam.gserviceaccount.com não tem permissão para acessar o repositório do projeto do Artifact Registry em projects/vertex-ai-restricted/locations/us/repositories/llm.

Esse erro de permissão ocorre devido a um atraso na propagação. Uma tentativa subsequente deve resolver esse erro.

A seguir