Previsões em lote

Nesta página, você aprenderá como fornecer várias linhas de dados para o AutoML Tables de uma só vez e receber uma previsão para cada linha.

Introdução

Após criar (treinar) um modelo, use o método batchPredict e faça uma solicitação assíncrona para receber um lote de previsões. Forneça os dados de entrada para o método batchPredict, no formato de tabela. Cada linha fornece valores para os atributos que o modelo foi treinado a usar. O método batchPredict envia esses dados para o modelo e retorna previsões para cada linha de dados.

Os modelos precisam ser treinados novamente a cada seis meses para que possam continuar exibindo previsões.

Como solicitar uma previsão em lote

Para previsões em lote, especifique uma origem de dados e um destino de resultados em uma Tabela do BigQuery ou em um arquivo CSV no Cloud Storage. Você não precisa usar a mesma tecnologia para a origem e o destino. Por exemplo, é possível usar o BigQuery para a fonte de dados e um arquivo CSV no Cloud Storage para o destino dos resultados. Siga as etapas apropriadas nas duas tarefas abaixo, dependendo dos seus requisitos.

Sua fonte de dados precisa conter dados tabulares que incluam todas as colunas usadas 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 da previsão, mas não são usadas para gerar a previsão.

Como usar tabelas do BigQuery

Os nomes das colunas e os tipos dos dados de entrada precisam corresponder aos dados usados no treinamento. As colunas podem ser ordenadas de modo diferente dos dados de treinamento.

Requisitos para tabelas do BigQuery

  • As tabelas de origem de dados do BigQuery não podem ser maiores que 100 GB.
  • Você precisa usar um conjunto de dados multirregional do BigQuery nos locais US ou EU.
  • Se a tabela estiver em outro projeto, você precisará conceder o papel BigQuery Data Editor à conta de serviço do AutoML Table do projeto. Saiba mais.

Como solicitar a previsão em lote

Console

  1. Acesse a página do AutoML Tables no console do Google Cloud.

    Acessar a página do AutoML Tables

  2. Selecione Modelos e abra o que você quer usar.

  3. Selecione a guia Testar e usar.

  4. Clique em Previsão em lote.

  5. No caso de Conjunto de dados de entrada, selecione Tabela do BigQuery e forneça os IDs do projeto, do conjunto de dados e da tabela de fonte de dados.

  6. No caso de Resultado, selecione Projeto do BigQuery e forneça o ID do projeto de destino dos resultados.

  7. Se você quiser ver o impacto de cada recurso na previsão, selecione Gerar importância do atributo.

    A geração de importância de atributos aumenta o tempo e calcula os atributos necessários para sua previsão. A importância do recurso local não está disponível com um destino de resultados do Cloud Storage.

  8. Clique em Enviar previsão em lote para solicitá-la.

    Página de previsão em lote do AutoML Tables

REST

Para solicitar previsões em lote, use o método models.batchPredict.

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

  • endpoint: automl.googleapis.com para o local global e eu-automl.googleapis.com para a região da UE.
  • project-id: é seu ID do projeto no Google Cloud.
  • location: o local do recurso: us-central1 para global ou eu para a União Europeia.
  • model-id: o código do modelo. Por exemplo, TBL543.
  • dataset-id: o ID do conjunto de dados do BigQuery em que os dados de previsão estão localizados.

  • table-id: o código da tabela do BigQuery em que os dados de previsão estão localizados.

    O AutoML Tables cria uma subpasta para os resultados da previsão chamada prediction-<model_name>-<timestamp> em project-id.dataset-id.table-id.

Método HTTP e URL: 

POST https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict

Corpo JSON da solicitação: 

{
  "inputConfig": {
    "bigquerySource": {
      "inputUri": "bq://project-id.dataset-id.table-id"
    },
  },
  "outputConfig": {
    "bigqueryDestination": {
      "outputUri": "bq://project-id"
    },
  },
}

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 "x-goog-user-project: project-id" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict"

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"; "x-goog-user-project" = "project-id" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict" | Select-Object -Expand Content
A previsão em lote é uma operação de longa duração. É possível pesquisar o status da operação ou esperar que ela seja retornada. Saiba mais.

Para receber a importância do recurso local, adicione o parâmetro feature_importance aos dados da solicitação. Para mais informações, consulte Importância do recurso local.

Java

Se os recursos estiverem localizados na região da UE, você precisará definir o endpoint explicitamente. Saiba mais. 

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1beta1.BatchPredictInputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictOutputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictRequest;
import com.google.cloud.automl.v1beta1.BatchPredictResult;
import com.google.cloud.automl.v1beta1.BigQueryDestination;
import com.google.cloud.automl.v1beta1.BigQuerySource;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.OperationMetadata;
import com.google.cloud.automl.v1beta1.PredictionServiceClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

abstract class TablesBatchPredictBigQuery {

  static void batchPredict() throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String inputUri = "bq://YOUR_PROJECT_ID.bqDatasetID.bqTableId";
    String outputUri = "bq://YOUR_PROJECT_ID";
    batchPredict(projectId, modelId, inputUri, outputUri);
  }

  static void batchPredict(String projectId, String modelId, String inputUri, String outputUri)
      throws IOException, ExecutionException, InterruptedException {
    // 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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);

      // Configure the source of the file from BigQuery
      BigQuerySource bigQuerySource = BigQuerySource.newBuilder().setInputUri(inputUri).build();
      BatchPredictInputConfig inputConfig =
          BatchPredictInputConfig.newBuilder().setBigquerySource(bigQuerySource).build();

      // Configure where to store the output in BigQuery
      BigQueryDestination bigQueryDestination =
          BigQueryDestination.newBuilder().setOutputUri(outputUri).build();
      BatchPredictOutputConfig outputConfig =
          BatchPredictOutputConfig.newBuilder().setBigqueryDestination(bigQueryDestination).build();

      // Build the request that will be sent to the API
      BatchPredictRequest request =
          BatchPredictRequest.newBuilder()
              .setName(name.toString())
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();

      // Start an asynchronous request
      OperationFuture<BatchPredictResult, OperationMetadata> future =
          client.batchPredictAsync(request);

      System.out.println("Waiting for operation to complete...");
      future.get();
      System.out.println("Batch Prediction results saved to BigQuery.");
    }
  }
}

Node.js

Se os recursos estiverem localizados na região da UE, você precisará definir o endpoint explicitamente. Saiba mais. 


/**
 * Demonstrates using the AutoML client to request prediction from
 * automl tables using bigQuery.
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const modelId = '[MODEL_ID]' e.g., "TBL4704590352927948800";
// const inputUri = '[BIGQUERY_PATH]'
// e.g., "bq://<project_id>.<dataset_id>.<table_id>",
// `The Big Query URI containing the inputs`;
// const outputUri = '[BIGQUERY_PATH]' e.g., "bq://<project_id>",
// `The destination Big Query URI for storing outputs`;

const automl = require('@google-cloud/automl');

// Create client for prediction service.
const automlClient = new automl.v1beta1.PredictionServiceClient();

// Get the full path of the model.
const modelFullId = automlClient.modelPath(projectId, computeRegion, modelId);

async function batchPredict() {
  // Construct request
  // Get the Big Query input URI.
  const inputConfig = {
    bigquerySource: {
      inputUri: inputUri,
    },
  };

  // Get the Big Query output URI.
  const outputConfig = {
    bigqueryDestination: {
      outputUri: outputUri,
    },
  };

  const [, operation] = await automlClient.batchPredict({
    name: modelFullId,
    inputConfig: inputConfig,
    outputConfig: outputConfig,
  });

  // Get the latest state of long-running operation.
  console.log(`Operation name: ${operation.name}`);
}

batchPredict();

Python

A biblioteca de cliente para AutoML Tables inclui outros métodos Python que simplificam o uso da API AutoML Tables. Esses métodos se referem aos conjuntos de dados e aos modelos pelos nomes e não pelos IDs. É preciso que os nomes dos conjuntos de dados e modelos sejam exclusivos. Para mais informações, consulte a Referência do cliente.

Se os recursos estiverem localizados na região da UE, você precisará definir o endpoint explicitamente. Saiba mais. 

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_display_name = 'MODEL_DISPLAY_NAME_HERE'
# bq_input_uri = 'bq://my-project.my-dataset.my-table'
# bq_output_uri = 'bq://my-project'
# params = {}

from google.cloud import automl_v1beta1 as automl

client = automl.TablesClient(project=project_id, region=compute_region)

# Query model
response = client.batch_predict(
    bigquery_input_uri=bq_input_uri,
    bigquery_output_uri=bq_output_uri,
    model_display_name=model_display_name,
    params=params,
)
print("Making batch prediction... ")
# `response` is a async operation descriptor,
# you can register a callback for the operation to complete via `add_done_callback`:
# def callback(operation_future):
#   result = operation_future.result()
# response.add_done_callback(callback)
#
# or block the thread polling for the operation's results:
response.result()
# AutoML puts predictions in a newly generated dataset with a name by a mask "prediction_" + model_id + "_" + timestamp
# here's how to get the dataset name:
dataset_name = (
    response.metadata.batch_predict_details.output_info.bigquery_output_dataset
)

print(
    "Batch prediction complete.\nResults are in '{}' dataset.\n{}".format(
        dataset_name, response.metadata
    )
)

Como usar arquivos CSV no Cloud Storage

Os nomes das colunas e os tipos dos dados de entrada precisam corresponder aos dados usados no treinamento. As colunas podem ser ordenadas de modo diferente dos dados de treinamento.

Requisitos para arquivos CSV

  • A primeira linha da fonte de dados precisa conter os nomes das colunas.

  • Cada arquivo de fonte de dados não pode ser superior a 10 GB.

    É possível incluir vários arquivos até um máximo de 100 GB.

  • É preciso que o bucket do Cloud Storage esteja em conformidade com os requisitos de bucket.

  • Se o bucket do Cloud Storage estiver em um projeto diferente daquele em você usa o AutoML Tables, será preciso conceder o papel Storage Object Creator à conta de serviço do AutoML Tables no projeto. Saiba mais.

Console

  1. Acesse a página do AutoML Tables no console do Google Cloud.

    Acessar a página do AutoML Tables

  2. Selecione Modelos e abra o que você quer usar.

  3. Selecione a guia Testar e usar.

  4. Clique em Previsão em lote.

  5. Em Conjunto de dados de entrada, selecione CSVs do Cloud Storage e forneça o URI do bucket da fonte de dados.

  6. No caso de Resultado, selecione bucket do Cloud Storage e forneça o URI do bucket de destino.

  7. Se você quiser ver o impacto de cada recurso na previsão, selecione Gerar importância do atributo.

    A geração de importância de atributos aumenta o tempo e calcula os atributos necessários para sua previsão. A importância do recurso local não está disponível com um destino de resultados do Cloud Storage.

  8. Clique em Enviar previsão em lote para solicitá-la.

    Página de previsão em lote do AutoML Tables

REST

Para solicitar previsões em lote, use o método models.batchPredict.

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

  • endpoint: automl.googleapis.com para o local global e eu-automl.googleapis.com para a região da UE.
  • project-id: é seu ID do projeto no Google Cloud.
  • location: o local do recurso: us-central1 para global ou eu para a União Europeia.
  • model-id: o código do modelo. Por exemplo, TBL543.
  • input-bucket-name: o nome do bucket do Cloud Storage em que os dados de previsão estão localizados.
  • input-directory-name: o nome do diretório do Cloud Storage em que os dados de previsão estão localizados.
  • object-name: o nome do objeto do Cloud Storage em que os dados de previsão estão localizados.
  • output-bucket-name: o nome do bucket do Cloud Storage para os resultados de previsão.
  • output-directory-name: o nome do diretório do Cloud Storage para os resultados de previsão.

    O AutoML Tables cria uma subpasta para os resultados de previsão denominados prediction-<model_name>-<timestamp> em gs://output-bucket-name/output-directory-name. Você precisa ter permissões de gravação nesse caminho.

Método HTTP e URL: 

POST https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict

Corpo JSON da solicitação: 

{
  "inputConfig": {
    "gcsSource": {
      "inputUris": [
        "gs://input-bucket-name/input-directory-name/object-name.csv"
      ]
    },
  },
  "outputConfig": {
    "gcsDestination": {
      "outputUriPrefix": "gs://output-bucket-name/output-directory-name"
     },
  },
}

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 "x-goog-user-project: project-id" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict"

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"; "x-goog-user-project" = "project-id" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict" | Select-Object -Expand Content
A previsão em lote é uma operação de longa duração. É possível pesquisar o status da operação ou esperar que ela seja retornada. Saiba mais.

Para receber a importância do recurso local, adicione o parâmetro feature_importance aos dados da solicitação. Para mais informações, consulte Importância do recurso local.

Java

Se os recursos estiverem localizados na região da UE, você precisará definir o endpoint explicitamente. Saiba mais. 

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1beta1.BatchPredictInputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictOutputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictRequest;
import com.google.cloud.automl.v1beta1.BatchPredictResult;
import com.google.cloud.automl.v1beta1.GcsDestination;
import com.google.cloud.automl.v1beta1.GcsSource;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.OperationMetadata;
import com.google.cloud.automl.v1beta1.PredictionServiceClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

abstract class BatchPredict {

  static void batchPredict() throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String inputUri = "gs://YOUR_BUCKET_ID/path_to_your_input_csv_or_jsonl";
    String outputUri = "gs://YOUR_BUCKET_ID/path_to_save_results/";
    batchPredict(projectId, modelId, inputUri, outputUri);
  }

  static void batchPredict(String projectId, String modelId, String inputUri, String outputUri)
      throws IOException, ExecutionException, InterruptedException {
    // 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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);

      // Configure the source of the file from a GCS bucket
      GcsSource gcsSource = GcsSource.newBuilder().addInputUris(inputUri).build();
      BatchPredictInputConfig inputConfig =
          BatchPredictInputConfig.newBuilder().setGcsSource(gcsSource).build();

      // Configure where to store the output in a GCS bucket
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(outputUri).build();
      BatchPredictOutputConfig outputConfig =
          BatchPredictOutputConfig.newBuilder().setGcsDestination(gcsDestination).build();

      // Build the request that will be sent to the API
      BatchPredictRequest request =
          BatchPredictRequest.newBuilder()
              .setName(name.toString())
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();

      // Start an asynchronous request
      OperationFuture<BatchPredictResult, OperationMetadata> future =
          client.batchPredictAsync(request);

      System.out.println("Waiting for operation to complete...");
      future.get();
      System.out.println("Batch Prediction results saved to specified Cloud Storage bucket.");
    }
  }
}

Node.js

Se os recursos estiverem localizados na região da UE, você precisará definir o endpoint explicitamente. Saiba mais. 


/**
 * Demonstrates using the AutoML client to request prediction from
 * automl tables using GCS.
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const modelId = '[MODEL_ID]' e.g., "TBL4704590352927948800";
// const inputUri = '[GCS_PATH]' e.g., "gs://<bucket-name>/<csv file>",
// `The Google Cloud Storage URI containing the inputs`;
// const outputUriPrefix = '[GCS_PATH]'
// e.g., "gs://<bucket-name>/<folder-name>",
// `The destination Google Cloud Storage URI for storing outputs`;

const automl = require('@google-cloud/automl');

// Create client for prediction service.
const automlClient = new automl.v1beta1.PredictionServiceClient();

// Get the full path of the model.
const modelFullId = automlClient.modelPath(projectId, computeRegion, modelId);

async function batchPredict() {
  // Construct request
  const inputConfig = {
    gcsSource: {
      inputUris: [inputUri],
    },
  };

  // Get the Google Cloud Storage output URI.
  const outputConfig = {
    gcsDestination: {
      outputUriPrefix: outputUriPrefix,
    },
  };

  const [, operation] = await automlClient.batchPredict({
    name: modelFullId,
    inputConfig: inputConfig,
    outputConfig: outputConfig,
  });

  // Get the latest state of long-running operation.
  console.log(`Operation name: ${operation.name}`);
  return operation;
}

batchPredict();

Python

A biblioteca de cliente para AutoML Tables inclui outros métodos Python que simplificam o uso da API AutoML Tables. Esses métodos se referem aos conjuntos de dados e aos modelos pelos nomes e não pelos IDs. É preciso que os nomes dos conjuntos de dados e modelos sejam exclusivos. Para mais informações, consulte a Referência do cliente.

Se os recursos estiverem localizados na região da UE, você precisará definir o endpoint explicitamente. Saiba mais. 

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_display_name = 'MODEL_DISPLAY_NAME_HERE'
# gcs_input_uri = 'gs://YOUR_BUCKET_ID/path_to_your_input_csv'
# gcs_output_uri = 'gs://YOUR_BUCKET_ID/path_to_save_results/'
# params = {}

from google.cloud import automl_v1beta1 as automl

client = automl.TablesClient(project=project_id, region=compute_region)

# Query model
response = client.batch_predict(
    gcs_input_uris=gcs_input_uri,
    gcs_output_uri_prefix=gcs_output_uri,
    model_display_name=model_display_name,
    params=params,
)
print("Making batch prediction... ")
# `response` is a async operation descriptor,
# you can register a callback for the operation to complete via `add_done_callback`:
# def callback(operation_future):
#   result = operation_future.result()
# response.add_done_callback(callback)
#
# or block the thread polling for the operation's results:
response.result()

print(f"Batch prediction complete.\n{response.metadata}")

Como recuperar resultados

Como recuperar resultados de previsão no BigQuery

Se você tiver especificado o BigQuery como destino de saída, os resultados da solicitação de previsão em lote serão retornados como um novo conjunto de dados no projeto do BigQuery especificado. O conjunto de dados do BigQuery é o nome do modelo, precedido por "prediction_" e anexado com o carimbo de data/hora do momento em que o job de previsão foi iniciado. Encontre o nome do conjunto de dados do BigQuery em Previsões recentes, na página Previsão em lote da guia Testar e usar do seu modelo.

O conjunto de dados do BigQuery contém duas tabelas: predictions e errors. A tabela errors tem uma linha para cada linha da solicitação de previsão para que o AutoML Tables não conseguir retornar uma previsão, por exemplo, no caso de um recurso não anulável estar nulo. A tabela predictions contém uma linha para cada previsão retornada.

Na tabela predictions, o AutoML Tables retorna seus dados de previsão e cria uma nova coluna para os resultados de previsão com a adição de "predicted_" antes do nome da coluna de destino. A coluna com os resultados da previsão contém uma estrutura aninhada do BigQuery, contendo os resultados da previsão.

Use uma consulta no console do BigQuery para recuperar os resultados da previsão. O formato da consulta depende do seu tipo de modelo.

Classificação binária:

SELECT predicted_<target-column-name>[OFFSET(0)].tables AS value_1,
predicted_<target-column-name>[OFFSET(1)].tables AS value_2
FROM <bq-dataset-name>.predictions

"value_1" e "value_2" são marcadores de lugar. É possível substituí-los pelos valores de destino ou por um equivalente.

Classificação multiclasse:

SELECT predicted_<target-column-name>[OFFSET(0)].tables AS value_1,
predicted_<target-column-name>[OFFSET(1)].tables AS value_2,
predicted_<target-column-name>[OFFSET(2)].tables AS value_3,
...
predicted_<target-column-name>[OFFSET(4)].tables AS value_5
FROM <bq-dataset-name>.predictions

"valor_1", "valor_2" etc. são marcadores de lugar. É possível substituí-los pelos valores de destino ou por um equivalente.

Regressão:

SELECT predicted_<target-column-name>[OFFSET(0)].tables.value,
predicted_<target-column-name>[OFFSET(0)].tables.prediction_interval.start,
predicted_<target-column-name>[OFFSET(0)].tables.prediction_interval.end
FROM <bq-dataset-name>.predictions

Como recuperar resultados no 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 arquivos 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 foi iniciado. Encontre o nome da pasta do Cloud Storage em Previsões recentes, na parte inferior da página Previsão em lote da guia Testar e usar do modelo.

A pasta do Cloud Storage contém dois tipos de arquivos: arquivos de erro e arquivos de previsão. Se os resultados forem extensos, serão criados outros arquivos.

Os arquivos de erro são denominados errors_1.csv, errors_2.csv e assim por diante. Esses arquivos contêm uma linha de cabeçalho e uma linha para cada linha da solicitação de previsão para que o AutoML Tables não conseguir retornar uma previsão.

Os arquivos de previsão são denominados tables_1.csv, tables_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.

Nos arquivos de previsão, o AutoML Tables retorna os dados de previsão e cria uma ou mais colunas para os resultados da previsão, dependendo do 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.

A importância do recurso local não está disponível para resultados no Cloud Storage.

Como interpretar os resultados

A forma como você interpreta os resultados depende do problema comercial que você está buscando resolver e de como seus dados são distribuídos.

Como interpretar resultados de modelos de classificação

Os resultados de previsão para modelos de classificação (binários e multiclasses) retornam uma pontuação de probabilidade para cada valor potencial da coluna de destino. Você precisa determinar como quer usar as pontuações. Por exemplo, para receber uma classificação binária a partir das pontuações fornecidas, você identificaria um valor limite. Se houver duas classes, "A" e "B", classifique o exemplo como "A" se a pontuação de "A" for maior que o limite escolhido, e como "B" se for menor. Em conjuntos de dados desequilibrados, o limite pode se aproximar de 100% ou de 0%.

É possível usar o gráfico de curva de recall de precisão, o gráfico de curva do operador do receptor e outras estatísticas relevantes por rótulo na página Avaliar do modelo no Console do Google Cloud para ver como a alteração do limite altera suas métricas de avaliação. Isso ajuda você a determinar a melhor maneira de usar os valores de pontuação para interpretar os resultados da previsão.

Como interpretar os resultados em modelos de regressão

O valor esperado, que é retornado em modelos de regressão, pode ser usado diretamente para muitos tipos de problemas. Também é possível usar o intervalo de previsão, se ele for retornado e se um intervalo fizer sentido para seu problema de negócios.

Como interpretar os resultados de importância do recurso local

Para informações sobre como interpretar os resultados de importância do recurso local, consulte Importância do recurso local.

A seguir