Backpropagation şi C + +

Pe formularul de recomandare un coder colegi, eu sunt reposting această întrebare aici.

Eu niciodată nu pot părea pentru a obţine dreptul de backpropagation, şi de fiecare dată am cere ajutor, nimeni nu pare să fie în măsură să răspundă sau sugestiile lor nu se rezolva problema. Deci, am crezut ca s-ar putea cere ajutor de la un alt punct - mi clase, fără a algoritmul backprop.
Poate cineva sa-mi spui procedura de backpropagating, în funcţie de sursa de mai jos? Am doar nevoie să ştiu cum algoritmul de backpropagation va lucra pentru configurare clasa mea (Ive 'been trying la spre a lua lucru darned timp de 2 ani, acum - în mod clar Sunt folosind abordarea greşită).

# include
# include
# include

neuron de clasă
(
publice:
float ** de intrare;
float * greutate;
numInputs nesemnat;
float de ieşire;
float manechinului; / / pentru returnarea referinţe proaste

neuron (input_numInputs nesemnate);
neuron ();
void reconstrui (input_numInputs nesemnate);
~ neuron ();
setInput void (neuron & N, inputIndex nesemnat);
setInput void (float & floatInput, inputIndex nesemnat);
float & getInput (inputIndex nesemnate);
recalc void ();
setWeight void (inputIndex nesemnate, float valoare);
);

neuralNetwork clasa
(
publice:
numInputLayer nesemnat;
numHiddenLayer nesemnat;
numInputs nesemnat;
float * intrare;
neuron * inputLayer;
neuron * hiddenLayer;
outputLayer neuron;

neuralNetwork (input_numInputs nesemnate, input_numInputLayer nesemnate, input_numHiddenLayer nesemnat);
~ neuralNetwork ();
);

float XOR (float input1, float input2, float biasLower = 0.0f, float biasUpper = 1.0f);

neuron nule:: setWeight (inputIndex nesemnate, float valoare)
(
în cazul în care (inputIndex> = numInputs)
return;
greutate [inputIndex] = valoare;
)
neuron nule:: recalc ()
(
în cazul în care (numInputs <= 0)
return;
float weightedInput = 0.0f;
for (i nesemnate = 0; i numInputs =)
return;
alt
intrare [inputIndex] = &floatInput;
)
float & neuron:: getInput (inputIndex nesemnate)
(
în cazul în care (inputIndex> = numInputs)
return (inactiv);
alt
return (intrare [inputIndex] [0]);
)
neuron:: neuron ()
(
numInputs = 0;
)
neuron:: neuron (input_numInputs nesemnate)
(
numInputs = 0;
reconstrui (input_numInputs);
)
neuron nule:: reconstrui (input_numInputs nesemnate)
(
în cazul în care (numInputs> 0)
(
a şterge [] de intrare;
a şterge [] greutate;
)
numInputs = input_numInputs;
input = new float * [numInputs];
greutate = new float [numInputs];
)
neuron:: ~ neuron ()
(
în cazul în care (numInputs> = 0)
(
a şterge de intrare;
a şterge greutate;
)
)
neuron nule:: setInput (neuron & N, inputIndex nesemnat)
(
în cazul în care (inputIndex> = numInputs)
return;
intrare [inputIndex] = & n.output;
)

neuralNetwork:: neuralNetwork (input_numInputs nesemnate, input_numInputLayer nesemnate, input_numHiddenLayer nesemnat)
(
I nesemnate, J;
numInputs = input_numInputs;
numHiddenLayer = input_numHiddenLayer;
numInputLayer = input_numInputLayer;
input = new float [numInputs];
inputLayer = neuron noi [numInputLayer];

hiddenLayer = neuron noi [numHiddenLayer];
outputLayer.rebuild (numHiddenLayer);
for (i = 0; i <numHiddenLayer; i + +)
(
hiddenLayer [i]. reconstrui (numInputLayer);
outputLayer.setInput (hiddenLayer [i], i);
)
for (i = 0; i <numInputLayer; i + +)
(
inputLayer [i]. reconstrui (numInputs);
for (j = 0; j <numHiddenLayer; j + +)
hiddenLayer [j]. setInput (inputLayer [i], i);
)
for (i = 0; i <numInputs; i + +)
for (j = 0; j 0)
a şterge de intrare;
în cazul în care (numInputLayer> 0)
a şterge [] inputLayer;
în cazul în care (numHiddenLayer> 0)
a şterge [] hiddenLayer;

)

float XOR (float input1, float input2, float biasLower, float biasUpper)
(
float correctedInput1, correctedInput2;
în cazul în care (input1 <((biasLower + biasUpper) / 2.0f))
correctedInput1 = biasLower;
alt
correctedInput1 = biasUpper;
în cazul în care (input2 <((biasLower + biasUpper) / 2.0f))
correctedInput2 = biasLower;
alt
correctedInput2 = biasUpper;
în cazul în care (correctedInput1 == correctedInput2)
(
return (biasLower);
)
alt
(
return (biasUpper);
)
)

int main (int argc, char * argv [])
(
NN neuralNetwork (2,2,1);
cout << "Done!" <<endl;
getch ();
return 0;
)

- Crash Matrix

Followup: În urma este codul de backpropagation I folos (care, btw, nu locul de muncă).

neuralNetwork nule:: backpropagate (float-ţintă)
(
în cazul în care (numInputs == 0 | | numInputLayer == 0 | | numHiddenLayer == 0)
return;
float deltaOutput;
float * deltaHidden = new float [numHiddenLayer];
I nesemnate, J;
/ *
Reţineţi că există două iesiri utilizat aici:
1) de ieşire din stratul de curent determină valoarea delta,
2) de ieşire din neuron conectat la intrare de neuron curent este utilizat în
reajustare a greutăţii.
* /
/ / Nu primul strat de ieşire
deltaOutput = (ţintă - outputLayer.output) * outputLayer.output * (1.0f - outputLayer.output);
for (i = 0; i <numHiddenLayer; i + +)
outputLayer.weight [i] + = learnRate * deltaOutput * hiddenLayer [i]. ieşire;
/ / Acum, nu stratul de ascuns
for (j = 0; j <numHiddenLayer; j + +)
(
deltaHidden [j] = outputLayer.weight [j] * * deltaOutput
hiddenLayer [j]. ieşire * (1.0f - hiddenLayer [j]. output);
for (i = 0; i <numInputLayer; i + +)
(
hiddenLayer [j]. greutate [i] + = deltaHidden [j] * learnRate * inputLayer [i]. ieşire;
)
)
)

Şi modul în care I a alerga acesta este după cum urmează:

I nesemnate, j, k;
NN neuralNetwork (2,2,1);
pentru (k = 0; k <100000; k + +)
(
for (i = 0; i <2; i + +)
for (j = 0; j <2; j + +)
(
nn.input [0] = (float) I;
nn.input [1] = (float) J;
nn.recalc ();
nn.backpropagate (XOR ((float) i, (float), j));
în cazul în care (k == 0 | | k == 99999)
(
nn.recalc ();
cout <<i << "XOR" <<j < "<<nn.outputLayer.output <<" ar trebui "<<XOR ((float) i, (float), j) <<endl;
)
)
în cazul în care (k == 0 | | k == 99999)
cout <<endl;
)

Ştiu, eu nu stabilesc un limitator de precizie pe ea. Dar, niciodată nu ieşirile veni orice distanţă mai mică de 0.4 din 1.0 (mici si mari sunt 0.0 şi 1.0, respectiv, precum şi rezultatele nu merg in afara de 0,45 şi 0,55). Rezultatele ar trebui să se îndrepte spre 1.0 şi 0.0 (evident), dar acestea nu.
Orice ideas Ce sa întâmplat?

Ne pare rău, am avut de fapt o altă schimbare, astfel încât ajustările ascunse de greutate nu sunt întotdeauna exact la fel,
(care ar fi ca având doar o greutate ascuns)
asa ca am schimbat, de asemenea,
hiddenLayer [j]. setInput (inputLayer [i], i);
la
(
hiddenLayer [j]. setInput (inputLayer [i], i);
hiddenLayer [j]. setWeight (I, 2.0 * rand () / RAND_MAX-1);
)