Predicciones en línea

En esta página, se describe cómo obtener predicciones en línea (con una sola latencia baja) de AutoML Tables.

Introducción

Después de crear (entrenar) un modelo, puedes implementar el modelo y solicitar predicciones en línea (en tiempo real). Las predicciones en línea aceptan una fila de datos y proporcionan un resultado previsto según tu modelo para esos datos. Usas predicciones en línea cuando necesitas una predicción como entrada para tu flujo de lógica empresarial.

Antes de poder solicitar una predicción en línea, debes implementar tu modelo. Los modelos implementados generan cargos. Cuando termines de realizar las predicciones en línea, puedes anular la implementación de tu modelo para evitar que se generen más cargos. Más información.

Obtén una predicción en línea

Console

En general, usas predicciones en línea para obtener predicciones desde las aplicaciones de tu empresa. Sin embargo, puedes usar AutoML Tables en Cloud Console para probar tu formato de datos o tu modelo con un conjunto de entradas específico.

  1. Visita la página AutoML Tables en Google Cloud Console.

    Ir a la página AutoML Tables

  2. Selecciona Modelos y elige el modelo que deseas usar.

  3. Selecciona la pestaña Probar y usar y haz clic en Predicción en línea.

  4. Si el modelo aún no se implementó, haz clic en Implementar modelo para implementarlo ahora.

    Se deben implementar los modelos para usar las predicciones en línea. La implementación del modelo genera costos. Para obtener más información, consulta la página Precios.

  5. Proporciona los valores de entrada en los cuadros de texto proporcionados.

    Como alternativa, puedes seleccionar Vista de código JSON para proporcionar los valores de entrada en formato JSON.

  6. Si deseas ver cómo cada atributo influyó en la predicción, selecciona Generar importancia de atributos.

    Google Cloud Console trunca los valores de importancia del atributo local para facilitar su lectura. Si necesitas un valor exacto, usa la API de Cloud AutoML para realizar la solicitud de predicción.

    Para obtener información sobre la importancia de las características, consulta la sección sobre la importancia de las características locales.

  7. Haz clic en Predecir (Predict) para obtener tu predicción.

    Página de predicción de AutoML Tables

    Para obtener información sobre cómo interpretar tus resultados de predicción, consulta la sección acerca de cómo interpretar tus resultados de predicción. Para obtener información sobre la importancia de los atributos locales, consulta la sección sobre la importancia de los atributos locales.

  8. Si no deseas solicitar más predicciones en línea, haz clic en Anular implementación a fin de anular la implementación de tu modelo para evitar cargos de implementación (opcional).

curl

Solicitas una predicción para un conjunto de valores mediante la creación de tu objeto JSON con los valores de tus atributos y, luego, usas el método model.predict a fin de obtener la predicción.

Los valores deben contener las columnas exactas que incluiste en el entrenamiento y deben estar en el mismo orden que se muestra en la pestaña Evaluar cuando haces clic en el vínculo de columnas incluidas.

Si deseas reordenar los valores, puedes incluir, de manera opcional, un conjunto de ID de especificaciones de columna en el orden de los valores. Puedes obtener los ID de las especificaciones de columna de tu objeto de modelo. Se encuentran en el campo TablesModelMetadata.inputFeatureColumnSpecs.

El tipo de datos de cada valor (atributo) en el objeto de fila depende del tipo de datos de AutoML Tables del atributo. Para obtener una lista de los tipos de datos que acepta el tipo de datos de AutoML Tables, consulta la sección sobre el formato del objeto de fila.

  1. Si aún no implementaste tu modelo, impleméntalo ahora. Más información

  2. Solicita la predicción.

    Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

    • endpoint: automl.googleapis.com para la ubicación global y eu-automl.googleapis.com para la región de la UE
    • project-id: Es el ID de tu proyecto de Google Cloud
    • location: la ubicación del recurso: us-central1 para la global o eu para la Unión Europea
    • model-id: El ID del modelo. Por ejemplo, TBL543
    • valueN: los valores de cada columna, en el orden correcto.

    Método HTTP y URL:

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

    Cuerpo JSON de la solicitud:

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

    Para enviar tu solicitud, elige una de estas opciones:

    curl

    Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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

    Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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 los resultados de importancia de las características locales, incluye el parámetro feature_importance. Para obtener información sobre la importancia de las características locales, consulta la sección sobre la importancia de las características locales.

  3. Visualiza los resultados.

    Para un modelo de clasificación, deberías ver un resultado similar al siguiente ejemplo. Ten en cuenta que se muestran dos resultados, cada uno con una estimación de confianza (score). La estimación de confianza está entre 0 y 1, y muestra la probabilidad de que el modelo piense que este es el valor de predicción correcto. Para obtener más información sobre cómo usar la estimación de confianza, consulta la sección sobre cómo interpretar tus resultados de predicción.

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

    En el caso de un modelo de regresión, los resultados incluyen un valor de predicción y un intervalo de predicción. El intervalo de predicción proporciona un rango que incluye el 95% del valor verdadero del tiempo (según los datos en los que se entrenó el modelo). Ten en cuenta que el valor previsto podría no estar centrado en el intervalo (incluso podría estar fuera del intervalo), ya que el intervalo de predicción se centra en la mediana, mientras que el valor previsto es el valor esperado (o la media).

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

    Para obtener información acerca de los resultados de importancia de los atributos locales, consulta la página sobre la importancia de los atributos locales.

  4. Si terminaste de solicitar las predicciones en línea, puedes anular la implementación de tu modelo para evitar cargos de implementación (opcional). Más información

Java

Si tus recursos se encuentran en la región de la UE, debes establecer el extremo de manera explícita. Más información.

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

Si tus recursos se encuentran en la región de la UE, debes establecer el extremo de manera explícita. Más información


/**
 * 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);

inputs = JSON.parse(inputs);

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

La biblioteca cliente de AutoML Tables incluye métodos adicionales de Python que simplifican el uso de la API de AutoML Tables. Estos métodos hacen referencia a conjuntos de datos y modelos por nombre en lugar de ID. El conjunto de datos y los nombres de los modelos deben ser únicos. Para obtener más información, consulta la página de referencia del cliente.

Si tus recursos se encuentran en la región de la UE, debes establecer el extremo de manera explícita. Más información

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

Qué sigue