Backpropagation och C + +

På rekommendation utgör en karl kodare, jag remailing denna fråga här.

Jag kan aldrig verkar få backpropagation rätt, och varje gång jag ber om hjälp, tycks ingen kunna svara eller deras förslag inte löser problemet. Så tänkte jag be om hjälp från en annan punkt - mina klasser utan backprop algoritm.
Kan någon berätta för mig förfarandet för backpropagating, baserat på källan nedan? Jag bara måste veta hur det backpropagation algoritm skulle fungera för min klass setup (Jag har försökt att få förbaskad sak för 2 år nu - klart jag använder fel metod).

# include
# include
# include

klass neuron
(
public:
float ** input;
float * weight;
unsigned numInputs;
float output;
float dummy; / / för återvändande dåliga referenser

neuron (unsigned input_numInputs);
neuron ();
void återuppbygga (unsigned input_numInputs);
~ neuron ();
void setInput (neuron & N, unsigned inputIndex);
void setInput (float & floatInput, unsigned inputIndex);
float & getInput (unsigned inputIndex);
void räkna om ();
void setWeight (unsigned inputIndex, float value);
);

klass neuralNetwork
(
public:
unsigned numInputLayer;
unsigned numHiddenLayer;
unsigned numInputs;
float * input;
neuron * inputLayer;
neuron * hiddenLayer;
neuron outputLayer;

neuralNetwork (unsigned input_numInputs, unsigned input_numInputLayer, unsigned input_numHiddenLayer);
~ neuralNetwork ();
);

float XOR (float INPUT1, float INPUT2, float biasLower = 0.0f, float biasUpper = 1.0f);

void neuron: setWeight (unsigned inputIndex, float värde)
(
if (inputIndex> = numInputs)
return;
Vikt [inputIndex] = value;
)
void neuron: räkna om ()
(
if (numInputs <= 0)
return;
float weightedInput = 0.0f;
for (unsigned i = 0; i = numInputs)
return;
annan
input [inputIndex] = &floatInput;
)
float & neuron: getInput (unsigned inputIndex)
(
if (inputIndex> = numInputs)
return (dummy);
annan
return (input [inputIndex] [0]);
)
neuron:: neuron ()
(
numInputs = 0;
)
neuron:: neuron (unsigned input_numInputs)
(
numInputs = 0;
återuppbygga (input_numInputs);
)
void neuron: återuppbygga (unsigned input_numInputs)
(
if (numInputs> 0)
(
ta bort [] input;
ta bort [] vikt;
)
numInputs = input_numInputs;
input = new float * [numInputs];
vikt = new float [numInputs];
)
neuron:: ~ neuron ()
(
if (numInputs> = 0)
(
bort input;
bort vikt;
)
)
void neuron: setInput (neuron & N, unsigned inputIndex)
(
if (inputIndex> = numInputs)
return;
input [inputIndex] = & n.output;
)

neuralNetwork:: neuralNetwork (unsigned input_numInputs, unsigned input_numInputLayer, unsigned input_numHiddenLayer)
(
unsigned i, j;
numInputs = input_numInputs;
numHiddenLayer = input_numHiddenLayer;
numInputLayer = input_numInputLayer;
input = new float [numInputs];
inputLayer = nya neuron [numInputLayer];

hiddenLayer = nya neuron [numHiddenLayer];
outputLayer.rebuild (numHiddenLayer);
for (i = 0; i <numHiddenLayer, i + +)
(
hiddenLayer [i]. återuppbygga (numInputLayer);
outputLayer.setInput (hiddenLayer [i], i);
)
for (i = 0; i <numInputLayer, i + +)
(
inputLayer [i]. återuppbygga (numInputs);
for (j = 0; j <numHiddenLayer j + +)
hiddenLayer [j]. setInput (inputLayer [i], i);
)
for (i = 0; i <numInputs, i + +)
for (j = 0; j 0)
bort input;
if (numInputLayer> 0)
ta bort [] inputLayer;
if (numHiddenLayer> 0)
ta bort [] hiddenLayer;

)

float XOR (float INPUT1, float INGÅNG2, float biasLower, float biasUpper)
(
float correctedInput1, correctedInput2;
if (INPUT1 <((biasLower + biasUpper) / 2.0F))
correctedInput1 = biasLower;
annan
correctedInput1 = biasUpper;
if (INGÅNG2 <((biasLower + biasUpper) / 2.0F))
correctedInput2 = biasLower;
annan
correctedInput2 = biasUpper;
if (correctedInput1 == correctedInput2)
(
return (biasLower);
)
annan
(
return (biasUpper);
)
)

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

- Crash Matrix

Uppföljning: Följande är backpropagation koden jag använder (vilket, btw, fungerar inte).

void neuralNetwork:: backpropagate (float target)
(
if (numInputs == 0 | | numInputLayer == 0 | | numHiddenLayer == 0)
return;
float deltaOutput;
float * deltaHidden = new float [numHiddenLayer];
unsigned i, j;
/ *
Observera att det finns två utgångar används här:
1) Resultatet av den aktuella nivån bestämmer delta värde,
2) Resultatet av neuron ansluten till ingången av den nuvarande neuron används i
justering av vikten.
* /
/ / Do utdata lager första
deltaOutput = (target - outputLayer.output) * outputLayer.output * (1.0f - outputLayer.output);
for (i = 0; i <numHiddenLayer, i + +)
outputLayer.weight [i] + = learnRate * deltaOutput * hiddenLayer [i]. output;
/ / Nu gör de dolda lager
for (j = 0; j <numHiddenLayer j + +)
(
deltaHidden [j] = outputLayer.weight [j] * deltaOutput *
hiddenLayer [j]. output * (1.0f - hiddenLayer [j]. output);
for (i = 0; i <numInputLayer, i + +)
(
hiddenLayer [j]. vikt [i] + = deltaHidden [j] * learnRate * inputLayer [i]. output;
)
)
)

Och hur jag köra det är följande:

unsigned I, J, K;
neuralNetwork NN (2,2,1);
for (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));
if (k == 0 | | k == 99999)
(
nn.recalc ();
cout <<i << "XOR" <<j < "<<nn.outputLayer.output <<" bör "<<XOR ((float) I, (float) j) <<endl;
)
)
if (k == 0 | | k == 99999)
cout <<endl;
)

Jag vet, jag inte sätter en precision limiter på det. Men resultaten aldrig komma närmare än 0,4 av 1,0 (de låga och höga är 0,0 och 1,0 respektive och utgångarna aldrig gå utomhus på 0,45 och 0,55). Utgångarna ska gå mot 1,0 och 0,0 (uppenbarligen), men de ser inte.
Any ideas what's wrong?

Tyvärr hade jag faktiskt en förändring så att de dolda vikt justeringar är inte alltid exakt samma,
(som skulle vilja ha bara en dold vikt)
så jag också ändrat
hiddenLayer [j]. setInput (inputLayer [i], i);
till
(
hiddenLayer [j]. setInput (inputLayer [i], i);
hiddenLayer [j]. setWeight (I, 2.0 * rand () / RAND_MAX-1);
)