Receber previsões e explicações em lote

Nesta página, mostramos como fazer uma solicitação de previsão em lote para o modelo de classificação ou regressão AutoML treinado usando o Console do Google Cloud ou a API Vertex AI.

Uma solicitação de previsão em lote é uma solicitação assíncrona, em oposição à previsão on-line, que é uma solicitação síncrona. Solicite previsões em lote diretamente do recurso do modelo sem precisar implantá-lo em um endpoint. Para dados tabulares, use previsões em lote quando não precisar de uma resposta imediata e quiser processar dados acumulados usando uma única solicitação.

Para fazer uma previsão em lote, especifique uma origem de entrada e um formato de saída em que a Vertex AI armazena os resultados das previsões.

Antes de começar

Antes de fazer uma solicitação de previsão em lote, treine um modelo.

Dados de entrada

Os dados de entrada para as solicitações de previsão em lote são aqueles usados pelo modelo para fazer previsões. Para modelos de classificação ou regressão, é possível fornecer dados de entrada em um destes dois formatos:

  • Tabelas do BigQuery
  • Objetos CSV no Cloud Storage

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

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 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 a ser usada nesta previsão em lote.
    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, 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 existente:
        • Para especificar o ID do projeto, insira-o no campo ID do projeto do Google Cloud. A Vertex AI cria um novo conjunto de dados de saída para você.
        • Para especificar um conjunto de dados existente, insira o caminho do BigQuery no campo ID do projeto do Google Cloud, como bq://projectid.datasetid.
      • Opcional. É 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. As atribuições de atributos estão incluídas nas previsões da Vertex AI pela Vertex Explainable AI.

        Para ativar as atribuições de atributos, selecione Ativar atribuições de atributos para este modelo. Essa opção vai estar disponível se o destino de saída for o BigQuery ou o JSONL no Cloud Storage. As atribuições de atributos não são suportadas em CSV no Cloud Storage.

  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

batchPredictionJobs.createbatchPredictionJobs.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. Se você especificar apenas o ID do projeto, o Vertex AI criará um novo conjunto de dados de saída para você. Use o seguinte formulário: 
    bq://bqprojectId.bqDatasetId
  • MACHINE_TYPE: os recursos de máquina a serem usados para este job de previsão em lote. Saiba mais.
  • STARTING_REPLICA_COUNT: o número inicial de nós deste job de previsão em lote. A contagem de nós pode ser aumentada ou reduzida conforme necessário pela carga, até o número máximo de nós, mas nunca ficará abaixo desse número.
  • MAX_REPLICA_COUNT: o número máximo de nós para este job de previsão em lote. A contagem de nós pode ser aumentada ou diminuída conforme necessário para o carregamento, mas nunca excederá o máximo. Opcional: o valor padrão é 10.
  • GENERATE_EXPLANATION: é 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. As atribuições de atributos estão incluídas nas previsões da Vertex AI pela Vertex Explainable AI.

    O valor padrão é false. Defina como true para ativar as atribuições de atributos.

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": "MODEL_ID",
  "inputConfig": {
    "instancesFormat": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
      "outputUri": "OUTPUT_URI"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "MACHINE_TYPE",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT,
    "maxReplicaCount": MAX_REPLICA_COUNT
  },

  "generateExplanation": GENERATE_EXPLANATION

}

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_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
  },
  "generateExplanation": false,
  "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.

Na amostra a seguir, defina os parâmetros "instances_format" e "predicts_format" como "bigquery". Para saber como definir os outros parâmetros, consulte a guia "REST e CMD LINE" nesta seção. 
from google.cloud import aiplatform_v1beta1
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value


def create_batch_prediction_job_bigquery_sample(
    project: str,
    display_name: str,
    model_name: str,
    instances_format: str,
    bigquery_source_input_uri: str,
    predictions_format: str,
    bigquery_destination_output_uri: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform_v1beta1.JobServiceClient(client_options=client_options)
    model_parameters_dict = {}
    model_parameters = json_format.ParseDict(model_parameters_dict, Value())

    batch_prediction_job = {
        "display_name": display_name,
        # Format: 'projects/{project}/locations/{location}/models/{model_id}'
        "model": model_name,
        "model_parameters": model_parameters,
        "input_config": {
            "instances_format": instances_format,
            "bigquery_source": {"input_uri": bigquery_source_input_uri},
        },
        "output_config": {
            "predictions_format": predictions_format,
            "bigquery_destination": {"output_uri": bigquery_destination_output_uri},
        },
        # optional
        "generate_explanation": True,
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_batch_prediction_job(
        parent=parent, batch_prediction_job=batch_prediction_job
    )
    print("response:", response)

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
  • MACHINE_TYPE: os recursos de máquina a serem usados para este job de previsão em lote. Saiba mais.
  • STARTING_REPLICA_COUNT: o número inicial de nós deste job de previsão em lote. A contagem de nós pode ser aumentada ou reduzida conforme necessário pela carga, até o número máximo de nós, mas nunca ficará abaixo desse número.
  • MAX_REPLICA_COUNT: o número máximo de nós para este job de previsão em lote. A contagem de nós pode ser aumentada ou diminuída conforme necessário para o carregamento, mas nunca excederá o máximo. Opcional: o valor padrão é 10.
  • GENERATE_EXPLANATION: é 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. As atribuições de atributos estão incluídas nas previsões da Vertex AI pela Vertex Explainable AI.

    O valor padrão é false. Defina como true para ativar as atribuições de atributos. 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.

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": "MODEL_ID",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": [
        URI1,...
      ]
    },
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "MACHINE_TYPE",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT,
    "maxReplicaCount": MAX_REPLICA_COUNT
  },

  "generateExplanation": GENERATE_EXPLANATION

}

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__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
  },
  "manualBatchTuningParameters": {
    "batchSize": 4
  }
  "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",
}

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.

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).

  • 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 previsões, acesse a página do BigQuery.

Acessar o BigQuery

O formato da consulta depende do seu tipo de modelo:

Classificação:

SELECT predicted_TARGET_COLUMN_NAME.classes AS classes,
predicted_TARGET_COLUMN_NAME.scores AS scores
FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

classes é a lista de classes em potencial e scores são as pontuações de confiança correspondentes.

Regressão:

SELECT predicted_TARGET_COLUMN_NAME.value
FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

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 fornece valores e previsões de quantis, além de minimizar o objetivo de otimização. Os valores de quantis são definidos durante o treinamento do modelo. As previsões de quantis são os valores de previsão associados aos valores de quantis.

Se você ativou as atribuições de atributos, também pode encontrá-las na tabela de previsões. Para acessar as atribuições de um atributo BQ_FEATURE_NAME, execute a seguinte consulta: 

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

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 foi iniciado: errors_TIMESTAMP Para recuperar a validação de erros tabela:

  1. No console, acesse a página do IAM:

    Acessar o BigQuery

  2. Execute a seguinte consulta: 
    SELECT * FROM BQ_DATASET_NAME.BQ_ERRORS_TABLE_NAME
Os erros são armazenados nas seguintes colunas:
  • errors_TARGET_COLUMN_NAME.code
  • errors_TARGET_COLUMN_NAME.message

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 "predictions_1.csv", "predictions_2.csv" e assim por diante. Esses objetos contêm uma linha de cabeçalho com os nomes das colunas e uma linha para cada previsão retornada. Nos objetos de previsão, a Vertex AI retorna os dados de previsão e cria uma ou mais colunas para os resultados da previsão, com base no tipo de modelo:

    • Classificação: para cada valor potencial da coluna de destino, uma coluna chamada TARGET_COLUMN_NAME_VALUE_score é adicionada aos resultados. Essa coluna contém a pontuação ou a estimativa de confiança desse valor.
    • Regressão: o valor previsto para essa linha é retornado em uma coluna chamada predicted_TARGET_COLUMN_NAME. O intervalo de previsão não é retornado para a saída CSV.
  • 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 dos dados de entrada para a qual a Vertex AI não conseguiu retornar uma previsão (por exemplo, se um atributo não anulável fosse nulo).

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

As atribuições de atributos não estão disponíveis para resultados de previsões em lote retornados no Cloud Storage.

Interpretar resultados de previsão

Classificação

Os modelos de classificação retornam uma pontuação de confiança.

A pontuação de confiança informa o quanto o modelo associa cada classe ou rótulo a um item de teste. Quanto maior o número, maior a confiança do modelo de que o rótulo precisa ser aplicado a esse item. Você decide o nível de confiança necessário para aceitar os resultados do modelo.

Regressão

Os modelos de regressão retornam um valor de previsão.

Se o modelo usar a inferência probabilística, o campo value vai conter o minimizador do objetivo de otimização. Por exemplo, se o objetivo de otimização for minimize-rmse, o campo value conterá o valor médio. Se for minimize-mae, o campo value conterá o valor médio.

Se o modelo usa inferência probabilística com quantis, a Vertex AI fornece valores e previsões de quantis, além de minimizar o objetivo de otimização. Os valores de quantis são definidos durante o treinamento do modelo. As previsões de quantis são os valores de previsão associados aos valores de quantis.

Interpretar resultados de explicação

Se os resultados da previsão em lote forem armazenados no BigQuery e você ativar as atribuições de atributos, encontre os valores de atribuição dos atributos na tabela de previsões.

Para calcular a importância do atributo local, a pontuação de previsão do valores de referência é calculada primeiro. Os valores de referência são calculados com base nos dados de treinamento e a utilização do valor mediano para atributos numéricos e do modo para atributos categóricos. A previsão gerada a partir dos valores de referência é a pontuação de previsão dos valores de referência. Os valores de referência são calculados uma vez para um modelo e não são alterados.

Para uma previsão específica, a importância do atributo local de cada atributo informa quanto esse atributo foi adicionado ou subtraído do resultado, em comparação com a pontuação de previsão dos valores de referência. A soma de todos os valores de importância do atributo é igual à diferença entre a pontuação de previsão dos valores de referência e o resultado da previsão.

Para modelos de classificação, a pontuação está sempre entre 0,0 e 1,0 (inclusos). Portanto, os valores de importância de recursos locais para modelos de classificação estão sempre entre -1,0 e 1,0 (inclusos).

Consulte exemplos de consultas de atribuições de atributos e outras informações em Atribuições de atributos para classificação e regressão.

A seguir