Backpropagation ir C + +

Rekomendacija kolega programuotojas, aš skelbti šį klausimą čia.

Aš niekada atrodo gauti backpropagation teisę, ir kiekvieną kartą prašau pagalbos, niekas, atrodo, galės atsakyti į jų pasiūlymus ne išspręsti problemą. Taigi, aš maniau gali prašyti pagalbos iš kitos perspektyvos - mano klases be backprop algoritmas.
Ar gali kas nors man pasakyti backpropagating procedūrą, remiantis žemiau šaltinio? Man tik reikia žinoti, kaip backpropagation algoritmas dirbti mano klasėje setup (aš bando gauti darned dalykas 2 metus dabar - aiškiai aš naudojant neteisingas požiūris).

# Include
# Include
# Include

klasės neuronų
{
visuomenės:
plūduriuoti ** įvesties;
plūduriuoti * Svoris;
nepasirašytos numInputs;
Flotacinis išėjimas;
float manekeną; / / grąžinimo blogas nuorodos

Neuronų (nepasirašytas input_numInputs);
Neuron ();
negalioja atstatyti (nepasirašytas input_numInputs);
~ Neuronų ();
tuščia setInput (neuronų & n, nepasirašytos inputIndex);
tuščia setInput (float ir floatInput, nepasirašytos inputIndex);
float ir getInput (nepasirašytas inputIndex);
tuščia recalc ();
negaliojančiu setWeight (nepasirašytos inputIndex flotacinio vertė);
};

klasės neuralNetwork
{
visuomenės:
nepasirašytos numInputLayer;
nepasirašytos numHiddenLayer;
nepasirašytos numInputs;
plūduriuoti * įvesties;
Neuronų * inputLayer;
Neuronų * hiddenLayer;
Neuronų outputLayer;

neuralNetwork (nepasirašytas input_numInputs, nepasirašytos input_numInputLayer, nepasirašytos input_numHiddenLayer);
~ NeuralNetwork ();
};

plūduriuoti XOR (flotacinio input1, input2 plūdė, plūdės biasLower = 0.0f, plūdės biasUpper = 1.0f);

negaliojančiu neuronų: setWeight (nepasirašytos inputIndex flotacinio vertė)
{
jei (inputIndex> = numInputs)
grįžti;
svoris [inputIndex] = vertė;
}
tuščia neuronų: recalc ()
{
if (numInputs <= 0)
grįžti;
plūduriuoti weightedInput = 0.0f;
(nepasirašytos i = 0; i = numInputs)
grįžti;
kitas
įvesties [inputIndex] = &floatInput;
}
float ir neuronų: getInput (nepasirašytos inputIndex)
{
jei (inputIndex> = numInputs)
grįžti (netikru);
kitas
grįžti (įvesties [inputIndex] [0]);
}
Neuronų: Neuron ()
{
numInputs = 0;
}
Neuronų: Neuron (nepasirašytos input_numInputs)
{
numInputs = 0;
atstatyti (input_numInputs);
}
negalioja neuronas: atstatyti (nepasirašytos input_numInputs)
{
if (numInputs> 0)
{
Išbraukti [] įvedimo;
ištrinti [] svoris;
}
numInputs = input_numInputs;
įvesties = nauji flotacinio * [numInputs];
svoris = nauji float [numInputs];
}
Neuronų:: ~ neuronų ()
{
if (numInputs> = 0)
{
ištrinti įėjimo;
ištrinti svorio;
}
}
tuščia neuronų:: setInput (neuronų & n, nepasirašytos inputIndex)
{
jei (inputIndex> = numInputs)
grįžti;
įvesties [inputIndex] = & n.output;
}

neuralNetwork: neuralNetwork (nepasirašytas input_numInputs, nepasirašytos input_numInputLayer, nepasirašytos input_numHiddenLayer)
{
nepasirašytos i ir j;
numInputs = input_numInputs;
numHiddenLayer = input_numHiddenLayer;
numInputLayer = input_numInputLayer;
įvesties = nauji float [numInputs];
inputLayer = nauji neuronų [numInputLayer];

hiddenLayer = nauji neuronų [numHiddenLayer];
outputLayer.rebuild (numHiddenLayer);
(i = 0; i <numHiddenLayer i + +)
{
hiddenLayer [I] atstatyti (numInputLayer);
outputLayer.setInput (hiddenLayer [i], I);
}
(i = 0; i <numInputLayer i + +)
{
inputLayer [I] atstatyti (numInputs);
(j = 0; j <numHiddenLayer; j + +)
hiddenLayer [j] setInput (inputLayer [i], I);
}
for (i = 0; i <numInputs i + +)
(j = 0; j 0)
ištrinti įėjimo;
jei (numInputLayer> 0)
ištrinti [] inputLayer;
jei (numHiddenLayer> 0)
ištrinti [] hiddenLayer;

}

plūduriuoti XOR (input1 plūdė, plūdės input2, plūdė biasLower, plūdės biasUpper)
{
float correctedInput1, correctedInput2;
if (input1 <((biasLower + biasUpper) / 2.0f))
correctedInput1 = biasLower;
kitas
correctedInput1 = biasUpper;
jei (input2 <((biasLower + biasUpper) / 2.0f))
correctedInput2 = biasLower;
kitas
correctedInput2 = biasUpper;
if (correctedInput1 == correctedInput2)
{
grąža (biasLower);
}
kitas
{
grąža (biasUpper);
}
}

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

- Crash Matrica

Taip pat: Po backpropagation kodą, kurį aš naudoju (kuri, beje, ne darbo).

tuščia neuralNetwork: backpropagate (flotacinio tikslinės)
{
if (numInputs == 0 | | numInputLayer == 0 | | numHiddenLayer == 0)
grįžti;
Flotacinis deltaOutput;
plūduriuoti * deltaHidden = nauji flotacinio [numHiddenLayer];
nepasirašytos i ir j;
/ *
Atkreipkite dėmesį, kad yra du išėjimai, naudojami čia:
1) einamųjų sluoksnio produkcija lemia delta vertės,
2), prijungtas prie dabartinės neuronas įėjimo neuronų produkcija yra naudojama
persiorientavimo svorio.
* /
/ / Ar išvesties sluoksnis
deltaOutput = (tikslinė - outputLayer.output) * outputLayer.output * (1.0f - outputLayer.output);
(i = 0; i <numHiddenLayer i + +)
outputLayer.weight [I] + = learnRate * deltaOutput * hiddenLayer [i] išėjimo.
/ / Dabar padaryti paslėptą sluoksnį
(j = 0; j <numHiddenLayer; j + +)
{
deltaHidden [j] = outputLayer.weight [J] * deltaOutput *
hiddenLayer [j] produkcija * (1.0f - hiddenLayer [J] išėjimo);
(i = 0; i <numInputLayer i + +)
{
hiddenLayer [J] Svoris [i] + = deltaHidden [J] * learnRate * inputLayer [I] išėjimo..;
}
}
}

Ir kaip aš jį taip:

nepasirašytos i, j ir k;
neuralNetwork NN (2,2,1);
(k = 0, k <100000; k + +)
{
(i = 0; i <2 i + +)
(j = 0; j <2; j + +)
{
nn.input [0] = (float) I;
nn.input [1] = (float) J;
nn.recalc ();
nn.backpropagate (xor ((float), (float) j));
if (k == 0 | | k == 99.999)
{
nn.recalc ();
cout <<i <<"XOR" <<j <<<nn.outputLayer.output <<"TURĖTŲ" <<XOR ((float), (float) j) <<endl;
}
}
if (k == 0 | | k == 99.999)
cout <<endl;
}

Žinau, aš ne nustatyti tikslumo ribotuvas. Tačiau, išėjimai niekada ateina arčiau nei 0,4 iš 1,0 (žemo ir aukšto yra atitinkamai 0,0 ir 1,0 ir rezultatų niekada išeiti iš 0,45 ir 0,55). Rezultatų judėti link 1,0 ir 0,0 (žinoma), tačiau jie neturi.
Bet kokias idėjas, kas negerai?

Atsiprašome, aš iš tikrųjų turėjo kitą pakeisti taip, kad paslėpti pritaikyti svoriui, yra ne visada lygiai taip pat,
(Kuris būtų lyg tik vienas paslėptas svoris)
todėl aš taip pat pasikeitė
hiddenLayer [j] setInput (inputLayer [i], I);
į
{
hiddenLayer [j] setInput (inputLayer [i], I);
hiddenLayer [J] setWeight (i 2.0 * rand () / RAND_MAX-1);
}