TensorFlow - сверточные нейронные сети

Поняв концепции машинного обучения, теперь мы можем переключить наше внимание на концепции глубокого обучения. Глубокое обучение - это раздел машинного обучения, который считается важным шагом, предпринятым исследователями в последние десятилетия. Примеры реализации глубокого обучения включают такие приложения, как распознавание изображений и распознавание речи.

Ниже приведены два важных типа глубоких нейронных сетей.

Сверточные нейронные сети
Рекуррентные нейронные сети

В этой главе мы сосредоточимся на CNN, сверточных нейронных сетях.

Сверточные нейронные сети

Сверточные нейронные сети предназначены для обработки данных через несколько уровней массивов. Этот тип нейронных сетей используется в таких приложениях, как распознавание изображений или лиц. Основное различие между CNN и любой другой обычной нейронной сетью состоит в том, что CNN принимает входные данные как двумерный массив и работает непосредственно с изображениями, а не фокусируется на извлечении признаков, на котором сосредоточены другие нейронные сети.

Доминирующий подход CNN включает решения проблем распознавания. Ведущие компании, такие как Google и Facebook, вложили средства в исследования и разработки, направленные на реализацию проектов признания, чтобы выполнять действия с большей скоростью.

Сверточная нейронная сеть использует три основных идеи:

Местные соответствующие поля
Convolution
Pooling

Давайте разберемся с этими идеями подробно.

CNN использует пространственные корреляции, существующие во входных данных. Каждый параллельный слой нейронной сети соединяет несколько входных нейронов. Эта специфическая область называется локальным рецептивным полем. Локальное рецептивное поле сосредоточено на скрытых нейронах. Скрытые нейроны обрабатывают входные данные внутри указанного поля, не осознавая изменений за пределами определенной границы.

Ниже представлена диаграмма создания локальных соответствующих полей.

Если мы рассмотрим приведенное выше представление, каждое соединение узнает вес скрытого нейрона с соответствующей связью с перемещением из одного слоя в другой. Здесь отдельные нейроны время от времени совершают сдвиги. Этот процесс называется «сверткой».

Сопоставление подключений входного слоя к карте скрытых функций определяется как «общие веса», а включенное смещение называется «общим смещением».

CNN или сверточные нейронные сети используют уровни объединения, которые представляют собой слои, расположенные сразу после объявления CNN. Он принимает вводимые пользователем данные в виде карты характеристик, которая поступает из сверточных сетей, и подготавливает сжатую карту характеристик. Объединение слоев помогает создавать слои с нейронами предыдущих слоев.

Реализация CNN в TensorFlow

В этом разделе мы узнаем о реализации CNN TensorFlow. Шаги, которые требуют выполнения и правильного измерения всей сети, показаны ниже:

Step 1 - Включите необходимые модули для TensorFlow и модули набора данных, которые необходимы для вычисления модели CNN.

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

Step 2 - Объявить функцию с именем run_cnn(), который включает различные параметры и переменные оптимизации с объявлением заполнителей данных. Эти переменные оптимизации объявят шаблон обучения.

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 - На этом этапе мы объявим заполнители обучающих данных с входными параметрами - для 28 x 28 пикселей = 784. Это данные сглаженного изображения, которые извлекаются из mnist.train.nextbatch().

Мы можем изменить тензор в соответствии с нашими требованиями. Первое значение (-1) указывает функции динамически формировать это измерение в зависимости от количества переданных в нее данных. Два средних размера соответствуют размеру изображения (например, 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 - Теперь важно создать несколько сверточных слоев -

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- Давайте сгладим выход, готовый для полностью подключенного выходного каскада - после двух слоев объединения шага 2 с размерами 28 x 28 до размера 14 x 14 или минимум 7 x 7 x, координаты y, но с 64 выходные каналы. Чтобы создать полностью связанный с «плотным» слоем, новая форма должна быть [-1, 7 x 7 x 64]. Мы можем установить некоторые значения веса и смещения для этого слоя, а затем активировать их с помощью 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 - Другой слой с конкретными активациями softmax с требуемым оптимизатором определяет оценку точности, которая производит настройку оператора инициализации.

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- Мы должны настроить записи переменных. Это добавляет сводку для сохранения точности данных.

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

Ниже приведен вывод, сгенерированный приведенным выше кодом -

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.