Backpropagation e C + +

Em forma de recomendação de um codificador de colegas, estou reposting esta pergunta aqui.

Eu nunca consigo ter direito backpropagation, e cada vez que eu pedir ajuda, ninguém parece ser capaz de responder ou as suas sugestões não resolverem o problema. Então, eu pensei que eu poderia pedir a ajuda de um ponto diferente - as minhas aulas sem o algoritmo backprop.
Alguém pode me dizer o processo de backpropagating, com base na fonte abaixo? Eu só preciso saber como o algoritmo de retropropagação iria trabalhar para a minha configuração de classe (Estive a tentar obter a coisa enervante para 2 anos - claro que estou usando a abordagem errada).

# include
# include
# include

neurônio classe
(
público:
entrada float **;
float * peso;
numInputs unsigned;
float resultado;
float dummy; / / para retornar referências ruim

neurônio (input_numInputs unsigned);
neurônio ();
void reconstruir (input_numInputs unsigned);
~ neurônio ();
SetInput void (neurônio & N, inputIndex unsigned);
SetInput void (float & floatInput, inputIndex unsigned);
float & getInput (inputIndex unsigned);
recalc void ();
setWeight void inputIndex (unsigned, float value);
);

neuralNetwork classe
(
público:
numInputLayer unsigned;
numHiddenLayer unsigned;
numInputs unsigned;
entrada float *;
neurônio * inputLayer;
neurônio * hiddenLayer;
outputLayer neurônio;

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

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

neurônio nulos:: setWeight (inputIndex unsigned, float valor)
(
if (inputIndex> = numInputs)
return;
peso [inputIndex] = valor;
)
neurônio nulos:: recalc ()
(
if (numInputs <= 0)
return;
float weightedInput = 0.0f;
for (unsigned i = 0; numInputs i =)
return;
diferente
input [inputIndex] = &floatInput;
)
float & neurônio:: getInput (inputIndex unsigned)
(
if (inputIndex> = numInputs)
return (dummy);
diferente
input ([inputIndex] [0]);
)
neurônio: neurônios ()
(
numInputs = 0;
)
neurônio: neurônios (input_numInputs unsigned)
(
numInputs = 0;
reconstruir (input_numInputs);
)
neurônio nulos:: reconstruir (input_numInputs unsigned)
(
if (numInputs> 0)
(
delete [input];
delete [peso];
)
numInputs = input_numInputs;
entrada = new float * [numInputs];
float peso = new [numInputs];
)
neurônio:: ~ neurônio ()
(
if (numInputs> = 0)
(
delete input;
eliminar peso;
)
)
neurônio nulos:: SetInput (neurônio & N, inputIndex unsigned)
(
if (inputIndex> = numInputs)
return;
input [inputIndex] = & n.output;
)

neuralNetwork:: neuralNetwork (input_numInputs unsigned, unsigned input_numInputLayer, input_numHiddenLayer unsigned)
(
unsigned i, j;
numInputs = input_numInputs;
numHiddenLayer = input_numHiddenLayer;
numInputLayer = input_numInputLayer;
entrada = new float [numInputs];
neurônio inputLayer = new [numInputLayer];

neurônio hiddenLayer = new [numHiddenLayer];
outputLayer.rebuild (numHiddenLayer);
for (numHiddenLayer i = 0; i <, i + +)
(
hiddenLayer [i]. reconstruir (numInputLayer);
hiddenLayer outputLayer.setInput ([i], i);
)
for (numInputLayer i = 0; i <, i + +)
(
inputLayer [i]. reconstruir (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 (float input1, float input2, biasLower float, float biasUpper)
(
float correctedInput1, correctedInput2;
if (input1 <((biasLower + biasUpper) / 2.0f))
correctedInput1 biasLower =;
diferente
correctedInput1 biasUpper =;
if (input2 <((biasLower + biasUpper) / 2.0f))
correctedInput2 biasLower =;
diferente
correctedInput2 biasUpper =;
if (correctedInput1 == correctedInput2)
(
return (biasLower);
)
diferente
(
return (biasUpper);
)
)

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

- Bater Matrix

Followup: Este é o código backpropagation eu uso (que, btw, não funciona).

neuralNetwork nulos:: backpropagate (float alvo)
(
if (numInputs == 0 | | numInputLayer == 0 | | numHiddenLayer == 0)
return;
float deltaOutput;
float * deltaHidden = new float [numHiddenLayer];
unsigned i, j;
/ *
Note que existem duas saídas utilizadas aqui:
1) A saída da camada atual determina o valor do delta,
2) A saída do neurônio conectado à entrada do neurônio atual é usado em
reajuste do peso.
* /
/ / Do a primeira camada de saída
deltaOutput = (alvo - outputLayer.output) * outputLayer.output * (1.0f - outputLayer.output);
for (numHiddenLayer i = 0; i <, i + +)
outputLayer.weight [i] + = learnRate * deltaOutput hiddenLayer * [i]. output;
/ / Agora faça a camada escondida
for (j = 0; j <numHiddenLayer; j + +)
(
deltaHidden [j] = outputLayer.weight [j] * * deltaOutput
hiddenLayer [j]. saída * (1.0f - hiddenLayer [j]. output);
for (numInputLayer i = 0; i <, i + +)
(
hiddenLayer [j]. peso [i] + = deltaHidden [j] * learnRate * inputLayer [i] de saída.;
)
)
)

E do jeito que eu executá-lo é a seguinte:

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

Eu sei, eu não definir um limitador de precisão sobre ele. Mas, nunca as saídas se aproxime a menos 0,4 por 1,0 (a baixa e alta são 0,0 e 1,0, respectivamente, e as saídas de nunca sair de 0,45 e 0,55). As saídas devem mover-se para 1,0 e 0,0 (obviamente), mas eles não.
Any ideas what's wrong?

Desculpe, eu realmente tive uma outra mudança de forma que os ajustes de peso escondido nem sempre são exatamente o mesmo,
(o que seria como ter um peso de apenas oculto)
então eu também mudou
hiddenLayer [j]. SetInput (inputLayer [i], i);
para
(
hiddenLayer [j]. SetInput (inputLayer [i], i);
hiddenLayer [j]. setWeight (i, 2,0 * rand () / RAND_MAX-1);
)