Алгоритм прямого распространения ошибки

Нейросети кажутся людям чем-то очень сложным и запутанным, однако это вовсе не так. Простую нейросеть можно написать менее чем за час с нуля. В нашей статье мы создадим нейронную сеть прямого распространения (также называемую многослойным перцептроном), используя лишь массивы, циклы и условные операторы, а значит этот код легко можно будет перенести на любой язык программирования, предоставляющий эти возможности. А если язык предоставляет библиотеку для матричных и векторных вычислений (как, например, numpy в языке Python, то написание займёт ещё меньше времени).

Что такое нейросеть?

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

Более простыми словами, это некий чёрный ящик, который превращает входные данные в выходные, или, говоря более математическим языком, является отображением пространства входных признаков X в пространство выходных признаков Y: X → Y. То есть мы хотим найти какую-то функцию F, которая сможет выполнять это преобразование. Для начала этой информации нам будет достаточно. Для более подробного ознакомления рекомендуем ознакомиться с этой статьёй на хабре.

Коротко об искусственном нейроне

Чаще всего в подобных статьях начинают расписывать про устройство биологического нейрона, связь с его искусственной моделью и прочую лирику. Мы же этого делать не будем, а сразу перейдём к сути. Искусственный нейрон — это всего лишь взвешенная сумма значений входного вектора элементов, которая передаётся на нелинейную функцию активации f: z = f(y), где y = w0·x0 + w1·x1 + ... + wm - 1·xm - 1. Здесь w0, ..., wm - 1 — коэффициенты, веса каждого элемента вектора, x0, ..., xm - 1 — значения входного вектора X, y — взвешенная сумма элементов X, а z — результат применения функции активации. Мы вернёмся к функции активации немного позднее, а пока давайте придумаем, как вместо одного выходного значения получить n.

Нейронный слой

Один нейрон способен входной вектор превратить в одну точку, однако по условию мы хотим получить несколько точек, так как выходной вектор Y может иметь произвольную размерность, определяемую лишь конкретной ситуацией (один выход для XOR, 10 выходов для определения принадлежности к одному из 10 классов и т.д.). Как же нам получить n точек, преобразуя элементы входного вектора X? Оказывается, всё довольно просто: для того, чтобы получить n выходных значений, необходимо использовать не один нейрон, а n. Тогда для каждого из элементов выходного вектора Y будет использовано ровно n различных взвешенных сумм от вектора X. То есть мы получаем, что zi = f(yi) = f(wi0·x0 + wi1·x1 + ... + wim - 1·xm - 1)

Если внимательно посмотреть, то оказывается, что написанная выше формула является определением умножения матрицы на вектор. И действительно, если взять матрицу W размера n на m и умножить её на вектор X размерности m, то получится другой вектор размерности n, то есть ровно то, что нам и нужно. Таким образом, получение выходного вектора по входному для n нейронов можно записать в более удобной матричной форме: Y = W·X, где W — матрица весовых коэффициентов, X — входной вектор и Y — выходной вектор. Однако полученный вектор является неактивированным состоянием (промежуточным, невыходным) всех нейронов, а чтобы получить выходное значение,, необходимо каждое неактивированное значение подать на вход функции активации. Результат её применения и будет выходным значением слоя.

Забегая вперёд скажем о том, что нередко используют последовательность нейронных слоёв для более глубокого обучения сети и большей формализации данных. Поэтому для получения итогового выходного вектора необходимо проделать описанную выше операцию несколько раз подряд от одного слоя к другому. Тогда для первого слоя входным вектором будет X, а для всех последующих входом будет являться выход предыдущего слоя. К примеру, сеть с 3 скрытыми слоями может выглядеть так:

Функция активации

Функция активации — это функция, которая добавляет в сеть нелинейность, благодаря чему нейроны могут довольно точно имитировать любую функцию. Наиболее распространёнными функциями активации являются:

• Сигмоида: f(x) = 1 / (1 + e-x)
• Гиперболический тангенс: f(x) = tanh(x)
• ReLU: f(x) = max(x,0)

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

Хватит бла бла, давайте писать код

Теперь нам достаточно знаний, чтобы написать код получения результата нейронной сети. Мы будем писать код на языке C#, однако, уверяем, код будет практически идентичным для других языков программирования. Давайте разберёмся, что нам потребуется для реализации сети прямого распространения:

1. Вектор (входные, выходные);
2. Матрица (каждый слой содержит матрицу весовых коэффициентов);
3. Нейросеть.

1. Вектор:

• Вектор можно создавать из количества элементов (длины);
• Вектор можно создавать из перечисления вещественных чисел;
• Можно получать значения по индексу i.
• Можно изменять значения по индексу i.

Напишем же это:

class Vector {
    public double[] v; // значения вектора
    public int n; // длина вектора

	// конструктор из длины
    public Vector(int n) {
        this.n = n; // копируем длину
        v = new double[n]; // создаём массив
    }

	// создание вектора из вещественных значений
    public Vector(params double[] values) {
        n = values.Length;
        v = new double[n];

        for (int i = 0; i < n; i++)
            v[i] = values[i];
    }

	// обращение по индексу
    public double this[int i] {
        get { return v[i]; } // получение значение
        set { v[i] = value; } // изменение значения
    }
}

2. Матрица:

• Матрицу можно создавать из числа строк, столбцов и генератора случайных чисел для заполнения случайными значениями;
• Можно получать значения по индексам i и j;
• Можно изменять значения по индексам i и j;

Напишем же это:

class Matrix {
    double[][] v; // значения матрицы
    public int n, m; // количество строк и столбцов

	// создание матрицы заданного размера и заполнение случайными числами из интервала (-0.5, 0.5)
    public Matrix(int n, int m, Random random) {
        this.n = n;
        this.m = m;

        v = new double[n][];

        for (int i = 0; i < n; i++) {
            v[i] = new double[m];

            for (int j = 0; j < m; j++)
                v[i][j] = random.NextDouble() - 0.5; // заполняем случайными числами
        }
    }

	// обращение по индексу
    public double this[int i, int j] {
        get { return v[i][j]; } // получение значения
        set { v[i][j] = value; } // изменение значения
    }
}

3. Сама нейросеть:

class Network {
    Matrix[] weights; // матрицы весов слоя

    int layersN; // число слоёв

	// создание сети из массива количества нейронов в каждом слое
    public Network(int[] sizes) {
        Random random = new Random(DateTime.Now.Millisecond); // создаём генератор случайных чисел

        layersN = sizes.Length - 1; // запоминаем число слоёв

        weights = new Matrix[layersN]; // создаём массив матриц

		// для каждого слоя создаём матрицы весовых коэффициентов
        for (int k = 1; k < sizes.Length; k++) {
            weights[k - 1] = new Matrix(sizes[k], sizes[k - 1], random);
        }
    }

	// получение выхода сети (прямое распространение)
    Vector Forward(Vector input) {
    	Vector output; // будущий выходной вектор

        for (int k = 0; k < layersN; k++) {
        	output = new Vector(weights[k].n); // создаём новый выходной вектор для каждого слоя

            for (int i = 0; i < weights[k].n; i++) {
                double y = 0; // неактивированный выход нейрона

                for (int j = 0; j < weights[k].m; j++)
                    y += weights[k][i, j] * input[j];

				// выполняем активацию с помощью сигмоидальной функции
                output[i] = 1 / (1 + Math.Exp(-y));

                // выполняем активацию с помощью гиперболического тангенса
                // output[i] = Math.Tanh(y);

                // выполняем активацию с помощью ReLU
                // output[i] = Math.Max(0, y);
            }
        }

        return output;
    }
}

Сеть есть, но её ответы случайны. Как обучать?

На данный момент мы имеем случайную (необученную) нейронную сеть, которая может по входному вектору input выдать случайный ответ, однако нам требуется ответы, удовлетворяющие конкретной задаче. Чтобы добиться этого нашу сеть необходимо обучить. Для этого нам необходима база тренировочных примеров, то есть множество пар векторов X — Y, на которых будет обучаться сеть. Обучать нейросеть мы будем с помощью алгоритма обратного распространения ошибки. Если кратко, то он работает следующим образом:

• Подать на вход сети обучающий пример (один входной вектор)
• Распространить сигнал по сети вперёд (получить выход сети)
• Вычислить ошибку (разница получившегося и ожидаемого векторов)
• Распространить ошибку на предыдущие слои
• Обновить весовые коэффициенты для уменьшения ошибки

Сам же алгоритм обучения выглядит так:

error = 0
epoch = 1

повторять:
	Для каждого обучающего примера:
		Найти ошибку e = f - d
		Прибавить к error сумму квадратов значений e
		Распространенить ошибку к первому слою
		Обновить веса

	если error < eps
		выйти

	если epoch > maxEpoch
		выйти из-за ограничения на число эпох

	epoch = epoch + 1

Обучаем нейронную сеть

Для обратного распространения ошибки нам потребуется знать значения входов, выходов и значения производных функции активации сети на каждом из слоёв, поэтому создадим структуру LayerT, в которой будет 3 вектора: x — вход слоя, z — выход слоя, df — производная функции активации. Также для каждого слоя потребуются векторы дельт, поэтому добавим в наш класс ещё и их. С учётом вышесказанного наш класс станет выглядеть так:

class Network {
    struct LayerT {
        public Vector x; // вход слоя
        public Vector z; // активированный выход слоя
        public Vector df; // производная функции активации слоя
    }

    Matrix[] weights; // матрицы весов слоя
    LayerT[] L; // значения на каждом слое
    Vector[] deltas; // дельты ошибки на каждом слое

    int layersN; // число слоёв

    public Network(int[] sizes) {
        Random random = new Random(DateTime.Now.Millisecond); // создаём генератор случайных чисел

        layersN = sizes.Length - 1; // запоминаем число слоёв

        weights = new Matrix[layersN]; // создаём массив матриц весовых коэффициентов
        L = new LayerT[layersN]; // создаём массив значений на каждом слое
        deltas = new Vector[layersN]; // создаём массив для дельт

        for (int k = 1; k < sizes.Length; k++) {
            weights[k - 1] = new Matrix(sizes[k], sizes[k - 1], random); // создаём матрицу весовых коэффициентов
	
            L[k - 1].x = new Vector(sizes[k - 1]); // создаём вектор для входа слоя
            L[k - 1].z = new Vector(sizes[k]); // создаём вектор для выхода слоя
            L[k - 1].df = new Vector(sizes[k]); // создаём вектор для производной слоя

            deltas[k - 1] = new Vector(sizes[k]); // создаём вектор для дельт
        }
    }

	// прямое распространение
    public Vector Forward(Vector input) {
        for (int k = 0; k < layersN; k++) {
            if (k == 0) {
                for (int i = 0; i < input.n; i++)
                    L[k].x[i] = input[i];
            }
            else {
                for (int i = 0; i < L[k - 1].z.n; i++)
                    L[k].x[i] = L[k - 1].z[i];
            }

            for (int i = 0; i < weights[k].n; i++) {
                double y = 0;

                for (int j = 0; j < weights[k].m; j++)
                    y += weights[k][i, j] * L[k].x[j];

				// активация с помощью сигмоидальной функции
                L[k].z[i] = 1 / (1 + Math.Exp(-y));
                L[k].df[i] = L[k].z[i] * (1 - L[k].z[i]);

				// активация с помощью гиперболического тангенса
                //L[k].z[i] = Math.Tanh(y);
                //L[k].df[i] = 1 - L[k].z[i] * L[k].z[i];
				
				// активация с помощью ReLU
                //L[k].z[i] = y > 0 ? y : 0;
                //L[k].df[i] = y > 0 ? 1 : 0;
            }
        }

        return L[layersN - 1].z; // возвращаем результат
    }
}

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

Перейдём к обратному распространению ошибки. В качестве функции оценки сети E(W) возьмём среднее квадратичное отклонение: E = 0.5 · Σ(y1i - y2i)2. Чтобы найти значение ошибки E, нам нужно найти сумму квадратов разности значений вектора, который выдала сеть в качестве ответа, и вектора, который мы ожидаем увидеть при обучении. Также нам потребуется найти дельту для каждого слоя, причём для последнего слоя она будет равна вектору разности полученного и ожидаемого векторов, умноженному (покомпонентно) на вектор значений производных последнего слоя: δlast = (zlast - d)·f'last, где zlast — выход последнего слоя сети, d — ожидаемый вектор сети, f'last — вектор значений производной функции активации последнего слоя.

Теперь, зная дельту последнего слоя, мы можем найти дельты всех предыдущих слоёв. Для этого нужно умножить транспонированную матрицы текущего слоя на дельту текущего слоя и затем умножить полученный вектор на вектор производных функции активации предыдущего слоя: δk-1 = WTk·δk·f'k.

Что ж, давайте реализуем это в коде:

// обратное распространение
void Backward(Vector output, ref double error) {
    int last = layersN - 1;

    error = 0; // обнуляем ошибку

    for (int i = 0; i < output.n; i++) {
        double e = L[last].z[i] - output[i]; // находим разность значений векторов

        deltas[last][i] = e * L[last].df[i]; // запоминаем дельту
        error += e * e / 2; // прибавляем к ошибке половину квадрата значения
    }

	// вычисляем каждую предудущю дельту на основе текущей с помощью умножения на транспонированную матрицу
    for (int k = last; k > 0; k--) {
        for (int i = 0; i < weights[k].m; i++) {
            deltas[k - 1][i] = 0;

            for (int j = 0; j < weights[k].n; j++)
                deltas[k - 1][i] += weights[k][j, i] * deltas[k][j];

            deltas[k - 1][i] *= L[k - 1].df[i]; // умножаем получаемое значение на производную предыдущего слоя
        }
    }
}

Изменение весов

Для того, чтобы уменьшить ошибку сети нужно изменить весовые коэффициенты каждого слоя. Как же именно нужно менять весовые коэффициенты матриц на каждом слое? Оказывается, всё довольно просто. Для этого используется метод градиентного спуска, а значит нам необходимо вычислить градиент по весам и сделать шаг в отрицательную сторону от этого градиента. На этапе прямого распространения мы зачем-то запоминали входные сигналы, а при обратном распространении ошибки мы вычисляли дельты в каждом слое. Именно их мы и будем сейчас использовать для нахождения градиента! Градиент по весам равен перемножению входного вектора и вектора дельт (не покомпонентно). Поэтому, чтобы обновить весовые коэффициенты и уменьшить тем самым ошибку сети нужно всего лишь вычесть из матрицы весов результат перемножения дельт и входных векторов, умноженный на скорость обучения. Это можно записать в таком виде: Wt+1 = Wt - η·δ·X, где Wt+1 — новая матрица весов, Wt — текущая матрица весов, X — входное значение слоя, δ — дельта этого слоя. Почему именно так с математической точки зрения хорошо описано в этой статье.

// обновление весовых коэффициентов, alpha - скорость обучения
void UpdateWeights(double alpha) {
    for (int k = 0; k < layersN; k++) {
        for (int i = 0; i < weights[k].n; i++) {
            for (int j = 0; j < weights[k].m; j++) {
                weights[k][i, j] -= alpha * deltas[k][i] * L[k].x[j];
            }
        }
    }
}

Обучение сети

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

public void Train(Vector[] X, Vector[] Y, double alpha, double eps, int epochs) {
	int epoch = 1; // номер эпохи
        
    double error; // ошибка эпохи

    do {
        error = 0; // обнуляем ошибку

		// проходимся по всем элементам обучающего множества
        for (int i = 0; i < X.Length; i++) {
            Forward(X[i]); // прямое распространение сигнала
            Backward(Y[i], ref error); // обратное распространение ошибки
            UpdateWeights(alpha); // обновление весовых коэффициентов
        }

        Console.WriteLine("epoch: {0}, error: {1}", epoch, error); // выводим в консоль номер эпохи и величину ошибку
        
        epoch++; // увеличиваем номер эпохи
    } while (epoch <= epochs && error > eps);
}	

Сеть готова. Давайте же её чему-нибудь научим!

Тренируем нейросеть на функции XOR

Почему функция XOR так интересна? Просто потому, что её невозможно получить одним нейроном: 0 ^ 0 = 0, 0 ^ 1 = 1, 1 ^ 0 = 1, 1 ^ 1 = 0. Однако она легко получается увеличением числа нейронов. Мы же попробуем выполнить обучение сети с 3 нейронами в скрытом слое и 1 выходным (так как выход у нас всего один). Для этого нам необходимо создать массив векторов X и Y с обучающими данными и саму нейросеть:

// массив входных обучающих векторов
Vector[] X = {
    new Vector(0, 0),
    new Vector(0, 1),
    new Vector(1, 0),
    new Vector(1, 1)
};

// массив выходных обучающих векторов
Vector[] Y = {
    new Vector(0.0), // 0 ^ 0 = 0
    new Vector(1.0), // 0 ^ 1 = 1
    new Vector(1.0), // 1 ^ 0 = 1
    new Vector(0.0) // 1 ^ 1 = 0
};

Network network = new Network(new int[]{2, 3, 1}); // создаём сеть с двумя входами, тремя нейронами в скрытом слое и одним выходом

После чего запустим обучение со следующими параметрами: скорость обучения — 0.5, число эпох — 100000, величина ошибки — 1e-7:

network.Train(X, Y, 0.5, 1e-7, 100000); // запускаем обучение сети 

После обучения посмотрим на результаты выполнив прямой проход для всех элементов:

for (int i = 0; i < 4; i++) {
	Vector output = network.Forward(X[i]);
	Console.WriteLine("X: {0} {1}, Y: {2}, output: {3}", X[i][0], X[i][1], Y[i][0], output[0]);
}

В результате вывод может быть таким:

X: 0 0, Y: 0, output: 0,00503439463431083
X: 0 1, Y: 1, output: 0,996036009216668
X: 1 0, Y: 1, output: 0,996036033202241
X: 1 1, Y: 0, output: 0,00550270947767007

Проверять результаты на тренировочной же выборке довольно скучно, ведь как никак на ней мы сеть обучали, но, увы, для XOR проблемы ничего другого не остаётся. В качестве более серьёзного примера рекомендуем выполнить задачу распознавания картинок с рукописными цифрами MNIST. Это база содержит 60000 картинок написанных от руки цифр размером 28 на 28 пикселей и используется как один из основных датасетов для начала изучения машинного обучения. Не смотря на простоту нашей сети, при грамотном выборе параметров (число нейронов, число слоёв, скорость обучения, число эпох…) можно получить точность распознавания до 98%! Проверить свою сеть вы можете, поучаствовав в соревновании на сайте Kaggle. Нашей команде удалось достичь точности в 98.171%! А вы сможете больше?

В заключение

Мы написали с вами нейронную сеть прямого распространения и даже обучили её функции XOR. При этом мы позаботились об универсальности, благодаря чему нейросеть может быть обучена на любых данных, главное только подготовить два массива обучающих векторов X и Y, подобрать параметры обучения и запустить само обучение, после чего наблюдать за процессом. Важно помнить, что при использовании сигмоидальной функции активации, выходные значения сети не будут превышать 1, а значит, для обучения данным, которые значительно больше 1 необходимо отнормировать их, то есть привести к отрезку [0, 1].

Возможно, будет интересно: Свёрточная нейронная сеть с нуля. Часть 0. Введение.

В этой статье поговорим о том, как создавать нейросети и в качестве примера рассмотрим, как сделать нейронную сеть прямого распространения с нуля. Для реализации поставленной задачи воспользуемся языком программирования C#.

Только ленивый не слышал сегодня о существовании и разработке нейронных сетей и такой сфере, как машинное обучение. Для некоторых создание нейросети кажется чем-то очень запутанным, однако на самом деле они создаются не так уж и сложно. Как же их делают? Давайте попробуем самостоятельно создать нейросеть прямого распространения, которую еще называют многослойным перцептроном. В процессе работы будем использовать лишь циклы, массивы и условные операторы. Что означает этот набор данных? Только то, что нам подойдет любой язык программирования, поддерживающий вышеперечисленные возможности. Если же у языка есть библиотеки для векторных и матричных вычислений (вспоминаем NumPy в Python), то реализация с их помощью займет совсем немного времени. Но мы не ищем легких путей и воспользуемся C#, причем полученный код по своей сути будет почти аналогичным и для прочих языков программирования.

Что же такое нейронная сеть?

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

Говоря проще, ИНС можно назвать неким «черным ящиком», превращающим входные данные в выходные данные. Если же посмотреть на это с точки зрения математики, то речь идет о том, чтобы отобразить пространство входных X-признаков в пространство выходных Y-признаков: X → Y. Таким образом, нам надо найти некую F-функцию, которая сможет выполнить данное преобразование. На первом этапе этой информации достаточно в качестве основы.  

Какую роль играет искусственный нейрон?

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

Искусственный нейрон представляет собой взвешенную сумму векторных значений входных элементов. Эта сумма передается на нелинейную функцию активации f:

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

Нейрослой

Один нейрон может превратить в одну точку входной вектор, но по условию мы желаем получить несколько точек, т. к. выходное Y способно иметь произвольную размерность, которая определяется лишь ситуацией (один выход для XOR, десять выходов, чтобы определить принадлежность к одному из десяти классов, и так далее). Каким же образом получить n точек? На деле все просто: для получения n выходных значений, надо задействовать не один нейрон, а n. В результате для каждого элемента выходного Y будет использовано n разных взвешенных сумм от X. В итоге мы придем к следующему соотношению:

Давайте внимательно посмотрим на него. Вышенаписанная формула — это не что иное, как определение умножения матрицы на вектор. И в самом деле, если мы возьмем матрицу W размера n на m и выполним ее умножение на X размерности m, то мы получим другое векторное значение n-размерности, то есть как раз то, что надо.

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

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

Ниже показан пример нейронной сети, имеющей 2 входа, 5 нейронов и 1 выход:

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

Функция активации

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

Каждая из них имеет свои особенности.

Пишем код

Теперь мы знаем достаточно, чтобы создать простую нейронную сеть. Чтобы сделать то, что задумали, нам потребуются:

1. Вектор.
2. Матрица (каждый слой включает в себя матрицу весовых коэффициентов).
3. Нейронная сеть.

Начнем с вектора. Создавать его можно:

• из количества элементов;
• из перечисления вещественных чисел.

Также мы можем получать и менять значения по индексу i.

Пишем код:

Теперь очередь матрицы. Ее можно создавать из числа строк и столбцов, а также генератора случайных чисел, причем есть возможность получать и менять значения по индексам i и j.

А вот и сама нейронная сеть:

Как будем обучать?

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

Некоторые особенности работы этого алгоритма:

• на вход сети подается обучающий пример (1 входной вектор);
• сигнал распространяется по нейросети вперед (получаем выход сети);
• вычисляется ошибка (это разница между получившимся и ожидаемым векторами);
• ошибка распространяется на предыдущие слои;
• происходит обновление весовых коэффициентов в целях уменьшения ошибки.

Вот как выглядит алгоритм обучения:

Переходим к обучению

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

• x — вход слоя,
• z — выход,
• df — производная функции активации.

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

Несколько слов об обратном распространении ошибки

В качестве функции оценки нейросети E(W) мы берем среднее квадратичное отклонение: 

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

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

Смотрим реализацию в коде:

Обновление весовых коэффициентов

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

Вот оно, обучение!

Теперь мы имеем все нужные нам методы, поэтому остается лишь всё это вместе соединить, сформировав единый метод обучения.

Наша сеть готова, но мы пока ее еще ничему не научили. Сейчас это исправим.  

Тренировка нейронной сети. Функции XOR

Функция XOR интересна тем, что ее нельзя получить одним нейроном:

Но ее легко получить путем увеличения количества нейронов. Давайте попробуем реализовать обучение с тремя нейронами в скрытом слое и одним выходным (выход ведь у нас только один). Чтобы все получилось, создадим массив X и Y, имеющий обучающие данные и саму нейронную сеть:

Теперь запускаем обучение с параметрами ниже:

• скорость обучения — 0.5,
• количество эпох — 100000,
• значение ошибки — 1e-7.

Выполнив обучение, посмотрим итоги, для чего надо будет сделать прямой проход для всех элементов:

В итоге вывод будет следующим:

Результаты

Мы написали нейронную сеть прямого распространения и не только написали, но и обучили ее функции XOR. Также была обеспечена универсальность, поэтому эту нейросеть можно обучать на любых данных — потребуется лишь:

• подготовить 2 векторных обучающих массива векторов X и Y,
• подобрать параметры,
• запустить само обучение,
• наблюдать за процессом.

Однако помните, что если используется сигмоидальная функция активации, выходные числа не будут больше единицы, что означает, что для обучения данным, которые существенно больше единицы, нужно будет нормировать их, приводя к отрезку [0, 1].

Надеемся, что материал был вам полезен и теперь вы знаете, как сделать нейросеть, и какие нюансы разработки стоит учитывать. Если же интересуют более продвинутые знания, обратите внимание на курсы, которые разработала команда Otus:

По материалам: https://programforyou.ru/poleznoe/pishem-neuroset-pryamogo-rasprostraneniya.

Подробная прямая нейронная сеть и алгоритм BP

1. Понятие нейронной сети

1.1 Базовая единица искусственной нейронной сети -> Персептрон

1.1.1 Объяснение модели персептрона

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

  

• Соответствующие символы на рисунке имеют следующие значения:
  • Вход (x1, …, xn)
  • Смещение b и синаптические веса (w1, …, wn), обратите внимание, что мы нажимаем ниже, чтобы использовать
    

    θ

    i

    Вместо wi для вывода формулы.

  • Комбинированная функция c (·)
  • Функция активации а (·)
  • Выход у
• На математическом языке, если у нас есть m выборок, каждая выборка соответствует n-мерным элементам и выводу двоичной категории следующим образом:

  (

  x

  1

  (

  0

  )

  ,

  x

  2

  (

  0

  )

  ,

  .

  .

  .

  x

  n

  (

  0

  )

  ,

  y

  0

  )

  ,

  (

  x

  1

  (

  1

  )

  ,

  x

  2

  (

  1

  )

  ,

  .

  .

  .

  x

  n

  (

  1

  )

  ,

  y

  1

  )

  ,

  .

  .

  .

  (

  x

  1

  (

  m

  )

  ,

  x

  2

  (

  m

  )

  ,

  .

  .

  .

  x

  n

  (

  m

  )

  ,

  y

  m

  )

• Наша цель — найти гиперплоскость, а именно:
  

  θ

  0

  +

  θ

  1

  x

  1

  +

  .

  .

  .

  +

  θ

  n

  x

  n

  =

  0

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

• Чтобы упростить модель, мы добавляем x0 = 1, делая уравнение гиперплоскости сокращенным
  

  ∑

  i

  =

  0

  n

  θ

  i

  x

  i

  =

  0

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

  θ

  ∙

  x

  =

  0

  среди них
  

  θ

  И X оба n * 1 векторов,
  

  ∙

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

• Следовательно, модель персептрона может быть определена как
  

  y

  =

  s

  i

  g

  n

  (

  θ

  ∙

  x

  )

  Где знак — это функция активации, которая является функцией знака, также известной как функция шага.

  s

  i

  g

  n

  (

  x

  )

  =

  {

  −

  1

  x

  <

  0

  1

  x

  ≥

  0

• В многослойных нейронных сетях мы можем использовать другие функции активации, а именно:

1.1.2 Функция потерь модели персептрона

• Основываясь на приведенном выше анализе, мы будем
  

  θ

  ∙

  x

  >

  0

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

  y

  θ

  ∙

  x

  >

  0

  И неправильный образец классификации удовлетворяет
  

  y

  θ

  ∙

  x

  <

  0

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

• из-за
  

  y

  θ

  ∙

  x

  <

  0

  Таким образом, для каждого неправильно классифицированного образца i расстояние до гиперплоскости равно:

  −

  y

  (

  i

  )

  θ

  ∙

  x

  (

  i

  )

  /

  |

  |

  θ

  |

  |

  2

• среди них,
  

  |

  |

  θ

  |

  |

  2

  Является ли норма L2. (Если формула расстояния здесь не понята, вы можете самостоятельно проверить расстояние от точки до прямой линии или изучить соответствующие главы машинного обучения)

• Далее мы предполагаем, что множество всех ошибочно классифицированных точек равно M, тогда сумма расстояний всех ошибочно классифицированных выборок до гиперплоскости равна:

  −

  ∑

  x

  i

  ∈

  M

  y

  (

  i

  )

  θ

  ∙

  x

  (

  i

  )

  /

  |

  |

  θ

  |

  |

  2

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

• Кроме того, нам также нужно упростить его, мы можем заметить, что как числитель, так и знаменатель имеют
  

  θ

  (Т.е. числитель и знаменатель имеют одинаковое увеличение), когда числитель
  

  θ

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

  J

  (

  θ

  )

  =

  −

  ∑

  x

  i

  ∈

  M

  y

  (

  i

  )

  θ

  ∙

  x

  (

  i

  )

  В дополнение к нам также необходимо обратить внимание наДля SVM он использует фиксированный числитель 1, а затем решает
  

  1

  |

  |

  θ

  |

  |

  2

  Проблема максимизации (Почему проблема максимизации, а не проблема минимизации, это связано с идеей оптимизации SVM, и я не буду ее здесь приводить.)

1.1.3 Метод оптимизации функции потерь персептрона и описание алгоритма потока

1.1.3.1 Метод оптимизации

• После приведенных выше рассуждений, мы получаем функцию потери перцептрона,
  

  J

  (

  θ

  )

  =

  −

  ∑

  x

  i

  ∈

  M

  y

  (

  i

  )

  θ

  ∙

  x

  (

  i

  )

  , Где M — множество всех ошибочно классифицированных точек, и это выпуклая функция, может использовать метод градиентного спуска или квазиньютоновского метода, обычно используемый SGD (случайный градиентный спуск), что означает, что каждый раз необходимо использовать только одну ошибочно классифицированную точку Обновите градиент. Из-за ограничения в нашей функции потерь, только выборки из неправильно классифицированного набора М могут участвовать в оптимизации функции потерь. Следовательно, BGD (пакетный градиентный спуск) нельзя использовать, только SGD или MSGD (небольшой пакетный градиентный спуск).

• Функция потери
  

  θ

  Частная производная вектора:

  ∂

  ∂

  θ

  J

  (

  θ

  )

  =

  −

  ∑

  x

  i

  ∈

  M

  y

  (

  i

  )

  x

  (

  i

  )

• 
  

  θ

  Формула градиентного спуска:

  θ

  =

  θ

  +

  α

  ∑

  x

  i

  ∈

  M

  y

  (

  i

  )

  x

  (

  i

  )

• Поскольку мы используем стохастический градиентный спуск, для вычисления градиента за один раз используется только одна неправильно классифицированная выборка. Предполагая, что i-я выборка используется для обновления градиента, упрощенная
  

  θ

  Итерационная формула градиентного спуска:

  θ

  =

  θ

  +

  α

  y

  (

  i

  )

  x

  (

  i

  )

• Где α — размер шага,
  

  y

  (

  i

  )

  Чтобы вывести 1 или -1 для выборки, x (i) является вектором (n + 1) x 1.

1.1.3.2 Описание алгоритма

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

    (

    x

    1

    (

    0

    )

    ,

    x

    2

    (

    0

    )

    ,

    .

    .

    .

    x

    n

    (

    0

    )

    ,

    y

    0

    )

    ,

    (

    x

    1

    (

    1

    )

    ,

    x

    2

    (

    1

    )

    ,

    .

    .

    .

    x

    n

    (

    1

    )

    ,

    y

    1

    )

    ,

    .

    .

    .

    (

    x

    1

    (

    m

    )

    ,

    x

    2

    (

    m

    )

    ,

    .

    .

    .

    x

    n

    (

    m

    )

    ,

    y

    m

    )

• Вывод:
  • Модельный коэффициент θ вектора разделяющей гиперплоскости
• Процесс выполнения алгоритма:
  • Определить все х0 до 1. Выберите начальное значение вектора θ и начальное значение шага α. Вектор θ может быть установлен на вектор 0, а размер шага установлен на 1. Следует отметить, что, поскольку решение персептрона не является уникальным, два используемых начальных значения будут влиять на конечный результат итерации вектора θ.
  • Выберите ошибочно классифицированную точку в тренировочном наборе
    

    (

    x

    1

    (

    i

    )

    ,

    x

    2

    (

    i

    )

    ,

    .

    .

    .

    x

    n

    (

    i

    )

    ,

    y

    i

    )

    Выражается в векторах т.е.
    

    (

    x

    (

    i

    )

    ,

    y

    (

    i

    )

    )

    , Этот пункт должен удовлетворять:
    

    y

    (

    i

    )

    θ

    ∙

    x

    (

    i

    )

    <

    0

  • Выполните итерацию стохастического градиентного спуска на векторе:
    

    θ

    =

    θ

    +

    α

    y

    (

    i

    )

    x

    (

    i

    )

  • Проверьте, есть ли в обучающем наборе все еще неправильно классифицированные точки, в противном случае алгоритм завершается, и вектор θ в это время является окончательным результатом. Если это так, перейдите к шагу 2.
• Наконец, также необходимо упомянуть, что когда алгоритм фактически был реализован в прошлом, мы использовали двойную форму алгоритма персептрона для решения параметров и оптимизации модели, поскольку она может оптимизировать скорость выполнения алгоритма. Читатели могут учиться самостоятельно. Мы все еще сосредоточены на следующем объяснении знаний, связанных с нейронными сетями.

1.2 Глубокая нейронная сеть (DNN) и алгоритм прямого распространения

1.2.1 Введение в глубокие нейронные сети

• С помощью персептрона его можно использовать только для задач двоичной классификации, но он не может решить нелинейные задачи.Нейронные сети сделали много расширений, главным образом отраженных в следующих аспектах:
  • Добавлены скрытые слои. Скрытые слои могут иметь несколько слоев, чтобы усилить выразительные возможности модели, поэтому ее сложность также значительно возросла.
  • На входном слое имеется более одного нейрона с несколькими выходами. Кроме того, существует полная связь между верхним уровнем и следующим уровнем, и нет связи между нейронами в одном и том же слое, и они не зависят друг от друга. Таким образом, модель может гибко применяться для классификации и регрессии (обычно разница заключается только в функции активации последнего прохода структуры. Если требуется регрессия и требуется непрерывное значение, не используйте стандартизированную функцию сжатия, такую ​​как Sigmoid)
  • Функция активации была расширена, чтобы заменить Sign (z) функцией Sigmod или другими функциями активации, tanx, softmax, ReLU и т. Д. Так выглядит следующая картина:

• DNN можно понимать как нейронную сеть с несколькими скрытыми слоями. Кроме того, его иногда называют многослойным персептроном (Multi-Layer Perceptron, MLP). Внутренний уровень нейронной сети делится на три категории: входной слой, скрытый слой и выходной слой. Как показано выше, в целом, первый слой является входным слоем, последний слой является выходным слоем, а все средние слои являются скрытыми слоями. Слои полностью связаны, то есть любой нейрон в слое i должен быть связан с любым нейроном в слое i + 1. Хотя DNN выглядит сложным, маленькая локальная модель остается такой же, как персептрон, то есть линейная зависимость
  

  z

  =

  ∑

  w

  i

  x

  i

  +

  b

  Добавьте функцию активации σ (z). Однако с увеличением количества слоев количество линейных соотношений W и смещения b также увеличивается. Определение следующее:

• Сначала давайте взглянем на определение коэффициента линейной зависимости w. На следующем рисунке в качестве примера показан трехслойный DNN. Линейный коэффициент четвертого нейрона во втором слое ко второму нейрону в третьем слое определяется как
  

  w

  24

  3

  Верхний индекс 3 представляет количество слоев, в которых расположен линейный коэффициент w, а нижний индекс соответствует выходному индексу третьего уровня 2 и входному индексу второго уровня 4. Вы можете спросить, почему нет
  

  w

  42

  3

  Вместо
  

  w

  24

  3

  Какой? Это главным образом для облегчения модели для операций матричного представления, если это
  

  w

  42

  3

  И каждый раз, когда выполняется матричная операция
  

  w

  T

  x

  +

  b

  Нужно транспонировать. Если выходной индекс помещен вперед, вес W не должен быть перемещен в линейной операции. То есть линейные коэффициенты k-го нейрона в слое l-1 до j-го нейрона в слое l определяются как
  

  w

  j

  k

  l

  Где входной слой не имеет параметра w.

  

• Давайте посмотрим на определение смещения б. На примере этого трехслойного DNN смещение, соответствующее третьему нейрону во втором слое, определяется как
  

  b

  3

  2

  Среди них верхний индекс 2 представляет количество слоев, а нижний индекс 3 представляет индекс нейронов, в которых находится смещение. Таким же образом, смещение первого нейрона в третьем должно быть выражено как
  

  b

  1

  3

  Аналогично, входной слой не имеет параметра смещения b.

  

1.2.2 Алгоритм прямого распространения

• Выше мы ввели определение коэффициента линейной зависимости w и смещения b каждого слоя DNN. Предполагая, что выбранная нами функция активации σ (z), выходное значение скрытого слоя и выходного слоя равно a, а затем для трехслойного DNN на следующем рисунке, используя ту же идею, что и персептрон, мы можем использовать выходные данные предыдущего слоя для вычисления Выход первого уровня — это так называемый алгоритм прямого распространения DNN.

  

• Для вывода второго слоя
  

  a

  1

  2

  ,

  a

  2

  2

  ,

  a

  3

  2

  ,У нас есть:

  • 
    

    a

    1

    2

    =

    σ

    (

    z

    1

    2

    )

    =

    σ

    (

    w

    11

    2

    x

    1

    +

    w

    12

    2

    x

    2

    +

    w

    13

    2

    x

    3

    +

    b

    1

    2

    )

  • 
    

    a

    2

    2

    =

    σ

    (

    z

    2

    2

    )

    =

    σ

    (

    w

    21

    2

    x

    1

    +

    w

    22

    2

    x

    2

    +

    w

    23

    2

    x

    3

    +

    b

    2

    2

    )

  • 
    

    a

    3

    2

    =

    σ

    (

    z

    3

    2

    )

    =

    σ

    (

    w

    31

    2

    x

    1

    +

    w

    32

    2

    x

    2

    +

    w

    33

    2

    x

    3

    +

    b

    3

    2

    )

• Для вывода третьего слоя
  

  a

  1

  3

  ,У нас есть:

  • 
    

    a

    1

    3

    =

    σ

    (

    z

    1

    3

    )

    =

    σ

    (

    w

    11

    3

    a

    1

    2

    +

    w

    12

    3

    a

    2

    2

    +

    w

    13

    3

    a

    3

    2

    +

    b

    1

    3

    )

• Обобщая вышеприведенный пример, предполагая, что в слое l-1 имеется m нейронов, для вывода j-го нейрона в слое l
  

  a

  j

  l

  ,У нас есть:

  a

  j

  l

  =

  σ

  (

  z

  j

  l

  )

  =

  σ

  (

  ∑

  k

  =

  1

  m

  w

  j

  k

  l

  a

  k

  l

  −

  1

  +

  b

  j

  l

  )

• Среди них, если
  

  l

  = 2, тогда a_k ^ 1 для входного слоя
  

  x

  k

  。

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

  l

  -1 слой имеет в общей сложности m нейронов, в то время как слой 1 имеет в общей сложности n нейронов, тогда
  

  l

  Линейный коэффициент w слоя образует матрицу Wl n × m, первый
  

  l

  Смещение b слоя формирует вектор n × 1
  

  b

  l

  , Раздел
  

  l

  Выход a слоя -1 формирует вектор m × 1
  

  a

  l

  −

  1

  , Раздел
  

  l

  Неактивный линейный выход z слоя формирует вектор n × 1
  

  z

  l

  , Раздел
  

  l

  Выход a слоя формирует вектор n × 1
  

  a

  l

  , Выражается матричным методом, первым
  

  l

  Выход слоя:

  a

  l

  =

  σ

  (

  z

  l

  )

  =

  σ

  (

  W

  l

  a

  l

  −

  1

  +

  b

  l

  )

• Это выражено очень кратко, поэтому последующее обсуждение будет выведено на основе этого матричного метода.
• Описание алгоритма потока:
  • Вход: общее количество слоев L, матрица W, соответствующая всем скрытым слоям и выходным слоям, вектор смещения b, вектор входных значений x
  • Выход: выходной слой
    

    a

    L

  • Обработать:
    • Initialize
      

      a

      1

      =x

    • for
      

      l

      =2 to
      

      L

      Расчет:

      a

      l

      =

      σ

      (

      z

      l

      )

      =

      σ

      (

      W

      l

      a

      l

      −

      1

      +

      b

      l

      )

    • Конечный результат — выход
      

      a

      L

• DNN алгоритм прямого распространения, как получить параметры, соответствующие большой матрице W и вектору смещения b? Как получить оптимальную матрицу W и вектор смещения b? Это должно быть решено алгоритмом обратного распространения DNN. Предпосылка понимания алгоритма обратного распространения состоит в том, чтобы понять модель DNN и алгоритм прямого распространения. Далее идет легендарный алгоритм БП.

1.3 Алгоритм обратного распространения BP (обратное распространение)

1.3.1 Проблемы, которые необходимо решить путем обратного распространения

• Прежде, чем понять алгоритм обратного распространения DNN, мы должны сначала знать проблему, которую должен решить алгоритм обратного распространения DNN, то есть, когда нам нужен этот алгоритм обратного распространения?
• Возвращаясь к нашей общей проблеме контролируемого обучения, предположим, что у нас есть m обучающих образцов:
  

  {

  (

  x

  1

  ,

  y

  1

  )

  ,

  (

  x

  2

  ,

  y

  2

  )

  ,

  .

  .

  .

  ,

  (

  x

  m

  ,

  y

  m

  )

  }

  Где x — входной вектор, а размерность объекта — n_in, а y — выходной вектор, а размерность объекта — n_out. Нам нужно использовать эти m образцов для обучения модели, когда есть новый тестовый образец (
  

  x

  t

  e

  s

  t

  ?) Когда мы придем, мы можем предсказать
  

  y

  t

  e

  s

  t

  Векторный вывод.

• Если мы примем модель DNN, у нас будет n_in нейронов на входном слое и n_out нейронов на выходном слое. Плюс несколько скрытых слоев, содержащих несколько нейронов. В настоящее время нам нужно найти соответствующую матрицу линейных коэффициентов W и вектор смещения b для всех скрытых слоев и выходных слоев, чтобы выходной сигнал, рассчитанный по всем входным сигналам обучающей выборки, был как можно ближе к выходным данным выборки или близко к ним. Как найти подходящие параметры?
• Вы можете подумать, что вы можете использовать подходящую функцию потерь для измерения выходных потерь обучающей выборки, а затем оптимизировать эту функцию потерь, чтобы минимизировать экстремальное значение. Соответствующий ряд матриц W линейного коэффициента, вектор смещения b является нашей Окончательные результаты. В DNN процесс оптимизации экстремума функции потерь обычно повторяется шаг за шагом по методу градиентного спуска.Конечно, можно использовать и другие итерационные методы, такие как метод Ньютона и квазиньютоновский метод.
• Процесс итеративной оптимизации функции потерь DNN путем градиентного спуска для нахождения минимального значения является нашим алгоритмом обратного распространения.

1.3.2 Основная идея алгоритма обратного распространения

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

  a

  l

  =

  σ

  (

  z

  l

  )

  =

  σ

  (

  W

  l

  a

  l

  −

  1

  +

  b

  l

  )

  , Рассчитать соответствующий L-й слой выходного слоя
  

  a

  L

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

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  =

  1

  2

  |

  |

  a

  L

  −

  y

  |

  |

  2

  2

• среди них,
  

  a

  L

  И у — векторы с размерностью объекта n_out, и
  

  |

  |

  S

  |

  |

  2

  Является ли L2 нормой S.

• С функцией потерь, теперь мы начинаем использовать градиентный спуск, чтобы итеративно решить W, b для каждого слоя.
• Первый — это L-й слой выходного слоя. Обратите внимание, что W, b в выходном слое удовлетворяет следующей формуле:

  a

  L

  =

  σ

  (

  z

  L

  )

  =

  σ

  (

  W

  L

  a

  L

  −

  1

  +

  b

  L

  )

• Таким образом, для параметров выходного слоя наша функция потерь становится:

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  =

  1

  2

  |

  |

  a

  L

  −

  y

  |

  |

  2

  2

  =

  1

  2

  |

  |

  σ

  (

  W

  L

  a

  L

  −

  1

  +

  b

  L

  )

  −

  y

  |

  |

  2

  2

• Решить градиент W, b таким образом просто:

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  W

  L

  =

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  z

  L

  ∂

  z

  L

  ∂

  W

  L

  =

  (

  a

  L

  −

  y

  )

  ⊙

  σ

  ′

  (

  z

  L

  )

  (

  a

  L

  −

  1

  )

  T

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  b

  L

  =

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  z

  L

  ∂

  z

  L

  ∂

  b

  L

  =

  (

  a

  L

  −

  y

  )

  ⊙

  σ

  ′

  (

  z

  L

  )

• Обратите внимание, что в приведенной выше формуле есть символ
  

  ⊙

  , Который представляет произведение Адамара, для двух векторов одного измерения
  

  A

  （

  a

  1

  ,

  a

  2

  ,

  .

  .

  .

  a

  n

  ）

  T

  с участием
  

  B

  （

  b

  1

  ,

  b

  2

  ,

  .

  .

  .

  b

  n

  ）

  T

  , Затем
  

  A

  ⊙

  B

  =

  (

  a

  1

  b

  1

  ,

  a

  2

  b

  2

  ,

  .

  .

  .

  a

  n

  b

  n

  )

  T

• Мы заметили, что при решении W, b в выходном слое, есть общая часть
  

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  z

  L

  Таким образом, мы можем относиться к публичной части как
  

  z

  L

  Сначала рассчитайте его и запишите как:

  δ

  L

  =

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  z

  L

  =

  (

  a

  L

  −

  y

  )

  ⊙

  σ

  ′

  (

  z

  L

  )

• Теперь, когда мы наконец рассчитали градиент выходного слоя, как рассчитать градиент верхнего слоя L − 1 и верхнего и верхнего слоя L − 2? Здесь нам нужно повторить шаг за шагом, отметив, что для неактивного вывода слоя l
  

  z

  l

  Его градиент может быть выражен как:

  δ

  l

  =

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  z

  l

  =

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  z

  L

  ∂

  z

  L

  ∂

  z

  L

  −

  1

  ∂

  z

  L

  −

  1

  ∂

  z

  L

  −

  2

  .

  .

  .

  ∂

  z

  l

  +

  1

  ∂

  z

  l

• Если мы можем рассчитать первое
  

  l

  Многослойные
  

  δ

  l

  Тогда слой
  

  W

  l

  ,
  

  b

  l

  Это легко рассчитать? y Поскольку согласно алгоритму прямого распространения, мы имеем:
  

  z

  l

  =

  W

  l

  a

  l

  −

  1

  +

  b

  l

• Таким образом, согласно приведенной выше формуле мы можем легко вычислить первое
  

  l

  Многослойные
  

  W

  l

  ,
  

  b

  l

  Градиент выглядит следующим образом:

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  W

  l

  =

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  z

  l

  ∂

  z

  l

  ∂

  W

  l

  =

  δ

  l

  (

  a

  l

  −

  1

  )

  T

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  b

  l

  =

  ∂

  J

  (

  W

  ,

  b

  ,

  x

  ,

  y

  )

  ∂

  z

  l

  ∂

  z

  l

  ∂

  b

  l

  =

  δ

  l

• Тогда ключ к проблеме сейчас заключается в том, чтобы попросить
  

  δ

  l

  Слишком. Здесь мы используем математическую индукцию, слой L
  

  δ

  L

  Мы нашли выше, предполагая, что первое
  

  l

  +1
  

  δ

  l

  +

  1

  Уже

  через

  нищенство

  Вне

  Приходить

  от

  ，

  который

  какой

  я

  Мы

  Такие как

  какие

  нищенство

  Вне

  Первый

  l
  

  Пол

  из

  А как насчет δ ^ l $? Мы заметили: (цепное правило)

δ

l

=

∂

J

(

W

,

b

,

x

,

y

)

∂

z

l

=

∂

J

(

W

,

b

,

x

,

y

)

∂

z

l

+

1

∂

z

l

+

1

∂

z

l

=

δ

l

+

1

∂

z

l

+

1

∂

z

l

• Видимо, рекурсивно по индукции
  

  δ

  l

  +

  1

  с участием
  

  δ

  l

  Ключ должен решить
  

  ∂

  z

  l

  +

  1

  ∂

  z

  l

• Пока
  

  z

  l

  +

  1

  с участием
  

  z

  l

  Отношения на самом деле очень легко найти:

  z

  l

  +

  1

  =

  W

  l

  +

  1

  a

  l

  +

  b

  l

  +

  1

  =

  W

  l

  +

  1

  σ

  (

  z

  l

  )

  +

  b

  l

  +

  1

• Это легко найти:

  ∂

  z

  l

  +

  1

  ∂

  z

  l

  =

  (

  W

  l

  +

  1

  )

  T

  ⊙

  (

  σ

  ′

  (

  z

  l

  )

  ,

  .

  .

  ,

  σ

  ′

  (

  z

  l

  )

  )

  ⏟

  n

  l

  +

  1

• Доведите вышеупомянутое до вершины
  

  δ

  l

  +

  1

  с участием
  

  δ

  l

  Мы получили:

  δ

  l

  =

  δ

  l

  +

  1

  ∂

  z

  l

  +

  1

  ∂

  z

  l

  =

  (

  W

  l

  +

  1

  )

  T

  δ

  l

  +

  1

  ⊙

  σ

  ′

  (

  z

  l

  )

• Теперь мы получили
  

  δ

  l

  Для рекурсивных отношений требуется только определенный уровень
  

  δ

  l

  , Решить
  

  W

  l

  ,
  

  b

  l

  Соответствующий градиент очень прост.

1.3.3 Процесс алгоритма обратного распространения DNN

• Здесь мы обсуждаем пакетный градиентный спуск.На самом деле, Mini-Batch обычно используется в разработке, но алгоритм имеет небольшой эффект.
• Войти:
  • Общее количество слоев L и количество нейронов в каждом скрытом слое и выходном слое, функция активации, функция потерь, размер шага итерации α, максимальное количество итераций MAX и порог остановки итерации ϵ, ввод m обучающих выборок.
• Вывод:
  • Матрица коэффициентов линейных отношений W и вектор смещения b каждого скрытого слоя и выходного слоя

• Алгоритм потока:

  • (1) Инициализируйте значения матрицы W коэффициента линейного отношения и вектора b смещения каждого скрытого слоя и выходного слоя случайным значением.
  • (2) for iter to 1 to MAX：
    • (2.1) for i =1 to m：
      • (а) Входной DNN
        

        a

        1

        Установить на Си

      • (b) для l = 2 до L, для вычисления алгоритма прямого распространения,
        

        a

        i

        ,

        l

        =

        σ

        (

        z

        i

        ,

        l

        )

        =

        σ

        (

        W

        l

        a

        i

        ,

        l

        −

        1

        +

        b

        l

        )

      • (c) Рассчитать выходной слой
        

        δ

        i

        ,

        L

      • (d) для l = L до 2 выполнить расчет алгоритма обратного распространения
        

        δ

        i

        ,

        l

        =

        (

        W

        l

        +

        1

        )

        T

        δ

        i

        ,

        l

        +

        1

        ⊙

        σ

        ′

        (

        z

        i

        ,

        l

        )

    • (2.2) для l = 2 до L обновите слой 1
      

      W

      l

      ,

      b

      l

      :

      • 
        

        W

        l

        =

        W

        l

        −

        α

        ∑

        i

        =

        1

        m

        δ

        i

        ,

        l

        (

        a

        i

        ,

        l

        −

        1

        )

        T

      • 
        

        b

        l

        =

        b

        l

        −

        α

        ∑

        i

        =

        1

        m

        δ

        i

        ,

        l

    • (2.3) Если значения изменения всех W, b меньше порога остановки итерации ϵ, то выпрыгните из цикла итерации к шагу 3
  • (3) Выведите матрицу коэффициентов линейных отношений W и вектор смещения b каждого скрытого слоя и выходного слоя

• Если вы видите здесь, вы можете подумать, что вы не понимаете очень глубоко, или если вы думаете, что это слишком теоретически выведено, и нет никакого практического примера, чтобы понять интуитивно, тогда блоггер рекомендует вам изучить эту статью. Он использует яркие изображения Для иллюстрации на примерах, я думаю, это поможет вам понять алгоритм BP.Используйте небольшой пример, чтобы проиллюстрировать алгоритм BP

1.3.4 Мышление на основе алгоритма обратного распространения DNN

• Основываясь на приведенном выше алгоритме вывода, мы знаем, что существует множество параметров DNN, и количество вычислений матрицы также очень велико. При непосредственном использовании возникнут различные проблемы. Каковы проблемы и как попытаться решить эти проблемы и оптимизировать модель и алгоритм DNN.Конечно, многие ученые дали некоторые решения или изучают эти проблемы, и для нас это тоже очень стоящее исследование. Что касается аспектов, ниже кратко обсуждаются эти вопросы без теоретического вывода.
• С точки зрения функции потери и активации:
  • Функция активации, которую мы выбрали ранее, является функцией Sigmoid, и, как видно из изображения, приведенного в начале, для Sigmoid, когда значение z становится все больше и больше, кривая функции становится все более плавной, что означает, что в это время Производная σ ′ (z) становится все меньше и меньше. Точно так же, когда значение z становится все меньше и меньше, эта проблема также существует. Только когда значение z составляет около 0, значение производной σ (z) больше. В рассмотренном выше алгоритме обратного распространения среднеквадратичной ошибки + сигмоида каждая прямая рекурсия уровня должна быть умножена на σ (z), чтобы получить значение изменения градиента. Судя по его функциональной кривой изображения, большую часть времени наше значение изменения градиента очень мало, что приводит к более медленной скорости обновления W, b до экстремального значения, то есть скорость сходимости алгоритма ниже.
  • Функциональные характеристики сигмоида приводят к проблеме медленной сходимости алгоритма обратного распространения, так как его улучшить? Заменить сигмоид? Это конечно вариант. Другим распространенным вариантом является замена функции среднеквадратичной потери на функцию кросс-энтропийной потери. Давайте сначала обсудим функцию обменных потерь как функцию кросс-энтропии + сигмоидной активации следующим образом:

    J

    (

    W

    ,

    b

    ,

    a

    ,

    y

    )

    =

    −

    y

    ∙

    l

    n

    a

    −

    (

    1

    −

    y

    )

    ∙

    l

    n

    (

    1

    −

    a

    )

  • Затем мы рассчитываем выходной слой
    

    δ

    L

    Ситуация с градиентом, обнаружено, что градиента нет в градиенте
    

    σ

    ′

    (

    z

    )

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

  • Кроме того, когда мы решаем задачи классификации, мы обычно рассматриваем функцию потери логарифмического правдоподобия и функцию активации softmax. Мы не будем здесь обсуждать причину. Заинтересованные читатели могут изучить ее самостоятельно. Функция активации нейрона определяется следующим образом:

    a

    i

    L

    =

    e

    z

    i

    L

    ∑

    j

    =

    1

    n

    L

    e

    z

    j

    L

  • Третья проблема заключается в том, что градиент взрыва градиента DNN исчезает, и функция активации ReLU чаще используется для активации исчезновения градиента в CNN с помощью функции активации градиента ReLU. Что такое градиентные взрывы и исчезновения градиентов? Ниже, попробуйте описать это на общем языке, потому что это очень сложно, и может привести к большой книге, поэтому вот краткое описание.
  • Проще говоря, в процессе обратного распространения, поскольку мы используем цепное правило матричного дифференцирования (ниже), существует большой ряд умножений. Если число умножений меньше 1 в каждом слое, Затем, чем меньше градиент, тем меньше умножение, и градиент исчезает.Если число умножений больше 1, градиент умножается и градиент взрывается.

    δ

    l

    =

    ∂

    J

    (

    W

    ,

    b

    ,

    x

    ,

    y

    )

    ∂

    z

    l

    =

    ∂

    J

    (

    W

    ,

    b

    ,

    x

    ,

    y

    )

    ∂

    z

    L

    ∂

    z

    L

    ∂

    z

    L

    −

    1

    ∂

    z

    L

    −

    1

    ∂

    z

    L

    −

    2

    .

    .

    .

    ∂

    z

    l

    +

    1

    ∂

    z

    l

  • Обычно используемые в общем машиностроении:
    • Для градиентного взрыва это обычно можно решить, отрегулировав параметры инициализации в нашей модели DNN.
    • Для проблемы исчезновения градиента, которая не может быть полностью решена, одним из возможных решений проблемы исчезновения градиента является использование функции активации ReLU (выпрямленная линейная единица) ReLU широко используется в CNN. Выражение очень простое: больше или равно 0 останется неизменным, меньше 0 будет равно 0 после активации.
      

      σ

      (

      z

      )

      =

      m

      a

      x

      (

      0

      ,

      z

      )

  • Кроме того, для решения проблемы переоснащения для регулярности общая регулярность L2 здесь не повторяется, и ее можно использовать как для функции среднеквадратичной ошибки, так и для функции перекрестной энтропии. Кроме того, для регуляризации можно использовать метод интегрированного обучения (Bagging), но из-за дальнейшего увеличения параметров, как правило, производится только 5-10 моделей DNN. Здесь мы обращаем внимание на регуляризацию отсева, которая очень похожа на метод Bagging, но есть некоторые отличия.
  • Так называемое выпадение относится к использованию алгоритма прямого распространения и алгоритма обратного распространения для обучения модели DNN.При итерации пакета данных часть нейронов скрытого слоя случайным образом удаляется из полностью подключенной сети DNN. Сеть нейронов с удаленными скрытыми слоями используется, чтобы соответствовать нашей партии обучающих данных. Используйте эту сеть нейронов с удаленным скрытым слоем, чтобы выполнить цикл итераций, обновляя все W, b.В заключениеТаким образом, в каждом цикле итерации градиентного спуска необходимо разделить обучающие данные на несколько пакетов, а затем выполнить итерацию в пакетах. Итеративно обновить W, b. После итеративного обновления каждого пакета данных неполная модель DNN должна быть восстановлена ​​до исходной модели DNN.
  • Разница между ним и Bagging, W, b в выпадающей модели — это совокупность. Все итеративные итерации DNN обновляют один и тот же набор W, b, при регуляризации по Бэггингу каждая модель DNN имеет свой уникальный набор параметров W, b, которые не зависят друг от друга. Конечно, они используют наборы пакетных данных на основе исходного набора данных для обучения модели каждый раз, что аналогично.

Во-вторых, практика кодирования прямой нейронной сети на основе TensorFlow

2.1 Функции библиотеки TensorFlow участвуют

• Функция активации TensorFlow

  • стандартная сигмоидная функция tf.sigmoid (x)
  • tf.tanh (x) гиперболическая касательная функция
  • tf.nn.relu (x) модифицированная линейная функция

• Другие функции в TensorFlow

  • tf.nn.elu (x) экспоненциальная линейная единица: если входное значение меньше 0, оно возвращает exp (x) -1, в противном случае возвращается x
  • tf.softsign (x) возвращает x / (abs (x) + 1)
  • tf.nn.bias_add (значение, смещение) добавляет смещение к значению

• Некоторые методы оптимизации потерь Tensorflow

  • tf.train.GradientDescentOptimizer (learning_rate, use_locking, name) Оригинальный метод градиентного спуска, единственным параметром является скорость обучения
  • tf.train.AdagradOptimizer адаптивно регулирует скорость обучения, в качестве знаменателя используется квадрат накопленного исторического градиента, чтобы предотвратить слишком большое значение градиента в некоторых направлениях, повысить эффективность оптимизации и хорошо справляться с разреженными градиентами
  • tf.train.AdadeltaOptimizer Расширенный метод оптимизации AdaGrad накапливает только самое последнее значение градиента и не накапливает градиент во всей истории.
  • tf.train.AdamOptimizer Градиентная оценка момента первого порядка и оценка момента второго порядка динамически регулирует скорость обучения каждого параметра.Адам является аббревиатурой для адаптивной оценки момента.

2.2 Подгонка нелинейной регрессии данных

# В этом примере мы вручную генерируем квадратичную функцию плюс набор данных шума, а затем подгоняем ее через простейшую нейронную сеть для достижения цели обучения           
%matplotlib inline 
import numpy as np 
import matplotlib.pyplot as plt 
import tensorflow as tf 
from sklearn.utils import shuffle 
from sklearn.metrics import accuracy_score

# Определение размера набора данных
trainsamples = 200
testsamples = 60 

# Here we will represent the model,a simple imput, 
# a hidden layer of sigmoid activation,
# Определить город ввода, слой вывода и сеть скрытых слоев с 10 узлами
def model(X,hidden_weights1,hidden_bias1,ow):
    hidden_layer = tf.nn.sigmoid(tf.matmul(X,hidden_weights1) + hidden_bias1)
    return tf.matmul(hidden_layer, ow)  

# Создать набор данных  
dsX = np.linspace(-1, 1, trainsamples + testsamplt).transpose()  
dsY = 0.4 * pow(dsX,2) + 2 * dsX + np.random.randn(*dsX.shape) * 0.22 + 0.8  

plt.figure()   # create a new figure  
plt.title('Origial data')
plt.scatter(dsX,dsY)  

<matplotlib.collections.PathCollection at 0x114554110>

X = tf.placeholder('float')  
Y = tf.placeholder('float')  

# create first hidden layer  
hw1 = tf.Variable(tf.random_normal([1, 10],stddev=0.01))
# create output connection 
ow = tf.Variable(tf.random_normal([10, 1],stddev=0.01))  
# create bias  
b = tf.Variable(tf.random_normal([10],stddev=0.01)) 

model_y = model(X,hw1,b,ow)

# cost Function
cost = tf.pow(model_y - Y,2) / (2)  

# create train Operator
train_op = tf.train.AdamOptimizer(0.01).minimize(cost)

# Launch the graph in a session 
with tf.Session() as sess:
    tf.initialize_all_variables().run()  

    # Начать итерацию
    for i in range(1,35):
        trainX, trainY = dsX[0:trainsamples], dsY[0:trainsamples] 
        for x1, y1 in zip(trainX,trainY):
            sess.run(train_op,feed_dict={X:[[x1]],Y:y1})

        testX, testY = dsX[trainsamples:trainsamples + testsamples],dsY[trainsamples:trainsamples+testsamples]        
        # print testY
        cost1 = 0.  
        for x1, y1 in zip(testX,testY):
            cost1 += sess.run(cost,feed_dict={X: [[x1]], Y: y1}) / testsamples 


        print "Average cost for epoch" + str(i) + ':' + str(cost1)

Average cost for epoch1:[[0.26329115]]
Average cost for epoch2:[[0.22221012]]
Average cost for epoch3:[[0.14709872]]
Average cost for epoch4:[[0.10356887]]

Некоторый контент здесь опущен:

Average cost for epoch29:[[0.02887413]]
Average cost for epoch30:[[0.02915836]]
Average cost for epoch31:[[0.029492]]
Average cost for epoch32:[[0.0298766]]
Average cost for epoch33:[[0.0303134]]
Average cost for epoch34:[[0.03080252]]

2.3 Использование Keras для моделирования непрерывных переменных

%matplotlib inline 
import pandas as pd 
import matplotlib as mpl 
import matplotlib.pyplot as plt 

from sklearn import datasets, cross_validation,metrics
from sklearn import preprocessing 

from tensorflow.contrib import learn  

from keras.models import  Sequential 
from keras.layers import  Dense  

# Read the original dataset 
data = pd.read_csv('mpg.csv',header=0)
print data.describe()
# Convert the displacement column as float 
data['displacement'] = data['displacement'].astype(float)

# Игнорировать первый и последний столбец  
X = data[data.columns[1:8]] 
y = data['mpg'] 

plt.figure()
f, ax1 = plt.subplots()
for i in range(1,8):
    number = 420 + i 
    ax1.locator_params(bnbins=3) 
    ax1 = plt.subplot(number)
    plt.title(list(data)[i])
    ax1.scatter(data[data.columns[i]],y)  

plt.tight_layout(pad=0.4,w_pad=0.5,h_pad=1.0)

              mpg   cylinders  displacement  horsepower       weight  
count  398.000000  398.000000    398.000000  398.000000   398.000000   
mean    23.514573    5.454774    193.425879  102.894472  2970.424623   
std      7.815984    1.701004    104.269838   40.269544   846.841774   
min      9.000000    3.000000     68.000000    0.000000  1613.000000   
25%     17.500000    4.000000    104.250000   75.000000  2223.750000   
50%     23.000000    4.000000    148.500000   92.000000  2803.500000   
75%     29.000000    8.000000    262.000000  125.000000  3608.000000   
max     46.600000    8.000000    455.000000  230.000000  5140.000000   


<matplotlib.figure.Figure at 0x11d0fd990>

# Split the datasets 
X_train, x_test, y_train, y_test = cross_validation.train_test_split(X,y,test_size=0.25)

# Scale the data for convergency optimization 
scaler = preprocessing.StandardScaler()

# set the transform parameters 
X_train = scaler.fit_transform(X_train) 

# Build a 2 layer fully connected DNN with 10 and 5 units respectively 
model = Sequential()
model.add(Dense(10,input_dim=7,init='normal',activation='relu'))
model.add(Dense(5,init='normal',activation='relu'))
# Вывод
model.add(Dense(1,init='normal'))  

# Compile the model, which the mean squared error as a loss function
model.compile(loss='mean_squared_error',optimizer='adam')

# Fit the model,in 1000 epochs 
# verbose: журналы показывают, что 0 не выводит журнальную информацию о стандартном потоке вывода, 1 - выходные записи индикатора выполнения, а 2 - запись одной строки за эпоху
# epochs: целое число, значение эпохи в конце обучения, обучение остановится, когда будет достигнуто значение эпохи
model.fit(X_train,y_train,nb_epoch=1200,validation_split=0.33,shuffle=True,verbose=2)  

Train on 199 samples, validate on 99 samples
Epoch 1/1200
 - 0s - loss: 624.4550 - val_loss: 609.7046
Epoch 2/1200
 - 0s - loss: 624.0735 - val_loss: 609.3263
Epoch 3/1200

 Части здесь опущены ...

Epoch 1197/1200
 - 0s - loss: 6.9051 - val_loss: 8.6608
Epoch 1198/1200
 - 0s - loss: 6.9028 - val_loss: 8.6282
Epoch 1199/1200
 - 0s - loss: 6.8984 - val_loss: 8.6874
Epoch 1200/1200
 - 0s - loss: 6.8917 - val_loss: 8.8152


<keras.callbacks.History at 0x11ec65ed0>

2.4 Задача мультиклассификации, многоузловой выходной слой

%matplotlib inline 
import pandas as pd 
import matplotlib.pyplot as plt 
import tensorflow as tf 
from sklearn.utils import shuffle 
from sklearn import preprocessing  

# Чтение данных
data = pd.read_csv('./wine.csv',header=0)
print (data.describe())  

for i in range(1,8):
    number = 420 + i 
    ax1 = plt.subplot(number)
    ax1.locator_params(nbins=3)
    plt.title(list(data)[i])
    ax1.scatter(data[data.columns[i]],data['Wine'])  
plt.tight_layout(pad=0.4,w_pad=0.5,h_pad=1.0)

             Wine     Alcohol  Malic.acid         Ash         Acl          Mg  
count  178.000000  178.000000  178.000000  178.000000  178.000000  178.000000   
mean     1.938202   13.000618    2.336348    2.366517   19.494944   99.741573   
std      0.775035    0.811827    1.117146    0.274344    3.339564   14.282484   
min      1.000000   11.030000    0.740000    1.360000   10.600000   70.000000   
25%      1.000000   12.362500    1.602500    2.210000   17.200000   88.000000   
50%      2.000000   13.050000    1.865000    2.360000   19.500000   98.000000   
75%      3.000000   13.677500    3.082500    2.557500   21.500000  107.000000   
max      3.000000   14.830000    5.800000    3.230000   30.000000  162.000000   

sess = tf.InteractiveSession()
X = data[data.columns[1:13]].values 

# Сами данные начинаются с 1, вычитают отклонение от данных и затем отображают Y в одноразовое кодирование 
y = data['Wine'].values - 1 
Y = tf.one_hot(indices=y,depth=3,on_value=1.,off_value=0.,axis=1,name='a').eval()          
X, Y = shuffle(X, Y) 

# Регуляризация тренировочных данных
scaler = preprocessing.StandardScaler()
X = scaler.fit_transform(X) 

# Здесь скрытый слой нейронной сети, предназначенный для обучения, выберите соответствующий скрытый слой для сложности модели
# Создайте модель, используйте функцию активации softmax + относительную энтропию в качестве функции потерь, в качестве мультиклассификации 
x = tf.placeholder(tf.float32,[None,12])   # Особенности ввода х имеют 12 измерений
W = tf.Variable(tf.zeros([12,3]))          # Вес 12 * 3 
b = tf.Variable(tf.zeros([3]))             # Смещение 1 * 3 
y = tf.nn.softmax(tf.matmul(x,W) + b)  

# Определяем потери и оптимизатор, функция кросс-энтропии потерь определяется следующим образом:
y_ = tf.placeholder(tf.float32,[None,3]) 
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y),reduction_indices=[1]))          
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(cross_entropy)  

# Train 
tf.initialize_all_variables().run()                 # Инициализировать переменные
for i in range(20):
    X, Y = shuffle(X,Y,random_state=1)              # Случайно перемешивать данные, чтобы увеличить способность

    Xtr = X[0:140,:]
    Ytr = Y[0:140,:] 

    Xt = X[140:178,:] 
    Yt = Y[140:178,:] 
    Xtr, Ytr = shuffle(Xtr,Ytr,random_state=0) 

    batch_xs, batch_ys = Xtr, Ytr 
    train_step.run({x:batch_xs,y_:batch_ys}) 
    cost = sess.run(cross_entropy,feed_dict={x:batch_xs,y_:batch_ys})

    # Test trained model 
    correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1)) 
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) 
    print(accuracy.eval({x:Xt,y_:Yt}))  

      Некоторые вещи здесь опущены ...
    0.94736844
    0.94736844
    0.94736844
    0.94736844
    0.9736842
    1.0
    0.9736842

Кодовые слова не легки. Если это поможет вам, пожалуйста, оставьте свои следы или вдохновите меня продолжать.

Примечание: ссылки в этой статье следующие: (Большое спасибо следующим замечательным блоггерам за то, что они позволили мне узнать много полезного)
1、 http://www.cnblogs.com/pinard/p/6472666.html
2、 https://www.jianshu.com/p/964345dddb70

Текст работы размещён без изображений и формул.
Полная версия работы доступна во вкладке «Файлы работы» в формате PDF

Нейронные сети: объяснение прямой связи и обратного распространения

  Перевод

  Ссылка на автора

(первоначально опубликовано на mlfromscratch )

КдействительноПонимание нейронных сетей. Одним из наиболее признанных понятий в глубоком обучении (подполе машинного обучения) являются нейронные сети.

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

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

1. Обзор нейронных сетей
2. Что такое нейронная сеть?
3. Детали, обозначения и математика используются
4. Обратное распространение: оптимизация всех весов
5. Оптимизация нейронной сети
6. Ввод нейронных сетей в шаги
7. Дальнейшее чтение (рекомендуемые книги)

обзор

Общая картина в нейронных сетях — это то, как мы получаем некоторые данные, добавляем их в какой-то алгоритм и надеемся на лучшее. Но что происходит внутри этого алгоритма? На этот вопрос важно ответить по многим причинам; одна из них заключается в том, что в противном случае вы могли бы просто рассматривать внутреннюю работу нейронных сетей как черный ящик.

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

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

Материал сложный, так что смело задавайте свои вопросы на форуме.

Вы можете скачать PDF версию перевода.

Приятного чтения!

Оглавление

1 Глава. Как они работают.

• 1.1   Легко для меня, тяжело для тебя
• 1.2   Простая предсказательная машина
• 1.3   Классификация это почти что предсказание
• 1.4   Тренировка простого классификатора
• 1.5   Иногда одного классификатора недостаточно
• 1.6   Нейроны — природные вычислительные машины
• 1.7   Проход сигнала через нейросеть
• 1.8   Умножать матрицы полезно… Серьезно!
• 1.9   Трехслойная нейросеть и произведение матриц
• 1.10 Калибровка весов нескольких связей
• 1.11 Обратное распространение ошибки от выходных нейронов
• 1.12 Обратное распространение ошибки на множество слоев
• 1.13 Обратное распространение ошибки и произведение матриц

1.10 Калибровка весов нескольких связей

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

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

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

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

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

Конечно, существует очень маленькая вероятность того, что только один вес внес погрешность, а второй был идеально откалиброван. Но даже если мы немного поменяем вес, который и так не вносит погрешность, то в процессе дальнейшего обучения сети он все равно придет в норму, так что ничего страшного.

Можно попытаться разделить погрешность одинаково на все нейроны:

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

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

На рисунке изображены два нейрона, которые подают сигналы третьему, выходному нейрону. Веса связей: ​( 3 )​ и ​( 1 )​. Согласно нашей идее о переносе погрешности на нейроны мы используем ​( frac{3}{4} )​ погрешности на корректировку первого (большего) веса и ​( frac{1}{4} )​ на корректировку второго (меньшего) веса.

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

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

Если у нашей сети 2 нейрона выходного слоя, то нам пришлось бы использовать этот метод еще раз, но уже для связей, которые повлияли на выход второго нейрона выходного слоя. Рассмотрим эту ситуацию подробнее.

1.11 Обратное распространение ошибки от выходных нейронов

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

Оба выхода сети могут иметь погрешность, особенно в тех случаях, когда сеть еще не натренирована. Мы должны использовать полученные погрешности для настройки весов связей. Можно использовать метод, который мы получили в предыдущем разделе — больше изменяем те нейроны, которые сделали больший вклад в выход сети.

То, что сейчас у нас больше одного выходного нейрона по сути ни на что не влияет. Мы просто используем наш метод дважды: для первого и второго нейронов. Почему так просто? Потому что связи с конкретным выходным нейроном никак не влияют на остальные выходные нейроны. Их изменение повлияет только на конкретный выходной нейрон. На диаграмме выше изменение весов ​( w_{1,2} )​ и ​( w_{2,2} )​ не повлияет на результат ​( o_1 )​.

Погрешность первого нейрона выходного слоя мы обозначили за ​( e_1 )​. Погрешность равна разнице между желаемым выходом нейрона ​( t_1 )​, который мы имеем в обучающей выборке и полученным реальным результатом ​( o_1 )​.

[ e_1 = t_1 — o_1 ]

Погрешность второго нейрона выходного слоя равна ​( e_2 )​.

На диаграмме выше погрешность ​( e_1 )​ разделяется на веса ​( w_{1,1} )​ и ​( w_{2,1} )​ соответственно их вкладу в эту погрешность. Аналогично, погрешность ​( e_2 )​ разделяется на веса ​( w_{1,2} )​ и ​( w_{2,2} )​.

Теперь надо определить, какой вес оказал большее влияние на выход нейрона. Например, мы можем определить, какая часть ошибки ​( e_1 )​ пойдет на исправление веса ​( w_{1,1} )​:

[ frac{w_{1,1}}{w_{1,1}+w_{2,1}} ]

А вот так находится часть ​( e_1 )​, которая пойдет на корректировку веса ​( w_{2,1} )​:

[ frac{w_{2,1}}{w_{1,1} + w_{2,1}} ]

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

А как нам понять величину веса относительно всех остальных весов? Для этого мы должны сравнить какой-то конкретный вес (например ​( w_{1,1} )​) с абстрактной «общей» суммой всех весов, повлиявших на выход нейрона. На выход нейрона повлияли два веса: ​( w_{1,1} )​ и ​( w_{2,1} )​. Мы складываем их и смотрим, какая часть от общего вклада приходится на ​( w_{1,1} )​ с помощью деления этого веса на полученную ранее общую сумму:

[ frac{w_{1,1}}{w_{1,1}+w_{2,1}} ]

Пусть ​( w_{1,1} )​ в два раза больше, чем ​( w_{2,1} )​: ​( w_{1,1} = 6 )​ и ​( w_{2,1} = 3 )​. Тогда имеем ​( 6/(6+3) = 6/9 = 2/3 )​, а значит ​( 2/3 )​ погрешности ​( e_1 )​ пойдет на корректировку ​( w_{1,1} )​, а ​( 1/3 )​ на корректировку ​( w_{2,1} )​.

В случае, когда оба веса равны, то каждому достанется по половине погрешности. Пусть ​( w_{1,1} = 4 )​ и ​( w_{2,1}=4 )​. Тогда имеем ​( 4/(4+4)=4/8=1/2 )​, а значит на каждый вес пойдет ​( 1/2 )​ погрешности ​( e_1 )​.

Прежде чем мы двинемся дальше, давайте на секунду остановимся и посмотрим, чего мы достигли. Нам нужно что-то менять в нейросети для уменьшения получаемой погрешности. Мы решили, что будем менять веса связей между нейронами. Мы также нашли способ, как распределять полученную на выходном слое сети погрешность между весами связей. В этом разделе мы получили формулы для вычисления конкретной части погрешности для каждого веса. Отлично!

Но есть еще одна проблема. Сейчас мы знаем, что делать с весами связей слое, который находится прямо перед выходным слоем сети. А что если наша нейросеть имеет больше 2 слоев? Что делать с весами связей в слоях, которые находятся за предпоследним слоем сети?

1.12 Обратное распространение ошибки на множество слоев

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

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

Для простоты обозначения были обобщены. Погрешности нейронов выходного слоя мы в целом назвали ​( e_{text{out}} )​, а все веса связей между скрытым и выходным слоем обозначили за ​( w_{text{ho}} )​.

Еще раз повторю, что для корректировки весов ​( w_{text{ho}} )​ мы распределяем погрешность нейрона выходного слоя по всем весам в зависимости от их вклада в выход нейрона.

Как видно из диаграммы ниже, для корректировки весов связей между входным и скрытым слоем нам надо повторить ту же операцию еще раз. Мы берем погрешности нейронов скрытого слоя ​( e_{text{hi}} )​ и распределяем их по весам связей между входным и скрытым слоем ​( w_{text{ih}} )​:

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

Для корректировки связей между предпоследним и выходным слоем мы использовали погрешность выходов сети ​( e_{text{out}} )​. А чему же равна погрешность выходов нейронов скрытых слоев ​( e_{text{hi}} )​? Это отличный вопрос потому что сходу на этот вопрос ответить трудно. Когда сигнал распространяется по сети от входного к выходному слою мы точно знаем значения выходных нейронов скрытых слоев. Мы получали эти значения с помощью функции активации, у которой в качестве аргумента использовалась сумма взвешенных сигналов, поступивших на вход нейрона. Но как из выходного значения нейрона скрытого слоя получить его погрешность?

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

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

Уже из рисунка можно понять, что делать дальше. Но давайте все-таки еще раз пройдемся по всему алгоритму. Нам нужно получить погрешность выхода нейрона скрытого слоя для того, чтобы скорректировать веса связей между текущим и предыдущим слоями. Назовем эту погрешность ​( e_{text{hi}} )​. Но мы не можем получить значение погрешности напрямую. Погрешность равна разности между ожидаемым и полученным значениями, но проблема заключается в том, что у нас есть ожидаемые значения только для нейронов выходного слоя нейросети.

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

Но выход есть. Мы умеем распределять погрешность нейронов выходного слоя по весам связей. Значит на каждый вес связи идет часть погрешности. Поэтому мы складываем части погрешностей, которые относятся к весам связей, исходящих из данного скрытого нейрона. Полученная сумма и будем считать за погрешность выхода данного нейрона. На диаграмме выше часть погрешности ​( e_{text{out 1}} )​ идет на вес ​( w_{1,1} )​, а часть погрешности ​( e_{text{out 2}} )​ идет на вес ​( w_{1,2} )​. Оба этих веса относятся к связям, исходящим из первого нейрона скрытого слоя. А значит мы можем найти его погрешность:

[ e_{text{hi 1}} = text{сумма частей погрешностей для весов } w_{1,1} text{ и } w_{1,2} ]

[ e_{text{hi 1}} = left(e_{text{out 1}}cdotfrac{w_{1,1}}{w_{1,1} + w_{2,1}}right) + left(e_{text{out 2}}cdotfrac{w_{1,2}}{w_{1,2} + w_{2,2}}right) ]

Рассмотрим алгоритм на реальной трехслойной нейросети с двумя нейронами в каждом слое:

Давайте отследим обратное распространение одной ошибки/погрешности. Погрешность второго выходного нейрона равна ​( 0.5 )​ и она распределяется на два веса. На вес ​( w_{12} )​ идет погрешность ​( 0.1 )​, а на вес ​( w_{22} )​ идет погрешность ​( 0.4 )​. Дальше у нас идет второй нейрон скрытого слоя. От него отходят две связи с весами ​( w_{21} )​ и ​( w_{22} )​. На эти веса связей также распределяется погрешность как от ​( e_1 )​, так и от ​( e_2 )​. На вес ​( w_{21} )​ идет погрешность ​( 0.9 )​, а на вес ​( w_{22} )​ идет погрешность ​( 0.4 )​. Сумма этих погрешностей и дает нам погрешность выхода второго нейрона скрытого слоя: ​( 0.4 + 0.9 = 1.3 )​.

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

Ключевые моменты

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

1.13 Обратное распространение ошибки и произведение матриц

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

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

Начинаем мы с самого конца нейросети — с матрицы погрешностей ее выходов. В примере выше у нас имеется две погрешности сети: ​( e_1 )​ и ​( e_2 )​.

[ mathbf{E}_{text{out}} = left(begin{matrix}e_1 e_2end{matrix}right) ]

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

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

[ e_{text{hi 1}} = left(e_1cdotfrac{w_{11}}{w_{11} + w_{21}}right) + left(e_2cdotfrac{w_{12}}{w_{12} + w_{22}}right) ]

Погрешность второго нейрона скрытого слоя высчитывается так:

[ e_{text{hi 2}} = left(e_1cdotfrac{w_{21}}{w_{11} + w_{21}}right) + left(e_2cdotfrac{w_{22}}{w_{12} + w_{22}}right) ]

Получаем матрицу погрешностей скрытого слоя:

[ mathbf{E}_{text{hid}} = left(begin{matrix}e_{text{hid 1}} e_{text{hid 2}}end{matrix}right) = left(begin{matrix} e_1cdotdfrac{w_{11}}{w_{11} + w_{21}} hspace{5pt} + hspace{5pt} e_2cdotdfrac{w_{12}}{w_{12} + w_{22}} e_1cdotdfrac{w_{21}}{w_{11} + w_{21}} hspace{5pt} + hspace{5pt} e_2cdotdfrac{w_{22}}{w_{12} + w_{22}} end{matrix}right) ]

Многие из вас уже заметили произведение матриц:

[ mathbf{E}_{text{hid}} = left(begin{matrix} dfrac{w_{11}}{w_{11} + w_{21}} & dfrac{w_{12}}{w_{12} + w_{22}} dfrac{w_{21}}{w_{11} + w_{21}} & dfrac{w_{22}}{w_{12} + w_{22}} end{matrix}right)times left(begin{matrix} e_1 e_2 end{matrix}right) ]

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

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

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

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

Но нам очень нужно получить простую формулу для удобного и быстрого расчета матрицы погрешностей.

Пора немного пошалить!

Вновь обратим взор на формулу выше. Можно заметить, что самым главным является умножение погрешности выходного нейрона ​( e_n )​ на вес связи ​( w_{ij} )​, которая к этому выходному нейрону подсоединена. Чем больше вес, тем большую погрешность получит нейрон скрытого слоя. Эту важную деталь мы сохраняем. А вот знаменатели дробей служат лишь нормализующим фактором. Если их убрать, то мы лишимся масштабирования ошибки на предыдущие слои, что не так уж и страшно. Таким образом, мы можем избавиться от знаменателей:

[ e_1cdot frac{w_{11}}{w_{11} + w_{21}} hspace{5pt} longrightarrow hspace{5pt} e_1 cdot w_{11} ]

Запишем теперь формулу для получения матрицы погрешностей, но без знаменателей в левой матрице:

[ mathbf{E}_{text{hid}} = left(begin{matrix} w_{11} & w_{12} w_{21} & w_{22} end{matrix}right)times left(begin{matrix} e_1 e_2 end{matrix}right) ]

Так гораздо лучше!

В разделе по использованию матриц при расчетах прохода сигнала по сети мы использовали следующую матрицу весов:

[ left(begin{matrix} w_{11} & w_{21} w_{12} & w_{22} end{matrix}right) ]

Сейчас, для расчета матрицы погрешностей мы используем такую матрицу:

[ left(begin{matrix} w_{11} & w_{12} w_{21} & w_{22} end{matrix}right) ]

Можно заметить, что во второй матрице элементы как бы отражены относительно диагонали матрицы, идущей от левого верхнего до правого нижнего края матрицы: ​( w_{21} )​ и ​( w_{12} )​ поменялись местами. Такая операция над матрицами существует и называется она textbf{транспонированием} матрицы. Ранее мы использовали матрицу весов ​( mathbf{W} )​. Транспонированные матрицы имеют специальный значок справа сверху: ​( ^intercal )​. В расчете матрицы погрешностей мы используем транспонированную матрицу весов: ​( mathbf{W}^intercal )​.

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

[ left(begin{matrix} 1 & 2 & 3 4 & 5 & 6 7 & 8 & 9 end{matrix}right)^intercal = left(begin{matrix} 1 & 4 & 7 2 & 5 & 8 3 & 6 & 9 end{matrix}right) ]

[ left(begin{matrix} 1 & 2 & 3 4 & 5 & 6 end{matrix}right)^intercal = left(begin{matrix} 1 & 4 2 & 5 3 & 6 end{matrix}right) ]

Мы получили то, что хотели — простую формулу для расчета матрицы погрешностей нейронов скрытого слоя:

[ mathbf{E}_{text{hid}} = mathbf{W}^intercal times mathbf{E}_{text{out}} ]

Это все конечно отлично, но правильно ли мы поступили, просто проигнорировав знаменатели? Да.

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

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

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

Ключевые моменты

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

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