Backpropagation og C + +

På anbefaling danne en fyr coder, jeg genindplacering dette spørgsmål her.

Jeg kan aldrig synes at få backpropagation højre, og hver gang jeg beder om hjælp, ingen synes at være i stand til at besvare eller deres forslag ikke løser problemet. Så jeg tænkte jeg måtte bede om hjælp fra et andet punkt - mine klasser uden backprop algoritme.
Kan nogen fortælle mig proceduren for backpropagating, baseret på kilden nedenfor? Jeg har bare brug for at vide, hvordan backpropagation algoritmen ville arbejde for min klasse setup (jeg har prøvet at få den stoppede noget i 2 år nu - klart jeg bruger en forkert metode).

# Include
# Include
# Include

klasse neuron
{
public:
float ** input;
float * vægt;
unsigned numInputs;
float output;
float dummy / / for at returnere dårlige referencer

neuron (unsigned input_numInputs);
neuron ();
void genopbygge (usignerede input_numInputs);
~ Neuron ();
void setInput (neuron & N, usigneret inputIndex);
void setInput (float & floatInput, usigneret inputIndex);
float & getInput (unsigned inputIndex);
void recalc ();
void lndstilVaegt (usignerede inputIndex, float værdi);
};

klasse neuralNetwork
{
public:
unsigned numInputLayer;
unsigned numHiddenLayer;
unsigned numInputs;
float * input;
neuron * inputLayer;
neuron * hiddenLayer;
neuron outputLayer;

neuralNetwork (usignerede input_numInputs, usigneret input_numInputLayer, usigneret input_numHiddenLayer);
~ NeuralNetwork ();
};

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

void neuron:: lndstilVaegt (unsigned inputIndex, float værdi)
{
if (inputIndex> = numInputs)
vende tilbage;
vægt [inputIndex] = værdi;
}
void neuron:: recalc ()
{
if (numInputs <= 0)
vende tilbage;
float weightedInput = 0.0f;
for (usignerede i = 0; i = numInputs)
vende tilbage;
andet
input [inputIndex] = &floatInput;
}
float & neuron:: getInput (unsigned inputIndex)
{
if (inputIndex> = numInputs)
afkast (dummy);
andet
return (indgang [inputIndex] [0]);
}
neuron:: neuron ()
{
numInputs = 0;
}
neuron:: neuron (unsigned input_numInputs)
{
numInputs = 0;
genopbygge (input_numInputs);
}
void neuron:: genopbygge (unsigned input_numInputs)
{
if (numInputs> 0)
{
slette [] input;
slette [] vægt;
}
numInputs = input_numInputs;
input = new float * [numInputs];
Vægt = nye float [numInputs];
}
neuron:: ~ neuron ()
{
if (numInputs> = 0)
{
slet input;
slet vægt;
}
}
void neuron:: setInput (neuron & N, usigneret inputIndex)
{
if (inputIndex> = numInputs)
vende tilbage;
input [inputIndex] = & n.output;
}

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

hiddenLayer = ny neuron [numHiddenLayer];
outputLayer.rebuild (numHiddenLayer);
for (i = 0; i <numHiddenLayer; i + +)
{
hiddenLayer [i] genopbygge (numInputLayer).
outputLayer.setInput (hiddenLayer [i], i);
}
for (i = 0; i <numInputLayer; i + +)
{
inputLayer [i] genopbygge (numInputs).
for (j = 0; j <numHiddenLayer j + +)
hiddenLayer [j] setInput (inputLayer [i], i).
}
for (i = 0; i <numInputs; i + +)
for (j = 0; j 0)
slet input;
if (numInputLayer> 0)
slette [] inputLayer;
if (numHiddenLayer> 0)
slette [] hiddenLayer;

}

float XOR (float Input1, float INPUT2, float biasLower, float biasUpper)
{
float correctedInput1, correctedInput2;
if (Input1 <((biasLower + biasUpper) / 2.0F))
correctedInput1 = biasLower;
andet
correctedInput1 = biasUpper;
if (INPUT2 <((biasLower + biasUpper) / 2.0F))
correctedInput2 = biasLower;
andet
correctedInput2 = biasUpper;
if (correctedInput1 == correctedInput2)
{
afkast (biasLower);
}
andet
{
afkast (biasUpper);
}
}

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

- Crash Matrix

Opfølgning: Efter den backpropagation koden jeg bruger (som, BTW, virker ikke).

void neuralNetwork:: backpropagate (float mål)
{
if (numInputs == 0 | | numInputLayer == 0 | | numHiddenLayer == 0)
vende tilbage;
float deltaOutput;
float * deltaHidden = new float [numHiddenLayer];
usignerede i, j;
/ *
Bemærk, at der er to udgange bruges her:
1) Resultaterne af de aktuelle lag bestemmer delta-værdi,
2) Resultaterne af de neuron er forbundet til indgangen på den aktuelle neuron bruges i
justering af vægten.
* /
/ / Gør output lag first
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 skjulte lag
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] vægt [i] + = deltaHidden [j] * learnRate * inputLayer [i] output..;
}
}
}

Og den måde, jeg køre det er som følger:

usignerede 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;
}

Jeg ved, jeg ikke sætte en præcision limiter på det. Men udgangene aldrig komme nogen nærmere end 0,4 ud af 1,0 (de lave og høje er 0,0 og 1,0 hhv og udgange aldrig gå udenfor på 0,45 og 0,55). Udgangene bør bevæge sig i retning af 1,0 og 0,0 (selvfølgelig), men de gør ikke.
Nogen ideer hvad er der galt?

Undskyld, jeg havde faktisk endnu en ændring, således at den skjulte vægten justeringer er ikke altid nøjagtig det samme,
(Hvilket ville være som at have kun ét skjult vægt)
så jeg også ændret
hiddenLayer [j] setInput (inputLayer [i], i).
til
{
hiddenLayer [j] setInput (inputLayer [i], i).
. hiddenLayer [j] lndstilVaegt (i, 2,0 * rand () / RAND_MAX-1);
}