Changeset 8946 for trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification

Timestamp:

11/27/12 11:02:09 (12 years ago)

Author:

mkommend

Message:

#1763: Merged remaining changes from the TreeSimplifier branch in the trunk and refactored impact values calculators.

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification

Files:

• . (modified) (1 prop)
• 3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification-3.4.csproj (modified) (3 diffs)
• 3.4/Properties (modified) (1 prop)
• 3.4/SymbolicClassificationSolutionImpactValuesCalculator.cs (copied) (copied from branches/HeuristicLab.TreeSimplifier/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationSolutionImpactValuesCalculator.cs) (1 diff)

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification-3.4.csproj

@@ -120 +120 @@
     <Compile Include="ModelCreators\NormalDistributedThresholdsModelCreator.cs" />
     <Compile Include="MultiObjective\SymbolicClassificationMultiObjectiveValidationBestSolutionAnalyzer.cs" />
+    <Compile Include="SymbolicClassificationSolutionImpactValuesCalculator.cs" />
     <Compile Include="SymbolicNearestNeighbourClassificationModel.cs" />
     <Compile Include="Plugin.cs" />
@@ -258 +259 @@
   -->
   <PropertyGroup>
-   <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
 set ProjectDir=$(ProjectDir)
 set SolutionDir=$(SolutionDir)
@@ -265 +266 @@
 call PreBuildEvent.cmd
 </PreBuildEvent>
-<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
 export ProjectDir=$(ProjectDir)
 export SolutionDir=$(SolutionDir)

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

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
-  public class SymbolicDiscriminantFunctionClassificationSolutionImpactValuesCalculator : SymbolicDataAnalysisSolutionImpactValuesCalculator {
-    public override IEnumerable<Tuple<ISymbolicExpressionTreeNode, double>> CalculateReplacementValues(ISymbolicExpressionTree tree,
-                                                                                                       ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
-                                                                                                       IDataAnalysisProblemData problemData) {
-      return from node in tree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPrefix()
-             select new Tuple<ISymbolicExpressionTreeNode, double>(node, CalculateReplacementValue(node, tree, interpreter, problemData));
+  public class SymbolicClassificationSolutionImpactValuesCalculator : SymbolicDataAnalysisSolutionImpactValuesCalculator {
+    public override double CalculateReplacementValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows) {
+      var classificationModel = (ISymbolicClassificationModel)model;
+      var classificationProblemData = (IClassificationProblemData)problemData;
+
+      return CalculateReplacementValue(node, classificationModel.SymbolicExpressionTree, classificationModel.Interpreter, classificationProblemData.Dataset, rows);
     }
 
-    public override IEnumerable<Tuple<ISymbolicExpressionTreeNode, double>> CalculateImpactValues(ISymbolicExpressionTree tree,
-                                                                                                  ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
-                                                                                                  IDataAnalysisProblemData classificationProblemData,
-                                                                                                  double lowerEstimationLimit, double upperEstimationLimit) {
-      var problemData = (IClassificationProblemData)classificationProblemData;
-      var dataset = problemData.Dataset;
-      var rows = problemData.TrainingIndices;
-      string targetVariable = problemData.TargetVariable;
-      var targetClassValues = dataset.GetDoubleValues(targetVariable, rows);
-      var originalOutput = interpreter.GetSymbolicExpressionTreeValues(tree, dataset, rows).LimitToRange(lowerEstimationLimit, upperEstimationLimit).ToArray();
+    public override double CalculateImpactValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows, double originalQuality = double.NaN) {
+      var classificationModel = (ISymbolicClassificationModel)model;
+      var classificationProblemData = (IClassificationProblemData)problemData;
+
+      var dataset = classificationProblemData.Dataset;
+      var targetClassValues = dataset.GetDoubleValues(classificationProblemData.TargetVariable, rows);
+
       OnlineCalculatorError errorState;
-      double originalGini = NormalizedGiniCalculator.Calculate(targetClassValues, originalOutput, out errorState);
-      if (errorState != OnlineCalculatorError.None) originalGini = 0.0;
+      if (double.IsNaN(originalQuality)) {
+        var originalClassValues = classificationModel.GetEstimatedClassValues(dataset, rows);
+        originalQuality = OnlineAccuracyCalculator.Calculate(targetClassValues, originalClassValues, out errorState);
+        if (errorState != OnlineCalculatorError.None) originalQuality = 0.0;
+      }
 
-      return from node in tree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPostfix()
-             select new Tuple<ISymbolicExpressionTreeNode, double>(node, CalculateImpact(tree, originalGini, node, interpreter, problemData, lowerEstimationLimit, upperEstimationLimit));
+      var replacementValue = CalculateReplacementValue(classificationModel, node, classificationProblemData, rows);
+      var constantNode = new ConstantTreeNode(new Constant()) { Value = replacementValue };
+      var cloner = new Cloner();
+      cloner.RegisterClonedObject(node, constantNode);
+      var tempModel = cloner.Clone(classificationModel);
+      tempModel.RecalculateModelParameters(classificationProblemData, rows);
+
+      var estimatedClassValues = tempModel.GetEstimatedClassValues(dataset, rows);
+      double newQuality = OnlineAccuracyCalculator.Calculate(targetClassValues, estimatedClassValues, out errorState);
+      if (errorState != OnlineCalculatorError.None) newQuality = 0.0;
+
+      return originalQuality - newQuality;
     }
 
-    private static double CalculateImpact(ISymbolicExpressionTree tree, double originalQuality, ISymbolicExpressionTreeNode node,
-                                          ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, IClassificationProblemData problemData,
-                                          double lowerEstimationLimit, double upperEstimationLimit) {
-      var dataset = problemData.Dataset;
-      var rows = problemData.TrainingIndices.ToList();
-      string targetVariable = problemData.TargetVariable;
-      var targetValues = dataset.GetDoubleValues(targetVariable, rows).ToList();
-
-      var parent = node.Parent;
-      var constantNode = (ConstantTreeNode)new Constant().CreateTreeNode();
-      constantNode.Value = CalculateReplacementValue(node, tree, interpreter, problemData);
-      SwitchNode(parent, node, constantNode);
-      var newOutput = interpreter.GetSymbolicExpressionTreeValues(tree, dataset, rows)
-                                 .LimitToRange(lowerEstimationLimit, upperEstimationLimit)
-                                 .ToArray();
-      OnlineCalculatorError errorState;
-      double quality = NormalizedGiniCalculator.Calculate(targetValues, newOutput, out errorState);
-      if (errorState != OnlineCalculatorError.None) quality = 0.0;
-      SwitchNode(parent, constantNode, node);
-      // impact = 0 if no change
-      // impact < 0 if new solution is better
-      // impact > 0 if new solution is worse
-      return originalQuality - quality;
-    }
   }
 }