Premiers pas avec l'algorithme intégré de classification d'images

Grâce aux algorithmes AI Platform Training intégrés, vous pouvez envoyer vos données d'entraînement, sélectionner un algorithme, puis laisser AI Platform Training effectuer les tâches de prétraitement et d'entraînement, sans avoir à écrire le code d'une application d'entraînement. Les algorithmes d'images intégrés vous permettent d'effectuer l'entraînement sur des TPU avec une configuration minimale. Le modèle SavedModel de TensorFlow obtenu est compatible avec les processeurs et les GPU.

Présentation

Dans ce tutoriel, vous allez entraîner un modèle de classification d'images sans écrire de code. Vous soumettez l'ensemble de données Flowers à AI Platform Training pour l'entraînement, puis vous déployez le modèle sur AI Platform Prediction pour obtenir des prédictions. Le modèle obtenu classe les images de fleurs en fonction des espèces (marguerite, tulipe, rose, tournesol ou pissenlit).

Avant de commencer

Pour suivre ce tutoriel sur la ligne de commande, utilisez Cloud Shell ou tout autre environnement dans lequel le SDK Cloud est installé.

Pour configurer un compte GCP, activer les API requises, puis installer et activer le SDK Cloud, procédez comme suit :

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API AI Platform Training & Prediction and Compute Engine.

    Activer les API

  5. Installez et initialisez le SDK Cloud.
  6. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  7. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  8. Activer les API AI Platform Training & Prediction and Compute Engine.

    Activer les API

  9. Installez et initialisez le SDK Cloud.

Autoriser Cloud TPU à accéder à votre projet

Pour autoriser le nom de compte de service Cloud TPU associé à votre projet Google Cloud, procédez comme suit :

  1. Obtenez le nom de votre compte de service Cloud TPU en appelant projects.getConfig. Exemple :

    PROJECT_ID=PROJECT_ID
    
    curl -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
        https://ml.googleapis.com/v1/projects/$PROJECT_ID:getConfig
    
  2. Enregistrez les valeurs des champs serviceAccountProject et tpuServiceAccount renvoyées par l'API.

  3. Initialisez le compte de service Cloud TPU :

    curl -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
      -H "Content-Type: application/json" -d '{}'  \
      https://serviceusage.googleapis.com/v1beta1/projects/<serviceAccountProject>/services/tpu.googleapis.com:generateServiceIdentity
    

Ajoutez ensuite le compte de service Cloud TPU en tant que membre de votre projet, avec le rôle Agent de service Cloud ML. Effectuez les étapes suivantes dans Google Cloud Console ou à l'aide de l'outil de ligne de commande gcloud :

Console

  1. Connectez-vous à Google Cloud Console, puis sélectionnez le projet dans lequel vous utilisez le TPU.
  2. Sélectionnez IAM et administration > IAM.
  3. Cliquez sur le bouton Ajouter pour ajouter un membre au projet.
  4. Saisissez le compte de service TPU dans la zone de texte Membres.
  5. Cliquez sur la liste déroulante Rôles.
  6. Activez le rôle Agent de service Cloud ML (Agents de service > Agent de service Cloud ML).

gcloud

  1. Définissez les variables d'environnement contenant votre ID de projet et le compte de service Cloud TPU :

    PROJECT_ID=PROJECT_ID
    SVC_ACCOUNT=your-tpu-sa-123@your-tpu-sa.google.com.iam.gserviceaccount.com
    
  2. Attribuez le rôle ml.serviceAgent au compte de service Cloud TPU :

    gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member serviceAccount:$SVC_ACCOUNT --role roles/ml.serviceAgent
    

Pour en savoir plus sur l'attribution de rôles aux comptes de service, consultez la documentation IAM.

Prérequis

Nous avons modifié l'ensemble de données TensorFlow "Flowers" pour l'utiliser dans le cadre de ce tutoriel et l'avons hébergé dans un bucket public de Cloud Storage : gs://cloud-samples-data/ai-platform/built-in/image/flowers/.

Console

Sélectionner un algorithme

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

    Page "Tâches" d'AI Platform Training

  2. Cliquez sur le bouton Nouvelle tâche d'entraînement. Dans les options qui s'affichent en dessous, cliquez sur Entraînement de l'algorithme intégré. La page Créer une tâche d'entraînement s'affiche.

  3. La création d'une tâche d'entraînement comporte quatre étapes. La première étape concerne l'algorithme d'entraînement. Sélectionnez Classification d'images, puis cliquez sur Suivant.

Données d'entraînement

  1. Dans la section Données d'entraînement, sélectionnez les données d'entraînement pour l'exemple d'ensemble de données hébergé dans notre bucket Cloud Storage public :

    1. Sélectionnez Utiliser plusieurs fichiers stockés dans un répertoire Cloud Storage.

    2. Dans Chemin d'accès au répertoire, renseignez "cloud-samples-data/ai-platform/built-in/image/flowers/".

    3. Dans Nom générique, renseignez "flowers_train*" pour sélectionner tous les fichiers d'entraînement du répertoire.

    4. Le chemin d'accès GCS complet s'affiche en dessous : gs://cloud-samples-data/ai-platform/built-in/image/flowers/flowers_train*.

  2. Dans la section Données de validation, sélectionnez les données de validation pour l'exemple d'ensemble de données hébergé dans notre bucket Cloud Storage public :

    1. Sélectionnez Utiliser plusieurs fichiers stockés dans un répertoire Cloud Storage.

    2. Dans Chemin d'accès au répertoire, renseignez "cloud-samples-data/ai-platform/built-in/image/flowers/".

    3. Pour Nom générique, renseignez "flowers_validation*" pour sélectionner tous les fichiers de validation du répertoire.

    4. Le chemin d'accès GCS complet s'affiche en dessous : gs://cloud-samples-data/ai-platform/built-in/image/flowers/flowers_validation*.

  3. Spécifiez le répertoire de sortie dans votre bucket Cloud Storage, où vous souhaitez qu'AI Platform Training stocke votre modèle entraîné, les points de contrôle et le résultat d'autres tâches d'entraînement. Vous pouvez renseigner le chemin d'accès exact au sein de votre bucket ou utiliser le bouton Parcourir pour le sélectionner.

gcloud

Configurez les variables d'environnement pour votre ID de projet, votre bucket Cloud Storage, le chemin d'accès Cloud Storage aux données d'entraînement et l'algorithme choisi.

Les algorithmes intégrés à AI Platform Training se trouvent dans des conteneurs Docker hébergés dans Container Registry.

PROJECT_ID="YOUR_PROJECT_ID"
BUCKET_NAME="YOUR_BUCKET_NAME"
REGION="us-central1"

gcloud config set project $PROJECT_ID
gcloud config set compute/region $REGION

# Set paths to the training and validation data.
TRAINING_DATA_PATH="gs://cloud-samples-data/ai-platform/built-in/image/flowers/flowers_train*"
VALIDATION_DATA_PATH="gs://cloud-samples-data/ai-platform/built-in/image/flowers/flowers_validation*"

# Specify the Docker container for your built-in algorithm selection.
IMAGE_URI="gcr.io/cloud-ml-algos/image_classification:latest"

Envoyer une tâche d'entraînement

Pour envoyer une tâche, vous devez spécifier certains arguments de base associés à l'entraînement, ainsi qu'à l'algorithme de classification d'images.

Arguments généraux liés à la tâche d'entraînement :

Arguments de la tâche d'entraînement
Argument Description
job-id Identifiant unique de la tâche d'entraînement. Il vous permet de rechercher les journaux d'état de la tâche d'entraînement une fois celle-ci envoyée.
job-dir Chemin d'accès à Cloud Storage, où AI Platform Training enregistre les fichiers d'entraînement après avoir effectué une tâche d'entraînement avec succès.
scale-tier Spécifie les types de machines pour l'entraînement. Utilisez le type BASIC pour sélectionner une configuration sur une seule machine.
master-image-uri URI Container Registry permettant de spécifier le conteneur Docker à utiliser pour la tâche d'entraînement. Utilisez le conteneur de l'algorithme intégré de classification d'images défini précédemment en tant que IMAGE_URI.
region Spécifiez la région disponible dans laquelle la tâche d'entraînement doit être exécutée. Pour ce tutoriel, vous pouvez utiliser la région us-central1.

Arguments spécifiques à l'algorithme intégré de classification d'images :

Arguments algorithmiques
Argument Description
training_data_path Chemin d'accès à un modèle de chemin d'accès TFRecord utilisé pour l'entraînement.
validation_data_path Chemin d'accès à un modèle de chemin d'accès TFRecord utilisé pour la validation.
pretrained_checkpoint_path Chemin d'accès aux points de contrôle pré-entraînés. Vous pouvez utiliser des points de contrôle publiés.
num_classes Nombre de classes dans les données d'entraînement/de validation.
max_steps Nombre d'étapes pour la tâche d'entraînement.
train_batch_size Nombre d'images à utiliser par étape d'entraînement.
num_eval_images Nombre total d'images utilisées pour l'évaluation.
Si ce paramètre est défini sur 0, toutes les images dans validation_data_path sont utilisées pour l'évaluation.
learning_rate_decay_type Méthode selon laquelle le taux d'apprentissage diminue pendant l'entraînement.
warmup_learning_rate Taux d'apprentissage au début de la phase d'échauffement.
warmup_steps Nombre d'étapes à réaliser pendant la phase d'échauffement ou durée de la phase d'échauffement en nombre d'étapes. La tâche d'entraînement utilise l'argument warmup_learning_rate pendant la phase d'échauffement. Lorsque la phase d'échauffement est terminée, la tâche d'entraînement utilise l'argument initial_learning_rate.
initial_learning_rate Taux d'apprentissage initial une fois la phase d'échauffement terminée.
stepwise_learning_rate_steps Étapes auxquelles les taux d'apprentissage décroissent/changent pour le type de dépréciation du taux d'apprentissage par étapes.
Par exemple, "100,200" signifie que le taux d'apprentissage va changer (par rapport à stepwise_learning_rate_levels) à l'étape 100 et à l'étape 200. Notez que cet argument n'est respecté que si learning_rate_decay_type est défini par étapes.
stepwise_learning_rate_levels Valeur du taux d'apprentissage de chaque étape pour le type de dépréciation du taux d'apprentissage par étapes. Notez que cet argument n'est respecté que si learning_rate_decay_type est défini par étapes.
image_size Taille de l'image (largeur et hauteur) utilisée pour l'entraînement.
optimizer_type Optimiseur utilisé pour l'entraînement. Il doit s'agir de l'un des éléments suivants :
{momentum, adam, rmsprop}
optimizer_arguments Arguments de l'optimiseur. Il s'agit d'une liste de paires "name=value" séparées par une virgule. Cet argument doit être compatible avec optimizer_type. Exemples :
  • Pour l'optimiseur Momentum, la valeur acceptée est momentum=0.9. Pour plus d'informations, consultez la page tf.train.MomentumOptimizer.
  • Pour l'optimiseur Adam, les valeurs acceptées sont beta1=0.9,beta2=0.999. Pour plus d'informations, consultez la page tf.train.AdamOptimizer.
  • Pour l'optimiseur RMSProp, les valeurs acceptées sont decay=0.9,momentum=0.1,epsilon=1e-10. Pour plus d'informations, consultez la page RMSPropOptimizer.
model_type Type d'architecture de modèle utilisé pour entraîner les modèles. Il peut s'agir de l'un des éléments suivants :
  • resnet-(18|34|50|101|152|200)
  • efficientnet-(b0|b1|b2|b3|b4|b5|b6|b7)
label_smoothing Paramètre de lissage d'étiquette utilisé dans softmax_cross_entropy.
weight_decay Coefficient de décroissance de la pondération pour la régularisation L2. loss = cross_entropy + params['weight_decay'] * l2_loss

Pour obtenir une liste détaillée de toutes les autres options de l'algorithme de classification d'images, consultez la documentation de référence sur l'algorithme intégré de classification d'images.

Console

Arguments algorithmiques

Dans la première partie de l'onglet Arguments algorithmiques, saisissez les valeurs suivantes :

  • Nombre de classes : 5
  • max_steps (nombre maximal d'étapes) : 15 000
  • train_batch_size (taille du lot d'entraînement) : 128
  • num_eval_images (nombre d'images d'évaluation) : 1

Dans la section Modèle de l'onglet Arguments algorithmiques :

  1. Pour model_type (type de modèle), sélectionnez Efficientnet-b4.
  2. Ne renseignez pas la valeur Pretrained checkpoint path (Chemin d'accès au point de contrôle pré-entraîné).
  3. Conservez les valeurs par défaut pour les valeurs Label smoothing (Lissage d'étiquette) et Weight Decay (Décroissance de la pondération).

Paramètres de la tâche

Dans l'onglet Paramètres de la tâche :

  1. Saisissez un ID de tâche unique (tel que "image_classification_example").
  2. Entrez une région disponible (telle que "us-central1").
  3. Pour les types de machines, sélectionnez "CUSTOM" pour le niveau d'évolutivité. Une section vous invitant à indiquer les spécifications de votre cluster personnalisé s'affiche.
    1. Pour le type de maître, sélectionnez complex_model_m.
    2. Pour le type de nœud de calcul, sélectionnez cloud_tpu. Le nombre de nœuds de calcul est défini sur 1 par défaut.

Cliquez sur Terminé pour envoyer la tâche d'entraînement.

gcloud

  1. Configurez tous les arguments de la tâche d'entraînement et de l'algorithme avant d'utiliser gcloud pour envoyer la tâche :

    DATASET_NAME="flowers"
    ALGORITHM="image_classification"
    MODEL_NAME="${DATASET_NAME}_${ALGORITHM}_model"
    
    # Give a unique name to your training job.
    DATE="$(date '+%Y%m%d_%H%M%S')"
    JOB_ID="${MODEL_NAME}_${DATE}"
    
    # Make sure you have access to this Cloud Storage bucket.
    JOB_DIR="gs://${BUCKET_NAME}/algorithms_training/${MODEL_NAME}/${DATE}"
    
  2. Envoyez la tâche :

    gcloud ai-platform jobs submit training $JOB_ID \
      --region=$REGION \
      --config=config.yaml \
      --master-image-uri=$IMAGE_URI \
      -- \
      --training_data_path=$TRAINING_DATA_PATH \
      --validation_data_path=$VALIDATION_DATA_PATH \
      --job-dir=$JOB_DIR \
      --max_steps=30000 \
      --train_batch_size=128 \
      --num_classes=5 \
      --num_eval_images=100 \
      --initial_learning_rate=0.128 \
      --warmup_steps=1000 \
      --model_type='efficientnet-b4'
    

  3. Une fois la tâche envoyée, vous pouvez afficher les journaux à l'aide des commandes gcloud suivantes :

    gcloud ai-platform jobs describe $JOB_ID
    gcloud ai-platform jobs stream-logs $JOB_ID
    

Comprendre votre répertoire de tâche

Après avoir terminé une tâche d'entraînement, AI Platform Training crée un modèle entraîné dans votre bucket Cloud Storage, accompagné d'autres artefacts. La structure de répertoire suivante apparaît dans votre répertoire JOB_DIR :

  • model/ (un répertoire TensorFlow SavedModel qui contient également un fichier deployment_config.yaml)
    • saved_model.pb.
    • deployment_config.yaml
  • eval/
    • events.out.tfevents.[timestamp].cmle-training-[timestamp]
    • events.out.tfevents...
  • variables/
    • variables.data-00000-of-00001
    • variables.index

Le répertoire de tâche contient également divers fichiers de points de contrôle du modèle.

Vérifiez que la structure de répertoire de JOB_DIR correspond à :

gsutil ls -a $JOB_DIR/*

Déployer le modèle entraîné

AI Platform Training organise vos modèles entraînés à l'aide de ressources de modèle et de version. Un modèle AI Platform Training est un conteneur qui stocke les versions de votre modèle de machine learning.

Pour déployer un modèle, créez une ressource de modèle dans AI Platform Training, ainsi qu'une version de ce modèle, puis utilisez le modèle et la version pour demander des prédictions en ligne.

Pour savoir comment déployer des modèles dans AI Platform Training, consultez la page expliquant comment déployer un modèle TensorFlow.

Console

  1. La page Tâches présente une liste de toutes vos tâches d'entraînement. Cliquez sur le nom de la tâche d'entraînement que vous venez d'envoyer ("image_classification" ou nom de la tâche utilisée).

  2. Sur la page Détails de la tâche, vous pouvez afficher la progression générale de la tâche ou cliquer sur Afficher les journaux pour accéder à une vue plus détaillée de la progression.

  3. Lorsque la tâche est réussie, le bouton Déployer un modèle apparaît en haut. Cliquez sur Déployer un modèle.

  4. Sélectionnez Déployer en tant que nouveau modèle et saisissez un nom de modèle, tel que "algorithms_image_classification_model". Ensuite, cliquez sur Confirmer.

  5. Sur la page Créer une version, entrez un nom de version, tel que "v1" et conservez les paramètres par défaut pour tous les autres champs. Cliquez sur Enregistrer.

gcloud

Le processus d'entraînement avec l'algorithme intégré de classification d'images génère un fichier, deployment_config.yaml, qui facilite le déploiement de votre modèle sur AI Platform Training pour l'obtention de prédictions.

  1. Copiez le fichier dans votre répertoire local et affichez son contenu :

    gsutil cp $JOB_DIR/model/deployment_config.yaml .
    cat deployment_config.yaml
    

    Votre fichier deployment_config.yaml doit ressembler à ce qui suit :

    deploymentUri: gs://BUCKET_NAME/algorithms_training/flowers_image_classification/model
    framework: TENSORFLOW
    labels:
      global_step: '1000'
      job_id: flowers_image_classification_20190227060114
    runtimeVersion: '1.14'
    
  2. Créez le modèle et la version dans AI Platform Training :

    gcloud ai-platform models create $MODEL_NAME --regions $REGION
    
    # Create a model and a version using the file above.
    VERSION_NAME="v_${DATE}"
    
    gcloud ai-platform versions create $VERSION_NAME \
      --model $MODEL_NAME \
      --config deployment_config.yaml
    

    La création de la version prend quelques minutes.

Obtenir des prédictions en ligne

Lorsque vous demandez des prédictions, vous devez vous assurer que vos données d'entrée sont au format JSON.

  1. Téléchargez les fichiers d'artefact d'entraînement :

    gsutil cp $JOB_DIR/artifacts/* .
    
  2. Préparez l'entrée de prédiction pour une image.

    Pour envoyer une requête de prédiction en ligne à l'aide de l'outil de ligne de commande gcloud, comme dans cet exemple, écrivez chaque instance sur une ligne dans un fichier JSON délimité par un retour à la ligne.

    Exécutez les commandes suivantes dans votre terminal pour créer une entrée pour une instance unique que vous pouvez envoyer à AI Platform Prediction :

    Le script Python suivant encode une image unique en base64, la met en forme pour la prédiction, ajoute une clé d'instance et écrit le résultat dans un fichier nommé prediction_instances.json :

    import json
    import base64
    import tensorflow as tf
    
    IMAGE_URI='gs://cloud-samples-data/ai-platform/built-in/image/tutorial_examples/daisy.jpg'
    
    with tf.gfile.Open(IMAGE_URI, 'rb') as image_file:
      encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
    
    image_bytes = {'b64': str(encoded_string)}
    instances = {'image_bytes': image_bytes, 'key': '1'}
    with open("prediction_instances.json","w") as f:
      f.write(json.dumps(instances))
    
  3. Envoyez la requête de prédiction :

    gcloud ai-platform predict --model $MODEL_NAME \
     --version $VERSION_NAME \
     --json-instances prediction_instances.json
    

Le résultat de la prédiction inclut très probablement la classe daisy. Cela signifie que le modèle déployé a classé l'image d'entrée comme étant une marguerite. (Comme l'entraînement n'est pas déterministe, votre modèle peut être différent.)

À propos des données

L'ensemble de données "Flowers" que cet exemple utilise pour l'entraînement est fourni par l'équipe TensorFlow.

Étape suivante