Простейшая нейросеть на C: создание многослойного перцептрона с нуля

Введение: зачем писать нейросеть на C

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

Кроме того, реализация с нуля позволяет глубоко понять механизмы работы нейронных сетей: прямое распространение сигнала, обратное распространение ошибки, функции активации и обновление весов. Без сторонних библиотек код легко портировать на другие платформы и языки, включая микроконтроллеры.

Архитектура многослойного перцептрона

Многослойный перцептрон (MLP) — это базовая архитектура нейросети, состоящая из входного слоя, одного или нескольких скрытых слоёв и выходного слоя. Каждый нейрон соединён со всеми нейронами предыдущего слоя (полносвязная структура).

В простейшей реализации на C количество слоёв и нейронов задаётся вручную. Например, для задачи распознавания рукописных цифр можно использовать конфигурацию: 100 нейронов на входе, 20 в первом скрытом слое, 6 во втором, 3 в третьем и 2 на выходе. Такая гибкость позволяет адаптировать сеть под конкретную задачу без перекомпиляции, если считывать параметры из файла.

Ключевой элемент — структура nnLay, которая хранит матрицу весов, скрытые значения и ошибки для каждого слоя. Матрица весов имеет размер (in+1) x out, где дополнительная строка отведена под смещение (bias).

Инициализация весов и функция активации

Перед обучением веса инициализируются случайными значениями. В коде используется формула: randWeight = (rand() / RAND_MAX - 0.5) * pow(out, -0.5). Это нормализует разброс весов в зависимости от количества выходов слоя, предотвращая слишком большие или слишком малые начальные значения.

В качестве функции активации применяется сигмоида: sigmoida(val) = 1 / (1 + exp(-val)). Она преобразует взвешенную сумму входов в диапазон от 0 до 1. Производная сигмоиды, используемая при обратном распространении, вычисляется как val * (1 - val).

Если количество слоёв превышает три, рекомендуется уменьшить степень в формуле инициализации (например, pow(out, -0.2)), чтобы сигнал не затухал при прямом проходе через глубокую сеть.

Прямое распространение сигнала (feed forward)

Прямое распространение — это процесс вычисления выходных значений сети для заданного входного вектора. Для каждого слоя выполняется:

1. Вычисление взвешенной суммы: tmpS = sum(inputs[i] * matrix[i][hid]) + matrix[in][hid] (последнее слагаемое — смещение).
2. Применение функции активации: hidden[hid] = sigmoida(tmpS).

Результат одного слоя становится входом для следующего. В коде это реализовано в методе makeHidden() структуры nnLay. После прохода через все слои выход последнего слоя даёт предсказание сети.

Для отладки можно вывести значения выходов до обучения — они будут случайными и не будут соответствовать целевым меткам.

Обратное распространение ошибки (backpropagation)

Обратное распространение — ключевой алгоритм обучения нейросети. Он состоит из двух этапов:

1. Вычисление ошибки на выходном слое: errors[ou] = (target[ou] - hidden[ou]) * sigmoidDerivate(hidden[ou]).
2. Распространение ошибки на скрытые слои: для каждого нейрона скрытого слоя ошибка вычисляется как взвешенная сумма ошибок следующего слоя, умноженная на производную активации.

В коде это реализовано методами calcOutError() и calcHidError(). После вычисления ошибок для всех слоёв выполняется обновление весов с заданной скоростью обучения (learnRate). Обновление происходит по правилу: matrix[hid][ou] += learnRate * errors[ou] * enteredVal[hid].

Цикл обучения и настройка гиперпараметров

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

Гиперпараметры, которые можно настраивать:

• Скорость обучения (learnRate): обычно от 0.01 до 0.1. Слишком высокая скорость может привести к расходимости, слишком низкая — к медленной сходимости.
• Количество слоёв и нейронов: влияет на способность сети запоминать сложные зависимости.
• Количество эпох: число полных проходов по обучающему набору.

В тесте с набором MNIST удалось достичь точности 0.9795 при learnRate = 0.03 и нескольких эпохах.

Тестирование сети и оценка результатов

После обучения необходимо проверить, как сеть работает на новых данных. В примере после обучения выполняется опрос сети для тех же входных векторов. Если до обучения выходы были близки к 0.5 (неопределённость), то после обучения они должны чётко разделиться: для одного вектора — (0.01, 0.99), для другого — (0.99, 0.01).

Для более серьёзных задач (например, классификация изображений) точность оценивается на отдельном тестовом наборе, который не участвовал в обучении. Это позволяет выявить переобучение — ситуацию, когда сеть запоминает обучающие примеры, но не обобщает новые.

Практические ограничения и пути улучшения

Простая реализация на C имеет ряд ограничений:

• Отсутствие регуляризации: нет механизмов для борьбы с переобучением (L1/L2, dropout).
• Фиксированная скорость обучения: не используется адаптивная настройка (Adam, RMSprop).
• Только сигмоида: другие функции активации (ReLU, tanh) могут дать лучшие результаты.
• Последовательное выполнение: нет распараллеливания вычислений.

Для улучшения можно добавить:

• Чтение конфигурации сети из файла.
• Пакетное обучение (mini-batch).
• Сохранение и загрузку обученных весов.
• Использование библиотек (OpenNN, FANN) для более сложных архитектур.

Пример кода: структура и основные функции

Основные компоненты реализации:

• Структура nnLay: хранит матрицу весов, скрытые значения и ошибки. Методы: setIO() — инициализация слоя, makeHidden() — прямое распространение, updMatrix() — обновление весов.
• Класс myNeuro: управляет списком слоёв, реализует feedForwarding(), backPropagate(), train() и query().
• Функция main(): создаёт сеть, генерирует случайные входные данные и цели, обучает и выводит результаты.

Код написан в QtCreator, но легко адаптируется для любой среды C/C++ заменой qDebug() на std::cout.

Заключение: от простого к сложному

Реализация простейшей нейросети на C — отличный способ понять основы машинного обучения. Даже без использования готовых библиотек можно создать работающий многослойный перцептрон, способный решать задачи классификации. Код легко портируется на другие языки и платформы, что делает его полезным для встраиваемых систем и образовательных проектов.

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

Вопросы и ответы