Changeset 12049 for branches/SymbolicExpressionTreeDiversityAnalyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective

Timestamp:

02/21/15 15:55:47 (9 years ago)

Author:

bburlacu

Message:

#2326: Addressed the issues found by the reviewer.

Location:

branches/SymbolicExpressionTreeDiversityAnalyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective

Files:

• SymbolicClassificationPhenotypicDiversityAnalyzer.cs (modified) (7 diffs)
• SymbolicClassificationSingleObjectiveProblem.cs (modified) (2 diffs)

branches/SymbolicExpressionTreeDiversityAnalyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationPhenotypicDiversityAnalyzer.cs

@@ -20 +20 @@
 #endregion
 
-using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Analysis;
@@ -30 +29 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Analyzers {
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
   [Item("SymbolicClassificationPhenotypicDiversityAnalyzer", "An analyzer which calculates diversity based on the phenotypic distance between trees")]
   [StorableClass]
@@ -39 +38 @@
     private const string SymbolicDataAnalysisTreeInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
     private const string ProblemDataParameterName = "ProblemData";
+    private const string ModelCreatorParameterName = "ModelCreator";
     private const string EstimationLimitsParameterName = "EstimationLimits";
     private const string UseClassValuesParameterName = "UseClassValues";
@@ -53 +53 @@
       get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicDataAnalysisTreeInterpreterParameterName]; }
     }
+    public ILookupParameter<ISymbolicDiscriminantFunctionClassificationModelCreator> ModelCreatorParameter {
+      get { return (ILookupParameter<ISymbolicDiscriminantFunctionClassificationModelCreator>)Parameters[ModelCreatorParameterName]; }
+    }
     public IValueLookupParameter<IClassificationProblemData> ProblemDataParameter {
       get { return (IValueLookupParameter<IClassificationProblemData>)Parameters[ProblemDataParameterName]; }
@@ -65 +68 @@
 
     #region properties
-    bool UseClassValues {
+    private bool UseClassValues {
       get { return UseClassValuesParameter.Value.Value; }
       set { UseClassValuesParameter.Value.Value = value; }
@@ -78 +81 @@
       Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName, "The interpreter that should be used to calculate the output values of the symbolic data analysis tree."));
       Parameters.Add(new ValueLookupParameter<IClassificationProblemData>(ProblemDataParameterName, "The problem data on which the symbolic data analysis solution should be evaluated."));
+      Parameters.Add(new LookupParameter<ISymbolicDiscriminantFunctionClassificationModelCreator>(ModelCreatorParameterName, "The model creator for creating discriminant function classification models."));
       Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The upper and lower limit that should be used as cut off value for the output values of symbolic data analysis trees."));
-      Parameters.Add(new FixedValueParameter<BoolValue>(UseClassValuesParameterName,
-        "Specifies whether the raw estimated values of the tree or the corresponding class values should be used for similarity calculation.", new BoolValue(false)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(UseClassValuesParameterName, "Specifies whether the raw estimated values of the tree or the corresponding class values should be used for similarity calculation.", new BoolValue(false)));
       #endregion
     }
@@ -100 +103 @@
       var trees = SymbolicExpressionTreeParameter.ActualValue;
       var interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
+      var problemData = ProblemDataParameter.ActualValue;
       var ds = ProblemDataParameter.ActualValue.Dataset;
       var rows = ProblemDataParameter.ActualValue.TrainingIndices;
-
-      if (UseClassValues) {
-        var problemData = ProblemDataParameter.ActualValue;
-        var evaluatedValues = new ItemArray<DoubleArray>(trees.Length);
-        for (int i = 0; i < trees.Length; ++i) {
-          var t = trees[i];
-          double[] classValues, thresholds;
-          var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(t, ds, rows).ToArray();
-          AccuracyMaximizationThresholdCalculator.CalculateThresholds(problemData, estimatedValues,
-            problemData.Dataset.GetDoubleValues(problemData.TargetVariable, problemData.TrainingIndices),
-            out classValues, out thresholds);
-          var estimatedClassValues = new List<double>();
-          foreach (var x in estimatedValues) {
-            int classIndex = 0;
-            // find first threshold value which is larger than x => class index = threshold index + 1
-            for (int j = 0; j < thresholds.Length; j++) {
-              if (x > thresholds[j]) classIndex++;
-              else break;
-            }
-            estimatedClassValues.Add(classValues.ElementAt(classIndex - 1));
-          }
-          evaluatedValues[i] = new DoubleArray(estimatedClassValues.ToArray());
-        }
-        EvaluatedValuesParameter.ActualValue = evaluatedValues;
-      } else {
-        var evaluatedValues = new ItemArray<DoubleArray>(trees.Select(t => new DoubleArray(interpreter.GetSymbolicExpressionTreeValues(t, ds, rows).ToArray())));
-        EvaluatedValuesParameter.ActualValue = evaluatedValues;
+      var modelCreator = ModelCreatorParameter.ActualValue;
+      var estimationLimits = EstimationLimitsParameter.ActualValue;
+      var evaluatedValues = new ItemArray<DoubleArray>(trees.Length);
+      for (int i = 0; i < trees.Length; ++i) {
+        var model = (IDiscriminantFunctionClassificationModel)modelCreator.CreateSymbolicDiscriminantFunctionClassificationModel(trees[i], interpreter, estimationLimits.Lower, estimationLimits.Upper);
+        model.RecalculateModelParameters(problemData, rows);
+        var values = UseClassValues ? model.GetEstimatedClassValues(ds, rows) : model.GetEstimatedValues(ds, rows);
+        evaluatedValues[i] = new DoubleArray(values.ToArray());
       }
+      EvaluatedValuesParameter.ActualValue = evaluatedValues;
       return base.Apply();
     }

branches/SymbolicExpressionTreeDiversityAnalyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveProblem.cs

@@ -24 +24 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.DataAnalysis.Symbolic.Analyzers;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
@@ -147 +146 @@
           op.ModelCreatorParameter.ActualName = ModelCreatorParameter.Name;
       }
+
+      foreach (var op in Operators.OfType<SymbolicClassificationPhenotypicDiversityAnalyzer>()) {
+        var sim = op.SimilarityCalculator as SymbolicExpressionTreePhenotypicSimilarityCalculator;
+        if (sim == null) {
+          op.SimilarityCalculator = new SymbolicExpressionTreePhenotypicSimilarityCalculator {
+            SolutionVariableName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName
+          };
+        } else {
+          sim.SolutionVariableName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+        }
+      }
     }
   }