Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/TrainingBestSymbolicClassificationSolutionAnalyzer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/TrainingBestSymbolicClassificationSolutionAnalyzer.cs	(revision 5321)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/TrainingBestSymbolicClassificationSolutionAnalyzer.cs	(revision 5322)
@@ -53,4 +53,5 @@
     private const string UpperEstimationLimitParameterName = "UpperEstimationLimit";
     private const string LowerEstimationLimitParameterName = "LowerEstimationLimit";
+    private const string ApplyLinearScalingParameterName = "ApplyLinearScaling";
     private const string BestSolutionParameterName = "Best training solution";
     private const string BestSolutionQualityParameterName = "Best training solution quality";
@@ -96,4 +97,7 @@
       get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
     }
+    public IValueLookupParameter<BoolValue> ApplyLinearScalingParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
+    }
 
     public ILookupParameter<SymbolicClassificationSolution> BestSolutionParameter {
@@ -170,4 +174,9 @@
       get { return LowerEstimationLimitParameter.ActualValue; }
     }
+    public BoolValue ApplyLinearScaling {
+      get { return ApplyLinearScalingParameter.ActualValue; }
+      set { ApplyLinearScalingParameter.ActualValue = value; }
+    }
+
     public ResultCollection Results {
       get { return ResultsParameter.ActualValue; }
@@ -241,4 +250,5 @@
       Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper estimation limit that was set for the evaluation of the symbolic expression trees."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower estimation limit that was set for the evaluation of the symbolic expression trees."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>(ApplyLinearScalingParameterName, "The switch determines if the best solution should be linearly scaled on the whole training set.", new BoolValue(false)));
       Parameters.Add(new LookupParameter<SymbolicClassificationSolution>(BestSolutionParameterName, "The best symbolic classification solution."));
       Parameters.Add(new LookupParameter<DoubleValue>(BestSolutionQualityParameterName, "The quality of the best symbolic classification solution."));
@@ -257,4 +267,11 @@
     }
 
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ApplyLinearScalingParameterName)) {
+        Parameters.Add(new ValueLookupParameter<BoolValue>(ApplyLinearScalingParameterName, "The switch determines if the best solution should be linearly scaled on the whole training set.", new BoolValue(false)));
+      }
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new TrainingBestSymbolicClassificationSolutionAnalyzer(this, cloner);
@@ -287,15 +304,17 @@
         string targetVariable = ProblemData.TargetVariable.Value;
 
-        // calculate scaling parameters and only for the best tree using the full training set
-        double alpha, beta;
-        SymbolicRegressionScaledMeanSquaredErrorEvaluator.Calculate(SymbolicExpressionTreeInterpreter, bestTree,
-          lowerEstimationLimit, upperEstimationLimit,
-          ProblemData.Dataset, targetVariable,
-          ProblemData.TrainingIndizes, out beta, out alpha);
-
-        // scale tree for solution
-        var scaledTree = SymbolicRegressionSolutionLinearScaler.Scale(bestTree, alpha, beta);
+        if (ApplyLinearScaling.Value) {
+          // calculate scaling parameters and only for the best tree using the full training set
+          double alpha, beta;
+          SymbolicRegressionScaledMeanSquaredErrorEvaluator.Calculate(SymbolicExpressionTreeInterpreter, bestTree,
+            lowerEstimationLimit, upperEstimationLimit,
+            ProblemData.Dataset, targetVariable,
+            ProblemData.TrainingIndizes, out beta, out alpha);
+
+          // scale tree for solution
+          bestTree = SymbolicRegressionSolutionLinearScaler.Scale(bestTree, alpha, beta);
+        }
         var model = new SymbolicRegressionModel((ISymbolicExpressionTreeInterpreter)SymbolicExpressionTreeInterpreter.Clone(),
-          scaledTree);
+          bestTree);
         var solution = new SymbolicClassificationSolution((ClassificationProblemData)ProblemData.Clone(), model, lowerEstimationLimit, upperEstimationLimit);
         solution.Name = BestSolutionParameterName;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/ValidationBestSymbolicClassificationSolutionAnalyzer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/ValidationBestSymbolicClassificationSolutionAnalyzer.cs	(revision 5321)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/ValidationBestSymbolicClassificationSolutionAnalyzer.cs	(revision 5322)
@@ -53,4 +53,5 @@
     private const string LowerEstimationLimitParameterName = "LowerEstimationLimit";
     private const string CalculateSolutionComplexityParameterName = "CalculateSolutionComplexity";
+    private const string ApplyLinearScalingParameterName = "ApplyLinearScaling";
 
     private const string ResultsParameterName = "Results";
@@ -79,5 +80,4 @@
       get { return (IValueLookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
     }
-
     public ILookupParameter<ClassificationProblemData> ClassificationProblemDataParameter {
       get { return (ILookupParameter<ClassificationProblemData>)Parameters[ClassificationProblemDataParameterName]; }
@@ -101,4 +101,7 @@
       get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
     }
+    public IValueLookupParameter<BoolValue> ApplyLinearScalingParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
+    }
     public ILookupParameter<DataTable> VariableFrequenciesParameter {
       get { return (ILookupParameter<DataTable>)Parameters[VariableFrequenciesParameterName]; }
@@ -107,4 +110,5 @@
       get { return (IValueParameter<BoolValue>)Parameters[CalculateSolutionComplexityParameterName]; }
     }
+
     public ILookupParameter<ResultCollection> ResultsParameter {
       get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
@@ -166,4 +170,8 @@
     public DoubleValue LowerEstimationLimit {
       get { return LowerEstimationLimitParameter.ActualValue; }
+    }
+    public BoolValue ApplyLinearScaling {
+      get { return ApplyLinearScalingParameter.ActualValue; }
+      set { ApplyLinearScalingParameter.ActualValue = value; }
     }
     public DataTable VariableFrequencies {
@@ -216,5 +224,4 @@
       Parameters.Add(new ScopeTreeLookupParameter<SymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
       Parameters.Add(new ValueLookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used for the analysis of symbolic expression trees."));
-
       Parameters.Add(new LookupParameter<ClassificationProblemData>(ClassificationProblemDataParameterName, "The problem data for which the symbolic expression tree is a solution."));
       Parameters.Add(new LookupParameter<ISymbolicClassificationEvaluator>(EvaluatorParameterName, "The evaluator which should be used to evaluate the solution on the validation set."));
@@ -226,4 +233,6 @@
       Parameters.Add(new LookupParameter<DataTable>(VariableFrequenciesParameterName, "The variable frequencies table to use for the calculation of variable impacts"));
       Parameters.Add(new ValueParameter<BoolValue>(CalculateSolutionComplexityParameterName, "Determines if the length and height of the validation best solution should be calculated.", new BoolValue(true)));
+      Parameters.Add(new ValueLookupParameter<BoolValue>(ApplyLinearScalingParameterName, "The switch determines if the best solution should be linearly scaled on the whole training set.", new BoolValue(false)));
+
       Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
       Parameters.Add(new LookupParameter<DoubleValue>(BestValidationQualityParameterName, "The validation quality of the best solution in the current run."));
@@ -245,4 +254,7 @@
       if (!Parameters.ContainsKey(BestSolutionHeightParameterName)) {
         Parameters.Add(new LookupParameter<IntValue>(BestSolutionHeightParameterName, "The height of the best symbolic classification solution."));
+      }
+      if (!Parameters.ContainsKey(ApplyLinearScalingParameterName)) {
+        Parameters.Add(new ValueLookupParameter<BoolValue>(ApplyLinearScalingParameterName, "The switch determines if the best solution should be linearly scaled on the whole training set.", new BoolValue(false)));
       }
     }
@@ -289,14 +301,16 @@
         (!Maximization.Value && bestQuality < BestValidationQuality.Value);
       if (newBest) {
-        double alpha, beta;
-        SymbolicRegressionScaledMeanSquaredErrorEvaluator.Calculate(SymbolicExpressionTreeInterpreter, bestTree,
-          lowerEstimationLimit, upperEstimationLimit,
-          ClassificationProblemData.Dataset, targetVariable,
-          ClassificationProblemData.TrainingIndizes, out beta, out alpha);
-
-        // scale tree for solution
-        var scaledTree = SymbolicRegressionSolutionLinearScaler.Scale(bestTree, alpha, beta);
+        if (ApplyLinearScaling.Value) {
+          double alpha, beta;
+          SymbolicRegressionScaledMeanSquaredErrorEvaluator.Calculate(SymbolicExpressionTreeInterpreter, bestTree,
+            lowerEstimationLimit, upperEstimationLimit,
+            ClassificationProblemData.Dataset, targetVariable,
+            ClassificationProblemData.TrainingIndizes, out beta, out alpha);
+
+          // scale tree for solution
+          bestTree = SymbolicRegressionSolutionLinearScaler.Scale(bestTree, alpha, beta);
+        }
         var model = new SymbolicRegressionModel((ISymbolicExpressionTreeInterpreter)SymbolicExpressionTreeInterpreter.Clone(),
-          scaledTree);
+          bestTree);
 
         if (BestValidationSolution == null) {
