Receber previsões para um modelo de previsão

Nesta página, mostramos como criar uma previsão usando o modelo treinado.

Para criar uma previsão, faça uma solicitação de previsão em lote diretamente ao seu modelo de previsão, especificando uma origem de entrada e um local de saída para armazenar os resultados da previsão.

A previsão com o AutoML não é compatível com a implantação de endpoints ou as previsões on-line. Se você quiser solicitar previsões on-line do seu modelo de previsão, use o fluxo de trabalho tabular para previsão.

É possível solicitar uma previsão com explicações, também chamadas de atribuições de atributos, para ver como o modelo chegou a uma previsão. Os valores de importância do atributo local informam quanto cada atributo contribuiu para o resultado da previsão. Para uma visão geral conceitual, consulte Atribuições de recursos para previsão.

Antes de começar

Antes de criar uma previsão, é preciso treinar um modelo de previsão.

Dados de entrada

Os dados de entrada para solicitações de previsão em lote são os dados que o modelo usa para criar previsões. É possível fornecer dados de entrada em um destes dois formatos:

• Objetos CSV no Cloud Storage
• Tabelas do BigQuery

Recomendamos o mesmo formato para os dados de entrada, que foi utilizado no treinamento do modelo. Por exemplo, se você treinou o modelo usando dados no BigQuery, é melhor usar uma tabela do BigQuery como a entrada para previsão em lote. Como a Vertex AI trata todos os campos de entrada CSV como strings, a combinação de formatos de dados de treinamento e de entrada pode causar erros.

Sua fonte de dados precisa conter dados tabulares que incluam todas as colunas, em qualquer ordem, que foi usada para treinar o modelo. É possível incluir colunas que não estejam nos dados de treinamento ou que estejam nos dados, mas não tenham sido usadas para o treinamento. Essas colunas extras são incluídas na saída, mas não afetam os resultados da previsão.

Requisitos de dados de entrada

As informações de modelos de estimativa precisam atender aos seguintes requisitos:

• Todos os valores na coluna de tempo precisam estar presentes e válidos.
• A frequência dos dados de entrada precisa ser igual à dos dados de treinamento. Se houver linhas ausentes na série temporal, você precisará inseri-las manualmente de acordo com o conhecimento de domínio adequado.
• As séries temporais com carimbos de data/hora duplicados são removidas das previsões. Para incluí-los, remova os carimbos de data/hora duplicados.
• Forneça dados históricos de cada série temporal para prever. Para as previsões mais precisas, a quantidade de dados precisa ser igual à janela de contexto, que é definida durante o treinamento do modelo. Por exemplo, se a janela de contexto for de 14 dias, forneça pelo menos 14 dias de dados históricos. Se você fornecer menos dados, o Vertex AI preencherá os dados com valores vazios.
• A previsão começa na primeira linha de uma série temporal (classificada por hora) com um valor nulo na coluna de destino. O valor nulo precisa ser contínuo dentro da série temporal. Por exemplo, se a coluna de destino for ordenada por tempo, não será possível ter algo como 1, 2, null, 3, 4, null e null para uma única série temporal. Para arquivos CSV, a Vertex AI trata uma string vazia como nula e, para o BigQuery, os valores nulos são compatíveis nativamente.

Tabela do BigQuery

Se você escolher uma tabela do BigQuery como entrada, verifique se:

• As tabelas de origem de dados do BigQuery não podem ser maiores que 100 GB.
• Se a tabela estiver em um projeto diferente, será preciso fornecer o papel BigQuery Data Editor à conta de serviço da Vertex AI nesse projeto.

Arquivo CSV

Se você escolher um objeto CSV no Cloud Storage como entrada, verifique se:

• A fonte de dados precisa começar com uma linha de cabeçalho com os nomes das colunas.
• Cada objeto de fonte de dados não pode ser maior do que 10 GB. É possível incluir vários arquivos até o máximo de 100 GB.
• Se o bucket do Cloud Storage estiver em um projeto diferente, você precisará conceder o papel Storage Object Creator à conta de serviço do Vertex AI nesse projeto.
• Coloque todas as strings entre aspas duplas (").

Formato da saída

O formato de saída da sua solicitação de previsão em lote não precisa ser o mesmo usado para a entrada. Por exemplo, se você usou a tabela do BigQuery como entrada, é possível gerar resultados de previsão para um objeto CSV no Cloud Storage.

Fazer uma solicitação de previsão em lote ao seu modelo

Para fazer solicitações de previsão em lote, use o Console do Google Cloud ou a API Vertex AI. A fonte de dados de entrada pode ser objetos CSV armazenados em um bucket do Cloud Storage ou tabelas do BigQuery. Dependendo da quantidade de dados enviados como entrada, uma tarefa de previsão em lote pode levar algum tempo para ser concluída.

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"

2. Clique em Criar para abrir a janela Nova previsão em lote.
3. 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 Versão, selecione a versão do modelo.
   4. Em Selecionar origem, selecione se os dados de entrada de origem serão um arquivo CSV no Cloud Storage ou uma tabela no BigQuery.
      • Para arquivos CSV, especifique o local do Cloud Storage em que seu arquivo de entrada CSV está localizado.
      • Para tabelas do BigQuery, especifique o ID do projeto em que a tabela está localizada, o ID do conjunto de dados do BigQuery e o ID da tabela ou visualização do BigQuery.
   5. Em Saída de previsão em lote, selecione CSV ou BigQuery.
      • Em CSV, especifique o bucket do Cloud Storage em que a Vertex AI armazena a saída.
      • No BigQuery, especifique um ID de projeto ou um conjunto de dados:
        • Para especificar o ID do projeto, insira-o no campo ID do projeto do Google Cloud. O Vertex AI cria um novo conjunto de dados de saída para você.
        • Para especificar um conjunto de dados atual, insira o caminho do BigQuery no campo ID do projeto do Google Cloud, como bq://projectid.datasetid.
      • Opcional. Se o destino de saída for o BigQuery ou o JSONL no Cloud Storage, será possível ativar as atribuições de recursos, além das previsões. Para fazer isso, selecione Ativar atribuições de recursos para este modelo. As atribuições de atributos não são suportadas em CSV no Cloud Storage. Saiba mais.
4. 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 é compatível com os canais de notificação PagerDuty, Slack e Pub/Sub.
5. Clique em Criar.

API : BigQuery

REST

Use o método batchPredictionJobs.create para solicitar uma previsão em lote.

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 em lote
• MODEL_ID: o ID do modelo a ser usado para fazer previsões
• INPUT_URI: referência à fonte de dados do BigQuery. No formulário, siga estas etapas:

  bq://bqprojectId.bqDatasetId.bqTableId
  

• OUTPUT_URI: referência ao destino do BigQuery (em que as previsões serão gravadas). Especifique o ID do projeto e, opcionalmente, um ID do conjunto de dados existente. Use o seguinte formulário:

  bq://bqprojectId.bqDatasetId

  Se você especificar apenas o ID do projeto, a Vertex AI vai criar um novo conjunto de dados de saída para você. Use o seguinte formulário:

  bq://bqprojectId

• GENERATE_EXPLANATION: o valor padrão é falso. Defina como true para ativar as atribuições de recursos. Para saber mais, consulte Atribuições de recursos para previsão.

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": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
      "outputUri": "OUTPUT_URI"
    }
  },
  "generate_explanation": GENERATE_EXPLANATION
}

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

curl

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . É possível verificar a conta ativa atual executando gcloud auth list.

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

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

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_ID/locations/LOCATION_ID/batchPredictionJobs/67890",
  "displayName": "batch_job_1 202005291958",
  "model": "projects/12345/locations/us-central1/models/5678",
  "state": "JOB_STATE_PENDING",
  "inputConfig": {
    "instancesFormat": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
        "outputUri": bq://12345
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "n1-standard-32",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": 2,
    "maxReplicaCount": 6
  },
  "manualBatchTuningParameters": {
    "batchSize": 4
  },
  "outputInfo": {
    "bigqueryOutputDataset": "bq://12345.reg_model_2020_10_02_06_04
  }
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-09-30T02:58:44.341643Z",
  "updateTime": "2020-09-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 INSTANCES_FORMAT e PREDICTIONS_FORMAT por `bigquery`. Para aprender a substituir os outros marcadores de posição, consulte a guia `REST & CMD LINE` desta seção.

import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.BigQueryDestination;
import com.google.cloud.aiplatform.v1.BigQuerySource;
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.ModelName;
import com.google.gson.JsonObject;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;

public class CreateBatchPredictionJobBigquerySample {

  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 bigquerySourceInputUri = "BIGQUERY_SOURCE_INPUT_URI";
    String predictionsFormat = "PREDICTIONS_FORMAT";
    String bigqueryDestinationOutputUri = "BIGQUERY_DESTINATION_OUTPUT_URI";
    createBatchPredictionJobBigquerySample(
        project,
        displayName,
        modelName,
        instancesFormat,
        bigquerySourceInputUri,
        predictionsFormat,
        bigqueryDestinationOutputUri);
  }

  static void createBatchPredictionJobBigquerySample(
      String project,
      String displayName,
      String model,
      String instancesFormat,
      String bigquerySourceInputUri,
      String predictionsFormat,
      String bigqueryDestinationOutputUri)
      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)) {
      JsonObject jsonModelParameters = new JsonObject();
      Value.Builder modelParametersBuilder = Value.newBuilder();
      JsonFormat.parser().merge(jsonModelParameters.toString(), modelParametersBuilder);
      Value modelParameters = modelParametersBuilder.build();
      BigQuerySource bigquerySource =
          BigQuerySource.newBuilder().setInputUri(bigquerySourceInputUri).build();
      BatchPredictionJob.InputConfig inputConfig =
          BatchPredictionJob.InputConfig.newBuilder()
              .setInstancesFormat(instancesFormat)
              .setBigquerySource(bigquerySource)
              .build();
      BigQueryDestination bigqueryDestination =
          BigQueryDestination.newBuilder().setOutputUri(bigqueryDestinationOutputUri).build();
      BatchPredictionJob.OutputConfig outputConfig =
          BatchPredictionJob.OutputConfig.newBuilder()
              .setPredictionsFormat(predictionsFormat)
              .setBigqueryDestination(bigqueryDestination)
              .build();
      String modelName = ModelName.of(project, location, model).toString();
      BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(displayName)
              .setModel(modelName)
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .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_bigquery_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    bigquery_source: str,
    bigquery_destination_prefix: str,
    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,
        bigquery_source=bigquery_source,
        bigquery_destination_prefix=bigquery_destination_prefix,
        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

API : Cloud Storage

REST

Use o método batchPredictionJobs.create para solicitar uma previsão em lote.

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 em lote
• MODEL_ID: o ID do modelo a ser usado para fazer previsões
• URI: caminhos (URIs) para os buckets do Cloud Storage que contêm os dados de treinamento. Pode haver mais de um. Cada URI tem o seguinte formato:

  gs://bucketName/pathToFileName
  

• OUTPUT_URI_PREFIX: caminho para um destino do Cloud Storage em que as previsões serão gravadas. A Vertex AI grava previsões em lote em um subdiretório com carimbo de data/hora deste caminho. Defina esse valor como uma string com o seguinte formato:

  gs://bucketName/pathToOutputDirectory
  

• GENERATE_EXPLANATION: o valor padrão é falso. Defina como true para ativar as atribuições de recursos. Esta opção só está disponível se o destino de saída for JSONL. As atribuições de recursos não são compatíveis com CSV no Cloud Storage. Para saber mais, consulte Atribuições de recursos para previsão.

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": "csv",
    "gcsSource": {
      "uris": [
        URI1,...
      ]
    },
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "generate_explanation": GENERATE_EXPLANATION
}

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

curl

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . É possível verificar a conta ativa atual executando gcloud auth list.

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

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

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_ID/locations/LOCATION_ID/batchPredictionJobs/67890",
  "displayName": "batch_job_1 202005291958",
  "model": "projects/12345/locations/us-central1/models/5678",
  "state": "JOB_STATE_PENDING",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": [
        "gs://bp_bucket/reg_mode_test"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "n1-standard-32",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": 2,
    "maxReplicaCount": 6
  }
  "outputInfo": {
    "gcsOutputDataset": "OUTPUT_URI_PREFIX/prediction-batch_job_1 202005291958-2020-09-30T02:58:44.341643Z"
  }
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-09-30T02:58:44.341643Z",
  "updateTime": "2020-09-30T02:58:44.341643Z",
}

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_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    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,
        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

Recuperar resultados de predição em lote

A Vertex AI envia a saída das previsões em lote para o destino especificado, que pode ser o BigQuery ou o Cloud Storage.

No momento, a saída do Cloud Storage para atribuições de recursos não é compatível.

BigQuery

Conjunto de dados de saída

Se você estiver usando o BigQuery, a saída da previsão em lote será armazenada em um conjunto de dados de saída. Se você forneceu um conjunto de dados à Vertex AI, o nome do conjunto de dados (BQ_DATASET_NAME) é o nome que você forneceu anteriormente. Se você não forneceu um conjunto de dados de saída, a Vertex AI criou um para você. Para encontrar o nome (BQ_DATASET_NAME), siga estas etapas:

1. No console do Google Cloud, acesse a página Previsões em lote da Vertex AI.

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

2. Selecione a previsão que você criou.
3. O conjunto de dados de saída é fornecido em Local de exportação. O nome do recurso é criado da seguinte maneira: prediction_MODEL_NAME_TIMESTAMP

Tabelas de saída

O conjunto de dados de saída contém uma ou mais das três tabelas de saída a seguir:

• Tabela de previsões
  

  A tabela contém uma linha para cada linha dos dados de entrada, em que uma previsão foi solicitada (por exemplo, TARGET_COLUMN_NAME = nulo). Por exemplo, se a entrada incluiu 14 entradas nulas para a coluna de destino (como vendas nos próximos 14 dias), sua solicitação de previsão retorna 14 linhas, o número de vendas para cada dia. Se a solicitação de previsão exceder o horizonte de previsão do modelo, o Vertex AI retornará apenas previsões até o horizonte de previsão.

• Tabela de validação de erros
  

  Esta tabela contém uma linha para cada erro não crítico encontrado durante a fase de agregação que ocorre antes da previsão em lote. Cada erro não crítico corresponde a uma linha nos dados de entrada para a qual a Vertex AI não conseguiu retornar uma previsão.

• Tabela de erros
  

  Esta tabela contém uma linha para cada erro não crítico encontrado durante a previsão em lote. Cada erro não crítico corresponde a uma linha nos dados de entrada para a qual a Vertex AI não conseguiu retornar uma previsão.

Tabela de previsões

O nome da tabela (BQ_PREDICTIONS_TABLE_NAME) é formado pela adição de "predictions_" com o carimbo de data/hora em que o job de previsão em lote começou: predictions_TIMESTAMP

Para recuperar a tabela de previsões:

1. No console, acesse a página do IAM:
   Ir para o BigQuery
2. Execute a seguinte consulta:

   SELECT * FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME
         

A Vertex AI armazena previsões na coluna predicted_TARGET_COLUMN_NAME.value.

Se você treinou um modelo com o Transformer Tempor Fusion (TFT), poderá encontrar a saída de interpretabilidade do TFT na coluna predicted_TARGET_COLUMN_NAME.tft_feature_importance:

Essa coluna é dividida no seguinte:

• context_columns: recursos de previsão com valores de janela de contexto que servem como entradas para o codificador de memória de curto prazo longa (LSTM, na sigla em inglês) do TFT.
• context_weights: os pesos de importância do atributo associados a cada um dos context_columns para a instância prevista.
• horizon_columns: atributos de previsão com valores de horizonte de previsão que servem como entradas para o decodificador de memória de curto prazo longa (LSTM, na sigla em inglês) do TFT.
• horizon_weights: os pesos de importância do atributo associados a cada um dos horizon_columns para a instância prevista.
• attribute_columns: recursos de previsão que são invariantes ao tempo.
• attribute_weights: os pesos associados a cada uma das attribute_columns.

Se o modelo estiver otimizado para perda de quantis e o conjunto de quantis incluir a mediana, predicted_TARGET_COLUMN_NAME.value será o valor de previsão na mediana. Caso contrário, predicted_TARGET_COLUMN_NAME.value é o valor de previsão no quantil mais baixo do conjunto. Por exemplo, se o conjunto de quantis for [0.1, 0.5, 0.9], value será a previsão para o quantil 0.5. Se o conjunto de quantis for [0.1, 0.9], value será a previsão para o quantil 0.1.

Além disso, a Vertex AI armazena valores de quantil e previsões nas seguintes colunas:

• predicted_TARGET_COLUMN_NAME.quantile_values: os valores dos quantis, que são definidos durante o treinamento do modelo. Por exemplo, eles podem ser 0.1, 0.5 e 0.9.
• predicted_TARGET_COLUMN_NAME.quantile_predictions: os valores de previsão associados aos quantile_values.

Se o modelo usa inferência probabilística, predicted_TARGET_COLUMN_NAME.value contém o minimizador do objetivo de otimização. Por exemplo, se o objetivo de otimização for minimize-rmse, predicted_TARGET_COLUMN_NAME.value terá o valor médio. Se for minimize-mae, predicted_TARGET_COLUMN_NAME.value conterá o valor mediano.

Se o modelo usa inferência probabilística com quantis, a Vertex AI armazena valores e previsões de quantis nas seguintes colunas:

• predicted_TARGET_COLUMN_NAME.quantile_values: os valores dos quantis, que são definidos durante o treinamento do modelo. Por exemplo, eles podem ser 0.1, 0.5 e 0.9.
• predicted_TARGET_COLUMN_NAME.quantile_predictions: os valores de previsão associados aos quantile_values.

Se você ativou as atribuições de recursos, elas também podem ser encontradas na tabela de previsões. Para acessar as atribuições de um recurso BQ_FEATURE_NAME, execute a seguinte consulta:

SELECT explanation.attributions[OFFSET(0)].featureAttributions.BQ_FEATURE_NAME FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME
  

Para saber mais, consulte Atribuições de recursos para previsão.

Tabela de validação de erros

O nome da tabela (BQ_ERRORS_VALIDATION_TABLE_NAME) é formado pela adição de "errors_validation" com o carimbo de data/hora em que o job de previsão em lote começou: errors_validation_TIMESTAMP

Para recuperar a tabela de validação de erros:

1. No console, acesse a página do IAM:
   Ir para o BigQuery
2. Execute a seguinte consulta:

   SELECT * FROM BQ_DATASET_NAME.BQ_ERRORS_VALIDATION_TABLE_NAME
         

A mensagem de erro é armazenada na seguinte coluna:

• TARGET_COLUMN_NAMEErros:

Tabela de erros

O nome da tabela (BQ_ERRORS_TABLE_NAME) é formado pela adição de "errors_" com o carimbo de data/hora em que o job de previsão em lote começou: errors_TIMESTAMP

Para recuperar a tabela de validação de erros:

1. No console, acesse a página do IAM:
   Ir para o BigQuery
2. Execute a seguinte consulta:

   SELECT * FROM BQ_DATASET_NAME.BQ_ERRORS_TABLE_NAME
         

Os erros são armazenados nas seguintes colunas:

• erros_TARGET_COLUMN_NAME.code
• erros_TARGET_COLUMN_NAME.mensagem

Cloud Storage

Se você tiver especificado o Cloud Storage como destino de saída, os resultados da solicitação de previsão em lote serão retornados como objetos CSV em uma nova pasta no bucket especificado. O nome da pasta é o nome do modelo, precedido por "prediction-" e anexado ao carimbo de data/hora do momento em que o job de previsão em lote foi iniciado. Encontre o nome da pasta do Cloud Storage na guia Previsões em lote do modelo.

A pasta do Cloud Storage contém dois tipos de objetos:

• Objetos de previsão

  Os objetos de previsão são chamados de "predictions_1.csv", "predictions_2.csv" e assim por diante. Esses arquivos contêm uma linha de cabeçalho com os nomes das colunas e uma linha para cada previsão retornada. O número de valores de previsão depende da entrada de previsão e do horizonte da previsão. Por exemplo, se a entrada incluiu 14 entradas nulas para a coluna de destino (como vendas nos próximos 14 dias), sua solicitação de previsão retorna 14 linhas, o número de vendas para cada dia. Se a solicitação de previsão exceder o horizonte de previsão do modelo, o Vertex AI retornará apenas previsões até o horizonte de previsão.

  Os valores de estimativa são retornados em uma coluna chamada "predicted_TARGET_COLUMN_NAME". Para previsões de quantil, a coluna de saída contém as previsões de quantil e os valores de quantil no formato JSON.

• Objetos de erro

  Os objetos de erro são denominados `errors_1.csv`, `errors_2.csv` e assim por diante. Eles contêm uma linha de cabeçalho e uma linha para cada linha nos dados de entrada para a qual a Vertex AI não conseguiu retornar uma previsão, por exemplo, se um recurso não anulável fosse nulo.

Observação: se os resultados forem grandes, ele será dividido em vários objetos.

Exemplos de consultas de atribuição de recursos no BigQuery

Exemplo 1: determinar as atribuições de uma única previsão

Considere a seguinte pergunta:

Quanto um anúncio de um produto aumentou as vendas previstas em 24 de novembro em uma determinada loja?

A consulta correspondente é a seguinte:

SELECT
  * EXCEPT(explanation, predicted_sales),
  ROUND(predicted_sales.value, 2) AS predicted_sales,
  ROUND(
    explanation.attributions[OFFSET(0)].featureAttributions.advertisement,
    2
  ) AS attribution_advertisement
FROM
  `project.dataset.predictions`
WHERE
  product = 'product_0'
  AND store = 'store_0'
  AND date = '2019-11-24'

Exemplo 2: determinar a importância do recurso global

Considere a seguinte pergunta:

Quanto cada recurso contribuiu para as vendas previstas?

É possível calcular manualmente a importância do recurso global agregando as atribuições de importância de recurso local. A consulta correspondente é a seguinte:

WITH

/*
* Aggregate from (id, date) level attributions to global feature importance.
*/
attributions_aggregated AS (
 SELECT
   SUM(ABS(attributions.featureAttributions.date)) AS date,
   SUM(ABS(attributions.featureAttributions.advertisement)) AS advertisement,
   SUM(ABS(attributions.featureAttributions.holiday)) AS holiday,
   SUM(ABS(attributions.featureAttributions.sales)) AS sales,
   SUM(ABS(attributions.featureAttributions.store)) AS store,
   SUM(ABS(attributions.featureAttributions.product)) AS product,
 FROM
   project.dataset.predictions,
   UNNEST(explanation.attributions) AS attributions

),

/*
* Calculate the normalization constant for global feature importance.
*/
attributions_aggregated_with_total AS (
 SELECT
   *,
   date + advertisement + holiday + sales + store + product AS total
 FROM
   attributions_aggregated
)

/*
* Calculate the normalized global feature importance.
*/
SELECT
 ROUND(date / total, 2) AS date,
 ROUND(advertisement / total, 2) AS advertisement,
 ROUND(holiday / total, 2) AS holiday,
 ROUND(sales / total, 2) AS sales,
 ROUND(store / total, 2) AS store,
 ROUND(product / total, 2) AS product,
FROM
 attributions_aggregated_with_total

Exemplo de saída da previsão em lote no BigQuery

Em um exemplo de conjunto de dados de vendas de bebidas alcoólicas, há quatro lojas na cidade de "Ida Grove": "Ida Grove Food Pride", "Discount Liquors of Ida Grove", "Casey's General Store #3757", e "Brew Ida Grove". store_name é o series identifier, e três das quatro lojas solicitam previsões para a coluna de destino sale_dollars. Um erro de validação é gerado porque nenhuma previsão foi solicitada para "Líquidos de desconto do Ida Grove".

Veja a seguir uma extração do conjunto de dados de entrada usado para previsão:

Veja a seguir uma extração dos resultados da previsão:

Veja a seguir uma extração dos erros de validação:

Exemplo de saída de previsão em lote de um modelo otimizado para perda de quantil

O exemplo a seguir é a saída de previsão em lote de um modelo otimizado para perda de quantis. Nesse cenário, o modelo de previsão previu as vendas nos próximos 14 dias para cada armazenamento.

Os valores de quantil são fornecidos na coluna predicted_Sales.quantile_values. Neste exemplo, o modelo previu valores nos quantis 0.1, 0.5 e 0.9.

Os valores de previsão são fornecidos na coluna predicted_Sales.quantile_predictions. Esta é uma matriz de valores de vendas, que são mapeados para os valores de quantil na coluna predicted_Sales.quantile_values. Na primeira linha, vemos que a probabilidade de o valor das vendas ser menor que 4484.04 é de 10%. A probabilidade de o valor das vendas ser menor que 5615.64 é de 50%. A probabilidade de o valor das vendas ser menor que 6853.29 é de 90%. A previsão para a primeira linha, representada como um valor único, é 5615.64.