Backpropagation và C + +

Trong đơn đề nghị một coder đồng, tôi là reposting câu hỏi này ở đây.

Tôi không bao giờ có thể có vẻ để có được quyền backpropagation, và mỗi khi tôi nhờ giúp đỡ, không có ai có vẻ là có thể trả lời hoặc đề xuất của họ không giải quyết vấn đề. Vì vậy, tôi nghĩ rằng tôi có thể yêu cầu sự giúp đỡ từ một điểm khác nhau - các lớp học của tôi mà không thuật toán backprop.
Bất cứ ai có thể cho tôi biết thủ tục backpropagating, dựa vào các nguồn dưới đây? Tôi chỉ cần biết cách thuật toán backpropagation sẽ làm việc cho thiết lập lớp của tôi (tôi đã cố gắng để có điều darned 2 năm nay - rõ ràng tôi đang sử dụng các phương pháp tiếp cận sai).

# include
# include
# include

lớp neuron
(
công cộng:
float ** đầu vào;
float * trọng lượng;
unsigned numInputs;
float đầu ra;
float dummy; / / xấu để trở về tài liệu tham khảo

neuron (unsigned input_numInputs);
neuron ();
void xây dựng lại (input_numInputs unsigned);
~ neuron ();
void setInput (neuron & n, unsigned inputIndex);
void setInput (float & floatInput, unsigned inputIndex);
float & getInput (unsigned inputIndex);
void recalc ();
void setWeight (unsigned inputIndex, thả nổi giá trị);
);

lớp neuralNetwork
(
công cộng:
unsigned numInputLayer;
unsigned numHiddenLayer;
unsigned numInputs;
float * đầu vào;
neuron * inputLayer;
neuron * hiddenLayer;
neuron outputLayer;

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

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

void neuron:: setWeight (inputIndex unsigned, thả nổi giá trị)
(
nếu (inputIndex> = numInputs)
return;
Trọng lượng [inputIndex] = giá trị;
)
void neuron:: recalc ()
(
nếu (numInputs <= 0)
return;
float weightedInput = 0.0f;
for (unsigned i = 0; i = numInputs)
return;
khác
input [inputIndex] = &floatInput;
)
float & neuron:: getInput (inputIndex unsigned)
(
nếu (inputIndex> = numInputs)
trở lại (dummy);
khác
trở lại (input [inputIndex] [0]);
)
neuron:: neuron ()
(
numInputs = 0;
)
neuron:: neuron (unsigned input_numInputs)
(
numInputs = 0;
xây dựng lại (input_numInputs);
)
void neuron:: xây dựng lại (input_numInputs unsigned)
(
nếu (numInputs> 0)
(
xóa [] đầu vào;
xóa [] trọng lượng;
)
numInputs = input_numInputs;
input = new float * [numInputs];
trọng lượng = new float [numInputs];
)
neuron:: ~ neuron ()
(
nếu (numInputs> = 0)
(
xóa đầu vào;
xoá trọng lượng;
)
)
void neuron:: setInput (neuron & n, unsigned inputIndex)
(
nếu (inputIndex> = numInputs)
return;
input [inputIndex] = & n.output;
)

neuralNetwork:: (input_numInputs neuralNetwork unsigned, unsigned input_numInputLayer, unsigned input_numHiddenLayer)
(
unsigned i, j;
numInputs = input_numInputs;
numHiddenLayer = input_numHiddenLayer;
numInputLayer = input_numInputLayer;
input = new float [numInputs];
inputLayer = mới neuron [numInputLayer];

hiddenLayer = mới neuron [numHiddenLayer];
outputLayer.rebuild (numHiddenLayer);
cho numHiddenLayer i = 0; i <(; i + +)
(
hiddenLayer [i] xây dựng lại (numInputLayer).;
outputLayer.setInput (hiddenLayer [i], i);
)
cho numInputLayer i = 0; i <(; i + +)
(
inputLayer [i]. xây dựng lại (numInputs);
for (i = 0; j <numHiddenLayer; i + +)
hiddenLayer [j]. setInput (inputLayer [i], i);
)
for (i = 0; i <numInputs; i + +)
for (i = 0; j 0)
xóa đầu vào;
nếu (numInputLayer> 0)
xóa [] inputLayer;
nếu (numHiddenLayer> 0)
xóa [] hiddenLayer;

)

float XOR (float input1, phao input2, phao biasLower, phao biasUpper)
(
float correctedInput1, correctedInput2;
nếu (input1 <((biasLower + biasUpper) / 2.0f))
correctedInput1 = biasLower;
khác
correctedInput1 = biasUpper;
nếu (input2 <((biasLower + biasUpper) / 2.0f))
correctedInput2 = biasLower;
khác
correctedInput2 = biasUpper;
nếu (correctedInput1 == correctedInput2)
(
trở lại (biasLower);
)
khác
(
trở lại (biasUpper);
)
)

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

- Crash Matrix

Trả lời: Sau đây là mã backpropagation tôi sử dụng (trong đó, btw, không làm việc).

void neuralNetwork:: backpropagate (float mục tiêu)
(
nếu (numInputs == 0 | | numInputLayer == 0 | | numHiddenLayer == 0)
return;
float deltaOutput;
float * deltaHidden = new float [numHiddenLayer];
unsigned i, j;
/ *
Lưu ý rằng có hai kết quả đầu ra được sử dụng ở đây:
1) Sản lượng của lớp hiện hành sẽ xác định giá trị đồng bằng,
2) Sản lượng của các neuron kết nối với đầu vào của các neuron hiện nay được sử dụng trong
điều chỉnh trọng lượng.
* /
/ / Do lớp sản lượng đầu tiên
deltaOutput = (mục tiêu - outputLayer.output) * outputLayer.output * (1.0f - outputLayer.output);
cho numHiddenLayer i = 0; i <(; i + +)
outputLayer.weight [i] + = learnRate * deltaOutput * hiddenLayer [i]. đầu ra;
/ / Now làm lớp ẩn
for (i = 0; j <numHiddenLayer; i + +)
(
deltaHidden [j] = outputLayer.weight [j] * deltaOutput *
hiddenLayer [j]. đầu ra * (1.0f - hiddenLayer [j] đầu ra).;
cho numInputLayer i = 0; i <(; i + +)
(
hiddenLayer [j]. trọng lượng [i] + = deltaHidden [j] * learnRate * inputLayer [i]. đầu ra;
)
)
)

Và cách tôi chạy nó là như sau:

unsigned i, j, k;
neuralNetwork nn (2,2,1);
for (k = 0; k <100.000; k + +)
(
for (i = 0; i <2; i + +)
for (i = 0; j <2; i + +)
(
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 <<" NÊN ĐƯỢC "<<XOR ((float) i, (float) j) <<endl;
)
)
if (k == 0 | | k == 99999)
cout <<endl;
)

Tôi biết, tôi không đặt giới hạn độ chính xác về nó. Tuy nhiên, các kết quả đầu ra không bao giờ đến bất cứ địa điểm gần nhất hơn 0,4 trên 1,0 (The thấp và cao là 0,0 và 1,0 tương ứng và không bao giờ đi ra ngoài 0,45 và 0,55). Các đầu ra nên di chuyển về hướng 1,0 và 0,0 (rõ ràng), nhưng họ không.
Bất cứ ý tưởng gì sai?

Xin lỗi, tôi thực sự đã có một sự thay đổi để điều chỉnh lượng ẩn không luôn luôn chính xác như nhau,
(mà sẽ được như chỉ có một trọng lượng ẩn)
vì vậy tôi cũng thay đổi
hiddenLayer [j]. setInput (inputLayer [i], i);
tới
(
hiddenLayer [j]. setInput (inputLayer [i], i);
hiddenLayer [j]. setWeight (i, 2,0 * rand () / RAND_MAX-1);
)