Previsioni online

In questa pagina viene descritto come ottenere previsioni online (singole e a bassa latenza) da tabelle AutoML.

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 basato sul modello per tali dati. Utilizzi le previsioni online quando hai bisogno di una previsione come input per il flusso della logica di business.

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

I modelli devono essere riaddestrati periodicamente in modo che possano continuare a fornire previsioni. Per le previsioni senza importanza della caratteristica, un modello deve essere riaddestrato ogni due anni. Per le previsioni con importanza della caratteristica, un modello deve essere addestrato ogni sei mesi.

Richiedere una previsione online

Console

In genere, utilizzi le previsioni online per ottenere previsioni dalle tue applicazioni aziendali. Tuttavia, puoi utilizzare AutoML Tables in Cloud Console per testare il tuo formato dati o il tuo modello con un set di input specifico.

  1. Visita la pagina AutoML Tables in Google Cloud Console.

    Vai alla pagina Tabelle AutoML

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

  3. Seleziona la scheda Test & Use (Prova e utilizzo) e fai clic su Online previsione (Previsione online).

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

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

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

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

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

    Google Cloud Console tronca i valori di importanza delle funzionalità locali per favorire la leggibilità. Se hai bisogno di un valore esatto, utilizza l'API Cloud AutoML per effettuare la richiesta di previsione.

    Per informazioni sull'importanza delle funzionalità, consulta importanza delle funzionalità locali.

  7. Fai clic su Previsione per ottenere la previsione.

    Pagina di previsione delle tabelle AutoML

    Per informazioni sull'interpretazione dei risultati della previsione, consulta la sezione Interpretare i risultati delle previsioni. Per informazioni sull'importanza delle funzionalità locali, consulta la sezione Importanza delle funzionalità locali.

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

Curling

Per richiedere una previsione per un insieme di valori, crea un oggetto JSON con i valori delle tue funzionalità e poi utilizza il metodo model.predict per ottenere la previsione.

I valori devono contenere le colonne esatte incluse nell'addestramento e devono seguire lo stesso ordine indicato nella scheda Valutazione facendo clic sul link delle colonne incluse.

Se vuoi riordinare i valori, puoi includere una serie di ID delle colonne nell'ordine in cui sono specificati. Puoi ottenere gli ID delle specifiche della colonna dall'oggetto del modello, che si trovano nel campo TablesModelMetadata.inputFeatureColumnSpecs.

Il tipo di dati di ogni valore (feature) nell'oggetto Row dipende dal tipo di dati Tabs di AutoML per la funzionalità. Per un elenco dei tipi di dati accettati per tipo di dati AutoML Tables, consulta Formato oggetto riga.

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

  2. Richiedi la previsione.

    Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

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

    Metodo HTTP e URL:

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

    Corpo JSON richiesta:

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

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    Curling

    Salva il corpo della richiesta in un file denominato request.json ed esegui il seguente 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

    Salva il corpo della richiesta in un file denominato request.json ed esegui il seguente 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
    Per includere i risultati di importanza delle funzionalità locali, includi il parametro feature_importance. Per saperne di più sull'importanza delle funzionalità locali, consulta Importanza della funzionalità locale.

  3. Visualizzare i risultati.

    Per un modello di classificazione, dovresti vedere un output simile all'esempio riportato di seguito. Tieni presente che vengono restituiti due risultati, ognuno con una stima dell'affidabilità (score). La stima dell'affidabilità è compresa tra 0 e 1 e mostra la probabilità che il modello rappresenti il valore corretto della previsione. Per scoprire di più su come utilizzare la stima di affidabilità, consulta Interpretare i risultati delle previsioni.

    {
     "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 vero valore del 95% delle volte (in base ai dati su cui è stato addestrato il modello). Tieni presente che il valore previsto potrebbe non essere centrato nell'intervallo (potrebbe persino non rientrare nell'intervallo), perché l'intervallo di previsione è centrato intorno alla mediana, mentre il valore previsto è il valore previsto (o medio).

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

    Per informazioni sull'importanza delle funzionalità locali, consulta Importanza dell'importanza delle funzionalità locali.

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

Java

Se le risorse si trovano nell'area geografica 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 nell'area geografica 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 si riferiscono a set di dati e modelli in base al nome anziché all'ID. I nomi del set di dati e del modello devono essere univoci. Per ulteriori informazioni, consulta la sezione Riferimento client.

Se le risorse si trovano nell'area geografica 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(
        "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)

Passaggi successivi