double BackPropagate(dvector *yrow, NNModel *nn, double lr, double mf, int regression)
{
if(yrow->size != nn->no){
fprintf(seterr, "wrong number of y\n");
return 99999999;
}
else{
size_t i, j, k;
// calculate error terms for output
dvector *odelta;
NewDVector(&odelta, nn->no);
DVectorSet(odelta, 0.f);
for(k = 0; k < nn->no; k++){
odelta->data[k] = yrow->data[k] - nn->ao->data[k];
if(regression == 0)
odelta->data[k] = dsigmoid(nn->ao->data[k]) * odelta->data[k];
}
// calculate error terms for hidden
dvector *hdelta;
NewDVector(&hdelta, nn->nh);
DVectorSet(hdelta, 0.f);
for(j = 0; j < nn->nh; j++){
double error = 0.f;
for(k = 0; k < nn->no; k++)
error += odelta->data[k] * nn->wo->data[j][k];
hdelta->data[j] = dsigmoid(nn->ah->data[j]) * error;
}
// update output weights
for(j = 0; j < nn->nh; j++){
for(k = 0; k < nn->no; k++){
double change = odelta->data[k] * nn->ah->data[j];
nn->wo->data[j][k] = nn->wo->data[j][k] + lr * change + mf*nn->co->data[j][k];
nn->co->data[j][k] = change;
}
}
// update input weights
for(i = 0; i < nn->ni; i++){
for(j = 0; j < nn->nh; j++){
double change = hdelta->data[j]*nn->ai->data[i];
nn->wi->data[i][j] = nn->wi->data[i][j] + lr * change + mf * nn->ci->data[i][j];
nn->ci->data[i][j] = change;
}
}
// calculate error
double error = 0.f;
for(k = 0; k < yrow->size; k++){
error += 0.5*pow((yrow->data[k]-nn->ao->data[k]),2);
}
return error;
}
}
double backPropogate(double* targets, double N, double M) {
double** deltas = new double *[hidden_layers + 1];
deltas[hidden_layers] = new double [no];
for(int i = 0; i < no; i++) {
deltas[hidden_layers][i] = targets[i] - node_acts[hidden_layers + 1][i];
deltas[hidden_layers][i] *= dsigmoid(node_acts[hidden_layers+1][i]);
}
for(int j = hidden_layers-1; j >= 0; j--) {
deltas[j] = new double [n_layers[j]];
for(int i = 0; i < n_layers[j]; i++) {
double error = 0.0;
for(int k = 0; k < n_layers[j+1]; k++) {
error += deltas[j+1][k] * weights[j][i][k];
}
deltas[j][i] = dsigmoid(node_acts[j][i]) * error;
}
}
int plen, len;
for(int k = hidden_layers; k >= 0; k--) {
if(k==0) { plen = ni; }
else { plen = n_layers[k-1]; }
if(k==hidden_layers) { len = no; }
else { plen = n_layers[k]; }
for(int j = 0; j < plen; j++) {
for(int i = 0; i < len; i++) {
double change = deltas[k][i] * node_acts[j][i];
weights[k][j][i] += N * change + M * changes[k][j][i];
changes[k][j][i] = change;
}
}
}
// Calculate error
double error = 0.0;
for(int i = 0; i < no; i++) {
error += 0.5 * ((targets[i]-node_acts[hidden_layers+1][i]) * (targets[i]-node_acts[hidden_layers+1][i]));
}
delete deltas;
return error;
}
