Backpropagation и C + +

По препоръка на колега програмист, аз съм reposting на този въпрос тук.

Никога не мога да изглежда да получите backpropagation право, и всеки път, когато помолите за помощ, никой не изглежда да бъде в състояние да отговори или техните предложения не реши проблема. Така че, аз мислех, че може да поиска помощ от различна точка - моите класове без backprop алгоритъм.
Може ли някой да ми кажете процедурата за backpropagating, въз основа на източник под? Аз просто трябва да се знае как алгоритъм backpropagation ще работи за моя клас настройка съм се опитва да получи мелодийките нещо за 2 години сега - ясно съм с погрешен подход.

# Включват
# Включват
# Включват

клас неврон
{
обществеността:
плувка ** вход;
поплавък * тегло;
неподписани numInputs;
плувка изход;
плувка манекен / / за връщане лошо препратки

неврон (неподписана input_numInputs);
неврон ();
невалидни възстановяване (неподписана input_numInputs);
~ Неврон ();
невалидни setInput (неврон & N, неподписани inputIndex);
невалидни setInput (плувка и floatInput, неподписани inputIndex);
плувка и getInput (неподписана inputIndex);
невалидни recalc ();
невалидни setWeight (грозен inputIndex стойност с плаваща запетая);
};

клас neuralNetwork
{
обществеността:
неподписани numInputLayer;
неподписани numHiddenLayer;
неподписани numInputs;
поплавък * вход;
неврон * inputLayer;
неврон * hiddenLayer;
неврон outputLayer;

neuralNetwork (неподписани input_numInputs, неподписани input_numInputLayer, неподписани input_numHiddenLayer);
~ NeuralNetwork ();
};

плувка XOR (плувка input1, плувка INPUT2, флоат biasLower = 0.0f, плувка biasUpper = 1.0f);

неврон за невалидни:: setWeight (грозен inputIndex стойност с плаваща запетая)
{
ако (inputIndex> = numInputs)
връщане;
тегло [inputIndex] = стойност;
}
невалидни неврон:: recalc ()
{
ако (numInputs <= 0)
връщане;
плувка weightedInput = 0.0f;
(неподписан I = 0; I = numInputs)
връщане;
друг
вход [inputIndex] = &floatInput;
}
плувка неврон:: getInput (неподписан inputIndex)
{
ако (inputIndex> = numInputs)
връщане (сляпо);
друг
връщане (въвеждане [inputIndex] [0]);
}
неврон:: неврон ()
{
numInputs = 0;
}
неврон: неврон (неподписан input_numInputs)
{
numInputs = 0;
възстановяване (input_numInputs);
}
невалидни неврон: възстановяване (неподписан input_numInputs)
{
ако (numInputs> 0)
{
Изтрий от [] вход;
изтриване [] тегло;
}
numInputs = input_numInputs;
вход = нов поплавък * [numInputs];
тегло = нови плувка numInputs];
}
неврон:: ~ неврон ()
{
ако (numInputs> = 0)
{
изтриете вход;
Изтриване на тегло;
}
}
невалидни неврон:: setInput (неврон & N, неподписани inputIndex)
{
ако (inputIndex> = numInputs)
връщане;
входящ [inputIndex] = & n.output;
}

neuralNetwork: neuralNetwork (неподписани input_numInputs, неподписани input_numInputLayer, неподписани input_numHiddenLayer)
{
неподписани и, к;
numInputs = input_numInputs;
numHiddenLayer = input_numHiddenLayer;
numInputLayer = input_numInputLayer;
вход = нови плувка [numInputs];
inputLayer = нови неврон [numInputLayer];

hiddenLayer = нови неврон [numHiddenLayer];
outputLayer.rebuild (numHiddenLayer);
(I = 0; и <numHiddenLayer; I + +)
{
hiddenLayer [I] възстановяване (numInputLayer).
outputLayer.setInput (hiddenLayer [I], I);
}
(I = 0; и <numInputLayer; I + +)
{
inputLayer [I] възстановяване (numInputs).
(J = 0; J <numHiddenLayer; J + +)
hiddenLayer [к] setInput (inputLayer [I], I).
}
(I = 0; и <numInputs I + +)
(J = 0; J 0)
изтриете вход;
ако (numInputLayer> 0)
изтриване [] inputLayer;
ако (numHiddenLayer> 0)
изтриване [] hiddenLayer;

}

плувка XOR (плувка input1, поплавък INPUT2, плуващ biasLower, плувка biasUpper)
{
поплавък correctedInput1, correctedInput2;
ако (input1 <((biasLower + biasUpper) / 2.0f))
correctedInput1 = biasLower;
друг
correctedInput1 = biasUpper;
ако (INPUT2 <((biasLower + biasUpper) / 2.0f))
correctedInput2 = biasLower;
друг
correctedInput2 = biasUpper;
(correctedInput1 == correctedInput2)
{
връщане (biasLower);
}
друг
{
връщане (biasUpper);
}
}

INT Основните (INT argc, Чар * argv [])
{
neuralNetwork Н.Н. (2,2,1);
<<"Готово!" <<endl;
getch ();
връщането на 0;
}

- Crash Matrix

В отговор: След backpropagation код, аз използвам (което, между другото, не работи).

невалидни neuralNetwork: backpropagate (плувка целеви)
{
(numInputs == 0 | | numInputLayer == 0 | | numHiddenLayer == 0)
връщане;
плувка deltaOutput;
поплавък * deltaHidden = нови плувка [numHiddenLayer];
неподписани и, к;
/ *
Имайте предвид, че има два изхода, използван тук:
1) изхода на текущия слой определя делта стойност,
2) Изходът на неврона, свързани към входа на текущата неврон се използва в
коригиране на теглото.
* /
/ / Направи първият слой изход
deltaOutput = (целеви - outputLayer.output) * outputLayer.output * (1.0f - outputLayer.output);
(I = 0; и <numHiddenLayer; I + +)
outputLayer.weight [I] + = learnRate * deltaOutput * hiddenLayer [I] изход.
/ / Сега направете скрит слой
(J = 0; J <numHiddenLayer; J + +)
{
deltaHidden [к] = outputLayer.weight [J] * deltaOutput *
hiddenLayer [J] изход * (1.0f - hiddenLayer [к] изход);
(I = 0; и <numInputLayer; I + +)
{
hiddenLayer [к] тегло [I] + = deltaHidden [к] * learnRate * inputLayer [I] изход..
}
}
}

И начина, по който аз го стартирате е както следва:

неподписани I, J, K;
neuralNetwork Н.Н. (2,2,1);
(к = 0; к <100 000; к + +)
{
(I = 0; и <2; I + +)
(J = 0; J <2; J + +)
{
nn.input [0] = (плувка) и;
nn.input [1] = (плаващи) J;
nn.recalc ();
nn.backpropagate (XOR ((плувка), (плаващи) J));
(к == 0 | | к == 99999)
{
nn.recalc ();
<<I <<"XOR" <<J <<<nn.outputLayer.output <<"ТРЯБВА ДА БЪДЕ" <<XOR ((плувка), (плаващи) J) <<endl;
}
}
(к == 0 | | к == 99999)
<<endl;
}

Знам, аз не зададете прецизност ограничител върху него. Но на изхода никога не дойде по-близо от 0.4 на 1.0 (ниски и високи са съответно 0.0 и 1.0 и резултатите никога не излезем навън от 0.45 и 0.55). Изходите трябва да се движат към 1.0 и 0.0 (очевидно), но те не го правят.
Някакви идеи какво не е наред?

За съжаление, аз всъщност имаше друга промяна, така че скритите настройки на тегло не винаги са точно същите,
(Което би било като имат само един скрит тегло)
така че аз също се промени
hiddenLayer [к] setInput (inputLayer [I], I).
за
{
hiddenLayer [к] setInput (inputLayer [I], I).
hiddenLayer [J] setWeight (I, 2.0 * ранд () / RAND_MAX-1);
}