Changeset 5736 for branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Implementation

Timestamp:

03/17/11 15:14:45 (14 years ago)

Author:

gkronber

Message:

#1418 implemented linear scaling for classification solutions, fixed bugs interactive simplifier view for classification solutions.

Location:

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Implementation

Files:

• Classification/ClassificationSolution.cs (modified) (1 diff)
• Classification/DiscriminantFunctionClassificationModel.cs (modified) (3 diffs)
• Classification/DiscriminantFunctionClassificationSolution.cs (modified) (2 diffs)
• Classification/ThresholdCalculators/AccuracyMaximizationThresholdCalculator.cs (modified) (1 diff)
• Classification/ThresholdCalculators/NormalDistributionCutPointsThresholdCalculator.cs (modified) (2 diffs)
• Regression/RegressionSolution.cs (modified) (1 diff)

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs

@@ -82 +82 @@
     }
 
-    private void RecalculateResults() {
+    protected void RecalculateResults() {
       double[] estimatedTrainingClassValues = EstimatedTrainingClassValues.ToArray(); // cache values
       IEnumerable<double> originalTrainingClassValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationModel.cs

@@ -40 +40 @@
     [Storable]
     private IRegressionModel model;
+
     [Storable]
     private double[] classValues;
-    // class values are not necessarily sorted in ascending order
     public IEnumerable<double> ClassValues {
       get { return (double[])classValues.Clone(); }
-      set {
-        if (value == null) throw new ArgumentException();
-        double[] newValue = value.ToArray();
-        if (newValue.Length != classValues.Length) throw new ArgumentException();
-        classValues = newValue;
-      }
+      private set { classValues = value.ToArray(); }
     }
+
     [Storable]
     private double[] thresholds;
     public IEnumerable<double> Thresholds {
       get { return (IEnumerable<double>)thresholds.Clone(); }
-      set {
-        thresholds = value.ToArray();
-        OnThresholdsChanged(EventArgs.Empty);
-      }
+      private set { thresholds = value.ToArray(); }
     }
 
@@ -71 +64 @@
       thresholds = (double[])original.thresholds.Clone();
     }
-    public DiscriminantFunctionClassificationModel(IRegressionModel model, IEnumerable<double> classValues, IEnumerable<double> thresholds)
+
+    public DiscriminantFunctionClassificationModel(IRegressionModel model)
       : base() {
       this.name = ItemName;
       this.description = ItemDescription;
       this.model = model;
-      this.classValues = classValues.ToArray();
-      this.thresholds = thresholds.ToArray();
+      this.classValues = new double[] { 0.0 };
+      this.thresholds = new double[] { double.NegativeInfinity };
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
       return new DiscriminantFunctionClassificationModel(this, cloner);
+    }
+
+    public void SetThresholdsAndClassValues(IEnumerable<double> thresholds, IEnumerable<double> classValues) {
+      var classValuesArr = classValues.ToArray();
+      var thresholdsArr = thresholds.ToArray();
+      if (thresholdsArr.Length != classValuesArr.Length) throw new ArgumentException();
+
+      this.classValues = classValuesArr;
+      this.thresholds = thresholdsArr;
+      OnThresholdsChanged(EventArgs.Empty);
     }
 
@@ -96 +100 @@
           else break;
         }
-        yield return classValues.ElementAt(classIndex);
+        yield return classValues.ElementAt(classIndex - 1);
       }
     }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs

@@ -40 +40 @@
     public new IDiscriminantFunctionClassificationModel Model {
       get { return (IDiscriminantFunctionClassificationModel)base.Model; }
-      protected set { base.Model = value; }
+      protected set {
+        if (value != null && value != Model) {
+          if (Model != null) {
+            Model.ThresholdsChanged -= new EventHandler(Model_ThresholdsChanged);
+          }
+          value.ThresholdsChanged += new EventHandler(Model_ThresholdsChanged);
+          base.Model = value;
+        }
+      }
     }
 
@@ -47 +55 @@
     protected DiscriminantFunctionClassificationSolution(DiscriminantFunctionClassificationSolution original, Cloner cloner)
       : base(original, cloner) {
+      RegisterEventHandler();
     }
-    public DiscriminantFunctionClassificationSolution(IRegressionModel model, IClassificationProblemData problemData, IEnumerable<double> classValues, IEnumerable<double> thresholds)
-      : this(new DiscriminantFunctionClassificationModel(model, classValues, thresholds), problemData) {
+    public DiscriminantFunctionClassificationSolution(IRegressionModel model, IClassificationProblemData problemData)
+      : this(new DiscriminantFunctionClassificationModel(model), problemData) {
     }
     public DiscriminantFunctionClassificationSolution(IDiscriminantFunctionClassificationModel model, IClassificationProblemData problemData)
       : base(model, problemData) {
+      RegisterEventHandler();
+      SetAccuracyMaximizingThresholds();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandler();
+    }
+
+    private void RegisterEventHandler() {
+      Model.ThresholdsChanged += new EventHandler(Model_ThresholdsChanged);
+    }
+    private void Model_ThresholdsChanged(object sender, EventArgs e) {
+      OnModelThresholdsChanged(e);
+    }
+
+    public void SetAccuracyMaximizingThresholds() {
+      double[] classValues;
+      double[] thresholds;
+      var targetClassValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
+      AccuracyMaximizationThresholdCalculator.CalculateThresholds(ProblemData, EstimatedTrainingValues, targetClassValues, out classValues, out thresholds);
+
+      Model.SetThresholdsAndClassValues(thresholds, classValues);
+    }
+
+    public void SetClassDistibutionCutPointThresholds() {
+      double[] classValues;
+      double[] thresholds;
+      var targetClassValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
+      NormalDistributionCutPointsThresholdCalculator.CalculateThresholds(ProblemData, EstimatedTrainingValues, targetClassValues, out classValues, out thresholds);
+
+      Model.SetThresholdsAndClassValues(thresholds, classValues);
+    }
+
+    protected override void OnModelChanged(EventArgs e) {
+      base.OnModelChanged(e);     
+      SetAccuracyMaximizingThresholds();
+    }
+
+    protected override void OnProblemDataChanged(EventArgs e) {
+      base.OnProblemDataChanged(e);
+      SetAccuracyMaximizingThresholds();
+    }
+    protected virtual void OnModelThresholdsChanged(EventArgs e) {
+      RecalculateResults();
     }
 

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ThresholdCalculators/AccuracyMaximizationThresholdCalculator.cs

@@ -69 +69 @@
       classValues = problemData.ClassValues.OrderBy(x => x).ToArray();
       int nClasses = classValues.Length;
-      thresholds = new double[nClasses + 1];
+      thresholds = new double[nClasses];
       thresholds[0] = double.NegativeInfinity;
-      thresholds[thresholds.Length - 1] = double.PositiveInfinity;
+      // thresholds[thresholds.Length - 1] = double.PositiveInfinity;
 
       // incrementally calculate accuracy of all possible thresholds
       int[,] confusionMatrix = new int[nClasses, nClasses];
 
-      for (int i = 1; i < thresholds.Length - 1; i++) {
+      for (int i = 1; i < thresholds.Length; i++) {
         double lowerThreshold = thresholds[i - 1];
         double actualThreshold = Math.Max(lowerThreshold, minEstimatedValue);

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ThresholdCalculators/NormalDistributionCutPointsThresholdCalculator.cs

@@ -88 +88 @@
       thresholdList.Sort();
       thresholdList.Insert(0, double.NegativeInfinity);
-      thresholdList.Add(double.PositiveInfinity);
 
       // determine class values for each partition separated by a threshold by calculating the density of all class distributions
       // all points in the partition are classified as the class with the maximal density in the parition
       List<double> classValuesList = new List<double>();
-      for (int i = 0; i < thresholdList.Count - 1; i++) {
+      for (int i = 0; i < thresholdList.Count; i++) {
         double m;
         if (double.IsNegativeInfinity(thresholdList[i])) {
           m = thresholdList[i + 1] - 1.0; // smaller than the smalles non-infinity threshold
-        } else if (double.IsPositiveInfinity(thresholdList[i + 1])) {
-          m = thresholdList[i] + 1.0; // larger than the largest non-infinity threshold
+        } else if (i == thresholdList.Count - 1) {
+          // last threshold
+          m = thresholdList[i] + 1.0; // larger than the last threshold
         } else {
           m = thresholdList[i] + (thresholdList[i + 1] - thresholdList[i]) / 2.0; // middle of partition
@@ -135 +135 @@
         }
       }
-      filteredThresholds.Add(double.PositiveInfinity);
       thresholds = filteredThresholds.ToArray();
       classValues = filteredClassValues.ToArray();

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs

@@ -111 +111 @@
     }
 
-    private void RecalculateResults() {
+    protected void RecalculateResults() {
       double[] estimatedTrainingValues = EstimatedTrainingValues.ToArray(); // cache values
       IEnumerable<double> originalTrainingValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);