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

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

Réseau neuronal convolutif, également connu sous le nom de convnets ou CNN, est une méthode bien connue dans les applications de vision par ordinateur. Il s'agit d'une classe de réseaux de neurones profonds utilisés pour analyser les images visuelles. Ce type d'architecture est dominant pour reconnaître des objets à partir d'une image ou d'une vidéo. Il est utilisé dans des applications comme la reconnaissance d’images ou de vidéos, le traitement du langage neuronal, etc.

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.

Une architecture convnet typique peut être résumée dans l’image ci-dessous. Tout d’abord, une image est poussée vers le réseau ; c'est ce qu'on appelle l'image d'entrée. Ensuite, l’image d’entrée passe par un nombre infini d’étapes ; c'est la partie convolutive du réseau. Enfin, le réseau neuronal peut prédire le chiffre sur l’image.

Une image est composée d'un tableau de pixels avec une hauteur et une largeur. Une image en niveaux de gris n'a qu'un seul canal tandis qu'une image couleur a trois canaux (chacun pour le rouge, le vert et le bleu). Un canal est empilé les uns sur les autres. Dans ce didacticiel, vous utiliserez une image en niveaux de gris avec un seul canal. Chaque pixel a une valeur de 0 à 255 pour refléter l'intensité de la couleur. Par exemple, un pixel égal à 0 affichera une couleur blanche tandis qu'un pixel d'une valeur proche de 255 sera plus sombre.

Jetons un coup d'œil à une image stockée dans le Jeu de données MNIST. L'image ci-dessous montre comment représenter l'image de gauche dans un format matriciel. Notez que la matrice d'origine a été standardisée pour être comprise entre 0 et 1. Pour les couleurs plus 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

Le composant le plus critique du modèle est la couche convolutive. Cette partie vise à réduire la taille de l'image pour accélérer les calculs des poids et améliorer sa 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 extraire uniquement les pixels les plus pertinents. Cette opération mathématique est appelée convolution. Cette technique permet au réseau d'apprendre des fonctionnalités de plus en plus complexes à chaque couche. La convolution divise la matrice en petits morceaux pour apprendre les éléments les plus essentiels de chaque morceau.

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

Il y a quatre composants d'un Convnets

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'extraire localement les caractéristiques de l'objet sur l'image. Cela signifie que le réseau apprendra des modèles spécifiques dans l’image et sera capable de les reconnaître partout dans l’image.

La convolution est une multiplication par éléments. Le concept est facile à comprendre. L'ordinateur numérisera une partie de l'image, généralement d'une dimension de 3 × 3, et la multipliera en un filtre. Le résultat de la multiplication élément par élément est appelé une carte de caractéristiques. Cette étape est répétée jusqu'à ce que toute l'image soit numérisée. Notez qu'après la convolution, la taille de l'image est réduite.

Ci-dessous, vous trouverez une URL pour voir en action comment fonctionne la convolution.

De nombreuses chaînes sont disponibles. Ci-dessous, nous avons répertorié certaines des chaînes. Vous pouvez voir que chaque filtre a un objectif spécifique. Notez, dans l'image ci-dessous ; le Kernel est synonyme de filtre.

Arithmétique derrière la convolution

La phase convolutive appliquera le filtre sur un petit tableau de pixels dans l'image. Le filtre se déplacera le long de l’image d’entrée avec une forme générale de 3×3 ou 5×5. Cela signifie que le réseau fera glisser ces fenêtres sur toute l'image d'entrée et calculera la convolution. L'image ci-dessous montre comment fonctionne la convolution. La taille du patch est de 3 × 3 et la matrice de sortie est le résultat de l'opération élément par élément entre la matrice d'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 a une carte de fonctionnalités 5 × 5 et un filtre 3 × 3. Il n'y a qu'une seule fenêtre au centre où le filtre peut filtrer une grille 3×3. La carte des caractéristiques de sortie sera réduite de deux tuiles avec une dimension 3×3.

Pour obtenir la même dimension de sortie que la dimension d'entrée, vous devez ajouter un remplissage. Le remplissage consiste à ajouter le bon nombre de lignes et de colonnes de chaque côté de la matrice. Cela permettra à la convolution de s'adapter au centre de chaque tuile d'entrée. Dans l'image ci-dessous, la matrice d'entrée/sortie a 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 :

1. Profondeur: Il définit le nombre de filtres à appliquer lors de la convolution. Dans l’exemple précédent, vous avez vu une profondeur de 1, ce qui signifie qu’un seul filtre est utilisé. Dans la plupart des cas, il existe plusieurs filtres. L'image ci-dessous montre les opérations effectuées dans une situation avec trois filtres

2. Foulée: Il définit le nombre de « sauts de pixels » entre deux tranches. Si la foulée est égale à 1, les fenêtres se déplaceront avec un étalement d'un pixel. Si la foulée est égale à deux, les fenêtres sauteront de 2 pixels. Si vous augmentez la foulée, vous obtiendrez des cartes de caractéristiques plus petites.

Exemple de foulée 1

foulée 2

3. Rembourrage zéro: Un remplissage est une opération consistant à ajouter un nombre correspondant de lignes et de colonnes de chaque côté des cartes d'entités en entrée. Dans ce cas, la sortie a la même dimension que l’entrée.

Non linéarité (ReLU)

A la fin de l'opération de convolution, la sortie est soumise à une fonction d'activation pour permettre la non-linéarité. La fonction d'activation habituelle pour convnet est le Relu. Tous les pixels ayant une valeur négative seront remplacés par zéro.

Pooling Operaproduction

Cette étape est facile à comprendre. Le but de la mise en commun est de réduire la dimensionnalité de l'image d'entrée. Les étapes sont effectuées pour réduire la complexité informatique de l'opération. En diminuant la dimensionnalité, le réseau a des poids à calculer inférieurs, ce qui évite le surajustement.

Dans cette étape, vous devez définir la taille et la foulée. Une manière standard de regrouper l’image d’entrée consiste à utiliser la valeur maximale de la carte des caractéristiques. Regardez l'image ci-dessous. Le « pooling » filtrera quatre sous-matrices de la carte de fonctionnalités 4×4 et renverra la valeur maximale. Le pooling prend la valeur maximale d'un tableau 2×2 puis déplace cette fenêtre de deux pixels. Par exemple, la première sous-matrice est [3,1,3,2], le pooling renverra le maximum, qui est 3.

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

Cette opération réduit de manière agressive la taille de la carte des fonctionnalités

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:

Le réseau neuronal convolutif TensorFlow compile différentes couches avant de faire 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 convolutives appliquent différents filtres sur une sous-région de l'image. La fonction d'activation Relu ajoute de la non-linéarité et les couches de pooling réduisent la dimensionnalité des cartes de fonctionnalités.

Toutes ces couches extraient des informations essentielles des images. Enfin, la carte des caractéristiques est transmise à une couche principale entièrement connectée avec une fonction softmax pour faire une prédiction.

Entraîner CNN avec TensorFlow

Maintenant que vous êtes familier avec les éléments constitutifs d'un convnet, vous êtes prêt à en créer un avec 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 :

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

Étape 2 : Couche d'entrée

Étape 3 : Couche convolutive

Étape 4 : Pooling couche

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

Étape 6 : Couche dense

Étape 7 : Couche Logit

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

L'ensemble de données MNIST est disponible avec scikit pour en savoir plus URL. Veuillez le télécharger et le stocker dans Téléchargements. Vous pouvez le télécharger avec fetch_mldata('MNIST original').

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 la fonctionnalité avec MinMaxScaler comme indiqué dans la classification d'images ci-dessous à l'aide de l'exemple 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 CNN utilise des filtres sur le pixel brut d'une image pour apprendre le modèle de détails par rapport au modèle global avec un réseau neuronal traditionnel. Pour construire un CNN, vous devez définir :

1. Une couche convolutive : appliquez un nombre n de filtres à la carte des caractéristiques. Après la convolution, vous devez utiliser une fonction d'activation Relu pour ajouter de la non-linéarité au réseau.
2. PoolinCouche g : l'étape suivante après la convolution consiste à sous-échantillonner le maximum de caractéristiques. L'objectif est de réduire la dimensionnalité de la carte des caractéristiques pour éviter le surajustement et améliorer la vitesse de calcul. Le regroupement maximal est la technique conventionnelle, qui divise les cartes des caractéristiques en sous-régions (généralement avec une taille de 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 convolutive : applique 14 filtres 5 × 5 (extraction de sous-régions 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 définirez une fonction pour construire le CNN. Voyons en détail comment construire chaque élément de base avant de tout regrouper 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 a une hauteur, une largeur et un canal. L'ensemble de données MNIST est une image monochronique de taille 28 × 28. Nous définissons la taille du lot sur -1 dans l'argument de forme afin qu'il prenne la forme des fonctionnalités ["x"]. L’avantage est de pouvoir ajuster les hyperparamètres de taille de lot. Si la taille du lot est définie sur 7, alors le tenseur fournira 5,488 28 valeurs (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 convolutive comporte 14 filtres avec une taille de noyau de 5 × 5 avec le même remplissage. Le même remplissage signifie que le tenseur de sortie et le tenseur d'entrée doivent avoir la même hauteur et la même largeur. Tensorflow ajoutera des zéros aux lignes et aux colonnes pour garantir la même taille.

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

Étape 4 : Pooling couche

La prochaine étape après la convolution est le calcul de pooling. Le calcul de pooling réduira la dimensionnalité des données. Vous pouvez utiliser le module max_pooling2d avec une taille de 2×2 et une foulée de 2. Vous utilisez la couche précédente comme entrée. La taille de 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 deuxième couche convolutive comporte 32 filtres, avec une taille de sortie de [batch_size, 14, 14, 32]. La couche de pooling a la même taille qu'avant et la forme de sortie est [batch_size, 14, 14, 18].

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 des caractéristiques doit être aplatie avant d'être connectée à la couche dense. Vous pouvez utiliser le module remodeler avec une taille de 7*7*36.

La couche dense reliera 1764 neurones. Vous ajoutez une fonction d'activation Relu. De plus, vous ajoutez un terme de régularisation d'abandon avec un taux de 0.3, ce qui signifie que 30 pour cent des poids seront mis à 0. Notez que l'abandon n'a lieu que pendant la phase d'entraînement. La fonction cnn_model_fn a un mode argument pour déclarer si le modèle doit être entraîné ou évalué comme indiqué dans l'exemple TensorFlow de classification d'images CNN 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 sortie est égale à la taille du lot et à 10, le nombre total d'images.

# 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. Le module tf.argmax() renvoie la valeur la plus élevée si les couches logit. 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 la prédiction du dictionnaire lorsque le mode est défini sur prédiction. Vous ajoutez ces codes 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 perte du modèle. Dans le dernier didacticiel, 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 TensorFlow CNN consiste à optimiser le modèle, c'est-à-dire à trouver les meilleures valeurs des poids. Pour cela, vous utilisez un optimiseur de descente de gradient avec un taux d'apprentissage de 0.001. L’objectif est de minimiser les pertes

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

Vous en avez fini avec CNN. Cependant, vous souhaitez afficher les mesures de performances pendant le mode d'évaluation. Les mesures de performances pour un modèle multiclasse sont les mesures de précision. Tensorflow est équipé d'un module de précision avec 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)

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")

Un CNN prend plusieurs fois à s'entraîner, par conséquent, vous créez un hook Logging 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. Vous définissez une taille de lot de 100 et mélangez les données. Notez que nous fixons des étapes de formation à 16.000 , cela peut prendre beaucoup de temps pour s'entraîner. Sois 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)

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, vous obtenez une précision de 97 %. Vous pouvez modifier l'architecture, la taille du lot et le nombre d'itérations pour améliorer la précision. Le réseau neuronal CNN a bien mieux fonctionné que l’ANN ou la régression logistique. Dans le tutoriel sur les réseaux de neurones artificiels, vous aviez une précision de 96 %, ce qui est inférieur à celui de CNN. Les performances de CNN sont impressionnantes avec une image plus grande set, tant en termes de vitesse de calcul que de précision.

Résumé

Un réseau de neurones convolutifs fonctionne très bien pour évaluer l’image. Ce type d'architecture est dominant pour reconnaître des objets à partir d'une image ou d'une vidéo.

Pour créer un CNN TensorFlow, vous devez suivre sept étapes :

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

L'ensemble de données MNIST est disponible avec scikit pour apprendre. Veuillez le télécharger et le stocker dans Téléchargements. Vous pouvez le télécharger avec fetch_mldata('MNIST original').

Étape 2: Couche d'entrée :

Cette étape remodèle les données. La forme est égale à la racine carrée du nombre de pixels. Par exemple, si une image comporte 156 pixels, alors la forme est de 26×26. Vous devez préciser si l'image est colorée ou non. Si oui, alors vous en aviez 3 pour la forme - 3 pour RVB -, sinon 1.

input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Étape 3: Couche convolutive

Ensuite, vous devez créer les couches convolutives. Vous appliquez différents filtres pour permettre au réseau d'apprendre les fonctionnalités importantes. Vous spécifiez la taille du noyau et le nombre de filtres.

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

Étape 4: Pooling couche

Dans la troisième étape, vous ajoutez une couche de pooling. Cette couche diminue la taille de l'entrée. Pour ce faire, il prend la valeur maximale de la sous-matrice a. Par exemple, si la sous-matrice est [3,1,3,2], le pooling renverra le maximum, qui est 3.

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

Étape 5: Ajouter une couche convolutive et Pooling Couche

Dans cette étape, vous pouvez ajouter autant de couches de conversion et de couches de pooling que vous le souhaitez. Google utilise une architecture avec plus de 20 couches de conversion.

Étape 6: Couche dense

L'étape 6 aplatit la précédente pour créer des calques entièrement connectés. Dans cette étape, vous pouvez utiliser différentes fonctions d'activation et ajouter un effet d'abandon.

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

La dernière étape est la prédiction.

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