/**
   * Normalize a single column to the input vector.
   *
   * @param colDef The column to normalize.
   * @param outputColumn The current position in the vector.
   * @param output The vector to output to.
   * @param isInput Is this an input column.
   * @param value The value to normalize.
   * @return The new current position in the vector.
   */
  public int normalizeToVector(
      ColumnDefinition colDef, int outputColumn, double[] output, boolean isInput, String value) {
    MissingHandler handler = null;

    if (this.unknownValues.contains(value)) {
      if (!this.missingHandlers.containsKey(colDef)) {
        throw new EncogError(
            "Do not know how to process missing value \""
                + value
                + "\" in field: "
                + colDef.getName());
      }
      handler = this.missingHandlers.get(colDef);
    }

    if (colDef.getDataType() == ColumnType.continuous) {
      double d = parseDouble(value);
      if (handler != null) {
        d = handler.processDouble(colDef);
      }
      return this.normStrategy.normalizeColumn(colDef, isInput, d, output, outputColumn);
    } else {
      if (handler != null) {
        value = handler.processString(colDef);
      }
      return this.normStrategy.normalizeColumn(colDef, isInput, value, output, outputColumn);
    }
  }
Exemplo n.º 2
0
  /**
   * Calculate the error for the given method and dataset.
   *
   * @param method The method to use.
   * @param data The data to use.
   * @return The error.
   */
  public double calculateError(MLMethod method, MLDataSet data) {
    if (this.dataset.getNormHelper().getOutputColumns().size() == 1) {
      ColumnDefinition cd = this.dataset.getNormHelper().getOutputColumns().get(0);
      if (cd.getDataType() == ColumnType.nominal) {
        return EncogUtility.calculateClassificationError((MLClassification) method, data);
      }
    }

    return EncogUtility.calculateRegressionError((MLRegression) method, data);
  }
 /** {@inheritDoc} */
 public String toString() {
   StringBuilder result = new StringBuilder();
   result.append("[NormalizationHelper:\n");
   for (ColumnDefinition colDef : this.sourceColumns) {
     result.append(colDef.toString());
     result.append("\n");
   }
   result.append("]");
   return result.toString();
 }
Exemplo n.º 4
0
  /** {@inheritDoc} */
  @Override
  public String denormalizeColumn(ColumnDefinition colDef, MLData data, int dataColumn) {

    double value = data.getData(dataColumn);
    final double result =
        ((colDef.getLow() - colDef.getHigh()) * value
                - this.normalizedHigh * colDef.getLow()
                + colDef.getHigh() * this.normalizedLow)
            / (this.normalizedLow - this.normalizedHigh);

    // typically caused by a number that should not have been normalized
    // (i.e. normalization or actual range is infinitely small.
    if (Double.isNaN(result)) {
      return "" + (((this.normalizedHigh - this.normalizedLow) / 2) + this.normalizedLow);
    }
    return "" + result;
  }
Exemplo n.º 5
0
  /** {@inheritDoc} */
  @Override
  public int normalizeColumn(
      ColumnDefinition colDef, double value, double[] outputData, int outputColumn) {
    double result =
        ((value - colDef.getLow()) / (colDef.getHigh() - colDef.getLow()))
                * (this.normalizedHigh - this.normalizedLow)
            + this.normalizedLow;

    // typically caused by a number that should not have been normalized
    // (i.e. normalization or actual range is infinitely small.
    if (Double.isNaN(result)) {
      result = ((this.normalizedHigh - this.normalizedLow) / 2) + this.normalizedLow;
    }

    outputData[outputColumn] = result;

    return outputColumn + 1;
  }
 /**
  * Define a source column. These define the raw input. Use this function if you know the index of
  * the column in a non-header file.
  *
  * @param name The name of the column.
  * @param index The index of the column, needed for non-headered files.
  * @param colType The column type.
  * @return The column definition
  */
 public ColumnDefinition defineSourceColumn(String name, int index, ColumnType colType) {
   ColumnDefinition result = new ColumnDefinition(name, colType);
   result.setIndex(index);
   addSourceColumn(result);
   return result;
 }
 /**
  * Add a source column. These define the raw input.
  *
  * @param def The column definition.
  */
 public void addSourceColumn(ColumnDefinition def) {
   this.sourceColumns.add(def);
   def.setOwner(this);
 }