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

Timestamp:

03/05/12 17:02:37 (12 years ago)

Author:

sforsten

Message:

#1776:

• models can be selected with a check box
• all strategies are now finished
• major changes have been made to provide the same behaviour when getting the estimated training or test values of an ensemble

File:

• branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/WeightCalculators/ClassificationWeightCalculator.cs (modified) (5 diffs)

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

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.DataAnalysis.Interfaces.Classification;
@@ -45 +45 @@
     }
 
-    private IEnumerable<double> weights;
+    private IDictionary<IClassificationSolution, double> weights;
 
     /// <summary>
@@ -52 +52 @@
     /// <param name="classificationSolutions"></param>
     /// <returns>weights which are equal or bigger than zero</returns>
-    public void CalculateNormalizedWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
+    public void CalculateNormalizedWeights(IEnumerable<IClassificationSolution> classificationSolutions) {
       List<double> weights = new List<double>();
-      if (classificationSolutions.Count > 0) {
+      if (classificationSolutions.Count() > 0) {
         foreach (var weight in CalculateWeights(classificationSolutions)) {
           weights.Add(weight >= 0 ? weight : 0);
         }
       }
-      this.weights = weights.Select(x => x / weights.Sum());
+      double sum = weights.Sum();
+      this.weights = classificationSolutions.Zip(weights, (sol, wei) => new { sol, wei }).ToDictionary(x => x.sol, x => x.wei / sum);
     }
 
-    protected abstract IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions);
+    protected abstract IEnumerable<double> CalculateWeights(IEnumerable<IClassificationSolution> classificationSolutions);
 
-    public virtual IEnumerable<double> AggregateEstimatedClassValues(IEnumerable<IClassificationModel> models, Dataset dataset, IEnumerable<int> rows) {
-      return from xs in ClassificationWeightCalculator.GetEstimatedClassValues(models, dataset, rows)
+    #region delegate CheckPoint
+    public CheckPoint GetTestClassDelegate() {
+      return PointInTest;
+    }
+    public CheckPoint GetTrainingClassDelegate() {
+      return PointInTraining;
+    }
+    public CheckPoint GetAllClassDelegate() {
+      return AllPoints;
+    }
+    #endregion
+
+    public virtual IEnumerable<double> AggregateEstimatedClassValues(IEnumerable<IClassificationSolution> solutions, Dataset dataset, IEnumerable<int> rows, CheckPoint handler) {
+      return from xs in GetEstimatedClassValues(solutions, dataset, rows, handler)
              select AggregateEstimatedClassValues(xs);
     }
 
-    protected double AggregateEstimatedClassValues(IEnumerable<double> estimatedClassValues) {
-      if (!estimatedClassValues.Count().Equals(weights.Count()))
-        throw new ArgumentException("'estimatedClassValues' has " + estimatedClassValues.Count() + " elements, while 'weights' has" + weights.Count());
+    protected double AggregateEstimatedClassValues(IDictionary<IClassificationSolution, double> estimatedClassValues) {
       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);
+      foreach (var item in estimatedClassValues) {
+        if (!weightSum.ContainsKey(item.Value))
+          weightSum[item.Value] = 0.0;
+        weightSum[item.Value] += weights[item.Key];
       }
       if (weightSum.Count <= 0)
@@ -88 +99 @@
     }
 
-    protected static IEnumerable<IEnumerable<double>> GetEstimatedClassValues(IEnumerable<IClassificationModel> models, Dataset dataset, IEnumerable<int> rows) {
-      if (!models.Any()) yield break;
-      var estimatedValuesEnumerators = (from model in models
-                                        select model.GetEstimatedClassValues(dataset, rows).GetEnumerator())
+    protected IEnumerable<IDictionary<IClassificationSolution, double>> GetEstimatedClassValues(IEnumerable<IClassificationSolution> solutions, Dataset dataset, IEnumerable<int> rows, CheckPoint handler) {
+      if (!solutions.Any()) yield break;
+      var estimatedValuesEnumerators = (from solution in solutions
+                                        select new { Solution = solution, EstimatedValuesEnumerator = solution.Model.GetEstimatedClassValues(dataset, rows).GetEnumerator() })
                                        .ToList();
 
-      while (estimatedValuesEnumerators.All(en => en.MoveNext())) {
-        yield return from enumerator in estimatedValuesEnumerators
-                     select enumerator.Current;
+      var rowEnumerator = rows.GetEnumerator();
+      while (rowEnumerator.MoveNext() & estimatedValuesEnumerators.All(x => x.EstimatedValuesEnumerator.MoveNext())) {
+        yield return (from enumerator in estimatedValuesEnumerators
+                      where handler(enumerator.Solution.ProblemData, rowEnumerator.Current)
+                      select enumerator)
+                     .ToDictionary(x => x.Solution, x => x.EstimatedValuesEnumerator.Current);
       }
     }
@@ -105 +119 @@
              select targetValues[i];
     }
+    protected bool PointInTraining(IClassificationProblemData problemData, int point) {
+      IntRange trainingPartition = problemData.TrainingPartition;
+      IntRange testPartition = problemData.TestPartition;
+      return (trainingPartition.Start <= point && point < trainingPartition.End)
+        && !(testPartition.Start <= point && point < testPartition.End);
+    }
+    protected bool PointInTest(IClassificationProblemData problemData, int point) {
+      IntRange testPartition = problemData.TestPartition;
+      return testPartition.Start <= point && point < testPartition.End;
+    }
+    protected bool AllPoints(IClassificationProblemData problemData, int point) {
+      return true;
+    }
     #endregion
   }