source: branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionBase.cs @ 7989

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2011 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.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Data;
using HeuristicLab.Optimization;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.DataAnalysis {
  [StorableClass]
  public abstract class TimeSeriesPrognosisSolutionBase : DataAnalysisSolution, ITimeSeriesPrognosisSolution {
    private const string TrainingMeanSquaredErrorResultName = "Mean squared error (training)";
    private const string TestMeanSquaredErrorResultName = "Mean squared error (test)";
    private const string TrainingMeanAbsoluteErrorResultName = "Mean absolute error (training)";
    private const string TestMeanAbsoluteErrorResultName = "Mean absolute error (test)";
    private const string TrainingSquaredCorrelationResultName = "Pearson's R² (training)";
    private const string TestSquaredCorrelationResultName = "Pearson's R² (test)";
    private const string TrainingRelativeErrorResultName = "Average relative error (training)";
    private const string TestRelativeErrorResultName = "Average relative error (test)";
    private const string TrainingNormalizedMeanSquaredErrorResultName = "Normalized mean squared error (training)";
    private const string TestNormalizedMeanSquaredErrorResultName = "Normalized mean squared error (test)";
    private const string TrainingDirectionalSymmetryResultName = "Average directional symmetry (training)";
    private const string TestDirectionalSymmetryResultName = "Average directional symmetry (test)";
    private const string TrainingWeightedDirectionalSymmetryResultName = "Average weighted directional symmetry (training)";
    private const string TestWeightedDirectionalSymmetryResultName = "Average weighted directional symmetry (test)";
    private const string TrainingTheilsUStatisticLastResultName = "Average Theil's U (last) (training)";
    private const string TestTheilsUStatisticLastResultName = "Average Theil's U (last) (test)";
    private const string TrainingTheilsUStatisticMeanResultName = "Average Theil's U (mean) (training)";
    private const string TestTheilsUStatisticMeanResultName = "Average Theil's U (mean) (test)";
    private const string TrainingTheilsUStatisticMaResultName = "Average Theil's U (moving average) (training)";
    private const string TestTheilsUStatisticMaResultName = "Average Theil's U (moving average) (test)";

    public new ITimeSeriesPrognosisModel Model {
      get { return (ITimeSeriesPrognosisModel)base.Model; }
      protected set { base.Model = value; }
    }

    public new ITimeSeriesPrognosisProblemData ProblemData {
      get { return (ITimeSeriesPrognosisProblemData)base.ProblemData; }
      set { base.ProblemData = value; }
    }

    [Storable]
    private int horizon;
    public int Horizon {
      get { return horizon; }
      set {
        if (horizon != value) {
          horizon = value;
          RecalculateResults();
        }
      }
    }

    public abstract IEnumerable<IEnumerable<double>> GetPrognosedValues(IEnumerable<int> rows, int horizon);

    #region Results
    public double TrainingMeanSquaredError {
      get { return ((DoubleValue)this[TrainingMeanSquaredErrorResultName].Value).Value; }
      private set { ((DoubleValue)this[TrainingMeanSquaredErrorResultName].Value).Value = value; }
    }
    public double TestMeanSquaredError {
      get { return ((DoubleValue)this[TestMeanSquaredErrorResultName].Value).Value; }
      private set { ((DoubleValue)this[TestMeanSquaredErrorResultName].Value).Value = value; }
    }
    public double TrainingMeanAbsoluteError {
      get { return ((DoubleValue)this[TrainingMeanAbsoluteErrorResultName].Value).Value; }
      private set { ((DoubleValue)this[TrainingMeanAbsoluteErrorResultName].Value).Value = value; }
    }
    public double TestMeanAbsoluteError {
      get { return ((DoubleValue)this[TestMeanAbsoluteErrorResultName].Value).Value; }
      private set { ((DoubleValue)this[TestMeanAbsoluteErrorResultName].Value).Value = value; }
    }
    public double TrainingRSquared {
      get { return ((DoubleValue)this[TrainingSquaredCorrelationResultName].Value).Value; }
      private set { ((DoubleValue)this[TrainingSquaredCorrelationResultName].Value).Value = value; }
    }
    public double TestRSquared {
      get { return ((DoubleValue)this[TestSquaredCorrelationResultName].Value).Value; }
      private set { ((DoubleValue)this[TestSquaredCorrelationResultName].Value).Value = value; }
    }
    public double TrainingRelativeError {
      get { return ((DoubleValue)this[TrainingRelativeErrorResultName].Value).Value; }
      private set { ((DoubleValue)this[TrainingRelativeErrorResultName].Value).Value = value; }
    }
    public double TestRelativeError {
      get { return ((DoubleValue)this[TestRelativeErrorResultName].Value).Value; }
      private set { ((DoubleValue)this[TestRelativeErrorResultName].Value).Value = value; }
    }
    public double TrainingNormalizedMeanSquaredError {
      get { return ((DoubleValue)this[TrainingNormalizedMeanSquaredErrorResultName].Value).Value; }
      private set { ((DoubleValue)this[TrainingNormalizedMeanSquaredErrorResultName].Value).Value = value; }
    }
    public double TestNormalizedMeanSquaredError {
      get { return ((DoubleValue)this[TestNormalizedMeanSquaredErrorResultName].Value).Value; }
      private set { ((DoubleValue)this[TestNormalizedMeanSquaredErrorResultName].Value).Value = value; }
    }
    public double TrainingDirectionalSymmetry {
      get { return ((DoubleValue)this[TrainingDirectionalSymmetryResultName].Value).Value; }
      private set { ((DoubleValue)this[TrainingDirectionalSymmetryResultName].Value).Value = value; }
    }
    public double TestDirectionalSymmetry {
      get { return ((DoubleValue)this[TestDirectionalSymmetryResultName].Value).Value; }
      private set { ((DoubleValue)this[TestDirectionalSymmetryResultName].Value).Value = value; }
    }
    public double TrainingWeightedDirectionalSymmetry {
      get { return ((DoubleValue)this[TrainingWeightedDirectionalSymmetryResultName].Value).Value; }
      private set { ((DoubleValue)this[TrainingWeightedDirectionalSymmetryResultName].Value).Value = value; }
    }
    public double TestWeightedDirectionalSymmetry {
      get { return ((DoubleValue)this[TestWeightedDirectionalSymmetryResultName].Value).Value; }
      private set { ((DoubleValue)this[TestWeightedDirectionalSymmetryResultName].Value).Value = value; }
    }
    public double TrainingTheilsUStatisticLast {
      get { return ((DoubleValue)this[TrainingTheilsUStatisticLastResultName].Value).Value; }
      private set { ((DoubleValue)this[TrainingTheilsUStatisticLastResultName].Value).Value = value; }
    }
    public double TestTheilsUStatisticLast {
      get { return ((DoubleValue)this[TestTheilsUStatisticLastResultName].Value).Value; }
      private set { ((DoubleValue)this[TestTheilsUStatisticLastResultName].Value).Value = value; }
    }
    public double TrainingTheilsUStatisticMean {
      get { return ((DoubleValue)this[TrainingTheilsUStatisticMeanResultName].Value).Value; }
      private set { ((DoubleValue)this[TrainingTheilsUStatisticMeanResultName].Value).Value = value; }
    }
    public double TestTheilsUStatisticMean {
      get { return ((DoubleValue)this[TestTheilsUStatisticMeanResultName].Value).Value; }
      private set { ((DoubleValue)this[TestTheilsUStatisticMeanResultName].Value).Value = value; }
    }
    public double TrainingTheilsUStatisticMovingAverage {
      get { return ((DoubleValue)this[TrainingTheilsUStatisticMaResultName].Value).Value; }
      private set { ((DoubleValue)this[TrainingTheilsUStatisticMaResultName].Value).Value = value; }
    }
    public double TestTheilsUStatisticMovingAverage {
      get { return ((DoubleValue)this[TestTheilsUStatisticMaResultName].Value).Value; }
      private set { ((DoubleValue)this[TestTheilsUStatisticMaResultName].Value).Value = value; }
    }
    #endregion

    [StorableConstructor]
    protected TimeSeriesPrognosisSolutionBase(bool deserializing) : base(deserializing) { }
    protected TimeSeriesPrognosisSolutionBase(TimeSeriesPrognosisSolutionBase original, Cloner cloner)
      : base(original, cloner) {
      this.horizon = original.horizon;
    }
    protected TimeSeriesPrognosisSolutionBase(ITimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData)
      : base(model, problemData) {
      Add(new Result(TrainingMeanSquaredErrorResultName, "Mean of squared errors of the model on the training partition", new DoubleValue()));
      Add(new Result(TestMeanSquaredErrorResultName, "Mean of squared errors of the model on the test partition", new DoubleValue()));
      Add(new Result(TrainingMeanAbsoluteErrorResultName, "Mean of absolute errors of the model on the training partition", new DoubleValue()));
      Add(new Result(TestMeanAbsoluteErrorResultName, "Mean of absolute errors of the model on the test partition", new DoubleValue()));
      Add(new Result(TrainingSquaredCorrelationResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the training partition", new DoubleValue()));
      Add(new Result(TestSquaredCorrelationResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the test partition", new DoubleValue()));
      Add(new Result(TrainingRelativeErrorResultName, "Average of the relative errors of the model output and the actual values on the training partition", new DoubleValue()));
      Add(new Result(TestRelativeErrorResultName, "Average of the relative errors of the model output and the actual values on the test partition", new DoubleValue()));
      Add(new Result(TrainingNormalizedMeanSquaredErrorResultName, "Normalized mean of squared errors of the model on the training partition", new DoubleValue()));
      Add(new Result(TestNormalizedMeanSquaredErrorResultName, "Normalized mean of squared errors of the model on the test partition", new DoubleValue()));
      Add(new Result(TrainingDirectionalSymmetryResultName, "The average directional symmetry of the forecasts of the model on the training partition", new DoubleValue()));
      Add(new Result(TestDirectionalSymmetryResultName, "The average directional symmetry of the forecasts of the model on the test partition", new DoubleValue()));
      Add(new Result(TrainingWeightedDirectionalSymmetryResultName, "The average weighted directional symmetry of the forecasts of the model on the training partition", new DoubleValue()));
      Add(new Result(TestWeightedDirectionalSymmetryResultName, "The average weighted directional symmetry of the forecasts of the model on the test partition", new DoubleValue()));
      Add(new Result(TrainingTheilsUStatisticLastResultName, "The average Theil's U statistic (reference: previous value) of the forecasts of the model on the training partition", new DoubleValue()));
      Add(new Result(TestTheilsUStatisticLastResultName, "The average Theil's U statistic (reference: previous value) of the forecasts of the model on the test partition", new DoubleValue()));
      Add(new Result(TrainingTheilsUStatisticMeanResultName, "The average Theil's U statistic (reference: mean value) of the forecasts of the model on the training partition", new DoubleValue()));
      Add(new Result(TestTheilsUStatisticMeanResultName, "The average Theil's U statistic (reference: mean value) of the forecasts of the model on the test partition", new DoubleValue()));
      Add(new Result(TrainingTheilsUStatisticMaResultName, "The average Theil's U statistic (reference: moving average) of the forecasts of the model on the training partition", new DoubleValue()));
      Add(new Result(TestTheilsUStatisticMaResultName, "The average Theil's U statistic (reference: moving average) of the forecasts of the model on the test partition", new DoubleValue()));
      horizon = 1;
    }


    protected void CalculateResults() {
      string targetVariable = ProblemData.TargetVariable;

      var trainingMseCalculators = new OnlineMeanSquaredErrorCalculator();
      var testMseCalculators = new OnlineMeanSquaredErrorCalculator();
      var trainingMaeCalculators = new OnlineMeanAbsoluteErrorCalculator();
      var testMaeCalculators = new OnlineMeanAbsoluteErrorCalculator();
      var trainingRSquaredCalculators = new OnlinePearsonsRSquaredCalculator();
      var testRSquaredCalculators = new OnlinePearsonsRSquaredCalculator();
      var trainingRelErrorCalculators = new OnlineMeanAbsolutePercentageErrorCalculator();
      var testRelErrorCalculators = new OnlineMeanAbsolutePercentageErrorCalculator();
      var trainingNmseCalculators = new OnlineNormalizedMeanSquaredErrorCalculator();
      var testNmseCalculators = new OnlineNormalizedMeanSquaredErrorCalculator();

      var trainingDsCalculators = new OnlineDirectionalSymmetryCalculator();
      var testDsCalculators = new OnlineDirectionalSymmetryCalculator();
      var trainingWdsCalculators = new OnlineWeightedDirectionalSymmetryCalculator();
      var testWdsCalculators = new OnlineWeightedDirectionalSymmetryCalculator();
      var trainingTheilsULastCalculators = new OnlineTheilsUStatisticCalculator();
      var testTheilsULastCalculators = new OnlineTheilsUStatisticCalculator();
      var trainingTheilsUMeanCalculators = new OnlineTheilsUStatisticCalculator();
      var testTheilsUMeanCalculators = new OnlineTheilsUStatisticCalculator();
      var trainingTheilsUMovingAverageCalculators = new OnlineTheilsUStatisticCalculator();
      var testTheilsUMovingAverageCalculators = new OnlineTheilsUStatisticCalculator();

      double mean = ProblemData.Dataset.GetDoubleValues(targetVariable, ProblemData.TrainingIndizes).Average();

      foreach (var row in ProblemData.TrainingIndizes) {
        if (row + horizon < ProblemData.Dataset.Rows) {
          var actualContinuation = ProblemData.Dataset.GetDoubleValues(targetVariable, Enumerable.Range(row, horizon)).ToList();
          var prognosedContinuation = GetPrognosedValues(new List<int> { row }, horizon).First().ToList();

          int maWindow = 10 * horizon;
          var movingAverageContinuation = from h in Enumerable.Range(0, horizon)
                                          select (from r in Enumerable.Range(row + h - maWindow, maWindow - h)
                                                  where r > 0
                                                  select ProblemData.Dataset.GetDoubleValue(targetVariable, r)
                                                 ).Average();

          double startValue = ProblemData.Dataset.GetDoubleValue(targetVariable, row - 1);

          trainingDsCalculators.Add(startValue, actualContinuation, prognosedContinuation);
          trainingWdsCalculators.Add(startValue, actualContinuation, prognosedContinuation);
          trainingTheilsULastCalculators.Add(startValue, actualContinuation, prognosedContinuation);
          trainingTheilsUMeanCalculators.Add(startValue, actualContinuation.Select(x => mean), actualContinuation, prognosedContinuation);
          trainingTheilsUMovingAverageCalculators.Add(startValue, movingAverageContinuation, actualContinuation, prognosedContinuation);

          var actualContinuationEnumerator = actualContinuation.GetEnumerator();
          var prognosedContinuationEnumerator = prognosedContinuation.GetEnumerator();

          while (actualContinuationEnumerator.MoveNext() & prognosedContinuationEnumerator.MoveNext()) {
            trainingMseCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
            trainingMaeCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
            trainingRelErrorCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
            trainingRSquaredCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
            trainingNmseCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
          }
          if (actualContinuationEnumerator.MoveNext() | prognosedContinuationEnumerator.MoveNext())
            throw new ArgumentException("Different number of elements in Actual continuation and prognosed continuation.");
        }
      }

      mean = ProblemData.Dataset.GetDoubleValues(targetVariable, ProblemData.TestIndizes).Average();
      foreach (var row in ProblemData.TestIndizes) {
        if (row + horizon < ProblemData.Dataset.Rows) {
          var actualContinuation = ProblemData.Dataset.GetDoubleValues(targetVariable, Enumerable.Range(row, horizon)).ToList();
          var prognosedContinuation = GetPrognosedValues(new List<int> { row }, horizon).First().ToList();

          int maWindow = 10 * horizon;
          var movingAverageContinuation = from h in Enumerable.Range(0, horizon)
                                          select (from r in Enumerable.Range(row + h - maWindow, maWindow - h)
                                                  where r > 0
                                                  select ProblemData.Dataset.GetDoubleValue(targetVariable, r)
                                                 ).Average();

          double startValue = ProblemData.Dataset.GetDoubleValue(targetVariable, row - 1);
          testDsCalculators.Add(startValue, actualContinuation, prognosedContinuation);
          testWdsCalculators.Add(startValue, actualContinuation, prognosedContinuation);
          testTheilsULastCalculators.Add(startValue, actualContinuation, prognosedContinuation);
          testTheilsUMeanCalculators.Add(startValue, actualContinuation.Select(x => mean), actualContinuation, prognosedContinuation);
          testTheilsUMovingAverageCalculators.Add(startValue, movingAverageContinuation, actualContinuation, prognosedContinuation);

          var actualContinuationEnumerator = actualContinuation.GetEnumerator();
          var prognosedContinuationEnumerator = prognosedContinuation.GetEnumerator();
          while (actualContinuationEnumerator.MoveNext() & prognosedContinuationEnumerator.MoveNext()) {
            testMseCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
            testMaeCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
            testRelErrorCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
            testRSquaredCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
            testNmseCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
          }
          if (actualContinuationEnumerator.MoveNext() | prognosedContinuationEnumerator.MoveNext())
            throw new ArgumentException("Different number of elements in Actual continuation and prognosed continuation.");
        }
      }

      TrainingMeanSquaredError = trainingMseCalculators.ErrorState == OnlineCalculatorError.None ? trainingMseCalculators.Value : double.PositiveInfinity;
      TestMeanSquaredError = testMseCalculators.ErrorState == OnlineCalculatorError.None ? testMseCalculators.Value : double.PositiveInfinity;
      TrainingMeanAbsoluteError = trainingMaeCalculators.ErrorState == OnlineCalculatorError.None ? trainingMaeCalculators.Value : double.PositiveInfinity;
      TestMeanAbsoluteError = testMaeCalculators.ErrorState == OnlineCalculatorError.None ? testMaeCalculators.Value : double.PositiveInfinity;
      TrainingRelativeError = trainingRelErrorCalculators.ErrorState == OnlineCalculatorError.None ? trainingRelErrorCalculators.Value : double.PositiveInfinity;
      TestRelativeError = testRelErrorCalculators.ErrorState == OnlineCalculatorError.None ? testRelErrorCalculators.Value : double.PositiveInfinity;
      TrainingRSquared = trainingRSquaredCalculators.ErrorState == OnlineCalculatorError.None ? trainingRSquaredCalculators.Value : 0.0;
      TestRSquared = testRSquaredCalculators.ErrorState == OnlineCalculatorError.None ? testRSquaredCalculators.Value : 0.0;
      TrainingNormalizedMeanSquaredError = trainingNmseCalculators.ErrorState == OnlineCalculatorError.None ? trainingNmseCalculators.Value : double.PositiveInfinity;
      TestNormalizedMeanSquaredError = testNmseCalculators.ErrorState == OnlineCalculatorError.None ? testNmseCalculators.Value : double.PositiveInfinity;

      TrainingDirectionalSymmetry = trainingDsCalculators.ErrorState == OnlineCalculatorError.None ? trainingDsCalculators.Value : 0.0;
      TestDirectionalSymmetry = testDsCalculators.ErrorState == OnlineCalculatorError.None ? testDsCalculators.Value : 0.0;
      TrainingWeightedDirectionalSymmetry = trainingWdsCalculators.ErrorState == OnlineCalculatorError.None ? trainingWdsCalculators.Value : double.PositiveInfinity;
      TestWeightedDirectionalSymmetry = testWdsCalculators.ErrorState == OnlineCalculatorError.None ? testWdsCalculators.Value : double.PositiveInfinity;
      TrainingTheilsUStatisticLast = trainingTheilsULastCalculators.ErrorState == OnlineCalculatorError.None ? trainingTheilsULastCalculators.Value : double.PositiveInfinity;
      TestTheilsUStatisticLast = testTheilsULastCalculators.ErrorState == OnlineCalculatorError.None ? testTheilsULastCalculators.Value : double.PositiveInfinity;
      TrainingTheilsUStatisticMean = trainingTheilsUMeanCalculators.ErrorState == OnlineCalculatorError.None ? trainingTheilsUMeanCalculators.Value : double.PositiveInfinity;
      TestTheilsUStatisticMean = testTheilsUMeanCalculators.ErrorState == OnlineCalculatorError.None ? testTheilsUMeanCalculators.Value : double.PositiveInfinity;
      TrainingTheilsUStatisticMovingAverage = trainingTheilsUMovingAverageCalculators.ErrorState == OnlineCalculatorError.None ? trainingTheilsUMovingAverageCalculators.Value : double.PositiveInfinity;
      TestTheilsUStatisticMovingAverage = testTheilsUMovingAverageCalculators.ErrorState == OnlineCalculatorError.None ? testTheilsUMovingAverageCalculators.Value : double.PositiveInfinity;
    }
  }
}