TensorFlow туториал. Часть 4: глубокое обучение

Теперь, когда вы изучили и подготовили свои данные, пришло время создать архитектуру нейронной сети с помощью пакета TensorFlow!

Предыдущие статьи:

Моделирование нейронной сети

Пришло время построить нейронную сеть, слой за слоем.

Если вы еще этого не сделали, импортируйте tensorflow в рабочую область под названием tf. Затем инициализируйте Graph с помощью функции Graph(). Используйте эту функцию для определения вычислений. Обратите внимание, что с помощью Graph вы ничего не вычисляете, поскольку она не принимает на вход никаких переменных. Graph лишь определяет операции, которые вы хотите выполнить позже.

C помощью as_default() установите контекст по умолчанию. as_default() возвращает менеджер контекста, который устанавливает заданный вами Graph графом по умолчанию. Используйте этот метод, если хотите создать несколько графов в одном процессе: с помощью этой функции создается глобальный граф по умолчанию, в который будут добавляться все операции, если вы целенаправленно не создадите еще один.

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

Во-первых, вы задаете плейсхолдеры для входных данных и меток, потому что пока что не задаете «настоящие» данные. Помните, что плейсхолдеры — это неинициализированные переменные, которые будут инициализированы сессией при ее запуске. Когда вы, наконец, запустите сессию, эти плейсхолдеры получат значения датасета, которые вы передадите в функцию run()!
Затем вы создаете сеть. Сначала нужно выполнить сглаживание входных данных с помощью функции ыхflatten(), которая создаст массив размерности [None, 784] вместо массива размерности [None, 28, 28], который является исходным массивом ваших изображений в оттенках серого.
После того, как вы произвели сглаживание данных, нужно создать полностью подключенный слой, который генерирует логиты размера [None, 62]. Логиты — это функции, работающие с немасштабированным выходным результатом предыдущих слоев и использующие относительную шкалу для проверки линейности единиц измерения.
После построения многослойного персептрона вы можете определить функцию потерь. Выбор функции потерь зависит от задачи, которую вы решаете. В нашем случае используйте эту:

sparse_softmax_cross_entropy_with_logits()

Эта функция вычисляет разреженную кросс-энтропию softmax между логитами и метками. Другими словами, она измеряет вероятность ошибки в дискретных задачах классификации, в которых классы являются взаимоисключающими. Это означает, что каждый элемент данных принадлежит только одному классу. В нашем случае, например, дорожный знак содержит только одну метку. Помните, хотя регрессия используется для предсказания непрерывных значений, классификация используется для предсказания дискретных значений или классов элементов данных. Вы выполняете свертку этой функции с reduce_mean(), которая вычисляет среднее значение элементов вдоль измерений тензора.
Также вам нужно установить оптимизатор обучения. Одни из наиболее популярных алгоритмов оптимизации — Stochastic Gradient Descent (SGD), ADAM и RMSprop. В зависимости от выбранного вами алгоритма необходимо настроить параметры, например, скорость обучения. В этом случае вы выбираете оптимизатор ADAM, для которого скорость обучения выбирается равной 0,001.
Наконец, вы инициализируете операции, выполняемые перед началом обучения.

# Импорт `tensorflow` 

import tensorflow as tf

# Инициализация плейсхолдеров 

x = tf.placeholder(dtype = tf.float32, shape = [None, 28, 28])

y = tf.placeholder(dtype = tf.int32, shape = [None])

# Сглаживание входных данных

images_flat = tf.contrib.layers.flatten(x)

# Полностью подключенный слой 

logits = tf.contrib.layers.fully_connected(images_flat, 62, tf.nn.relu)

# Определение функции потерь

losstf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels = y, logits = logits))

# Определение оптимизатора 

train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)

# Конвертация логитов в индексы меток

correct_pred = tf.argmax(logits, 1)

# Определение метрики точности

accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

Вы только что успешно создали свою первую нейронную сеть с помощью TensorFlow!

Если хотите, также можно вывести значения (большинства) переменных, чтобы получить краткую сводку того, что вы только что запрограммировали:

print("images_flat: ", images_flat)

print("logits: ", logits)

print("loss: ", loss)

print("predicted_labels: ", correct_pred)

Совет. Если вы видите ошибку module ‘pandas’ has no attribute ‘computation’, обновите пакеты dask, запустив команду pip install —upgrade dask в командной строке.

Запуск нейронной сети

Теперь, когда вы собрали модель cети слой за слоем, пришло время запустить ее! Для этого сначала инициализируйте сессию с помощью Session(), которой вы передаете граф graph, определенный в предыдущем разделе. Затем вы можете запустить сессию с помощью run(), которой вы передаете инициализированные операции в форме переменной init, которую вы также определили в предыдущем разделе.

Затем можно использовать эту инициализированную сессию для запуска тренировочных циклов. В этом случае вы выбираете 201, потому что хотите зарегистрировать последнее значение loss_value. В цикле нужно запустить сессию с оптимизатором обучения и метрикой потерь (или точностью), которую вы определили в предыдущем разделе. Также нужно передать аргумент функции feed_dict, с помощью которой вы подаете данные в модель. Через каждые 10 циклов вы получаете лог, который даст вам больше информации о потерях.

Как было показано в разделе об основах TensorFlow, нет необходимости закрывать сессию вручную; это уже сделано для вас. Хотите опробовать другую конфигурацию? Вам, вероятно, понадобится сделать это с помощью sess.close(), если вы определили свою сессию как sess, как в блоке ниже:

tf.set_random_seed(1234)

sess = tf.Session()

sess.run(tf.global_variables_initializer())

for i in range(201):

print('EPOCH', i)

_, accuracy_val = sess.run([train_op, accuracy], feed_dict={x: images28, y: labels})

if i % 10 == 0:

print("Loss: ", loss)

print('DONE WITH EPOCH')

Также можете запустить следующий блок, но помните, что он сразу же закроет сессию, как было показано во первой части этого туториала:

tf.set_random_seed(1234)

with tf.Session() as sess:

sess.run(tf.global_variables_initializer())

for i in range(201):

_, loss_value = sess.run([train_op, loss], feed_dict={x: images28, y: labels})

if i % 10 == 0:

print("Loss: ", loss)

Обратите внимание, что используется функция global_variables_initializer(), потому что функция initialize_all_variables() устарела.

Вы успешно обучили свою модель! Это было не слишком сложно, не так ли?

Оценка вашей нейронной сети

Мы еще не закончили: осталось оценить нейронную сеть. Получите представление о работе своей модели, выбрав 10 случайных изображений и сравнив предсказанные метки с реальными.

Давайте воспользуемся matplotlib и выведем дорожные знаки для визуального сравнения:

# Импорт `matplotlib`

import matplotlib.pyplot as plt

import random

# Выбор 10 случайных изображений

sample_indexes = random.sample(range(len(images28)), 10)

sample_images = [images28[i] for i in sample_indexes]

sample_labels = [labels[i] for i in sample_indexes]

# Запуск операции "correct_pred"

predicted = sess.run([correct_pred], feed_dict={x: sample_images})[0]

# Вывод истинных и предсказанных меток

print(sample_labels) print(predicted)

# Вывод предсказанных и истинных изображений

fig = plt.figure(figsize=(10, 10))

for i in range(len(sample_images)):

truth = sample_labels[i]

prediction = predicted[i]

plt.subplot(5, 2,1+i)

plt.axis('off') color='green' if truth == prediction else 'red'

plt.text(40, 10, "Truth: {0}nPrediction: {1}".format(truth, prediction), fontsize=12, color=color)

plt.imshow(sample_images[i], cmap="gray")

plt.show()

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

Обратите внимание, что используется функция load_data(), которая была определена в начале этого руководства.

# Импорт`skimage`

from skimage import transform

# Загрузка данных проверки

test_images, test_labels = load_data(test_data_directory)

# Преобразование изображений в 28 х 28 пикселей

test_images28 = [transform.resize(image, (28, 28)) for image in test_images]

# Конвертация в оттенки серого

from skimage.color import rgb2gray

test_images28 = rgb2gray(np.array(test_images28))

# Вывод предсказаний и полного набора данных проверки

predicted = sess.run([correct_pred], feed_dict={x: test_images28})[0]

# Вычисление совпадений 

match_count = sum([int(y == y_) for y, y_ in zip(test_labels, predicted)])

# Вычисление точности

accuracy = match_count / len(test_labels)

# Вывод точности

print("Accuracy: {:.3f}".format(accuracy))

Не забудьте закрыть сессию помощью sess.close(), если вы не использовали команду with tf.Session() as sess:, чтобы начать сеанс TensorFlow.

Что делать дальше с моделью?

Если вы хотите продолжить работу с этим датасетом и моделью, которую вы построили в этом туториале, попробуйте выполнить следующее:

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

Если знаете английский язык, обязательно ознакомьтесь с книгой Machine Learning With TensorFlow, написанной Nishant Shukla.

Интересные статьи: