Changeset 5717 for branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis

Timestamp:

03/16/11 16:34:31 (14 years ago)

Author:

gkronber

Message:

#1418 Implemented interactive simplifier views for symbolic classification and regression.

Location:

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4

Files:

• ClassificationEnsembleModel.cs (modified) (1 diff)
• ClassificationSolution.cs (modified) (4 diffs)
• ClusteringSolution.cs (modified) (1 diff)
• DataAnalysisSolution.cs (modified) (1 diff)
• DiscriminantFunctionClassificationSolution.cs (modified) (3 diffs)
• Interfaces/Classification/IClassificationSolution.cs (modified) (1 diff)
• Interfaces/Classification/IDiscriminantFunctionClassificationModel.cs (modified) (1 diff)
• Interfaces/Classification/IDiscriminantFunctionClassificationSolution.cs (modified) (1 diff)
• Interfaces/Regression/IRegressionSolution.cs (modified) (1 diff)
• RegressionSolution.cs (modified) (4 diffs)
• ThresholdCalculators/AccuracyMaximizationThresholdCalculator.cs (modified) (1 diff)

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/ClassificationEnsembleModel.cs

@@ -54 +54 @@
       this.name = ItemName;
       this.description = ItemDescription;
-      this.models = new List<IClassificationModel>(models);
+      this.models = new List<IClassificationModel>(models);      
     }
 

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/ClassificationSolution.cs

@@ -39 +39 @@
     private const string TrainingAccuracyResultName = "Accuracy (training)";
     private const string TestAccuracyResultName = "Accuracy (test)";
+
+    public new IClassificationModel Model {
+      get { return (IClassificationModel)base.Model; }
+      protected set { base.Model = value; }
+    }
+
+    public new IClassificationProblemData ProblemData {
+      get { return (IClassificationProblemData)base.ProblemData; }
+      protected set { base.ProblemData = value; }
+    }
+
+    public double TrainingAccuracy {
+      get { return ((DoubleValue)this[TrainingAccuracyResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingAccuracyResultName].Value).Value = value; }
+    }
+
+    public double TestAccuracy {
+      get { return ((DoubleValue)this[TestAccuracyResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestAccuracyResultName].Value).Value = value; }
+    }
+
     [StorableConstructor]
     protected ClassificationSolution(bool deserializing) : base(deserializing) { }
@@ -46 +67 @@
     public ClassificationSolution(IClassificationModel model, IClassificationProblemData problemData)
       : base(model, problemData) {
+      Add(new Result(TrainingAccuracyResultName, "Accuracy of the model on the training partition (percentage of correctly classified instances).", new PercentValue()));
+      Add(new Result(TestAccuracyResultName, "Accuracy of the model on the test partition (percentage of correctly classified instances).", new PercentValue()));
+      RecalculateResults();
+    }
+
+    protected override void OnProblemDataChanged(EventArgs e) {
+      base.OnProblemDataChanged(e);
+      RecalculateResults();
+    }
+
+    protected override void OnModelChanged(EventArgs e) {
+      base.OnModelChanged(e);
+      RecalculateResults();
+    }
+
+    private void RecalculateResults() {
       double[] estimatedTrainingClassValues = EstimatedTrainingClassValues.ToArray(); // cache values
       IEnumerable<double> originalTrainingClassValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
@@ -54 +91 @@
       double testAccuracy = OnlineAccuracyEvaluator.Calculate(estimatedTestClassValues, originalTestClassValues);
 
-      Add(new Result(TrainingAccuracyResultName, "Accuracy of the model on the training partition (percentage of correctly classified instances).", new PercentValue(trainingAccuracy)));
-      Add(new Result(TestAccuracyResultName, "Accuracy of the model on the test partition (percentage of correctly classified instances).", new PercentValue(testAccuracy)));
-    }
-
-    #region IClassificationSolution Members
-
-    public new IClassificationModel Model {
-      get { return (IClassificationModel)base.Model; }
-    }
-
-    public new IClassificationProblemData ProblemData {
-      get { return (IClassificationProblemData)base.ProblemData; }
+      TrainingAccuracy = trainingAccuracy;
+      TestAccuracy = testAccuracy;
     }
 
@@ -89 +116 @@
       return Model.GetEstimatedClassValues(ProblemData.Dataset, rows);
     }
-    #endregion
   }
 }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/ClusteringSolution.cs

@@ -51 +51 @@
     public new IClusteringModel Model {
       get { return (IClusteringModel)base.Model; }
+      set { base.Model = value; }
     }
 
     public new IClusteringProblemData ProblemData {
       get { return (IClusteringProblemData)base.ProblemData; }
+      set { base.ProblemData = value; }
     }
 

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/DataAnalysisSolution.cs

@@ -48 +48 @@
     public IDataAnalysisModel Model {
       get { return (IDataAnalysisModel)this[ModelResultName].Value; }
-      //set {
-      //  if (this[ModelResultName].Value != value) {
-      //    if (value != null) {
-      //      this[ModelResultName].Value = value;
-      //      OnModelChanged(EventArgs.Empty);
-      //    }
-      //  }
-      //}
+      protected set {
+        if (this[ModelResultName].Value != value) {
+          if (value != null) {
+            this[ModelResultName].Value = value;
+            OnModelChanged(EventArgs.Empty);
+          }
+        }
+      }
     }
 
     public IDataAnalysisProblemData ProblemData {
       get { return (IDataAnalysisProblemData)this[ProblemDataResultName].Value; }
-      //set {
-      //  if (this[ProblemDataResultName].Value != value) {
-      //    if (value != null) {
-      //      ProblemData.Changed -= new EventHandler(ProblemData_Changed);
-      //      this[ProblemDataResultName].Value = value;
-      //      ProblemData.Changed += new EventHandler(ProblemData_Changed);
-      //      OnProblemDataChanged(EventArgs.Empty);
-      //    }
-      //  }
-      //}
+      protected set {
+        if (this[ProblemDataResultName].Value != value) {
+          if (value != null) {
+            ProblemData.Changed -= new EventHandler(ProblemData_Changed);
+            this[ProblemDataResultName].Value = value;
+            ProblemData.Changed += new EventHandler(ProblemData_Changed);
+            OnProblemDataChanged(EventArgs.Empty);
+          }
+        }
+      }
     }
     #endregion

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/DiscriminantFunctionClassificationSolution.cs

@@ -38 +38 @@
   [Item("DiscriminantFunctionClassificationSolution", "Represents a classification solution that uses a discriminant function and classification thresholds.")]
   public class DiscriminantFunctionClassificationSolution : ClassificationSolution, IDiscriminantFunctionClassificationSolution {
+    public new IDiscriminantFunctionClassificationModel Model {
+      get { return (IDiscriminantFunctionClassificationModel)base.Model; }
+      protected set { base.Model = value; }
+    }
+
     [StorableConstructor]
     protected DiscriminantFunctionClassificationSolution(bool deserializing) : base(deserializing) { }
@@ -48 +53 @@
     public DiscriminantFunctionClassificationSolution(IDiscriminantFunctionClassificationModel model, IClassificationProblemData problemData)
       : base(model, problemData) {
-      Model.ThresholdsChanged += new EventHandler(Model_ThresholdsChanged);
-    }
-
-    #region IDiscriminantFunctionClassificationSolution Members
-
-    public new IDiscriminantFunctionClassificationModel Model {
-      get { return (IDiscriminantFunctionClassificationModel)base.Model; }
     }
 
@@ -72 +70 @@
       return Model.GetEstimatedValues(ProblemData.Dataset, rows);
     }
-
-    public IEnumerable<double> Thresholds {
-      get {
-        return Model.Thresholds;
-      }
-      set { Model.Thresholds = new List<double>(value); }
-    }
-
-    public event EventHandler ThresholdsChanged;
-
-    private void Model_ThresholdsChanged(object sender, EventArgs e) {
-      OnThresholdsChanged(e);
-    }
-
-    protected virtual void OnThresholdsChanged(EventArgs e) {
-      var listener = ThresholdsChanged;
-      if (listener != null) listener(this, e);
-    }
-    #endregion
   }
 }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Classification/IClassificationSolution.cs

@@ -31 +31 @@
     IEnumerable<double> EstimatedTestClassValues { get; }
     IEnumerable<double> GetEstimatedClassValues(IEnumerable<int> rows);
+
+    double TrainingAccuracy { get; }
+    double TestAccuracy { get; }
   }
 }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Classification/IDiscriminantFunctionClassificationModel.cs

@@ -26 +26 @@
     IEnumerable<double> Thresholds { get; set; }
     IEnumerable<double> ClassValues { get; set; }
+    IEnumerable<double> GetEstimatedValues(Dataset dataset, IEnumerable<int> rows);
+
     event EventHandler ThresholdsChanged;
-    IEnumerable<double> GetEstimatedValues(Dataset dataset, IEnumerable<int> rows);
   }
 }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Classification/IDiscriminantFunctionClassificationSolution.cs

@@ -30 +30 @@
     IEnumerable<double> EstimatedTestValues { get; }
     IEnumerable<double> GetEstimatedValues(IEnumerable<int> rows);
-
-    IEnumerable<double> Thresholds { get; set; }
-
-    event EventHandler ThresholdsChanged;
   }
 }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionSolution.cs

@@ -30 +30 @@
     IEnumerable<double> EstimatedTestValues { get; }
     IEnumerable<double> GetEstimatedValues(IEnumerable<int> rows);
+
+    double TrainingMeanSquaredError { get; }
+    double TestMeanSquaredError { get; }
+    double TrainingRSquared { get; }
+    double TestRSquared { get; }
   }
 }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/RegressionSolution.cs

@@ -44 +44 @@
     private const string TestRelativeErrorResultName = "Average relative error (test)";
 
+    public new IRegressionModel Model {
+      get { return (IRegressionModel)base.Model; }
+      protected set { base.Model = value; }
+    }
+
+    public new IRegressionProblemData ProblemData {
+      get { return (IRegressionProblemData)base.ProblemData; }
+      protected set { base.ProblemData = value; }
+    }
+
+    public double TrainingMeanSquaredError {
+      get { return ((DoubleValue)this[TrainingMeanSquaredErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingMeanSquaredErrorResultName].Value).Value = value; }
+    }
+
+    public double TestMeanSquaredError {
+      get { return ((DoubleValue)this[TestMeanSquaredErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestMeanSquaredErrorResultName].Value).Value = value; }
+    }
+
+    public double TrainingRSquared {
+      get { return ((DoubleValue)this[TrainingSquaredCorrelationResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingSquaredCorrelationResultName].Value).Value = value; }
+    }
+
+    public double TestRSquared {
+      get { return ((DoubleValue)this[TestSquaredCorrelationResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestSquaredCorrelationResultName].Value).Value = value; }
+    }
+
+    public double TrainingRelativeError {
+      get { return ((DoubleValue)this[TrainingRelativeErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingRelativeErrorResultName].Value).Value = value; }
+    }
+
+    public double TestRelativeError {
+      get { return ((DoubleValue)this[TestRelativeErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestRelativeErrorResultName].Value).Value = value; }
+    }
+
+
     [StorableConstructor]
     protected RegressionSolution(bool deserializing) : base(deserializing) { }
@@ -51 +92 @@
     public RegressionSolution(IRegressionModel model, IRegressionProblemData problemData)
       : base(model, problemData) {
+      Add(new Result(TrainingMeanSquaredErrorResultName, "Mean of squared errors of the model on the training partition", new DoubleValue()));
+      Add(new Result(TestMeanSquaredErrorResultName, "Mean of squared errors of the model on the test partition", new DoubleValue()));
+      Add(new Result(TrainingSquaredCorrelationResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the training partition", new DoubleValue()));
+      Add(new Result(TestSquaredCorrelationResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the test partition", new DoubleValue()));
+      Add(new Result(TrainingRelativeErrorResultName, "Average of the relative errors of the model output and the actual values on the training partition", new PercentValue()));
+      Add(new Result(TestRelativeErrorResultName, "Average of the relative errors of the model output and the actual values on the test partition", new PercentValue()));
+
+      RecalculateResults();
+    }
+
+    protected override void OnProblemDataChanged(EventArgs e) {
+      base.OnProblemDataChanged(e);
+      RecalculateResults();
+    }
+    protected override void OnModelChanged(EventArgs e) {
+      base.OnModelChanged(e);
+      RecalculateResults();
+    }
+
+    private void RecalculateResults() {
       double[] estimatedTrainingValues = EstimatedTrainingValues.ToArray(); // cache values
       IEnumerable<double> originalTrainingValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
@@ -63 +124 @@
       double testRelError = OnlineMeanAbsolutePercentageErrorEvaluator.Calculate(estimatedTestValues, originalTestValues);
 
-      Add(new Result(TrainingMeanSquaredErrorResultName, "Mean of squared errors of the model on the training partition", new DoubleValue(trainingMSE)));
-      Add(new Result(TestMeanSquaredErrorResultName, "Mean of squared errors of the model on the test partition", new DoubleValue(testMSE)));
-      Add(new Result(TrainingSquaredCorrelationResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the training partition", new DoubleValue(trainingR2)));
-      Add(new Result(TestSquaredCorrelationResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the test partition", new DoubleValue(testR2)));
-      Add(new Result(TrainingRelativeErrorResultName, "Average of the relative errors of the model output and the actual values on the training partition", new PercentValue(trainingRelError)));
-      Add(new Result(TestRelativeErrorResultName, "Average of the relative errors of the model output and the actual values on the test partition", new PercentValue(testRelError)));
-    }
-
-    protected override void OnProblemDataChanged(EventArgs e) {
-      base.OnProblemDataChanged(e);
-      throw new NotImplementedException(); // need to recalculate results
-    }
-    protected override void OnModelChanged(EventArgs e) {
-      base.OnModelChanged(e);
-      throw new NotImplementedException(); // need to recalculate results
-    }
-    #region IRegressionSolution Members
-
-    public new IRegressionModel Model {
-      get { return (IRegressionModel)base.Model; }
-    }
-
-    public new IRegressionProblemData ProblemData {
-      get { return (IRegressionProblemData)base.ProblemData; }
+      TrainingMeanSquaredError = trainingMSE;
+      TestMeanSquaredError = testMSE;
+      TrainingRSquared = trainingR2;
+      TestRSquared = testR2;
+      TrainingRelativeError = trainingRelError;
+      TestRelativeError = testRelError;
     }
 
@@ -110 +153 @@
       return Model.GetEstimatedValues(ProblemData.Dataset, rows);
     }
-    #endregion
   }
 }

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/ThresholdCalculators/AccuracyMaximizationThresholdCalculator.cs

@@ -76 +76 @@
       int[,] confusionMatrix = new int[nClasses, nClasses];
 
-      // one threshold is always treated as binary separation of the remaining classes
       for (int i = 1; i < thresholds.Length - 1; i++) {
         double lowerThreshold = thresholds[i - 1];