Changeset 8723 for trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationSolution.cs

Timestamp:

10/03/12 11:38:57 (12 years ago)

Author:

mkommend

Message:

#1964: Added new results to symbolic classification and regression solutions. Additionally, the way results are calculated was refactored and unified.

File:

• trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationSolution.cs (modified) (5 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationSolution.cs

@@ -20 +20 @@
 #endregion
 
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -35 +36 @@
     private const string ModelLengthResultName = "Model Length";
     private const string ModelDepthResultName = "Model Depth";
+
+    private const string EstimationLimitsResultsResultName = "Estimation Limits Results";
+    private const string EstimationLimitsResultName = "Estimation Limits";
+    private const string TrainingUpperEstimationLimitHitsResultName = "Training Upper Estimation Limit Hits";
+    private const string TestLowerEstimationLimitHitsResultName = "Test Lower Estimation Limit Hits";
+    private const string TrainingLowerEstimationLimitHitsResultName = "Training Lower Estimation Limit Hits";
+    private const string TestUpperEstimationLimitHitsResultName = "Test Upper Estimation Limit Hits";
+    private const string TrainingNaNEvaluationsResultName = "Training NaN Evaluations";
+    private const string TestNaNEvaluationsResultName = "Test NaN Evaluations";
 
     public new ISymbolicDiscriminantFunctionClassificationModel Model {
@@ -57 +67 @@
       private set { ((IntValue)this[ModelDepthResultName].Value).Value = value; }
     }
+
+    private ResultCollection EstimationLimitsResultCollection {
+      get { return (ResultCollection)this[EstimationLimitsResultsResultName].Value; }
+    }
+    public DoubleLimit EstimationLimits {
+      get { return (DoubleLimit)EstimationLimitsResultCollection[EstimationLimitsResultName].Value; }
+    }
+
+    public int TrainingUpperEstimationLimitHits {
+      get { return ((IntValue)EstimationLimitsResultCollection[TrainingUpperEstimationLimitHitsResultName].Value).Value; }
+      private set { ((IntValue)EstimationLimitsResultCollection[TrainingUpperEstimationLimitHitsResultName].Value).Value = value; }
+    }
+    public int TestUpperEstimationLimitHits {
+      get { return ((IntValue)EstimationLimitsResultCollection[TestUpperEstimationLimitHitsResultName].Value).Value; }
+      private set { ((IntValue)EstimationLimitsResultCollection[TestUpperEstimationLimitHitsResultName].Value).Value = value; }
+    }
+    public int TrainingLowerEstimationLimitHits {
+      get { return ((IntValue)EstimationLimitsResultCollection[TrainingLowerEstimationLimitHitsResultName].Value).Value; }
+      private set { ((IntValue)EstimationLimitsResultCollection[TrainingLowerEstimationLimitHitsResultName].Value).Value = value; }
+    }
+    public int TestLowerEstimationLimitHits {
+      get { return ((IntValue)EstimationLimitsResultCollection[TestLowerEstimationLimitHitsResultName].Value).Value; }
+      private set { ((IntValue)EstimationLimitsResultCollection[TestLowerEstimationLimitHitsResultName].Value).Value = value; }
+    }
+    public int TrainingNaNEvaluations {
+      get { return ((IntValue)EstimationLimitsResultCollection[TrainingNaNEvaluationsResultName].Value).Value; }
+      private set { ((IntValue)EstimationLimitsResultCollection[TrainingNaNEvaluationsResultName].Value).Value = value; }
+    }
+    public int TestNaNEvaluations {
+      get { return ((IntValue)EstimationLimitsResultCollection[TestNaNEvaluationsResultName].Value).Value; }
+      private set { ((IntValue)EstimationLimitsResultCollection[TestNaNEvaluationsResultName].Value).Value = value; }
+    }
+
     [StorableConstructor]
     private SymbolicDiscriminantFunctionClassificationSolution(bool deserializing) : base(deserializing) { }
@@ -66 +109 @@
       Add(new Result(ModelLengthResultName, "Length of the symbolic classification model.", new IntValue()));
       Add(new Result(ModelDepthResultName, "Depth of the symbolic classification model.", new IntValue()));
-      CalculateSymbolicDiscriminantFunctionClassificationResults();
+
+
+      ResultCollection estimationLimitResults = new ResultCollection();
+      estimationLimitResults.Add(new Result(EstimationLimitsResultName, "", new DoubleLimit()));
+      estimationLimitResults.Add(new Result(TrainingUpperEstimationLimitHitsResultName, "", new IntValue()));
+      estimationLimitResults.Add(new Result(TestUpperEstimationLimitHitsResultName, "", new IntValue()));
+      estimationLimitResults.Add(new Result(TrainingLowerEstimationLimitHitsResultName, "", new IntValue()));
+      estimationLimitResults.Add(new Result(TestLowerEstimationLimitHitsResultName, "", new IntValue()));
+      estimationLimitResults.Add(new Result(TrainingNaNEvaluationsResultName, "", new IntValue()));
+      estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
+      Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
+
+      CalculateResults();
     }
 
@@ -73 +128 @@
     }
 
-    private void CalculateSymbolicDiscriminantFunctionClassificationResults() {
-      CalculateResults();
-      CalculateRegressionResults();
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!ContainsKey(EstimationLimitsResultsResultName)) {
+        ResultCollection estimationLimitResults = new ResultCollection();
+        estimationLimitResults.Add(new Result(EstimationLimitsResultName, "", new DoubleLimit()));
+        estimationLimitResults.Add(new Result(TrainingUpperEstimationLimitHitsResultName, "", new IntValue()));
+        estimationLimitResults.Add(new Result(TestUpperEstimationLimitHitsResultName, "", new IntValue()));
+        estimationLimitResults.Add(new Result(TrainingLowerEstimationLimitHitsResultName, "", new IntValue()));
+        estimationLimitResults.Add(new Result(TestLowerEstimationLimitHitsResultName, "", new IntValue()));
+        estimationLimitResults.Add(new Result(TrainingNaNEvaluationsResultName, "", new IntValue()));
+        estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
+        Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
+        CalculateResults();
+      }
+    }
+
+
+    private void CalculateResults() {
       ModelLength = Model.SymbolicExpressionTree.Length;
       ModelDepth = Model.SymbolicExpressionTree.Depth;
+
+      EstimationLimits.Lower = Model.LowerEstimationLimit;
+      EstimationLimits.Upper = Model.UpperEstimationLimit;
+
+      TrainingUpperEstimationLimitHits = EstimatedTrainingValues.Count(x => x.IsAlmost(Model.UpperEstimationLimit));
+      TestUpperEstimationLimitHits = EstimatedTestValues.Count(x => x.IsAlmost(Model.UpperEstimationLimit));
+      TrainingLowerEstimationLimitHits = EstimatedTrainingValues.Count(x => x.IsAlmost(Model.LowerEstimationLimit));
+      TestLowerEstimationLimitHits = EstimatedTestValues.Count(x => x.IsAlmost(Model.LowerEstimationLimit));
+      TrainingNaNEvaluations = Model.Interpreter.GetSymbolicExpressionTreeValues(Model.SymbolicExpressionTree, ProblemData.Dataset, ProblemData.TrainingIndices).Count(double.IsNaN);
+      TestNaNEvaluations = Model.Interpreter.GetSymbolicExpressionTreeValues(Model.SymbolicExpressionTree, ProblemData.Dataset, ProblemData.TestIndices).Count(double.IsNaN);
     }
 
     protected override void RecalculateResults() {
-      CalculateSymbolicDiscriminantFunctionClassificationResults();
+      base.RecalculateResults();
+      CalculateResults();
     }
   }