Changeset 12216 for branches

Timestamp:

03/17/15 15:56:40 (10 years ago)

Author:

ehopf

Message:

#2361: Removed redundant calculations.

Location:

branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4

Files:

• Interfaces/ISymbolicDiscriminantFunctionClassificationModel.cs (modified) (1 diff)
• SingleObjective/SymbolicClassificationSingleObjectiveWeightedPerformanceMeasuresEvaluator.cs (modified) (3 diffs)
• SymbolicDiscriminantFunctionClassificationModel.cs (modified) (1 diff)

branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/Interfaces/ISymbolicDiscriminantFunctionClassificationModel.cs

@@ -20 +20 @@
 #endregion
 
+using System.Collections.Generic;
+
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
   public interface ISymbolicDiscriminantFunctionClassificationModel : IDiscriminantFunctionClassificationModel, ISymbolicClassificationModel {
-
+    IEnumerable<double> GetEstimatedClassValues(IEnumerable<double> estimatedValues);
   }
 }

branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveWeightedPerformanceMeasuresEvaluator.cs

@@ -30 +30 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification.SingleObjective {
-  [Item("Weighted Performance Measures Evaluator", "Calculates the quality a symbolic classification solution based on three weighted measures(normalized mean squared error, false negative rate and false positve rate).")]
+  [Item("Weighted Performance Measures Evaluator", "Calculates the quality of a symbolic classification solution based on three weighted measures(normalized mean squared error, false negative rate(1-sensitivity) and false positve rate(1-specificity)).")]
   [StorableClass]
   public class SymbolicClassificationSingleObjectiveWeightedPerformanceMeasuresEvaluator : SymbolicClassificationSingleObjectiveEvaluator {
@@ -101 +101 @@
                 IEnumerable<int> rows, bool applyLinearScaling, ISymbolicClassificationModelCreator modelCreator, double normalizedMeanSquaredErrorWeightingFactor, double falseNegativeRateWeightingFactor, double falsePositiveRateWeightingFactor) {
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
-      IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
+      IEnumerable<double> targetClassValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
       OnlineCalculatorError errorState;
       double nmse;
 
       //calculate performance measures
-      var model = modelCreator.CreateSymbolicClassificationModel(solution, interpreter, lowerEstimationLimit, upperEstimationLimit);
+      var model = (ISymbolicDiscriminantFunctionClassificationModel)modelCreator.CreateSymbolicClassificationModel(solution, interpreter, lowerEstimationLimit, upperEstimationLimit);
       string positiveClassName = problemData.PositiveClass;
-      model.RecalculateModelParameters(problemData, rows);
+      double[] classValues, thresholds;
+      model.ThresholdCalculator.Calculate(problemData, estimatedValues, targetClassValues, out classValues, out thresholds);
+      model.SetThresholdsAndClassValues(thresholds, classValues);
       var performanceCalculator = new ClassificationPerformanceMeasuresCalculator(positiveClassName, problemData.GetClassValue(positiveClassName));
-      var estimatedClassValues = model.GetEstimatedClassValues(problemData.Dataset, rows);
-      performanceCalculator.Calculate(estimatedClassValues, targetValues);
+      var estimatedClassValues = model.GetEstimatedClassValues(estimatedValues);
+      performanceCalculator.Calculate(targetClassValues, estimatedClassValues);
       if (performanceCalculator.ErrorState != OnlineCalculatorError.None) 
         return Double.NaN;
@@ -119 +121 @@
       if (applyLinearScaling) {
         var nmseCalculator = new OnlineNormalizedMeanSquaredErrorCalculator();
-        CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, nmseCalculator, problemData.Dataset.Rows);
+        CalculateWithScaling(targetClassValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, nmseCalculator, problemData.Dataset.Rows);
         errorState = nmseCalculator.ErrorState;
         nmse = nmseCalculator.NormalizedMeanSquaredError;
       } else {
         IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
-        nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
+        nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetClassValues, boundedEstimatedValues, out errorState);
       }
       if (errorState != OnlineCalculatorError.None) return Double.NaN;

branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationModel.cs

@@ -123 +123 @@
       }
     }
-
+    public IEnumerable<double> GetEstimatedClassValues(IEnumerable<double> estimatedValues) {
+      if (!Thresholds.Any() && !ClassValues.Any()) throw new ArgumentException("No thresholds and class values were set for the current symbolic classification model.");
+      foreach (var x in estimatedValues) {
+        int classIndex = 0;
+        // find first threshold value which is larger than x => class index = threshold index + 1
+        for (int i = 0; i < thresholds.Length; i++) {
+          if (x > thresholds[i]) classIndex++;
+          else break;
+        }
+        yield return classValues.ElementAt(classIndex - 1);
+      }
+    }
 
     public override ISymbolicClassificationSolution CreateClassificationSolution(IClassificationProblemData problemData) {