TensorFlow - Réseaux de neurones convolutifs

Après avoir compris les concepts d'apprentissage automatique, nous pouvons maintenant nous concentrer sur les concepts d'apprentissage profond. L'apprentissage en profondeur est une division de l'apprentissage automatique et est considéré comme une étape cruciale prise par les chercheurs au cours des dernières décennies. Les exemples de mise en œuvre de l'apprentissage en profondeur incluent des applications telles que la reconnaissance d'image et la reconnaissance vocale.

Voici les deux types importants de réseaux de neurones profonds -

Réseaux de neurones convolutifs
Réseaux de neurones récurrents

Dans ce chapitre, nous nous concentrerons sur le CNN, les réseaux de neurones convolutifs.

Réseaux de neurones convolutifs

Les réseaux neuronaux convolutifs sont conçus pour traiter les données à travers plusieurs couches de tableaux. Ce type de réseaux neuronaux est utilisé dans des applications telles que la reconnaissance d'image ou la reconnaissance faciale. La principale différence entre CNN et tout autre réseau de neurones ordinaire est que CNN prend les entrées sous forme de tableau bidimensionnel et opère directement sur les images plutôt que de se concentrer sur l'extraction de caractéristiques sur laquelle se concentrent d'autres réseaux de neurones.

L'approche dominante de CNN inclut des solutions aux problèmes de reconnaissance. Des entreprises de premier plan comme Google et Facebook ont investi dans la recherche et le développement pour des projets de reconnaissance afin d'accélérer les activités.

Un réseau de neurones convolutifs utilise trois idées de base -

Champs respectifs locaux
Convolution
Pooling

Comprenons ces idées en détail.

CNN utilise des corrélations spatiales qui existent dans les données d'entrée. Chaque couche simultanée d'un réseau neuronal connecte certains neurones d'entrée. Cette région spécifique est appelée champ réceptif local. Le champ réceptif local se concentre sur les neurones cachés. Les neurones cachés traitent les données d'entrée à l'intérieur du champ mentionné sans réaliser les changements en dehors de la limite spécifique.

Voici une représentation schématique de la génération de champs respectifs locaux -

Si nous observons la représentation ci-dessus, chaque connexion apprend un poids du neurone caché avec une connexion associée avec le mouvement d'une couche à l'autre. Ici, les neurones individuels effectuent un changement de temps en temps. Ce processus est appelé «convolution».

Le mappage des connexions de la couche d'entrée à la carte d'entités cachées est défini comme des «pondérations partagées» et le biais inclus est appelé «biais partagé».

CNN ou réseaux de neurones convolutifs utilisent des couches de regroupement, qui sont les couches, positionnées immédiatement après la déclaration CNN. Il prend les entrées de l'utilisateur comme une carte des caractéristiques qui sort des réseaux convolutifs et prépare une carte des caractéristiques condensée. La mise en commun des couches aide à créer des couches avec des neurones des couches précédentes.

Implémentation TensorFlow de CNN

Dans cette section, nous découvrirons l'implémentation TensorFlow de CNN. Les étapes, qui nécessitent l'exécution et la dimension appropriée de l'ensemble du réseau, sont indiquées ci-dessous -

Step 1 - Incluez les modules nécessaires pour TensorFlow et les modules de jeu de données, nécessaires pour calculer le modèle CNN.

import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

Step 2 - Déclarez une fonction appelée run_cnn(), qui comprend divers paramètres et variables d'optimisation avec déclaration d'espaces réservés de données. Ces variables d'optimisation déclareront le modèle d'apprentissage.

def run_cnn():
   mnist = input_data.read_data_sets("MNIST_data/", one_hot = True)
   learning_rate = 0.0001
   epochs = 10
   batch_size = 50

Step 3 - Dans cette étape, nous déclarerons les espaces réservés des données d'entraînement avec les paramètres d'entrée - pour 28 x 28 pixels = 784. Il s'agit des données d'image aplatie qui sont tirées de mnist.train.nextbatch().

Nous pouvons remodeler le tenseur selon nos besoins. La première valeur (-1) indique à la fonction de façonner dynamiquement cette dimension en fonction de la quantité de données qui lui est transmise. Les deux dimensions moyennes sont réglées sur la taille de l'image (c'est-à-dire 28 x 28).

x = tf.placeholder(tf.float32, [None, 784])
x_shaped = tf.reshape(x, [-1, 28, 28, 1])
y = tf.placeholder(tf.float32, [None, 10])

Step 4 - Maintenant, il est important de créer des couches convolutives -

layer1 = create_new_conv_layer(x_shaped, 1, 32, [5, 5], [2, 2], name = 'layer1')
layer2 = create_new_conv_layer(layer1, 32, 64, [5, 5], [2, 2], name = 'layer2')

Step 5- Aplatissons la sortie prête pour l'étage de sortie entièrement connecté - après deux couches de mise en commun stride 2 avec les dimensions de 28 x 28, à la dimension de 14 x 14 ou minimum 7 x 7 x, coordonnées y, mais avec 64 canaux de sortie. Pour créer le calque entièrement connecté avec "dense", la nouvelle forme doit être [-1, 7 x 7 x 64]. Nous pouvons définir des poids et des valeurs de biais pour cette couche, puis l'activer avec ReLU.

flattened = tf.reshape(layer2, [-1, 7 * 7 * 64])

wd1 = tf.Variable(tf.truncated_normal([7 * 7 * 64, 1000], stddev = 0.03), name = 'wd1')
bd1 = tf.Variable(tf.truncated_normal([1000], stddev = 0.01), name = 'bd1')

dense_layer1 = tf.matmul(flattened, wd1) + bd1
dense_layer1 = tf.nn.relu(dense_layer1)

Step 6 - Une autre couche avec des activations softmax spécifiques avec l'optimiseur requis définit l'évaluation de la précision, ce qui rend la configuration de l'opérateur d'initialisation.

wd2 = tf.Variable(tf.truncated_normal([1000, 10], stddev = 0.03), name = 'wd2')
bd2 = tf.Variable(tf.truncated_normal([10], stddev = 0.01), name = 'bd2')

dense_layer2 = tf.matmul(dense_layer1, wd2) + bd2
y_ = tf.nn.softmax(dense_layer2)

cross_entropy = tf.reduce_mean(
   tf.nn.softmax_cross_entropy_with_logits(logits = dense_layer2, labels = y))

optimiser = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

init_op = tf.global_variables_initializer()

Step 7- Nous devons mettre en place des variables d'enregistrement. Cela ajoute un résumé pour stocker l'exactitude des données.

tf.summary.scalar('accuracy', accuracy)
   merged = tf.summary.merge_all()
   writer = tf.summary.FileWriter('E:\TensorFlowProject')
   
   with tf.Session() as sess:
      sess.run(init_op)
      total_batch = int(len(mnist.train.labels) / batch_size)
      
      for epoch in range(epochs):
         avg_cost = 0
      for i in range(total_batch):
         batch_x, batch_y = mnist.train.next_batch(batch_size = batch_size)
            _, c = sess.run([optimiser, cross_entropy], feed_dict = {
            x:batch_x, y: batch_y})
            avg_cost += c / total_batch
         test_acc = sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
            summary = sess.run(merged, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
         writer.add_summary(summary, epoch)

   print("\nTraining complete!")
   writer.add_graph(sess.graph)
   print(sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
      mnist.test.labels}))

def create_new_conv_layer(
   input_data, num_input_channels, num_filters,filter_shape, pool_shape, name):

   conv_filt_shape = [
      filter_shape[0], filter_shape[1], num_input_channels, num_filters]

   weights = tf.Variable(
      tf.truncated_normal(conv_filt_shape, stddev = 0.03), name = name+'_W')
   bias = tf.Variable(tf.truncated_normal([num_filters]), name = name+'_b')

#Out layer defines the output
   out_layer =
      tf.nn.conv2d(input_data, weights, [1, 1, 1, 1], padding = 'SAME')

   out_layer += bias
   out_layer = tf.nn.relu(out_layer)
   ksize = [1, pool_shape[0], pool_shape[1], 1]
   strides = [1, 2, 2, 1]
   out_layer = tf.nn.max_pool(
      out_layer, ksize = ksize, strides = strides, padding = 'SAME')

   return out_layer

if __name__ == "__main__":
run_cnn()

Voici la sortie générée par le code ci-dessus -

See @{tf.nn.softmax_cross_entropy_with_logits_v2}.

2018-09-19 17:22:58.802268: I
T:\src\github\tensorflow\tensorflow\core\platform\cpu_feature_guard.cc:140]
Your CPU supports instructions that this TensorFlow binary was not compiled to
use: AVX2

2018-09-19 17:25:41.522845: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

2018-09-19 17:25:44.630941: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 501760000 exceeds 10% of system memory.

Epoch: 1 cost = 0.676 test accuracy: 0.940

2018-09-19 17:26:51.987554: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.