Changeset 12448 for branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification

Timestamp:

06/15/15 17:00:37 (9 years ago)

Author:

ehopf

Message:

#2361: Minor naming changes.

File:

• branches/SensitivityEvaluator/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveWeightedResidualsMeanSquaredErrorEvaluator.cs (modified) (9 diffs)

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

@@ -32 +32 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
   [Item("Weighted Residuals Mean Squared Error Evaluator", @"A modified mean squared error evaluator that enables the possibility to weight residuals differently.
-The first residual category belongs to estimated values which obviously belong to a specific class because the estimated value is located above the maximum or below the minimum of all the class values (ObviousResidualsWeight).
+The first residual category belongs to estimated values which definitely belong to a specific class because the estimated value is located above the maximum or below the minimum of all the class values (DefiniteResidualsWeight).
 The second residual category represents residuals which belong to the positive class whereby the estimated value is located between the positive and a negative class (PositiveClassResidualsWeight).
-All other cases are represented by the third category (NegativeClassResidualsWeight).
+All other cases are represented by the third category (NegativeClassesResidualsWeight).
 The weight is multiplied to the error before squaring which means that the Evaluator acts like a normal MSE-Evaluator if all the weights are set to 1.")]
   [StorableClass]
   public class SymbolicClassificationSingleObjectiveWeightedResidualsMeanSquaredErrorEvaluator : SymbolicClassificationSingleObjectiveEvaluator {
-    private const string ObviousResidualsWeightParameterName = "ObviousResidualsWeight";
+    private const string DefiniteResidualsWeightParameterName = "DefiniteResidualsWeight";
     private const string PositiveClassResidualsWeightParameterName = "PositiveClassResidualsWeight";
-    private const string NegativeClassResidualsWeightParameterName = "NegativeClassResidualsWeight";
+    private const string NegativeClassesResidualsWeightParameterName = "NegativeClassesResidualsWeight";
     [StorableConstructor]
     protected SymbolicClassificationSingleObjectiveWeightedResidualsMeanSquaredErrorEvaluator(bool deserializing) : base(deserializing) { }
@@ -52 +52 @@
     public SymbolicClassificationSingleObjectiveWeightedResidualsMeanSquaredErrorEvaluator()
       : base() {
-      Parameters.Add(new FixedValueParameter<DoubleValue>(ObviousResidualsWeightParameterName, "Weight of residuals which obviously belong to a specific class because the estimated values is located above the maximum or below the minimum of all the class values.", new DoubleValue(1)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(DefiniteResidualsWeightParameterName, "Weight of residuals which definitely belong to a specific class because the estimated values is located above the maximum or below the minimum of all the class values.", new DoubleValue(1)));
       Parameters.Add(new FixedValueParameter<DoubleValue>(PositiveClassResidualsWeightParameterName, "Weight of residuals which belong to the positive class whereby the estimated value is located between the positive and a negative class.", new DoubleValue(1)));
-      Parameters.Add(new FixedValueParameter<DoubleValue>(NegativeClassResidualsWeightParameterName, "Weight of residuals which are not covered by the ObviousResidualsWeight or the PositiveClassResidualsWeight.", new DoubleValue(1)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(NegativeClassesResidualsWeightParameterName, "Weight of residuals which are not covered by the DefiniteResidualsWeight or the PositiveClassResidualsWeight.", new DoubleValue(1)));
     }
 
     #region parameter properties
-    public IFixedValueParameter<DoubleValue> ObviousResidualsWeightParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters[ObviousResidualsWeightParameterName]; }
+    public IFixedValueParameter<DoubleValue> DefiniteResidualsWeightParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[DefiniteResidualsWeightParameterName]; }
     }
     public IFixedValueParameter<DoubleValue> PositiveClassResidualsWeightParameter {
       get { return (IFixedValueParameter<DoubleValue>)Parameters[PositiveClassResidualsWeightParameterName]; }
     }
-    public IFixedValueParameter<DoubleValue> NegativeClassResidualsWeightParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters[NegativeClassResidualsWeightParameterName]; }
+    public IFixedValueParameter<DoubleValue> NegativeClassesResidualsWeightParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[NegativeClassesResidualsWeightParameterName]; }
     }
     #endregion
@@ -72 +72 @@
     public override bool Maximization { get { return false; } }
 
-    public double ObviousResidualsWeight {
+    public double DefiniteResidualsWeight {
       get {
-        return ObviousResidualsWeightParameter.Value.Value;
+        return DefiniteResidualsWeightParameter.Value.Value;
       }
     }
@@ -82 +82 @@
       }
     }
-    public double NegativeClassResidualsWeight {
+    public double NegativeClassesResidualsWeight {
       get {
-        return NegativeClassResidualsWeightParameter.Value.Value;
+        return NegativeClassesResidualsWeightParameter.Value.Value;
       }
     }
@@ -93 +93 @@
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value,
-        ObviousResidualsWeight, PositiveClassResidualsWeight, NegativeClassResidualsWeight);
+        DefiniteResidualsWeight, PositiveClassResidualsWeight, NegativeClassesResidualsWeight);
       QualityParameter.ActualValue = new DoubleValue(quality);
       return base.InstrumentedApply();
@@ -99 +99 @@
 
     public static double Calculate(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, IClassificationProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
-      double obviousResidualsWeight, double positiveClassResidualsWeight, double negativeClassResidualsWeight) {
+      double definiteResidualsWeight, double positiveClassResidualsWeight, double negativeClassesResidualsWeight) {
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
@@ -116 +116 @@
       if (applyLinearScaling) {
         var calculator = new OnlineWeightedResidualsMeanSquaredErrorCalculator(positiveClassValue, classValuesMax, classValuesMin,
-          obviousResidualsWeight, positiveClassResidualsWeight, negativeClassResidualsWeight);
+          definiteResidualsWeight, positiveClassResidualsWeight, negativeClassesResidualsWeight);
         CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, calculator, problemData.Dataset.Rows);
         errorState = calculator.ErrorState;
@@ -123 +123 @@
         IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
         quality = OnlineWeightedResidualsMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, positiveClassValue, classValuesMax,
-          classValuesMin, obviousResidualsWeight, positiveClassResidualsWeight, negativeClassResidualsWeight, out errorState);
+          classValuesMin, definiteResidualsWeight, positiveClassResidualsWeight, negativeClassesResidualsWeight, out errorState);
       }
       if (errorState != OnlineCalculatorError.None) return Double.NaN;
@@ -134 +134 @@
       ApplyLinearScalingParameter.ExecutionContext = context;
 
-      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, ApplyLinearScalingParameter.ActualValue.Value, ObviousResidualsWeight, PositiveClassResidualsWeight, NegativeClassResidualsWeight);
+      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, ApplyLinearScalingParameter.ActualValue.Value, DefiniteResidualsWeight, PositiveClassResidualsWeight, NegativeClassesResidualsWeight);
 
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;