Блог

У кого-нибудь есть опыт обучения нейронной сети с обратной связью с обратным распространением?

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

Даже если я расширю итерацию на 200 000, но останусь в цикле for, результат будет выглядеть великолепно.

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

Нейронная сеть легко усваивает сеть. Однако я использую инкрементное обучение и хотел бы много раз проходить цикл for(эпохи). Каким-то образом, когда мы выходим из цикла и запускаем цикл while для эпох, я получаю результат, отклоняющийся от целевого значения. Есть какие-нибудь идеи?

Функция, которую мы тренируем, равна y=2x^2 1

ФРАГМЕНТ ОСНОВНОЙ ЧАСТИ КОДА

 '''
%while epoch <10

for index2  = 1:1:201
 
z = index2
%first solve for activation vector values   
a(1) = w(1)*xInput(z);
a(2) = w(2)*xInput(z);
a(3) = w(3)*xInput(z);
a(4) = w(4)*xInput(z);
a(5) = w(5)*xInput(z);

d(1) = 1/(1 exp(-a(1)));
d(2) = 1/(1 exp(-a(2)));
d(3) = 1/(1 exp(-a(3)));
d(4) = 1/(1 exp(-a(4)));
d(5) = 1/(1 exp(-a(5)));


%next use second set of weights along with decision vector to find 

yPredicted(z) = d(1)*v(1) d(2)*v(2) d(3)*v(3) d(4)*v(4) d(5)*v(5);

%next begin the back propogation (3)

deltaY = yTarget(z)-yPredicted(z);

errorY(z) = (0.5)* ((yTarget(z)-yPredicted(z))^2);

%our first error was calculated, we can use this to try to train nn
%new values for weights

%next calculate transpose of b weights
dTranspose = d.'; 
vTranspose = v.';
xInputTranspose = xInput.';

dErr = -vTranspose*deltaY;

aErr(1) = d(1)*(1-d(1))*dErr(1);
aErr(2) = d(2)*(1-d(2))*dErr(2);
aErr(3) = d(3)*(1-d(3))*dErr(3);
aErr(4) = d(4)*(1-d(4))*dErr(4);
aErr(5) = d(5)*(1-d(5))*dErr(5);

weightError = aErr*xInput(index2);

deltaVOld = deltaV;
deltaWOld = deltaW;

deltaV = learningGain*deltaY*dTranspose momentumGain*deltaVOld; 

v(1) = v(1) deltaV(1);
v(2) = v(2) deltaV(2);
v(3) = v(3) deltaV(3);
v(4) = v(4) deltaV(4);
v(5) = v(5) deltaV(5);

deltaW = learningGain*(-weightError) (momentumGain*deltaWOld);

w(1) = w(1)   deltaW(1);
w(2) = w(2)   deltaW(2);
w(3) = w(3)   deltaW(3);
w(4) = w(4)   deltaW(4);
w(5) = w(5)   deltaW(5);

end;

%epoch = epoch 1;

end;