13) ConvNet TensorFlow

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

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

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

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

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

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

Шаг 7: Logit Layer

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, то тензор подаст 5488 значений (28 * 28 * 7).

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

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

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

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

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

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)

Наконец, вы можете определить последний слой с предсказанием модели. Форма вывода равна размеру пакета и 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)

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

Резюме

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

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

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

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

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

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

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

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

Шаг 3: объединение слоя

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

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

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

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

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

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

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)

Шаг 6: Logit Layer

Последний шаг — это прогноз.

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