Changeset 7504 for branches

Timestamp:

02/21/12 16:44:20 (13 years ago)

Author:

sforsten

Message:

#1776:

• improvements in the usage of the WeightCalculators
• small changes in all class which inherit from the WeightCalculator class

Location:

branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4

Files:

• HeuristicLab.Problems.DataAnalysis-3.4.csproj (modified) (1 diff)
• Implementation/Classification/ClassificationEnsembleSolution.cs (modified) (3 diffs)
• Implementation/Classification/WeightCalculators/AccuracyWeightCalculator.cs (modified) (1 diff)
• Implementation/Classification/WeightCalculators/MajorityVoteWeightCalculator.cs (modified) (1 diff)
• Implementation/Classification/WeightCalculators/NeighbourhoodWeightCalculator.cs (modified) (3 diffs)
• Implementation/Classification/WeightCalculators/PointCertaintyWeightCalculator.cs (modified) (3 diffs)
• Implementation/Classification/WeightCalculators/WeightCalculator.cs (modified) (2 diffs)
• Interfaces/Classification/IClassificationEnsembleSolutionWeightCalculator.cs (modified) (1 diff)

branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj

@@ -129 +129 @@
     <Compile Include="Implementation\Classification\DiscriminantFunctionClassificationSolutionBase.cs" />
     <Compile Include="Implementation\Classification\WeightCalculators\AccuracyWeightCalculator.cs" />
+    <Compile Include="Implementation\Classification\WeightCalculators\ContinuousPointCertaintyWeightCalculator.cs" />
     <Compile Include="Implementation\Classification\WeightCalculators\NeighbourhoodWeightCalculator.cs" />
     <Compile Include="Implementation\Classification\WeightCalculators\PointCertaintyWeightCalculator.cs" />

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

@@ -68 +68 @@
         if (value != null) {
           weightCalculator = value;
-          weights = weights = weightCalculator.CalculateWeights(classificationSolutions);
+          weights = weights = weightCalculator.CalculateNormalizedWeights(classificationSolutions);
           if (!ProblemData.IsEmpty)
             RecalculateResults();
@@ -316 +316 @@
       trainingPartitions[solution.Model] = solution.ProblemData.TrainingPartition;
       testPartitions[solution.Model] = solution.ProblemData.TestPartition;
-      weights = weightCalculator.CalculateWeights(classificationSolutions);
+      weights = weightCalculator.CalculateNormalizedWeights(classificationSolutions);
     }
 
@@ -324 +324 @@
       trainingPartitions.Remove(solution.Model);
       testPartitions.Remove(solution.Model);
-      weights = weightCalculator.CalculateWeights(classificationSolutions);
+      weights = weightCalculator.CalculateNormalizedWeights(classificationSolutions);
     }
   }

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

@@ -48 +48 @@
     }
 
-    public override IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
-      double sum = classificationSolutions.Select(s => s.TestAccuracy).Sum();
-      List<double> weights = new List<double>();
-      foreach (var item in classificationSolutions) {
-        weights.Add(item.TestAccuracy / sum);
-      }
-      return weights;
+    protected override IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
+      return classificationSolutions.Select(s => s.TrainingAccuracy);
     }
   }

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

@@ -48 +48 @@
     }
 
-    public override IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
+    protected override IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
       return Enumerable.Repeat<double>(1, classificationSolutions.Count);
     }

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

@@ -49 +49 @@
     }
 
-    public override IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
+    protected override IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
       if (classificationSolutions.Count <= 0)
         return new List<double>();
@@ -56 +56 @@
         return Enumerable.Repeat<double>(1, classificationSolutions.Count);
 
-      ItemCollection<IDiscriminantFunctionClassificationSolution> discriminantSolutions = new ItemCollection<IDiscriminantFunctionClassificationSolution>();
-      List<List<double>> estimatedTestValEnumerators = new List<List<double>>();
-      List<List<double>> estimatedTestClassValEnumerators = new List<List<double>>();
+      List<List<double>> estimatedTrainingValEnumerators = new List<List<double>>();
+      List<List<double>> estimatedTrainingClassValEnumerators = new List<List<double>>();
+      IDiscriminantFunctionClassificationSolution discriminantSolution;
       foreach (var solution in classificationSolutions) {
-        discriminantSolutions.Add((IDiscriminantFunctionClassificationSolution)solution);
-        estimatedTestValEnumerators.Add(discriminantSolutions.Last().EstimatedTestValues.ToList());
-        estimatedTestClassValEnumerators.Add(discriminantSolutions.Last().EstimatedTestClassValues.ToList());
+        discriminantSolution = (IDiscriminantFunctionClassificationSolution)solution;
+        estimatedTrainingValEnumerators.Add(discriminantSolution.EstimatedTrainingValues.ToList());
+        estimatedTrainingClassValEnumerators.Add(discriminantSolution.EstimatedTrainingClassValues.ToList());
       }
 
@@ -68 +68 @@
 
       IClassificationProblemData problemData = classificationSolutions.ElementAt(0).ProblemData;
-      IList<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable).ToList();
-      List<double> testVal = GetValues(targetValues, problemData.TestIndizes).ToList();
+      List<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable).ToList();
+      List<double> trainingVal = GetValues(targetValues, problemData.TrainingIndizes).ToList();
 
       double pointAvg, help;
       int count;
-      for (int point = 0; point < estimatedTestClassValEnumerators.First().Count; point++) {
+      for (int point = 0; point < estimatedTrainingClassValEnumerators.First().Count; point++) {
         pointAvg = 0.0;
         count = 0;
-        for (int solution = 0; solution < estimatedTestClassValEnumerators.Count; solution++) {
-          if (estimatedTestClassValEnumerators[solution][point].Equals(testVal[point])) {
-            pointAvg += estimatedTestValEnumerators[solution][point];
+        for (int solution = 0; solution < estimatedTrainingClassValEnumerators.Count; solution++) {
+          if (estimatedTrainingClassValEnumerators[solution][point].Equals(targetValues[point])) {
+            pointAvg += estimatedTrainingValEnumerators[solution][point];
             count++;
           }
         }
         pointAvg /= (double)count;
-        for (int solution = 0; solution < estimatedTestClassValEnumerators.Count; solution++) {
-          if (estimatedTestClassValEnumerators[solution][point].Equals(testVal[point])) {
+        for (int solution = 0; solution < estimatedTrainingClassValEnumerators.Count; solution++) {
+          if (estimatedTrainingClassValEnumerators[solution][point].Equals(targetValues[point])) {
             weights[solution] += 0.5;
-            help = Math.Abs(estimatedTestValEnumerators[solution][point] - 0.5);
+            help = Math.Abs(estimatedTrainingValEnumerators[solution][point] - 0.5);
             weights[solution] += help < 0.5 ? 0.5 - help : 0.0;
           }
         }
       }
-      return weights.Select(x => x / weights.Sum());
+      return weights;
     }
 

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

@@ -49 +49 @@
     }
 
-    public override IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
+    protected override IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
       if (classificationSolutions.Count <= 0)
         return new List<double>();
@@ -62 +62 @@
 
       List<double> weights = new List<double>();
-
       IClassificationProblemData problemData = classificationSolutions.ElementAt(0).ProblemData;
-      IList<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable).ToList();
-      IEnumerator<double> testVal;
-
+      IEnumerable<double> targetValues = GetValues(problemData.Dataset.GetDoubleValues(problemData.TargetVariable).ToList(), problemData.TrainingIndizes);
+      IEnumerator<double> trainingValues;
       double avg = problemData.ClassValues.Average();
 
       foreach (var solution in discriminantSolutions) {
-        IEnumerator<double> estimatedTest = solution.EstimatedTestValues.GetEnumerator();
-        IEnumerator<double> estimatedTestClass = solution.EstimatedTestClassValues.GetEnumerator();
+        IEnumerator<double> estimatedTrainingVal = solution.EstimatedTrainingValues.GetEnumerator();
+        IEnumerator<double> estimatedTrainingClassVal = solution.EstimatedTrainingClassValues.GetEnumerator();
 
-        testVal = GetValues(targetValues, problemData.TestIndizes).GetEnumerator();
+        trainingValues = targetValues.GetEnumerator();
         double curWeight = 0.0;
-        while (estimatedTest.MoveNext() && estimatedTestClass.MoveNext() && testVal.MoveNext()) {
-          if (estimatedTestClass.Current.Equals(testVal.Current)) {
+        while (estimatedTrainingVal.MoveNext() && estimatedTrainingClassVal.MoveNext() && trainingValues.MoveNext()) {
+          if (estimatedTrainingClassVal.Current.Equals(trainingValues.Current)) {
             curWeight += 0.5;
-            double distanceToPoint = Math.Abs(estimatedTest.Current - avg);
-            double distanceToClass = Math.Abs(testVal.Current - avg);
-            if (testVal.Current > avg && estimatedTest.Current > avg
-             || testVal.Current < avg && estimatedTest.Current < avg)
+            double distanceToPoint = Math.Abs(estimatedTrainingVal.Current - avg);
+            double distanceToClass = Math.Abs(trainingValues.Current - avg);
+            if (trainingValues.Current > avg && estimatedTrainingVal.Current > avg
+             || trainingValues.Current < avg && estimatedTrainingVal.Current < avg)
               curWeight += distanceToPoint < distanceToClass ? (0.5 / distanceToClass) * distanceToPoint : 0.5;
           }
@@ -87 +85 @@
         weights.Add(curWeight);
       }
-      return weights.Select(x => x / weights.Sum());
+      return weights;
     }
 

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

@@ -21 +21 @@
 
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -43 +44 @@
     }
 
-    abstract public IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions);
+    /// <summary>
+    /// calls CalculateWeights and removes negative weights 
+    /// </summary>
+    /// <param name="classificationSolutions"></param>
+    /// <returns>weights which are equal or bigger than zero</returns>
+    public IEnumerable<double> CalculateNormalizedWeights(ItemCollection<IClassificationSolution> classificationSolutions) {
+      List<double> weights = new List<double>();
+      foreach (var weight in CalculateWeights(classificationSolutions)) {
+        weights.Add(weight >= 0 ? weight : 0);
+      }
+      return weights.Select(x => x / weights.Sum());
+    }
+
+    protected abstract IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions);
   }
 }

branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Classification/IClassificationEnsembleSolutionWeightCalculator.cs

@@ -25 +25 @@
 namespace HeuristicLab.Problems.DataAnalysis.Interfaces.Classification {
   public interface IClassificationEnsembleSolutionWeightCalculator : INamedItem {
-    IEnumerable<double> CalculateWeights(ItemCollection<IClassificationSolution> classificationSolutions);
+    IEnumerable<double> CalculateNormalizedWeights(ItemCollection<IClassificationSolution> classificationSolutions);
   }
 }