Previsões on-line

Nesta página, você aprenderá como receber predições on-line (únicas e de baixa latência) usando o AutoML Tables.

Introdução

Após criar (treinar) um modelo, será possível implantá-lo e solicitar predições on-line (em tempo real). As predições on-line aceitam uma linha de dados e fornecem um resultado previsto com base no modelo aplicado a esses dados. As predições on-line são úteis para quando você precisar usar uma predição como entrada do fluxo de lógica de negócios.

Para solicitar uma predição on-line, primeiro é necessário implantar o modelo. Modelos implantados geram cobranças. Quando você terminar de fazer as predições on-line, poderá remover a implantação do modelo para evitar cobranças futuras. Saiba mais.

Os modelos precisam ser retreinados periodicamente para que possam continuar a fornecer previsões. Para previsões que não são essenciais, é preciso retreinar o modelo a cada dois anos. Para previsões mais importantes, é preciso retreinar o modelo a cada seis meses.

Como receber uma predição on-line

Console

Geralmente, as predições on-line são usadas para conseguir predições internas de aplicativos comerciais. No entanto, é possível usar o AutoML Tables no Console do Google Cloud para testar o formato dos dados ou o modelo com um conjunto específico de entrada.

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

    Acessar a página do AutoML Tables

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

  3. Selecione a guia Testar e usar e clique em Previsão on-line.

  4. Se o modelo ainda não foi implementado, faça-o agora clicando em Implementar modelo.

    É necessário que o modelo esteja implementado para fazer predições on-line. A implantação do modelo gera custos. Para mais informações, consulte a página de preços.

  5. Insira seus valores de entrada nas caixas de texto disponíveis.

    Outra alternativa é selecionar Visualização de código JSON para inserir os valores de entrada no formato JSON.

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

    O Console do Google Cloud trunca os valores de importância do recurso local para facilitar a leitura. Se você precisar de um valor exato, use a API Cloud AutoML para fazer a solicitação de previsão.

    Para informações sobre a importância do recurso, consulte Importância do recurso local.

  7. Clique em Prever para receber a previsão.

    Página de previsões do AutoML Tables

    Para informações sobre como interpretar os resultados da previsão, consulte Como interpretar os resultados da sua previsão. Para informações sobre a importância de atributos locais, consulte Importância do atributo local.

  8. (Opcional) Se você não planeja solicitar mais previsões on-line, poderá remover a implantação do modelo para evitar cobranças. Para fazer isso, basta clicar em Cancelar a implantação do modelo.

curl

É possível solicitar uma previsão para um conjunto de valores, basta criar seu objeto JSON com os valores do elemento e, em seguida, usar o método model.predict para receber a previsão.

É necessário que os valores contenham as colunas exatas incluídas no treinamento. Além disso, eles precisam estar na mesma ordem mostrada na guia Avaliar, que você vê ao clicar no link das colunas incluídas.

Para reordenar os valores, inclua opcionalmente um conjunto de IDs de especificação de coluna na mesma ordem dos valores. Para saber os IDs de especificação de coluna do objeto do modelo, veja o campo TablesModelMetadata.inputFeatureColumnSpecs.

O tipo de dados de cada valor (atributo) no objeto Row depende do tipo de dados designado ao atributo no AutoML Tables. Consulte Formato de objeto Row para ver a lista de tipos de dados aceitos, de acordo com cada tipo de dados do AutoML Tables.

  1. Se você ainda não implantou o modelo, faça-o agora. Saiba mais.

  2. Solicite a previsão.

    Antes de usar qualquer um dos dados da solicitação, faça as seguintes substituições:

    • 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.
    • valueN: os valores de cada coluna, na ordem correta.

    Método HTTP e URL:

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

    Corpo JSON da solicitação:

    {
      "payload": {
        "row": {
          "values": [
            value1, value2,...
          ]
        }
      }
    }
    

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

    curl

    Salve o corpo da solicitação em um arquivo chamado request.json e execute o seguinte comando:

    curl -X POST \
    -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:predict"

    PowerShell

    Salve o corpo da solicitação em um arquivo chamado request.json e execute o seguinte comando:

    $cred = gcloud auth application-default print-access-token
    $headers = @{ "Authorization" = "Bearer $cred" }

    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:predict" | Select-Object -Expand Content
    Para incluir os resultados de importância de recursos locais, inclua o parâmetro feature_importance. Para mais informações sobre a importância do recurso local, consulte Importância do recurso local.

  3. Ver os resultados.

    No caso de modelos de classificação, o resultado será semelhante ao exemplo a abaixo. Observe que dois resultados são retornados, cada um com uma estimativa de confiança (score). A estimativa de confiança fica entre 0 e 1 e mostra a probabilidade de que o modelo ache que esse é o valor de previsão correto. Para mais informações sobre como usar a estimativa de confiança, consulte Como interpretar os resultados da sua previsão.

    {
     "payload": [
       {
         "tables": {
           "score": 0.11210235,
           "value": "1"
         }
       },
       {
         "tables": {
           "score": 0.8878976,
           "value": "2"
         }
       }
     ]
    }
    

    Para um modelo de regressão, os resultados incluem um valor de predição e um intervalo de predição. O intervalo de previsão fornece um intervalo que inclui o valor verdadeiro em 95% do tempo (com base nos dados em que o modelo foi treinado). O valor previsto pode não ser centralizado no intervalo (ele pode até estar fora do intervalo), porque o intervalo de previsão é centrada em torno da mediana, enquanto o valor previsto é o valor esperado (ou médio).

    {
     "payload": [
       {
         "tables": {
           "value": 207.18209838867188,
           "predictionInterval": {
             "start": 29.712770462036133,
             "end": 937.42041015625
           }
         }
       }
     ]
    }
    

    Para informações sobre os resultados de importância de atributos locais, consulte Importância do atributo local.

  4. (Opcional) Se você não quiser solicitar mais predições on-line, poderá remover a implantação do modelo para evitar cobranças. Saiba mais.

Java

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

import com.google.cloud.automl.v1beta1.AnnotationPayload;
import com.google.cloud.automl.v1beta1.ExamplePayload;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.PredictRequest;
import com.google.cloud.automl.v1beta1.PredictResponse;
import com.google.cloud.automl.v1beta1.PredictionServiceClient;
import com.google.cloud.automl.v1beta1.Row;
import com.google.cloud.automl.v1beta1.TablesAnnotation;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

class TablesPredict {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    // Values should match the input expected by your model.
    List<Value> values = new ArrayList<>();
    // values.add(Value.newBuilder().setBoolValue(true).build());
    // values.add(Value.newBuilder().setNumberValue(10).build());
    // values.add(Value.newBuilder().setStringValue("YOUR_STRING").build());
    predict(projectId, modelId, values);
  }

  static void predict(String projectId, String modelId, List<Value> values) throws IOException {
    // 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);
      Row row = Row.newBuilder().addAllValues(values).build();
      ExamplePayload payload = ExamplePayload.newBuilder().setRow(row).build();

      // Feature importance gives you visibility into how the features in a specific prediction
      // request informed the resulting prediction. For more info, see:
      // https://cloud.google.com/automl-tables/docs/features#local
      PredictRequest request =
          PredictRequest.newBuilder()
              .setName(name.toString())
              .setPayload(payload)
              .putParams("feature_importance", "true")
              .build();

      PredictResponse response = client.predict(request);

      System.out.println("Prediction results:");
      for (AnnotationPayload annotationPayload : response.getPayloadList()) {
        TablesAnnotation tablesAnnotation = annotationPayload.getTables();
        System.out.format(
            "Classification label: %s%n", tablesAnnotation.getValue().getStringValue());
        System.out.format("Classification score: %.3f%n", tablesAnnotation.getScore());
        // Get features of top importance
        tablesAnnotation
            .getTablesModelColumnInfoList()
            .forEach(
                info ->
                    System.out.format(
                        "\tColumn: %s - Importance: %.2f%n",
                        info.getColumnDisplayName(), info.getFeatureImportance()));
      }
    }
  }
}

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 csv.
 * 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., "TBL000000000000";
// const inputs = [{ numberValue: 1 }, { stringValue: 'value' }, { stringValue: 'value2' } ...]

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 predict() {
  // Set the payload by giving the row values.
  const payload = {
    row: {
      values: inputs,
    },
  };

  // Params is additional domain-specific parameters.
  // Currently there is no additional parameters supported.
  const [response] = await automlClient.predict({
    name: modelFullId,
    payload: payload,
    params: {feature_importance: true},
  });
  console.log('Prediction results:');

  for (const result of response.payload) {
    console.log(`Predicted class name: ${result.displayName}`);
    console.log(`Predicted class score: ${result.tables.score}`);

    // Get features of top importance
    const featureList = result.tables.tablesModelColumnInfo.map(
      columnInfo => {
        return {
          importance: columnInfo.featureImportance,
          displayName: columnInfo.columnDisplayName,
        };
      }
    );
    // Sort features by their importance, highest importance first
    featureList.sort((a, b) => {
      return b.importance - a.importance;
    });

    // Print top 10 important features
    console.log('Features of top importance');
    console.log(featureList.slice(0, 10));
  }
}
predict();

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'
# inputs = {'value': 3, ...}

from google.cloud import automl_v1beta1 as automl

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

if feature_importance:
    response = client.predict(
        model_display_name=model_display_name,
        inputs=inputs,
        feature_importance=True,
    )
else:
    response = client.predict(
        model_display_name=model_display_name, inputs=inputs
    )

print("Prediction results:")
for result in response.payload:
    print(
        "Predicted class name: {}".format(result.tables.value)
    )
    print("Predicted class score: {}".format(result.tables.score))

    if feature_importance:
        # get features of top importance
        feat_list = [
            (column.feature_importance, column.column_display_name)
            for column in result.tables.tables_model_column_info
        ]
        feat_list.sort(reverse=True)
        if len(feat_list) < 10:
            feat_to_show = len(feat_list)
        else:
            feat_to_show = 10

        print("Features of top importance:")
        for feat in feat_list[:feat_to_show]:
            print(feat)

A seguir