Obtenir des prédictions en ligne

La prédiction en ligne AI Platform Prediction est un service optimisé pour faire traiter vos données par des modèles hébergés avec le moins de latence possible. Vous envoyez de petits lots de données au service, et il renvoie vos prédictions dans la réponse.

Apprenez-en plus sur la prédiction en ligne par rapport à la prédiction par lot ou lisez la présentation des concepts liés à la prédiction.

Avant de commencer

Avant de lancer une requête de prédiction, vous devez suivre ces étapes :

Régions

La prédiction en ligne est disponible dans certaines régions. De plus, différents types de machines sont disponibles dans chaque région. Pour en savoir plus sur la disponibilité de la prédiction en ligne dans chaque région, consultez le guide des régions.

Créer des modèles et des versions

Vous devez prendre les décisions importantes suivantes concernant l'exécution de la prédiction en ligne lors de la création des ressources de modèle et de version :

Ressource créée Décision requise lors de la création de ressource
Modèle Région dans laquelle exécuter les prédictions
Modèle Activer la journalisation des prévisions en ligne
Version Version d'exécution à utiliser
Version Version Python à utiliser
Version Type de machine à utiliser pour la prédiction en ligne

Après la création initiale du modèle ou de la version, vous ne pourrez plus mettre à jour les paramètres répertoriés ci-dessus. Si vous devez les modifier, créez une autre ressource de modèle ou de version avec les nouveaux paramètres et déployez à nouveau votre modèle.

Types de machines disponibles pour la prédiction en ligne

Lorsque vous créez une version, vous pouvez choisir le type de machine virtuelle à utiliser par AI Platform Prediction pour les nœuds de prédiction en ligne. Apprenez-en plus sur les types de machines.

Obtenir les journaux pour les requêtes de prédiction en ligne

Par défaut, le service de prédiction AI Platform Prediction ne fournit pas d'informations journalisées sur les requêtes, car la journalisation entraîne des coûts. La prédiction en ligne à un taux élevé de requêtes par seconde peut produire un nombre important de journaux, qui sont soumis aux règles de tarification de Cloud Logging ou aux règles de tarification de BigQuery.

Si vous souhaitez activer la journalisation des prédictions en ligne, vous devez la configurer soit lorsque vous créez une ressource de modèle, soit lorsque vous créez une ressource de version de modèle, suivant le type de journalisation que vous souhaitez activer. Il existe trois types de journalisation que vous pouvez activer indépendamment :

  • La journalisation des accès, qui consigne dans Cloud Logging des informations telles que l'horodatage et la latence associés à chaque requête.

    Vous pouvez activer la journalisation des accès lorsque vous créez une ressource de modèle.

  • La journalisation de la console, qui consigne dans Cloud Logging les flux stderr et stdout provenant des nœuds de prédiction. Elle peut être utile pour le débogage. Ce type de journalisation est en version bêta pour les types de machines Compute Engine (N1) et en disponibilité générale pour les anciens types de machines (MLS1).

    Vous pouvez activer la journalisation de la console lorsque vous créez une ressource de modèle.

  • La journalisation des requêtes et réponses, qui consigne un échantillon de requêtes de prédiction en ligne et de réponses dans une table BigQuery. Ce type de journalisation est en version bêta.

    Vous pouvez activer la journalisation des requêtes et réponses en créant une ressource de version de modèle, puis en mettant à jour cette version.

gcloud

Pour activer la journalisation des accès, incluez l'indicateur --enable-logging lorsque vous créez votre modèle à l'aide de la commande gcloud ai-platform models create. Exemple :

gcloud ai-platform models create MODEL_NAME \
  --region=us-central1 \
  --enable-logging

Pour activer la journalisation de la console (version bêta), utilisez le composant gcloud beta et incluez l'option --enable-console-logging. Exemple :

gcloud components install beta

gcloud beta ai-platform models create MODEL_NAME \
  --region=us-central1 \
  --enable-console-logging

À l'heure actuelle, il n'est pas possible d'utiliser l'outil gcloud pour activer la journalisation des requêtes et réponses (version bêta). Vous ne pouvez activer ce type de journalisation que lorsque vous envoyez une requête projects.models.versions.patch à l'API REST.

API REST

Pour activer la journalisation des accès, définissez l'attribut onlinePredictionLogging à la valeur True dans la ressource de modèle lorsque vous créez celui-ci à l'aide de projects.models.create.

Pour activer la journalisation de la console (version bêta), définissez le champ onlinePredictionConsoleLogging sur True dans la ressource de modèle.

Journalisation des requêtes et réponses

Contrairement aux autres types de journalisation, vous ne pouvez pas activer la journalisation des requêtes et réponses lors de la création d'un modèle. Par contre, vous pouvez l'activer à l'aide de la méthode projects.models.versions.patch sur une version de modèle existante. (Vous devez au préalable créer la version de modèle à l'aide de Google Cloud Console, de l'outil gcloud ou de l'API REST.)

Pour activer la journalisation des requêtes et réponses, saisissez les éléments suivants dans le champ requestLoggingConfig de la ressource de version :

  • samplingPercentage : un nombre compris entre 0 et 1, qui définit la fraction des requêtes à consigner. Par exemple, définissez cette valeur sur 1 pour consigner l'intégralité des requêtes, ou sur 0.1 pour n'en consigner que 10 %.
  • bigqueryTableName : nom complet (PROJECT_ID.DATASET_NAME.TABLE_NAME) de la table BigQuery dans laquelle vous souhaitez consigner les requêtes et les réponses. Cette table doit déjà exister et présenter le schéma suivant :

    fieldNameTypeMode
    modelCHAÎNEOBLIGATOIRE
    model_versionCHAÎNEOBLIGATOIRE
    timeHORODATAGEOBLIGATOIRE
    raw_dataCHAÎNEOBLIGATOIRE
    raw_predictionCHAÎNEPEUT ÊTRE VIDE
    groundtruthCHAÎNENULLABLE

    Découvrez comment créer une table BigQuery.

Inspecter les modèles à l'aide de l'outil What-If

L'outil de simulation What-If (WIT) permet d'inspecter des modèles AI Platform Prediction dans les environnements notebook via un tableau de bord interactif. L'outil What-If s'intègre à TensorBoard, aux notebooks Jupyter et Colab, ainsi qu'à JupyterHub. Il est également préinstallé sur les instances de notebooks TensorFlow.

Découvrez comment utiliser l'outil What-If avec AI Platform.

Mettre en forme vos entrées pour la prédiction en ligne

Mettre en forme les instances en tant que chaînes JSON

Le format de base pour la prédiction en ligne est une liste d'instances de données. Il peut s'agir de simples listes de valeurs ou de membres d'un objet JSON, selon la configuration des entrées dans l'application d'entraînement. Les modèles TensorFlow et les routines de prédiction personnalisées peuvent accepter des entrées plus complexes, tandis que la plupart des modèles scikit-learn et XGBoost attendent une liste de nombres en entrée.

Cet exemple illustre un Tensor d’entrée et une clé d’instance pour un modèle TensorFlow :

{"values": [1, 2, 3, 4], "key": 1}

La composition de la chaîne JSON peut être complexe tant qu'elle suit les règles suivantes :

  • Le premier niveau des données d'instance doit être un objet JSON, soit un dictionnaire de paires clé/valeur.

  • Les valeurs individuelles dans un objet d'instance peuvent être des chaînes, des nombres ou des listes. Vous ne pouvez pas intégrer d'objets JSON.

  • Les listes doivent contenir uniquement des éléments du même type (y compris d'autres listes). Vous ne pouvez pas mélanger des valeurs numériques et des chaînes.

Vous devez transmettre les instances d'entrée pour la prédiction en ligne en tant que corps de message lors de l'appel projects.predict. Apprenez-en plus sur les exigences concernant la mise en forme du corps de la requête.

gcloud

Vous pouvez formater votre entrée de deux manières différentes, selon la manière dont vous envisagez d'envoyer votre requête de prédiction. Nous vous recommandons d'utiliser l'option --json-request de la commande gcloud ai-platform predict. Vous pouvez également utiliser l'option --json-instances avec des données JSON délimitées par un retour à la ligne.

Pour "--json-request"

Faites de chaque instance un élément dans un tableau JSON et fournissez le tableau en tant que champ instances d'un fichier JSON. Exemple :

instances.json

{"instances": [
  {"values": [1, 2, 3, 4], "key": 1},
  {"values": [5, 6, 7, 8], "key": 2}
]}

Pour "--json-instances"

Assurez-vous que le fichier d'entrée est un fichier délimité par des retours à la ligne) avec chaque instance incluse en tant qu'objet JSON (une instance par ligne). Exemple :

instances.jsonl

{"values": [1, 2, 3, 4], "key": 1}
{"values": [5, 6, 7, 8], "key": 2}

API REST

Faites de chaque instance un élément dans un tableau JSON et fournissez le tableau en tant que champ instances d'un objet JSON. Exemple :

{"instances": [
  {"values": [1, 2, 3, 4], "key": 1},
  {"values": [5, 6, 7, 8], "key": 2}
]}

Données binaires des entrées de prédiction

Les données binaires ne peuvent pas être mises en forme en tant que chaînes encodées UTF-8 compatibles avec JSON. Si des données binaires apparaissent dans les entrées, vous devez les représenter à l'aide de l'encodage base64. Le format spécial suivant est requis :

  • La chaîne encodée doit être mise en forme en tant qu'objet JSON avec une seule clé nommée b64. L'exemple Python 2.7 suivant encode un tampon de données JPEG brutes en utilisant la bibliothèque base64 pour créer une instance :

    {"image_bytes": {"b64": base64.b64encode(jpeg_data)}}
    

    Dans Python 3.5, l'encodage base64 génère une séquence d'octets. Vous devez la convertir en chaîne pour la rendre sérialisable en JSON :

    {'image_bytes': {'b64': base64.b64encode(jpeg_data).decode()}}
    
  • Dans le code de modèle TensorFlow, vous devez nommer les alias pour les Tensors binaires d'entrée et de sortie de façon qu'ils se terminent par "_bytes".

Effectuer une requête de prédiction

Effectuez une requête de prédiction en ligne en envoyant les instances de données d'entrée en tant que chaîne JSON dans une requête predict. Pour en savoir plus sur le format du corps de la requête et de la réponse, consultez les détails de la requête de prédiction.

Si vous ne spécifiez pas de version de modèle, votre requête de prédiction utilise la version par défaut du modèle.

gcloud

  1. Créez des variables d'environnement pour contenir les paramètres, y compris une valeur de version si vous décidez de spécifier une version de modèle particulière :

    MODEL_NAME="[YOUR-MODEL-NAME]"
    INPUT_DATA_FILE="instances.json"
    VERSION_NAME="[YOUR-VERSION-NAME]"
    
  2. Utilisez gcloud ai-platform predict pour envoyer des instances à un modèle déployé. Notez que --version est facultatif.

    gcloud ai-platform predict \
      --model=$MODEL_NAME \
      --version=$VERSION_NAME \
      --json-request=$INPUT_DATA_FILE \
      --region=REGION
    

    Remplacez REGION par la région du point de terminaison régional où vous avez créé votre modèle. Si vous avez créé votre modèle sur le point de terminaison mondial, omettez l'option --region.

  3. L'outil gcloud analyse la réponse et envoie les prédictions à votre terminal dans un format lisible. Vous pouvez spécifier un format de sortie différent, tel que JSON ou CSV, en utilisant l'indicateur "--format" avec votre commande "predict". Voir les formats de sortie disponibles.

Python

Vous pouvez utiliser la bibliothèque cliente des API Google pour Python pour l'API AI Platform Training and Prediction sans avoir à créer manuellement de requêtes HTTP. Avant d'exécuter l'exemple de code suivant, vous devez configurer l'authentification.

# Create the AI Platform service object.
# To authenticate set the environment variable
# GOOGLE_APPLICATION_CREDENTIALS=<path_to_service_account_file>
service = googleapiclient.discovery.build('ml', 'v1')

def predict_json(project, model, instances, version=None):
    """Send json data to a deployed model for prediction.

    Args:
        project (str): project where the AI Platform Model is deployed.
        model (str): model name.
        instances ([Mapping[str: Any]]): Keys should be the names of Tensors
            your deployed model expects as inputs. Values should be datatypes
            convertible to Tensors, or (potentially nested) lists of datatypes
            convertible to tensors.
        version: str, version of the model to target.
    Returns:
        Mapping[str: any]: dictionary of prediction results defined by the
            model.
    """
    name = 'projects/{}/models/{}'.format(project, model)

    if version is not None:
        name += '/versions/{}'.format(version)

    response = service.projects().predict(
        name=name,
        body={'instances': instances}
    ).execute()

    if 'error' in response:
        raise RuntimeError(response['error'])

    return response['predictions']

Java

Vous pouvez utiliser la bibliothèque cliente des API Google pour Java pour l'API AI Platform Training and Prediction sans avoir à créer manuellement de requêtes HTTP. Avant d'exécuter l'exemple de code suivant, vous devez configurer l'authentification.

/*
 * Copyright 2017 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.FileContent;
import com.google.api.client.http.GenericUrl;
import com.google.api.client.http.HttpContent;
import com.google.api.client.http.HttpRequest;
import com.google.api.client.http.HttpRequestFactory;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.http.UriTemplate;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.discovery.Discovery;
import com.google.api.services.discovery.model.JsonSchema;
import com.google.api.services.discovery.model.RestDescription;
import com.google.api.services.discovery.model.RestMethod;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.File;
import java.util.ArrayList;
import java.util.List;

/*
 * Sample code for sending an online prediction request to Cloud Machine Learning Engine.
 */

public class OnlinePredictionSample {
  public static void main(String[] args) throws Exception {
    HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
    JsonFactory jsonFactory = JacksonFactory.getDefaultInstance();
    Discovery discovery = new Discovery.Builder(httpTransport, jsonFactory, null).build();

    RestDescription api = discovery.apis().getRest("ml", "v1").execute();
    RestMethod method = api.getResources().get("projects").getMethods().get("predict");

    JsonSchema param = new JsonSchema();
    String projectId = "YOUR_PROJECT_ID";
    // You should have already deployed a model and a version.
    // For reference, see https://cloud.google.com/ml-engine/docs/deploying-models.
    String modelId = "YOUR_MODEL_ID";
    String versionId = "YOUR_VERSION_ID";
    param.set(
        "name", String.format("projects/%s/models/%s/versions/%s", projectId, modelId, versionId));

    GenericUrl url =
        new GenericUrl(UriTemplate.expand(api.getBaseUrl() + method.getPath(), param, true));
    System.out.println(url);

    String contentType = "application/json";
    File requestBodyFile = new File("input.txt");
    HttpContent content = new FileContent(contentType, requestBodyFile);
    System.out.println(content.getLength());

    List<String> scopes = new ArrayList<>();
    scopes.add("https://www.googleapis.com/auth/cloud-platform");

    GoogleCredentials credential = GoogleCredentials.getApplicationDefault().createScoped(scopes);
    HttpRequestFactory requestFactory =
        httpTransport.createRequestFactory(new HttpCredentialsAdapter(credential));
    HttpRequest request = requestFactory.buildRequest(method.getHttpMethod(), url, content);

    String response = request.execute().parseAsString();
    System.out.println(response);
  }
}

Dépanner la prédiction en ligne

Les erreurs courantes dans la prédiction en ligne incluent les suivantes :

  • Mémoire insuffisante
  • Mise en forme incorrecte des données d'entrée
  • Une requête de prédiction en ligne ne doit pas contenir plus de 1,5 Mo de données. De plus, les requêtes créées à l'aide de l'outil gcloud sont limitées à 100 instances par fichier. La prédiction par lot permet d'obtenir des prédictions pour davantage d'instances à la fois.

Essayez de réduire la taille de votre modèle avant de le déployer pour la prédiction dans AI Platform Prediction.

Pour en savoir plus, consultez la section Dépanner la prédiction en ligne.

Étapes suivantes