Классификация изображений CNN в TensorFlow с шагами и примерами

Что такое сверточная нейронная сеть?

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

Archiструктура сверточной нейронной сети

Вспомните Facebook: несколько лет назад после того, как вы загрузили изображение в свой профиль, вас попросили вручную добавить имя к лицу на изображении. В настоящее время Facebook использует confnet, чтобы автоматически отмечать вашего друга на фотографии.

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

Типичную архитектуру сети можно резюмировать на рисунке ниже. Прежде всего, изображение передается в сеть; это называется входным изображением. Затем входное изображение проходит бесконечное количество шагов; это сверточная часть сети. Наконец, нейронная сеть может предсказать цифру на изображении.

Изображение состоит из массива пикселей с высотой и шириной. Изображение в оттенках серого имеет только один канал, тогда как цветное изображение имеет три канала (каждый для красного, зеленого и синего). Каналы накладываются друг на друга. В этом уроке вы будете использовать изображение в оттенках серого только с одним каналом. Каждый пиксель имеет значение от 0 до 255, отражающее интенсивность цвета. Например, пиксель, равный 0, будет иметь белый цвет, а пиксель со значением, близким к 255, будет темнее.

Давайте посмотрим на изображение, хранящееся в Набор данных MNIST. На рисунке ниже показано, как представить изображение слева в матричном формате. Обратите внимание, что исходная матрица стандартизирована и находится в диапазоне от 0 до 1. Для более темного цвета значение матрицы составляет около 0.9, а белые пиксели имеют значение 0.

Сверточная операция

Наиболее важным компонентом модели является сверточный слой. Эта часть направлена ​​на уменьшение размера изображения для более быстрого вычисления весов и улучшения его обобщения.

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

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

Компоненты сверточной нейронной сети (ConvNet или CNN)

Существует четыре компонента Convnets.

1. Свертка
2. Нелинейность (ReLU)
3. Poolinг или субвыборка
4. Классификация (полносвязный уровень)

Свертка

Цель свертки — локально извлечь особенности объекта на изображении. Это означает, что сеть изучит определенные закономерности на изображении и сможет распознавать их повсюду на изображении.

Свертка — это поэлементное умножение. Идея проста для понимания. Компьютер сканирует часть изображения, обычно размером 3х3, и умножает ее на фильтр. Результат поэлементного умножения называется картой объектов. Этот шаг повторяется до тех пор, пока не будет отсканировано все изображение. Обратите внимание, что после свертки размер изображения уменьшается.

Ниже приведен URL-адрес, по которому можно увидеть, как работает свертка.

Доступно множество каналов. Ниже мы перечислили некоторые каналы. Вы можете видеть, что каждый фильтр имеет определенную цель. Обратите внимание, на рисунке ниже; Ядро — это синоним фильтра.

Арифметика свертки

На этапе свертки фильтр применяется к небольшому массиву пикселей изображения. Фильтр будет перемещаться по входному изображению общей формы 3×3 или 5×5. Это означает, что сеть проведет эти окна по всему входному изображению и вычислит свертку. На изображении ниже показано, как работает свертка. Размер патча составляет 3×3, а выходная матрица является результатом поэлементной операции между матрицей изображения и фильтром.

Вы заметили, что ширина и высота вывода может отличаться от ширины и высоты ввода. Это происходит из-за пограничного эффекта.

Эффект границы

Изображение имеет карту объектов 5×5 и фильтр 3×3. В центре есть только одно окно, где фильтр может экранировать сетку 3×3. Выходная карта объектов уменьшится на две плитки и станет размером 3×3.

Чтобы получить то же выходное измерение, что и входное, вам нужно добавить отступы. Заполнение состоит из добавления нужного количества строк и столбцов с каждой стороны матрицы. Это позволит свертке центрировать каждую входную плитку. На изображении ниже матрица ввода/вывода имеет одинаковый размер 5×5.

Когда вы определяете сеть, свернутые объекты контролируются тремя параметрами:

1. глубина: определяет количество фильтров, применяемых во время свертки. В предыдущем примере вы видели глубину 1, что означает, что используется только один фильтр. В большинстве случаев имеется более одного фильтра. На рисунке ниже показаны операции, выполняемые в ситуации с тремя фильтрами.

2. шагать: определяет количество «переходов пикселей» между двумя срезами. Если шаг равен 1, окна будут перемещаться с разбросом в один пиксель. Если шаг равен двум, окна подпрыгнут на 2 пикселя. Если вы увеличите шаг, у вас будут карты объектов меньшего размера.

Пример шага 1

шаг 2

3. Заполнение нулями: Заполнение — это операция добавления соответствующего количества строк и столбцов на каждой стороне входных карт объектов. В этом случае выход имеет ту же размерность, что и вход.

Нелинейность (ReLU)

В конце операции свертки к выходным данным применяется функция активации, обеспечивающая нелинейность. Обычная функция активации для convnet — это Relu. Все пиксели с отрицательным значением будут заменены на ноль.

Pooling Operaпроизводство

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

На этом этапе вам необходимо определить размер и шаг. Стандартный способ объединения входного изображения — использовать максимальное значение карты объектов. Посмотрите на картинку ниже. «Объединение» отобразит четыре подматрицы карты объектов 4×4 и вернет максимальное значение. При объединении принимается максимальное значение массива 2×2, а затем перемещается это окно на два пикселя. Например, первая подматрица — [3,1,3,2], объединение вернет максимальное значение, равное 3.

Существует еще одна операция объединения, например среднее значение.

Эта операция агрессивно уменьшает размер карты объектов.

Полностью связанные слои

Последний шаг состоит в построении традиционного искусственная нейронная сеть как вы это делали в предыдущем уроке. Вы соединяете все нейроны предыдущего слоя со следующим слоем. Вы используете функцию активации softmax для классификации числа на входном изображении.

Резюме:

Сверточная нейронная сеть TensorFlow компилирует различные слои перед тем, как сделать прогноз. Нейронная сеть имеет:

• Сверточный слой
• Функция активации Relu
• Poolinг-слой
• Плотно связанный слой

Сверточные слои применяют различные фильтры к определенной части изображения. Функция активации Relu добавляет нелинейность, а слои объединения уменьшают размерность карт объектов.

Все эти слои извлекают важную информацию из изображений. Наконец, карта объектов передается на основной полносвязный слой с функцией softmax для прогнозирования.

Обучайте CNN с помощью TensorFlow

Теперь, когда вы знакомы со строительным блоком сети, вы готовы построить ее с помощью TensorFlow. Мы будем использовать набор данных MNIST для классификации изображений CNN.

Подготовка данных такая же, как и в предыдущем уроке. Вы можете запустить коды и сразу перейти к архитектуре CNN.

Вы выполните следующие шаги для классификации изображений с использованием CNN:

Шаг 1. Загрузите набор данных

Шаг 2: Входной слой

Шаг 3: Сверточный слой

Шаг 4: Poolinг-слой

Шаг 5: Второй сверточный слой и Poolinг Слой

Шаг 6: Плотный слой

Шаг 7: Логит-слой

Шаг 1. Загрузите набор данных

Набор данных MNIST доступен с помощью scikit для изучения по этой ссылке. URL. Загрузите его и сохраните в разделе «Загрузки». Вы можете загрузить его с помощью fetch_mldata('MNIST original').

Создайте набор поездов/тестов

Вам нужно разделить набор данных с помощью train_test_split

Масштабируйте функции

Наконец, вы можете масштабировать эту функцию с помощью MinMaxScaler, как показано в приведенной ниже классификации изображений, используя пример 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:]

Дайте определение CNN

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

1. Сверточный слой: примените n фильтров к карте объектов. После свертки вам необходимо использовать функцию активации Relu, чтобы добавить нелинейность в сеть.
2. Pooling-слой: Следующий шаг после свертки — это понижение максимального значения признака. Цель — уменьшить размерность карты признаков, чтобы предотвратить переобучение и повысить скорость вычислений. Объединение максимумов — это общепринятая техника, которая делит карты признаков на подобласти (обычно размером 2×2) и сохраняет только максимальные значения.
3. Полностью связанные слои: все нейроны предыдущих слоев подключены к следующим слоям. CNN будет классифицировать метку в соответствии с признаками сверточных слоев и уменьшенными с помощью слоя объединения.

Архитектура CNN

• Сверточный слой: применяет 14 фильтров 5×5 (извлечение подобластей 5×5 пикселей) с функцией активации ReLU.
• Pooling Layer: выполняет максимальное объединение с фильтром 2×2 и шагом 2 (что указывает на то, что объединенные регионы не перекрываются)
• Сверточный слой: применяет 36 фильтров 5×5 с функцией активации ReLU.
• Pooling Слой № 2: снова выполняет максимальное объединение с фильтром 2×2 и шагом 2
• 1,764 нейрона с коэффициентом регуляризации отсева 0.4 (вероятность 0.4, что какой-либо элемент будет отброшен во время обучения)
• Плотный слой (логитовый слой): 10 нейронов, по одному на каждый целевой класс цифр (0–9).

Для создания CNN можно использовать три важных модуля:

• конв2д(). Создает двумерный сверточный слой с количеством фильтров, размером ядра фильтра, заполнением и функцией активации в качестве аргументов.
• max_pooling2d(). Создает двумерный слой пула с использованием алгоритма максимального пула.
• плотный(). Создает плотный слой со скрытыми слоями и блоками.

Вы определите функцию для построения CNN. Давайте подробно рассмотрим, как построить каждый стандартный блок, прежде чем объединять все в функцию.

Шаг 2: Входной слой

def cnn_model_fn(features, labels, mode):
    input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Вам нужно определить тензор с формой данных. Для этого вы можете использовать модуль tf.reshape. В этом модуле вам необходимо объявить тензор для изменения формы и форму тензора. Первый аргумент — это характеристики данных, которые определены в аргументе функции.

Изображение имеет высоту, ширину и канал. Набор данных MNIST представляет собой монохронное изображение размером 28×28. Мы устанавливаем размер пакета равным -1 в аргументе shape, чтобы он принимал форму объектов[“x”]. Преимущество заключается в возможности настройки гиперпараметров размера пакета. Если размер пакета установлен на 7, то тензор будет передавать 5,488 значений (28*28*7).

Шаг 3: Сверточный слой

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

Первый сверточный слой имеет 14 фильтров с размером ядра 5×5 с одинаковым заполнением. То же заполнение означает, что выходной и входной тензоры должны иметь одинаковую высоту и ширину. Tensorflow добавит нули к строкам и столбцам, чтобы обеспечить одинаковый размер.

Вы используете функцию активации Relu. Выходной размер будет [28, 28, 14].

Шаг 4: Poolinг-слой

Следующим шагом после свертки является вычисление пула. Объединение вычислений уменьшит размерность данных. Вы можете использовать модуль max_pooling2d размером 2×2 и шагом 2. В качестве входных данных вы используете предыдущий слой. Размер вывода будет [batch_size, 14, 14, 14]

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

Шаг 5: Второй сверточный слой и Poolinг Слой

Второй сверточный слой имеет 32 фильтра с выходным размером [batch_size, 14, 14, 32]. Слой объединения имеет тот же размер, что и раньше, а выходная форма — [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)

Шаг 6: Плотный слой

Затем вам нужно определить полносвязный слой. Карта объектов должна быть сглажена, прежде чем ее можно будет соединить с плотным слоем. Вы можете использовать модуль решейпа размером 7*7*36.

Плотный слой соединит 1764 нейрона. Вы добавляете функцию активации Relu. Кроме того, вы добавляете член регуляризации отсева с коэффициентом 0.3, что означает, что 30 процентов весов будут установлены на 0. Обратите внимание, что отсев происходит только на этапе обучения. Функция cnn_model_fn имеет режим аргумента, позволяющий объявить, нужно ли обучать модель или оценивать, как показано в приведенном ниже примере TensorFlow классификации изображений CNN.

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)

Шаг 7: Логит-слой

Наконец, в примере классификации изображений TensorFlow вы можете определить последний слой с предсказанием модели. Выходная форма равна размеру пакета и 10 — общему количеству изображений.

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

Вы можете создать словарь, содержащий классы и вероятность каждого класса. Модуль tf.argmax() возвращает наибольшее значение для слоев logit. Функция softmax возвращает вероятность каждого класса.

predictions = {				
	# Generate predictions				
    "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 (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

Последним шагом примера TensorFlow CNN является оптимизация модели, то есть поиск наилучших значений весов. Для этого вы используете оптимизатор градиентного спуска со скоростью обучения 0.001. Цель – минимизировать потери

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

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

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)

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

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)

Действия, описанные ниже, аналогичны предыдущим урокам.

Прежде всего, вы определяете оценщик с помощью модели CNN для классификации изображений.

# Create the Estimator
mnist_classifier = tf.estimator.Estimator(
    model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")

Для обучения CNN требуется много раз, поэтому вы создаете ловушку ведения журнала для сохранения значений слоев softmax каждые 50 итераций.

# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

Вы готовы оценить модель. Вы устанавливаете размер пакета 100 и перемешиваете данные. Обратите внимание, что мы установили количество шагов обучения 16.000 XNUMX, обучение может занять много времени. Потерпи.

# 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])

Теперь, когда модель обучена, вы можете оценить ее и распечатать результаты.

# 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}

При нынешней архитектуре вы получаете точность 97%. Вы можете изменить архитектуру, размер пакета и количество итераций, чтобы повысить точность. Нейронная сеть CNN показала себя намного лучше, чем ANN или логистическая регрессия. В уроке по искусственной нейронной сети точность была 96%, что ниже, чем у CNN. Выступления CNN впечатляют более масштабным изображением набор, как с точки зрения скорости вычислений, так и с точки зрения точности.

Итого

Сверточная нейронная сеть очень хорошо работает для оценки изображения. Этот тип архитектуры является доминирующим для распознавания объектов по изображению или видео.

Чтобы создать CNN TensorFlow, вам необходимо выполнить семь шагов:

Шаг 1: Загрузить набор данных:

Набор данных MNIST доступен для изучения с помощью scikit. Загрузите его и сохраните в разделе «Загрузки». Вы можете загрузить его с помощью fetch_mldata('MNIST original').

Шаг 2: Входной слой:

Этот шаг изменяет форму данных. Форма равна квадратному корню из количества пикселей. Например, если изображение имеет 156 пикселей, то форма будет 26×26. Вам необходимо указать, цветная картинка или нет. Если да, то у вас было 3 для формы — 3 для RGB-, иначе 1.

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

Шаг 3: Сверточный слой

Далее вам нужно создать сверточные слои. Вы применяете различные фильтры, чтобы позволить сети изучить важную функцию. Вы указываете размер ядра и количество фильтров.

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

Шаг 4: Poolinг-слой

На третьем этапе вы добавляете слой объединения. Этот слой уменьшает размер ввода. Это делается путем принятия максимального значения подматрицы a. Например, если подматрица равна [3,1,3,2], объединение вернет максимальное значение, равное 3.

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

Шаг 5: добавить сверточный слой и Poolinг Слой

На этом этапе вы можете добавить столько слоев, сколько захотите, и слоев объединения. Google использует архитектуру с более чем 20 уровнями конверсий.

Шаг 6: Плотный слой

Шаг 6 сглаживает предыдущий, чтобы создать полностью связанные слои. На этом этапе вы можете использовать другую функцию активации и добавить эффект выпадения.

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)

Шаг 7: Логит-слой

Последний шаг – предсказание.

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