Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

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

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

Cette courte introduction utilise Keras à:

  1. Chargez un jeu de données prédéfini.
  2. Construisez 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 Google Colaboratory portable. Les programmes Python sont exécutés directement dans le navigateur, un excellent moyen d'apprendre et d'utiliser TensorFlow. Pour suivre ce tutoriel, exécutez le bloc-notes dans Google Colab en cliquant sur le bouton en haut de cette page.

  1. En Colab, se connecter à un moteur d' exécution Python: En haut à droite de la barre de menu, sélectionnez CONNECT.
  2. Exécuter toutes les cellules de code portable: Sélectionnez Runtime> Exécuter tout.

Configurer TensorFlow

Importez TensorFlow dans votre programme pour commencer :

import tensorflow as tf
print("TensorFlow version:", tf.__version__)
TensorFlow version: 2.6.0

Si vous suivez le long dans votre propre environnement de développement, plutôt que Colab , consultez le guide d' installation pour la mise en place tensorflow pour le développement.

Charger un jeu de données

Charger et préparer l' ensemble 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
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
11501568/11490434 [==============================] - 0s 0us/step

Construire un modèle d'apprentissage automatique

Construire un tf.keras.Sequential modèle par empilement de 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 retourne un vecteur de logits ou log-odds scores, un pour chaque classe.

predictions = model(x_train[:1]).numpy()
predictions
array([[ 0.74148655, -0.39261633,  0.08016336, -0.46431944,  0.21458861,
         0.31183302,  0.7555975 ,  0.80728006, -0.6296631 , -0.4926056 ]],
      dtype=float32)

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

tf.nn.softmax(predictions).numpy()
array([[0.16651046, 0.05356818, 0.08594736, 0.04986165, 0.09831339,
        0.10835411, 0.16887674, 0.1778342 , 0.04226285, 0.04847102]],
      dtype=float32)

Définir une fonction de perte pour la formation à l' aide losses.SparseCategoricalCrossentropy , qui prend un vecteur de logits et un True index et retourne une perte scalaire pour chaque exemple.

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

Cette perte est égale au log de probabilité négatif de la vraie classe : La perte est nulle si le modèle est sûr de la bonne classe.

Ce modèle donne sans formation probabilités proche aléatoire (1/10 pour chaque classe), de sorte que la perte initiale devrait être proche de -tf.math.log(1/10) ~= 2.3 .

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

Avant de commencer la formation, configurer et compilez le modèle à l' aide Keras Model.compile . Définir l' optimizer classe à adam , définissez la loss à la loss_fn fonction que vous avez définie précédemment, et spécifiez une mesure à évaluer pour le modèle en définissant les metrics paramètre de accuracy .

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

Former et évaluer votre modèle

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

model.fit(x_train, y_train, epochs=5)
Epoch 1/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2956 - accuracy: 0.9137
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1430 - accuracy: 0.9572
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1059 - accuracy: 0.9682
Epoch 4/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0870 - accuracy: 0.9736
Epoch 5/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0732 - accuracy: 0.9774
<keras.callbacks.History at 0x7fabfe6f6cd0>

La Model.evaluate méthode vérifie les performances des modèles, généralement sur une « validation-set » ou « Test-set ».

model.evaluate(x_test,  y_test, verbose=2)
313/313 - 0s - loss: 0.0771 - accuracy: 0.9756
[0.07707860320806503, 0.975600004196167]

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

Si vous souhaitez 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([[9.35628634e-07, 1.90160367e-08, 2.08603578e-05, 3.36712168e-04,
        3.99928729e-10, 3.29815066e-07, 1.11730861e-12, 9.99547541e-01,
        5.78590800e-07, 9.29015441e-05],
       [9.06768847e-08, 1.75887300e-03, 9.98239040e-01, 1.42416525e-06,
        2.24498985e-14, 1.93019602e-07, 4.19461571e-07, 1.78353019e-14,
        1.09490275e-08, 3.30677152e-15],
       [1.80358853e-07, 9.99705374e-01, 4.36524460e-05, 7.87066620e-06,
        6.60410151e-05, 1.29832119e-06, 2.66996949e-06, 5.51502962e-05,
        1.15344104e-04, 2.45894512e-06],
       [9.99937892e-01, 1.82150364e-10, 2.67099913e-05, 1.87603248e-07,
        2.81131548e-07, 1.86480634e-06, 2.33697901e-05, 1.97653662e-07,
        3.29448504e-08, 9.38197445e-06],
       [1.53162068e-06, 2.57238808e-09, 2.05853598e-06, 2.75526531e-07,
        9.93477166e-01, 2.57349512e-07, 3.59538944e-06, 9.20545644e-05,
        1.77590653e-06, 6.42123120e-03]], dtype=float32)>

Conclusion

Toutes nos félicitations! Vous avez formé un modèle d'apprentissage de la machine à l' aide d' un jeu de données préconstruit en utilisant l' Keras API.

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