Example #1
0
  /** Calculate weights using Ada method */
  public void GetAdaWeights() {

    for (int i = 0; i < Noutputs; i++) {
      for (int j = 0; j < Nnetworks; j++) {
        weights[i][j] = Math.log(1.0 / betta[j]);
      }
    }
  }
Example #2
0
  /**
   * Test ensemble in regression
   *
   * @param global Global definition parameters
   * @param data Input data
   * @param npatterns No of patterns
   * @return Test ensemble in regression
   */
  public double TestEnsembleInRegression(
      EnsembleParameters global, double data[][], int npatterns) {
    double fitness, RMS = 0.0, error;

    double[] outputs = new double[Noutputs];

    for (int i = 0; i < npatterns; i++) {
      // Obtain network output
      EnsembleOutput(data[i], outputs);

      // Obtain RMS error
      error = 0.0;
      for (int j = 0; j < Noutputs; j++) {
        error += Math.pow(outputs[j] - data[i][Ninputs + j], 2.0);
      }
      RMS += Math.sqrt(error);
    }

    fitness = RMS / (npatterns * global.Noutputs);

    return fitness;
  }
Example #3
0
  /**
   * Calculate weights using GEM method
   *
   * @param global Global definition parameters
   * @param data Input data
   * @param n matrix order (no of rows and colms in data matrix)
   */
  public void GetGEMWeights(EnsembleParameters global, double data[][], int n) {
    int xx, yy, offset, cols;
    double scalar;

    double[] module = new double[Nnetworks];
    boolean[] collinear = new boolean[Nnetworks];
    double[][] omega = new double[Nnetworks][Nnetworks];
    double[][] inverse = new double[Nnetworks][Nnetworks];
    double[][] toinvert = new double[Nnetworks][Nnetworks];
    double[] output_i = new double[Noutputs];
    double[] output_j = new double[Noutputs];

    // Weight for every output.
    for (int out = 0; out < Noutputs; out++) {
      // Obtain omega matrix.
      for (int i = 0; i < Nnetworks; i++) {
        for (int j = 0; j <= i; j++) {
          omega[i][j] = 0.0;
          for (int k = 0; k < n; k++) {
            nets[i].GenerateOutput(data[k], output_i);
            nets[j].GenerateOutput(data[k], output_j);
            omega[i][j] +=
                (data[k][Ninputs + out] - output_i[out]) * (data[k][Ninputs + out] - output_j[out]);
          }
          omega[j][i] = (omega[i][j] /= n);
        }
      }

      // Search collinearity.
      for (int i = 0; i < Nnetworks; i++) {
        module[i] = 0.0;
        for (int k = 0; k < Nnetworks; k++) {
          module[i] += omega[i][k] * omega[i][k];
        }
        module[i] = Math.sqrt(module[i]);
        collinear[i] = false;
      }

      for (int i = 0; i < Nnetworks - 1; i++) {
        for (int j = i + 1; j < Nnetworks && !collinear[i]; j++) {
          scalar = 0.0;
          for (int k = 0; k < Nnetworks; k++) {
            scalar += omega[i][k] * omega[j][k];
          }
          if (scalar / (module[i] * module[j]) > TH_COS) {
            collinear[i] = true;
          }
        }
      }

      // Create non-singular matrixx.
      for (int i = xx = 0; i < Nnetworks; i++) {
        if (!collinear[i]) {
          // Copyy row.
          for (int j = yy = 0; j < Nnetworks; j++) {
            if (!collinear[j]) {
              toinvert[xx][yy] = omega[i][j];
              yy++;
            }
          }
          xx++;
        }
      }

      cols = xx;

      // Invert omega matrix.
      Matrix.InvertMatrix(toinvert, inverse, cols);

      // Obtain sum of matrix elements (1 Omega-1 1).
      double sum = 0.0;
      for (int i = 0; i < cols; i++) {
        for (int j = 0; j < cols; j++) {
          sum += inverse[i][j];

          // Obtain weights.
        }
      }
      for (int i = offset = 0; i < Nnetworks; i++) {
        weights[out][i] = 0.0;
        if (!collinear[i]) {
          for (int j = 0; j < cols; j++) {
            weights[out][i] += inverse[i - offset][j];
          }
          weights[out][i] /= sum;
        } else {
          offset++;
        }
      }
    }
  }