TensorFlow - Reti neurali convoluzionali

Dopo aver compreso i concetti di apprendimento automatico, ora possiamo spostare la nostra attenzione sui concetti di apprendimento profondo. Il deep learning è una divisione del machine learning ed è considerato un passo cruciale compiuto dai ricercatori negli ultimi decenni. Gli esempi di implementazione del deep learning includono applicazioni come il riconoscimento di immagini e il riconoscimento vocale.

Di seguito sono riportati i due importanti tipi di reti neurali profonde:

Reti neurali convoluzionali
Reti neurali ricorrenti

In questo capitolo, ci concentreremo sulla CNN, Convolutional Neural Networks.

Reti neurali convoluzionali

Le reti neurali convoluzionali sono progettate per elaborare i dati attraverso più livelli di array. Questo tipo di reti neurali viene utilizzato in applicazioni come il riconoscimento delle immagini o il riconoscimento facciale. La differenza principale tra la CNN e qualsiasi altra rete neurale ordinaria è che la CNN prende l'input come un array bidimensionale e opera direttamente sulle immagini piuttosto che concentrarsi sull'estrazione di caratteristiche su cui si concentrano altre reti neurali.

L'approccio dominante della CNN include soluzioni per problemi di riconoscimento. Le migliori aziende come Google e Facebook hanno investito in ricerca e sviluppo verso progetti di riconoscimento per svolgere le attività con maggiore velocità.

Una rete neurale convoluzionale utilizza tre idee di base:

Campi rispettivi locali
Convolution
Pooling

Cerchiamo di capire queste idee in dettaglio.

La CNN utilizza le correlazioni spaziali che esistono all'interno dei dati di input. Ogni strato simultaneo di una rete neurale collega alcuni neuroni di input. Questa regione specifica è chiamata campo ricettivo locale. Il campo ricettivo locale si concentra sui neuroni nascosti. I neuroni nascosti elaborano i dati di input all'interno del campo menzionato non realizzando i cambiamenti al di fuori del confine specifico.

Di seguito è riportato un diagramma che rappresenta la generazione dei rispettivi campi locali:

Se osserviamo la rappresentazione di cui sopra, ogni connessione apprende un peso del neurone nascosto con una connessione associata con il movimento da uno strato all'altro. Qui, i singoli neuroni eseguono un cambiamento di volta in volta. Questo processo è chiamato "convoluzione".

La mappatura delle connessioni dal livello di input alla mappa delle caratteristiche nascoste è definita come "pesi condivisi" e il bias incluso è chiamato "bias condiviso".

CNN o reti neurali convoluzionali utilizzano livelli di pooling, che sono i livelli, posizionati immediatamente dopo la dichiarazione della CNN. Prende l'input dell'utente come una mappa delle caratteristiche che esce dalle reti convoluzionali e prepara una mappa delle caratteristiche condensata. Il raggruppamento dei livelli aiuta a creare livelli con i neuroni dei livelli precedenti.

TensorFlow Implementazione della CNN

In questa sezione apprenderemo l'implementazione di TensorFlow della CNN. I passaggi, che richiedono l'esecuzione e la corretta dimensione dell'intera rete, sono i seguenti:

Step 1 - Includere i moduli necessari per TensorFlow e i moduli del set di dati, necessari per calcolare il modello CNN.

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

Step 2 - Dichiarare una funzione chiamata run_cnn(), che include vari parametri e variabili di ottimizzazione con dichiarazione di segnaposto dati. Queste variabili di ottimizzazione dichiareranno il modello di addestramento.

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 - In questo passaggio, dichiareremo i segnaposto dei dati di addestramento con i parametri di input - per 28 x 28 pixel = 784. Questi sono i dati dell'immagine appiattita che vengono estratti mnist.train.nextbatch().

Possiamo rimodellare il tensore secondo le nostre esigenze. Il primo valore (-1) indica alla funzione di modellare dinamicamente quella dimensione in base alla quantità di dati trasmessi. Le due dimensioni intermedie sono impostate sulla dimensione dell'immagine (cioè 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 - Ora è importante creare alcuni strati convoluzionali -

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- Appiattiamo l'uscita pronta per lo stadio di uscita completamente connesso - dopo due strati di raggruppamento della falcata 2 con le dimensioni di 28 x 28, alla dimensione di 14 x 14 o minimo 7 x 7 x, coordinate y, ma con 64 canali di uscita. Per creare il livello completamente connesso con "denso", la nuova forma deve essere [-1, 7 x 7 x 64]. Possiamo impostare alcuni pesi e valori di bias per questo livello, quindi attivarli con 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 - Un altro livello con specifiche attivazioni softmax con l'ottimizzatore richiesto definisce la valutazione dell'accuratezza, che rende operatore di configurazione di inizializzazione.

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- Dovremmo impostare le variabili di registrazione. Questo aggiunge un riepilogo per memorizzare l'accuratezza dei dati.

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

Di seguito è riportato l'output generato dal codice sopra -

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.