Previsioni online

Questa pagina descrive come ottenere previsioni online (singole e a bassa latenza) da AutoML Tables.

Introduzione

Dopo aver creato (addestrato) un modello, puoi eseguirne il deployment e richiedere previsioni online (in tempo reale). Le previsioni online accettano una riga di dati e forniscono un risultato previsto in base al modello per i dati in questione. Le previsioni online sono utili per le previsioni come input per il flusso della logica di business.

Prima di poter richiedere una previsione online, devi eseguire il deployment del modello. I modelli di cui è stato eseguito il deployment sono soggetti ad addebiti. Quando hai finito di effettuare previsioni online, puoi annullare il deployment del modello per evitare ulteriori addebiti. Scopri di più.

I modelli devono essere riaddestrati ogni sei mesi per poter continuare a fornire previsioni.

Generare una previsione online

Console

In genere, si utilizzano le previsioni online per ottenere previsioni dalle applicazioni aziendali. Tuttavia, puoi utilizzare AutoML Tables nella console Google Cloud per testare il formato dei dati o il modello con un set di input specifico.

  1. Visita la pagina AutoML Tables nella console Google Cloud.

    Vai alla pagina AutoML Tables

  2. Seleziona Modelli e scegli il modello che vuoi utilizzare.

  3. Seleziona la scheda Testa e utilizza e fai clic su Previsione online.

  4. Se il deployment del modello non è stato ancora eseguito, esegui il deployment del modello facendo clic su Esegui il deployment del modello.

    Per utilizzare le previsioni online, devi eseguire il deployment del modello. Il deployment del modello prevede costi. Per ulteriori informazioni, consulta la pagina dei prezzi.

  5. Fornisci i valori di input nelle caselle di testo fornite.

    In alternativa, puoi selezionare Visualizzazione codice JSON per fornire i valori di input in formato JSON.

  6. Se vuoi vedere in che modo ogni caratteristica ha influito sulla previsione, seleziona Genera importanza delle caratteristiche.

    La console Google Cloud tronca i valori di importanza delle caratteristiche locali per la leggibilità. Se ti serve un valore esatto, usa l'API Cloud AutoML per effettuare la richiesta.

    Per informazioni sull'importanza delle caratteristiche, consulta Importanza delle caratteristiche locali.

  7. Fai clic su Previsione per visualizzare la previsione.

    Pagina di previsione di AutoML Tables

    Per informazioni sull'interpretazione dei risultati delle previsioni, consulta Interpretazione dei risultati delle previsioni. Per informazioni sull'importanza delle caratteristiche locali, consulta Importanza delle caratteristiche locali.

  8. (Facoltativo) Se non prevedi di richiedere altre previsioni online, puoi annullare il deployment del modello per evitare addebiti facendo clic su Annulla deployment modello.

curl

Per richiedere una previsione per un insieme di valori, crea l'oggetto JSON con i tuoi valori delle caratteristiche, quindi utilizza il metodo model.predict per ottenere la previsione.

I valori devono contenere esattamente le colonne incluse nell'addestramento e devono avere lo stesso ordine mostrato nella scheda Valuta facendo clic sul link delle colonne incluse.

Se vuoi riordinare i valori, puoi facoltativamente includere un insieme di ID delle specifiche di colonna nell'ordine dei valori. Puoi ottenere gli ID delle specifiche di colonna dall'oggetto model, che si trovano nel campo TablesModelMetadata.inputFeatureColumnSpecs.

Il tipo di dati di ogni valore (funzionalità) nell'oggetto Row dipende dal tipo di dati di AutoML Tables della funzionalità. Per un elenco dei tipi di dati accettati in base al tipo di dati AutoML Tables, consulta Formato degli oggetti riga.

  1. Se non hai ancora eseguito il deployment del modello, esegui subito il deployment. Scopri di più.

  2. Richiedi la previsione.

    Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

    • endpoint: automl.googleapis.com per la località globale e eu-automl.googleapis.com per la regione dell'UE.
    • project-id: il tuo ID progetto Google Cloud.
    • location: la località per la risorsa: us-central1 per Globale o eu per l'Unione Europea.
    • model-id: l'ID del modello. Ad esempio, TBL543.
    • valueN: i valori di ogni colonna, nell'ordine corretto.

    Metodo HTTP e URL: 

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

    Corpo JSON della richiesta: 

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

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    arricciatura

    Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

    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:predict"

    PowerShell

    Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

    $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:predict" | Select-Object -Expand Content
    Per includere i risultati relativi all'importanza delle caratteristiche locali, includi il parametro feature_importance. Per saperne di più sull'importanza delle caratteristiche locali, consulta Importanza delle caratteristiche locali.

  3. Visualizza i risultati.

    Per un modello di classificazione, dovresti vedere un output simile al seguente esempio. Tieni presente che vengono restituiti due risultati, ciascuno con una stima di affidabilità (score). La stima di confidenza è compresa tra 0 e 1 e mostra la probabilità che il modello ritenga che questo sia il valore di previsione corretto. Per saperne di più su come utilizzare la stima di affidabilità, consulta Interpretazione dei risultati della previsione.

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

    Per un modello di regressione, i risultati includono un valore di previsione e un intervallo di previsione. L'intervallo di previsione fornisce un intervallo che include il valore reale il 95% delle volte (in base ai dati su cui il modello è stato addestrato). Tieni presente che il valore previsto potrebbe non essere centrato nell'intervallo (potrebbe anche non rientrare nell'intervallo), perché l'intervallo di previsione è incentrato sulla mediana, mentre il valore previsto è il valore previsto (o la media).

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

    Per informazioni sui risultati relativi all'importanza delle caratteristiche locali, consulta Importanza delle caratteristiche locali.

  4. (Facoltativo) Se hai finito di richiedere previsioni online, puoi annullare il deployment del modello per evitare addebiti. Scopri di più.

Java

Se le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Scopri di più. 

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 le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Scopri di più. 


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

La libreria client per AutoML Tables include metodi Python aggiuntivi che semplificano l'utilizzo dell'API AutoML Tables. Questi metodi fanno riferimento a set di dati e modelli per nome anziché per ID. I nomi dei set di dati e dei modelli devono essere univoci. Per maggiori informazioni, consulta la documentazione di riferimento per i client.

Se le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Scopri di più. 

# 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(f"Predicted class name: {result.tables.value}")
    print(f"Predicted class score: {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)

Passaggi successivi