Classification d'images CNN dans TensorFlow avec étapes et exemples

Qu'est-ce qu'un réseau de neurones convolutifs ?

Réseau neuronal convolutifLes réseaux de neurones convolutifs (CNN), également appelés réseaux de neurones à propagation avant (convnets), sont une méthode bien connue en vision par ordinateur. Il s'agit d'une classe de réseaux de neurones profonds utilisés pour analyser des images. Ce type d'architecture est prédominant pour la reconnaissance d'objets dans une image ou une vidéo. On le retrouve dans des applications telles que la reconnaissance d'images ou de vidéos, le traitement automatique du langage naturel et les systèmes de recommandation.

Archistructure d'un réseau de neurones convolutifs

Pensez à Facebook il y a quelques années, après avoir téléchargé une photo sur votre profil, il vous était demandé d'ajouter manuellement un nom au visage sur la photo. De nos jours, Facebook utilise convnet pour identifier automatiquement votre ami sur la photo.

Un réseau neuronal convolutif pour la classification d’images n’est pas très difficile à comprendre. Une image d'entrée est traitée pendant la phase de convolution et se voit ensuite attribuer une étiquette.

L'architecture typique d'un réseau de neurones convolutif est illustrée ci-dessous. Une image, appelée image d'entrée, est d'abord fournie au réseau. Elle subit ensuite une série d'étapes : la phase de convolution. Enfin, le réseau de neurones peut prédire le chiffre présent sur l'image.

Une image est composée d'un ensemble de pixels, définis par une hauteur et une largeur. Une image en niveaux de gris ne possède qu'un seul canal, tandis qu'une image couleur en possède trois (un pour le rouge, un pour le vert et un pour le bleu). Ces canaux sont superposés. Dans ce tutoriel, vous utiliserez une image en niveaux de gris à un seul canal. Chaque pixel possède une valeur comprise entre 0 et 255, reflétant l'intensité de sa couleur. Par exemple, un pixel de valeur 0 sera blanc, tandis qu'un pixel dont la valeur est proche de 255 sera plus foncé.

Jetons un coup d'œil à une image stockée dans le Jeu de données MNISTL'image ci-dessous montre comment représenter l'image de gauche sous forme de matrice. Notez que la matrice originale a été normalisée entre 0 et 1. Pour les couleurs foncées, la valeur dans la matrice est d'environ 0.9, tandis que les pixels blancs ont une valeur de 0.

Opération convolutive

L'élément le plus critique du modèle est la couche de convolution. Cette partie vise à réduire la taille de l'image pour accélérer le calcul des poids et améliorer la généralisation.

Durant la partie convolutive, le réseau conserve les caractéristiques essentielles de l'image et exclut les bruits non pertinents. Par exemple, le modèle apprend à reconnaître un éléphant à partir d’une photo avec une montagne en arrière-plan. Si vous utilisez un réseau de neurones classique, le modèle attribuera un poids à tous les pixels, y compris ceux de la montagne ce qui n'est pas indispensable et peut induire le réseau en erreur.

Au lieu de cela, un Keras Le réseau neuronal convolutif utilisera une technique mathématique pour extracSeuls les pixels les plus pertinents sont conservés. Cette opération mathématique s'appelle la convolution. Cette technique permet au réseau d'apprendre des caractéristiques de plus en plus complexes à chaque couche. La convolution divise la matrice en petits morceaux afin d'apprendre les éléments les plus essentiels au sein de chaque morceau.

Composants du réseau neuronal convolutif (ConvNet ou CNN)

Un réseau de neurones convolutif comporte quatre composants :

1. Convolution
2. Non linéarité (ReLU)
3. Pooling ou sous-échantillonnage
4. Classification (couche entièrement connectée)

Convolution

Le but de la convolution est d'extracLe réseau apprendra les caractéristiques de l'objet sur l'image localement. Autrement dit, il apprendra des motifs spécifiques au sein de l'image et sera capable de les reconnaître partout.

La convolution est une multiplication élément par élément. Le concept est simple à comprendre. L'ordinateur analyse une partie de l'image, généralement de dimension 3×3, et la multiplie par un filtre. Le résultat de cette multiplication élément par élément est appelé carte de caractéristiques. Cette étape est répétée jusqu'à ce que l'image entière soit analysée. Notez qu'après la convolution, la taille de l'image est réduite.

Le schéma ci-dessous montre une portion de l'image multipliée par le filtre pour produire une seule cellule de la carte des caractéristiques.

L'animation ci-dessous montre la même convolution parcourant l'ensemble de l'image.

De nombreux filtres sont disponibles. Vous trouverez ci-dessous une liste de quelques-uns d'entre eux. Chaque filtre a une fonction spécifique. Notez que, sur l'image ci-dessous, le terme « noyau » désigne un synonyme du filtre.

Arithmétique derrière la convolution

La phase de convolution applique le filtre à une petite matrice de pixels de l'image. Le filtre se déplace le long de l'image d'entrée selon une forme générale de 3×3 ou 5×5. Autrement dit, le réseau fait glisser ces fenêtres sur toute l'image d'entrée et calcule la convolution. L'animation ci-dessous illustre le fonctionnement de la convolution. La taille de la matrice est de 3×3, et la matrice de sortie résulte de l'opération élément par élément entre la matrice de l'image et le filtre.

Vous remarquez que la largeur et la hauteur de la sortie peuvent être différentes de la largeur et de la hauteur de l'entrée. Cela se produit à cause de l’effet frontière.

Effet bordure

L'image comporte une carte de caractéristiques 5×5 et un filtre 3×3. Seule une fenêtre centrale permet au filtre de filtrer une grille 3×3. La carte de caractéristiques résultante est réduite de deux tuiles sur chaque axe, conservant ainsi une dimension de 3×3.

Pour que la matrice de sortie ait la même dimension que la matrice d'entrée, il faut ajouter un remplissage. Ce remplissage consiste à ajouter le nombre approprié de lignes et de colonnes de chaque côté de la matrice. Cela permettra à la convolution de centrer chaque élément de la matrice d'entrée. Dans l'image ci-dessous, les matrices d'entrée et de sortie ont la même dimension : 5×5.

Lorsque vous définissez le réseau, les entités convoluées sont contrôlées par trois paramètres :

Profondeur: Il définit le nombre de filtres à appliquer lors de la convolution. Dans l'exemple précédent, la profondeur était de 1, ce qui signifie qu'un seul filtre est utilisé. Dans la plupart des cas, plusieurs filtres sont appliqués. L'animation ci-dessous illustre les opérations effectuées avec trois filtres.

Foulée: Il définit le nombre de pixels de décalage entre deux tranches. Si le décalage est de 1, la fenêtre se déplace d'un pixel. Si le décalage est de 2, la fenêtre se déplace de 2 pixels. Plus le décalage est important, plus les cartes de caractéristiques sont petites. Les deux schémas ci-dessous comparent un décalage de 1 à un décalage de 2.

Exemple de foulée 1

foulée 2

Remplissage nul : Le remplissage consiste à ajouter un nombre correspondant de lignes et de colonnes de chaque côté des cartes de caractéristiques d'entrée. Dans ce cas, la sortie a les mêmes dimensions que l'entrée.

Non linéarité (ReLU)

À la fin de l'opération de convolution, la sortie est soumise à une fonction d'activation pour introduire la non-linéarité. La fonction d'activation généralement utilisée pour un réseau de neurones convolutif est la ReLU. Tous les pixels ayant une valeur négative sont remplacés par zéro.

Pooling Operaproduction

Cette étape est facile à comprendre. Le but du pooling est de réduire la dimensionnalité de l'image d'entrée. Ces étapes permettent de réduire la complexité de calcul de l'opération. En diminuant la dimensionnalité, le réseau a moins de poids à calculer, ce qui évite le surapprentissage.

À cette étape, vous devez définir la taille et le pas. Une méthode standard pour le pooling de l'image d'entrée consiste à utiliser la valeur maximale de la carte de caractéristiques. Voir l'image ci-dessous. Le pooling analyse quatre sous-matrices de la carte de caractéristiques 4×4 et renvoie la valeur maximale. Le pooling prend la valeur maximale d'un tableau 2×2, puis décale cette fenêtre de deux pixels. Par exemple, la première sous-matrice est [3,1,3,2], le pooling renverra donc le maximum, soit 3.

Il existe une autre opération de mutualisation telle que la moyenne.

Cette opération réduit drastiquement la taille de la carte des caractéristiques.

Couches entièrement connectées

La dernière étape consiste à construire un bâtiment traditionnel réseau neuronal artificiel comme vous l'avez fait dans le tutoriel précédent. Vous connectez tous les neurones de la couche précédente à la couche suivante. Vous utilisez une fonction d'activation softmax pour classer le numéro sur l'image d'entrée.

Recap:

Un réseau de neurones convolutif TensorFlow compile différentes couches avant d'effectuer une prédiction. Un réseau de neurones possède :

• Une couche convolutive
• Fonction d'activation ReLU
• Pooling couche
• Couche densément connectée

Les couches de convolution appliquent différents filtres à une sous-région de l'image. La fonction d'activation ReLU introduit de la non-linéarité, et les couches de pooling réduisent la dimensionnalité des cartes de caractéristiques.

Toutes ces couches extracLes informations essentielles sont extraites des images. Enfin, les cartes de caractéristiques sont transmises à une couche entièrement connectée avec une fonction softmax pour effectuer une prédiction.

Entraîner CNN avec TensorFlow

Maintenant que vous connaissez les éléments constitutifs d'un réseau de neurones convolutif, vous êtes prêt à en construire un. TensorFlow. Nous utiliserons l'ensemble de données MNIST pour la classification des images CNN.

La préparation des données est la même que celle du tutoriel précédent. Vous pouvez exécuter les codes et accéder directement à l'architecture de CNN.

Vous suivrez les étapes ci-dessous pour la classification d'images à l'aide de CNN :

1. Étape 1 : Télécharger l'ensemble de données
2. Étape 2 : Couche d'entrée
3. Étape 3 : Couche convolutive
4. Étape 4 : Pooling couche
5. Étape 5 : Deuxième couche convolutive et Pooling Couche
6. Étape 6 : Couche dense
7. Étape 7 : Couche Logit

Note de version : Les exemples ci-dessous ciblent TensorFlow 1.x. Dans TensorFlow 2, l'espace de noms `tf.layers` et `tf.estimator.inputs.numpy_input_fn` n'existent plus ; leurs équivalents sont `tf.keras.layers.Conv2D` et `Max`.PoolinLes couches g2D, Dense et Dropout sont assemblées dans un modèle tf.keras.Model et entraînées avec model.fit(). Consultez la documentation relative au fonctionnement de chaque couche, puis appliquez-la à l'API Keras.

Étape 1 : Télécharger l'ensemble de données

Le jeu de données MNIST est disponible via scikit-learn. Veuillez le télécharger et l'enregistrer dans le dossier Téléchargements. Vous pouvez ensuite l'importer avec la fonction `fetch_mldata('MNIST original')`.

Note de version : mldata.org a fermé ses portes et la fonction fetch_mldata() a été supprimée dans scikit-learn 0.22. Sur toute installation actuelle, chargez les mêmes chiffres avec récupérer_openml Utilisez plutôt `fetch_openml('mnist_784', version=1)`. Le reste du pipeline demeure inchangé.

Créer un ensemble d'entraînement/test

Vous devez diviser l'ensemble de données avec train_test_split.

Mettre à l'échelle les fonctionnalités

Enfin, vous pouvez mettre à l'échelle les caractéristiques avec MinMaxScaler comme indiqué dans l'exemple de classification d'images ci-dessous utilisant TensorFlow CNN.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))
feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]
X_train_scaled.shape[1:]

Définir le CNN

Un réseau de neurones convolutif (CNN) utilise des filtres sur les pixels bruts d'une image pour apprendre des motifs détaillés, contrairement aux motifs globaux appris par un réseau de neurones traditionnel. Pour construire un CNN, il faut définir :

1. Couche de convolution : Appliquez n filtres à la carte de caractéristiques. Après la convolution, utilisez une fonction d'activation ReLU pour introduire de la non-linéarité dans le réseau.
2. PoolinCouche g : L’étape suivante après la convolution consiste à sous-échantillonner la carte de caractéristiques. L’objectif est de réduire sa dimensionnalité afin d’éviter le surapprentissage et d’améliorer la vitesse de calcul. Le max pooling est la technique classique ; il divise la carte de caractéristiques en sous-régions (généralement de taille 2×2) et ne conserve que les valeurs maximales.
3. Couches entièrement connectées : tous les neurones des couches précédentes sont connectés aux couches suivantes. Le CNN classera l'étiquette en fonction des caractéristiques des couches convolutives et réduites avec la couche de pooling.

Architecture de CNN

• Couche de convolution : applique 14 filtres 5×5 (ex.tracsous-régions de 5×5 pixels), avec fonction d'activation ReLU
• Pooling Layer : effectue un regroupement maximal avec un filtre 2×2 et une foulée de 2 (qui spécifie que les régions regroupées ne se chevauchent pas)
• Couche convolutive : applique 36 filtres 5 × 5, avec fonction d'activation ReLU
• Pooling Couche n°2 : Encore une fois, effectue un regroupement maximal avec un filtre 2×2 et une foulée de 2
• 1,764 0.4 neurones, avec un taux de régularisation d'abandon de 0.4 (probabilité de qu'un élément donné soit abandonné pendant l'entraînement)
• Couche dense (couche Logits) : 10 neurones, un pour chaque classe cible de chiffres (0 à 9).

Il existe trois modules importants à utiliser pour créer un CNN :

• conv2d(). Construit une couche convolutive bidimensionnelle avec le nombre de filtres, la taille du noyau du filtre, le remplissage et la fonction d'activation comme arguments.
• max_pooling2d(). Construit une couche de pooling bidimensionnelle à l'aide de l'algorithme de pooling maximum.
• dense(). Construit une couche dense avec les couches et unités cachées

Vous allez définir une fonction pour construire le CNN. Voyons en détail comment construire chaque élément constitutif avant de conclure.ping Tout est réuni dans la fonction.

Étape 2 : Couche d'entrée

def cnn_model_fn(features, labels, mode):
    input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Vous devez définir un tenseur avec la forme des données. Pour cela, vous pouvez utiliser le module tf.reshape. Dans ce module, vous devez déclarer le tenseur à remodeler ainsi que la forme du tenseur. Le premier argument concerne les caractéristiques des données, qui sont définies dans l'argument de la fonction.

Une image possède une hauteur, une largeur et un canal. Le jeu de données MNIST est composé d'images monochromes de 28 × 28 pixels. Nous fixons la taille du lot à -1 dans l'argument `shape` afin qu'elle corresponde à la forme des `features["x"]`. L'avantage est de pouvoir ajuster la taille du lot comme un hyperparamètre. Si la taille du lot est fixée à 7, le tenseur recevra 5 488 valeurs (28 × 28 × 7).

Étape 3 : Couche convolutive

# first Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

La première couche de convolution comporte 14 filtres avec un noyau de taille 5×5 et un remplissage identique. Ce remplissage identique garantit que les tenseurs d'entrée et de sortie ont la même hauteur et la même largeur. TensorFlow ajoute des zéros aux lignes et aux colonnes pour assurer cette homogénéité.

Vous utilisez la fonction d'activation ReLU. La taille de la sortie sera [28, 28, 14].

Étape 4 : Pooling couche

L'étape suivante après la convolution est le calcul du pooling. Ce calcul réduit la dimensionnalité des données. Vous pouvez utiliser le module `max_pooling2d` avec une taille de 2×2 et un pas de 2. La couche précédente est utilisée comme entrée. La taille de la sortie sera `[batch_size, 14, 14, 14]`.

# first Pooling Layer 
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Étape 5 : Deuxième couche convolutive et Pooling Couche

La seconde couche de convolution applique 36 filtres, ce qui donne une sortie de taille [batch_size, 14, 14, 36]. La couche de pooling utilise la même fenêtre 2×2 et le même pas de 2 qu'auparavant ; elle divise donc chaque axe spatial par deux et la forme de la sortie devient [batch_size, 7, 7, 36].

conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

Étape 6 : Couche dense

Ensuite, vous devez définir la couche entièrement connectée. La carte de caractéristiques doit être aplatie avant d'être connectée à la couche dense. Vous pouvez utiliser le module reshape avec une taille de 7 × 7 × 36.

La couche dense comprendra 1,764 0 neurones. Une fonction d'activation ReLU est ajoutée. De plus, un terme de régularisation par abandon (dropout) avec un taux de 0.3 est appliqué, ce qui signifie que 30 % des activations seront mises à zéro. Notez que le dropout n'intervient que pendant la phase d'entraînement. La fonction `cnn_model_fn` possède un argument `mode` permettant de spécifier si le modèle doit être entraîné ou évalué, comme illustré dans l'exemple de classification d'images par CNN sous TensorFlow ci-dessous.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Étape 7 : Couche Logit

Enfin, dans l'exemple de classification d'images TensorFlow, vous pouvez définir la dernière couche avec la prédiction du modèle. La forme de la sortie est égale à la taille du lot et à 10, le nombre total de classes cibles.

# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)

Vous pouvez créer un dictionnaire contenant les classes et la probabilité de chaque classe. La fonction `tf.argmax()` renvoie l'indice de la valeur la plus élevée dans la couche logits. La fonction `softmax` renvoie la probabilité de chaque classe.

predictions = {				
	# Generate predictions				
    "classes": tf.argmax(input=logits, axis=1),				
    "probabilities": tf.nn.softmax(logits, name="softmax_tensor")  }			

Vous souhaitez uniquement renvoyer le dictionnaire de prédictions lorsque le mode est défini sur « prédiction ». Ajoutez ce code pour afficher les prédictions.

if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

L'étape suivante consiste à calculer la fonction de perte du modèle. Dans le tutoriel précédent, vous avez appris que la fonction de perte d'un modèle multiclasse est l'entropie croisée. La perte se calcule facilement avec le code suivant :

# Calculate Loss (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

La dernière étape de l'exemple de réseau de neurones convolutif TensorFlow consiste à optimiser le modèle, c'est-à-dire à trouver les meilleures valeurs pour les poids. Pour cela, on utilise un optimiseur de descente de gradient avec un taux d'apprentissage de 0.001. L'objectif est de minimiser la perte.

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())

Vous avez terminé avec le CNN. Cependant, vous souhaitez afficher les indicateurs de performance en mode évaluation. L'indicateur de performance pour un modèle multiclasse est la précision. TensorFlow dispose d'un module de précision qui prend deux arguments : les étiquettes et les valeurs prédites.

eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

C'est ça. Vous avez créé votre premier CNN et vous êtes prêt à tout intégrer dans une fonction afin de l'utiliser pour entraîner et évaluer le modèle.

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

  # Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=32,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

  # Pooling Layer
  pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

  # Convolutional Layer #2 and Pooling Layer
  conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
  pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

  # Dense Layer
  pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])
  dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
  dropout = tf.layers.dropout(
      inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)

  # Logits Layer
  logits = tf.layers.dense(inputs=dropout, units=10)

  predictions = {
      # Generate predictions (for PREDICT and EVAL mode)
      "classes": tf.argmax(input=logits, axis=1),
      "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
  }

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  # Calculate Loss
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

  # Configure the Training Op (for TRAIN mode)
  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
    train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

  # Add evaluation metrics Evaluation mode
  eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(
          labels=labels, predictions=predictions["classes"])}
  return tf.estimator.EstimatorSpec(
      mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Note sur la fonction assemblée : La version encapsulée ci-dessus configure la première couche convolutionnelle avec 32 filtres et un taux de dropout de 0.4, tandis que les extraits étape par étape utilisent 14 filtres et 0.3. Les deux versions s'exécutent, mais choisissez une paire de valeurs et conservez-la cohérente afin que les formes imprimées correspondent au tableau des couches.

Les étapes ci-dessous sont les mêmes que les didacticiels précédents.

Tout d'abord, vous définissez un estimateur avec le modèle CNN pour la classification d'images.

# Create the Estimator
mnist_classifier = tf.estimator.Estimator(
    model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")

L'entraînement d'un CNN prend beaucoup de temps ; par conséquent, vous créez un système de journalisation pour stocker les valeurs des couches softmax toutes les 50 itérations.

# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

Vous êtes prêt à estimer le modèle. Définissez une taille de lot de 100 et mélangez les données. Notez que nous avons défini 16 000 itérations d'entraînement, ce qui peut prendre beaucoup de temps. Soyez patient.

# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=100,
    num_epochs=None,
    shuffle=True)
mnist_classifier.train(
    input_fn=train_input_fn,
    steps=16000,
    hooks=[logging_hook])

Maintenant que le modèle est entraîné, vous pouvez l'évaluer et imprimer les résultats.

# Evaluate the model and print results
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test,
    num_epochs=1,
    shuffle=False)
eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
print(eval_results)

L'évaluation affiche le point de contrôle restauré, l'étape à laquelle elle s'est arrêtée et le dictionnaire final des métriques.

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269
{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}

Avec l'architecture actuelle, le dictionnaire d'évaluation indique une précision de 0.9689286, soit environ 97 %. Vous pouvez modifier l'architecture, la taille des lots et le nombre d'itérations pour améliorer la précision. Le CNN a obtenu des résultats bien supérieurs à ceux d'un autre réseau de neurones. réseau neuronal artificiel ou la régression logistique : dans le tutoriel sur les réseaux de neurones artificiels, vous avez obtenu une précision de 96 %, inférieure à celle du CNN. Les performances du CNN sont impressionnantes avec un grand nombre d’images, tant en termes de vitesse de calcul que de précision.

FAQ