Assistez au symposium Women in ML le 7 décembre Inscrivez-vous maintenant

Démarrage rapide de TensorFlow 2 pour les débutants

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Voir sur TensorFlow.org Exécuter dans Google Colab Voir la source sur GitHub Télécharger le cahier

Cette courte introduction utilise Keras pour :

  1. Chargez un jeu de données prédéfini.
  2. Créez un modèle d'apprentissage automatique de réseau neuronal qui classe les images.
  3. Entraînez ce réseau de neurones.
  4. Évaluer la précision du modèle.

Ce tutoriel est un bloc-notes Google Colaboratory . Les programmes Python sont exécutés directement dans le navigateur, un excellent moyen d'apprendre et d'utiliser TensorFlow. Pour suivre ce didacticiel, exécutez le bloc-notes dans Google Colab en cliquant sur le bouton en haut de cette page.

  1. Dans Colab, connectez-vous à un runtime Python : en haut à droite de la barre de menus, sélectionnez CONNECT .
  2. Exécutez toutes les cellules de code du bloc-notes : sélectionnez Runtime > Run all .

Configurer TensorFlow

Importez TensorFlow dans votre programme pour commencer :

import tensorflow as tf
print("TensorFlow version:", tf.__version__)
TensorFlow version: 2.8.0-rc1

Si vous suivez dans votre propre environnement de développement, plutôt que Colab , consultez le guide d'installation pour configurer TensorFlow pour le développement.

Charger un jeu de données

Chargez et préparez le jeu de données MNIST . Convertissez les exemples de données d'entiers en nombres à virgule flottante :

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

Créer un modèle d'apprentissage automatique

Créez un modèle tf.keras.Sequential en empilant des couches.

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10)
])

Pour chaque exemple, le modèle renvoie un vecteur de scores logits ou log-odds , un pour chaque classe.

predictions = model(x_train[:1]).numpy()
predictions
array([[ 0.2760778 , -0.39324787, -0.17098302,  1.2016621 , -0.03416392,
         0.5461229 , -0.7203061 , -0.41886678, -0.59480035, -0.7580608 ]],
      dtype=float32)

La fonction tf.nn.softmax convertit ces logits en probabilités pour chaque classe :

tf.nn.softmax(predictions).numpy()
array([[0.11960829, 0.06124588, 0.0764901 , 0.30181262, 0.08770514,
        0.15668967, 0.04416083, 0.05969675, 0.05006609, 0.04252464]],
      dtype=float32)

Définissez une fonction de perte pour l'entraînement à l'aide losses.SparseCategoricalCrossentropy , qui prend un vecteur de logits et un indice True et renvoie une perte scalaire pour chaque exemple.

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

Cette perte est égale à la probabilité logarithmique négative de la vraie classe : la perte est nulle si le modèle est sûr de la bonne classe.

Ce modèle non formé donne des probabilités proches du hasard (1/10 pour chaque classe), donc la perte initiale devrait être proche de -tf.math.log(1/10) ~= 2.3 .

loss_fn(y_train[:1], predictions).numpy()
1.8534881

Avant de commencer l'entraînement, configurez et compilez le modèle à l'aide de Keras Model.compile . Définissez la classe d' optimizer sur adam , définissez la loss sur la fonction loss_fn que vous avez définie précédemment et spécifiez une métrique à évaluer pour le modèle en définissant le metrics sur accuracy .

model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])

Entraînez et évaluez votre modèle

Utilisez la méthode Model.fit pour ajuster les paramètres de votre modèle et minimiser la perte :

model.fit(x_train, y_train, epochs=5)
Epoch 1/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2950 - accuracy: 0.9143
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1451 - accuracy: 0.9567
Epoch 3/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.1080 - accuracy: 0.9668
Epoch 4/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.0906 - accuracy: 0.9717
Epoch 5/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.0749 - accuracy: 0.9761
<keras.callbacks.History at 0x7f062c606850>

La méthode Model.evaluate vérifie les performances des modèles, généralement sur un " Validation-set " ou " Test-set ".

model.evaluate(x_test,  y_test, verbose=2)
313/313 - 1s - loss: 0.0783 - accuracy: 0.9755 - 588ms/epoch - 2ms/step
[0.07825208455324173, 0.9754999876022339]

Le classificateur d'images est maintenant formé à une précision d'environ 98 % sur cet ensemble de données. Pour en savoir plus, lisez les tutoriels TensorFlow .

Si vous voulez que votre modèle renvoie une probabilité, vous pouvez envelopper le modèle entraîné et lui attacher le softmax :

probability_model = tf.keras.Sequential([
  model,
  tf.keras.layers.Softmax()
])
probability_model(x_test[:5])
<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[2.72807270e-08, 2.42517650e-08, 7.75602894e-06, 1.28684027e-04,
        7.66215633e-11, 3.54162950e-07, 3.04894151e-14, 9.99857187e-01,
        2.32766553e-08, 5.97762892e-06],
       [7.37396704e-08, 4.73638036e-04, 9.99523997e-01, 7.20633352e-07,
        4.54133671e-17, 1.42298268e-06, 5.96959016e-09, 1.23534145e-13,
        7.77225608e-08, 6.98619169e-16],
       [1.95462448e-07, 9.99295831e-01, 1.02249986e-04, 1.86699708e-05,
        5.65737491e-06, 1.12115902e-06, 5.32719559e-06, 5.22767776e-04,
        4.79981136e-05, 1.76624681e-07],
       [9.99649286e-01, 1.80224735e-09, 3.73612856e-05, 1.52324446e-07,
        1.30824594e-06, 2.82781020e-05, 6.99703523e-05, 3.30940424e-07,
        2.13184350e-07, 2.13106396e-04],
       [1.53770895e-06, 1.72272063e-08, 1.98980865e-06, 3.97882580e-08,
        9.97192323e-01, 1.10544443e-05, 1.54713348e-06, 2.81727880e-05,
        3.48721733e-06, 2.75991508e-03]], dtype=float32)>

Conclusion

Toutes nos félicitations! Vous avez formé un modèle d'apprentissage automatique à l'aide d'un ensemble de données prédéfini à l'aide de l'API Keras .

Pour plus d'exemples d'utilisation de Keras, consultez les tutoriels . Pour en savoir plus sur la création de modèles avec Keras, lisez les guides . Si vous souhaitez en savoir plus sur le chargement et la préparation des données, consultez les didacticiels sur le chargement des données d'image ou le chargement des données CSV .