Практическая работа - Первая нейронная сеть

Потренируемся создавать собственную нейронную сеть.

Для работы понадобятся библиотеки: Keras, NumPy.

Подключите класс для создания последовательной модели Sequential.

from tensorflow.keras.models import Sequential

С помощью него создайте экземпляр модели:

model = Sequential()

Это и есть ваша модель!

Сейчас она похожа на пустую коробку. Чтобы она что-то делала, нужно поместить в нее какиенибудь данные!

Объекты

Что помещать? Для начала нужно определиться, сколько информации будет приходить нейросети на вход. Один экземпляр такой информации называется - объект, который всегда состоит из чисел.

Допустим, вы решили, что каждый ваш входной объект состоит из 10 чисел. Настройте сеть на вход из 10 чисел:

from tensorflow.keras.layers import Dense model.add(Dense(32, input_dim=10))

Внутри нейросеть состоит из слоев нейронов, и только что вы создали один из них.

Этот первый слой называется Dense-слоем (линейным или полносвязным слоем). Здесь же вы указали с помощью параметра input_dim, что ваша сеть принимает на вход последовательность из 10 чисел:

Полносвязный слой чаще других используется в нейросетях.

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

Их количество задается самым первым аргументом (в примере выше: 32).

Выход из сети создавать не нужно.

Результат, который выдает последний слой, и есть выход сети.

На данном этапе сеть еще не готова к работе, сначала её нужно скомпилировать (собрать, подготовить к обучению) и обучить.

Для подготовки к обучению вам понадобятся еще две вещи – оптимизатор и функция потерь (или функция ошибки). Они задаются с помощью метода модели .compile() :

model.compile(loss='categorical_crossentropy', optimizer='adam')

При обучении нейронной сети обязательно указывают оптимизатор и функцию ошибки.

Распознавание рукописных цифр MNIST

Создание собственной нейронной сети и её обучение на распознавание рукописных цифр, изображенных на картинках.

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

Подготовка данных

Для проекта необходимы модули:     mnist – для загрузки набора данных рукописных цифр, который будет использоваться при обучении нейронной сети;

Sequential – для создания последовательной модели нейронной сети;

Dense – линейный (полносвязный) слой. Из таких слоев будет создана нейросеть; utils – полезные инструменты для подготовки данных; plt – для рисования графиков.

from tensorflow.keras.datasets import mnist     # Библиотека с базой рукописных цифр from tensorflow.keras.models import Sequential  # Подключение класса создания модели Sequential from tensorflow.keras.layers import Dense       # Подключение класса Dense - полносвязный слой from tensorflow.keras import utils              # Утилиты для подготовки данных import numpy as np                              # Работа с массивами import matplotlib.pyplot as plt                 # Отрисовка изображений

Чтобы чему-то научить вашу нейронную сеть, понадобится набор данных для задачи, которую вы собираетесь решать. У вас это набор картинок, на которых изображены рукописные цифры от 0 до 9.

Код ниже скачает эти данные:

x_train_org, y_train_org – изображения для обучения нейронной сети; x_test_org, y_test_org – изображения для тестирования нейронной сети.

# Загрузка из облака данных Mnist

(x_train_org, y_train_org), (x_test_org, y_test_org) = mnist.load_data()

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

# !!! Это наглядный пример. Данный код писать не Поэтому форма массива данных выглядит так: нужно !!! # Вывод формы данных для обучения x_train_org.shape

(60000, 28, 28)

Убедитесь, что ваши данные действительно представляют собой картинки с числами.

Для этого выберите из массива x_train_org какую-нибудь матрицу чисел и отобразите ее в серой шкале:

# Номер картинки (попробуй указать другие значения) n = 143 # Отрисовка картинки plt.imshow(x_train_org[n], cmap='gray') # Вывод n-й картинки plt.show()

Если же вы взглянете на массив y_train_org, который содержит в себе метки для картинок (то есть правильные значения распознаваемых цифр на картинках), то увидите, что этой картинке соответствует значение 2:

# Вывод метки класса для n-го изображения print(y_train_org[n])

2

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

Для обучения нейронной сети вам необходимо преобразовать изображение в более простой вид – в одномерную последовательность чисел (вектор).

Сделайте это с помощью метода .reshape() :

# Изменение формы входных картинок с 28х28 на 784

# первая ось остается без изменения, остальные складываются в вектор x_train = x_train_org.reshape(x_train_org.shape[0], -1)    x_test = x_test_org.reshape(x_test_org.shape[0], -1)    # Проверка результата print(f'Форма обучающих данных: {x_train_org.shape} -> {x_train.shape}') print(f'Форма  тестовых данных: {x_test_org.shape} -> {x_test.shape}')

Форма обучающих данных: (60000, 28, 28) -> (60000, 784)

Форма  тестовых данных: (10000, 28, 28) -> (10000, 784)

Теперь каждая картинка представлена в вашем наборе данных последовательностью из 784 чисел (28x28).

Чтобы нейронной сети было легче учиться, необходимо привести входные данные к некоему стандартному виду. В нашем случае числа, которые описывают картинку (те самые 784 числа), должны находиться в диапазоне от 0 до 1, хотя сейчас они в диапазоне от 0 до 255, ведь они описывают интенсивность каждого пиксела. Поделив все эти значения на 255, вы нормализуете входные данные:

# Нормализация входных картинок

# Преобразование x_train в тип float32 (числа с плавающей точкой) и нормализация x_train = x_train.astype('float32') / 255.

# Преобразование x_test в тип float32 (числа с плавающей точкой) и нормализация x_test = x_test.astype('float32') / 255.

Также нужно провести некоторые преобразования и с метками классов, то есть с теми числами, которые отвечают на вопрос «Что же изображено на картинке?».

Для этого нужно привести все метки к виду one hot encoding.

Это значит, что каждое число будет представлять собой последовательность (вектор) значений 0 или 1. Последовательность будет длиной 10, потому что всего существует 10 цифр, которые вы будете распознавать (от 0 до 9). В векторе one hot encoding везде стоят нули, кроме позиции самой метки.

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

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

CLASS_COUNT = 10

Преобразуйте выходные данные в векторы one hot encoding с помощью функции to_categorical() модуля utils:

# Преобразование ответов в формат one_hot_encoding y_train = utils.to_categorical(y_train_org, CLASS_COUNT) y_test = utils.to_categorical(y_test_org, CLASS_COUNT)

Теперь выходные данные для вашей нейронной сети выглядят следующим образом:

# Вывод формы y_train

# 60 тысяч примеров, каждый длины 10 по числу классов print(y_train.shape)

(60000, 10)

# Вывод примера одного выходного вектора print(y_train[0]) 

[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]

Для сравнения - в оригинальных выходных данных все метки классов - просто одиночные числа:

# Вывод формы массива меток print(y_train_org.shape)

(60000,)

# Вывод метки, соответствующей 36-му элементу print(y_train_org[36])

6

Создание нейронной сети

Теперь самое интересное. Буквально за несколько строчек кода вы создадите свою собственную нейронную сеть, а потом научите ее распознавать цифры!

Для начала создайте объект нейронной сети с помощью класса Sequential:

Сейчас это пустая нейронная сеть, не содержащая в себе никаких слоев и нейронов. Добавьте в нее несколько слоев нейронов, идущих друг за другом, последовательно, по образцу:

В данном случае 400 – это количество нейронов в слое, а 'relu' – функция активации, которая будет

применяться после умножения значений входов нейрона на его веса. # Создание последовательной модели model = Sequential() # Добавление полносвязного слоя на 800 нейронов с relu-активацией model.add(Dense(800, input_dim=784, activation='relu'))  # Добавление полносвязного слоя на 400 нейронов с relu-активацией model.add(Dense(400, activation='relu'))  # Добавление полносвязного слоя с количеством нейронов по числу классов с softmax-активацией model.add(Dense(CLASS_COUNT, activation='softmax'))

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

Строкой кода ниже вы скомпилируете модель.

В методе .compile() вы назначаете функцию ошибки ('categorical_crossentropy'), оптимизатор нейронной сети ('adam') и метрики, которые будут подсчитываться в процессе обучения нейросети

(['accuracy']).

Метод .summary() выведет на экран структуру вашей нейронной сети в виде таблицы:

# Компиляция модели model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # Вывод структуры модели print(model.summary())

Функция plot_model() модуля utils нарисует наглядную схему (граф) нейронной сети, она удобна для понимания и более сложных моделей.

Эта функция принимает следующие аргументы:

model - модель, схему которой вы хотите построить (обязательный параметр);

to_ le - имя файла или путь к файлу, в который сохраняется схема (обязательный параметр); show_shapes - Показывать или нет формы входных/выходных данных каждого слоя

(необязательный параметр, по умолчанию False);

   show_layer_names - показывать или нет название каждого слоя (необязательный параметр, по умолчанию True).

utils.plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=False)

Здесь вы впервые сталкиваетесь с сохранением данных.

Сейчас сохранение произойдет автоматически и файл появится в той папке, где находится файл с кодом.

Обучение нейронной сети

Сайчас самое интересное!

Одной строчкой кода вы запустите обучение нейронной сети и сможете наблюдать за процессом.

Для этого вызовите метод модели .fit() и передайте ему данные для обучения - x_train, y_train.

batch_size – размер батча, который указывает нейросети на то, сколько картинок она будет обрабатывать за один раз.

epochs – количество циклов обучения, то есть сколько раз нейронная сеть повторит просмотр и обучение на всех ваших данных.

model.fit(x_train, y_train, batch_size=128, epochs=15, verbose=1)

# x_train - обучающая выборка, входные данные

# y_train - обучающая выборка, выходные данные

# batch_size - кол-во примеров, которое обрабатывает нейронка перед одним изменением весов

# epochs - количество эпох, когда нейронка обучается на всех примерах выборки

# verbose - 0 - не визуализировать ход обучения, 1 - визуализировать

Запустив код, вы увидете процесс обучения нейронной сети на 15 эпохах. После каждого цикла обучения вы можете видеть среднее значение ошибки. Обратите внимание, что практически каждую эпоху значение метрики точности (accuracy) увеличивается. Это означает, что ваша нейронная сеть с каждым разом делает все более точное распознавание!

Теперь сохраните веса вашей модели, чтобы потом можно было снова их использовать:

model.save_weights('model.h5') model.load_weights('model.h5')

Метод .save_weights() сохранит веса вашей модели в файл 'model.h5', а метод .load_weights() загрузит их обратно.

Распознавание рукописных цифр

Ура! Вы научили нейронную сеть распознавать цифры на картинках с огромной точностью – более 99%.

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

# Номер тестовой цифры, которую будем распознавать n_rec = 389 # Отображение картинки из тестового набора под номером n_rec plt.imshow(x_test_org[n_rec], cmap='gray') plt.show()

Теперь сохраните в переменную x эту картинку в виде набора из 784 чисел.

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

# Выбор нужной картинки из тестовой выборки x = x_test[n_rec] # Проверка формы данных print(x.shape)

(784,)

# Добавление одной оси в начале, чтобы нейронка могла распознать пример # Массив из одного примера, так как нейронка принимает именно массивы примеров (батчи) для распознава x = np.expand_dims(x, axis=0) # Проверка формы данных print(x.shape)

(1, 784)

Чтобы ваша сеть сделала предсказание, нужно вызвать метод .predict() и передать в него данные для распознавания:

# Распознавание примера prediction = model.predict(x) 

Ответом вашей нейронной сети будет такой массив чисел:

# Вывод результата - вектор из 10 чисел print(prediction)

[[7.3494338e-15 3.5296533e-12 3.9147574e-12 2.3130077e-15 1.7387430e-06

  5.3687417e-15 3.5024766e-21 9.1579379e-05 9.1114504e-15 9.9990666e-01]]

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

print(sum(prediction[0]))

1.000000000015285

Таким образом, индекс самой большой вероятности в этом списке чисел и будет ответом вашей нейронной сети:

# Получение и вывод индекса самого большого элемента (это значение цифры, которую распознала сеть) pred = np.argmax(prediction) print(pred)

9

Как видите, ваша сеть находит правильный ответ для картинки с изображением цифры 9.

# Вывод правильного ответа для сравнения print(y_test_org[n_rec])

9

Если все сделано, а занятие не закончилось, то вот задачка:

(но сначала не забудь поиграться с другими цифрами, если это еще не сделано :))

Задана модель нейронной сети следующей структуры:

input_dim = 3 - размерность входных данных

Dense(3) - первый полносвязный слой с тремя нейронами Dense(1) - второй полносвязный слой с одним нейроном.

Создайте модель заданной структуры, для этого:

импортируйте библиотеку для создания модели импортируйте библиотеку для создания необходимых слоев создайте модель полносвязной сети добавьте заданные слои в модель.

Выведите структуру модели с помощью функции .summary() .

Выведите веса модели с помощью функции .get_weights() .