Changeset 7562 for branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/WeightCalculators

Timestamp:

03/06/12 15:08:13 (13 years ago)

Author:

sforsten

Message:

#1776:

• bug fix in NeighbourhoodWeightCalculator
• added GetConfidence method to IClassificationEnsembleSolutionWeightCalculator
• adjusted the confidence column in ClassificationEnsembleSolutionEstimatedClassValuesView

Location:

branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/WeightCalculators

Files:

• ClassificationWeightCalculator.cs (modified) (1 diff)
• DiscriminantClassificationWeightCalculator.cs (modified) (1 diff)
• MedianThresholdCalculator.cs (modified) (3 diffs)
• NeighbourhoodWeightCalculator.cs (modified) (1 diff)

branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/WeightCalculators/ClassificationWeightCalculator.cs

@@ -113 +113 @@
     }
 
+    public virtual double GetConfidence(IEnumerable<IClassificationSolution> solutions, int index, double estimatedClassValue) {
+      if (solutions.Count() < 1)
+        return double.NaN;
+      Dataset dataset = solutions.First().ProblemData.Dataset;
+      var correctSolutions = solutions.Select(s => new { Solution = s, Values = s.Model.GetEstimatedClassValues(dataset, Enumerable.Repeat(index, 1)).First() })
+                                      .Where(a => a.Values.Equals(estimatedClassValue))
+                                      .Select(a => a.Solution);
+      return (from sol in correctSolutions
+              select weights[sol]).Sum();
+    }
+
     #region Helper
     protected IEnumerable<double> GetValues(IList<double> targetValues, IEnumerable<int> indizes) {

branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/WeightCalculators/DiscriminantClassificationWeightCalculator.cs

@@ -82 +82 @@
       }
     }
+
+    public sealed override double GetConfidence(IEnumerable<IClassificationSolution> solutions, int index, double estimatedClassValue) {
+      if (solutions.Count() < 1 || !solutions.All(x => x is IDiscriminantFunctionClassificationSolution))
+        return double.NaN;
+
+      IEnumerable<IDiscriminantFunctionClassificationSolution> discriminantSolutions = solutions.Cast<IDiscriminantFunctionClassificationSolution>();
+
+      return GetDiscriminantConfidence(discriminantSolutions, index, estimatedClassValue);
+    }
+
+    protected virtual double GetDiscriminantConfidence(IEnumerable<IDiscriminantFunctionClassificationSolution> solutions, int index, double estimatedClassValue) {
+      return base.GetConfidence(solutions, index, estimatedClassValue);
+    }
   }
 }

branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/WeightCalculators/MedianThresholdCalculator.cs

@@ -20 +20 @@
 #endregion
 
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
@@ -84 +85 @@
       }
       AccuracyMaximizationThresholdCalculator.CalculateThresholds(solutionProblemData[0], median, targetValues, out classValues, out threshold);
-      return median;
+      return Enumerable.Repeat<double>(1, discriminantSolutions.Count());
     }
 
     protected override double DiscriminantAggregateEstimatedClassValues(IDictionary<IClassificationSolution, double> estimatedClassValues, IDictionary<IClassificationSolution, double> estimatedValues) {
-      double classValue = classValues.First();
       IList<double> values = estimatedValues.Select(x => x.Value).ToList();
       if (values.Count <= 0)
         return double.NaN;
       double median = GetMedian(values);
+      return GetClassValueToMedian(median);
+    }
+    private double GetClassValueToMedian(double median) {
+      double classValue = classValues.First();
       for (int i = 0; i < classValues.Count(); i++) {
         if (median > threshold[i])
@@ -100 +104 @@
       }
       return classValue;
+    }
+
+    protected override double GetDiscriminantConfidence(IEnumerable<IDiscriminantFunctionClassificationSolution> solutions, int index, double estimatedClassValue) {
+      // only works with binary classification
+      if (!classValues.Count().Equals(2))
+        return double.NaN;
+      Dataset dataset = solutions.First().ProblemData.Dataset;
+      IList<double> values = solutions.Select(s => s.Model.GetEstimatedValues(dataset, Enumerable.Repeat(index, 1)).First()).ToList();
+      if (values.Count <= 0)
+        return double.NaN;
+      double median = GetMedian(values);
+      if (estimatedClassValue.Equals(classValues[0])) {
+        if (median < estimatedClassValue)
+          return 1;
+        else if (median >= threshold[1])
+          return 0;
+        else {
+          double distance = threshold[1] - classValues[0];
+          return (1 / distance) * (median - classValues[0]);
+        }
+      } else if (estimatedClassValue.Equals(classValues[1])) {
+        if (median > estimatedClassValue)
+          return 1;
+        else if (median <= threshold[1])
+          return 0;
+        else {
+          double distance = classValues[1] - threshold[1];
+          return (1 / distance) * (classValues[1] - median);
+        }
+      } else
+        return double.NaN;
     }
 

branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/WeightCalculators/NeighbourhoodWeightCalculator.cs

@@ -58 +58 @@
       foreach (var solution in discriminantSolutions) {
         estimatedValues.Add(solution.Model.GetEstimatedValues(dataSet, rows).ToList());
-        estimatedClassValues.Add(solution.Model.GetEstimatedValues(dataSet, rows).ToList());
+        estimatedClassValues.Add(solution.Model.GetEstimatedClassValues(dataSet, rows).ToList());
       }