Changeset 6520 for trunk/sources/HeuristicLab.Problems.DataAnalysis

Timestamp:

07/06/11 21:13:34 (13 years ago)

Author:

gkronber

Message:

#1450 implemented menu item to merge all data analysis solutions in a run collection into ensemble solutions and fixed a few bugs related to ensemble solutions.

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4

Files:

• Implementation/Classification/ClassificationEnsembleModel.cs (modified) (1 diff)
• Implementation/Classification/ClassificationEnsembleProblemData.cs (modified) (1 diff)
• Implementation/Classification/ClassificationEnsembleSolution.cs (modified) (2 diffs)
• Implementation/Regression/RegressionEnsembleModel.cs (modified) (1 diff)
• Implementation/Regression/RegressionEnsembleSolution.cs (modified) (3 diffs)
• Interfaces/Classification/IClassificationEnsembleModel.cs (modified) (1 diff)
• Interfaces/Regression/IRegressionEnsembleModel.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleModel.cs

@@ -58 +58 @@
 
     #region IClassificationEnsembleModel Members
+    public void Add(IClassificationModel model) {
+      models.Add(model);
+    }
 
     public IEnumerable<IEnumerable<double>> GetEstimatedClassValueVectors(Dataset dataset, IEnumerable<int> rows) {

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleProblemData.cs

@@ -37 +37 @@
     public override IEnumerable<int> TrainingIndizes {
       get {
-        return Enumerable.Range(TrainingPartition.Start, TestPartition.End - TestPartition.Start);
+        return Enumerable.Range(TrainingPartition.Start, TrainingPartition.End - TrainingPartition.Start);
       }
     }

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs

@@ -79 +79 @@
       this.trainingPartitions = new Dictionary<IClassificationModel, IntRange>();
       this.testPartitions = new Dictionary<IClassificationModel, IntRange>();
-      var modelEnumerator = models.GetEnumerator();
-      var trainingPartitionEnumerator = trainingPartitions.GetEnumerator();
-      var testPartitionEnumerator = testPartitions.GetEnumerator();
-      while (modelEnumerator.MoveNext() & trainingPartitionEnumerator.MoveNext() & testPartitionEnumerator.MoveNext()) {
-        this.trainingPartitions[modelEnumerator.Current] = (IntRange)trainingPartitionEnumerator.Current.Clone();
-        this.testPartitions[modelEnumerator.Current] = (IntRange)testPartitionEnumerator.Current.Clone();
-      }
-      if (modelEnumerator.MoveNext() | trainingPartitionEnumerator.MoveNext() | testPartitionEnumerator.MoveNext()) {
-        throw new ArgumentException();
-      }
+      AddModelsAndParitions(models,
+        trainingPartitions,
+        testPartitions);
       RecalculateResults();
     }
@@ -169 +162 @@
       .First();
     }
+
+    public void AddModelsAndParitions(IEnumerable<IClassificationSolution> solutions) {
+      foreach (var solution in solutions) {
+        var ensembleSolution = solution as ClassificationEnsembleSolution;
+        if (ensembleSolution != null) {
+          var data = from m in ensembleSolution.Model.Models
+                     let train = ensembleSolution.trainingPartitions[m]
+                     let test = ensembleSolution.testPartitions[m]
+                     select new { m, train, test };
+
+          foreach (var d in data) {
+            Model.Add(d.m);
+            trainingPartitions[d.m] = (IntRange)d.train.Clone();
+            testPartitions[d.m] = (IntRange)d.test.Clone();
+          }
+        } else {
+          Model.Add(solution.Model);
+          trainingPartitions[solution.Model] = (IntRange)solution.ProblemData.TrainingPartition.Clone();
+          testPartitions[solution.Model] = (IntRange)solution.ProblemData.TestPartition.Clone();
+        }
+      }
+
+      RecalculateResults();
+    }
+
+    private void AddModelsAndParitions(IEnumerable<IClassificationModel> models, IEnumerable<IntRange> trainingPartitions, IEnumerable<IntRange> testPartitions) {
+      var modelEnumerator = models.GetEnumerator();
+      var trainingPartitionEnumerator = trainingPartitions.GetEnumerator();
+      var testPartitionEnumerator = testPartitions.GetEnumerator();
+
+      while (modelEnumerator.MoveNext() & trainingPartitionEnumerator.MoveNext() & testPartitionEnumerator.MoveNext()) {
+        this.trainingPartitions[modelEnumerator.Current] = (IntRange)trainingPartitionEnumerator.Current.Clone();
+        this.testPartitions[modelEnumerator.Current] = (IntRange)testPartitionEnumerator.Current.Clone();
+      }
+      if (modelEnumerator.MoveNext() | trainingPartitionEnumerator.MoveNext() | testPartitionEnumerator.MoveNext()) {
+        throw new ArgumentException();
+      }
+    }
   }
 }

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleModel.cs

@@ -58 +58 @@
     #region IRegressionEnsembleModel Members
 
+    public void Add(IRegressionModel model) {
+      models.Add(model);
+    }
+
     public IEnumerable<IEnumerable<double>> GetEstimatedValueVectors(Dataset dataset, IEnumerable<int> rows) {
       var estimatedValuesEnumerators = (from model in models

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs

@@ -64 +64 @@
       trainingPartitions = new Dictionary<IRegressionModel, IntRange>();
       testPartitions = new Dictionary<IRegressionModel, IntRange>();
-      foreach (var model in models) {
-        trainingPartitions[model] = (IntRange)problemData.TrainingPartition.Clone();
-        testPartitions[model] = (IntRange)problemData.TestPartition.Clone();
-      }
+      AddModelsAndParitions(models,
+        from m in models select (IntRange)problemData.TrainingPartition.Clone(),
+        from m in models select (IntRange)problemData.TestPartition.Clone());
       RecalculateResults();
     }
@@ -75 +74 @@
       this.trainingPartitions = new Dictionary<IRegressionModel, IntRange>();
       this.testPartitions = new Dictionary<IRegressionModel, IntRange>();
-      var modelEnumerator = models.GetEnumerator();
-      var trainingPartitionEnumerator = trainingPartitions.GetEnumerator();
-      var testPartitionEnumerator = testPartitions.GetEnumerator();
-      while (modelEnumerator.MoveNext() & trainingPartitionEnumerator.MoveNext() & testPartitionEnumerator.MoveNext()) {
-        this.trainingPartitions[modelEnumerator.Current] = (IntRange)trainingPartitionEnumerator.Current.Clone();
-        this.testPartitions[modelEnumerator.Current] = (IntRange)testPartitionEnumerator.Current.Clone();
-      }
-      if (modelEnumerator.MoveNext() | trainingPartitionEnumerator.MoveNext() | testPartitionEnumerator.MoveNext()) {
-        throw new ArgumentException();
-      }
+      AddModelsAndParitions(models, trainingPartitions, testPartitions);
       RecalculateResults();
     }
@@ -160 +150 @@
       return estimatedValues.DefaultIfEmpty(double.NaN).Average();
     }
+
+
+    public void AddModelsAndParitions(IEnumerable<IRegressionSolution> solutions) {
+      foreach (var solution in solutions) {
+        var ensembleSolution = solution as RegressionEnsembleSolution;
+        if (ensembleSolution != null) {
+          var data = from m in ensembleSolution.Model.Models
+                     let train = ensembleSolution.trainingPartitions[m]
+                     let test = ensembleSolution.testPartitions[m]
+                     select new { m, train, test };
+
+          foreach (var d in data) {
+            Model.Add(d.m);
+            trainingPartitions[d.m] = (IntRange)d.train.Clone();
+            testPartitions[d.m] = (IntRange)d.test.Clone();
+          }
+        } else {
+          Model.Add(solution.Model);
+          trainingPartitions[solution.Model] = (IntRange)solution.ProblemData.TrainingPartition.Clone();
+          testPartitions[solution.Model] = (IntRange)solution.ProblemData.TestPartition.Clone();
+        }
+      }
+
+      RecalculateResults();
+    }
+
+    private void AddModelsAndParitions(IEnumerable<IRegressionModel> models, IEnumerable<IntRange> trainingPartitions, IEnumerable<IntRange> testPartitions) {
+      var modelEnumerator = models.GetEnumerator();
+      var trainingPartitionEnumerator = trainingPartitions.GetEnumerator();
+      var testPartitionEnumerator = testPartitions.GetEnumerator();
+
+      while (modelEnumerator.MoveNext() & trainingPartitionEnumerator.MoveNext() & testPartitionEnumerator.MoveNext()) {
+        this.trainingPartitions[modelEnumerator.Current] = (IntRange)trainingPartitionEnumerator.Current.Clone();
+        this.testPartitions[modelEnumerator.Current] = (IntRange)testPartitionEnumerator.Current.Clone();
+      }
+      if (modelEnumerator.MoveNext() | trainingPartitionEnumerator.MoveNext() | testPartitionEnumerator.MoveNext()) {
+        throw new ArgumentException();
+      }
+    }
   }
 }

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Classification/IClassificationEnsembleModel.cs

@@ -23 +23 @@
 namespace HeuristicLab.Problems.DataAnalysis {
   public interface IClassificationEnsembleModel : IClassificationModel {
+    void Add(IClassificationModel model);
     IEnumerable<IClassificationModel> Models { get; }
     IEnumerable<IEnumerable<double>> GetEstimatedClassValueVectors(Dataset dataset, IEnumerable<int> rows);

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionEnsembleModel.cs

@@ -23 +23 @@
 namespace HeuristicLab.Problems.DataAnalysis {
   public interface IRegressionEnsembleModel : IRegressionModel {
+    void Add(IRegressionModel model);
     IEnumerable<IRegressionModel> Models { get; }
     IEnumerable<IEnumerable<double>> GetEstimatedValueVectors(Dataset dataset, IEnumerable<int> rows);