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 Google Cloud CLI est installé.
Pour configurer un compte GCP, activer les API requises, puis installer et activer Google Cloud CLI, procédez comme suit :
- Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the AI Platform Training & Prediction and Compute Engine APIs.
- Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the AI Platform Training & Prediction and Compute Engine APIs.
- Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init
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 :
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
Enregistrez les valeurs des champs
serviceAccountProject
ettpuServiceAccount
renvoyées par l'API.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
- Connectez-vous à Google Cloud Console, puis sélectionnez le projet dans lequel vous utilisez le TPU.
- Choisissez IAM et administration > IAM.
- Cliquez sur le bouton Ajouter pour ajouter un membre au projet.
- Saisissez le compte de service TPU dans la zone de texte Membres.
- Cliquez sur la liste déroulante Rôles.
- Activez le rôle Agent de service Cloud ML (Agents de service > Agent de service Cloud ML).
gcloud
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
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
Accédez à la page "Tâches" d'AI Platform Training dans Google Cloud Console :
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.
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
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 :
Sélectionnez Utiliser plusieurs fichiers stockés dans un répertoire Cloud Storage.
Dans Chemin d'accès au répertoire, renseignez "cloud-samples-data/ai-platform/built-in/image/flowers/".
Dans Nom générique, renseignez "flowers_train*" pour sélectionner tous les fichiers d'entraînement du répertoire.
Le chemin d'accès GCS complet s'affiche en dessous : gs://cloud-samples-data/ai-platform/built-in/image/flowers/flowers_train*.
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 :
Sélectionnez Utiliser plusieurs fichiers stockés dans un répertoire Cloud Storage.
Dans Chemin d'accès au répertoire, renseignez "cloud-samples-data/ai-platform/built-in/image/flowers/".
Pour Nom générique, renseignez "flowers_validation*" pour sélectionner tous les fichiers de validation du répertoire.
Le chemin d'accès GCS complet s'affiche en dessous : gs://cloud-samples-data/ai-platform/built-in/image/flowers/flowers_validation*.
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 :
|
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 :
|
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 :
- Pour model_type (type de modèle), sélectionnez Efficientnet-b4.
- Ne renseignez pas la valeur Pretrained checkpoint path (Chemin d'accès au point de contrôle pré-entraîné).
- 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 :
- Saisissez un ID de tâche unique (tel que "image_classification_example").
- Entrez une région disponible (telle que "us-central1").
- 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.
- Pour le type de maître, sélectionnez complex_model_m.
- 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
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}"
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'
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 à :
gcloud storage ls $JOB_DIR/* --all-versions
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
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).
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.
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.
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.
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.
Copiez le fichier dans votre répertoire local et affichez son contenu :
gcloud storage 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'
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.
Téléchargez les fichiers d'artefact d'entraînement :
gcloud storage cp $JOB_DIR/artifacts/* .
Préparez l'entrée de prédiction pour une image.
Pour envoyer une requête de prédiction en ligne à l'aide de Google Cloud CLI, 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))
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
- Obtenez davantage d'informations sur l'utilisation de l'algorithme intégré de classification d'images.