source: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.MultiVariate.TimeSeriesPrognosis/3.3/Symbolic/Evaluators/SymbolicTimeSeriesPrognosisMahalanobisEvaluator.cs @ 5242

#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;
using HeuristicLab.Problems.DataAnalysis.Symbolic;

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

    public SymbolicTimeSeriesPrognosisMahalanobisEvaluator()
      : base() {
    }

    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];

      SymbolicTimeSeriesPrognosisScaledNormalizedMseEvaluator.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]);

      OnlineMeanMahalanobisDistanceEvaluator evaluator = new OnlineMeanMahalanobisDistanceEvaluator();
      // for covariance calculation: array of variables
      IEnumerable<double>[] targetValues = (from targetVariableIndex in selectedTargetVariableIndexes
                                            select dataset.GetEnumeratedVariableValues(targetVariableIndex, rows))
                                           .ToArray();
      evaluator.InitializeCovarianceMatrixFromSamples(targetValues);

      var estimatedValuesEnumerator = estimatedValues.GetEnumerator();
      var originalValuesEnumerator = originalValues.GetEnumerator();
      while (originalValuesEnumerator.MoveNext() & estimatedValuesEnumerator.MoveNext()) {
        IEnumerable<double> currentOriginal = originalValuesEnumerator.Current;
        double[] currentEstimated = estimatedValuesEnumerator.Current;
        // limit estimated values to bounds
        for (int i = 0; i < currentEstimated.Length; i++) {
          if (double.IsNaN(currentEstimated[i])) currentEstimated[i] = upperEstimationLimit[i];
          else currentEstimated[i] = Math.Min(upperEstimationLimit[i], Math.Max(lowerEstimationLimit[i], currentEstimated[i]));
        }

        evaluator.Add(currentOriginal, currentEstimated);
      }

      return evaluator.MeanGeneralizedSquaredInterpointDistance;
    }
  }
}