예제 #1
0
  /**
   * Query a regression algorithm using equilateral encoding.
   *
   * @param alg The algorithm being used.
   * @param theTrainingData The training data.
   * @param items The category items classified.
   * @param high The high value.
   * @param low The low value.
   */
  public static void queryEquilateral(
      final RegressionAlgorithm alg,
      final List<BasicData> theTrainingData,
      final Map<String, Integer> items,
      final double high,
      final double low) {
    // first, we need to invert the items.  Right now it maps from category to index.  We need index
    // to category.
    final Map<Integer, String> invMap = new HashMap<>();
    for (final Map.Entry<String, Integer> entry : items.entrySet()) {
      invMap.put(entry.getValue(), entry.getKey());
    }

    // now we can query
    final Equilateral eq = new Equilateral(items.size(), high, low);
    for (final BasicData data : theTrainingData) {
      final double[] output = alg.computeRegression(data.getInput());
      final int idealIndex = eq.decode(data.getIdeal());
      final int actualIndex = eq.decode(output);
      System.out.println(
          Arrays.toString(data.getInput())
              + " -> "
              + invMap.get(actualIndex)
              + ", Ideal: "
              + invMap.get(idealIndex));
    }
  }
예제 #2
0
  /** {@inheritDoc} */
  @Override
  public void iteration() {
    this.network.setNetworkTraining(true);

    // alert the layers that a new batch is starting.
    for (Layer layer : this.network.getLayers()) {
      layer.trainingBatch(this.stochastic);
    }

    // begin the iteration
    this.gradients.reset();
    this.errorCalc.clear();

    int iterationSize =
        this.batchSize == 0 ? this.training.size() : Math.min(this.batchSize, this.training.size());

    for (int i = 0; i < iterationSize; i++) {
      BasicData element;

      if (isOnlineTraining()) {
        if (this.stochastic != null) {
          int stochasticIndex = this.stochastic.nextInt(0, this.training.size());
          element = this.training.get(stochasticIndex);
        } else {
          element = this.training.get(this.currentIndex++);
        }
      } else {
        element = this.training.get(i);
      }
      this.gradients.process(this.errorCalc, element.getInput(), element.getIdeal());
    }

    if (this.currentIndex > this.training.size() || this.batchSize == 0) {
      this.currentIndex = 0;
    }

    this.currentError = this.errorCalc.calculate();

    for (int i = 0; i < this.network.getWeights().length; i++) {
      double delta;

      if (this.nesterovUpdate) {
        double prevNesterov = this.lastDelta[i];

        this.lastDelta[i] =
            (this.momentum * prevNesterov) + (this.gradients.getGradients()[i] * this.learningRate);
        delta = (this.momentum * prevNesterov) - ((1 + this.momentum) * this.lastDelta[i]);
      } else {
        delta =
            (this.gradients.getGradients()[i] * -this.learningRate)
                + (this.lastDelta[i] * this.momentum);
        this.lastDelta[i] = delta;
      }

      this.network.getWeights()[i] += delta;
    }
    this.network.setNetworkTraining(false);
  }
예제 #3
0
 /**
  * Query a regression algorithm and see how close it matches the training data.
  *
  * @param alg The algorithm to evaluate.
  * @param theTrainingData The training data.
  */
 public static void query(final RegressionAlgorithm alg, final List<BasicData> theTrainingData) {
   for (final BasicData data : theTrainingData) {
     final double[] output = alg.computeRegression(data.getInput());
     System.out.println(
         Arrays.toString(data.getInput())
             + " -> "
             + Arrays.toString(output)
             + ", Ideal: "
             + Arrays.toString(data.getIdeal()));
   }
 }