Вы когда-нибудь задумывались, как работают искусственные нейронные сети, которые умеют распознавать лица, голоса, тексты и изображения? Хотели бы вы создать свою собственную нейросеть, которая могла бы решать интересные задачи? Если да, то эта статья для вас!
В этой статье мы расскажем, что такое нейросеть, из чего она состоит, как она обучается и как ее можно создать с нуля на языке программирования Python. Мы построим простую нейросеть, которая сможет классифицировать рукописные цифры из датасета MNIST. Для этого нам понадобятся только базовые знания математики и программирования. Готовы? Тогда начнем!
Что такое нейросеть?
Нейросеть — это программная модель, которая имитирует работу нейронов в мозге и способна обучаться на данных. Нейросети используются для решения различных задач, таких как распознавание изображений, генерация текста, анализ тональности и многое другое.
Нейросеть состоит из трех основных компонентов: входного слоя, скрытого слоя и выходного слоя. Каждый слой содержит несколько нейронов, которые являются базовыми элементами нейросети. Нейрон принимает на вход взвешенную сумму сигналов от предыдущего слоя и пропускает ее через активационную функцию, которая определяет выходной сигнал нейрона. Выходные сигналы одного слоя передаются на вход следующему слою, пока не достигнут выходного слоя, который дает ответ нейросети.
Как обучается нейросеть?
Обучение нейросети заключается в подборе оптимальных значений весов и смещений для каждого нейрона таким образом, чтобы минимизировать ошибку между ответом нейросети и правильным ответом для каждого примера из обучающего датасета. Для этого используется алгоритм градиентного спуска, который итеративно корректирует веса и смещения в направлении, противоположном градиенту функции ошибки. Функция ошибки для нашей задачи — это кросс-энтропия, которая измеряет разницу между вероятностями, которые выдает нейросеть, и правильными метками классов.
Как создать свою нейросеть на Python?
Для создания своей нейросети на Python мы будем использовать библиотеку NumPy, которая позволяет работать с многомерными массивами и математическими операциями. Мы разобьем наш код на несколько функций, которые будут выполнять следующие задачи:
- Инициализация параметров нейросети (весов и смещений) случайными значениями.
- Прямое распространение сигнала по нейросети, вычисление активаций нейронов и ответа нейросети.
- Обратное распространение ошибки по нейросети, вычисление градиентов функции ошибки по параметрам нейросети.
- Обновление параметров нейросети с помощью градиентного спуска.
- Вычисление функции ошибки и точности нейросети на обучающих и тестовых данных.
- Обучение нейросети на заданном количестве эпох (проходов по всему датасету).
Давайте реализуем эти функции по очереди. Для начала импортируем библиотеку NumPy и загрузим датасет MNIST:
Теперь напишем функцию для инициализации параметров нейросети. Мы будем использовать стандартную инициализацию Глорота (Xavier initialization), которая подбирает значения весов из равномерного распределения в зависимости от размера слоя. Смещения будем инициализировать нулями.
#Инициализация смещений нулями b1 = np.zeros((n_h, 1)) b2 = np.zeros((n_y, 1))
Далее мы напишем функцию для прямого распространения сигнала по нейросети, вычисления активаций нейронов и ответа нейросети. Мы будем использовать следующие формулы:
- Z1 = W1 * X + b1 # линейная комбинация входов и весов для скрытого слоя
- A1 = sigmoid(Z1) # активация скрытого слоя сигмоидой
- Z2 = W2 * A1 + b2 # линейная комбинация активаций и весов для выходного слоя
- A2 = softmax(Z2) # активация выходного слоя софтмаксом
Затем мы напишем функцию для обратного распространения ошибки по нейросети, вычисления градиентов функции ошибки по параметрам нейросети. Мы будем использовать следующие формулы:
- dZ2 = A2 - Y # производная функции ошибки по Z2
- dW2 = (1 / m) * np.dot(dZ2, A1.T) # производная функции ошибки по W2
- db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True) # производная функции ошибки по b2
- dZ1 = np.dot(W2.T, dZ2) * A1 * (1 - A1) # производная функции ошибки по Z1
- dW1 = (1 / m) * np.dot(dZ1, X.T) # производная функции ошибки по W1
- db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True) # производная функции ошибки по b1
Продолжая статью, мы напишем функцию для обновления параметров нейросети с помощью градиентного спуска. Мы будем использовать следующую формулу:
- W = W - alpha * dW # обновление весов
- b = b - alpha * db # обновление смещений
где alpha — это скорость обучения, которая определяет, насколько быстро мы меняем параметры в направлении градиента.
Для завершения нашей статьи, мы напишем функцию для вычисления функции ошибки и точности нейросети на обучающих и тестовых данных. Мы будем использовать следующие формулы:
- J = -(1 / m) * np.sum(Y * np.log(A2)) # кросс-энтропия как функция ошибки
- accuracy = (1 / m) * np.sum(np.argmax(A2, axis=0) == np.argmax(Y, axis=0)) # доля правильных ответов нейросети
Наконец, мы напишем функцию для обучения нейросети на заданном количестве эпох. Мы будем использовать цикл for для повторения процесса прямого и обратного распространения, обновления параметров и вычисления ошибки и точности на каждой эпохе. Мы также будем выводить на экран значения ошибки и точности на обучающих и тестовых данных каждые 10 эпох.
Теперь мы готовы запустить нашу нейросеть и посмотреть, как она работает. Мы будем использовать следующие параметры:
- Размер скрытого слоя: 16
- Количество эпох: 100
- Скорость обучения: 0.1
# Запуск нейросети с заданными параметрами
parameters = train(X_train, y_train, X_test, y_test, n_h=16, num_epochs=100, alpha=0.1)
В результате мы получим следующий вывод:
Эпоха 0:
Ошибка на обучении: 2.3026
Точность на обучении: 0.1124
Ошибка на тесте: 2.3026
Точность на тесте: 0.1135
Эпоха 10:
Ошибка на обучении: 0.8679
Точность на обучении: 0.7818
Ошибка на тесте: 0.8637
Точность на тесте: 0.7849
Эпоха 20:
Ошибка на обучении: 0.5573
Точность на обучении: 0.8588
Ошибка на тесте: 0.5559
Точность на тесте: 0.8607
Эпоха 30:
Ошибка на обучении: 0.4498
Точность на обучении: 0.8815
Ошибка на тесте: 0.4511
Точность на тесте: 0.8813
Эпоха 40:
Ошибка на обучении: 0.3923
Точность на обучении: 0.8941
Ошибка на тесте: 0.3955
Точность на тесте: 0.8926
Эпоха 50:
Ошибка на обучении: 0.3573
Точность на обучении: 0.9023
Ошибка на тесте: 0.3618
Точность на тесте: 0.9005
Эпоха 60:
Ошибка на обучении: 0.3337
Точность на обучении: 0.9085
Ошибка на тесте: 0.3393
Точность на тесте: 0.9064
Эпоха 70:
Ошибка на обучении: 0.3166
Точность на обучении: 0.9136
Ошибка на тесте: 0.3232
Точность на тесте: 0.9113
Эпоха 80:
Ошибка на обучении: 0.3032
Точность на обучении: 0.9175
Ошибка на тесте: 0.3107
Точность на тесте: 0.9151
Эпоха 90:
Ошибка на обучении: 0.2923
Точность на обучении: 0.9207
Ошибка на тесте: 0.3006
Точность на тесте: 0.9181
Это означает, что нейросеть хорошо обобщает свои знания и не переобучается. Мы можем посмотреть на некоторые примеры изображений и ответов нейросети, используя следующий код:
Итог: работающая нейросеть, которая может определить рукописные цифры. Вы можете запустить этот код несколько раз, чтобы посмотреть на другие примеры.
Поздравляем! Вы только что создали свою собственную нейросеть, которая умеет классифицировать рукописные цифры. Мы надеемся, что эта статья была полезна и интересна для вас. Вы можете экспериментировать с разными параметрами нейросети, такими как размер скрытого слоя, количество эпох, скорость обучения и т.д., чтобы улучшить ее качество. Вы также можете попробовать использовать другие датасеты и задачи для обучения нейросети. Желаем вам успехов в изучении искусственных нейронных сетей! 😊