Реализация персептрона с алгоритмом обратного распространения - PullRequest
Новая
       2

Реализация персептрона с алгоритмом обратного распространения

5 голосов
/ 07 февраля 2012

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

Во-первых, я отмечу, что я использую сигмовидную функцию для активации, и поэтому производная является (из того, что я понимаю) сигмоидой (v) * (1 - сигмоид (v)). Итак, это используется при расчете значения дельты.

Итак, в основном я настроил сеть и пробежал всего несколько эпох (пройдемся по каждому возможному шаблону - в данном случае 16 шаблонов ввода). После первой эпохи веса меняются незначительно. После второго веса не меняются и остаются такими, независимо от того, сколько еще эпох я бегу. Я использую скорость обучения 0,1 и смещение +1 на данный момент.

Процесс обучения сети приведен ниже в псевдокоде (который, как я считаю, является правильным в соответствии с источниками, которые я проверил):

Шаг подачи вперед: 

v = SUM[weight connecting input to hidden * input value] + bias  
y = Sigmoid(v)  
set hidden.values to y  
v = SUM[weight connecting hidden to output * hidden value] + bias  
y = Sigmoid(v)  
set output value to y

Обратное распространение выходного слоя: 

error = desired - output.value  
outputDelta = error * output.value * (1 - output.value)

Обратное распространение скрытого слоя: 

for each hidden neuron h:  
error = outputDelta * weight connecting h to output  
hiddenDelta[i] = error * h.value * (1 - h.value)

Обновление весов: 

for each hidden neuron h connected to the output layer  
h.weight connecting h to output = learningRate * outputDelta * h.value

for each input neuron x connected to the hidden layer  
x.weight connecting x to h[i] = learningRate * hiddenDelta[i] * x.value

Этот процесс, конечно, проходит в разные эпохи, и изменения в весе продолжаются. Итак, мой вопрос: есть ли причины, по которым весы остаются постоянными после второй эпохи? При необходимости я могу опубликовать свой код, но в данный момент я надеюсь на что-то очевидное, что я пропускаю. Спасибо всем!

РЕДАКТИРОВАТЬ: Вот ссылки на мой код, предложенный sarnold:
MLP.java: http://codetidy.com/1903
Neuron.java: http://codetidy.com/1904
Pattern.java: http://codetidy.com/1905
input.txt: http://codetidy.com/1906

1 Ответ

4 голосов
/ 07 февраля 2012

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

for each hidden neuron h connected to the output layer
h.weight connecting h to output = learningRate * outputDelta * h.value

for each input neuron x connected to the hidden layer
x.weight connecting x to h[i] = learningRate * hiddenDelta[i] * x.value

Я считаю, что h.weight должен быть обновлен относительно предыдущего веса. Ваш механизм обновления устанавливает его только на основе скорости обучения, выходной дельты и значения узла. Аналогично, x.weight также устанавливается на основе скорости обучения, скрытой дельты и значения узла: 

    /*** Weight updates ***/

    // update weights connecting hidden neurons to output layer
    for (i = 0; i < output.size(); i++) {
        for (Neuron h : output.get(i).left) {
            h.weights[i] = learningRate * outputDelta[i] * h.value;
        }
    }

    // update weights connecting input neurons to hidden layer
    for (i = 0; i < hidden.size(); i++) {
        for (Neuron x : hidden.get(i).left) {
            x.weights[i] = learningRate * hiddenDelta[i] * x.value;
        }
    }

Я не знаю, каково правильное решение ; но у меня есть два предложения:

  1. Заменить эти строки: 

            h.weights[i] = learningRate * outputDelta[i] * h.value;
        x.weights[i] = learningRate * hiddenDelta[i] * x.value;

    с этими строками: 

            h.weights[i] += learningRate * outputDelta[i] * h.value;
        x.weights[i] += learningRate * hiddenDelta[i] * x.value;

    (+= вместо =.)

  2. Заменить эти строки: 

            h.weights[i] = learningRate * outputDelta[i] * h.value;
        x.weights[i] = learningRate * hiddenDelta[i] * x.value;

    с этими строками: 

            h.weights[i] *= learningRate * outputDelta[i];
        x.weights[i] *= learningRate * hiddenDelta[i];

    (Игнорируйте значение и просто масштабируйте существующий вес. Скорость обучения должна быть 1.05 вместо .05 для этого изменения.)

...