Changeset 11684 for branches/Classification-Extensions

Timestamp:

12/15/14 01:20:08 (10 years ago)

Author:

ehopf

Message:

#2278: Encapsulated the classification performance measures to the ClassificationPerformanceMeasuresResultCollection

Location:

branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4

Files:

• HeuristicLab.Problems.DataAnalysis-3.4.csproj (modified) (1 diff)
• Implementation/Classification/ClassificationPerformanceMeasuresResultCollection.cs (added)
• Implementation/Classification/ClassificationSolutionBase.cs (modified) (6 diffs)

branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj

@@ -175 +175 @@
     </Compile>
     <Compile Include="Implementation\Classification\ClassificationEnsembleSolution.cs" />
+    <Compile Include="Implementation\Classification\ClassificationPerformanceMeasuresResultCollection.cs" />
     <Compile Include="Implementation\Classification\ClassificationProblemData.cs" />
     <Compile Include="Implementation\Classification\ClassificationProblem.cs" />

branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs

@@ -34 +34 @@
     private const string TrainingNormalizedGiniCoefficientResultName = "Normalized Gini Coefficient (training)";
     private const string TestNormalizedGiniCoefficientResultName = "Normalized Gini Coefficient (test)";
-
-    private const string ClassificationPositiveClassValueResultName = "Classification positive class";
-    private const string TrainingTruePositiveRateResultName = "True positive rate (training)";
-    private const string TrainingTrueNegativeRateResultName = "True negative rate (training)";
-    private const string TrainingPositivePredictiveValueResultName = "Positive predictive value (training)";
-    private const string TrainingNegativePredictiveValueResultName = "Negative predictive value (training)";
-    private const string TrainingFalsePositiveRateResultName = "False positive rate (training)";
-    private const string TrainingFalseDiscoveryRateResultName = "False discovery rate (training)";
-    private const string TestTruePositiveRateResultName = "True positive rate (test)";
-    private const string TestTrueNegativeRateResultName = "True negative rate (test)";
-    private const string TestPositivePredictiveValueResultName = "Positive predictive value (test)";
-    private const string TestNegativePredictiveValueResultName = "Negative predictive value (test)";
-    private const string TestFalsePositiveRateResultName = "False positive rate (test)";
-    private const string TestFalseDiscoveryRateResultName = "False discovery rate (test)";
     private const string ClassificationPerformanceMeasuresResultName = "Classification Performance Measures";
 
@@ -77 +63 @@
       protected set { ((DoubleValue)this[TestNormalizedGiniCoefficientResultName].Value).Value = value; }
     }
-
-    #region Classification performance measures
-    public ResultCollection ClassificationPerformanceMeasures {
-      get { return ((ResultCollection)this[ClassificationPerformanceMeasuresResultName].Value); }
+    public ClassificationPerformanceMeasuresResultCollection ClassificationPerformanceMeasures {
+      get { return ((ClassificationPerformanceMeasuresResultCollection)this[ClassificationPerformanceMeasuresResultName].Value); }
       protected set { (this[ClassificationPerformanceMeasuresResultName].Value) = value; }
     }
-
-    public string ClassificationPositiveClassValue {
-      get { return ((StringValue)ClassificationPerformanceMeasures[ClassificationPositiveClassValueResultName].Value).Value; }
-      protected set { ((StringValue)ClassificationPerformanceMeasures[ClassificationPositiveClassValueResultName].Value).Value = value; }
-    }
-    public double TrainingTruePositiveRate {
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TrainingTruePositiveRateResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TrainingTruePositiveRateResultName].Value).Value = value; }
-    }
-    public double TrainingTrueNegativeRate {  
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TrainingTrueNegativeRateResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TrainingTrueNegativeRateResultName].Value).Value = value; }
-    }
-    public double TrainingPositivePredictiveValue {
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TrainingPositivePredictiveValueResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TrainingPositivePredictiveValueResultName].Value).Value = value; }
-    }
-    public double TrainingNegativePredictiveValue {
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TrainingNegativePredictiveValueResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TrainingNegativePredictiveValueResultName].Value).Value = value; }
-    }
-    public double TrainingFalsePositiveRate {
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TrainingFalsePositiveRateResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TrainingFalsePositiveRateResultName].Value).Value = value; }
-    }
-    public double TrainingFalseDiscoveryRate {
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TrainingFalseDiscoveryRateResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TrainingFalseDiscoveryRateResultName].Value).Value = value; }
-    }
-    public double TestTruePositiveRate {
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TestTruePositiveRateResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TestTruePositiveRateResultName].Value).Value = value; }
-    }
-    public double TestTrueNegativeRate {
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TestTrueNegativeRateResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TestTrueNegativeRateResultName].Value).Value = value; }
-    }
-    public double TestPositivePredictiveValue {
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TestPositivePredictiveValueResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TestPositivePredictiveValueResultName].Value).Value = value; }
-    }
-    public double TestNegativePredictiveValue {
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TestNegativePredictiveValueResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TestNegativePredictiveValueResultName].Value).Value = value; }
-    }
-    public double TestFalsePositiveRate {
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TestFalsePositiveRateResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TestFalsePositiveRateResultName].Value).Value = value; }
-    }
-    public double TestFalseDiscoveryRate {
-      get { return ((DoubleValue)ClassificationPerformanceMeasures[TestFalseDiscoveryRateResultName].Value).Value; }
-      protected set { ((DoubleValue)ClassificationPerformanceMeasures[TestFalseDiscoveryRateResultName].Value).Value = value; }
-    }
-    #endregion
     #endregion
 
@@ -150 +80 @@
       Add(new Result(TrainingNormalizedGiniCoefficientResultName, "Normalized Gini coefficient of the model on the training partition.", new DoubleValue()));
       Add(new Result(TestNormalizedGiniCoefficientResultName, "Normalized Gini coefficient of the model on the test partition.", new DoubleValue()));
-      AddClassificationPerformanceMeasuresResultCollection();
+      Add(new Result(ClassificationPerformanceMeasuresResultName, @"Classification performance measures.\n
+                              In a multiclass classification all misclassifications of the negative class will be treated as true negatives except on positive class estimations.",
+                            new ClassificationPerformanceMeasuresResultCollection()));
     }
 
@@ -160 +92 @@
         Add(new Result(TestNormalizedGiniCoefficientResultName, "Normalized Gini coefficient of the model on the test partition.", new DoubleValue()));
       if (!this.ContainsKey(ClassificationPerformanceMeasuresResultName)) {
-        AddClassificationPerformanceMeasuresResultCollection();
+        Add(new Result(ClassificationPerformanceMeasuresResultName, @"Classification performance measures.\n
+                              In a multiclass classification all misclassifications of the negative class will be treated as true negatives except on positive class estimations.",
+                              new ClassificationPerformanceMeasuresResultCollection()));
         RecalculateResults();
       }
-    }
-
-    protected void AddClassificationPerformanceMeasuresResultCollection() {
-      ResultCollection performanceMeasures = new ResultCollection();
-      performanceMeasures.Add(new Result(ClassificationPositiveClassValueResultName, "The positive class which is used for the performance measure calculations.", new StringValue()));
-      performanceMeasures.Add(new Result(TrainingTruePositiveRateResultName, "Sensitivity/True positive rate of the model on the training partition\n(TP/(TP+FN)).", new PercentValue()));
-      performanceMeasures.Add(new Result(TrainingTrueNegativeRateResultName, "Specificity/True negative rate of the model on the training partition\n(TN/(FP+TN)).", new PercentValue()));
-      performanceMeasures.Add(new Result(TrainingPositivePredictiveValueResultName, "Precision/Positive predictive value of the model on the training partition\n(TP/(TP+FP)).", new PercentValue()));
-      performanceMeasures.Add(new Result(TrainingNegativePredictiveValueResultName, "Negative predictive value of the model on the training partition\n(TN/(TN+FN)).", new PercentValue()));
-      performanceMeasures.Add(new Result(TrainingFalsePositiveRateResultName, "The false positive rate is the complement of the true negative rate of the model on the training partition.", new PercentValue()));
-      performanceMeasures.Add(new Result(TrainingFalseDiscoveryRateResultName, "The false discovery rate is the complement of the positive predictive value of the model on the training partition.", new PercentValue()));
-      performanceMeasures.Add(new Result(TestTruePositiveRateResultName, "Sensitivity/True positive rate of the model on the test partition\n(TP/(TP+FN)).", new PercentValue()));
-      performanceMeasures.Add(new Result(TestTrueNegativeRateResultName, "Specificity/True negative rate of the model on the test partition\n(TN/(FP+TN)).", new PercentValue()));
-      performanceMeasures.Add(new Result(TestPositivePredictiveValueResultName, "Precision/Positive predictive value of the model on the test partition\n(TP/(TP+FP)).", new PercentValue()));
-      performanceMeasures.Add(new Result(TestNegativePredictiveValueResultName, "Negative predictive value of the model on the test partition\n(TN/(TN+FN)).", new PercentValue()));
-      performanceMeasures.Add(new Result(TestFalsePositiveRateResultName, "The false positive rate is the complement of the true negative rate of the model on the test partition.", new PercentValue()));
-      performanceMeasures.Add(new Result(TestFalseDiscoveryRateResultName, "The false discovery rate is the complement of the positive predictive value of the model on the test partition.", new PercentValue()));
-      Add(new Result(ClassificationPerformanceMeasuresResultName, @"Classification performance measures.\n
-                              In a multiclass classification all misclassifications of the negative class will be treated as true negatives except on positive class estimations.", performanceMeasures));
     }
 
@@ -193 +108 @@
       var positiveClassName = ProblemData.PositiveClassName;
       double positiveClassValue = ProblemData.GetClassValue(positiveClassName);
-      ClassificationPositiveClassValue = positiveClassName;
+      ClassificationPerformanceMeasures.ClassificationPositiveClassValue = positiveClassName;
       ClassificationPerformanceMeasuresCalculator trainingPerformanceCalculator = new ClassificationPerformanceMeasuresCalculator(positiveClassValue);
       ClassificationPerformanceMeasuresCalculator testPerformanceCalculator = new ClassificationPerformanceMeasuresCalculator(positiveClassValue);
@@ -214 +129 @@
       TestNormalizedGiniCoefficient = testNormalizedGini;
 
-      //performance measures training partition
       trainingPerformanceCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues, out errorState);
-      if (errorState != OnlineCalculatorError.None) {
-        TrainingTruePositiveRate = double.NaN;
-        TrainingTrueNegativeRate = double.NaN;
-        TrainingPositivePredictiveValue = double.NaN;
-        TrainingNegativePredictiveValue = double.NaN;
-        TrainingFalsePositiveRate = double.NaN;
-        TrainingFalseDiscoveryRate = double.NaN;
-      } else {
-        TrainingTruePositiveRate = trainingPerformanceCalculator.TruePositiveRate;
-        TrainingTrueNegativeRate = trainingPerformanceCalculator.TrueNegativeRate;
-        TrainingPositivePredictiveValue = trainingPerformanceCalculator.PositivePredictiveValue;
-        TrainingNegativePredictiveValue = trainingPerformanceCalculator.NegativePredictiveValue;
-        TrainingFalsePositiveRate = trainingPerformanceCalculator.FalsePositiveRate;
-        TrainingFalseDiscoveryRate = trainingPerformanceCalculator.FalseDiscoveryRate;
+      if (errorState == OnlineCalculatorError.None) {
+        ClassificationPerformanceMeasures.TrainingTruePositiveRate = trainingPerformanceCalculator.TruePositiveRate;
+        ClassificationPerformanceMeasures.TrainingTrueNegativeRate = trainingPerformanceCalculator.TrueNegativeRate;
+        ClassificationPerformanceMeasures.TrainingPositivePredictiveValue = trainingPerformanceCalculator.PositivePredictiveValue;
+        ClassificationPerformanceMeasures.TrainingNegativePredictiveValue = trainingPerformanceCalculator.NegativePredictiveValue;
+        ClassificationPerformanceMeasures.TrainingFalsePositiveRate = trainingPerformanceCalculator.FalsePositiveRate;
+        ClassificationPerformanceMeasures.TrainingFalseDiscoveryRate = trainingPerformanceCalculator.FalseDiscoveryRate; 
       }
-      //performance measures test partition
       testPerformanceCalculator.Calculate(originalTestClassValues, estimatedTestClassValues, out errorState);
-      if (errorState != OnlineCalculatorError.None) {
-        TestTruePositiveRate = double.NaN;
-        TestTrueNegativeRate = double.NaN;
-        TestPositivePredictiveValue = double.NaN;
-        TestNegativePredictiveValue = double.NaN;
-        TestFalsePositiveRate = double.NaN;
-        TestFalseDiscoveryRate = double.NaN;
-      } else {
-        TestTruePositiveRate = testPerformanceCalculator.TruePositiveRate;
-        TestTrueNegativeRate = testPerformanceCalculator.TrueNegativeRate;
-        TestPositivePredictiveValue = testPerformanceCalculator.PositivePredictiveValue;
-        TestNegativePredictiveValue = testPerformanceCalculator.NegativePredictiveValue;
-        TestFalsePositiveRate = testPerformanceCalculator.FalsePositiveRate;
-        TestFalseDiscoveryRate = testPerformanceCalculator.FalseDiscoveryRate;
+      if (errorState == OnlineCalculatorError.None) {
+        ClassificationPerformanceMeasures.TestTruePositiveRate = testPerformanceCalculator.TruePositiveRate;
+        ClassificationPerformanceMeasures.TestTrueNegativeRate = testPerformanceCalculator.TrueNegativeRate;
+        ClassificationPerformanceMeasures.TestPositivePredictiveValue = testPerformanceCalculator.PositivePredictiveValue;
+        ClassificationPerformanceMeasures.TestNegativePredictiveValue = testPerformanceCalculator.NegativePredictiveValue;
+        ClassificationPerformanceMeasures.TestFalsePositiveRate = testPerformanceCalculator.FalsePositiveRate;
+        ClassificationPerformanceMeasures.TestFalseDiscoveryRate = testPerformanceCalculator.FalseDiscoveryRate;
       }
     }