Exemplo n.º 1
0
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;
  }
}
Exemplo n.º 2
0
 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;
 }