Changeset 11310 for branches/DataAnalysis.ComplexityAnalyzer/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveTrainingBestSolutionAnalyzer.cs

Timestamp:

08/27/14 10:29:38 (10 years ago)

Author:

mkommend

Message:

#2175: Merged trunk changes into complexity branch.

Location:

branches/DataAnalysis.ComplexityAnalyzer/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression

Files:

• . (modified) (1 prop)
• 3.4 (modified) (1 prop)
• 3.4/MultiObjective/SymbolicRegressionMultiObjectiveTrainingBestSolutionAnalyzer.cs (modified) (6 diffs)

branches/DataAnalysis.ComplexityAnalyzer/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveTrainingBestSolutionAnalyzer.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -20 +20 @@
 #endregion
 
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Analysis;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -37 +42 @@
     private const string SymbolicDataAnalysisTreeInterpreterParameterName = "SymbolicDataAnalysisTreeInterpreter";
     private const string EstimationLimitsParameterName = "EstimationLimits";
+    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
+
     #region parameter properties
     public ILookupParameter<IRegressionProblemData> ProblemDataParameter {
@@ -46 +53 @@
     public IValueLookupParameter<DoubleLimit> EstimationLimitsParameter {
       get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
+    }
+    public ILookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
+      get { return (ILookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
     }
     #endregion
@@ -57 +67 @@
       Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName, "The symbolic data analysis tree interpreter for the symbolic expression tree."));
       Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The lower and upper limit for the estimated values produced by the symbolic regression model."));
+      Parameters.Add(new LookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, "Maximal length of the symbolic expression."));
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(MaximumSymbolicExpressionTreeLengthParameterName))
+        Parameters.Add(new LookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, "Maximal length of the symbolic expression."));
     }
 
@@ -68 +85 @@
       return new SymbolicRegressionSolution(model, (IRegressionProblemData)ProblemDataParameter.ActualValue.Clone());
     }
+
+    public override IOperation Apply() {
+      var operation = base.Apply();
+
+      var paretoFront = TrainingBestSolutionsParameter.ActualValue;
+
+      IResult result;
+      ScatterPlot qualityToTreeSize;
+      if (!ResultCollection.TryGetValue("Pareto Front Analysis", out result)) {
+        qualityToTreeSize = new ScatterPlot("Quality vs Tree Size", "");
+        qualityToTreeSize.VisualProperties.XAxisMinimumAuto = false;
+        qualityToTreeSize.VisualProperties.XAxisMaximumAuto = false;
+        qualityToTreeSize.VisualProperties.YAxisMinimumAuto = false;
+        qualityToTreeSize.VisualProperties.YAxisMaximumAuto = false;
+
+        qualityToTreeSize.VisualProperties.XAxisMinimumFixedValue = 0;
+        qualityToTreeSize.VisualProperties.XAxisMaximumFixedValue = MaximumSymbolicExpressionTreeLengthParameter.ActualValue.Value;
+        qualityToTreeSize.VisualProperties.YAxisMinimumFixedValue = 0;
+        qualityToTreeSize.VisualProperties.YAxisMaximumFixedValue = 2;
+        ResultCollection.Add(new Result("Pareto Front Analysis", qualityToTreeSize));
+      } else {
+        qualityToTreeSize = (ScatterPlot)result.Value;
+      }
+
+      var problemData = ProblemDataParameter.ActualValue;
+      var constantValue = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, problemData.TrainingIndices).Average();
+      var constantSolution = CreateConstantSymbolicRegressionSolution(constantValue);
+
+      int previousTreeLength = constantSolution.Model.SymbolicExpressionTree.Length;
+      var sizeParetoFront = new LinkedList<ISymbolicRegressionSolution>();
+      sizeParetoFront.AddLast(constantSolution);
+
+      foreach (var solution in paretoFront.OrderBy(s => s.Model.SymbolicExpressionTree.Length)) {
+        int treeLength = solution.Model.SymbolicExpressionTree.Length;
+        if (!sizeParetoFront.Any()) sizeParetoFront.AddLast(solution);
+        if (solution.TrainingNormalizedMeanSquaredError < sizeParetoFront.Last.Value.TrainingNormalizedMeanSquaredError) {
+          if (treeLength == previousTreeLength)
+            sizeParetoFront.RemoveLast();
+          sizeParetoFront.AddLast(solution);
+        }
+        previousTreeLength = treeLength;
+      }
+
+      qualityToTreeSize.Rows.Clear();
+      var trainingRow = new ScatterPlotDataRow("Training NMSE", "", sizeParetoFront.Select(x => new Point2D<double>(x.Model.SymbolicExpressionTree.Length, x.TrainingNormalizedMeanSquaredError)));
+      trainingRow.VisualProperties.PointSize = 5;
+      var testRow = new ScatterPlotDataRow("Test NMSE", "", sizeParetoFront.Select(x => new Point2D<double>(x.Model.SymbolicExpressionTree.Length, x.TestNormalizedMeanSquaredError)));
+      testRow.VisualProperties.PointSize = 5;
+      qualityToTreeSize.Rows.Add(trainingRow);
+      qualityToTreeSize.Rows.Add(testRow);
+
+      double trainingHyperVolume, testHyperVolume;
+      CalculateNormalizedHyperVolume(sizeParetoFront, out trainingHyperVolume, out testHyperVolume);
+
+      DoubleValue trainingHyperVolumeResult, testHyperVolumeResult;
+      if (!ResultCollection.TryGetValue("HyperVolume training", out result)) {
+        trainingHyperVolumeResult = new DoubleValue();
+        ResultCollection.Add(new Result("HyperVolume training", trainingHyperVolumeResult));
+      } else trainingHyperVolumeResult = (DoubleValue)result.Value;
+
+      if (!ResultCollection.TryGetValue("HyperVolume test", out result)) {
+        testHyperVolumeResult = new DoubleValue();
+        ResultCollection.Add(new Result("HyperVolume test", testHyperVolumeResult));
+      } else testHyperVolumeResult = (DoubleValue)result.Value;
+
+      trainingHyperVolumeResult.Value = trainingHyperVolume;
+      testHyperVolumeResult.Value = testHyperVolume;
+
+      return operation;
+    }
+
+    private void CalculateNormalizedHyperVolume(IEnumerable<ISymbolicRegressionSolution> solutions, out double trainingHyperVolume, out double testHyperVolume) {
+      trainingHyperVolume = 0.0;
+      testHyperVolume = 0.0;
+
+      var prevX = 0;
+      var prevYTraining = 1.0;
+      var prevYTest = 1.0;
+      var treeSize = 0;
+
+      foreach (var solution in solutions) {
+        treeSize = solution.Model.SymbolicExpressionTree.Length;
+        trainingHyperVolume += (prevYTraining + solution.TrainingNormalizedMeanSquaredError) * (treeSize - prevX) / 2;
+        testHyperVolume += (prevYTest + solution.TestNormalizedMeanSquaredError) * (treeSize - prevX) / 2;
+        prevX = treeSize;
+        prevYTraining = solution.TrainingNormalizedMeanSquaredError;
+        prevYTest = solution.TestNormalizedMeanSquaredError;
+      }
+
+      trainingHyperVolume = trainingHyperVolume / treeSize;
+      testHyperVolume = testHyperVolume / treeSize;
+    }
+
+    private ISymbolicRegressionSolution CreateConstantSymbolicRegressionSolution(double constantValue) {
+      var grammar = new ArithmeticExpressionGrammar();
+      var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode();
+      var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode();
+      var constantTreeNode = new ConstantTreeNode(new Constant()) { Value = constantValue };
+      rootNode.AddSubtree(startNode);
+      startNode.AddSubtree(constantTreeNode);
+      var tree = new SymbolicExpressionTree();
+      tree.Root = rootNode;
+
+      var model = new SymbolicRegressionModel(tree, SymbolicDataAnalysisTreeInterpreterParameter.ActualValue);
+      var solution = new SymbolicRegressionSolution(model, ProblemDataParameter.ActualValue);
+      return solution;
+    }
   }
 }