Obtenha inferências em lote a partir de um modelo personalizado

Esta página mostra-lhe como obter inferências em lote dos seus modelos preparados de forma personalizada através da Google Cloud consola ou da API Vertex AI.

Para fazer um pedido de inferência em lote, especifica uma origem de entrada e uma localização de saída, no Cloud Storage ou no BigQuery, onde o Vertex AI armazena os resultados da inferência em lote.

Limitações e requisitos

Considere as seguintes limitações e requisitos ao obter inferências em lote:

  • Para minimizar o tempo de processamento, as localizações de entrada e saída têm de estar na mesma região ou multirregião. Por exemplo, se a sua entrada estiver em us-central1, a saída pode estar em us-central1 ou US, mas não em europe-west4. Para saber mais, consulte as localizações do Cloud Storage e as localizações do BigQuery.
  • A entrada e a saída também têm de estar na mesma região ou multirregião que o seu modelo.
  • Os modelos do BigQuery ML não são modelos personalizados com aprendizagem. No entanto, as informações nesta página podem ser usadas para obter inferências em lote a partir de um modelo do BigQuery ML nas seguintes condições:
    • O modelo do BigQuery ML tem de estar registado no Registo de modelos do Vertex AI.
    • Para usar uma tabela do BigQuery como entrada, tem de definir InstanceConfig.instanceType como "object" através da API Vertex AI.
  • O carregamento de um modelo de inferência em lote excede o limite de tempo após aproximadamente 40 minutos. Se vir a seguinte mensagem de erro, use um modelo mais pequeno para inferências em lote: Error: model server never became ready. Please validate that your model file or container configuration are valid.

Requisitos de dados de entrada

A entrada para pedidos em lote especifica os itens a enviar ao seu modelo para inferência. Suportamos os seguintes formatos de entrada:

JSON Lines

Use um ficheiro JSON Lines para especificar uma lista de instâncias de entrada para fazer inferências sobre. Armazene o ficheiro num contentor do Cloud Storage.

Exemplo 1

O exemplo seguinte mostra um ficheiro JSON Lines em que cada linha contém uma matriz:

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

Seguem-se os dados enviados para o contentor no corpo do pedido HTTP:

Todos os outros contentores

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

Contentores do PyTorch

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

Exemplo 2

O exemplo seguinte mostra um ficheiro JSON Lines em que cada linha contém um objeto.

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

Seguem-se os dados enviados para o contentor no corpo do pedido HTTP. Tenha em atenção que o mesmo corpo do pedido é enviado para todos os contentores.

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

Exemplo 3

Para contentores pré-criados do PyTorch, certifique-se de que envolve cada instância num campo data, conforme exigido pelo controlador predefinido do TorchServe. O Vertex AI não envolve as suas instâncias. Por exemplo:

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

Seguem-se os dados enviados para o contentor de inferência no corpo do pedido HTTP:

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

TFRecord

Guardar instâncias de entrada no formato TFRecord. Opcionalmente, pode comprimir os ficheiros TFRecord com Gzip. Armazene os ficheiros TFRecord num contentor do Cloud Storage.

O Vertex AI lê cada instância nos seus ficheiros TFRecord como binária e, em seguida, codifica a instância em base64 como um objeto JSON com uma única chave denominada b64.

Seguem-se os dados enviados para o contentor no corpo do pedido HTTP:

Todos os outros contentores

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

Contentores do PyTorch

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

Certifique-se de que o contentor sabe como descodificar a instância.

CSV

Especifique uma instância de entrada por linha num ficheiro CSV. A primeira linha tem de ser uma linha de cabeçalho. Tem de colocar todas as strings entre aspas duplas ("). O Vertex AI não aceita valores de células que contenham novas linhas. Os valores sem aspas são lidos como números de vírgula flutuante.

O exemplo seguinte mostra um ficheiro CSV com duas instâncias de entrada:

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

Seguem-se os dados enviados para o contentor no corpo do pedido HTTP:

Todos os outros contentores

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

Contentores do PyTorch

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

Lista de ficheiros

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

Se planeia usar a Google Cloud consola para obter inferências em lote, cole a sua lista de ficheiros diretamente na Google Cloud consola. Caso contrário, guarde a lista num contentor do Cloud Storage.

O exemplo que se segue mostra uma lista de ficheiros com duas instâncias de entrada:

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

Seguem-se os dados enviados para o contentor no corpo do pedido HTTP:

Todos os outros contentores

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

Contentores do PyTorch

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

Certifique-se de que o contentor sabe como descodificar a instância.

BigQuery

Especifique uma tabela do BigQuery como projectId.datasetId.tableId. A Vertex AI transforma cada linha da tabela numa 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"

Seguem-se os dados enviados para o contentor no corpo do pedido HTTP:

Todos os outros contentores

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

Contentores 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 JSON Valor de exemplo
String String "abc"
Número inteiro Número inteiro 1
Flutuante Flutuante 1.2
Numérico Flutuante 4925.000000000
Booleano Booleano verdadeiro
TimeStamp String "2019-01-01 23:59:59.999999+00:00"
Data String "2018-12-31"
Hora String "23:59:59.999999"
DateTime String "2019-01-01T00:00:00"
Grave Objeto { "A": 1,"B": 2}
Tipo repetido Array[Type] [1, 2]
Registo aninhado Objeto {"A": {"a": 0}, "B": 1}

Crie partições de dados

A inferência em lote usa o MapReduce para dividir a entrada em cada réplica. Para usar as funcionalidades do MapReduce, a entrada deve ser divisível.

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

O Vertex AI não particiona automaticamente os ficheiros CSV porque não são naturalmente adequados para a partição. As linhas nos ficheiros CSV não são autodescritivas, são escritas e podem conter novas linhas. Recomendamos que não use a entrada CSV para aplicações sensíveis ao débito.

Para a entrada TFRecord, certifique-se de que particiona manualmente os dados dividindo as instâncias em ficheiros mais pequenos e transmitindo os ficheiros à tarefa com um caráter universal (por exemplo, gs://my-bucket/*.tfrecord). O número de ficheiros deve ser, pelo menos, o número de réplicas especificado.

Filtre e transforme dados de entrada

Pode filtrar e transformar a entrada em lote especificando instanceConfig no seu pedido BatchPredictionJob.

A filtragem permite-lhe excluir determinados campos que estão nos dados de entrada do seu pedido de inferência ou incluir apenas um subconjunto de campos dos dados de entrada no seu pedido de inferência, sem ter de fazer qualquer pré-processamento ou pós-processamento personalizado no contentor de inferência. Isto é útil quando o ficheiro de dados de entrada tem colunas adicionais de que o modelo não precisa, como chaves ou dados adicionais.

A transformação permite-lhe enviar as instâncias para o seu contentor num formato JSON array ou object. Consulte instanceType para mais informações.

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

customerId col1 col2
1001 1 2
1002 5 6

e especificar o seguinte instanceConfig:

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

Em seguida, as instâncias no seu pedido de inferência são enviadas como objetos JSON e a coluna customerId é excluída:

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

Tenha em atenção que a especificação do seguinte instanceConfig produziria o mesmo resultado:

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

Para uma demonstração sobre como usar filtros de caraterísticas, consulte o bloco de notas Inferência em lote de modelos personalizados com filtragem de caraterísticas.

Peça uma inferência em lote

Para pedidos de inferência em lote, pode usar a Google Cloud consola ou a API Vertex AI. Consoante o número de itens introduzidos que enviou, uma tarefa de inferência em lote pode demorar algum tempo a ser concluída.

Quando pede uma inferência em lote, o contentor de inferência é executado como a conta de serviço personalizada fornecida pelo utilizador. As operações de leitura/escrita, como a leitura das instâncias de inferência da origem de dados ou a escrita dos resultados da inferência, são realizadas através do agente do serviço Vertex AI, que, por predefinição, tem acesso ao BigQuery e ao Cloud Storage.

Google Cloud consola

Use a Google Cloud consola para pedir uma inferência em lote.

  1. Na Google Cloud consola, na secção Vertex AI, aceda à página Previsões em lote.

Aceda à 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 os seguintes passos:

    1. Introduza um nome para a inferência em lote.

    2. Para Nome do modelo, selecione o nome do modelo a usar para esta inferência em lote.

    3. Para Selecionar origem, selecione a origem que se aplica aos seus dados de entrada:

      • Se tiver formatado a entrada como JSON Lines, CSV ou TFRecord, selecione Ficheiro no Cloud Storage (JSON Lines, CSV, TFRecord, TFRecord Gzip). Em seguida, especifique o ficheiro de entrada no campo Caminho de origem.
      • Se estiver a usar uma lista de ficheiros como entrada, selecione Ficheiros no armazenamento na nuvem (outro) e cole a lista de ficheiros no campo seguinte.
      • Para a entrada do BigQuery, selecione Caminho do BigQuery. Se selecionar o BigQuery como entrada, também tem de selecionar o BigQuery como saída e Google-managed encryption key. A chave de encriptação gerida pelo cliente (CMEK) não é suportada com o BigQuery como entrada/saída.

    4. No campo Caminho de destino, especifique o diretório do Cloud Storage onde quer que o Vertex AI armazene o resultado da inferência em lote.

    5. Opcionalmente, pode selecionar a opção Ativar atribuições de funcionalidades para este modelo para receber atribuições de funcionalidades como parte da resposta de inferência em lote. Em seguida, clique em Editar para configurar as definições de explicação. (A edição das definições de explicação é opcional se tiver configurado anteriormente as definições de explicação para o modelo e obrigatória caso contrário.)

    6. Especifique as opções de computação para a tarefa de inferência em lote: Número de nós de computação, Tipo de máquina e (opcionalmente) Tipo de acelerador e Quantidade de aceleradores.

  3. Opcional: Monitorização de modelos A análise para inferências em lote está disponível na pré-visualização. Consulte os Pré-requisitos para adicionar a configuração de deteção de desvio à sua tarefa de inferência em lote.

    1. Clique para ativar a opção Ativar monitorização do modelo para esta previsão em lote.

    2. Selecione uma origem de dados de preparação. Introduza o caminho ou a localização dos dados da origem de dados de preparação que selecionou.

    3. Opcional: em Limites de alerta, especifique os limites nos quais os alertas são acionados.

    4. Para Emails de notificação, introduza um ou mais endereços de email separados por vírgulas para receber alertas quando um modelo exceder um limite de alerta.

    5. Opcional: para Canais de notificação, adicione canais do Cloud Monitoring para receber alertas quando um modelo exceder um limite de alerta. Pode selecionar canais do Cloud Monitoring existentes ou criar um novo clicando em Gerir canais de notificação. A consola Google Cloud suporta canais de notificação do PagerDuty, Slack e Pub/Sub.

  4. Clique em Criar.

API

Use a API Vertex AI para enviar pedidos de inferência em lote. Selecione um separador consoante a ferramenta que está a usar para obter inferências em lote.

REST

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION_ID: região onde o modelo está armazenado e a tarefa de previsão em lote é executada. Por exemplo, us-central1.

  • PROJECT_ID: o seu ID do projeto.

  • BATCH_JOB_NAME: nome a apresentar para a tarefa de previsão em lote.

  • MODEL_ID: o ID do modelo a usar 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 seus dados de entrada. Pode conter carateres universais.

  • OUTPUT_DIRECTORY: URI do Cloud Storage de um diretório onde quer que o Vertex AI guarde a saída.

  • MACHINE_TYPE: os recursos da máquina a usar para esta tarefa de previsão em lote.

    Opcionalmente, pode configurar o machineSpeccampo para usar aceleradores, mas o exemplo seguinte não demonstra esta opção.

  • BATCH_SIZE: o número de instâncias a enviar em cada pedido de previsão; o valor predefinido é 64. Aumentar o tamanho do lote pode levar a um débito mais elevado, mas também pode causar limites de tempo limite de pedidos.

  • STARTING_REPLICA_COUNT: o número de nós para esta tarefa 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 do pedido: 

{
  "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 o seu pedido, escolha uma destas opções:

curl

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte comando: 

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

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte comando: 

$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

Deve receber uma resposta JSON semelhante à seguinte:

{
  "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 experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

No exemplo seguinte, substitua PREDICTIONS_FORMAT por jsonl. Para saber como substituir os outros marcadores de posição, consulte o separador REST & CMD LINE desta secçã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 ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API. 

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 de REST anterior usa o Cloud Storage para a origem e o destino. Para usar o BigQuery em alternativa, faça as seguintes alterações:

  • Altere 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 o seguinte:

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

Importância das funcionalidades

Se quiser que os valores de importância das funcionalidades sejam devolvidos para as suas inferências, defina a propriedade generateExplanation como true. Tenha em atenção que os modelos de previsão não suportam a importância das funcionalidades, pelo que não pode incluí-la nos seus pedidos de inferência em lote.

A importância das funcionalidades, por vezes denominada atribuições de funcionalidades, faz parte do Vertex Explainable AI.

Só pode definir generateExplanation como true se tiver configurado o seu Model para explicações ou se especificar o campo BatchPredictionJobexplanationSpec.

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

O escalamento horizontal, através do aumento do número de réplicas, melhora o débito de forma mais linear e previsível do que a utilização de tipos de máquinas maiores.

Em geral, recomendamos que especifique o tipo de máquina mais pequeno possível para a sua tarefa e aumente o número de réplicas.

Para rentabilidade, recomendamos que escolha a quantidade de réplicas de forma que a tarefa de inferência em lote seja executada durante, pelo menos, 10 minutos. Isto deve-se ao facto de a faturação ser feita por hora de nó de réplica, o que inclui os aproximadamente 5 minutos necessários para cada réplica ser iniciada. Não é rentável processar apenas durante alguns segundos e, em seguida, desligar.

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

N / (T * (60 / Tb))

Onde:

  • N: o número de lotes na tarefa. Por exemplo, 1 milhão de instâncias / 100 tamanho do lote = 10 000 lotes.
  • T: o tempo esperado para a tarefa de inferência em lote. Por exemplo, 10 minutos.
  • Tb: o tempo, em segundos, que uma réplica demora a processar um único lote. Por exemplo, 1 segundo por lote num tipo de máquina de 2 núcleos.

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

Ao contrário da inferência online, as tarefas de inferência em lote não são dimensionadas automaticamente. Uma vez que todos os dados de entrada são conhecidos antecipadamente, o sistema divide os dados em cada réplica quando a tarefa é iniciada. O sistema usa o parâmetro starting_replica_count. O parâmetro max_replica_count é ignorado.

Estas recomendações são todas diretrizes aproximadas. Não oferecem necessariamente um débito ideal para todos os modelos. Não fornecem estimativas exatas do tempo de processamento e do custo. Além disso, não captam necessariamente as melhores compromissos entre custo e débito para cada cenário. Use-os como ponto de partida razoável e ajuste-os conforme necessário. Para medir características como o débito do seu modelo, execute o bloco de notas Finding ideal machine type.

Para máquinas aceleradas pela GPU ou pela TPU

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

  • Pode precisar de mais CPUs e GPUs (por exemplo, para o pré-processamento de dados).
  • Os tipos de máquinas com GPU demoram mais tempo a iniciar (10 minutos), pelo que é recomendável segmentar tempos mais longos (por exemplo,, pelo menos 20 minutos em vez de 10 minutos) para a tarefa de inferência em lote, de modo que uma proporção razoável do tempo e do custo seja gasta na geração de inferências.

Obtenha resultados da inferência em lote

Quando uma tarefa de inferência em lote está concluída, o resultado da inferência é armazenado no contentor do Cloud Storage ou na localização do BigQuery que especificou no seu pedido.

Exemplo de resultado da inferência em lote

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

Os ficheiros têm o nome {gcs_path}/prediction.results-{file_number}-of-{number_of_files_generated}. O número de ficheiros é não determinístico devido à natureza distribuída da inferência em lote.

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

  • prediction: contém o valor devolvido pelo contentor.
  • instance: para uma lista de ficheiros, contém o URI do Cloud Storage. Para todos os outros formatos de entrada, contém o valor que foi enviado para o contentor no corpo do pedido HTTP.

Exemplo 1

Se o pedido HTTP contiver:

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

E o contentor devolve:

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

Então, o ficheiro 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 o pedido HTTP contiver:

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

E o contentor devolve:

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

Então, o ficheiro 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}}

Use a IA explicável

Não recomendamos a execução de explicações baseadas em caraterísticas numa grande quantidade de dados. Isto deve-se ao facto de cada entrada poder gerar potencialmente milhares de pedidos com base no conjunto de valores de funcionalidades possíveis, o que pode resultar num aumento significativo do tempo de processamento e do custo. Em geral, um pequeno conjunto de dados é suficiente para compreender a importância das funcionalidades.

A inferência em lote não suporta explicações baseadas em exemplos.

Blocos de notas

O que se segue?