Prédictions en ligne

Cette page décrit comment obtenir des prédictions en ligne (uniques et à faible latence) à partir d'AutoML Tables.

Introduction

Une fois que vous avez créé (entraîné) un modèle, vous pouvez le déployer et demander des prédictions en ligne (en temps réel). Celles-ci acceptent une ligne de données et fournissent un résultat prédit basé sur votre modèle pour ces données. Les prédictions en ligne permettent de fournir des données prévisionnelles en entrée dans votre flux de logique métier.

Avant de pouvoir demander une prédiction en ligne, vous devez déployer votre modèle. Des frais sont appliqués aux modèles déployés. Pour les éviter, vous pouvez annuler le déploiement de votre modèle une fois que vous avez terminé les opérations de prédiction en ligne. En savoir plus

Les modèles doivent être réentraînés tous les six mois pour continuer à fournir des prédictions.

Obtenir une prédiction en ligne

Console

En règle générale, les prédictions en ligne sont demandées pour obtenir des données prévisionnelles à partir d'applications métier. Toutefois, vous pouvez utiliser AutoML Tables dans la console Google Cloud pour tester votre format de données ou votre modèle avec un ensemble d'entrées spécifique.

  1. Accédez à la page AutoML Tables dans la console Google Cloud.

    Accéder à la page AutoML Tables

  2. Cliquez sur Modèles et sélectionnez le modèle que vous souhaitez utiliser.

  3. Cliquez sur l'onglet Test et utilisation, puis sur Prédiction en ligne.

  4. Si votre modèle n'est pas encore déployé, déployez-le maintenant en cliquant sur Deploy model (Déployer le modèle).

    Pour pouvoir utiliser les prédictions en ligne, le modèle doit être déployé. Le déploiement de votre modèle entraîne des frais. Pour en savoir plus, consultez la page des tarifs.

  5. Indiquez les valeurs d'entrée dans les zones de texte.

    Vous pouvez également cliquer sur Afficher le code JSON pour indiquer vos valeurs d'entrée au format JSON.

  6. Pour connaître l'incidence de chaque caractéristique sur la prédiction, cliquez sur Générer l'importance des caractéristiques.

    La console Google Cloud tronque les valeurs d'importance des caractéristiques locales pour une meilleure lisibilité. Si vous avez besoin d'une valeur exacte, utilisez l'API Cloud AutoML pour effectuer la requête de prédiction.

    Pour plus d'informations sur l'importance des caractéristiques, consultez la page Importance des caractéristiques locales.

  7. Cliquez sur Predict (Prédiction) pour obtenir votre prédiction.

    Page "Prédiction" d'AutoML Tables

    Pour plus d'informations sur l'interprétation des résultats de la prédiction, consultez la page Interpréter les résultats de vos prédictions. Pour plus d'informations sur l'importance des caractéristiques locales, consultez la page Importance des caractéristiques locales.

  8. (Facultatif) Si vous ne prévoyez pas de demander d'autres prédictions en ligne, vous pouvez annuler le déploiement de votre modèle pour éviter des frais supplémentaires. Pour cela, cliquez sur Undeploy model (Annuler le déploiement du modèle).

curl

Vous demandez une prédiction pour un ensemble de valeurs en créant un objet JSON contenant vos valeurs de caractéristiques, puis en utilisant la méthode model.predict pour obtenir la prédiction.

Les valeurs doivent contenir les colonnes exactement comme vous les avez configurées pour l'entraînement, dans le même ordre qu'affiché dans l'onglet Évaluation lorsque vous cliquez sur un lien de colonne.

Si vous souhaitez réorganiser les valeurs, vous pouvez également inclure un ensemble d'ID de spécifications de colonne dans l'ordre des valeurs. Les ID de spécifications de colonne sont indiqués dans votre objet de modèle, dans le champ TablesModelMetadata.inputFeatureColumnSpecs.

Dans l'objet Ligne, le type de données de chaque valeur (caractéristique) dépend du type de données AutoML Tables de la caractéristique. Pour obtenir une liste des types de données acceptés par type de données AutoML Tables, consultez la section Format d'objet Ligne.

  1. Si vous n'avez pas encore déployé votre modèle, déployez-le maintenant. En savoir plus

  2. Demandez la prédiction.

    Avant d'utiliser les données de requête, effectuez les remplacements suivants:

    • endpoint: automl.googleapis.com pour la zone internationale et eu-automl.googleapis.com pour la région UE.
    • project-id : ID de votre projet Google Cloud.
    • location : emplacement de la ressource : us-central1 pour l'emplacement mondial ou eu pour l'Union européenne.
    • model-id : ID du modèle. Par exemple, TBL543.
    • valueN : valeurs de chaque colonne, dans le bon ordre.

    Méthode HTTP et URL : 

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

    Corps JSON de la requête : 

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

    Pour envoyer votre requête, choisissez l'une des options suivantes :

    curl

    Enregistrez le corps de la requête dans un fichier nommé request.json et exécutez la commande suivante: 

    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

    Enregistrez le corps de la requête dans un fichier nommé request.json et exécutez la commande suivante: 

    $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
      Pour inclure les résultats de l'importance des caractéristiques locales, ajoutez le paramètre feature_importance. Pour plus d'informations sur l'importance des caractéristiques locales, consultez la page Importance des caractéristiques locales.

  3. Consultez vos résultats.

    Pour un modèle de classification, vous devriez obtenir un résultat semblable à l'exemple ci-après. Notez que deux résultats s'affichent, chacun avec une estimation du niveau de confiance (score). Le score de confiance se situe entre 0 et 1 et indique dans quelle mesure le modèle considère qu'il s'agit de la valeur de prédiction correcte. Pour plus d'informations sur l'utilisation de l'estimation du niveau de confiance, consultez la page Interpréter les résultats de vos prédictions.

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

    Pour un modèle de régression, les résultats incluent une valeur de prédiction et un intervalle de prédiction. L'intervalle de prédiction fournit une plage qui inclut la bonne valeur 95 % du temps (en fonction des données sur lesquelles le modèle a été entraîné). Notez que la valeur prédite peut ne pas être centrée dans l'intervalle (elle peut même tomber en dehors de l'intervalle), car l'intervalle de prédiction est centré autour de la médiane, tandis que la valeur prédite est la valeur attendue (ou moyenne).

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

    Pour plus d'informations sur les résultats de l'importance des caractéristiques locales, consultez la page Importance des caractéristiques locales.

  4. (Facultatif) Si vous n'avez plus de prédictions en ligne à demander, vous pouvez annuler le déploiement du modèle pour éviter des frais supplémentaires. En savoir plus

Java

Si vos ressources sont situées dans la région UE, vous devez définir explicitement le point de terminaison. En savoir plus 

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 vos ressources sont situées dans la région UE, vous devez définir explicitement le point de terminaison. En savoir plus 


/**
 * 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 bibliothèque cliente AutoML Tables comprend des méthodes Python supplémentaires qui simplifient l'utilisation de l'API AutoML Tables. Ces méthodes référencent les ensembles de données et les modèles par nom et non par identifiant. L'ensemble de données et les noms de modèles doivent être uniques. Pour plus d'informations, consultez la documentation de référence du client.

Si vos ressources sont situées dans la région UE, vous devez définir explicitement le point de terminaison. En savoir plus 

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

Étapes suivantes