TensorFlow - konwolucyjne sieci neuronowe

Po zrozumieniu koncepcji uczenia maszynowego możemy teraz skupić się na koncepcjach uczenia głębokiego. Głębokie uczenie się jest działem uczenia maszynowego i jest uważane za kluczowy krok podjęty przez naukowców w ostatnich dziesięcioleciach. Przykłady implementacji uczenia głębokiego obejmują aplikacje takie jak rozpoznawanie obrazu i rozpoznawanie mowy.

Poniżej przedstawiono dwa ważne typy głębokich sieci neuronowych -

Konwolucyjne sieci neuronowe
Powtarzające się sieci neuronowe

W tym rozdziale skupimy się na CNN, konwolucyjnych sieciach neuronowych.

Konwolucyjne sieci neuronowe

Konwolucyjne sieci neuronowe są przeznaczone do przetwarzania danych przez wiele warstw macierzy. Ten typ sieci neuronowych jest używany w aplikacjach takich jak rozpoznawanie obrazu lub rozpoznawanie twarzy. Podstawowa różnica między CNN a jakąkolwiek inną zwykłą siecią neuronową polega na tym, że CNN przyjmuje dane wejściowe jako dwuwymiarowa tablica i działa bezpośrednio na obrazach, zamiast skupiać się na ekstrakcji cech, na której koncentrują się inne sieci neuronowe.

Dominujące podejście CNN obejmuje rozwiązania problemów rozpoznawania. Czołowe firmy, takie jak Google i Facebook, zainwestowały w badania i rozwój w celu uzyskania rozpoznawalności, aby szybciej wykonywać działania.

Konwolucyjna sieć neuronowa wykorzystuje trzy podstawowe idee -

Lokalne odpowiednie pola
Convolution
Pooling

Rozumiemy szczegółowo te pomysły.

CNN wykorzystuje korelacje przestrzenne, które istnieją w danych wejściowych. Każda współbieżna warstwa sieci neuronowej łączy niektóre neurony wejściowe. Ten konkretny region nazywany jest lokalnym polem receptywnym. Lokalne pole receptywne skupia się na ukrytych neuronach. Ukryte neurony przetwarzają dane wejściowe wewnątrz wspomnianego pola, nie zdając sobie sprawy ze zmian poza określonymi granicami.

Poniżej znajduje się diagram przedstawiający generowanie lokalnych odpowiednich pól -

Jeśli obserwujemy powyższą reprezentację, każde połączenie uczy się wagi ukrytego neuronu z powiązanym połączeniem z ruchem z jednej warstwy do drugiej. Tutaj poszczególne neurony od czasu do czasu dokonują przesunięcia. Ten proces nazywa się „konwolucją”.

Mapowanie połączeń z warstwy wejściowej do mapy obiektów ukrytych jest definiowane jako „współdzielone wagi”, a uwzględnione odchylenie jest nazywane „współdzielonym odchyleniem”.

CNN lub konwolucyjne sieci neuronowe używają warstw puli, które są warstwami umieszczonymi bezpośrednio po deklaracji CNN. Pobiera dane wejściowe od użytkownika jako mapę cech, która wychodzi z sieci konwolucyjnych i przygotowuje skondensowaną mapę cech. Łączenie warstw pomaga w tworzeniu warstw z neuronami z poprzednich warstw.

Implementacja CNN TensorFlow

W tej sekcji dowiemy się o implementacji CNN przez TensorFlow. Kroki, które wymagają wykonania i odpowiedniego zwymiarowania całej sieci, przedstawiono poniżej -

Step 1 - Dołącz niezbędne moduły dla TensorFlow i moduły zestawu danych, które są potrzebne do obliczenia modelu CNN.

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

Step 2 - Zadeklaruj funkcję o nazwie run_cnn(), który zawiera różne parametry i zmienne optymalizacyjne z deklaracją symboli zastępczych danych. Te zmienne optymalizacji będą deklarować wzorzec szkoleniowy.

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 - W tym kroku zadeklarujemy symbole zastępcze danych treningowych z parametrami wejściowymi - dla 28 x 28 pikseli = 784. To są spłaszczone dane obrazu, które są pobierane z mnist.train.nextbatch().

Możemy zmienić kształt tensora zgodnie z naszymi wymaganiami. Pierwsza wartość (-1) mówi funkcji, aby dynamicznie kształtować ten wymiar na podstawie ilości przesłanych do niego danych. Dwa środkowe wymiary są ustawione na rozmiar obrazu (tj. 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 - Teraz ważne jest, aby utworzyć kilka warstw konwolucyjnych -

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- Spłaszczmy wyjście gotowe dla w pełni podłączonego stopnia wyjściowego - po dwóch warstwach kroku 2 pooling o wymiarach 28 x 28, do wymiaru 14 x 14 lub minimum 7 x 7 x, y, ale z 64 kanały wyjściowe. Aby stworzyć w pełni związaną z „gęstą” warstwę, nowy kształt musi mieć postać [-1,7 x 7 x 64]. Możemy ustawić wagi i wartości odchylenia dla tej warstwy, a następnie aktywować za pomocą 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 - Kolejna warstwa z określonymi aktywacjami softmax z wymaganym optymalizatorem definiuje ocenę dokładności, która dokonuje konfiguracji inicjalizacji operatora.

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- Powinniśmy ustawić rejestrację zmiennych. To dodaje podsumowanie do przechowywania dokładności danych.

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

Poniżej przedstawiono dane wyjściowe wygenerowane przez powyższy kod -

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.