Obtenir des prédictions par lots

Si vous n'avez pas besoin de prédictions dans l'immédiat ou que vous disposez d'un grand nombre d'instances nécessitant des prévisions, vous pouvez utiliser le service de prédiction par lot. Cette page explique comment démarrer des tâches de prédiction par lot dans AI Platform Prediction.

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 :

  • Créez une ressource de modèle et une ressource de version, ou stockez un modèle SavedModel TensorFlow dans un emplacement Cloud Storage auquel votre projet peut accéder.

    • Si vous choisissez d'utiliser une ressource de version pour la prédiction par lot, vous devez créer la version avec le type de machine mls1-c1-m2.
  • Configurez un emplacement Cloud Storage auquel votre projet a accès pour :

    • les fichiers de données d'entrée. Vous pouvez configurer plusieurs emplacements, mais votre projet doit bénéficier d'autorisations de lecture pour chacun.

    • les fichiers de sortie. Vous ne pouvez spécifier qu'un seul chemin de sortie, et votre projet doit bénéficier d'autorisations d'écriture de données pour cet emplacement.

  • Vérifiez que le format de votre fichier d'entrée est adapté à la prédiction par lot.

Configurer une tâche de prédiction par lot

Pour démarrer votre tâche de prédiction par lot, vous devez collecter des données de configuration. Il s'agit des mêmes données que celles contenues dans l'objet PredictionInput utilisé lorsque vous appelez l'API directement.

Format des données

Il s'agit du type de format de saisie utilisé pour vos fichiers d'entrée. Tous vos fichiers d'entrée correspondant à une tâche donnée doivent utiliser le même format. Définissez ce format sur l'une des valeurs suivantes :

JSON

Vos fichiers d'entrée sont rédigés en texte brut et comportent une instance sur chaque ligne. Ce format est décrit sur la page relative aux concepts de la prédiction.

TF_RECORD

Vos fichiers d'entrée respectent le format TFRecord TensorFlow.

TF_RECORD_GZIP

Vos fichiers d'entrée sont au format TFRecord et sont compressés avec GZIP.

Chemins d'entrée

Il s'agit des URI de vos fichiers de données d'entrée, qui doivent se trouver dans des emplacements Cloud Storage. Vous pouvez spécifier ce qui suit :

  • Chemins d'accès à des fichiers spécifiques : 'gs://path/to/my/input/file.json'.

  • Chemins vers des répertoires comprenant un seul caractère générique (*), permettant de spécifier tous les fichiers du répertoire : 'gs://path/to/my/input/*'.

  • Chemins vers des noms de fichiers partiels comprenant un seul caractère générique (*) final, permettant de spécifier tous les fichiers commençant par la séquence fournie : 'gs://path/to/my/input/file*'.

Vous pouvez combiner plusieurs URI. En Python, vous en dressez la liste. Si vous utilisez l'outil de ligne de commande gcloud ou appelez l'API directement, vous pouvez répertorier plusieurs URI en les séparant par des virgules, mais sans ajouter d'espace entre eux. Le format correct pour l'indicateur --input-paths est le suivant :

 --input-paths gs://a/directory/of/files/*,gs://a/single/specific/file.json,gs://a/file/template/data*
Chemin de sortie

Il s'agit du chemin d'accès à l'emplacement Cloud Storage où vous souhaitez que le service de prédiction enregistre les résultats. Votre projet doit bénéficier d'autorisations d'écriture pour cet emplacement.

Nom du modèle et nom de la version

Il s'agit du nom du modèle et, éventuellement, de la version à partir de laquelle vous souhaitez obtenir des prédictions. Si vous ne spécifiez pas de version, la version par défaut du modèle est utilisée. Pour la prédiction par lot, la version doit utiliser le type de machine mls1-c1-m2.

Si vous spécifiez un URI de modèle (voir la section suivante), omettez ces champs.

Modèle URI

Vous pouvez obtenir des prédictions à partir d'un modèle non déployé sur AI Platform Prediction. Pour cela, spécifiez l'URI du modèle SavedModel que vous souhaitez utiliser. Le SavedModel doit être stocké sur Cloud Storage.

Pour résumer, vous disposez de trois options pour spécifier le modèle à utiliser lors de la prédiction par lot. Vous pouvez indiquer :

  • uniquement le nom du modèle afin d'utiliser la version par défaut ;

  • les noms du modèle et de la version afin d'utiliser une version de modèle spécifique ;

  • l'URI du modèle afin d'utiliser un modèle SavedModel qui se trouve sur Cloud Storage, mais qui n'est pas déployé sur AI Platform Prediction.

Région

Il s'agit de la région Google Compute Engine dans laquelle vous souhaitez exécuter votre tâche. Pour bénéficier de performances optimales, vous pouvez exécuter votre tâche de prédiction et stocker vos données d'entrée et de sortie dans la même région, en particulier pour les ensembles de données très volumineux. La prédiction par lot d'AI Platform Prediction est disponible dans les régions suivantes :

  -   us-central1
  -   us-east1
  -   europe-west1
  -   asia-east1

Pour bien comprendre quelles régions sont disponibles pour les services AI Platform Prediction, y compris l'entraînement de modèles et la prédiction en ligne, consultez le guide des régions.

Nom de la tâche

Il s'agit du nom de votre tâche, qui doit :

  • ne contenir que des lettres majuscules/minuscules (nom sensible à la casse), des chiffres et des traits de soulignement ;
  • commencer par une lettre ;
  • ne pas contenir plus de 128 caractères ;
  • être unique et différent de tous les noms de tâches d'entraînement et de prédiction par lot déjà utilisés dans votre projet (cela inclut toutes les tâches créées dans votre projet, quel que soit leur état de réussite ou leur statut).
Taille du lot (facultatif)

Nombre d'enregistrements par lot. Le service mettra en mémoire tampon le nombre d'enregistrements batch_size en mémoire avant d'appeler votre modèle. En l'absence de spécification, la valeur par défaut est 64.

Libellés (facultatifs)

Vous pouvez ajouter des libellés à votre tâche pour organiser et trier les tâches en catégories lorsque vous affichez ou surveillez des ressources. Par exemple, vous pouvez trier les tâches par équipe (en ajoutant des libellés tels que engineering ou research) ou par phase de développement (prod ou test). Pour ajouter des libellés à votre tâche de prédiction, fournissez une liste de paires KEY=VALUE.

Nombre maximal de nœuds de calcul (facultatif)

Il s'agit du nombre maximal de nœuds de prédiction à utiliser dans le cluster de traitement pour cette tâche. Ainsi, vous pouvez fixer une limite supérieure à la fonctionnalité de scaling automatique de la prédiction par lot. Si vous ne spécifiez aucune valeur, la limite par défaut est de 10. Quelle que soit la valeur spécifiée, le scaling est limité par le quota de nœuds de prédiction.

Version d'exécution (facultatif)

Version d'AI Platform Prediction à utiliser pour la tâche. Cette option est incluse pour vous permettre de spécifier une version d'exécution à utiliser avec les modèles non déployés sur AI Platform Prediction. Vous devez toujours omettre cette valeur pour les versions de modèle déployées : ceci indique au service d'utiliser la même version que celle spécifiée lors du déploiement de la version du modèle.

Nom de la signature (facultatif)

Si votre modèle enregistré possède plusieurs signatures, cette option vous permet de spécifier un nom de signature TensorFlow personnalisé. Ainsi, vous pouvez sélectionner un autre mappage de données d'entrée et de sortie défini dans le modèle SavedModel TensorFlow. Consultez la documentation de TensorFlow relative au modèle SavedModel pour découvrir comment utiliser les signatures et comment spécifier les sorties d'un modèle personnalisé. La valeur par défaut est DEFAULT_SERVING_SIGNATURE_DEF_KEY, qui correspond à la valeur serving_default.

Les exemples suivants définissent des variables permettant de contenir des données de configuration.

gcloud

Il n'est pas nécessaire de créer des variables lors de l'utilisation de l'outil de ligne de commande gcloud pour démarrer une tâche. Cependant, cela rend la commande d'envoi de tâche beaucoup plus facile à saisir et à lire.

DATA_FORMAT="text" # JSON data format
INPUT_PATHS='gs://path/to/your/input/data/*'
OUTPUT_PATH='gs://your/desired/output/location'
MODEL_NAME='census'
VERSION_NAME='v1'
REGION='us-east1'
now=$(date +"%Y%m%d_%H%M%S")
JOB_NAME="census_batch_predict_$now"
MAX_WORKER_COUNT="20"
BATCH_SIZE="32"
LABELS="team=engineering,phase=test,owner=sara"

Python

Lorsque vous utilisez la bibliothèque cliente des API Google pour Python, vous pouvez utiliser des dictionnaires Python pour représenter les ressources Job et PredictionInput.

  1. Mettez en forme le nom du projet ainsi que le nom du modèle ou de la version à l'aide de la syntaxe utilisée par les API REST d'AI Platform Prediction :

    • nom_projet -> "projects/project_name"
    • nom_modèle -> "projects/project_name/models/model_name"
    • nom_version -> "projects/project_name/models/model_name/versions/version_name"
  2. Créez un dictionnaire pour la ressource Job et remplissez-le avec deux éléments :

    • Une clé nommée 'jobId', ayant comme valeur le nom de la tâche que vous souhaitez utiliser.

    • Une clé nommée 'predictionInput', qui contient un autre objet de dictionnaire contenant tous les membres requis de la ressource PredictionInput et tous les membres facultatifs que vous souhaitez utiliser.

    L'exemple suivant montre une fonction pour laquelle les informations de configuration sont considérées comme des variables d'entrée, et qui renvoie le corps de la requête de prédiction. En plus des éléments habituels, l'exemple génère également un identifiant de tâche unique basé sur le nom de votre projet, le nom du modèle et l'heure actuelle.

    import time
    import re
    
    def make_batch_job_body(project_name, input_paths, output_path,
            model_name, region, data_format='JSON',
            version_name=None, max_worker_count=None,
            runtime_version=None):
    
        project_id = 'projects/{}'.format(project_name)
        model_id = '{}/models/{}'.format(project_id, model_name)
        if version_name:
            version_id = '{}/versions/{}'.format(model_id, version_name)
    
        # Make a jobName of the format "model_name_batch_predict_YYYYMMDD_HHMMSS"
        timestamp = time.strftime('%Y%m%d_%H%M%S', time.gmtime())
    
        # Make sure the project name is formatted correctly to work as the basis
        # of a valid job name.
        clean_project_name = re.sub(r'\W+', '_', project_name)
    
        job_id = '{}_{}_{}'.format(clean_project_name, model_name,
                               timestamp)
    
        # Start building the request dictionary with required information.
        body = {'jobId': job_id,
                'predictionInput': {
                    'dataFormat': data_format,
                    'inputPaths': input_paths,
                    'outputPath': output_path,
                    'region': region}}
    
        # Use the version if present, the model (its default version) if not.
        if version_name:
            body['predictionInput']['versionName'] = version_id
        else:
            body['predictionInput']['modelName'] = model_id
    
        # Only include a maximum number of workers or a runtime version if specified.
        # Otherwise let the service use its defaults.
        if max_worker_count:
            body['predictionInput']['maxWorkerCount'] = max_worker_count
    
        if runtime_version:
            body['predictionInput']['runtimeVersion'] = runtime_version
    
        return body
    

Envoyer une tâche de prédiction par lot

L'envoi de la tâche s'effectue via un simple appel à projects.jobs.create ou à gcloud ai-platform jobs submit prediction, son équivalent sous forme d'outil de ligne de commande.

gcloud

L'exemple suivant reprend les variables définies dans la section précédente pour démarrer la prédiction par lot.

gcloud ai-platform jobs submit prediction $JOB_NAME \
    --model $MODEL_NAME \
    --input-paths $INPUT_PATHS \
    --output-path $OUTPUT_PATH \
    --region $REGION \
    --data-format $DATA_FORMAT

Python

Le lancement d'une tâche de prédiction par lot avec la bibliothèque cliente des API Google pour Python fonctionne à peu près de la même manière que les autres procédures du SDK client :

  1. Préparez le corps de la requête à utiliser pour l'appel (procédure décrite dans la section précédente).

  2. Formulez la requête en appelant "ml.projects.jobs.create".

  3. Appelez la fonction "execute" sur la requête pour obtenir une réponse, en vérifiant attentivement qu'il n'y ait pas d'erreur HTTP.

  4. Utilisez la réponse en tant que dictionnaire pour obtenir des valeurs à partir de la ressource Job.

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.

    import googleapiclient.discovery as discovery

    project_id = 'projects/{}'.format(project_name)

    ml = discovery.build('ml', 'v1')
    request = ml.projects().jobs().create(parent=project_id,
                                          body=batch_predict_body)

    try:
        response = request.execute()

        print('Job requested.')

        # The state returned will almost always be QUEUED.
        print('state : {}'.format(response['state']))

    except errors.HttpError as err:
        # Something went wrong, print out some information.
        print('There was an error getting the prediction results.' +
              'Check the details:')
        print(err._get_reason())

Surveiller votre tâche de prédiction par lot

L'exécution d'une tâche de prédiction par lot peut prendre beaucoup de temps. Vous pouvez surveiller la progression de la tâche à l'aide de Google Cloud Console :

  1. Accédez à la page "Tâches" d'AI Platform Prediction dans Google Cloud Console :

    Accéder à la page des tâches de Cloud Console

  2. Cliquez sur le nom de votre tâche dans la liste ID de tâche. La page Informations sur la tâche s'affiche.

  3. L'état actuel de la tâche s'affiche à côté de son nom, en haut de la page.

  4. Si vous souhaitez plus de détails, vous pouvez cliquer sur Afficher les journaux pour consulter l'entrée dans Cloud Logging.

Il existe d'autres méthodes pour suivre la progression de votre travail de prédiction par lot. Ces méthodes suivent les mêmes schémas que la surveillance des tâches d'apprentissage. Pour en savoir plus, consultez la page spécifique à la surveillance de vos tâches d'entraînement. Vous devrez peut-être vous éloigner légèrement des instructions pour utiliser les tâches de prédiction, mais les mécanismes sont les mêmes.

Obtenir des résultats de prédiction

Le service écrit les prédictions dans l'emplacement Cloud Storage que vous spécifiez. Il existe deux types de sorties de fichiers susceptibles d'inclure des résultats intéressants :

  • Les fichiers nommés prediction.errors_stats-NNNNN-of-NNNNN contiennent des informations relatives aux problèmes rencontrés lors de la tâche.

  • Les fichiers nommés prediction.results-NNNNN-of-NNNNN contiennent les prédictions définies par la sortie de votre modèle.

Les noms de fichiers incluent des numéros d'index (indiqués ci-dessus par une série de "N" correspondant à chaque chiffre) qui représentent le nombre total de fichiers qui devraient s'afficher. Par exemple, une tâche comprenant six fichiers de résultats inclut des fichiers allant de prediction.results-00000-of-00006 à prediction.results-00005-of-00006.

Les résultats de prédiction sont mis en forme en tant qu'objets JSON dans des fichiers texte. Vous pouvez les ouvrir avec l'éditeur de texte de votre choix. Pour en obtenir un aperçu dans la ligne de commande, vous pouvez utiliser la commande gsutil cat :

gsutil cat $OUTPUT_PATH/prediction.results-NNNNN-of-NNNNN|less

Notez que vos résultats de prédiction ne sont généralement pas affichés dans le même ordre que vos instances d'entrée, même si vous n'utilisez qu'un seul fichier d'entrée. Vous pouvez trouver la prédiction associée à une instance en faisant correspondre les clés d'instance.

Étapes suivantes