Changeset 4272 for branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/FixedValidationBestScaledSymbolicRegressionSolutionAnalyzer.cs

Timestamp:

08/20/10 17:42:27 (14 years ago)

Author:

gkronber

Message:

Worked on overfitting analyzer and CPP. #1142

File:

• branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/FixedValidationBestScaledSymbolicRegressionSolutionAnalyzer.cs (modified) (8 diffs)

branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/FixedValidationBestScaledSymbolicRegressionSolutionAnalyzer.cs

@@ -140 +140 @@
       get { return (ILookupParameter<SymbolicRegressionSolution>)Parameters[BestSolutionParameterName]; }
     }
+    public ILookupParameter<SymbolicRegressionSolution> BestTrainingSolutionParameter {
+      get { return (ILookupParameter<SymbolicRegressionSolution>)Parameters["BestTrainingSolution"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
     public ILookupParameter<IntValue> GenerationsParameter {
       get { return (ILookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
@@ -228 +235 @@
       Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower estimation limit that was set for the evaluation of the symbolic expression trees."));
       Parameters.Add(new LookupParameter<SymbolicRegressionSolution>(BestSolutionParameterName, "The best symbolic regression solution."));
+      Parameters.Add(new LookupParameter<SymbolicRegressionSolution>("BestTrainingSolution"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality"));
       Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations calculated so far."));
       Parameters.Add(new LookupParameter<DoubleValue>(BestSolutionQualityParameterName, "The quality of the best symbolic regression solution."));
@@ -252 +261 @@
         Parameters.Add(new LookupParameter<DataTable>(BestSolutionQualityValuesParameterName));
       }
+      if (!Parameters.ContainsKey("BestTrainingSolution")) {
+        Parameters.Add(new LookupParameter<SymbolicRegressionSolution>("BestTrainingSolution"));
+      }
+      if (!Parameters.ContainsKey("Quality")) {
+        Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality"));
+      }
       #endregion
     }
 
     public override IOperation Apply() {
-      var trees = SymbolicExpressionTree;
+      ItemArray<SymbolicExpressionTree> trees = SymbolicExpressionTree;
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
 
       string targetVariable = ProblemData.TargetVariable.Value;
@@ -273 +289 @@
       double bestQuality = Maximization.Value ? double.NegativeInfinity : double.PositiveInfinity;
       SymbolicExpressionTree bestTree = null;
-
-      foreach (var tree in trees) {
+      SymbolicExpressionTree bestTrainingTree = trees[0];
+      double bestTrainingQuality = qualities[0].Value;
+      for (int i = 0; i < trees.Length; i++) {
+        SymbolicExpressionTree tree = trees[i];
         double quality = Evaluator.Evaluate(SymbolicExpressionTreeInterpreter, tree,
           lowerEstimationLimit, upperEstimationLimit,
@@ -285 +303 @@
           bestTree = tree;
         }
-      }
+        if ((Maximization.Value && qualities[i].Value > bestTrainingQuality) ||
+            (!Maximization.Value && qualities[i].Value < bestTrainingQuality)) {
+          bestTrainingQuality = qualities[i].Value;
+          bestTrainingTree = tree;
+        }
+      }
+
+      var scaledBestTrainingTree = GetScaledTree(bestTrainingTree);
+
+      SymbolicRegressionSolution bestTrainingSolution = new SymbolicRegressionSolution(ProblemData,
+        new SymbolicRegressionModel(SymbolicExpressionTreeInterpreter, scaledBestTrainingTree),
+        lowerEstimationLimit, upperEstimationLimit);
+      bestTrainingSolution.Name = "Best solution (training)";
+      bestTrainingSolution.Description = "The solution of the population with the highest fitness";
 
       // if the best validation tree is better than the current best solution => update
@@ -293 +324 @@
         (!Maximization.Value && bestQuality < BestSolutionQuality.Value);
       if (newBest) {
-        // calculate scaling parameters and only for the best tree using the full training set
-        double alpha, beta;
-        int trainingStart = ProblemData.TrainingSamplesStart.Value;
-        int trainingEnd = ProblemData.TrainingSamplesEnd.Value;
-        IEnumerable<int> trainingRows = Enumerable.Range(trainingStart, trainingEnd - trainingStart);
-        IEnumerable<double> originalValues = ProblemData.Dataset.GetEnumeratedVariableValues(targetVariable, trainingRows);
-        IEnumerable<double> estimatedValues = SymbolicExpressionTreeInterpreter.GetSymbolicExpressionTreeValues(bestTree, ProblemData.Dataset, trainingRows);
-
-        SymbolicRegressionScaledMeanSquaredErrorEvaluator.CalculateScalingParameters(originalValues, estimatedValues, out beta, out alpha);
-
-        // scale tree for solution
-        var scaledTree = SymbolicRegressionSolutionLinearScaler.Scale(bestTree, alpha, beta);
+        var scaledTree = GetScaledTree(bestTree);
         var model = new SymbolicRegressionModel((ISymbolicExpressionTreeInterpreter)SymbolicExpressionTreeInterpreter.Clone(),
           scaledTree);
@@ -323 +343 @@
         Results.Add(new Result(BestSolutionQualityParameterName, new DoubleValue()));
         Results.Add(new Result(CurrentBestValidationQualityParameterName, new DoubleValue()));
+        Results.Add(new Result("Best solution (training)", bestTrainingSolution));
       }
       Results[BestSolutionQualityParameterName].Value = new DoubleValue(BestSolutionQualityParameter.ActualValue.Value);
       Results[CurrentBestValidationQualityParameterName].Value = new DoubleValue(bestQuality);
+      Results["Best solution (training)"].Value = bestTrainingSolution;
 
       DataTable validationValues = (DataTable)Results[BestSolutionQualityValuesParameterName].Value;
@@ -332 +354 @@
 
       BestSolutionQualityValuesParameter.ActualValue = validationValues;
-      
+
       return base.Apply();
+    }
+
+    private SymbolicExpressionTree GetScaledTree(SymbolicExpressionTree tree) {
+      // calculate scaling parameters and only for the best tree using the full training set
+      double alpha, beta;
+      int trainingStart = ProblemData.TrainingSamplesStart.Value;
+      int trainingEnd = ProblemData.TrainingSamplesEnd.Value;
+      IEnumerable<int> trainingRows = Enumerable.Range(trainingStart, trainingEnd - trainingStart);
+      IEnumerable<double> originalValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable.Value, trainingRows);
+      IEnumerable<double> estimatedValues = SymbolicExpressionTreeInterpreter.GetSymbolicExpressionTreeValues(tree, ProblemData.Dataset, trainingRows);
+
+      SymbolicRegressionScaledMeanSquaredErrorEvaluator.CalculateScalingParameters(originalValues, estimatedValues, out beta, out alpha);
+
+      // scale tree for solution
+      return SymbolicRegressionSolutionLinearScaler.Scale(tree, alpha, beta);
     }