Предисловие

Всем привет!

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

Со всеми корректными замечаниями по поводу кода жду в комментариях.

Решаемая задача

Решаемая задача звучит примерно следующим образом: На вход подается картинка размером 7х7, необходимо определить, что на ней нарисовано - круг, квадрат или треугольник.

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

Теоретическая составляющая

Для начала определимся с основными условными обозначениями.

- выход нейрона i слоя k
- количество нейронов в слое с номером k - 1
- ожидаемое значение выхода i сети
- номер последнего слоя сети
- вес нейрона в соответствующей связи, k - номер слоя, i - номер нейрона, j - номер входа из предыдущего слоя

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

Каждое значение нейрона на выходном слое соответствует вероятности того, что на картинке нарисована соответствующая фигура. Поскольку возможных фигур у нас 3, то выходных нейронов будет тоже 3. На входе же у нас картинки размером 7 на 7, поэтому входов будет 49, соответствующих каждому пикселю изображения соответственно.

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

Считаются значения нейронов по следующей формуле:

Объясняю эту формулу - мы берем все нейроны на предыдущем уровне и умножаем их на соответствующие веса, которые выходят из нейронов на прошлом уровне и доходят до нашего нейрона. Затем мы полученную сумму загоняем в функцию активации, это нужно для того, чтобы значения нейронов не превышали 1. В нашем случае, в качестве функции активации будем использовать сигмоиду:

Итак, мы подсчитали, значения выходных нейронов, пройдя по всем слоям, но выходы, естественно, не совпали с нашими ожиданиями касаемо значений вероятности. Что же делать? Подстраивать веса таким образом, чтобы когда в следующий раз мы прогоним то же изображение, сеть дала немного более точный результат.

Для подстройки весов используем следующую формулу:

Альфа - коэффициент обучения, чем ближе фактические значения к ожидаемым, тем меньше нужно делать альфа.

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

Для выходного слоя формула:

Для всех остальных слоев формула основывается на значениях предыдущего слоя:

В общем, тут алгоритм подсчета дельт примерно такой же, как для подсчёта нейронов, только с другими формулами и в обратную сторону.

Практическая составляющая

Наконец-то перейдем к написанию кода!

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

class NeuralNet
{
public:
    void set_input(vector<vector<double>> input); // Передаем в сеть картинку
    void set_expected(vector<double> input); // Передаем в сеть ожидаемые значения выхода
    void train(void); // Запуск итерации обучения
    size_t apply(void); // Запуск подсчёта сети без обучения (для валидации результатов)

private:
    double activation(double x); // Функция активации
    void count_neural_net(void); // Подсчёт значений нейронов
    void clear_neural_net(void); // Обнуление значений нейронов
    void recal_alpha(void); // Обновляем коэф обучения в зависимости от ошибки
    void adj_weight(void); // Подстройка весов
    size_t output_size; // Количество выходных нейронов = 3
    size_t input_size; // Размер стороны входной картинки = 7
    size_t neuron_size; // Количество нейронов в промежуточных слоях
    size_t layer_count; // Количество промежуточных слоёв
    double alpha; // Коэффициент обучения
    vector<double> expected; // Для хранения ожидаемых значений
    vector<vector<double>> layers; // Слои нейронов
    vector<vector<double>> delta; // Значения дельта для соответствующих слоёв
    vector<vector<vector<double>>> weight; // Веса сети
};

Начнем с простого и будем двигаться к более сложному, напишем функции для обучения и валидации:

void NeuralNet::train(void)
{
    clear_neural_net(); // Обнуляем веса
    count_neural_net(); // Счиатем веса
    recal_alpha(); // В зависимости от результатов подстраиваем коэф обучение
    if (err() > MAX_ERR) // Если ошибка достаточно большая, то подстраиваем веса
        adj_weight();
}

size_t NeuralNet::apply(void)
{
    clear_neural_net();
    count_neural_net();
    // То же, что и в обучении, только без подстройки весов 
    // и возвращаем номер наиболее вероятной фигуры
    return distance(layers[layer_count + 1].begin(), 
      max_element(
        layers[layer_count + 1].begin(), 
        layers[layer_count + 1].end()));
}

Разберем пересчёт коэффициента обучения:

void NeuralNet::recal_alpha(void)
{
    double e = err(); // получаем ошибку
    double rel_e = 2 * abs(e) / output_size; // Получаем среднее значение ошибки
    // Подстраиваем коэф обучения под диапазон возможных значений alpha
    alpha = rel_e * (MAX_ALPHA - MIN_ALPHA) + MIN_ALPHA; 
}

Далее посмотрим на подсчёт значений нейронов:

void NeuralNet::count_neural_net(void)
{
    // Перебираем по очереди все слои
    for (size_t layer = 0; layer <= layer_count; layer++)
    {
        // В каждом слое перебираем все нейроны
        for (size_t neuron = 0; neuron < weight[layer].size(); neuron++)
        {
            // Для каждого нейрона перебираем все нейроны предыдущего уровня
            for (size_t input = 0; input < weight[layer][neuron].size(); input++)
            {
                // Сначала считаем сумму произведений нейронов прошлого уровня на их веса
                layers[layer + 1][neuron] += layers[layer][input] * weight[layer][neuron][input];
            }
            // А теперь применяем к сумме функцию активации
            layers[layer + 1][neuron] = activation(layers[layer + 1][neuron]);
        }
    }
}

Ну и самое сложное - подстройка весов:

void NeuralNet::adj_weight(void)
{
    // Сначала рассчитываем все дельты для выходного слоя, чтобы было от чего отталкиваться
    for (size_t exp = 0; exp < output_size; exp++)
    {
        double t = expected[exp], y = layers[layer_count + 1][exp];
        delta[layer_count][exp] = y * (1 - y) * (t - y);
    }
    // Теперь перебираем остальные слои (кроме входного) и считаем дельту для них
    for (int layer = layer_count - 1; layer >= 0; layer--)
    {
        // Перебираем все нейроны в слое
        for (size_t input = 0; input < layers[layer + 1].size(); input++)
        {
            double next_sum = 0;
            // Для каждого нейрона перебираем все дельты на следующем уровне
            for (size_t next_neuron = 0; next_neuron < layers[layer + 2].size(); next_neuron++)
            {
                // Суммируем все взвешенные значения дельт на следующем уровне
                next_sum += delta[layer + 1][next_neuron] * weight[layer + 1][next_neuron][input];
            }
            // Домножаем на коэффициент y * (1 - y)
            delta[layer][input] = layers[layer + 1][input] * (1 - layers[layer + 1][input]) * next_sum;
        }
    }
    // Наконец можно подсчитать все новые веса
    for (size_t layer = 0; layer < layer_count + 1; layer++)
    {
        for (size_t output = 0; output < weight[layer].size(); output++)
        {
            for (size_t input = 0; input < weight[layer][output].size(); input++)
            {
                // Домножаем дельты на коэф обучения и значение самого нейрона
                weight[layer][output][input] += alpha * delta[layer][output] * layers[layer][input];
            }
        }
    }
}

Заключение

Не так страшна задача, когда декомпозируешь её на более мелкие задачи.

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

Далее приведу ссылку на исходный код, в котором количество нейронов в сети, количество слоёв и количество эпох являются параметризуемыми величинами, для того, чтобы вы смогли подобрать наиболее эффективные их значения. У меня получилось так, что наиболее эффективным оказалась сеть всего с одним скрытым слоем из 14 нейронов.

Если кому-то помог разобраться в теме, лайки и подписки приветствуются!

Исходный код