Receber predições em lote de um modelo treinado personalizado

Nesta página, mostramos como receber previsões em lote de modelos de classificação de vídeo usando o console do Google Cloud ou a API Vertex AI.

Para fazer uma solicitação de previsão em lote, especifique uma origem de entrada e um local de saída, o Cloud Storage ou o BigQuery, em que a Vertex AI armazena os resultados da previsão em lote.

Limitações e requisitos

Considere as seguintes limitações e requisitos ao receber previsões em lote:

  • Para minimizar o tempo de processamento, os locais de entrada e saída precisam estar na mesma região ou multirregião. Por exemplo, se a entrada estiver em us-central1, a saída poderá estar em us-central1 ou US, mas não em europe-west4. Para saber mais, consulte Locais do Cloud Storage e Locais do BigQuery.
  • A entrada e a saída também precisam estar na mesma região ou multirregião do modelo.
  • Os modelos do Model Garden não são compatíveis.
  • Os modelos do BigQuery ML não são treinados de forma personalizada. No entanto, as informações desta página podem ser usadas para receber previsões em lote de um modelo do BigQuery ML nas seguintes condições:
    • O modelo do BigQuery ML precisa ser registrado no Vertex AI Model Registry.
    • Para usar uma tabela do BigQuery como entrada, defina InstanceConfig.instanceType como "object" usando a API da Vertex AI.

Requisitos de dados de entrada

A entrada de solicitações em lote especifica os itens que serão enviados ao seu modelo para previsão. Oferecemos compatibilidade com os seguintes formatos de entrada:

Linhas JSON

Use um arquivo JSON Lines para especificar uma lista de instâncias de entrada para fazer previsões. Armazene o arquivo em um bucket do Cloud Storage.

Exemplo 1

O exemplo a seguir mostra um arquivo de linhas JSON, em que cada linha contém uma matriz:

[1, 2, 3, 4]
[5, 6, 7, 8]

Veja o que é enviado para o contêiner de previsão no corpo da solicitação HTTP:

Todos os outros contêineres

{"instances": [ [1, 2, 3, 4], [5, 6, 7, 8] ]}

Contêineres do PyTorch

{"instances": [
{ "data": [1, 2, 3, 4] },
{ "data": [5, 6, 7, 8] } ]}

Exemplo 2

O exemplo a seguir mostra um arquivo de linhas JSON, em que cada linha contém um objeto.

{ "values": [1, 2, 3, 4], "key": 1 }
{ "values": [5, 6, 7, 8], "key": 2 }

Saiba o que é enviado para o contêiner de previsão no corpo da solicitação HTTP. O mesmo corpo de solicitação é enviado a todos os contêineres.

{"instances": [
  { "values": [1, 2, 3, 4], "key": 1 },
  { "values": [5, 6, 7, 8], "key": 2 }
]}

Exemplo 3:

Para contêineres pré-criados do PyTorch, encapsule cada instância em um campo data conforme exigido pelo gerenciador padrão do TorchServe. A Vertex AI não encapsula as instâncias para você. Exemplo:

{ "data": { "values": [1, 2, 3, 4], "key": 1 } }
{ "data": { "values": [5, 6, 7, 8], "key": 2 } }

Veja o que é enviado para o contêiner de previsão no corpo da solicitação HTTP:

{"instances": [
  { "data": { "values": [1, 2, 3, 4], "key": 1 } },
  { "data": { "values": [5, 6, 7, 8], "key": 2 } }
]}

TFRecord

Salve as instâncias de entrada no formato TFRecord. Como opção, você pode compactar os arquivos TFRecord com o Gzip. Armazene os arquivos TFRecord em um bucket do Cloud Storage.

A Vertex AI lê cada instância nos arquivos TFRecord como binária e, em seguida, codifica a instância em base64 como objeto JSON com uma única chave chamada b64.

Veja o que é enviado para o contêiner de previsão no corpo da solicitação HTTP:

Todos os outros contêineres

{"instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

Contêineres do PyTorch

{"instances": [ { "data": {"b64": "b64EncodedASCIIString" } }, { "data": {"b64": "b64EncodedASCIIString" } }
]}

Verifique se o contêiner de previsão sabe como decodificar a instância.

CSV

Especifique uma instância de entrada por linha em um arquivo CSV. A primeira linha precisa ser uma linha de cabeçalho. Coloque todas as strings entre aspas duplas ("). O Vertex AI não aceita valores de célula que contenham novas linhas. Os valores sem aspas são lidos como números de ponto flutuante.

O exemplo a seguir mostra um arquivo CSV com duas instâncias de entrada:

"input1","input2","input3"
0.1,1.2,"cat1"
4.0,5.0,"cat2"

Veja o que é enviado para o contêiner de previsão no corpo da solicitação HTTP:

Todos os outros contêineres

{"instances": [ [0.1,1.2,"cat1"], [4.0,5.0,"cat2"] ]}

Contêineres do PyTorch

{"instances": [
{ "data": [0.1,1.2,"cat1"] },
{ "data": [4.0,5.0,"cat2"] } ]}

Lista de arquivos

Crie um arquivo de texto em que cada linha seja o URI do Cloud Storage para um arquivo. A Vertex AI lê o conteúdo de cada arquivo como binário e, em seguida, codifica a instância em base64 como objeto JSON com uma única chave chamada b64.

Se você planeja usar o console do Google Cloud para receber previsões em lote, cole a lista de arquivos diretamente no console. Caso contrário, salve a lista em um bucket do Cloud Storage.

O exemplo a seguir mostra uma lista de arquivos com duas instâncias de entrada:

gs://path/to/image/image1.jpg
gs://path/to/image/image2.jpg

Veja o que é enviado para o contêiner de previsão no corpo da solicitação HTTP:

Todos os outros contêineres

{ "instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

Contêineres do PyTorch

{ "instances": [ { "data": { "b64": "b64EncodedASCIIString" } }, { "data": { "b64": "b64EncodedASCIIString" } }
]}

Verifique se o contêiner de previsão sabe como decodificar a instância.

BigQuery

Especifique uma tabela do BigQuery como projectId.datasetId.tableId. A Vertex AI transforma cada linha da tabela em uma instância JSON.

Por exemplo, se a tabela contiver o seguinte:

Coluna 1 Coluna 2 Coluna 3
1,0 3.0 "Cat1"
2.0 4.0 "Cat2"

Veja o que é enviado para o contêiner de previsão no corpo da solicitação HTTP:

Todos os outros contêineres

{"instances": [ [1.0,3.0,"cat1"], [2.0,4.0,"cat2"] ]}

Contêineres do PyTorch

{"instances": [
{ "data": [1.0,3.0,"cat1"] },
{ "data": [2.0,4.0,"cat2"] } ]}

Veja como os tipos de dados do BigQuery são convertidos em JSON:

Tipo do BigQuery Tipo de JSON Valor de exemplo
String String "abc"
Inteiro Inteiro 1
Ponto flutuante Ponto flutuante 1,2
Numérico Ponto flutuante 4925.000000000
Booleano Booleano verdadeiro
Carimbo de data/hora String "2019-01-01 23:59:59.999999+00:00"
Data String "2018-12-31"
Tempo String "23:59:59.999999"
DateTime String "2019-01-01T00:00:00"
Record Objeto { "A": 1,"B": 2}
Tipo repetido Matriz[Tipo] [1, 2]
Registro aninhado Objeto {"A": {"a": 0}, "B": 1}

Dados de partição

A previsão em lote usa o MapReduce para fragmentar a entrada em cada réplica. Para usar os recursos do MapReduce, a entrada precisa ser particionável.

A Vertex AI particiona automaticamente a entrada do BigQuery, da lista de arquivos e das linhas JSON.

A Vertex AI não particiona automaticamente arquivos CSV, porque eles não são naturalmente compatíveis com partições. As linhas em arquivos CSV não são autodescritivas, digitadas e podem conter novas linhas. Não recomendamos o uso de entradas CSV para aplicativos sensíveis à capacidade de processamento.

Para a entrada TFRecord, particione manualmente os dados dividindo as instâncias em arquivos menores e transmitindo os arquivos para o job com um caractere curinga (por exemplo, gs://my-bucket/*.tfrecord). O número de arquivos precisa ser pelo menos o número de réplicas especificado.

Filtrar e transformar dados de entrada

É possível filtrar e transformar a entrada em lote especificando instanceConfig na solicitação BatchPredictionJob.

A filtragem permite excluir determinados campos que estão nos dados de entrada da solicitação de previsão ou incluir apenas um subconjunto de campos dos dados de entrada na solicitação de previsão, sem que seja necessário fazer qualquer pré-processamento ou pós-processamento personalizado no contêiner de previsão. Isso é útil quando o arquivo de dados de entrada tem colunas extras que o modelo não precisa, como chaves ou dados adicionais.

A transformação permite que você envie as instâncias para o contêiner de previsão no formato array ou object JSON. Veja mais informações em instanceType.

Por exemplo, se a tabela de entrada contiver o seguinte:

customerId col1 col2
1001 1 2
1002 5 6

e você especificar instanceConfig:

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "excludedFields":["customerId"]
    "instanceType":"object"
  }
}

Em seguida, as instâncias na solicitação de previsão são enviadas como objetos JSON, e a coluna customerId é excluída:

{"col1":1,"col2":2}
{"col1":5,"col2":6}

Especificar o seguinte instanceConfig teria o mesmo resultado:

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "includedFields": ["col1","col2"]
    "instanceType":"object"
  }
}

Para acessar uma demonstração de como usar filtros de recursos, consulte o notebook Previsão de lote de modelo personalizado com filtragem de recursos.

Solicitar uma predição em lote

Para solicitações de previsão em lote, use o Console do Google Cloud ou a API Vertex AI. Dependendo do número de itens de entrada enviados, uma tarefa de previsão em lote pode levar algum tempo para ser concluída.

Quando você solicita uma previsão em lote, o contêiner de previsão é executado como a conta de serviço personalizada fornecida pelo usuário. As operações de leitura/gravação, como a leitura das instâncias de previsão da fonte de dados ou a gravação dos resultados da previsão, são feitas com o agente de serviço da Vertex AI, que, por padrão, tem acesso ao BigQuery e ao Cloud Storage.

Console do Google Cloud

Use o console do Google Cloud para solicitar uma previsão em lote.

  1. No console do Google Cloud, na seção Vertex AI, acesse a página Previsões em lote.

Acessar a página "Previsões em lote"

  1. Clique em Criar para abrir a janela Nova previsão em lote.

  2. Para Definir a previsão em lote, conclua as seguintes etapas:

    1. Insira um nome para a previsão em lote.

    2. Em Nome do modelo, selecione o nome do modelo a ser usado para a previsão em lote.

    3. Em Selecionar origem, escolha a origem que se aplica aos dados de entrada:

      • Se você formatou sua entrada como JSON Lines, CSV ou TFRecord, selecione Arquivo no Cloud Storage (JSON Lines, CSV, TFRecord, TFRecord Gzip). Em seguida, especifique o arquivo de entrada no campo Caminho de origem.
      • Se você estiver usando uma lista de arquivos como entrada, selecione Arquivos no Cloud Storage (outro) e cole a lista de arquivos no campo a seguir.
      • Para entrada do BigQuery, selecione BigQuery path. Se você selecionar o BigQuery como entrada, também precisará selecionar o BigQuery como saída e a chave de criptografia gerenciada pelo Google. A chave de criptografia gerenciada pelo cliente (CMEK) não é compatível com o BigQuery como entrada/saída.

    4. No campo Caminho de destino, especifique o diretório do Cloud Storage em que a Vertex AI vai armazenar a saída da previsão em lote.

    5. Opcionalmente, você pode marcar Ativar atribuições de recursos para este modelo para receber atribuições de recursos como parte da resposta de previsão em lote. Em seguida, clique em Editar para definir as configurações de explicação. Editar as configurações de explicação é opcional se você já fez essas definições para o modelo. Caso contrário, é necessário.

    6. Especifique as opções de computação do job de previsão em lote: Número de nós de computação, Tipo de máquina e (opcionalmente) Tipo de acelerador e Contagem de aceleradores.

  3. Opcional: a análise do Monitoramento de modelos para previsões em lote está disponível em Visualização. Consulte os Pré-requisitos para adicionar a configuração de detecção de desvio ao job de previsão em lote.

    1. Clique em Ativar monitoramento de modelos para esta previsão em lote.

    2. Selecione uma Fonte de dados de treinamento. Insira o caminho ou o local dos dados para a fonte de dados de treinamento selecionada.

    3. Opcional: em Limites de alerta, especifique limites para acionar alertas.

    4. Em E-mails de notificação, insira um ou mais endereços de e-mail separados por vírgula para receber alertas quando um modelo exceder um limite de alerta.

    5. Opcional: em canais de notificação, adicione canais do Cloud Monitoring para receber alertas quando um modelo exceder um limite de alertas. Selecione canais existentes do Cloud Monitoring ou crie um novo clicando em Gerenciar canais de notificação. O console do Google Cloud é compatível com os canais de notificação PagerDuty, Slack e Pub/Sub.

  4. Clique em Criar.

API

Use a API Vertex AI para enviar solicitações de previsão em lote. Selecione uma guia conforme a ferramenta que você está usando para receber previsões em lote.

REST

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

  • LOCATION_ID: região em que o modelo está armazenado e o job de previsão em lote é executado. Por exemplo, us-central1.

  • PROJECT_ID: o ID do projeto.

  • BATCH_JOB_NAME: nome de exibição do job de previsão em lote.

  • MODEL_ID: o ID do modelo a ser usado para fazer previsões.

  • INPUT_FORMAT: o formato dos dados de entrada: jsonl, csv, tf-record, tf-record-gzip ou file-list.

  • INPUT_URI: URI do Cloud Storage dos dados de entrada. Pode conter caracteres curinga.

  • OUTPUT_DIRECTORY: URI do Cloud Storage de um diretório em que você quer que a Vertex AI salve a saída.

  • MACHINE_TYPE: os recursos de máquina a serem usados neste job de previsão em lote.

    Se preferir, configure o campo machineSpec para usar aceleradores, mas o exemplo a seguir não demonstra isso.

  • BATCH_SIZE: o número de instâncias a serem enviadas em cada solicitação de previsão o padrão é 64. Aumentar o tamanho do lote pode levar a maior capacidade, mas também pode causar tempos limite de solicitação.

  • STARTING_REPLICA_COUNT: o número de nós deste job de previsão em lote.

Método HTTP e URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs

Corpo JSON da solicitação:

{
  "displayName": "BATCH_JOB_NAME",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "INPUT_FORMAT",
    "gcsSource": {
      "uris": ["INPUT_URI"],
    },
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY",
    },
  },
  "dedicatedResources" : {
    "machineSpec" : {
      "machineType": MACHINE_TYPE
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT
  },
  "manualBatchTuningParameters": {
    "batch_size": BATCH_SIZE,
  }
}

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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs"

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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME 202005291958",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "jsonl",
    "gcsSource": {
      "uris": [
        "INPUT_URI"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY"
    }
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-05-30T02:58:44.341643Z",
  "updateTime": "2020-05-30T02:58:44.341643Z",
}

Java

Antes de testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre 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.

No exemplo a seguir, substitua PREDICTIONS_FORMAT por jsonl. Para saber como substituir os outros marcadores, consulte a guia REST & CMD LINE desta seção.

import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.BatchDedicatedResources;
import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.GcsSource;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.protobuf.Value;
import java.io.IOException;

public class CreateBatchPredictionJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String modelName = "MODEL_NAME";
    String instancesFormat = "INSTANCES_FORMAT";
    String gcsSourceUri = "GCS_SOURCE_URI";
    String predictionsFormat = "PREDICTIONS_FORMAT";
    String gcsDestinationOutputUriPrefix = "GCS_DESTINATION_OUTPUT_URI_PREFIX";
    createBatchPredictionJobSample(
        project,
        displayName,
        modelName,
        instancesFormat,
        gcsSourceUri,
        predictionsFormat,
        gcsDestinationOutputUriPrefix);
  }

  static void createBatchPredictionJobSample(
      String project,
      String displayName,
      String model,
      String instancesFormat,
      String gcsSourceUri,
      String predictionsFormat,
      String gcsDestinationOutputUriPrefix)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient client = JobServiceClient.create(settings)) {

      // Passing in an empty Value object for model parameters
      Value modelParameters = ValueConverter.EMPTY_VALUE;

      GcsSource gcsSource = GcsSource.newBuilder().addUris(gcsSourceUri).build();
      BatchPredictionJob.InputConfig inputConfig =
          BatchPredictionJob.InputConfig.newBuilder()
              .setInstancesFormat(instancesFormat)
              .setGcsSource(gcsSource)
              .build();
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(gcsDestinationOutputUriPrefix).build();
      BatchPredictionJob.OutputConfig outputConfig =
          BatchPredictionJob.OutputConfig.newBuilder()
              .setPredictionsFormat(predictionsFormat)
              .setGcsDestination(gcsDestination)
              .build();
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-2")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_T4)
              .setAcceleratorCount(1)
              .build();
      BatchDedicatedResources dedicatedResources =
          BatchDedicatedResources.newBuilder()
              .setMachineSpec(machineSpec)
              .setStartingReplicaCount(1)
              .setMaxReplicaCount(1)
              .build();
      String modelName = ModelName.of(project, location, model).toString();
      BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(displayName)
              .setModel(modelName)
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .setDedicatedResources(dedicatedResources)
              .build();
      LocationName parent = LocationName.of(project, location);
      BatchPredictionJob response = client.createBatchPredictionJob(parent, batchPredictionJob);
      System.out.format("response: %s\n", response);
      System.out.format("\tName: %s\n", response.getName());
    }
  }
}

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. 

def create_batch_prediction_job_dedicated_resources_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    instances_format: str = "jsonl",
    machine_type: str = "n1-standard-2",
    accelerator_count: int = 1,
    accelerator_type: Union[str, aiplatform_v1.AcceleratorType] = "NVIDIA_TESLA_K80",
    starting_replica_count: int = 1,
    max_replica_count: int = 1,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    my_model = aiplatform.Model(model_resource_name)

    batch_prediction_job = my_model.batch_predict(
        job_display_name=job_display_name,
        gcs_source=gcs_source,
        gcs_destination_prefix=gcs_destination,
        instances_format=instances_format,
        machine_type=machine_type,
        accelerator_count=accelerator_count,
        accelerator_type=accelerator_type,
        starting_replica_count=starting_replica_count,
        max_replica_count=max_replica_count,
        sync=sync,
    )

    batch_prediction_job.wait()

    print(batch_prediction_job.display_name)
    print(batch_prediction_job.resource_name)
    print(batch_prediction_job.state)
    return batch_prediction_job

BigQuery

O exemplo REST anterior usa o Cloud Storage para a origem e o destino. Para usar o BigQuery, faça as seguintes mudanças:

  • Mude o campo inputConfig para o seguinte:

    "inputConfig": {
   "instancesFormat": "bigquery",
   "bigquerySource": {
      "inputUri": "bq://SOURCE_PROJECT_ID.SOURCE_DATASET_NAME.SOURCE_TABLE_NAME"
   }
}

  • Altere o campo outputConfig para o seguinte:

    "outputConfig": {
   "predictionsFormat":"bigquery",
   "bigqueryDestination":{
      "outputUri": "bq://DESTINATION_PROJECT_ID.DESTINATION_DATASET_NAME.DESTINATION_TABLE_NAME"
   }
 }

  • Substitua:

    • SOURCE_PROJECT_ID: ID do projeto de origem do Google Cloud
    • SOURCE_DATASET_NAME: nome do conjunto de dados de origem do BigQuery
    • SOURCE_TABLE_NAME: nome da tabela de origem do BigQuery
    • DESTINATION_PROJECT_ID: ID do projeto de destino do Google Cloud
    • DESTINATION_DATASET_NAME: nome do conjunto de dados de destino do BigQuery
    • DESTINATION_TABLE_NAME: nome da tabela de destino do BigQuery

Importância do recurso

Se você quiser que os valores de importância do recurso sejam retornados para suas previsões, defina a propriedade generateExplanation como true. Os modelos de previsão não são compatíveis com a importância do recurso. Portanto, não é possível incluí-lo nas solicitações de previsão em lote.

A importância do recurso, às vezes chamada de atribuições de recursos, faz parte da Vertex IA Explicável.

Só é possível definir generateExplanation como true se você configurou o Model para explicações ou se especificar o campo explanationSpec do BatchPredictionJob.

Escolha o tipo de máquina e a contagem de réplicas

O escalonamento horizontal aumentando o número de réplicas melhora a capacidade de processamento de maneira mais linear e previsível do que usando tipos de máquinas maiores.

Em geral, recomendamos especificar o menor tipo de máquina possível para seu job e aumentar o número de réplicas.

Para melhor custo-benefício, recomendamos que você escolha a contagem de réplicas, de modo que o job de previsão em lote seja executado por pelo menos 10 minutos. Isso ocorre porque você é faturado por hora de uso do nó de réplica, o que inclui aproximadamente 5 minutos para que cada réplica seja iniciada. Não é econômico processar por apenas alguns segundos e depois desligá-lo.

Como orientação geral, para milhares de instâncias, recomendamos um starting_replica_count nas dezenas. Para milhões de instâncias, recomendamos um starting_replica_count nas centenas. Também é possível usar a seguinte fórmula para estimar o número de réplicas:

N / (T * (60 / Tb))

Em que:

  • N: o número de lotes no job. Por exemplo, 1 milhão de instâncias/100 tamanho de lote = 10.000 lotes.
  • T: o tempo esperado para o job de predição em lote. Por exemplo, 10 minutes.
  • Tb: o tempo necessário para que uma réplica processe um único lote. Por exemplo, 1 segundo por lote em um tipo de máquina de dois núcleos.

No nosso exemplo, 10.000 lotes / (10 minutos * (60 / 1s)) arredondam para 17 réplicas.

Ao contrário da previsão on-line, os jobs de previsão em lote não escalonam automaticamente. Como todos os dados de entrada são conhecidos antecipadamente, o sistema particiona os dados em cada réplica quando o job é iniciado. O sistema usa o parâmetro starting_replica_count. O parâmetro max_replica_count é ignorado.

Todas essas recomendações são orientações aproximadas. Elas não necessariamente oferecem capacidade ideal para cada modelo. Elas não fornecem previsões exatas de tempo e custo de processamento. Eles não capturam necessariamente as melhores vantagens de custo/capacidade para cada cenário. Use-os como ponto de partida razoável e ajuste-os conforme necessário. Para medir características como a capacidade do modelo, execute o notebook Como encontrar o tipo de máquina ideal.

Para máquinas aceleradas por GPU ou TPU

Siga as diretrizes anteriores (que também se aplicam a modelos somente de CPU) com as considerações adicionais a seguir:

  • Talvez você precise de mais CPUs e GPUs (por exemplo, para pré-processamento de dados).
  • Os tipos de máquina GPU levam mais tempo para inicializar (10 minutos). Portanto, convém segmentar tempos mais longos (por exemplo, pelo menos 20 minutos em vez de 10 minutos) para o job de previsão em lote para que uma proporção razoável. do tempo e do custo na geração de previsões.

Recuperar resultados de predição em lote

Quando uma tarefa de previsão em lote é concluída, a saída da previsão é armazenada no bucket do Cloud Storage ou no local do BigQuery que você especificou na solicitação.

Exemplo de resultado de previsão em lote

A pasta de saída contém um conjunto de arquivos JSON Lines.

Os arquivos são denominados {gcs_path}/prediction.results-{file_number}-of-{number_of_files_generated}. O número de arquivos não é determinístico devido à natureza distribuída da previsão em lote.

Cada linha no arquivo corresponde a uma instância da entrada e tem os seguintes pares de chave-valor:

  • prediction: contém o valor retornado pelo contêiner de previsão.
  • instance: para uma lista de arquivos, contém o URI do Cloud Storage. Para todos os outros formatos de entrada, ele contém o valor que foi enviado ao contêiner de previsão no corpo da solicitação HTTP.

Exemplo 1

Se a solicitação HTTP contiver:

{
  "instances": [
    [1, 2, 3, 4],
    [5, 6, 7, 8]
]}

E o contêiner de previsão retorna:

{
  "predictions": [
    [0.1,0.9],
    [0.7,0.3]
  ],
}

O arquivo de saída JSON Lines é:

{ "instance": [1, 2, 3, 4], "prediction": [0.1,0.9]}
{ "instance": [5, 6, 7, 8], "prediction": [0.7,0.3]}

Exemplo 2

Se a solicitação HTTP contiver:

{
  "instances": [
    {"values": [1, 2, 3, 4], "key": 1},
    {"values": [5, 6, 7, 8], "key": 2}
]}

E o contêiner de previsão retorna:

{
  "predictions": [
    {"result":1},
    {"result":0}
  ],
}

O arquivo de saída JSON Lines é:

{ "instance": {"values": [1, 2, 3, 4], "key": 1}, "prediction": {"result":1}}
{ "instance": {"values": [5, 6, 7, 8], "key": 2}, "prediction": {"result":0}}

Usar a Explainable AI

Não recomendamos executar explicações baseadas em recursos em uma grande quantidade de dados. Isso ocorre porque cada entrada pode distribuir potencialmente milhares de solicitações com base no conjunto de valores de atributos possíveis, o que pode resultar em um aumento massivo em tempo e custo de processamento. Em geral, um conjunto de dados pequeno é suficiente para entender a importância do atributo.

A previsão em lote não aceita explicações baseadas em exemplos.

Notebooks

A seguir