Backpropagation e C + +

En forma de recomendación dun codificador de colegas, estou reposting esta pregunta aquí.

Eu nunca podo ter dereito backpropagation, e cada vez que podo pedir axuda, ninguén parece ser capaz de responder ou as súas suxestións non resolver o problema. Entón, eu penso que eu podería pedir a axuda de un punto diferente - as miñas clases sen o algoritmo backprop.
Alguén me pode dicir o proceso de backpropagating, con base na fonte de abaixo? Eu só preciso saber como o algoritmo de retropropagação iría traballar para a miña configuración de clase (estiven a tentar obter a cousa enervante para 2 anos - claro que está a usar a visión errónea).

# Include
# Include
# Include

neurona clase
(
público:
entrada float **;
float * peso;
numInputs unsigned;
float resultado;
float dummy; / / para voltar referencias malo

neurona (input_numInputs unsigned);
neurona ();
void reconstruír (input_numInputs unsigned);
~ Neurona ();
SetInput void (neurona & N, inputIndex unsigned);
SetInput void (float & floatInput, inputIndex unsigned);
float & getInput (inputIndex unsigned);
recalc void ();
setWeight void inputIndex (unsigned, float value);
);

neuralNetwork clase
(
público:
numInputLayer unsigned;
numHiddenLayer unsigned;
numInputs unsigned;
entrada float *;
neurona * inputLayer;
neurona * hiddenLayer;
outputLayer neurona;

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);

neurona nulos:: setWeight (inputIndex unsigned, float valor)
(
if (inputIndex> = numInputs)
return;
peso [inputIndex] = valor;
)
neurona nulos:: recalc ()
(
if (numInputs <= 0)
return;
float weightedInput = 0.0f;
for (unsigned i = 0; numInputs i =)
return;
diferente
input [inputIndex] = &floatInput;
)
float & neurona:: getInput (inputIndex unsigned)
(
if (inputIndex> = numInputs)
return (dummy);
diferente
input ([inputIndex] [0]);
)
neurona: neuronas ()
(
numInputs = 0;
)
neurona: neuronas (input_numInputs unsigned)
(
numInputs = 0;
reconstruír (input_numInputs);
)
neurona nulos:: reconstruír (input_numInputs unsigned)
(
if (numInputs> 0)
(
delete [input];
delete [peso];
)
numInputs = input_numInputs;
entrada = new float * [numInputs];
float peso = new [numInputs];
)
neurona:: ~ neurona ()
(
if (numInputs> = 0)
(
delete entrada;
eliminar peso;
)
)
neurona nulos:: SetInput (neurona & 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];
neurona inputLayer = new [numInputLayer];

neurona hiddenLayer = new [numHiddenLayer];
outputLayer.rebuild (numHiddenLayer);
for (numHiddenLayer i = 0, i <, i + +)
(
hiddenLayer [i]. reconstruír (numInputLayer);
hiddenLayer outputLayer.setInput ([i], i);
)
for (numInputLayer i = 0, i <, i + +)
(
inputLayer [i]. reconstruír (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 entrada;
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);
couto << "Done!" <<ENDL;
getch ();
return 0;
)

- Bater Matrix

Seguimento: Este é o código backpropagation eu uso (que, btw, non funciona).

neuralNetwork nulos:: backpropagate (float branco)
(
if (numInputs == 0 | | numInputLayer == 0 | | numHiddenLayer == 0)
return;
float deltaOutput;
float * deltaHidden = new float [numHiddenLayer];
unsigned i, j;
/ *
Teña en conta que hai dúas saídas empregadas aquí:
1) A saída da capa actual determina o valor do delta,
2) A saída da neurona conectado á entrada da neurona actual é usado en
reajuste de peso.
* /
/ / Dende a primeira capa de saída
deltaOutput = (destino - outputLayer.output) * outputLayer.output * (1.0f - outputLayer.output);
for (numHiddenLayer i = 0, i <, i + +)
outputLayer.weight [i] + = learnRate * deltaOutput hiddenLayer * [i]. saída;
/ / Agora fai a capa agochada
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 xeito que eu executalo é 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 ();
couto <<i << "XOR" <<j <<<nn.outputLayer.output << "debe ser" <<XOR ((float) i, (float) j) <<ENDL;
)
)
if (k == 0 | | k == 99999)
couto <<ENDL;
)

Eu sei, eu non establecer un límite de precisión sobre el. Pero, nunca as saídas se achegue a menos 0,4 por 1,0 (a baixe e alta son 0,0 e 1,0, respectivamente, e as saídas de nunca sair de 0,45 e 0,55). As saídas deben moverse a 1,0 e 0,0 (obviamente), pero eles non.
Any ideas what's wrong?

Sentímolo, realmente tivo outra cambio de forma que os axustes de peso escondidos non sempre son exactamente o mesmo,
(o que sería como ter un peso de só oculto)
entón eu tamén cambiou
hiddenLayer [j]. SetInput (inputLayer [i], i);
a
(
hiddenLayer [j]. SetInput (inputLayer [i], i);
hiddenLayer [j]. setWeight (i, 2,0 * rand () / RAND_MAX-1);
)