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

Timestamp:

02/27/12 16:11:34 (13 years ago)

Author:

sforsten

Message:

#1776:

• 2 more strategies have been implemented
• major changes in the inheritance have been made to make it possible to add strategies which don't use a voting strategy with weights
• ClassificationEnsembleSolutionEstimatedClassValuesView doesn't currently show the confidence (has been removed for test purpose)

Location:

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

Files:

• ClassificationEnsembleSolution.cs (modified) (8 diffs)
• WeightCalculators/AccuracyWeightCalculator.cs (modified) (2 diffs)
• WeightCalculators/ClassificationWeightCalculator.cs (added)
• WeightCalculators/ContinuousPointCertaintyWeightCalculator.cs (added)
• WeightCalculators/DiscriminantClassificationWeightCalculator.cs (added)
• WeightCalculators/MajorityVoteWeightCalculator.cs (modified) (1 diff)
• WeightCalculators/MedianThresholdCalculator.cs (added)
• WeightCalculators/NeighbourhoodWeightCalculator.cs (modified) (3 diffs)
• WeightCalculators/PointCertaintyWeightCalculator.cs (modified) (3 diffs)
• WeightCalculators/WeightCalculator.cs (deleted)

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

@@ -51 +51 @@
     }
 
-    public IEnumerable<double> Weights {
-      get { return new List<double>(weights); }
-    }
-
     [Storable]
     private Dictionary<IClassificationModel, IntRange> trainingPartitions;
@@ -60 +56 @@
     private Dictionary<IClassificationModel, IntRange> testPartitions;
 
-    private IEnumerable<double> weights;
-
     private IClassificationEnsembleSolutionWeightCalculator weightCalculator;
 
@@ -68 +62 @@
         if (value != null) {
           weightCalculator = value;
-          weights = weights = weightCalculator.CalculateNormalizedWeights(classificationSolutions);
+          weightCalculator.CalculateNormalizedWeights(classificationSolutions);
           if (!ProblemData.IsEmpty)
             RecalculateResults();
@@ -169 +163 @@
     #region Evaluation
     public override IEnumerable<double> EstimatedTrainingClassValues {
-      get {
-        var rows = ProblemData.TrainingIndizes;
-        var estimatedValuesEnumerators = (from model in Model.Models
-                                          select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedClassValues(ProblemData.Dataset, rows).GetEnumerator() })
-                                         .ToList();
-        var rowsEnumerator = rows.GetEnumerator();
-        // 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)) {
-          int currentRow = rowsEnumerator.Current;
-
-          var selectedEnumerators = from pair in estimatedValuesEnumerators
-                                    where RowIsTrainingForModel(currentRow, pair.Model) && !RowIsTestForModel(currentRow, pair.Model)
-                                    select pair.EstimatedValuesEnumerator;
-          yield return AggregateEstimatedClassValues(selectedEnumerators.Select(x => x.Current), weights);
-        }
-      }
+      get { return weightCalculator.AggregateEstimatedClassValues(Model.Models, ProblemData.Dataset, ProblemData.TrainingIndizes); }
     }
 
     public override IEnumerable<double> EstimatedTestClassValues {
-      get {
-        var rows = ProblemData.TestIndizes;
-        var estimatedValuesEnumerators = (from model in Model.Models
-                                          select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedClassValues(ProblemData.Dataset, rows).GetEnumerator() })
-                                         .ToList();
-        var rowsEnumerator = ProblemData.TestIndizes.GetEnumerator();
-        // 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)) {
-          int currentRow = rowsEnumerator.Current;
-
-          var selectedEnumerators = from pair in estimatedValuesEnumerators
-                                    where RowIsTestForModel(currentRow, pair.Model)
-                                    select pair.EstimatedValuesEnumerator;
-
-          yield return AggregateEstimatedClassValues(selectedEnumerators.Select(x => x.Current), weights);
-        }
-      }
+      get { return weightCalculator.AggregateEstimatedClassValues(Model.Models, ProblemData.Dataset, ProblemData.TestIndizes); }
     }
 
@@ -218 +181 @@
 
     public override IEnumerable<double> GetEstimatedClassValues(IEnumerable<int> rows) {
-      return from xs in GetEstimatedClassValueVectors(ProblemData.Dataset, rows)
-             select AggregateEstimatedClassValues(xs, weights);
+      return weightCalculator.AggregateEstimatedClassValues(Model.Models, ProblemData.Dataset, rows);
     }
 
@@ -232 +194 @@
                      select enumerator.Current;
       }
-    }
-
-    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
@@ -316 +250 @@
       trainingPartitions[solution.Model] = solution.ProblemData.TrainingPartition;
       testPartitions[solution.Model] = solution.ProblemData.TestPartition;
-      weights = weightCalculator.CalculateNormalizedWeights(classificationSolutions);
+      weightCalculator.CalculateNormalizedWeights(classificationSolutions);
     }
 
@@ -324 +258 @@
       trainingPartitions.Remove(solution.Model);
       testPartitions.Remove(solution.Model);
-      weights = weightCalculator.CalculateNormalizedWeights(classificationSolutions);
+      weightCalculator.CalculateNormalizedWeights(classificationSolutions);
     }
   }

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

@@ -32 +32 @@
   [StorableClass]
   [Item("AccuracyWeightCalculator", "Represents a weight calculator that gives every classification solution a weight based on the accuracy.")]
-  public class AccuracyWeightCalculator : WeightCalculator {
+  public class AccuracyWeightCalculator : ClassificationWeightCalculator {
 
     public AccuracyWeightCalculator()
       : base() {
     }
-
     [StorableConstructor]
     protected AccuracyWeightCalculator(bool deserializing) : base(deserializing) { }
@@ -43 +42 @@
       : base(original, cloner) {
     }
-
     public override IDeepCloneable Clone(Cloner cloner) {
       return new AccuracyWeightCalculator(this, cloner);

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

@@ -32 +32 @@
   [StorableClass]
   [Item("MajorityVoteWeightCalculator", "Represents a weight calculator that gives every classification solution the same weight.")]
-  public class MajorityVoteWeightCalculator : WeightCalculator {
+  public class MajorityVoteWeightCalculator : ClassificationWeightCalculator {
 
     public MajorityVoteWeightCalculator()

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

@@ -33 +33 @@
   [StorableClass]
   [Item("NeighbourhoodWeightCalculator", "")]
-  public class NeighbourhoodWeightCalculator : WeightCalculator {
+  public class NeighbourhoodWeightCalculator : DiscriminantClassificationWeightCalculator {
 
     public NeighbourhoodWeightCalculator()
@@ -49 +49 @@
     }
 
-    protected override IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
-      if (classificationSolutions.Count <= 0)
-        return new List<double>();
-
-      if (!classificationSolutions.All(x => x is IDiscriminantFunctionClassificationSolution))
-        return Enumerable.Repeat<double>(1, classificationSolutions.Count);
-
+    protected override IEnumerable<double> DiscriminantCalculateWeights(ItemCollection<IDiscriminantFunctionClassificationSolution> discriminantSolutions) {
       List<List<double>> estimatedTrainingValEnumerators = new List<List<double>>();
       List<List<double>> estimatedTrainingClassValEnumerators = new List<List<double>>();
-      IDiscriminantFunctionClassificationSolution discriminantSolution;
-      foreach (var solution in classificationSolutions) {
-        discriminantSolution = (IDiscriminantFunctionClassificationSolution)solution;
-        estimatedTrainingValEnumerators.Add(discriminantSolution.EstimatedTrainingValues.ToList());
-        estimatedTrainingClassValEnumerators.Add(discriminantSolution.EstimatedTrainingClassValues.ToList());
+      foreach (var solution in discriminantSolutions) {
+        estimatedTrainingValEnumerators.Add(solution.EstimatedTrainingValues.ToList());
+        estimatedTrainingClassValEnumerators.Add(solution.EstimatedTrainingClassValues.ToList());
       }
 
-      List<double> weights = Enumerable.Repeat<double>(0, classificationSolutions.Count()).ToList<double>();
+      List<double> weights = Enumerable.Repeat<double>(0, discriminantSolutions.Count()).ToList<double>();
 
-      IClassificationProblemData problemData = classificationSolutions.ElementAt(0).ProblemData;
+      IClassificationProblemData problemData = discriminantSolutions.ElementAt(0).ProblemData;
       List<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable).ToList();
       List<double> trainingVal = GetValues(targetValues, problemData.TrainingIndizes).ToList();
@@ -93 +85 @@
       return weights;
     }
-
-    private IEnumerable<double> GetValues(IList<double> targetValues, IEnumerable<int> indizes) {
-      return from i in indizes
-             select targetValues[i];
-    }
   }
 }

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

@@ -28 +28 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
-  /// <summary>
-  /// 
-  /// </summary>
   [StorableClass]
   [Item("PointCertaintyWeightCalculator", "")]
-  public class PointCertaintyWeightCalculator : WeightCalculator {
+  public class PointCertaintyWeightCalculator : DiscriminantClassificationWeightCalculator {
 
     public PointCertaintyWeightCalculator()
       : base() {
     }
-
     [StorableConstructor]
     protected PointCertaintyWeightCalculator(bool deserializing) : base(deserializing) { }
@@ -44 +40 @@
       : base(original, cloner) {
     }
-
     public override IDeepCloneable Clone(Cloner cloner) {
       return new PointCertaintyWeightCalculator(this, cloner);
     }
 
-    protected override IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
-      if (classificationSolutions.Count <= 0)
-        return new List<double>();
-
-      if (!classificationSolutions.All(x => x is IDiscriminantFunctionClassificationSolution))
-        return Enumerable.Repeat<double>(1, classificationSolutions.Count);
-
-      ItemCollection<IDiscriminantFunctionClassificationSolution> discriminantSolutions = new ItemCollection<IDiscriminantFunctionClassificationSolution>();
-      foreach (var solution in classificationSolutions) {
-        discriminantSolutions.Add((IDiscriminantFunctionClassificationSolution)solution);
-      }
-
+    protected override IEnumerable<double> DiscriminantCalculateWeights(ItemCollection<IDiscriminantFunctionClassificationSolution> discriminantSolutions) {
       List<double> weights = new List<double>();
-      IClassificationProblemData problemData = classificationSolutions.ElementAt(0).ProblemData;
+      IClassificationProblemData problemData = discriminantSolutions.ElementAt(0).ProblemData;
       IEnumerable<double> targetValues = GetValues(problemData.Dataset.GetDoubleValues(problemData.TargetVariable).ToList(), problemData.TrainingIndizes);
       IEnumerator<double> trainingValues;
@@ -87 +71 @@
       return weights;
     }
-
-    private IEnumerable<double> GetValues(IList<double> targetValues, IEnumerable<int> indizes) {
-      return from i in indizes
-             select targetValues[i];
-    }
   }
 }