Changeset 11761

Timestamp:

01/15/15 11:16:05 (10 years ago)

Author:

mkommend

Message:

#2278: Minor code cleanup in classification extensions.

Location:

branches/Classification-Extensions

Files:

• HeuristicLab.Optimization/3.3/ResultCollection.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/ClassificationPerformanceMeasuresCalculator.cs (modified) (5 diffs)

branches/Classification-Extensions/HeuristicLab.Optimization/3.3/ResultCollection.cs

@@ -24 +24 @@
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System.Linq;
 
-namespace HeuristicLab.Optimization {   
+namespace HeuristicLab.Optimization {
   [StorableClass]
   [Item("ResultCollection", "Represents a collection of results.")]
@@ -47 +46 @@
 
     public virtual void CollectResultValues(IDictionary<string, IItem> values) {
-      CollectResultValues(values, string.Empty);  
+      CollectResultValues(values, string.Empty);
     }
 
@@ -67 +66 @@
       if (result.Value == null) yield break;
       yield return new KeyValuePair<string, IItem>(string.Empty, result.Value);
+
       var resultCollection = result.Value as ResultCollection;
-      if (resultCollection != null) {       
+      if (resultCollection != null) {
         var children = new Dictionary<string, IItem>();
         resultCollection.CollectResultValues(children);

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

@@ -128 +128 @@
       TestNormalizedGiniCoefficient = testNormalizedGini;
 
-      trainingPerformanceCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues, out errorState);
-      if (errorState == OnlineCalculatorError.None)
+      trainingPerformanceCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues);
+      if (trainingPerformanceCalculator.ErrorState == OnlineCalculatorError.None)
         ClassificationPerformanceMeasures.SetTrainingResults(trainingPerformanceCalculator);
-      testPerformanceCalculator.Calculate(originalTestClassValues, estimatedTestClassValues, out errorState);
-      if (errorState == OnlineCalculatorError.None)
+
+      testPerformanceCalculator.Calculate(originalTestClassValues, estimatedTestClassValues);
+      if (testPerformanceCalculator.ErrorState == OnlineCalculatorError.None)
         ClassificationPerformanceMeasures.SetTestResults(testPerformanceCalculator);
     }

branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/ClassificationPerformanceMeasuresCalculator.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using HeuristicLab.Common;
 
@@ -32 +30 @@
       this.positiveClassName = positiveClassName;
       this.positiveClassValue = positiveClassValue;
-      Reset();        
+      Reset();
     }
 
     #region Properties
-    private string positiveClassName;
-    private double positiveClassValue;
     private int truePositiveCount, falsePositiveCount, trueNegativeCount, falseNegativeCount;
 
+    private readonly string positiveClassName;
     public string PositiveClassName {
-      get {
-        return positiveClassName;
-      }
+      get { return positiveClassName; }
     }
+
+    private readonly double positiveClassValue;
     public double PositiveClassValue {
-      get {
-        return positiveClassValue;
-      }
+      get { return positiveClassValue; }
     }
     public double TruePositiveRate {
@@ -92 +87 @@
     }
     #endregion
-                                
+
     public void Reset() {
       truePositiveCount = 0;
@@ -103 +98 @@
     public void Add(double originalClassValue, double estimatedClassValue) {
       // ignore cases where original is NaN completely 
-      if (!double.IsNaN(originalClassValue)) {
-        if (originalClassValue.IsAlmost(positiveClassValue) 
-              || estimatedClassValue.IsAlmost(positiveClassValue)) { //positive class/positive class estimation
-          if (estimatedClassValue.IsAlmost(originalClassValue)) {
-            truePositiveCount++;
-          } else {
-            if (estimatedClassValue.IsAlmost(positiveClassValue)) //misclassification of the negative class
-              falsePositiveCount++;
-            else //misclassification of the positive class
-              falseNegativeCount++;
-          }
-        } else { //negative class/negative class estimation
-          //In a multiclass classification all misclassifications of the negative class
-          //will be treated as true negatives except on positive class estimations
-          trueNegativeCount++;
+      if (double.IsNaN(originalClassValue)) return;
+
+      if (originalClassValue.IsAlmost(positiveClassValue)
+            || estimatedClassValue.IsAlmost(positiveClassValue)) { //positive class/positive class estimation
+        if (estimatedClassValue.IsAlmost(originalClassValue)) {
+          truePositiveCount++;
+        } else {
+          if (estimatedClassValue.IsAlmost(positiveClassValue)) //misclassification of the negative class
+            falsePositiveCount++;
+          else //misclassification of the positive class
+            falseNegativeCount++;
         }
-        errorState = OnlineCalculatorError.None; // number of (non-NaN) samples >= 1
+      } else { //negative class/negative class estimation
+        //In a multiclass classification all misclassifications of the negative class
+        //will be treated as true negatives except on positive class estimations
+        trueNegativeCount++;
       }
+
+      errorState = OnlineCalculatorError.None; // number of (non-NaN) samples >= 1
     }
 
-    public void Calculate(IEnumerable<double> originalClassValues, IEnumerable<double> estimatedClassValues,
-                                                                          out OnlineCalculatorError errorState) {
+    public void Calculate(IEnumerable<double> originalClassValues, IEnumerable<double> estimatedClassValues) {
       IEnumerator<double> originalEnumerator = originalClassValues.GetEnumerator();
       IEnumerator<double> estimatedEnumerator = estimatedClassValues.GetEnumerator();
@@ -137 +132 @@
 
       // check if both enumerators are at the end to make sure both enumerations have the same length
-      if (ErrorState == OnlineCalculatorError.None &&
-          (estimatedEnumerator.MoveNext() || originalEnumerator.MoveNext())) {
+      if (ErrorState == OnlineCalculatorError.None && (estimatedEnumerator.MoveNext() || originalEnumerator.MoveNext())) {
         throw new ArgumentException("Number of elements in originalValues and estimatedValues enumerations doesn't match.");
-      } else {
-        errorState = ErrorState;
       }
+      errorState = ErrorState;
     }
   }