Changeset 7729 for branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation

Timestamp:

04/16/12 09:14:38 (13 years ago)

Author:

sforsten

Message:

#1776:

• bugfix the method GetEstimatedValues of DiscriminantClassificationWeightCalculator returns real values and not class values
• changed arguments of method DiscriminantAggregateEstimatedClassValues of DiscriminantClassificationWeightCalculator
• added two calculators

Location:

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

Files:

• AverageThresholdCalculator.cs (added)
• DiscriminantClassificationWeightCalculator.cs (modified) (3 diffs)
• MedianPointThresholdCalculator.cs (added)
• MedianThresholdCalculator.cs (modified) (3 diffs)

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

@@ -59 +59 @@
 
       IEnumerable<IDictionary<IClassificationSolution, double>> estimatedClassValues = GetEstimatedClassValues(solutions, dataset, rows, handler);
-      IEnumerable<IDictionary<IClassificationSolution, double>> estimatedValues = GetEstimatedValues(discriminantSolutions, dataset, rows, handler);
+      IEnumerable<IDictionary<IDiscriminantFunctionClassificationSolution, double>> estimatedValues = GetEstimatedValues(discriminantSolutions, dataset, rows, handler);
 
       return from zip in estimatedClassValues.Zip(estimatedValues, (classValues, values) => new { ClassValues = classValues, Values = values })
@@ -65 +65 @@
     }
 
-    protected virtual double DiscriminantAggregateEstimatedClassValues(IDictionary<IClassificationSolution, double> estimatedClassValues, IDictionary<IClassificationSolution, double> estimatedValues) {
+    protected virtual double DiscriminantAggregateEstimatedClassValues(IDictionary<IClassificationSolution, double> estimatedClassValues, IDictionary<IDiscriminantFunctionClassificationSolution, double> estimatedValues) {
       return AggregateEstimatedClassValues(estimatedClassValues);
     }
 
-    protected IEnumerable<IDictionary<IClassificationSolution, double>> GetEstimatedValues(IEnumerable<IDiscriminantFunctionClassificationSolution> solutions, Dataset dataset, IEnumerable<int> rows, CheckPoint handler) {
+    protected IEnumerable<IDictionary<IDiscriminantFunctionClassificationSolution, double>> GetEstimatedValues(IEnumerable<IDiscriminantFunctionClassificationSolution> solutions, Dataset dataset, IEnumerable<int> rows, CheckPoint handler) {
       var estimatedValuesEnumerators = (from solution in solutions
-                                        select new { Solution = solution, EstimatedValuesEnumerator = solution.Model.GetEstimatedClassValues(dataset, rows).GetEnumerator() })
+                                        select new { Solution = solution, EstimatedValuesEnumerator = solution.Model.GetEstimatedValues(dataset, rows).GetEnumerator() })
                                         .ToList();
 
@@ -79 +79 @@
                       where handler(enumerator.Solution.ProblemData, rowEnumerator.Current)
                       select enumerator)
-                      .ToDictionary(x => (IClassificationSolution)x.Solution, x => x.EstimatedValuesEnumerator.Current);
+                      .ToDictionary(x => x.Solution, x => x.EstimatedValuesEnumerator.Current);
       }
     }

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

@@ -47 +47 @@
     protected double[] classValues;
 
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="discriminantSolutions"></param>
-    /// <returns>median instead of weights, because it doesn't use any weights</returns>
     protected override IEnumerable<double> DiscriminantCalculateWeights(IEnumerable<IDiscriminantFunctionClassificationSolution> discriminantSolutions) {
-      List<List<double>> estimatedValues = new List<List<double>>();
-      List<List<double>> estimatedClassValues = new List<List<double>>();
-
-      List<IClassificationProblemData> solutionProblemData = discriminantSolutions.Select(sol => sol.ProblemData).ToList();
-      Dataset dataSet = solutionProblemData[0].Dataset;
-      IEnumerable<int> rows = Enumerable.Range(0, dataSet.Rows);
-      foreach (var solution in discriminantSolutions) {
-        estimatedValues.Add(solution.Model.GetEstimatedValues(dataSet, rows).ToList());
-        estimatedClassValues.Add(solution.Model.GetEstimatedValues(dataSet, rows).ToList());
+      classValues = discriminantSolutions.First().Model.ClassValues.ToArray();
+      var modelThresholds = discriminantSolutions.Select(x => x.Model.Thresholds.ToArray());
+      threshold = new double[modelThresholds.First().GetLength(0)];
+      for (int i = 0; i < modelThresholds.First().GetLength(0); i++) {
+        threshold[i] = GetMedian(modelThresholds.Select(x => x[i]).ToList());
       }
-
-      List<double> median = new List<double>();
-      List<double> targetValues = dataSet.GetDoubleValues(solutionProblemData[0].TargetVariable).ToList();
-      IList<double> curTrainingpoints = new List<double>();
-      int removed = 0;
-      int count = targetValues.Count;
-      for (int point = 0; point < count; point++) {
-        curTrainingpoints.Clear();
-        for (int solutionPos = 0; solutionPos < solutionProblemData.Count; solutionPos++) {
-          if (PointInTraining(solutionProblemData[solutionPos], point)) {
-            curTrainingpoints.Add(estimatedValues[solutionPos][point]);
-          }
-        }
-        if (curTrainingpoints.Count > 0)
-          median.Add(GetMedian(curTrainingpoints.OrderBy(p => p).ToList()));
-        else {
-          //remove not used points
-          targetValues.RemoveAt(point - removed);
-          removed++;
-        }
-      }
-      AccuracyMaximizationThresholdCalculator.CalculateThresholds(solutionProblemData[0], median, targetValues, out classValues, out threshold);
       return Enumerable.Repeat<double>(1, discriminantSolutions.Count());
     }
 
-    protected override double DiscriminantAggregateEstimatedClassValues(IDictionary<IClassificationSolution, double> estimatedClassValues, IDictionary<IClassificationSolution, double> estimatedValues) {
+    protected override double DiscriminantAggregateEstimatedClassValues(IDictionary<IClassificationSolution, double> estimatedClassValues, IDictionary<IDiscriminantFunctionClassificationSolution, double> estimatedValues) {
       IList<double> values = estimatedValues.Select(x => x.Value).ToList();
       if (values.Count <= 0)
@@ -122 +91 @@
         else {
           double distance = threshold[1] - classValues[0];
-          return (1 / distance) * (median - classValues[0]);
+          return (1 / distance) * (threshold[1] - median);
         }
       } else if (estimatedClassValue.Equals(classValues[1])) {
@@ -131 +100 @@
         else {
           double distance = classValues[1] - threshold[1];
-          return (1 / distance) * (classValues[1] - median);
+          return (1 / distance) * (median - threshold[1]);
         }
       } else