public static double Calculate(ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, ITimeSeriesPrognosisProblemData problemData, IEnumerable<int> rows, IntRange evaluationPartition, int horizon, bool applyLinearScaling) {
var horizions = rows.Select(r => Math.Min(horizon, evaluationPartition.End - r));
IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows.Zip(horizions, Enumerable.Range).SelectMany(r => r));
IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows, horizions).SelectMany(x => x);
OnlineCalculatorError errorState;
double mse;
if (applyLinearScaling && horizon == 1) { //perform normal evaluation and afterwards scale the solution and calculate the fitness value
var mseCalculator = new OnlineMeanSquaredErrorCalculator();
CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, mseCalculator, problemData.Dataset.Rows * horizon);
errorState = mseCalculator.ErrorState;
mse = mseCalculator.MeanSquaredError;
} else if (applyLinearScaling) { //first create model to perform linear scaling and afterwards calculate fitness for the scaled model
var model = new SymbolicTimeSeriesPrognosisModel((ISymbolicExpressionTree)solution.Clone(), interpreter, lowerEstimationLimit, upperEstimationLimit);
model.Scale(problemData);
var scaledSolution = model.SymbolicExpressionTree;
estimatedValues = interpreter.GetSymbolicExpressionTreeValues(scaledSolution, problemData.Dataset, rows, horizions).SelectMany(x => x);
var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
mse = OnlineMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
} else {
var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
mse = OnlineMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
}
if (errorState != OnlineCalculatorError.None) return Double.NaN;
else return mse;
}
private static ITimeSeriesPrognosisSolution CreateAutoRegressiveSolution(ITimeSeriesPrognosisProblemData problemData, int timeOffset, out double rmsError, out double cvRmsError)
{
string targetVariable = problemData.TargetVariable;
double[,] inputMatrix = new double[problemData.TrainingPartition.Size, timeOffset + 1];
var targetValues = problemData.Dataset.GetDoubleValues(targetVariable).ToList();
for (int i = 0, row = problemData.TrainingPartition.Start; i < problemData.TrainingPartition.Size; i++, row++)
{
for (int col = 0; col < timeOffset; col++)
{
inputMatrix[i, col] = targetValues[row - col - 1];
}
}
// set target values in last column
for (int i = 0; i < inputMatrix.GetLength(0); i++)
{
inputMatrix[i, timeOffset] = targetValues[i + problemData.TrainingPartition.Start];
}
if (inputMatrix.Cast <double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
{
throw new NotSupportedException("Linear regression does not support NaN or infinity values in the input dataset.");
}
alglib.linearmodel lm = new alglib.linearmodel();
alglib.lrreport ar = new alglib.lrreport();
int nRows = inputMatrix.GetLength(0);
int nFeatures = inputMatrix.GetLength(1) - 1;
double[] coefficients = new double[nFeatures + 1]; // last coefficient is for the constant
int retVal = 1;
alglib.lrbuild(inputMatrix, nRows, nFeatures, out retVal, out lm, out ar);
if (retVal != 1)
{
throw new ArgumentException("Error in calculation of linear regression solution");
}
rmsError = ar.rmserror;
cvRmsError = ar.cvrmserror;
alglib.lrunpack(lm, out coefficients, out nFeatures);
var tree = LinearModelToTreeConverter.CreateTree(
variableNames: Enumerable.Repeat(problemData.TargetVariable, nFeatures).ToArray(),
lags: Enumerable.Range(0, timeOffset).Select(i => (i + 1) * -1).ToArray(),
coefficients: coefficients.Take(nFeatures).ToArray(),
@const: coefficients[nFeatures]
);
var interpreter = new SymbolicTimeSeriesPrognosisExpressionTreeInterpreter(problemData.TargetVariable);
var model = new SymbolicTimeSeriesPrognosisModel(problemData.TargetVariable, tree, interpreter);
var solution = model.CreateTimeSeriesPrognosisSolution((ITimeSeriesPrognosisProblemData)problemData.Clone());
return(solution);
}
protected TimeSeriesPrognosisSolutionBase(ITimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData)
: base(model, problemData)
{
Add(new Result(TrainingDirectionalSymmetryResultName, TrainingDirectionalSymmetryResultDescription, new DoubleValue()));
Add(new Result(TestDirectionalSymmetryResultName, TestDirectionalSymmetryResultDescription, new DoubleValue()));
Add(new Result(TrainingWeightedDirectionalSymmetryResultName, TrainingWeightedDirectionalSymmetryResultDescription, new DoubleValue()));
Add(new Result(TestWeightedDirectionalSymmetryResultName, TestWeightedDirectionalSymmetryResultDescription, new DoubleValue()));
Add(new Result(TrainingTheilsUStatisticAR1ResultName, TrainingTheilsUStatisticAR1ResultDescription, new DoubleValue()));
Add(new Result(TestTheilsUStatisticLastResultName, TestTheilsUStatisticAR1ResultDescription, new DoubleValue()));
Add(new Result(TrainingTheilsUStatisticMeanResultName, TrainingTheilsUStatisticMeanResultDescription, new DoubleValue()));
Add(new Result(TestTheilsUStatisticMeanResultName, TestTheilsUStatisticMeanResultDescription, new DoubleValue()));
}
public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree, ITimeSeriesPrognosisProblemData problemData, IEnumerable<int> rows) {
SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
EstimationLimitsParameter.ExecutionContext = context;
HorizonParameter.ExecutionContext = context;
double r2 = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, HorizonParameter.ActualValue.Value);
HorizonParameter.ExecutionContext = null;
SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
EstimationLimitsParameter.ExecutionContext = null;
return r2;
}
public static double Calculate(ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, ITimeSeriesPrognosisProblemData problemData, IEnumerable<int> rows, int horizon) {
var allPredictedContinuations =
interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, problemData.TargetVariables.ToArray(),
rows, horizon).ToArray();
var meanCalculator = new OnlineMeanAndVarianceCalculator();
int i = 0;
foreach (var targetVariable in problemData.TargetVariables) {
var actualContinuations = from r in rows
select problemData.Dataset.GetDoubleValues(targetVariable, Enumerable.Range(r, horizon));
var startValues = problemData.Dataset.GetDoubleValues(targetVariable, rows.Select(r => r - 1));
OnlineCalculatorError errorState;
meanCalculator.Add(OnlineTheilsUStatisticCalculator.Calculate(
startValues,
allPredictedContinuations.Select(v => v.ElementAt(i)),
actualContinuations, out errorState));
if (errorState != OnlineCalculatorError.None) return double.NaN;
i++;
}
return meanCalculator.Mean;
}
public SymbolicTimeSeriesPrognosisSolution(ISymbolicTimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData)
: base(model, problemData)
{
Add(new Result(ModelLengthResultName, "Length of the symbolic regression model.", new IntValue()));
Add(new Result(ModelDepthResultName, "Depth of the symbolic regression model.", new IntValue()));
CalculateResults();
}
public ITimeSeriesPrognosisSolution CreateTimeSeriesPrognosisSolution(ITimeSeriesPrognosisProblemData problemData)
{
return(new TimeSeriesPrognosisSolution(this, new TimeSeriesPrognosisProblemData(problemData)));
}
public ITimeSeriesPrognosisSolution CreateTimeSeriesPrognosisSolution(ITimeSeriesPrognosisProblemData problemData) {
return new TimeSeriesPrognosisSolution(this, new TimeSeriesPrognosisProblemData(problemData));
}
private static ITimeSeriesPrognosisSolution CreateAutoRegressiveSolution(ITimeSeriesPrognosisProblemData problemData, int timeOffset, out double rmsError, out double cvRmsError)
{
string targetVariable = problemData.TargetVariable;
double[,] inputMatrix = new double[problemData.TrainingPartition.Size, timeOffset + 1];
var targetValues = problemData.Dataset.GetDoubleValues(targetVariable).ToList();
for (int i = 0, row = problemData.TrainingPartition.Start; i < problemData.TrainingPartition.Size; i++, row++)
{
for (int col = 0; col < timeOffset; col++)
{
inputMatrix[i, col] = targetValues[row - col - 1];
}
}
// set target values in last column
for (int i = 0; i < inputMatrix.GetLength(0); i++)
{
inputMatrix[i, timeOffset] = targetValues[i + problemData.TrainingPartition.Start];
}
if (inputMatrix.Cast <double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
{
throw new NotSupportedException("Linear regression does not support NaN or infinity values in the input dataset.");
}
alglib.linearmodel lm = new alglib.linearmodel();
alglib.lrreport ar = new alglib.lrreport();
int nRows = inputMatrix.GetLength(0);
int nFeatures = inputMatrix.GetLength(1) - 1;
double[] coefficients = new double[nFeatures + 1]; // last coefficient is for the constant
int retVal = 1;
alglib.lrbuild(inputMatrix, nRows, nFeatures, out retVal, out lm, out ar);
if (retVal != 1)
{
throw new ArgumentException("Error in calculation of linear regression solution");
}
rmsError = ar.rmserror;
cvRmsError = ar.cvrmserror;
alglib.lrunpack(lm, out coefficients, out nFeatures);
ISymbolicExpressionTree tree = new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode());
ISymbolicExpressionTreeNode startNode = new StartSymbol().CreateTreeNode();
tree.Root.AddSubtree(startNode);
ISymbolicExpressionTreeNode addition = new Addition().CreateTreeNode();
startNode.AddSubtree(addition);
for (int i = 0; i < timeOffset; i++)
{
LaggedVariableTreeNode node = (LaggedVariableTreeNode) new LaggedVariable().CreateTreeNode();
node.VariableName = targetVariable;
node.Weight = coefficients[i];
node.Lag = (i + 1) * -1;
addition.AddSubtree(node);
}
ConstantTreeNode cNode = (ConstantTreeNode) new Constant().CreateTreeNode();
cNode.Value = coefficients[coefficients.Length - 1];
addition.AddSubtree(cNode);
var interpreter = new SymbolicTimeSeriesPrognosisExpressionTreeInterpreter(problemData.TargetVariable);
var model = new SymbolicTimeSeriesPrognosisModel(problemData.TargetVariable, tree, interpreter);
var solution = model.CreateTimeSeriesPrognosisSolution((ITimeSeriesPrognosisProblemData)problemData.Clone());
return(solution);
}
protected internal TimeSeriesPrognosisSolution(ITimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData)
: base(model, problemData)
{
CalculateRegressionResults();
CalculateTimeSeriesResults();
CalculateTimeSeriesResults(ProblemData.TrainingHorizon, ProblemData.TestHorizon);
}
public static double Calculate(ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, ITimeSeriesPrognosisProblemData problemData, IEnumerable <int> rows, int horizon)
{
var allPredictedContinuations =
interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, problemData.TargetVariables.ToArray(),
rows, horizon).ToArray();
var meanCalculator = new OnlineMeanAndVarianceCalculator();
int i = 0;
foreach (var targetVariable in problemData.TargetVariables)
{
var actualContinuations = from r in rows
select problemData.Dataset.GetDoubleValues(targetVariable, Enumerable.Range(r, horizon));
var startValues = problemData.Dataset.GetDoubleValues(targetVariable, rows.Select(r => r - 1));
OnlineCalculatorError errorState;
meanCalculator.Add(OnlineTheilsUStatisticCalculator.Calculate(
startValues,
allPredictedContinuations.Select(v => v.ElementAt(i)),
actualContinuations, out errorState));
if (errorState != OnlineCalculatorError.None)
{
return(double.NaN);
}
i++;
}
return(meanCalculator.Mean);
}
ITimeSeriesPrognosisSolution ITimeSeriesPrognosisModel.CreateTimeSeriesPrognosisSolution(ITimeSeriesPrognosisProblemData problemData)
{
return(CreateTimeSeriesPrognosisSolution(problemData));
}
public TimeSeriesPrognosisProblemData(ITimeSeriesPrognosisProblemData timeseriesProblemData)
: this(timeseriesProblemData.Dataset, timeseriesProblemData.AllowedInputVariables, timeseriesProblemData.TargetVariable) {
TrainingPartition.Start = timeseriesProblemData.TrainingPartition.Start;
TrainingPartition.End = timeseriesProblemData.TrainingPartition.End;
TestPartition.Start = timeseriesProblemData.TestPartition.Start;
TestPartition.End = timeseriesProblemData.TestPartition.End;
TrainingHorizon = timeseriesProblemData.TrainingHorizon;
TestHorizon = timeseriesProblemData.TestHorizon;
}
/// <summary>
/// Calculates an AR(p) model. For further information see http://en.wikipedia.org/wiki/Autoregressive_model
/// </summary>
/// <param name="problemData">The problem data which should be used for training</param>
/// <param name="timeOffset">The parameter p of the AR(p) specifying the maximum time offset [1,infinity] </param>
/// <returns>The times series autoregressive solution </returns>
public static ITimeSeriesPrognosisSolution CreateAutoRegressiveSolution(ITimeSeriesPrognosisProblemData problemData, int timeOffset)
{
double rmsError, cvRmsError;
return(CreateAutoRegressiveSolution(problemData, timeOffset, out rmsError, out cvRmsError));
}
protected internal TimeSeriesPrognosisSolution(ITimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData)
: base(model, problemData) {
CalculateRegressionResults();
CalculateTimeSeriesResults();
CalculateTimeSeriesResults(ProblemData.TrainingHorizon, ProblemData.TestHorizon);
}
ITimeSeriesPrognosisSolution ITimeSeriesPrognosisModel.CreateTimeSeriesPrognosisSolution(ITimeSeriesPrognosisProblemData problemData) {
return CreateTimeSeriesPrognosisSolution(problemData);
}
public SymbolicTimeSeriesPrognosisSolution(ISymbolicTimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData)
: base(model, problemData) {
Add(new Result(ModelLengthResultName, "Length of the symbolic regression model.", new IntValue()));
Add(new Result(ModelDepthResultName, "Depth of the symbolic regression model.", new IntValue()));
CalculateResults();
}
public static double Calculate(ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, ITimeSeriesPrognosisProblemData problemData, IEnumerable <int> rows, IntRange evaluationPartition, int horizon, bool applyLinearScaling)
{
var horizions = rows.Select(r => Math.Min(horizon, evaluationPartition.End - r));
IEnumerable <double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows.Zip(horizions, Enumerable.Range).SelectMany(r => r));
IEnumerable <double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows, horizions).SelectMany(x => x);
OnlineCalculatorError errorState;
double mse;
if (applyLinearScaling && horizon == 1) //perform normal evaluation and afterwards scale the solution and calculate the fitness value
{
var mseCalculator = new OnlineMeanSquaredErrorCalculator();
CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, mseCalculator, problemData.Dataset.Rows * horizon);
errorState = mseCalculator.ErrorState;
mse = mseCalculator.MeanSquaredError;
}
else if (applyLinearScaling) //first create model to perform linear scaling and afterwards calculate fitness for the scaled model
{
var model = new SymbolicTimeSeriesPrognosisModel(problemData.TargetVariable, (ISymbolicExpressionTree)solution.Clone(), interpreter, lowerEstimationLimit, upperEstimationLimit);
model.Scale(problemData);
var scaledSolution = model.SymbolicExpressionTree;
estimatedValues = interpreter.GetSymbolicExpressionTreeValues(scaledSolution, problemData.Dataset, rows, horizions).SelectMany(x => x);
var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
mse = OnlineMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
}
else
{
var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
mse = OnlineMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
}
if (errorState != OnlineCalculatorError.None)
{
return(Double.NaN);
}
else
{
return(mse);
}
}
public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree, ITimeSeriesPrognosisProblemData problemData, IEnumerable <int> rows)
{
SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
EstimationLimitsParameter.ExecutionContext = context;
HorizonParameter.ExecutionContext = context;
EvaluationPartitionParameter.ExecutionContext = context;
double mse = Calculate((ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter)SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, EvaluationPartitionParameter.ActualValue, HorizonParameter.ActualValue.Value, ApplyLinearScalingParameter.ActualValue.Value);
HorizonParameter.ExecutionContext = null;
SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
EstimationLimitsParameter.ExecutionContext = null;
EvaluationPartitionParameter.ExecutionContext = null;
return(mse);
}
protected TimeSeriesPrognosisSolutionBase(ITimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData)
: base(model, problemData) {
Add(new Result(TrainingDirectionalSymmetryResultName, TrainingDirectionalSymmetryResultDescription, new DoubleValue()));
Add(new Result(TestDirectionalSymmetryResultName, TestDirectionalSymmetryResultDescription, new DoubleValue()));
Add(new Result(TrainingWeightedDirectionalSymmetryResultName, TrainingWeightedDirectionalSymmetryResultDescription, new DoubleValue()));
Add(new Result(TestWeightedDirectionalSymmetryResultName, TestWeightedDirectionalSymmetryResultDescription, new DoubleValue()));
Add(new Result(TrainingTheilsUStatisticAR1ResultName, TrainingTheilsUStatisticAR1ResultDescription, new DoubleValue()));
Add(new Result(TestTheilsUStatisticLastResultName, TestTheilsUStatisticAR1ResultDescription, new DoubleValue()));
Add(new Result(TrainingTheilsUStatisticMeanResultName, TrainingTheilsUStatisticMeanResultDescription, new DoubleValue()));
Add(new Result(TestTheilsUStatisticMeanResultName, TestTheilsUStatisticMeanResultDescription, new DoubleValue()));
}
