Rétropropagation et C + +

Le formulaire de recommandation d'un codeur chers collègues, je vais reposter cette question ici.

Je ne peux jamais faire les choses semblent rétropropagation, et chaque fois que je demander de l'aide, personne ne semble être en mesure de répondre ou de leurs suggestions ne résolvent pas le problème. Alors, j'ai pensé que je pourrais demander de l'aide d'un autre point - mes classes sans l'algorithme backprop.
Quelqu'un peut-il me dire la procédure pour backpropagating, fondée sur la source ci-dessous? J'ai besoin seulement de savoir comment l'algorithme de rétropropagation travaillerait pour ma configuration de classe (j'ai essayé d'enfiler ce damné pour 2 ans maintenant - je suis clairement en utilisant une approche erronée).

# include
# include
# include

classe neurone
(
public:
** flotteur d'entrée;
* float weight;
unsigned numInputs;
float de sortie;
float dummy; / / pour le retour des mauvaises références

neurone (input_numInputs non signé);
neurone ();
void reconstruire (input_numInputs non signé);
~ neurone ();
void setInput (neurone & N, inputIndex non signé);
setInput void (float & floatInput, inputIndex non signé);
float & GetInput (inputIndex non signé);
void recalc ();
void setWeight (inputIndex non signé, float value);
);

classe neuralNetwork
(
public:
unsigned numInputLayer;
unsigned numHiddenLayer;
unsigned numInputs;
float * input;
* inputLayer neurone;
* hiddenLayer neurone;
neurone outputLayer;

neuralNetwork (input_numInputs non signés, input_numInputLayer non signés, input_numHiddenLayer non signé);
~ neuralNetwork ();
);

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

neurone Void:: setWeight (inputIndex non signé, float value)
(
if (inputIndex> = numInputs)
return;
poids [inputIndex] = value;
)
void neurone:: recalc ()
(
if (numInputs <= 0)
return;
float weightedInput = 0.0f;
for (unsigned i = 0; i numInputs =)
return;
autre
input [inputIndex] = &floatInput;
)
float & neurone:: GetInput (inputIndex non signé)
(
if (inputIndex> = numInputs)
return (factice);
autre
(aller-retour d'entrée [inputIndex] [0]);
)
neurone:: neurone ()
(
numInputs = 0;
)
neurone:: neurone (input_numInputs non signé)
(
numInputs = 0;
rebuild (input_numInputs);
)
neurone Void:: rebuild (input_numInputs non signé)
(
if (numInputs> 0)
(
delete [] d'entrée;
delete [] poids;
)
numInputs = input_numInputs;
input = new float * [numInputs];
= poids new float [numInputs];
)
neurone:: ~ neurone ()
(
if (numInputs> = 0)
(
supprimer d'entrée;
supprimer poids;
)
)
neurone Void:: setInput (neurone & N, inputIndex non signé)
(
if (inputIndex> = numInputs)
return;
input [inputIndex] = & n.output;
)

neuralNetwork:: neuralNetwork (input_numInputs non signés, input_numInputLayer non signés, input_numHiddenLayer non signé)
(
unsigned i, j;
numInputs = input_numInputs;
numHiddenLayer = input_numHiddenLayer;
numInputLayer = input_numInputLayer;
input = new float [numInputs];
= inputLayer de nouveaux neurones [numInputLayer];

= hiddenLayer de nouveaux neurones [numHiddenLayer];
outputLayer.rebuild (numHiddenLayer);
for (i = 0; i <numHiddenLayer; i + +)
(
hiddenLayer [i]. rebuild (numInputLayer);
(outputLayer.setInput hiddenLayer [i], i);
)
for (i = 0; i <numInputLayer; i + +)
(
inputLayer [i]. rebuild (numInputs);
for (int j = 0; j <numHiddenLayer; j + +)
hiddenLayer [j]. setInput (inputLayer [i], i);
)
for (i = 0; i <numInputs; i + +)
for (int j = 0; j 0)
supprimer d'entrée;
if (numInputLayer> 0)
delete [] inputLayer;
if (numHiddenLayer> 0)
delete [] hiddenLayer;

)

float XOR (float INPUT1, float input2, float biasLower, float biasUpper)
(
float correctedInput1, correctedInput2;
if (INPUT1 <((biasLower + biasUpper) / 2.0f))
correctedInput1 = biasLower;
autre
correctedInput1 = biasUpper;
if (input2 <((biasLower + biasUpper) / 2.0f))
correctedInput2 = biasLower;
autre
correctedInput2 = biasUpper;
if (correctedInput1 == correctedInput2)
(
return (biasLower);
)
autre
(
return (biasUpper);
)
)

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

- Crash Matrix

Followup: Voici le code rétropropagation j'utilise (qui, btw, ne fonctionne pas).

neuralNetwork Void:: backpropagate (float cible)
(
if (numInputs == 0 | | numInputLayer == 0 | | numHiddenLayer == 0)
return;
float deltaOutput;
* float deltaHidden = new float [numHiddenLayer];
unsigned i, j;
/ *
Notez qu'il existe deux produits utilisés ici:
1) La sortie de la couche de courant détermine la valeur du delta,
2) La sortie du neurone connecté à l'entrée du neurone en cours est utilisé dans
réajustement du poids.
* /
/ / Ne la couche première sortie
deltaOutput = (cible - outputLayer.output) * outputLayer.output * (1.0f - outputLayer.output);
for (i = 0; i <numHiddenLayer; i + +)
outputLayer.weight [i] + = learnRate * deltaOutput * hiddenLayer [i]. production;
/ / Faites maintenant la couche cachée
for (int j = 0; j <numHiddenLayer; j + +)
(
deltaHidden [j] = outputLayer.weight [j] * deltaOutput *
hiddenLayer [j]. sortie * (1.0f - hiddenLayer [j]. output);
for (i = 0; i <numInputLayer; i + +)
(
hiddenLayer [j]. poids [i] + = deltaHidden [j] * learnRate * inputLayer [i]. production;
)
)
)

Et la façon dont je dirige, il est comme suit:

unsigned i, j, k;
neuralNetwork NN (2,2,1);
for (int k = 0; k <100000; k + +)
(
for (i = 0; i <2; i + +)
for (int 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 <<" doit être "<<XOR ((float) i, (float) j) <<endl;
)
)
if (k == 0 | | k == 99999)
cout <<endl;
)

Je sais, je ne fixent pas de limiteur de précision à ce sujet. Mais, les résultats ne viennent jamais plus près de 0,4 out of 1.0 (la basse et haute sont respectivement 0,0 et 1,0 et les sorties ne jamais aller à l'extérieur de 0.45 et 0.55). Les sorties devraient s'orienter vers 1.0 et 0.0 (évidemment), mais ils n'en ont pas.
Toute idées what's wrong?

Désolé, j'ai effectivement eu un autre changement afin que les ajustements de poids cachés ne sont pas toujours exactement les mêmes,
(ce qui serait comme avoir un seul poids caché)
alors j'ai aussi changé
hiddenLayer [j]. setInput (inputLayer [i], i);
à
(
hiddenLayer [j]. setInput (inputLayer [i], i);
hiddenLayer [j]. setWeight (i, 2.0 * rand () / RAND_MAX-1);
)