source: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.TimeSeriesPrognosis/3.3/Symbolic/Evaluators/SymbolicTimeSeriesPrognosisScaledNormalizedMseEvaluator.cs @ 11301

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis.SupportVectorMachine;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Evaluators;
using HeuristicLab.Parameters;
using HeuristicLab.Optimization;
using HeuristicLab.Operators;
using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using System.Collections.Generic;
using HeuristicLab.Problems.DataAnalysis.Regression;
using HeuristicLab.Problems.DataAnalysis.MultiVariate.TimeSeriesPrognosis.Symbolic.Interfaces;
using HeuristicLab.Problems.DataAnalysis.MultiVariate.Evaluators;

namespace HeuristicLab.Problems.DataAnalysis.MultiVariate.TimeSeriesPrognosis.Symbolic.Evaluators {
  [Item("SymbolicTimeSeriesPrognosisScaledNormalizedMseEvaluator", "")]
  [StorableClass]
  public class SymbolicTimeSeriesPrognosisScaledNormalizedMseEvaluator : SymbolicTimeSeriesPrognosisEvaluator {

    [StorableConstructor]
    protected SymbolicTimeSeriesPrognosisScaledNormalizedMseEvaluator(bool deserializing) : base(deserializing) { }
    protected SymbolicTimeSeriesPrognosisScaledNormalizedMseEvaluator(SymbolicTimeSeriesPrognosisScaledNormalizedMseEvaluator original, Cloner cloner)
      : base(original, cloner) {
    }
    public SymbolicTimeSeriesPrognosisScaledNormalizedMseEvaluator()
      : base() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new SymbolicTimeSeriesPrognosisScaledNormalizedMseEvaluator(this, cloner);
    }
    public override double Evaluate(SymbolicExpressionTree tree, MultiVariateDataAnalysisProblemData problemData, ISymbolicTimeSeriesExpressionInterpreter interpreter, IEnumerable<int> rows, int predictionHorizon, DoubleArray lowerEstimationLimit, DoubleArray upperEstimationLimit) {
      return Calculate(tree, problemData, interpreter, rows, predictionHorizon, lowerEstimationLimit, upperEstimationLimit);
    }

    public static double Calculate(SymbolicExpressionTree tree, MultiVariateDataAnalysisProblemData problemData, ISymbolicTimeSeriesExpressionInterpreter interpreter, IEnumerable<int> rows, int predictionHorizon, DoubleArray lowerEstimationLimit, DoubleArray upperEstimationLimit) {
      double[] alpha, beta;
      double quality;

      Dataset dataset = problemData.Dataset;
      // calculate scaling parameters based on one-step-predictions
      IEnumerable<string> selectedTargetVariables = (from item in problemData.TargetVariables
                                                     where problemData.TargetVariables.ItemChecked(item)
                                                     select item.Value).ToArray();
      int dimension = selectedTargetVariables.Count();

      IEnumerable<int> selectedTargetVariableIndexes = (from targetVariable in selectedTargetVariables
                                                        select dataset.GetVariableIndex(targetVariable)).ToArray();
      IEnumerable<IEnumerable<double>> oneStepPredictions =
        interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, selectedTargetVariables, rows, 1).Cast<IEnumerable<double>>();
      IEnumerable<IEnumerable<double>> originalValues = from row in rows
                                                        select (from targetVariableIndex in selectedTargetVariableIndexes
                                                                select dataset[row, targetVariableIndex]);
      alpha = new double[dimension];
      beta = new double[dimension];

      CalculateScalingParameters(originalValues, oneStepPredictions, ref beta, ref alpha);

      // calculate the quality for the full horizon
      quality = CalculateWithScaling(tree, problemData, interpreter,
        rows, predictionHorizon,
        lowerEstimationLimit, upperEstimationLimit,
        beta, alpha);
      return quality;
    }

    public static double CalculateWithScaling(SymbolicExpressionTree tree, MultiVariateDataAnalysisProblemData problemData,
      ISymbolicTimeSeriesExpressionInterpreter interpreter,
      IEnumerable<int> rows, int predictionHorizon,
      DoubleArray lowerEstimationLimit, DoubleArray upperEstimationLimit,
      double[] beta, double[] alpha) {
      Dataset dataset = problemData.Dataset;
      IEnumerable<string> selectedTargetVariables = (from targetVariable in problemData.TargetVariables
                                                     where problemData.TargetVariables.ItemChecked(targetVariable)
                                                     select targetVariable.Value).ToArray();
      IEnumerable<int> selectedTargetVariableIndexes = (from targetVariable in selectedTargetVariables
                                                        select dataset.GetVariableIndex(targetVariable)).ToArray();

      IEnumerable<double[]> estimatedValues =
        interpreter.GetScaledSymbolicExpressionTreeValues(tree, dataset, selectedTargetVariables,
        rows, predictionHorizon, beta, alpha);

      IEnumerable<IEnumerable<double>> originalValues = from row in rows
                                                        from step in Enumerable.Range(0, predictionHorizon)
                                                        select (from targetVariableIndex in selectedTargetVariableIndexes
                                                                select dataset[row + step, targetVariableIndex]);

      var evaluator = new OnlineMultiVariateEvaluator<OnlineNormalizedMeanSquaredErrorEvaluator>();

      var estimatedValuesEnumerator = estimatedValues.GetEnumerator();
      var originalValuesEnumerator = originalValues.GetEnumerator();
      while (originalValuesEnumerator.MoveNext() & estimatedValuesEnumerator.MoveNext()) {
        IEnumerable<double> original = originalValuesEnumerator.Current;
        double[] estimated = estimatedValuesEnumerator.Current;
        for (int i = 0; i < estimated.Length; i++) {
          if (double.IsNaN(estimated[i])) estimated[i] = upperEstimationLimit[i];
          else estimated[i] = Math.Min(upperEstimationLimit[i], Math.Max(lowerEstimationLimit[i], estimated[i]));
        }
        evaluator.Add(original, estimated);
      }

      double quality = evaluator.Value;
      return quality;
    }

    public static void CalculateScalingParameters(IEnumerable<IEnumerable<double>> originalValues, IEnumerable<IEnumerable<double>> estimatedValues, ref double[] beta, ref double[] alpha) {
      List<OnlineLinearScalingCalculator> linearScalingCalculators = new List<OnlineLinearScalingCalculator>();
      // initialize lists
      int dimension = originalValues.First().Count();
      for (int i = 0; i < dimension; i++) {
        linearScalingCalculators.Add(new OnlineLinearScalingCalculator());
      }

      var estimatedEnumerator = estimatedValues.GetEnumerator();
      var originalEnumerator = originalValues.GetEnumerator();
      // foreach row vector in both series
      while (estimatedEnumerator.MoveNext() & originalEnumerator.MoveNext()) {
        IEnumerable<double> original = originalEnumerator.Current;
        IEnumerable<double> estimated = estimatedEnumerator.Current;
        var originalComponentValuesEnumerator = original.GetEnumerator();
        var estimatedComponentValuesEnumerator = estimated.GetEnumerator();

        int component = 0;
        // for each component in both row vectors
        while (originalComponentValuesEnumerator.MoveNext() & estimatedComponentValuesEnumerator.MoveNext() && component < dimension) {
          if (IsValidValue(originalComponentValuesEnumerator.Current) && IsValidValue(estimatedComponentValuesEnumerator.Current)) {
            linearScalingCalculators[component].Add(originalComponentValuesEnumerator.Current, estimatedComponentValuesEnumerator.Current);
          }
          component++;
        }
        // check if both row vectors are finished
        if (originalComponentValuesEnumerator.MoveNext() | estimatedComponentValuesEnumerator.MoveNext() || component < dimension) {
          throw new ArgumentException("Number of elements in original and estimated row vectors does not match.");
        }
      }

      // check if both series are finished
      if (estimatedEnumerator.MoveNext() || originalEnumerator.MoveNext())
        throw new InvalidOperationException("Number of elements in estimated and original series doesn't match.");

      // get alpha and beta for each component
      for (int component = 0; component < dimension; component++) {
        alpha[component] = linearScalingCalculators[component].Alpha;
        beta[component] = linearScalingCalculators[component].Beta;
      }
    }

    private static bool IsValidValue(double d) {
      return !double.IsInfinity(d) && !double.IsNaN(d) && d > -1.0E07 && d < 1.0E07;  // don't consider very large or very small values for scaling
    }
  }
}