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

Timestamp:

02/06/12 16:55:27 (13 years ago)

Author:

sforsten

Message:

#1776: first implementation of different voting strategies (currently no gui elements are available to choose between the strategies)

Location:

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

Files:

• ClassificationEnsembleSolution.cs (modified) (9 diffs)
• WeightCalculators (added)
• WeightCalculators/AccuracyWeightCalculator.cs (added)
• WeightCalculators/MajorityVoteWeightCalculator.cs (added)
• WeightCalculators/WeightCalculator.cs (added)

branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs

@@ -28 +28 @@
 using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Interfaces.Classification;
 
 namespace HeuristicLab.Problems.DataAnalysis {
@@ -55 +56 @@
     private Dictionary<IClassificationModel, IntRange> testPartitions;
 
+    private IClassificationEnsembleSolutionWeightCalculator weightCalculator;
+
     [StorableConstructor]
     private ClassificationEnsembleSolution(bool deserializing)
@@ -95 +98 @@
       classificationSolutions = new ItemCollection<IClassificationSolution>();
 
+      weightCalculator = new AccuracyWeightCalculator();
+
       RegisterClassificationSolutionsEventHandler();
     }
@@ -153 +158 @@
                                          .ToList();
         var rowsEnumerator = rows.GetEnumerator();
+        IEnumerable<double> weights = weightCalculator.CalculateWeights(classificationSolutions);
         // aggregate to make sure that MoveNext is called for all enumerators 
         while (rowsEnumerator.MoveNext() & estimatedValuesEnumerators.Select(en => en.EstimatedValuesEnumerator.MoveNext()).Aggregate(true, (acc, b) => acc & b)) {
@@ -160 +166 @@
                                     where RowIsTrainingForModel(currentRow, pair.Model) && !RowIsTestForModel(currentRow, pair.Model)
                                     select pair.EstimatedValuesEnumerator;
-          yield return AggregateEstimatedClassValues(selectedEnumerators.Select(x => x.Current));
+          yield return AggregateEstimatedClassValues(selectedEnumerators.Select(x => x.Current), weights);
         }
       }
@@ -172 +178 @@
                                          .ToList();
         var rowsEnumerator = ProblemData.TestIndizes.GetEnumerator();
+        IEnumerable<double> weights = weightCalculator.CalculateWeights(classificationSolutions);
         // aggregate to make sure that MoveNext is called for all enumerators 
         while (rowsEnumerator.MoveNext() & estimatedValuesEnumerators.Select(en => en.EstimatedValuesEnumerator.MoveNext()).Aggregate(true, (acc, b) => acc & b)) {
@@ -180 +187 @@
                                     select pair.EstimatedValuesEnumerator;
 
-          yield return AggregateEstimatedClassValues(selectedEnumerators.Select(x => x.Current));
+          yield return AggregateEstimatedClassValues(selectedEnumerators.Select(x => x.Current), weights);
         }
       }
@@ -196 +203 @@
 
     public override IEnumerable<double> GetEstimatedClassValues(IEnumerable<int> rows) {
+      IEnumerable<double> weights = weightCalculator.CalculateWeights(classificationSolutions);
       return from xs in GetEstimatedClassValueVectors(ProblemData.Dataset, rows)
-             select AggregateEstimatedClassValues(xs);
+             select AggregateEstimatedClassValues(xs, weights);
     }
 
@@ -212 +220 @@
     }
 
-    private double AggregateEstimatedClassValues(IEnumerable<double> estimatedClassValues) {
-      return estimatedClassValues
-      .GroupBy(x => x)
-      .OrderBy(g => -g.Count())
-      .Select(g => g.Key)
-      .DefaultIfEmpty(double.NaN)
-      .First();
+    private double AggregateEstimatedClassValues(IEnumerable<double> estimatedClassValues, IEnumerable<double> weights) {
+      IDictionary<double, double> weightSum = new Dictionary<double, double>();
+      for (int i = 0; i < estimatedClassValues.Count(); i++) {
+        if (!weightSum.ContainsKey(estimatedClassValues.ElementAt(i)))
+          weightSum[estimatedClassValues.ElementAt(i)] = 0.0;
+        weightSum[estimatedClassValues.ElementAt(i)] += weights.ElementAt(i);
+      }
+      if (weightSum.Count <= 0)
+        return double.NaN;
+      var max = weightSum.Max(x => x.Value);
+      max = weightSum
+        .Where(x => x.Value.Equals(max))
+        .Select(x => x.Key)
+        .First();
+      return max;
+      //old code
+      //return weightSum
+      //  .Where(x => x.Value.Equals(max))
+      //  .Select(x => x.Key)
+      //  .First();
+      //return estimatedClassValues
+      //.GroupBy(x => x)
+      //.OrderBy(g => -g.Count())
+      //.Select(g => g.Key)
+      //.DefaultIfEmpty(double.NaN)
+      //.First();
     }
     #endregion