GSP631

Présentation

Développé par Google, TensorFlow est une bibliothèque Open Source de machine learning (ML) portable, performante et capable de fonctionner avec de très grands ensembles de données. Dans cet atelier, vous allez créer et entraîner un modèle de vision par ordinateur pour reconnaître différents vêtements à l'aide de TensorFlow Vertex AI Workbench.

Introduction à TensorFlow

TensorFlow offre un framework de calcul pour créer des modèles de ML. Il fournit différents kits d'outils vous permettant de concevoir des modèles au niveau d'abstraction souhaité. Dans cet atelier, vous allez utiliser l'API de haut niveau tf.keras afin de créer et d'entraîner un réseau de neurones pour classer des images dans TensorFlow.

Réseaux de neurones

Un réseau de neurones est un modèle inspiré du cerveau humain. Il est constitué de couches (dont au moins une est cachée) contenant des unités connectées simples, ou neurones, suivies de non-linéarités.

Un nœud d'un réseau de neurones accepte généralement plusieurs valeurs d'entrée et génère une valeur de sortie. Le neurone applique une fonction d'activation (transformation non linéaire) à une somme pondérée de valeurs d'entrée pour calculer la valeur de sortie.

Pour en savoir plus sur les réseaux de neurones, consultez Réseaux de neurones : structure.

Objectifs

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

• Concevoir, compiler, entraîner et évaluer un modèle Tensorflow
• Enregistrer et charger des modèles
• Écrire vos propres rappels pour personnaliser le comportement pendant l'entraînement
• Réaliser une série d'exercices vous permettant de tester les différentes couches du réseau

Préparation

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;

Remarque : Ouvrez une fenêtre de navigateur en mode incognito/navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le temporaire étudiant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier afin d'éviter que des frais supplémentaires ne vous soient facturés.

Tâche 1 : Ouvrir le notebook dans Vertex AI Workbench

1. Dans la console Google Cloud, accédez au menu de navigation et cliquez sur Vertex AI > Workbench.

2. Recherchez l'instance , puis cliquez sur le bouton Ouvrir JupyterLab.

L'interface JupyterLab de votre instance Workbench s'ouvre dans un nouvel onglet de navigateur.

Installer TensorFlow et d'autres packages

1. Dans le menu de lancement, sous Other (Autre), sélectionnez Terminal.

2. Vérifiez si votre environnement Python est déjà configuré. Copiez et collez la commande ci-dessous dans le terminal.

python --version

Exemple de résultat :

Python 3.10.14

3. Exécutez la commande ci-dessous pour installer le package TensorFlow.

pip3 install tensorflow

4. Pour mettre à niveau pip3, exécutez la commande ci-dessous dans le terminal.

pip3 install --upgrade pip

Pylint est un outil qui recherche les erreurs dans le code Python. Il met en évidence les problèmes syntaxiques et stylistiques dans votre code source Python.

5. Exécutez la commande ci-dessous pour installer le package pylint.

pip install -U pylint --user

6. Installez les packages du fichier requirements.txt dont vous avez besoin pour l'atelier :

pip install -r requirements.txt

Votre environnement est désormais configuré.

Tâche 2 : Créer un notebook et importer des bibliothèques

1. Cliquez sur l'icône + dans la partie gauche de Workbench pour ouvrir un nouveau menu de lancement.

2. Dans le menu de lancement, sous Notebook, sélectionnez Python3.

Un nouveau notebook Jupyter s'affiche. Consultez la documentation sur les notebooks Jupyter pour savoir comment les utiliser.

3. Importez et configurez logging et google-cloud-logging pour Cloud Logging. Dans la première cellule, ajoutez le code suivant :

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging cloud_logger = logging.getLogger('cloudLogger') cloud_logger.setLevel(logging.INFO) cloud_logger.addHandler(CloudLoggingHandler(cloud_logging.Client())) cloud_logger.addHandler(logging.StreamHandler())

4. Importez tensorflow pour entraîner et évaluer le modèle. Pour plus de simplicité, appelez-le tf. Ajoutez le code ci-dessous à la première cellule.

# Import TensorFlow import tensorflow as tf

5. Importez numpy pour analyser les données à des fins de débogage. Pour plus de simplicité, appelez-le np. Ajoutez le code ci-dessous à la première cellule.

# Import numpy import numpy as np

6. Ajoutez le code ci-dessous à la première cellule pour importer tensorflow_datasets et intégrer l'ensemble de données. TensorFlow Datasets est une collection d'ensembles de données prêts à être utilisés avec TensorFlow.

Pour savoir comment l'utiliser, consultez le guide et la liste des ensembles de données. # Import tensorflow_datasets import tensorflow_datasets as tfds

7. Pour exécuter la cellule, cliquez sur le bouton Run (Exécuter) ou appuyez sur Maj+Entrée.

8. Enregistrez le notebook. Cliquez sur File > Save (Fichier > Enregistrer). Nommez le fichier model.ipynb, puis cliquez sur OK.

Tâche 3 : Charger et prétraiter l'ensemble de données

À propos de l'ensemble de données

Vous allez entraîner un réseau de neurones à classer les images de vêtements d'un ensemble de données appelé Fashion MNIST.

Cet ensemble de données contient 70 000 vêtements appartenant à 10 catégories différentes. Les images montrent chaque vêtement en basse résolution (28 x 28 pixels), comme vous le voyez ici :

Dans cet atelier, 60 000 images vont être utilisées pour entraîner le réseau et 10 000 images serviront à évaluer la justesse avec laquelle le réseau a appris à classer les images.

Les données Fashion MNIST sont disponibles dans tensorflow datasets(tfds).

Charger l'ensemble de données

Pour charger les données Fashion MNIST, vous allez utiliser la fonction tfds.load().

1. Ajoutez le code suivant à la deuxième cellule du notebook :

# Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True)

Dans le code ci-dessus, définissez l'argument split pour spécifier les divisions de l'ensemble de données à charger. Paramétrez as_supervised sur True pour que l'objet tf.data.Dataset chargé ait une structure à deux tuples (input, label).

ds_train et ds_test sont de type tf.data.Dataset. ds_train contient 60 000 images qui seront utilisées pour entraîner le modèle. ds_test comporte 10 000 images qui serviront à évaluer le modèle.

Pour en savoir plus sur tfds.load() et ses arguments, consultez le guide.

À quoi ressemblent ces valeurs ?

2. Ensuite, ajoutez des instructions "print" afin d'afficher les valeurs minimale et maximale des images d'entraînement pour l'élément 0. Ajoutez le code suivant à la deuxième cellule :

# Values before normalization image_batch, labels_batch = next(iter(ds_train)) print("Before normalization ->", np.min(image_batch[0]), np.max(image_batch[0]))

Prétraitement des données

1. En machine learning, la taille de lot désigne le nombre d'exemples d'entraînement utilisés dans une itération. Vous allez la définir sur la valeur 32.

Spécifiez la taille de lot en ajoutant le code suivant à model.ipynb :

# Define batch size BATCH_SIZE = 32

2. Pour diverses raisons, il est plus facile de mettre à l'échelle les valeurs de pixels dans une plage comprise entre 0 et 1 lorsque vous entraînez un réseau de neurones. Ce processus est appelé "normalisation". Étant donné que les valeurs de pixels de l'ensemble de données Fashion MNIST se situent dans la plage [0, 255], vous allez les diviser par 255,0 pour normaliser les images.

Le code ci-dessous fait appel à la fonction map() de tf.data.Dataset pour appliquer la normalisation aux images dans ds_train et ds_test. Les valeurs de pixels étant de type tf.uint8, la fonction tf.cast est utilisée pour les convertir en tf.float32 et les diviser par 255,0. Par ailleurs, la méthode batch() est appelée avec l'argument BATCH_SIZE pour convertir l'ensemble de données en lots.

Pour en savoir plus sur les méthodes disponibles pour tf.data.Dataset, cliquez ici.

Ajoutez le code suivant à la fin du fichier :

# Normalize and batch process the dataset ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE)

3. Ajoutez de nouveau des instructions "print" pour afficher les valeurs minimale et maximale d'une image de l'ensemble de données d'entraînement.

Ajoutez le code suivant à la fin du fichier :

# Examine the min and max values of the batch after normalization image_batch, labels_batch = next(iter(ds_train)) print("After normalization ->", np.min(image_batch[0]), np.max(image_batch[0]))

Tâche 4 : Concevoir, compiler et entraîner le modèle

Dans cette section, vous allez concevoir votre modèle à l'aide de TensorFlow.

1. Ajoutez le code suivant au fichier :

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

Examinez les différents types de couches et les paramètres utilisés dans l'architecture du modèle :

• Sequential : définit une SÉQUENCE de couches dans le réseau de neurones.

• Flatten : nos images sont de forme (28, 28), c'est-à-dire que les valeurs se présentent sous la forme d'une matrice carrée. Le paramètre "Flatten" accepte en entrée cette matrice carrée et la transforme en vecteur unidimensionnel.

• Dense : ajoute une couche de neurones.

Chaque couche de neurones a besoin d'une fonction d'activation pour décider si un neurone doit être activé ou non. De nombreuses options sont disponibles. Voici celles utilisées dans cet atelier :

• La fonction ReLU renvoie X si X>0, sinon elle renvoie 0. Elle transmet les valeurs égales ou supérieures à 0 à la couche suivante du réseau.
• La fonction Softmax accepte en entrée un ensemble de valeurs et choisit la plus grande d'entre elles. Vous n'avez donc pas à effectuer de tri pour trouver la plus grande valeur. Par exemple, la fonction renvoie [0,0,0,0,1,0,0,0,0] si le résultat de la dernière couche se présente comme suit : [0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05].

Compiler et entraîner le modèle

Dans cette section, vous allez d'abord compiler votre modèle avec un optimiseur et une fonction de perte. Ensuite, vous l'entraînerez avec vos données d'entraînement et vos étiquettes.

L'objectif est de permettre au modèle de déterminer la relation entre les données d'entraînement et les étiquettes. Une fois l'entraînement terminé, vous présenterez au modèle de nouvelles images de vêtements qui ressemblent aux données d'entraînement et effectuerez des prédictions concernant la classe de vêtements à laquelle elles appartiennent.

Un optimiseur est l'un des deux arguments requis pour compiler un modèle tf.keras. Le paramètre optimizer est un algorithme qui modifie les attributs du réseau de neurones comme les pondérations et le taux d'apprentissage. Il permet de réduire la perte et d'améliorer la justesse.

Pour en savoir plus sur les différents types d'optimiseurs disponibles dans tf.keras, cliquez ici.

Le paramètre loss indique les performances du modèle sous forme de nombre. Si les performances du modèle s'améliorent, la perte diminue. Si elles se dégradent, la perte augmente.

Pour en savoir plus sur les différents types de fonctions de perte disponibles dans tf.keras, cliquez ici.

Examinez le paramètre metrics=. Il permet à TensorFlow de rendre compte de la justesse de l'entraînement après chaque époque en vérifiant les résultats prédits par rapport aux réponses connues (étiquettes). En fait, il indique si l'entraînement progresse efficacement.

Cliquez ici pour en savoir plus sur les différents types de métriques disponibles dans tf.keras.

La méthode model.fit entraîne le modèle pour un nombre fixe d'époques.

1. Ajoutez le code suivant au fichier :

# Compile the model model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5)

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer des modèles de machine learning

Exécuter le code

1. Exécutez la deuxième cellule en cliquant sur le bouton Run (Exécuter) ou en appuyant sur Maj+Entrée.

Lorsque la cellule du notebook s'exécute, la perte et la justesse s'affichent après chaque époque (ou cycle) d'entraînement. Notez que la justesse augmente avec chaque époque (ou cycle).

Vous trouverez un exemple de résultat ci-dessous (notez que vos valeurs peuvent être légèrement différentes et que vous devez ignorer les messages d'avertissement) :

Before normalization -> 0 227 After normalization -> 0.0 1.0 Epoch 1/5 1875/1875 [==============================] - 12s 6ms/step - loss: 0.5264 - sparse_categorical_accuracy: 0.8175 Epoch 2/5 1875/1875 [==============================] - 6s 3ms/step - loss: 0.3977 - sparse_categorical_accuracy: 0.8580 Epoch 3/5 1875/1875 [==============================] - 5s 3ms/step - loss: 0.3585 - sparse_categorical_accuracy: 0.8701 Epoch 4/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3329 - sparse_categorical_accuracy: 0.8784 Epoch 5/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3151 - sparse_categorical_accuracy: 0.8846

Pour le résultat # Values before normalization, vous remarquerez que les valeurs minimale et maximale sont comprises dans la plage [0, 255]. Après la normalisation, toutes les valeurs se situent dans la plage [0, 1].

À mesure que l'entraînement progresse, la perte diminue et la justesse augmente.

Lorsque l'entraînement du modèle est terminé, une valeur de justesse s'affiche à la fin de la dernière époque. Elle peut être proche de 0.8864 comme ci-dessus (notez que votre valeur peut être différente).

Cela indique que le réseau de neurones classe les données d'entraînement avec une justesse d'environ 89 %. En d'autres termes, il a trouvé une correspondance entre l'image et les étiquettes dans 89 % des cas. Même si ce résultat n'est pas optimal, il est plutôt satisfaisant sachant que l'entraînement n'a été effectué que pour cinq époques sur un petit réseau de neurones.

Tâche 5 : Évaluer les performances du modèle sur des données inconnues

Votre modèle est-il performant pour traiter des données inconnues ?

L'ensemble de test peut vous aider à répondre à cette question. Appelez la fonction model.evaluate et transmettez-lui les deux ensembles afin qu'elle renvoie la perte pour chacun d'eux.

Évaluez l'ensemble de test :

1. Ajoutez le code suivant à la troisième cellule du notebook :

cloud_logger.info(model.evaluate(ds_test))

2. Exécutez la cellule en cliquant sur le bouton Run (Exécuter) ou en appuyant sur Maj+Entrée.

Faites défiler le code que vous avez obtenu jusqu'en bas afin de voir le résultat de l'évaluation à la dernière ligne.

Before normalization -> 0 227 After normalization -> 0.0 1.0 Epoch 1/5 1875/1875 [==============================] - 12s 6ms/step - loss: 0.5264 - sparse_categorical_accuracy: 0.8175 Epoch 2/5 1875/1875 [==============================] - 6s 3ms/step - loss: 0.3977 - sparse_categorical_accuracy: 0.8580 Epoch 3/5 1875/1875 [==============================] - 5s 3ms/step - loss: 0.3585 - sparse_categorical_accuracy: 0.8701 Epoch 4/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3329 - sparse_categorical_accuracy: 0.8784 Epoch 5/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3151 - sparse_categorical_accuracy: 0.8846 313/313 [==============================] - 1s 4ms/step - loss: 0.3653 - sparse_categorical_accuracy: 0.8708 INFO:cloudLogger:[0.36530008912086487, 0.8708000183105469]

Le modèle indique une justesse de 0.8708 pour l'ensemble de test (ds_test), ce qui signifie qu'elle est d'environ 87 % (notez que vos valeurs peuvent être légèrement différentes).

Comme prévu, le modèle n'est pas aussi précis avec les données inconnues qu'avec celles sur lesquelles il a été entraîné.

À mesure que vous découvrirez plus en détail TensorFlow, vous apprendrez à améliorer cet aspect.

Cliquez sur Vérifier ma progression pour valider l'objectif. Utiliser le modèle

Tâche 6 : Enregistrer et charger le modèle

La progression du modèle peut être enregistrée pendant et après l'entraînement. Autrement dit, l'exécution du modèle peut reprendre là où elle s'était arrêtée, ce qui évite les longues durées d'entraînement. Grâce à l'enregistrement, vous pouvez partager votre modèle et d'autres peuvent recréer votre travail. Pour ce premier exercice, vous allez ajouter le code requis pour enregistrer et charger votre modèle.

Un modèle entier peut être enregistré dans deux formats de fichiers différents (SavedModel et Keras). TensorFlow SavedModel est le format de fichier par défaut dans TF2.x. Toutefois, les modèles peuvent être enregistrés au format Keras. Vous découvrirez comment enregistrer des modèles dans les deux formats de fichiers.

1. Ajoutez le code suivant à la quatrième cellule du notebook :

# Save the entire model as a SavedModel. model.save('saved_model') # Reload a fresh Keras model from the saved model new_model = tf.keras.models.load_model('saved_model') # Summary of loaded SavedModel new_model.summary() # Save the entire model to a keras file. model.save('my_model.keras') # Recreate the exact same model, including its weights and the optimizer new_model_keras = tf.keras.models.load_model('my_model.keras') # Summary of loaded keras model new_model_keras.summary()

Le code ci-dessus montre comment enregistrer le modèle dans deux formats différents et recharger le modèle enregistré. Vous pouvez choisir n'importe quel format selon votre cas d'utilisation. Pour en savoir plus sur cette fonctionnalité, consultez "Enregistrer et charger des modèles" dans la documentation TensorFlow.

2. Exécutez la cellule en cliquant sur le bouton Run (Exécuter) ou en appuyant sur Maj+Entrée.

Vous pouvez voir deux résumés de modèle à la fin du résultat. Le premier est celui créé après l'enregistrement du modèle au format SavedModel, tandis que le deuxième a été obtenu après l'enregistrement du modèle au format h5.

Comme vous le constatez, les deux résumés de modèle sont identiques, car le même modèle est enregistré dans deux formats différents.

Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= flatten (Flatten) (None, 784) 0 dense (Dense) (None, 64) 50240 dense_1 (Dense) (None, 10) 650 ================================================================= Total params: 50,890 Trainable params: 50,890 Non-trainable params: 0 _________________________________________________________________ Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= flatten (Flatten) (None, 784) 0 dense (Dense) (None, 64) 50240 dense_1 (Dense) (None, 10) 650 ================================================================= Total params: 50,890 Trainable params: 50,890 Non-trainable params: 0 _________________________________________________________________

Cliquez sur Vérifier ma progression pour valider l'objectif. Enregistrer et charger des modèles

Tâche 7 : Explorer les rappels

Lorsque vous avez entraîné le modèle, vous avez remarqué que la perte diminuait et que la justesse augmentait à mesure que l'entraînement progressait. Une fois que vous avez atteint les valeurs souhaitées de justesse et de perte, il se peut que vous ayez dû attendre un certain temps pour que l'entraînement se termine.

Vous auriez peut-être voulu pouvoir arrêter l'entraînement lorsque le modèle avait atteint la valeur de justesse attendue.

Par exemple, si une valeur de justesse de 95 % est suffisante et que le modèle l'atteint après trois époques d'entraînement, pourquoi attendre que davantage d'époques s'exécutent ?

Les rappels apportent une solution à ce problème.

Un rappel est un outil puissant pour personnaliser le comportement d'un modèle Keras pendant l'entraînement, l'évaluation ou l'inférence. Vous pouvez définir un rappel afin d'arrêter l'entraînement dès que votre modèle atteint le niveau de justesse souhaité pour l'ensemble d'entraînement.

Utilisez le code suivant pour voir ce qui se passe si vous définissez un rappel pour arrêter l'entraînement lorsque la justesse atteint 84 % :

1. Ouvrez le menu de lancement et sélectionnez Python3 pour créer un notebook Jupiter.

2. Enregistrez le fichier sous le nom callback_model.ipynb.

3. Collez le code suivant dans la première cellule de callback_model.ipynb :

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging exp_logger = logging.getLogger('expLogger') exp_logger.setLevel(logging.INFO) exp_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="callback")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define Callback class myCallback(tf.keras.callbacks.Callback): def on_epoch_end(self, epoch, logs={}): if(logs.get('sparse_categorical_accuracy')>0.84): exp_logger.info("\nReached 84% accuracy so cancelling training!") self.model.stop_training = True callbacks = myCallback() # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5, callbacks=[callbacks])

4. Appuyez sur Ctrl+S ou accédez à File > Save Notebook (Fichier > Enregistrer le notebook) pour enregistrer les modifications.

5. Exécutez le code en cliquant sur le bouton Run (Exécuter) ou en appuyant sur Maj+Entrée.

Vous constatez que l'entraînement a été annulé après quelques époques.

Cliquez sur Vérifier ma progression pour valider l'objectif. Explorer les rappels

Tâche 8 : Tester le modèle

Dans cette section, vous allez tester les différentes couches du réseau.

Exercice 1

Dans cet exercice, vous allez explorer les couches de votre modèle. Que se passe-t-il lorsque vous modifiez le nombre de neurones ?

1. Ouvrez le menu de lancement et sélectionnez Python3 pour créer un notebook Jupiter.

2. Enregistrez le fichier sous le nom updated_model.ipynb.

3. Collez le code suivant dans la première cellule de updated_model.ipynb :

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging up_logger = logging.getLogger('upLogger') up_logger.setLevel(logging.INFO) up_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="updated")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5) # Logs model summary model.summary(print_fn=up_logger.info)

4. Testez différentes valeurs pour la couche dense.

Accédez à la section # Define the model et passez de 64 à 128 neurones :

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

4. Appuyez sur Ctrl+S ou accédez à File > Save Notebook (Fichier > Enregistrer le notebook) pour enregistrer les modifications.

5. Exécutez le code en cliquant sur le bouton Run (Exécuter) ou en appuyant sur Maj+Entrée.

Les résultats obtenus pour des métriques comme la perte ou la durée d'entraînement sont-ils différents ? À votre avis, pourquoi ?

Lorsque vous passez à 128 neurones, vous devez effectuer davantage de calculs, ce qui ralentit le processus d'entraînement. Dans ce cas, l'augmentation du nombre de neurones a eu un impact positif, car le modèle est plus précis. Cependant, il n'est pas toujours préférable d'ajouter des neurones. La loi des rendements décroissants peut s'appliquer très rapidement.

Cliquez sur Vérifier ma progression pour valider l'objectif. Exercice 1

Exercice 2

Examinez les effets de couches supplémentaires dans le réseau. Que se passe-t-il si vous ajoutez une couche entre les deux couches denses ?

1. Dans updated_model.ipynb, ajoutez une couche à la section # Define the model.

Remplacez la définition de votre modèle par la suivante :

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Appuyez sur Ctrl+S ou accédez à File > Save Notebook (Fichier > Enregistrer le notebook) pour enregistrer les modifications.

3. Exécutez le code en cliquant sur le bouton Run (Exécuter) ou en appuyant sur Maj+Entrée.

Réponse : Aucun impact significatif n'est constaté, car les données sont relativement simples. Pour des données beaucoup plus complexes, des couches supplémentaires sont souvent nécessaires.

Cliquez sur Vérifier ma progression pour valider l'objectif. Exercice 2

Exercice 3

Avant d'entraîner votre modèle, vous avez normalisé les valeurs de pixels dans la plage [0, 1]. Que se passerait-il si vous supprimiez la normalisation pour que les valeurs soient comprises dans la plage [0, 255], comme elles l'étaient initialement dans l'ensemble de données ?

1. Faites le test ! Dans la section # Define, load and configure data, supprimez la fonction map appliquée aux ensembles de données d'entraînement et de test.

# Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.batch(BATCH_SIZE) ds_test = ds_test.batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Ajoutez le code ci-dessous à la fin de la cellule pour afficher la valeur maximale de la première image du lot 0 à l'aide de "print". Sans normalisation, la valeur maximale est comprise dans la plage [0, 255].

# Print out max value to see the changes image_batch, labels_batch = next(iter(ds_train)) t_image_batch, t_labels_batch = next(iter(ds_test)) up_logger.info("training images max " + str(np.max(image_batch[0]))) up_logger.info("test images max " + str(np.max(t_image_batch[0])))

3. Le fichier updated_model.ipynb final se présente comme suit :

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging up_logger = logging.getLogger('upLogger') up_logger.setLevel(logging.INFO) up_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="updated")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.batch(BATCH_SIZE) ds_test = ds_test.batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5) # Logs model summary model.summary(print_fn=up_logger.info) # Print out max value to see the changes image_batch, labels_batch = next(iter(ds_train)) t_image_batch, t_labels_batch = next(iter(ds_test)) up_logger.info("training images max " + str(np.max(image_batch[0]))) up_logger.info("test images max " + str(np.max(t_image_batch[0])))

4. Appuyez sur Ctrl+S ou accédez à File > Save Notebook (Fichier > Enregistrer le notebook) pour enregistrer les modifications.

5. Exécutez le code en cliquant sur le bouton Run (Exécuter) ou en appuyant sur Maj+Entrée.

Résultat attendu pour # Print out max value to see the changes

INFO:upLogger:training images max 255 INFO:upLogger:test images max 255

Après avoir exécuté les époques, vous pouvez voir que la justesse varie en l'absence de normalisation.

À votre avis, pourquoi ?

Consultez cette page Stack Overflow qui explique très bien la raison de ce phénomène.

Cliquez sur Vérifier ma progression pour valider l'objectif. Exercice 3

Exercice 4

Que se passe-t-il si vous supprimez la couche Flatten() et pourquoi ?

Faites le test.

1. Dans la section # Define the model, supprimez tf.keras.layers.Flatten() :

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Enregistrez et exécutez la cellule dans updated_model.ipynb.

Vous recevez un message d'erreur concernant la forme des données, ce qui est tout à fait normal.

Les détails de l'erreur peuvent sembler vagues pour l'instant, mais ils mettent l'accent sur le fait que la première couche de votre réseau doit généralement avoir la même forme que vos données. Les images d'entrée sont actuellement de forme 28x28, et 28 couches de 28 neurones seraient ingérables. Il est donc plus logique d'aplatir cette valeur 28,28 à 784x1.

Au lieu d'écrire tout le code pour gérer ce problème vous-même, vous pouvez ajouter la couche Flatten() au début. Lorsque les tableaux seront chargés ultérieurement dans le modèle, ils seront automatiquement aplatis.

Exercice 5

Observez la couche (de sortie) finale. Pourquoi comporte-t-elle 10 neurones ? Que se passe-t-il si le nombre de neurones est différent de 10 ?

Découvrez-le en entraînant le réseau avec 5 neurones.

1. Remplacez la section # Define the model par le code suivant pour annuler la modification apportée dans la section précédente :

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Faites passer le nombre de neurones de la dernière couche de 10 à 5 :

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(5, activation=tf.nn.softmax)])

3. Enregistrez et exécutez la cellule dans updated_model.ipynb.

Ce qui se passe : vous recevez un message d'erreur dès qu'une valeur inattendue est détectée.

Autre règle de base : le nombre de neurones de la dernière couche doit correspondre au nombre de classes à catégoriser. Dans ce cas, il s'agit des chiffres 0 à 9. Il y en a donc 10 et la dernière couche doit comporter 10 neurones.

Félicitations !

Félicitations ! Dans cet atelier, vous avez découvert comment concevoir, compiler, entraîner et évaluer un modèle Tensorflow. Vous avez également appris à enregistrer et à charger des modèles, ainsi qu'à écrire vos propres rappels pour personnaliser le comportement pendant l'entraînement. Par ailleurs, vous avez réalisé une série d'exercices vous permettant de tester les différentes couches du réseau.

Étapes suivantes et informations supplémentaires

• Découvrez tout ce que vous devez savoir dans le Cours d'initiation au Machine Learning.
• Amusez-vous sur la page Essayer pour vous faire une idée de ce que vous pouvez réaliser avec la vision par ordinateur.
• Pour explorer les fonctionnalités de machine learning disponibles dans Vertex AI, consultez la documentation Vertex AI.
• Découvrez l'IA de façon ludique grâce aux Expériences avec Google.
• Apprenez-en plus sur TensorFlow.

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 12 septembre 2024

Dernier test de l'atelier : 12 septembre 2024

Copyright 2024 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.