Backpropagation és C + +

Szóló ajánlás formájában egy fickó coder vagyok reposting ezt a kérdést itt.

Nem is tudom látszik-hoz kap backpropagation jobbra, és minden alkalommal, amikor segítséget kérni, senki nem tud válaszolni, vagy azok javaslatok nem oldja meg a problémát. Szóval, azt hittem, talán kérhetek segítséget egy másik kérdés - órákon nélkül backprop algoritmust.
Tud akárki mondja meg az eljárást backpropagating alapuló, a forrás alatt? Én csak azt kell tudni, hogy az algoritmus backpropagation fog dolgozni az osztályomban setup (Ive 'kipróbálás-hoz kap a darned dolog 2 éve - jól vagyok használ a rossz megközelítés).

: # include
: # include
: # include

neuront osztály
(
public:
float ** bemenet;
float * súly;
unsigned numInputs;
float output;
float dummy / / a visszatérő rossz referenciák

neuron (unsigned input_numInputs);
neuron ();
void rebuild (unsigned input_numInputs);
~ neuron ();
void setInput (neuron & n, unsigned inputIndex);
void setInput (float & floatInput, unsigned inputIndex);
float & getInput (unsigned inputIndex);
void újrasz ();
void setWeight (unsigned inputIndex, float value);
);

osztály 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 ();
);

XOR float (lebegőpontos input1, float INPUT2, úsztatott biasLower = 0.0f, float biasUpper = 1.0f);

void neuron:: setWeight (unsigned inputIndex, lebegőpontos érték)
(
if (inputIndex> = numInputs)
return;
súly [inputIndex] = érték;
)
void neuron:: újrasz ()
(
if (numInputs <= 0)
return;
float weightedInput = 0.0f;
for (unsigned i = 0, i = numInputs)
return;
vagy
input [inputIndex] = &floatInput;
)
float & neuron: getInput (unsigned inputIndex)
(
if (inputIndex> = numInputs)
return (dummy);
vagy
return (input [inputIndex] [0]);
)
neuron:: neuron ()
(
numInputs = 0;
)
neuron: idegsejt (unsigned input_numInputs)
(
numInputs = 0;
rebuild (input_numInputs);
)
void neuron:: újjáépíteni (unsigned input_numInputs)
(
if (numInputs> 0)
(
delete [] input;
delete [] tömeg;
)
numInputs = input_numInputs;
input = new float * [numInputs];
súly = new float [numInputs];
)
neuron:: ~ neuron ()
(
if (numInputs> = 0)
(
delete input;
delete súly;
)
)
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 = new neuron [numInputLayer];

hiddenLayer = new neuron [numHiddenLayer];
outputLayer.rebuild (numHiddenLayer);
for (i = 0; i <numHiddenLayer; i + +)
(
hiddenLayer [i]. újjáépíteni (numInputLayer);
outputLayer.setInput (hiddenLayer [i], i);
)
for (i = 0; i <numInputLayer; i + +)
(
inputLayer [i]. újjáépíteni (numInputs);
for (j = 0; j <numHiddenLayer j + +)
hiddenLayer [j]. setInput (inputLayer [i], i);
)
for (i = 0; i <numInputs; i + +)
for (j = 0 j 0)
delete input;
if (numInputLayer> 0)
delete [] inputLayer;
if (numHiddenLayer> 0)
delete [] hiddenLayer;

)

XOR float (lebegőpontos input1, float INPUT2, float biasLower, úsztatott biasUpper)
(
float correctedInput1, correctedInput2;
if (input1 <((biasLower + biasUpper) / 2.0f))
correctedInput1 = biasLower;
vagy
correctedInput1 = biasUpper;
if (INPUT2 <((biasLower + biasUpper) / 2.0f))
correctedInput2 = biasLower;
vagy
correctedInput2 = biasUpper;
if (correctedInput1 == correctedInput2)
(
return (biasLower);
)
vagy
(
return (biasUpper);
)
)

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

- Crash Matrix

Válaszcikk-csoport: Az alábbiakban a backpropagation kód, amit használni (ami btw, nem működik).

void neuralNetwork:: backpropagate (float cél)
(
if (numInputs == 0 | | numInputLayer == 0 | | numHiddenLayer == 0)
return;
float deltaOutput;
float * deltaHidden = new float [numHiddenLayer];
unsigned i, j;
/ *
Ne feledjük, hogy az itt használt két kimenet:
1) A kimenet az aktuális réteg határozza meg a delta érték,
2) A kimenet a neuron kapcsolódik a bemeneti a jelenlegi neuron használják
újrafelosztása a súlyát.
* /
/ / Do a kimeneti réteg első
deltaOutput = (target - outputLayer.output) * outputLayer.output * (1.0f - outputLayer.output);
for (i = 0; i <numHiddenLayer; i + +)
outputLayer.weight [i] + = learnRate * deltaOutput * hiddenLayer [i]. kimenet;
/ / Most már a rejtett réteg
for (j = 0; j <numHiddenLayer j + +)
(
deltaHidden [j] = outputLayer.weight [j] * deltaOutput *
hiddenLayer [j]. kimenet * (1.0f - hiddenLayer [j]. output);
for (i = 0; i <numInputLayer; i + +)
(
hiddenLayer [j]. súly [i] + = deltaHidden [j] * learnRate * inputLayer [i]. kimenet;
)
)
)

És ahogy én futtassa a következő:

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 <<" legyen "<<XOR ((float) i, (float) j) <<endl;
)
)
if (k == 0 | | k == 99999)
cout <<endl;
)

Tudom, nem állítok precíziós limiter rajta. De, a kimenet nem jön közelebb, mint 0,4-ből 1,0 (alacsony és magas a 0,0 és 1,0, illetve a kimenetek és soha nem megy kívüli 0,45 és 0,55). A kimenetek kellene elmozdulni 1,0 és 0,0 (természetesen), de nem.
Van ötleted, mi a baj?

Elnézést, de tulajdonképpen már egy másik változás, hogy a rejtett tömeg kiigazítások nem mindig pontosan ugyanaz,
(ami lehet, mintha csak egy rejtett súly)
így én is megváltozott
hiddenLayer [j]. setInput (inputLayer [i], i);
hogy
(
hiddenLayer [j]. setInput (inputLayer [i], i);
hiddenLayer [j]. setWeight (i, 2,0 * rand () / RAND_MAX-1);
)