#region License Information
/* HeuristicLab
* Copyright (C) 2002-2015 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 .
*/
#endregion
using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Optimization;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
namespace HeuristicLab.Problems.DataAnalysis {
[StorableClass]
[Item("Prognosis Results", "Represents a collection of time series prognosis results.")]
public class TimeSeriesPrognosisResults : ResultCollection {
#region result names
protected const string PrognosisTrainingMeanSquaredErrorResultName = "Mean squared error (training)";
protected const string PrognosisTestMeanSquaredErrorResultName = "Mean squared error (test)";
protected const string PrognosisTrainingMeanAbsoluteErrorResultName = "Mean absolute error (training)";
protected const string PrognosisTestMeanAbsoluteErrorResultName = "Mean absolute error (test)";
protected const string PrognosisTrainingSquaredCorrelationResultName = "Pearson's R² (training)";
protected const string PrognosisTestSquaredCorrelationResultName = "Pearson's R² (test)";
protected const string PrognosisTrainingRelativeErrorResultName = "Average relative error (training)";
protected const string PrognosisTestRelativeErrorResultName = "Average relative error (test)";
protected const string PrognosisTrainingNormalizedMeanSquaredErrorResultName = "Normalized mean squared error (training)";
protected const string PrognosisTestNormalizedMeanSquaredErrorResultName = "Normalized mean squared error (test)";
protected const string PrognosisTrainingMeanErrorResultName = "Mean error (training)";
protected const string PrognosisTestMeanErrorResultName = "Mean error (test)";
protected const string PrognosisTrainingDirectionalSymmetryResultName = "Average directional symmetry (training)";
protected const string PrognosisTestDirectionalSymmetryResultName = "Average directional symmetry (test)";
protected const string PrognosisTrainingWeightedDirectionalSymmetryResultName = "Average weighted directional symmetry (training)";
protected const string PrognosisTestWeightedDirectionalSymmetryResultName = "Average weighted directional symmetry (test)";
protected const string PrognosisTrainingTheilsUStatisticAR1ResultName = "Theil's U2 (AR1) (training)";
protected const string PrognosisTestTheilsUStatisticAR1ResultName = "Theil's U2 (AR1) (test)";
protected const string PrognosisTrainingTheilsUStatisticMeanResultName = "Theil's U2 (mean) (training)";
protected const string PrognosisTestTheilsUStatisticMeanResultName = "Theil's U2 (mean) (test)";
#endregion
#region result descriptions
protected const string PrognosisTrainingMeanSquaredErrorResultDescription = "Mean of squared errors of the model on the training partition";
protected const string PrognosisTestMeanSquaredErrorResultDescription = "Mean of squared errors of the model on the test partition";
protected const string PrognosisTrainingMeanAbsoluteErrorResultDescription = "Mean of absolute errors of the model on the training partition";
protected const string PrognosisTestMeanAbsoluteErrorResultDescription = "Mean of absolute errors of the model on the test partition";
protected const string PrognosisTrainingSquaredCorrelationResultDescription = "Squared Pearson's correlation coefficient of the model output and the actual values on the training partition";
protected const string PrognosisTestSquaredCorrelationResultDescription = "Squared Pearson's correlation coefficient of the model output and the actual values on the test partition";
protected const string PrognosisTrainingRelativeErrorResultDescription = "Average of the relative errors of the model output and the actual values on the training partition";
protected const string PrognosisTestRelativeErrorResultDescription = "Average of the relative errors of the model output and the actual values on the test partition";
protected const string PrognosisTrainingNormalizedMeanSquaredErrorResultDescription = "Normalized mean of squared errors of the model on the training partition";
protected const string PrognosisTestNormalizedMeanSquaredErrorResultDescription = "Normalized mean of squared errors of the model on the test partition";
protected const string PrognosisTrainingMeanErrorResultDescription = "Mean of errors of the model on the training partition";
protected const string PrognosisTestMeanErrorResultDescription = "Mean of errors of the model on the test partition";
protected const string PrognosisTrainingDirectionalSymmetryResultDescription = "The average directional symmetry of the forecasts of the model on the training partition";
protected const string PrognosisTestDirectionalSymmetryResultDescription = "The average directional symmetry of the forecasts of the model on the test partition";
protected const string PrognosisTrainingWeightedDirectionalSymmetryResultDescription = "The average weighted directional symmetry of the forecasts of the model on the training partition";
protected const string PrognosisTestWeightedDirectionalSymmetryResultDescription = "The average weighted directional symmetry of the forecasts of the model on the test partition";
protected const string PrognosisTrainingTheilsUStatisticAR1ResultDescription = "The Theil's U statistic (reference: AR1 model) of the forecasts of the model on the training partition";
protected const string PrognosisTestTheilsUStatisticAR1ResultDescription = "The Theil's U statistic (reference: AR1 model) of the forecasts of the model on the test partition";
protected const string PrognosisTrainingTheilsUStatisticMeanResultDescription = "The Theil's U statistic (reference: mean model) of the forecasts of the model on the training partition";
protected const string PrognosisTestTheilsUStatisticMeanResultDescription = "The Theil's U statistic (reference: mean value) of the forecasts of the model on the test partition";
#endregion
#region result properties
//prognosis results for different horizons
public double PrognosisTrainingMeanSquaredError {
get {
if (!ContainsKey(PrognosisTrainingMeanSquaredErrorResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTrainingMeanSquaredErrorResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTrainingMeanSquaredErrorResultName)) Add(new Result(PrognosisTrainingMeanSquaredErrorResultName, PrognosisTrainingMeanSquaredErrorResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTrainingMeanSquaredErrorResultName].Value).Value = value;
}
}
public double PrognosisTestMeanSquaredError {
get {
if (!ContainsKey(PrognosisTestMeanSquaredErrorResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTestMeanSquaredErrorResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTestMeanSquaredErrorResultName)) Add(new Result(PrognosisTestMeanSquaredErrorResultName, PrognosisTestMeanSquaredErrorResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTestMeanSquaredErrorResultName].Value).Value = value;
}
}
public double PrognosisTrainingMeanAbsoluteError {
get {
if (!ContainsKey(PrognosisTrainingMeanAbsoluteErrorResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTrainingMeanAbsoluteErrorResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTrainingMeanAbsoluteErrorResultName)) Add(new Result(PrognosisTrainingMeanAbsoluteErrorResultName, PrognosisTrainingMeanAbsoluteErrorResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTrainingMeanAbsoluteErrorResultName].Value).Value = value;
}
}
public double PrognosisTestMeanAbsoluteError {
get {
if (!ContainsKey(PrognosisTestMeanAbsoluteErrorResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTestMeanAbsoluteErrorResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTestMeanAbsoluteErrorResultName)) Add(new Result(PrognosisTestMeanAbsoluteErrorResultName, PrognosisTestMeanAbsoluteErrorResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTestMeanAbsoluteErrorResultName].Value).Value = value;
}
}
public double PrognosisTrainingRSquared {
get {
if (!ContainsKey(PrognosisTrainingSquaredCorrelationResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTrainingSquaredCorrelationResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTrainingSquaredCorrelationResultName)) Add(new Result(PrognosisTrainingSquaredCorrelationResultName, PrognosisTrainingSquaredCorrelationResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTrainingSquaredCorrelationResultName].Value).Value = value;
}
}
public double PrognosisTestRSquared {
get {
if (!ContainsKey(PrognosisTestSquaredCorrelationResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTestSquaredCorrelationResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTestSquaredCorrelationResultName)) Add(new Result(PrognosisTestSquaredCorrelationResultName, PrognosisTestSquaredCorrelationResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTestSquaredCorrelationResultName].Value).Value = value;
}
}
public double PrognosisTrainingRelativeError {
get {
if (!ContainsKey(PrognosisTrainingRelativeErrorResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTrainingRelativeErrorResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTrainingRelativeErrorResultName)) Add(new Result(PrognosisTrainingRelativeErrorResultName, PrognosisTrainingRelativeErrorResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTrainingRelativeErrorResultName].Value).Value = value;
}
}
public double PrognosisTestRelativeError {
get {
if (!ContainsKey(PrognosisTestRelativeErrorResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTestRelativeErrorResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTestRelativeErrorResultName)) Add(new Result(PrognosisTestRelativeErrorResultName, PrognosisTestRelativeErrorResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTestRelativeErrorResultName].Value).Value = value;
}
}
public double PrognosisTrainingNormalizedMeanSquaredError {
get {
if (!ContainsKey(PrognosisTrainingNormalizedMeanSquaredErrorResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTrainingNormalizedMeanSquaredErrorResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTrainingNormalizedMeanSquaredErrorResultName)) Add(new Result(PrognosisTrainingNormalizedMeanSquaredErrorResultName, PrognosisTrainingNormalizedMeanSquaredErrorResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTrainingNormalizedMeanSquaredErrorResultName].Value).Value = value;
}
}
public double PrognosisTestNormalizedMeanSquaredError {
get {
if (!ContainsKey(PrognosisTestNormalizedMeanSquaredErrorResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTestNormalizedMeanSquaredErrorResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTestNormalizedMeanSquaredErrorResultName)) Add(new Result(PrognosisTestNormalizedMeanSquaredErrorResultName, PrognosisTestNormalizedMeanSquaredErrorResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTestNormalizedMeanSquaredErrorResultName].Value).Value = value;
}
}
public double PrognosisTrainingMeanError {
get {
if (!ContainsKey(PrognosisTrainingMeanErrorResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTrainingMeanErrorResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTrainingMeanErrorResultName)) Add(new Result(PrognosisTrainingMeanErrorResultName, PrognosisTrainingMeanErrorResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTrainingMeanErrorResultName].Value).Value = value;
}
}
public double PrognosisTestMeanError {
get {
if (!ContainsKey(PrognosisTestMeanErrorResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTestMeanErrorResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTestMeanErrorResultName)) Add(new Result(PrognosisTestMeanErrorResultName, PrognosisTestMeanErrorResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTestMeanErrorResultName].Value).Value = value;
}
}
public double PrognosisTrainingDirectionalSymmetry {
get {
if (!ContainsKey(PrognosisTrainingDirectionalSymmetryResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTrainingDirectionalSymmetryResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTrainingDirectionalSymmetryResultName)) Add(new Result(PrognosisTrainingDirectionalSymmetryResultName, PrognosisTrainingDirectionalSymmetryResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTrainingDirectionalSymmetryResultName].Value).Value = value;
}
}
public double PrognosisTestDirectionalSymmetry {
get {
if (!ContainsKey(PrognosisTestDirectionalSymmetryResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTestDirectionalSymmetryResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTestDirectionalSymmetryResultName)) Add(new Result(PrognosisTestDirectionalSymmetryResultName, PrognosisTestDirectionalSymmetryResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTestDirectionalSymmetryResultName].Value).Value = value;
}
}
public double PrognosisTrainingWeightedDirectionalSymmetry {
get {
if (!ContainsKey(PrognosisTrainingWeightedDirectionalSymmetryResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTrainingWeightedDirectionalSymmetryResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTrainingWeightedDirectionalSymmetryResultName)) Add(new Result(PrognosisTrainingWeightedDirectionalSymmetryResultName, PrognosisTrainingWeightedDirectionalSymmetryResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTrainingWeightedDirectionalSymmetryResultName].Value).Value = value;
}
}
public double PrognosisTestWeightedDirectionalSymmetry {
get {
if (!ContainsKey(PrognosisTestWeightedDirectionalSymmetryResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTestWeightedDirectionalSymmetryResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTestWeightedDirectionalSymmetryResultName)) Add(new Result(PrognosisTestWeightedDirectionalSymmetryResultName, PrognosisTestWeightedDirectionalSymmetryResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTestWeightedDirectionalSymmetryResultName].Value).Value = value;
}
}
public double PrognosisTrainingTheilsUStatisticAR1 {
get {
if (!ContainsKey(PrognosisTrainingTheilsUStatisticAR1ResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTrainingTheilsUStatisticAR1ResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTrainingTheilsUStatisticAR1ResultName)) Add(new Result(PrognosisTrainingTheilsUStatisticAR1ResultName, PrognosisTrainingTheilsUStatisticAR1ResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTrainingTheilsUStatisticAR1ResultName].Value).Value = value;
}
}
public double PrognosisTestTheilsUStatisticAR1 {
get {
if (!ContainsKey(PrognosisTestTheilsUStatisticAR1ResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTestTheilsUStatisticAR1ResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTestTheilsUStatisticAR1ResultName)) Add(new Result(PrognosisTestTheilsUStatisticAR1ResultName, PrognosisTestTheilsUStatisticAR1ResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTestTheilsUStatisticAR1ResultName].Value).Value = value;
}
}
public double PrognosisTrainingTheilsUStatisticMean {
get {
if (!ContainsKey(PrognosisTrainingTheilsUStatisticMeanResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTrainingTheilsUStatisticMeanResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTrainingTheilsUStatisticMeanResultName)) Add(new Result(PrognosisTrainingTheilsUStatisticMeanResultName, PrognosisTrainingTheilsUStatisticMeanResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTrainingTheilsUStatisticMeanResultName].Value).Value = value;
}
}
public double PrognosisTestTheilsUStatisticMean {
get {
if (!ContainsKey(PrognosisTestTheilsUStatisticMeanResultName)) return double.NaN;
return ((DoubleValue)this[PrognosisTestTheilsUStatisticMeanResultName].Value).Value;
}
private set {
if (!ContainsKey(PrognosisTestTheilsUStatisticMeanResultName)) Add(new Result(PrognosisTestTheilsUStatisticMeanResultName, PrognosisTestTheilsUStatisticMeanResultDescription, new DoubleValue()));
((DoubleValue)this[PrognosisTestTheilsUStatisticMeanResultName].Value).Value = value;
}
}
#endregion
[Storable]
private int trainingHorizon;
public int TrainingHorizon {
get { return trainingHorizon; }
set {
if (trainingHorizon != value) {
trainingHorizon = value;
OnTrainingHorizonChanged();
}
}
}
[Storable]
private int testHorizon;
public int TestHorizon {
get { return testHorizon; }
set {
if (testHorizon != value) {
testHorizon = value;
OnTestHorizonChanged();
}
}
}
private ITimeSeriesPrognosisSolution solution;
[Storable]
public ITimeSeriesPrognosisSolution Solution {
get { return solution; }
private set { solution = value; } //necessary for persistence
}
[StorableConstructor]
public TimeSeriesPrognosisResults(bool deserializing) : base(deserializing) { }
protected TimeSeriesPrognosisResults(TimeSeriesPrognosisResults original, Cloner cloner)
: base(original, cloner) {
this.trainingHorizon = original.trainingHorizon;
this.testHorizon = original.testHorizon;
this.solution = cloner.Clone(original.solution);
}
public override IDeepCloneable Clone(Cloner cloner) {
return new TimeSeriesPrognosisResults(this, cloner);
}
public TimeSeriesPrognosisResults(int trainingHorizon, int testHorizon, ITimeSeriesPrognosisSolution solution)
: base() {
this.trainingHorizon = trainingHorizon;
this.testHorizon = testHorizon;
this.solution = solution;
CalculateTrainingPrognosisResults();
CalculateTestPrognosisResults();
}
#region events
public event EventHandler TrainingHorizonChanged;
protected virtual void OnTrainingHorizonChanged() {
CalculateTrainingPrognosisResults();
var handler = TrainingHorizonChanged;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler TestHorizonChanged;
protected virtual void OnTestHorizonChanged() {
CalculateTestPrognosisResults();
var handler = TestHorizonChanged;
if (handler != null) handler(this, EventArgs.Empty);
}
#endregion
private void CalculateTrainingPrognosisResults() {
OnlineCalculatorError errorState;
var problemData = Solution.ProblemData;
if (!problemData.TrainingIndices.Any()) return;
var model = Solution.Model;
//mean model
double trainingMean = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, problemData.TrainingIndices).Average();
var meanModel = new ConstantTimeSeriesPrognosisModel(trainingMean);
//AR1 model
double alpha, beta;
IEnumerable trainingStartValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, problemData.TrainingIndices.Select(r => r - 1).Where(r => r > 0)).ToList();
OnlineLinearScalingParameterCalculator.Calculate(problemData.Dataset.GetDoubleValues(problemData.TargetVariable, problemData.TrainingIndices.Where(x => x > 0)), trainingStartValues, out alpha, out beta, out errorState);
var AR1model = new TimeSeriesPrognosisAutoRegressiveModel(problemData.TargetVariable, new double[] { beta }, alpha);
var trainingHorizions = problemData.TrainingIndices.Select(r => Math.Min(trainingHorizon, problemData.TrainingPartition.End - r)).ToList();
IEnumerable> trainingTargetValues = problemData.TrainingIndices.Zip(trainingHorizions, Enumerable.Range).Select(r => problemData.Dataset.GetDoubleValues(problemData.TargetVariable, r)).ToList();
IEnumerable> trainingEstimatedValues = model.GetPrognosedValues(problemData.Dataset, problemData.TrainingIndices, trainingHorizions).ToList();
IEnumerable> trainingMeanModelPredictions = meanModel.GetPrognosedValues(problemData.Dataset, problemData.TrainingIndices, trainingHorizions).ToList();
IEnumerable> trainingAR1ModelPredictions = AR1model.GetPrognosedValues(problemData.Dataset, problemData.TrainingIndices, trainingHorizions).ToList();
IEnumerable originalTrainingValues = trainingTargetValues.SelectMany(x => x).ToList();
IEnumerable estimatedTrainingValues = trainingEstimatedValues.SelectMany(x => x).ToList();
double trainingMSE = OnlineMeanSquaredErrorCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
PrognosisTrainingMeanSquaredError = errorState == OnlineCalculatorError.None ? trainingMSE : double.NaN;
double trainingMAE = OnlineMeanAbsoluteErrorCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
PrognosisTrainingMeanAbsoluteError = errorState == OnlineCalculatorError.None ? trainingMAE : double.NaN;
double trainingR2 = OnlinePearsonsRSquaredCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
PrognosisTrainingRSquared = errorState == OnlineCalculatorError.None ? trainingR2 : double.NaN;
double trainingRelError = OnlineMeanAbsolutePercentageErrorCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
PrognosisTrainingRelativeError = errorState == OnlineCalculatorError.None ? trainingRelError : double.NaN;
double trainingNMSE = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
PrognosisTrainingNormalizedMeanSquaredError = errorState == OnlineCalculatorError.None ? trainingNMSE : double.NaN;
double trainingME = OnlineMeanErrorCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
PrognosisTrainingMeanError = errorState == OnlineCalculatorError.None ? trainingME : double.NaN;
PrognosisTrainingDirectionalSymmetry = OnlineDirectionalSymmetryCalculator.Calculate(trainingStartValues, trainingTargetValues, trainingEstimatedValues, out errorState);
PrognosisTrainingDirectionalSymmetry = errorState == OnlineCalculatorError.None ? PrognosisTrainingDirectionalSymmetry : 0.0;
PrognosisTrainingWeightedDirectionalSymmetry = OnlineWeightedDirectionalSymmetryCalculator.Calculate(trainingStartValues, trainingTargetValues, trainingEstimatedValues, out errorState);
PrognosisTrainingWeightedDirectionalSymmetry = errorState == OnlineCalculatorError.None ? PrognosisTrainingWeightedDirectionalSymmetry : 0.0;
PrognosisTrainingTheilsUStatisticAR1 = OnlineTheilsUStatisticCalculator.Calculate(trainingStartValues, trainingTargetValues, trainingAR1ModelPredictions, trainingEstimatedValues, out errorState);
PrognosisTrainingTheilsUStatisticAR1 = errorState == OnlineCalculatorError.None ? PrognosisTrainingTheilsUStatisticAR1 : double.PositiveInfinity;
PrognosisTrainingTheilsUStatisticMean = OnlineTheilsUStatisticCalculator.Calculate(trainingStartValues, trainingTargetValues, trainingMeanModelPredictions, trainingEstimatedValues, out errorState);
PrognosisTrainingTheilsUStatisticMean = errorState == OnlineCalculatorError.None ? PrognosisTrainingTheilsUStatisticMean : double.PositiveInfinity;
}
private void CalculateTestPrognosisResults() {
OnlineCalculatorError errorState;
var problemData = Solution.ProblemData;
if (!problemData.TestIndices.Any()) return;
var model = Solution.Model;
var testHorizions = problemData.TestIndices.Select(r => Math.Min(testHorizon, problemData.TestPartition.End - r)).ToList();
IEnumerable> testTargetValues = problemData.TestIndices.Zip(testHorizions, Enumerable.Range).Select(r => problemData.Dataset.GetDoubleValues(problemData.TargetVariable, r)).ToList();
IEnumerable> testEstimatedValues = model.GetPrognosedValues(problemData.Dataset, problemData.TestIndices, testHorizions).ToList();
IEnumerable testStartValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, problemData.TestIndices.Select(r => r - 1).Where(r => r > 0)).ToList();
IEnumerable originalTestValues = testTargetValues.SelectMany(x => x).ToList();
IEnumerable estimatedTestValues = testEstimatedValues.SelectMany(x => x).ToList();
double testMSE = OnlineMeanSquaredErrorCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
PrognosisTestMeanSquaredError = errorState == OnlineCalculatorError.None ? testMSE : double.NaN;
double testMAE = OnlineMeanAbsoluteErrorCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
PrognosisTestMeanAbsoluteError = errorState == OnlineCalculatorError.None ? testMAE : double.NaN;
double testR2 = OnlinePearsonsRSquaredCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
PrognosisTestRSquared = errorState == OnlineCalculatorError.None ? testR2 : double.NaN;
double testRelError = OnlineMeanAbsolutePercentageErrorCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
PrognosisTestRelativeError = errorState == OnlineCalculatorError.None ? testRelError : double.NaN;
double testNMSE = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
PrognosisTestNormalizedMeanSquaredError = errorState == OnlineCalculatorError.None ? testNMSE : double.NaN;
double testME = OnlineMeanErrorCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
PrognosisTestMeanError = errorState == OnlineCalculatorError.None ? testME : double.NaN;
PrognosisTestDirectionalSymmetry = OnlineDirectionalSymmetryCalculator.Calculate(testStartValues, testTargetValues, testEstimatedValues, out errorState);
PrognosisTestDirectionalSymmetry = errorState == OnlineCalculatorError.None ? PrognosisTestDirectionalSymmetry : 0.0;
PrognosisTestWeightedDirectionalSymmetry = OnlineWeightedDirectionalSymmetryCalculator.Calculate(testStartValues, testTargetValues, testEstimatedValues, out errorState);
PrognosisTestWeightedDirectionalSymmetry = errorState == OnlineCalculatorError.None ? PrognosisTestWeightedDirectionalSymmetry : 0.0;
if (problemData.TrainingIndices.Any()) {
//mean model
double trainingMean = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, problemData.TrainingIndices).Average();
var meanModel = new ConstantTimeSeriesPrognosisModel(trainingMean);
//AR1 model
double alpha, beta;
IEnumerable trainingStartValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, problemData.TrainingIndices.Select(r => r - 1).Where(r => r > 0)).ToList();
OnlineLinearScalingParameterCalculator.Calculate(problemData.Dataset.GetDoubleValues(problemData.TargetVariable, problemData.TrainingIndices.Where(x => x > 0)), trainingStartValues, out alpha, out beta, out errorState);
var AR1model = new TimeSeriesPrognosisAutoRegressiveModel(problemData.TargetVariable, new double[] { beta }, alpha);
IEnumerable> testMeanModelPredictions = meanModel.GetPrognosedValues(problemData.Dataset, problemData.TestIndices, testHorizions).ToList();
IEnumerable> testAR1ModelPredictions = AR1model.GetPrognosedValues(problemData.Dataset, problemData.TestIndices, testHorizions).ToList();
PrognosisTestTheilsUStatisticAR1 = OnlineTheilsUStatisticCalculator.Calculate(testStartValues, testTargetValues, testAR1ModelPredictions, testEstimatedValues, out errorState);
PrognosisTestTheilsUStatisticAR1 = errorState == OnlineCalculatorError.None ? PrognosisTestTheilsUStatisticAR1 : double.PositiveInfinity;
PrognosisTestTheilsUStatisticMean = OnlineTheilsUStatisticCalculator.Calculate(testStartValues, testTargetValues, testMeanModelPredictions, testEstimatedValues, out errorState);
PrognosisTestTheilsUStatisticMean = errorState == OnlineCalculatorError.None ? PrognosisTestTheilsUStatisticMean : double.PositiveInfinity;
}
}
}
}