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

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

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

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

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

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

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

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

Есть четыре компонента Convnets

1. свертка
2. Нелинейность (ReLU)
3. Объединение или субвыборка
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. Все пиксели с отрицательным значением будут заменены нулем.

Операция объединения

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

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

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

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

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

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

Резюме:

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

• Сверточный слой
• Функция активации Relu
• Объединенный слой
• Плотно связанный слой

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

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

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

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

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

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

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

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

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

Шаг 4: Объединение слоев

Шаг 5: Второй сверточный слой и объединяющий слой

Шаг 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. Слой пула: Следующим шагом после свертки является понижение дискретизации максимального признака. Цель состоит в том, чтобы уменьшить размерность карты объектов, чтобы предотвратить переоснащение и повысить скорость вычислений. Максимальное объединение — это традиционный метод, который делит карты объектов на подрегионы (обычно размером 2 × 2) и сохраняет только максимальные значения.
3. Полностью связанные слои: все нейроны из предыдущих слоев подключены к следующим слоям. CNN классифицирует метку в соответствии с функциями из сверточных слоев и сокращается с помощью слоя объединения.

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

• Сверточный слой: применяет 14 фильтров 5 × 5 (извлечение подобластей 5 × 5 пикселей) с функцией активации ReLU.
• Слой объединения: выполняет максимальное объединение с фильтром 2 × 2 и шагом 2 (что указывает, что объединенные области не перекрываются).
• Сверточный слой: применяет 36 фильтров 5 × 5 с функцией активации ReLU.
• Слой объединения № 2: снова выполняет максимальное объединение с фильтром 2 × 2 и шагом 2.
• 1764 нейрона с коэффициентом регуляризации отсева 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 в аргументе формы, чтобы он принимал форму функций [“x”]. Преимущество состоит в том, чтобы настроить гиперпараметры размера пакета. Если размер пакета установлен на 7, то тензор будет передавать 5488 значений (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: Объединение слоев

Следующим шагом после свертки является вычисление пула. Вычисление объединения уменьшит размерность данных. Вы можете использовать модуль 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: Второй сверточный слой и объединяющий слой

Второй сверточный слой имеет 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: Плотный слой

Затем вам нужно определить полносвязный слой. Карта объектов должна быть сглажена, прежде чем ее можно будет соединить с плотным слоем. Вы можете использовать модуль reshape размером 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() возвращает максимальное значение, если логит-уровни. Функция 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 занимает много времени, поэтому вы создаете крючок Logging для хранения значений слоев 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, обучение может занять много времени. Потерпи.

# 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 впечатляет большим набором изображений , как с точки зрения скорости вычислений, так и точности.

Резюме

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

Чтобы построить TensorFlow CNN, вам нужно выполнить семь шагов:

Шаг 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 : Объединение слоев

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

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

Шаг 5 : Добавьте сверточный слой и объединяющий слой

На этом шаге вы можете добавить столько конверсионных слоев и слоев пула, сколько хотите. 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)

Статья является переводом https://www.guru99.com/