Changeset 2328

Timestamp:

09/03/09 15:00:23 (15 years ago)

Author:

gkronber

Message:

this is the remaining part of changeset r2327.
Applied changes in modeling plugins that are necessary for the new model analyzer (#722)

• predictor has properties for the lower and upper limit of the predicted value
• added views for predictors that show the limits (also added a new view for GeneticProgrammingModel that shows the size and height of the model)
• Reintroduced TreeEvaluatorInjectors that read a PunishmentFactor and calculate the lower and upper limits for estimated values (limits are set in the tree evaluators)
• Added operators to create Predictors. Changed modeling algorithms to use the predictors for the calculation of final model qualities and variable impacts (to be compatible with the new model analyzer the predictors use a very large PunishmentFactor)
• replaced all private implementations of double.IsAlmost and use HL.Commons instead (see #733 r2324)
• Implemented operator SolutionExtractor and moved BestSolutionStorer from HL.Logging to HL.Modeling (fixes #734)

Location:

trunk/sources

Files:

• HeuristicLab.GP.Boolean/3.3/BooleanTreeInterpreter.cs (modified) (3 diffs)
• HeuristicLab.GP.Boolean/3.3/HeuristicLab.GP.Boolean-3.3.csproj (modified) (1 diff)
• HeuristicLab.GP.Boolean/3.3/HeuristicLabGPBooleanPlugin.cs (modified) (1 diff)
• HeuristicLab.GP.StructureIdentification.Classification/3.3/ClassificationMeanSquaredErrorEvaluator.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLab.GP.StructureIdentification.Classification-3.3.csproj (modified) (1 diff)
• HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLabGPClassificationPlugin.cs (modified) (1 diff)
• HeuristicLab.GP.StructureIdentification.Classification/3.3/MulticlassModeller.cs (modified) (6 diffs)
• HeuristicLab.GP.StructureIdentification.Classification/3.3/MulticlassOneVsOneAnalyzer.cs (modified) (6 diffs)
• HeuristicLab.GP.StructureIdentification/3.3/BaseClasses/AlgorithmBase.cs (modified) (9 diffs)
• HeuristicLab.GP.StructureIdentification/3.3/BaseClasses/TreeEvaluatorBase.cs (modified) (7 diffs)
• HeuristicLab.GP.StructureIdentification/3.3/Evaluators/GPEvaluatorBase.cs (modified) (2 diffs)
• HeuristicLab.GP.StructureIdentification/3.3/HL2TreeEvaluator.cs (modified) (1 diff)
• HeuristicLab.GP.StructureIdentification/3.3/HL3TreeEvaluator.cs (modified) (1 diff)
• HeuristicLab.GP.StructureIdentification/3.3/HeuristicLab.GP.StructureIdentification-3.3.csproj (modified) (2 diffs)
• HeuristicLab.GP.StructureIdentification/3.3/ITreeEvaluator.cs (modified) (1 diff)
• HeuristicLab.GP.StructureIdentification/3.3/Predictor.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification/3.3/PredictorBuilder.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs (modified) (3 diffs)
• HeuristicLab.GP/3.3/FunctionTreeView.Designer.cs (modified) (2 diffs)
• HeuristicLab.GP/3.3/GeneticProgrammingModel.cs (modified) (1 diff)
• HeuristicLab.GP/3.3/HeuristicLab.GP-3.3.csproj (modified) (2 diffs)
• HeuristicLab.LinearRegression/3.2/LinearRegression.cs (modified) (4 diffs)
• HeuristicLab.Logging/3.2/HeuristicLab.Logging-3.2.csproj (modified) (1 diff)
• HeuristicLab.Modeling/3.2/BestSolutionStorer.cs (moved) (moved from trunk/sources/HeuristicLab.Logging/3.2/BestSolutionStorer.cs) (1 diff)
• HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj (modified) (1 diff)
• HeuristicLab.Modeling/3.2/IPredictor.cs (modified) (1 diff)
• HeuristicLab.Modeling/3.2/PredictorBase.cs (added)
• HeuristicLab.SupportVectorMachines/3.2/HeuristicLab.SupportVectorMachines-3.2.csproj (modified) (2 diffs)
• HeuristicLab.SupportVectorMachines/3.2/Predictor.cs (modified) (4 diffs)
• HeuristicLab.SupportVectorMachines/3.2/PredictorBuilder.cs (modified) (3 diffs)
• HeuristicLab.SupportVectorMachines/3.2/SVMModelView.cs (modified) (1 diff)
• HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs (modified) (1 diff)

trunk/sources/HeuristicLab.GP.Boolean/3.3/BooleanTreeInterpreter.cs

@@ -27 +27 @@
 using System.Xml;
 using System.Diagnostics;
+using HeuristicLab.Common;
 using HeuristicLab.Data;
 using HeuristicLab.GP.Interfaces;
@@ -67 +68 @@
             var varNode = (VariableFunctionTree)t;
             int index = dataset.GetVariableIndex(varNode.VariableName);
-            return !IsAlmost(dataset.GetValue(currentRow, index), 0.0);
+            return !dataset.GetValue(currentRow, index).IsAlmost(0.0);
           }
         case SymbolTable.UNKNOWN:
@@ -74 +75 @@
       }
     }
-
-    private bool IsAlmost(double x, double y) {
-      return Math.Abs(x - y) < EPSILON;
-    }
   }
 }

trunk/sources/HeuristicLab.GP.Boolean/3.3/HeuristicLab.GP.Boolean-3.3.csproj

@@ -100 +100 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.2\HeuristicLab.Common-3.2.csproj">
+      <Project>{1FC004FC-59AF-4249-B1B6-FF25873A20E4}</Project>
+      <Name>HeuristicLab.Common-3.2</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Core\3.2\HeuristicLab.Core-3.2.csproj">
       <Project>{F43B59AB-2B8C-4570-BC1E-15592086517C}</Project>

trunk/sources/HeuristicLab.GP.Boolean/3.3/HeuristicLabGPBooleanPlugin.cs

@@ -28 +28 @@
   [ClassInfo(Name = "HeuristicLab.GP.Boolean-3.3")]
   [PluginFile(Filename = "HeuristicLab.GP.Boolean-3.3.dll", Filetype = PluginFileType.Assembly)]
+  [Dependency(Dependency = "HeuristicLab.Common-3.2")]
   [Dependency(Dependency = "HeuristicLab.Core-3.2")]
   [Dependency(Dependency = "HeuristicLab.Data-3.2")]

trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/ClassificationMeanSquaredErrorEvaluator.cs

@@ -23 +23 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.GP.StructureIdentification.Classification {
@@ -49 +50 @@
           // on the lower end and upper end only add linear error if the absolute error is larger than 1
           // the error>1.0 constraint is needed for balance because in the interval ]-1, 1[ the squared error is smaller than the absolute error
-          if ((IsEqual(original, classes[0]) && error < -1.0) ||
-            (IsEqual(original, classes[classes.Length - 1]) && error > 1.0)) {
+          if ((original.IsAlmost(classes[0]) && error < -1.0) ||
+            (original.IsAlmost(classes[classes.Length - 1]) && error > 1.0)) {
             errorsSquaredSum += Math.Abs(error); // only add linear error below the smallest class or above the largest class
           } else {
@@ -71 +72 @@
       mse.Data = errorsSquaredSum;
     }
-
-    private bool IsEqual(double x, double y) {
-      return Math.Abs(x - y) < EPSILON;
-    }
   }
 }

trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLab.GP.StructureIdentification.Classification-3.3.csproj

@@ -94 +94 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.2\HeuristicLab.Common-3.2.csproj">
+      <Project>{1FC004FC-59AF-4249-B1B6-FF25873A20E4}</Project>
+      <Name>HeuristicLab.Common-3.2</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Core\3.2\HeuristicLab.Core-3.2.csproj">
       <Project>{F43B59AB-2B8C-4570-BC1E-15592086517C}</Project>

trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLabGPClassificationPlugin.cs

@@ -28 +28 @@
   [ClassInfo(Name = "HeuristicLab.GP.StructureIdentification.Classification-3.3")]
   [PluginFile(Filename = "HeuristicLab.GP.StructureIdentification.Classification-3.3.dll", Filetype = PluginFileType.Assembly)]
+  [Dependency(Dependency = "HeuristicLab.Common-3.2")]
   [Dependency(Dependency = "HeuristicLab.Core-3.2")]
   [Dependency(Dependency = "HeuristicLab.Data-3.2")]

trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/MulticlassModeller.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
@@ -83 +84 @@
             double[] row = new double[dataset.Columns];
             double targetValue = origDataset.GetValue(k, targetVariable);
-            if (IsEqual(targetValue, classAValue)) {
+            if (targetValue.IsAlmost(classAValue)) {
               for (int l = 0; l < row.Length; l++) {
                 row[l] = origDataset.GetValue(k, l);
@@ -89 +90 @@
               row[targetVariable] = 0;
               rows.Add(row);
-            } else if (IsEqual(targetValue, classBValue)) {
+            } else if (targetValue.IsAlmost(classBValue)) {
               for (int l = 0; l < row.Length; l++) {
                 row[l] = origDataset.GetValue(k, l);
@@ -102 +103 @@
             double[] row = new double[dataset.Columns];
             double targetValue = origDataset.GetValue(k, targetVariable);
-            if (IsEqual(targetValue, classAValue)) {
+            if (targetValue.IsAlmost(classAValue)) {
               for (int l = 0; l < row.Length; l++) {
                 row[l] = origDataset.GetValue(k, l);
@@ -108 +109 @@
               row[targetVariable] = 0;
               rows.Add(row);
-            } else if (IsEqual(targetValue, classBValue)) {
+            } else if (targetValue.IsAlmost(classBValue)) {
               for (int l = 0; l < row.Length; l++) {
                 row[l] = origDataset.GetValue(k, l);
@@ -141 +142 @@
       return null;
     }
-
-    private bool IsEqual(double x, double y) {
-      return Math.Abs(x - y) < EPSILON;
-    }
   }
 }

trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/MulticlassOneVsOneAnalyzer.cs

@@ -25 +25 @@
 using HeuristicLab.DataAnalysis;
 using HeuristicLab.GP.Interfaces;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.GP.StructureIdentification.Classification {
@@ -44 +45 @@
     private const string TREEEVALUATOR = "TreeEvaluator";
 
-    private const double EPSILON = 1E-6;
     public override string Description {
       get { return @"TASK"; }
@@ -56 +56 @@
       AddVariableInfo(new VariableInfo(CLASSAVALUE, "The original class value of the class A in the subscope", typeof(DoubleData), VariableKind.In));
       AddVariableInfo(new VariableInfo(CLASSBVALUE, "The original class value of the class B in the subscope", typeof(DoubleData), VariableKind.In));
-      AddVariableInfo(new VariableInfo(TRAININGSAMPLESSTART, "The start of training samples in the original dataset", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo(TRAININGSAMPLESEND, "The end of training samples in the original dataset", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo(SAMPLESSTART, "The start of samples in the original dataset", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo(SAMPLESEND, "The end of samples in the original dataset", typeof(IntData), VariableKind.In));
@@ -84 +82 @@
 
         ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>(TREEEVALUATOR, bestScope, true);
-        evaluator.PrepareForEvaluation(dataset, targetVariable, trainingSamplesStart, trainingSamplesEnd, gpModel.FunctionTree);
+        evaluator.PrepareForEvaluation(dataset, gpModel.FunctionTree);
         for(int i = 0; i < (samplesEnd - samplesStart); i++) {
           double est = evaluator.Evaluate(i + samplesStart);
@@ -110 +108 @@
           }
         }
-        if(IsEqual(originalClassValue, estimatedClassValue) && sameVotes == 0) correctlyClassified++;
+        if(originalClassValue.IsAlmost(estimatedClassValue) && sameVotes == 0) correctlyClassified++;
       }
 
@@ -122 +120 @@
     private void CastVote(int[,] votes, int sample, double votedClass, ItemList<DoubleData> classValues) {
       for(int i = 0; i < classValues.Count; i++) {
-        if(IsEqual(classValues[i].Data, votedClass)) votes[sample, i]++;
+        if(classValues[i].Data.IsAlmost(votedClass)) votes[sample, i]++;
       }
-    }
-
-    private bool IsEqual(double x, double y) {
-      return Math.Abs(x - y) < EPSILON;
     }
   }

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/BaseClasses/AlgorithmBase.cs

@@ -33 +33 @@
 using HeuristicLab.Random;
 using HeuristicLab.Selection;
+using HeuristicLab.Operators.Programmable;
 
 namespace HeuristicLab.GP.StructureIdentification {
@@ -75 +76 @@
         if (!engine.Terminated) throw new InvalidOperationException("The algorithm is still running. Wait until the algorithm is terminated to retrieve the result.");
         if (model == null) {
-          IScope bestModelScope = engine.GlobalScope.GetVariableValue<IScope>("BestValidationSolution", false);
+          IScope bestModelScope = engine.GlobalScope.SubScopes[0];
           model = CreateGPModel(bestModelScope);
         }
@@ -140 +141 @@
 
       IOperator globalInjector = CreateGlobalInjector();
+      IOperator treeEvaluatorInjector = new HL2TreeEvaluatorInjector();
       IOperator initialization = CreateInitialization();
       IOperator funLibInjector = CreateFunctionLibraryInjector();
@@ -163 +165 @@
       seq.AddSubOperator(problemInjector);
       seq.AddSubOperator(globalInjector);
+      seq.AddSubOperator(treeEvaluatorInjector);
       seq.AddSubOperator(funLibInjector);
       seq.AddSubOperator(initialization);
       seq.AddSubOperator(mainLoop);
       seq.AddSubOperator(cleanUp);
+      seq.AddSubOperator(CreateModelAnalysisOperator());
 
       initialization.AddSubOperator(treeCreator);
@@ -179 +183 @@
       this.algorithm = seq;
       return algo;
+    }
+
+    protected internal virtual IOperator CreateModelAnalysisOperator() {
+      CombinedOperator op = new CombinedOperator();
+      SequentialProcessor seq = new SequentialProcessor();
+      SolutionExtractor extractor = new SolutionExtractor();
+      extractor.GetVariableInfo("Scope").ActualName = "BestValidationSolution";
+      SequentialSubScopesProcessor seqSubScopeProc = new SequentialSubScopesProcessor();
+      SequentialProcessor solutionProc = new SequentialProcessor();
+
+      seq.AddSubOperator(extractor);
+      seq.AddSubOperator(seqSubScopeProc);
+      seqSubScopeProc.AddSubOperator(solutionProc);
+
+      HL2TreeEvaluatorInjector evaluatorInjector = new HL2TreeEvaluatorInjector();
+      evaluatorInjector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
+      evaluatorInjector.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+
+      #region MSE
+      MeanSquaredErrorEvaluator trainingMseEvaluator = new MeanSquaredErrorEvaluator();
+      trainingMseEvaluator.Name = "TrainingMseEvaluator";
+      trainingMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingMseEvaluator.GetVariableInfo("MSE").ActualName = "TrainingMSE";
+      trainingMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      MeanSquaredErrorEvaluator validationMseEvaluator = new MeanSquaredErrorEvaluator();
+      validationMseEvaluator.Name = "ValidationMseEvaluator";
+      validationMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationMseEvaluator.GetVariableInfo("MSE").ActualName = "ValidationMSE";
+      validationMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      MeanSquaredErrorEvaluator testMseEvaluator = new MeanSquaredErrorEvaluator();
+      testMseEvaluator.Name = "TestMeanSquaredErrorEvaluator";
+      testMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestMSE";
+      testMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      #endregion
+      #region MAPE
+      MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
+      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
+      trainingMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
+      trainingMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
+      trainingMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
+      MeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
+      validationMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
+      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
+      validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      MeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
+      testMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      testMapeEvaluator.Name = "TestMapeEvaluator";
+      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
+      testMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      #endregion
+      #region MAPRE
+      MeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
+      trainingMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
+      trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TrainingMAPRE";
+      trainingMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
+      trainingMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
+      MeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
+      validationMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationMapreEvaluator.Name = "ValidationMapreEvaluator";
+      validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "ValidationMAPRE";
+      validationMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      MeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
+      testMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      testMapreEvaluator.Name = "TestMapreEvaluator";
+      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
+      testMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      #endregion MAPRE
+      #region R2
+      CoefficientOfDeterminationEvaluator trainingR2Evaluator = new CoefficientOfDeterminationEvaluator();
+      trainingR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingR2Evaluator.Name = "TrainingR2Evaluator";
+      trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
+      trainingR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
+      trainingR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
+      CoefficientOfDeterminationEvaluator validationR2Evaluator = new CoefficientOfDeterminationEvaluator();
+      validationR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationR2Evaluator.Name = "ValidationR2Evaluator";
+      validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
+      validationR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      CoefficientOfDeterminationEvaluator testR2Evaluator = new CoefficientOfDeterminationEvaluator();
+      testR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      testR2Evaluator.Name = "TestR2Evaluator";
+      testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
+      testR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      #endregion
+      #region VAF
+      VarianceAccountedForEvaluator trainingVAFEvaluator = new VarianceAccountedForEvaluator();
+      trainingVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
+      trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = "TrainingVAF";
+      trainingVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
+      trainingVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
+      VarianceAccountedForEvaluator validationVAFEvaluator = new VarianceAccountedForEvaluator();
+      validationVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      validationVAFEvaluator.Name = "ValidationVAFEvaluator";
+      validationVAFEvaluator.GetVariableInfo("VAF").ActualName = "ValidationVAF";
+      validationVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      VarianceAccountedForEvaluator testVAFEvaluator = new VarianceAccountedForEvaluator();
+      testVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      testVAFEvaluator.Name = "TestVAFEvaluator";
+      testVAFEvaluator.GetVariableInfo("VAF").ActualName = "TestVAF";
+      testVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
+      testVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
+      #endregion
+
+      solutionProc.AddSubOperator(evaluatorInjector);
+      solutionProc.AddSubOperator(trainingMseEvaluator);
+      solutionProc.AddSubOperator(validationMseEvaluator);
+      solutionProc.AddSubOperator(testMseEvaluator);
+      solutionProc.AddSubOperator(trainingMapeEvaluator);
+      solutionProc.AddSubOperator(validationMapeEvaluator);
+      solutionProc.AddSubOperator(testMapeEvaluator);
+      solutionProc.AddSubOperator(trainingMapreEvaluator);
+      solutionProc.AddSubOperator(validationMapreEvaluator);
+      solutionProc.AddSubOperator(testMapreEvaluator);
+      solutionProc.AddSubOperator(trainingR2Evaluator);
+      solutionProc.AddSubOperator(validationR2Evaluator);
+      solutionProc.AddSubOperator(testR2Evaluator);
+      solutionProc.AddSubOperator(trainingVAFEvaluator);
+      solutionProc.AddSubOperator(validationVAFEvaluator);
+      solutionProc.AddSubOperator(testVAFEvaluator);
+
+      #region variable impacts
+      // calculate and set variable impacts
+      VariableNamesExtractor namesExtractor = new VariableNamesExtractor();
+      namesExtractor.GetVariableInfo("VariableNames").ActualName = "InputVariableNames";
+      PredictorBuilder predictorBuilder = new PredictorBuilder();
+      predictorBuilder.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
+      predictorBuilder.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
+
+      VariableEvaluationImpactCalculator evaluationImpactCalculator = new VariableEvaluationImpactCalculator();
+      evaluationImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
+      evaluationImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
+      VariableQualityImpactCalculator qualityImpactCalculator = new VariableQualityImpactCalculator();
+      qualityImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
+      qualityImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
+
+      solutionProc.AddSubOperator(namesExtractor);
+      solutionProc.AddSubOperator(predictorBuilder);
+      solutionProc.AddSubOperator(evaluationImpactCalculator);
+      solutionProc.AddSubOperator(qualityImpactCalculator);
+      #endregion
+
+      op.OperatorGraph.AddOperator(seq);
+      op.OperatorGraph.InitialOperator = seq;
+      return op;
     }
 
@@ -207 +371 @@
       injector.AddVariable(new HeuristicLab.Core.Variable("Parents", new IntData()));
       injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("TreeEvaluator", new HL2TreeEvaluator()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(10.0)));
       return injector;
     }
@@ -312 +476 @@
     protected internal virtual IOperator CreateBestSolutionProcessor() {
       SequentialProcessor seq = new SequentialProcessor();
-      // calculate and set variable impacts
-      VariableNamesExtractor namesExtractor = new VariableNamesExtractor();
-      namesExtractor.GetVariableInfo("VariableNames").ActualName = "InputVariableNames";
-      PredictorBuilder predictorBuilder = new PredictorBuilder();
-
-      VariableEvaluationImpactCalculator evaluationImpactCalculator = new VariableEvaluationImpactCalculator();
-      evaluationImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      evaluationImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      VariableQualityImpactCalculator qualityImpactCalculator = new VariableQualityImpactCalculator();
-      qualityImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      qualityImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-
-      seq.AddSubOperator(namesExtractor);
-      seq.AddSubOperator(predictorBuilder);
-      seq.AddSubOperator(evaluationImpactCalculator);
-      seq.AddSubOperator(qualityImpactCalculator);
+      ProgrammableOperator progOperator = new ProgrammableOperator();
+      progOperator.RemoveVariableInfo("Result");
+      progOperator.AddVariableInfo(new HeuristicLab.Core.VariableInfo("EvaluatedSolutions", "", typeof(IntData), VariableKind.In));
+      progOperator.Code = @"
+int evalSolutions = EvaluatedSolutions.Data;
+scope.AddVariable(new Variable(""EvaluatedSolutions"", new IntData(evalSolutions)));
+";
+      seq.AddSubOperator(progOperator);
       return seq;
     }
@@ -439 +595 @@
       model.TestSamplesEnd = bestModelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
 
-      model.TrainingMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("Quality", false).Data;
-      model.ValidationMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("ValidationQuality", false).Data;
+      model.TrainingMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TrainingMSE", false).Data;
+      model.ValidationMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("ValidationMSE", false).Data;
+      model.TestMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TestMSE", false).Data;
+      model.TrainingCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data;
+      model.ValidationCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data;
+      model.TestCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TestR2", false).Data;
+      model.TrainingMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data;
+      model.ValidationMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data;
+      model.TestMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data;
+      model.TrainingMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data;
+      model.ValidationMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data;
+      model.TestMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data;
+      model.TrainingVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data;
+      model.ValidationVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data;
+      model.TestVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TestVAF", false).Data;
 
       ItemList evaluationImpacts = bestModelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
@@ -456 +625 @@
         model.AddInputVariable(variableName);
       }
-      Engine.GlobalScope.RemoveSubScope(bestModelScope);
+
       return model;
     }

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/BaseClasses/TreeEvaluatorBase.cs

@@ -33 +33 @@
   public abstract class TreeEvaluatorBase : ItemBase, ITreeEvaluator {
     protected const double EPSILON = 1.0e-7;
-    protected double maxValue = double.MaxValue;
-    protected double minValue = double.MinValue;
-    private double punishmentFactor = 10.0; // we should provide a view for treeevaluators that allows to change this value
 
     protected class Instr {
@@ -50 +47 @@
     protected int sampleIndex;
 
+    public double UpperEvaluationLimit { get; set; }
+    public double LowerEvaluationLimit { get; set; }
+
+    public TreeEvaluatorBase() // for persistence
+      : this(double.MinValue, double.MaxValue) {
+    }
+
+    public TreeEvaluatorBase(double minEstimatedValue, double maxEstimatedValue)
+      : base() {
+      UpperEvaluationLimit = maxEstimatedValue;
+      LowerEvaluationLimit = minEstimatedValue;
+    }
+
     public void PrepareForEvaluation(Dataset dataset, IFunctionTree functionTree) {
       this.dataset = dataset;
@@ -57 +67 @@
         codeArr[i++] = TranslateToInstr(tree);
       }
-    }
-
-    public void PrepareForEvaluation(Dataset dataset, int targetVariable, int start, int end, IFunctionTree functionTree) {
-      // calculate upper and lower bounds for the estimated value (mean +/- punishmentFactor * range)
-      double mean = dataset.GetMean(targetVariable, start, end);
-      double range = dataset.GetRange(targetVariable, start, end);
-      maxValue = mean + punishmentFactor * range;
-      minValue = mean - punishmentFactor * range;
-      PrepareForEvaluation(dataset, functionTree);
     }
 
@@ -106 +107 @@
       this.sampleIndex = sampleIndex;
 
-      double estimated = EvaluateBakedCode();
-      if (double.IsNaN(estimated) || double.IsInfinity(estimated)) estimated = maxValue;
-      else if (estimated < minValue) estimated = minValue;
-      else if (estimated > maxValue) estimated = maxValue;
+      double estimated = Math.Min(Math.Max(EvaluateBakedCode(), LowerEvaluationLimit), UpperEvaluationLimit);
+      if (double.IsNaN(estimated)) estimated = UpperEvaluationLimit;
       return estimated;
     }
@@ -126 +125 @@
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       TreeEvaluatorBase clone = (TreeEvaluatorBase)base.Clone(clonedObjects);
-      clone.maxValue = maxValue;
-      clone.minValue = minValue;
-      clone.punishmentFactor = punishmentFactor;
+      clone.UpperEvaluationLimit = UpperEvaluationLimit;
+      clone.LowerEvaluationLimit = LowerEvaluationLimit;
       return clone;
     }
@@ -134 +132 @@
     public override System.Xml.XmlNode GetXmlNode(string name, System.Xml.XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
-      XmlAttribute maxValueAttribute = document.CreateAttribute("MaxPredictionValue");
-      XmlAttribute minValueAttribute = document.CreateAttribute("MinPredictionValue");
-      XmlAttribute punishmentFactorAttribute = document.CreateAttribute("PunishmentFactor");
-      maxValueAttribute.Value = XmlConvert.ToString(maxValue);
-      minValueAttribute.Value = XmlConvert.ToString(minValue);
-      punishmentFactorAttribute.Value = XmlConvert.ToString(punishmentFactor);
-
-      node.Attributes.Append(punishmentFactorAttribute);
+      XmlAttribute maxValueAttribute = document.CreateAttribute("UpperEvaluationLimit");
+      XmlAttribute minValueAttribute = document.CreateAttribute("LowerEvaluationLimit");
+      maxValueAttribute.Value = XmlConvert.ToString(UpperEvaluationLimit);
+      minValueAttribute.Value = XmlConvert.ToString(LowerEvaluationLimit);
       node.Attributes.Append(minValueAttribute);
       node.Attributes.Append(maxValueAttribute);
@@ -149 +143 @@
     public override void Populate(System.Xml.XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
-      minValue = XmlConvert.ToDouble(node.Attributes["MinPredictionValue"].Value);
-      maxValue = XmlConvert.ToDouble(node.Attributes["MaxPredictionValue"].Value);
-      punishmentFactor = XmlConvert.ToDouble(node.Attributes["PunishmentFactor"].Value);
+      LowerEvaluationLimit = XmlConvert.ToDouble(node.Attributes["LowerEvaluationLimit"].Value);
+      UpperEvaluationLimit = XmlConvert.ToDouble(node.Attributes["UpperEvaluationLimit"].Value);
     }
   }

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/GPEvaluatorBase.cs

@@ -34 +34 @@
       AddVariableInfo(new VariableInfo("TargetVariable", "Index of the column of the dataset that holds the target variable", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("TotalEvaluatedNodes", "Number of evaluated nodes", typeof(DoubleData), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("TrainingSamplesStart", "Start index of training samples in dataset", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("TrainingSamplesEnd", "End index of training samples in dataset", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("SamplesStart", "Start index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("SamplesEnd", "End index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
@@ -47 +45 @@
       IGeneticProgrammingModel gpModel = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", scope, true);
       double totalEvaluatedNodes = scope.GetVariableValue<DoubleData>("TotalEvaluatedNodes", true).Data;
-      int trainingStart = GetVariableValue<IntData>("TrainingSamplesStart", scope, true).Data;
-      int trainingEnd = GetVariableValue<IntData>("TrainingSamplesEnd", scope, true).Data;
       int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
       int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
       bool useEstimatedValues = GetVariableValue<BoolData>("UseEstimatedTargetValue", scope, true).Data;
       ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
-      evaluator.PrepareForEvaluation(dataset, targetVariable, trainingStart, trainingEnd, gpModel.FunctionTree);
+      evaluator.PrepareForEvaluation(dataset, gpModel.FunctionTree);
 
       double[] backupValues = null;

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/HL2TreeEvaluator.cs

@@ -28 +28 @@
   /// </summary>
   public class HL2TreeEvaluator : TreeEvaluatorBase {
+    public HL2TreeEvaluator() : base() { } // for persistence
+    public HL2TreeEvaluator(double minValue, double maxValue) : base(minValue, maxValue) { }
 
     protected override double EvaluateBakedCode() {

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/HL3TreeEvaluator.cs

@@ -30 +30 @@
   /// </summary>
   public class HL3TreeEvaluator : TreeEvaluatorBase {
+    public HL3TreeEvaluator() : base() { } // for persistence
+    public HL3TreeEvaluator(double minValue, double maxValue) : base(minValue, maxValue) { }
+
     protected override double EvaluateBakedCode() {
       Instr currInstr = codeArr[PC++];

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/HeuristicLab.GP.StructureIdentification-3.3.csproj

@@ -85 +85 @@
     <Compile Include="BaseClasses\FunctionTreeBase.cs" />
     <Compile Include="BaseClasses\TreeEvaluatorBase.cs" />
+    <Compile Include="HL3TreeEvaluatorInjector.cs" />
+    <Compile Include="HL2TreeEvaluatorInjector.cs" />
     <Compile Include="PredictorBuilder.cs" />
     <Compile Include="Predictor.cs" />
     <Compile Include="Evaluators\SimpleGPEvaluatorBase.cs" />
     <Compile Include="HL3TreeEvaluator.cs" />
+    <Compile Include="PredictorView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="PredictorView.Designer.cs">
+      <DependentUpon>PredictorView.cs</DependentUpon>
+    </Compile>
     <Compile Include="Symbols\Addition.cs" />
     <Compile Include="Symbols\And.cs" />
@@ -222 +230 @@
       <DependentUpon>OffSpringSelectionGpEditor.cs</DependentUpon>
     </EmbeddedResource>
+    <EmbeddedResource Include="PredictorView.resx">
+      <DependentUpon>PredictorView.cs</DependentUpon>
+    </EmbeddedResource>
     <EmbeddedResource Include="StandardGpEditor.resx">
       <DependentUpon>StandardGpEditor.cs</DependentUpon>

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/ITreeEvaluator.cs

@@ -26 +26 @@
 namespace HeuristicLab.GP.StructureIdentification {
   public interface ITreeEvaluator : IItem {
-    void PrepareForEvaluation(Dataset dataset, int targetVariable, int start, int end, IFunctionTree functionTree);
+    double LowerEvaluationLimit { get; set; }
+    double UpperEvaluationLimit { get; set; }
     void PrepareForEvaluation(Dataset dataset, IFunctionTree functionTree);
     double Evaluate(int sampleIndex);

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Predictor.cs

@@ -31 +31 @@
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public class Predictor : ItemBase, IPredictor {
+  public class Predictor : PredictorBase {
     private ITreeEvaluator treeEvaluator;
-    
-
-    public Predictor() : base() { } // for persistence
-    public Predictor(ITreeEvaluator evaluator, IGeneticProgrammingModel tree)
-      : base() {
-      this.treeEvaluator = evaluator;
-      this.functionTree = tree;
-    }
 
     private IGeneticProgrammingModel functionTree;
@@ -46 +38 @@
       get { return functionTree; }
     }
+    public Predictor() : base() { } // for persistence
+    public Predictor(ITreeEvaluator evaluator, IGeneticProgrammingModel tree, double lowerPredictionLimit, double upperPredictionLimit)
+      : base(lowerPredictionLimit, upperPredictionLimit) {
+      this.treeEvaluator = evaluator;
+      this.functionTree = tree;
+    }
 
-    public double[] Predict(Dataset input, int start, int end) {
+    public override double[] Predict(Dataset input, int start, int end) {
+      treeEvaluator.UpperEvaluationLimit = UpperPredictionLimit;
+      treeEvaluator.LowerEvaluationLimit = LowerPredictionLimit;
+
       if (start < 0 || end <= start) throw new ArgumentException("start must be larger than zero and strictly smaller than end");
       if (end > input.Rows) throw new ArgumentOutOfRangeException("number of rows in input is smaller then end");
@@ -59 +60 @@
 
     public override IView CreateView() {
-      return functionTree.CreateView();
+      return new PredictorView(this);
     }
 

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/PredictorBuilder.cs

@@ -28 +28 @@
 using HeuristicLab.GP.Interfaces;
 using HeuristicLab.Modeling;
+using HeuristicLab.DataAnalysis;
 
 namespace HeuristicLab.GP.StructureIdentification {
@@ -35 +36 @@
       AddVariableInfo(new VariableInfo("FunctionTree", "The function tree", typeof(IGeneticProgrammingModel), VariableKind.In));
       AddVariableInfo(new VariableInfo("TreeEvaluator", "The tree evaluator used to evaluate the model", typeof(ITreeEvaluator), VariableKind.In));
+      AddVariableInfo(new VariableInfo("PunishmentFactor", "The punishment factor limits the estimated values to a certain range", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("Dataset", "The dataset", typeof(Dataset), VariableKind.In));
+      AddVariableInfo(new VariableInfo("TrainingSamplesStart", "Start index of training set", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("TrainingSamplesEnd", "End index of training set", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("TargetVariable", "Index of the target variable", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("Predictor", "The predictor combines the function tree and the evaluator and can be used to generate estimated values", typeof(IPredictor), VariableKind.New));
     }
@@ -44 +50 @@
     public override IOperation Apply(IScope scope) {
       IGeneticProgrammingModel model = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", scope, true);
-      ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("Predictor"), new Predictor(evaluator, model)));
+      ITreeEvaluator evaluator = (ITreeEvaluator)GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true).Clone();
+      double punishmentFactor = GetVariableValue<DoubleData>("PunishmentFactor", scope, true).Data;
+      Dataset dataset = GetVariableValue<Dataset>("Dataset", scope, true);
+      int start = GetVariableValue<IntData>("TrainingSamplesStart", scope, true).Data;
+      int end = GetVariableValue<IntData>("TrainingSamplesEnd", scope, true).Data;
+      int targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
+      double mean = dataset.GetMean(targetVariable, start, end);
+      double range = dataset.GetRange(targetVariable, start, end);
+      double minEstimatedValue = mean - punishmentFactor * range;
+      double maxEstimatedValue = mean + punishmentFactor * range;
+      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("Predictor"), new Predictor(evaluator, model, minEstimatedValue, maxEstimatedValue)));
       return null;
     }

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs

@@ -115 +115 @@
 
     protected internal override IOperator CreateProblemInjector() {
-      SequentialProcessor seq = new SequentialProcessor();      
+      SequentialProcessor seq = new SequentialProcessor();
       var probInject = new ProblemInjector();
       probInject.GetVariableInfo("MaxNumberOfTrainingSamples").Local = true;
@@ -201 +201 @@
       manipulator.OperatorGraph.InitialOperator = multibranch;
       return manipulator;
-    }
-
-    protected internal override IOperator CreateBestSolutionProcessor() {      
-      SequentialProcessor bestSolutionProcessor = new SequentialProcessor();
-      bestSolutionProcessor.AddSubOperator(base.CreateBestSolutionProcessor());
-
-      #region MSE
-      MeanSquaredErrorEvaluator testMseEvaluator = new MeanSquaredErrorEvaluator();
-      testMseEvaluator.Name = "TestMeanSquaredErrorEvaluator";
-      testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestQuality";
-      testMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-      #endregion
-      #region MAPE
-      MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
-      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
-      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
-      trainingMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      trainingMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      MeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
-      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
-      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
-      validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      MeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
-      testMapeEvaluator.Name = "TestMapeEvaluator";
-      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
-      testMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-      #endregion
-      #region MAPRE
-      MeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
-      trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
-      trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TrainingMAPRE";
-      trainingMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      trainingMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      MeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
-      validationMapreEvaluator.Name = "ValidationMapreEvaluator";
-      validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "ValidationMAPRE";
-      validationMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      MeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
-      testMapreEvaluator.Name = "TestMapreEvaluator";
-      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
-      testMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-      #endregion MAPRE
-      #region R2
-      CoefficientOfDeterminationEvaluator trainingR2Evaluator = new CoefficientOfDeterminationEvaluator();
-      trainingR2Evaluator.Name = "TrainingR2Evaluator";
-      trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
-      trainingR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      trainingR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      CoefficientOfDeterminationEvaluator validationR2Evaluator = new CoefficientOfDeterminationEvaluator();
-      validationR2Evaluator.Name = "ValidationR2Evaluator";
-      validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
-      validationR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      CoefficientOfDeterminationEvaluator testR2Evaluator = new CoefficientOfDeterminationEvaluator();
-      testR2Evaluator.Name = "TestR2Evaluator";
-      testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
-      testR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-      #endregion
-      #region VAF
-      VarianceAccountedForEvaluator trainingVAFEvaluator = new VarianceAccountedForEvaluator();
-      trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
-      trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = "TrainingVAF";
-      trainingVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
-      trainingVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
-      VarianceAccountedForEvaluator validationVAFEvaluator = new VarianceAccountedForEvaluator();
-      validationVAFEvaluator.Name = "ValidationVAFEvaluator";
-      validationVAFEvaluator.GetVariableInfo("VAF").ActualName = "ValidationVAF";
-      validationVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      VarianceAccountedForEvaluator testVAFEvaluator = new VarianceAccountedForEvaluator();
-      testVAFEvaluator.Name = "TestVAFEvaluator";
-      testVAFEvaluator.GetVariableInfo("VAF").ActualName = "TestVAF";
-      testVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
-      testVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
-      #endregion
-      ProgrammableOperator progOperator = new ProgrammableOperator();
-      progOperator.RemoveVariableInfo("Result");
-      progOperator.AddVariableInfo(new HeuristicLab.Core.VariableInfo("EvaluatedSolutions", "", typeof(IntData), VariableKind.In));
-      progOperator.Code = @"
-int evalSolutions = EvaluatedSolutions.Data;
-scope.AddVariable(new Variable(""EvaluatedSolutions"", new IntData(evalSolutions)));
-";
-      bestSolutionProcessor.AddSubOperator(testMseEvaluator);
-      bestSolutionProcessor.AddSubOperator(trainingMapeEvaluator);
-      bestSolutionProcessor.AddSubOperator(validationMapeEvaluator);
-      bestSolutionProcessor.AddSubOperator(testMapeEvaluator);
-      bestSolutionProcessor.AddSubOperator(trainingMapreEvaluator);
-      bestSolutionProcessor.AddSubOperator(validationMapreEvaluator);
-      bestSolutionProcessor.AddSubOperator(testMapreEvaluator);
-      bestSolutionProcessor.AddSubOperator(trainingR2Evaluator);
-      bestSolutionProcessor.AddSubOperator(validationR2Evaluator);
-      bestSolutionProcessor.AddSubOperator(testR2Evaluator);
-      bestSolutionProcessor.AddSubOperator(trainingVAFEvaluator);
-      bestSolutionProcessor.AddSubOperator(validationVAFEvaluator);
-      bestSolutionProcessor.AddSubOperator(testVAFEvaluator);
-      bestSolutionProcessor.AddSubOperator(progOperator);
-      return bestSolutionProcessor;
     }
 
@@ -338 +235 @@
     }
 
-    protected internal override IAnalyzerModel CreateGPModel(IScope bestModelScope) {
-      IAnalyzerModel model = base.CreateGPModel(bestModelScope);
-      model.TestMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TestQuality", false).Data;
-      model.TrainingCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data;
-      model.ValidationCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data;
-      model.TestCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TestR2", false).Data;
-      model.TrainingMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data;
-      model.ValidationMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data;
-      model.TestMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data;
-      model.TrainingMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data;
-      model.ValidationMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data;
-      model.TestMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data;
-      model.TrainingVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data;
-      model.ValidationVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data;
-      model.TestVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TestVAF", false).Data;
-
-      return model;
-    }
-
     public virtual IEditor CreateEditor() {
       return new StandardGpEditor(this);

trunk/sources/HeuristicLab.GP/3.3/FunctionTreeView.Designer.cs

@@ -52 +52 @@
       // funTreeView
       // 
-      this.funTreeView.Dock = System.Windows.Forms.DockStyle.Fill;
       this.funTreeView.HideSelection = false;
       this.funTreeView.Location = new System.Drawing.Point(0, 0);
@@ -73 +72 @@
     #endregion
 
-    private System.Windows.Forms.ContextMenu treeNodeContextMenu;
-    private System.Windows.Forms.TreeView funTreeView;
+    protected System.Windows.Forms.ContextMenu treeNodeContextMenu;
+    protected System.Windows.Forms.TreeView funTreeView;
   }
 }

trunk/sources/HeuristicLab.GP/3.3/GeneticProgrammingModel.cs

@@ -97 +97 @@
 
     public override IView CreateView() {
-      return new FunctionTreeView(this.FunctionTree);
+      return new GeneticProgrammingModelView(this);
     }
   }

trunk/sources/HeuristicLab.GP/3.3/HeuristicLab.GP-3.3.csproj

@@ -89 +89 @@
     <Compile Include="BaseClasses\Terminal.cs" />
     <Compile Include="BaseClasses\UnaryFunction.cs" />
+    <Compile Include="GeneticProgrammingModelView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="GeneticProgrammingModelView.Designer.cs">
+      <DependentUpon>GeneticProgrammingModelView.cs</DependentUpon>
+    </Compile>
     <Compile Include="FunctionLibrary.cs" />
     <Compile Include="FunctionLibraryEditor.cs">
@@ -127 +133 @@
   </ItemGroup>
   <ItemGroup>
+    <EmbeddedResource Include="GeneticProgrammingModelView.resx">
+      <DependentUpon>GeneticProgrammingModelView.cs</DependentUpon>
+    </EmbeddedResource>
     <EmbeddedResource Include="FunctionLibraryEditor.resx">
       <DependentUpon>FunctionLibraryEditor.cs</DependentUpon>

trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegression.cs

@@ -97 +97 @@
       problemInjector.AddVariable(new HeuristicLab.Core.Variable("MaxNumberOfTrainingSamples", new IntData(5000)));
 
+      HL2TreeEvaluatorInjector treeEvaluatorInjector = new HL2TreeEvaluatorInjector();
+
       IOperator shuffler = new DatasetShuffler();
       shuffler.GetVariableInfo("ShuffleStart").ActualName = "TrainingSamplesStart";
@@ -108 +110 @@
       seq.AddSubOperator(problemInjector);
       seq.AddSubOperator(globalInjector);
+      seq.AddSubOperator(treeEvaluatorInjector);
       seq.AddSubOperator(shuffler);
       seq.AddSubOperator(lrOperator);
@@ -120 +123 @@
     private IOperator CreateGlobalInjector() {
       VariableInjector injector = new VariableInjector();
-      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(10)));
+      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000)));
       injector.AddVariable(new HeuristicLab.Core.Variable("TotalEvaluatedNodes", new DoubleData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("TreeEvaluator", new HL2TreeEvaluator()));
       injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData(false)));
 
@@ -272 +274 @@
     }
 
-
     protected internal virtual IAnalyzerModel CreateLRModel(IScope bestModelScope) {
       IAnalyzerModel model = new AnalyzerModel();

trunk/sources/HeuristicLab.Logging/3.2/HeuristicLab.Logging-3.2.csproj

@@ -80 +80 @@
   <ItemGroup>
     <Compile Include="BestAverageWorstQualityCalculator.cs" />
-    <Compile Include="BestSolutionStorer.cs" />
     <Compile Include="PointXYChartView.cs">
       <SubType>UserControl</SubType>

trunk/sources/HeuristicLab.Modeling/3.2/BestSolutionStorer.cs

@@ -25 +25 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Operators;
 
-namespace HeuristicLab.Logging {
+namespace HeuristicLab.Modeling {
   /// <summary>
   /// Keeps a variable in the global scope that contains the scope representing the best solution.

trunk/sources/HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj

@@ -83 +83 @@
   <ItemGroup>
     <Compile Include="AnalyzerModel.cs" />
+    <Compile Include="BestSolutionStorer.cs" />
     <Compile Include="ClassificationProblemInjector.cs" />
+    <Compile Include="SolutionExtractor.cs" />
+    <Compile Include="PredictorBase.cs" />
     <Compile Include="IAnalyzerModel.cs" />
     <Compile Include="MatrixCreator.cs" />

trunk/sources/HeuristicLab.Modeling/3.2/IPredictor.cs

@@ -28 +28 @@
 namespace HeuristicLab.Modeling {
   public interface IPredictor : IItem {
+    double UpperPredictionLimit { get; set; }
+    double LowerPredictionLimit { get; set; }
     double[] Predict(Dataset dataset, int start, int end);
   } 

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/HeuristicLab.SupportVectorMachines-3.2.csproj

@@ -83 +83 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="PredictorView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="PredictorView.Designer.cs">
+      <DependentUpon>PredictorView.cs</DependentUpon>
+    </Compile>
     <Compile Include="Predictor.cs" />
     <Compile Include="PredictorBuilder.cs" />
@@ -154 +160 @@
   </ItemGroup>
   <ItemGroup>
+    <EmbeddedResource Include="PredictorView.resx">
+      <DependentUpon>PredictorView.cs</DependentUpon>
+    </EmbeddedResource>
     <EmbeddedResource Include="SVMModelView.resx">
       <DependentUpon>SVMModelView.cs</DependentUpon>

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/Predictor.cs

@@ -32 +32 @@
 
 namespace HeuristicLab.SupportVectorMachines {
-  public class Predictor : ItemBase, IPredictor {
+  public class Predictor : PredictorBase {
     private SVMModel svmModel;
+    public SVMModel Model {
+      get { return svmModel; }
+    }
+
     private Dictionary<string, int> variableNames = new Dictionary<string, int>();
     private string targetVariable;
@@ -46 +50 @@
     }
 
-    public double[] Predict(Dataset input, int start, int end) {
+    public override double[] Predict(Dataset input, int start, int end) {
       if (start < 0 || end <= start) throw new ArgumentException("start must be larger than zero and strictly smaller than end");
       if (end > input.Rows) throw new ArgumentOutOfRangeException("number of rows in input is smaller then end");
@@ -64 +68 @@
       double[] result = new double[rows];
       for (int row = 0; row < rows; row++) {
-        result[row] = SVM.Prediction.Predict(model, scaledProblem.X[row]);
+        result[row] = Math.Max(Math.Min(SVM.Prediction.Predict(model, scaledProblem.X[row]), UpperPredictionLimit), LowerPredictionLimit);
       }
       return result;
@@ -70 +74 @@
 
     public override IView CreateView() {
-      return svmModel.CreateView();
+      return new PredictorView(this);
     }
 

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/PredictorBuilder.cs

@@ -37 +37 @@
       AddVariableInfo(new VariableInfo("TargetVariable", "The target variable", typeof(StringData), VariableKind.In));
       AddVariableInfo(new VariableInfo("InputVariables", "The input variable names", typeof(StringData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("TrainingSamplesStart", "Start index of the training set", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("TrainingSamplesEnd", "End index of the training set", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("PunishmentFactor", "The punishment factor limits the range of predicted values", typeof(DoubleData), VariableKind.In));
       AddVariableInfo(new VariableInfo("Predictor", "The predictor can be used to generate estimated values", typeof(IPredictor), VariableKind.New));
     }
@@ -48 +51 @@
       SVMModel model = GetVariableValue<SVMModel>("SVMModel", scope, true);
       int targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
+      int start = GetVariableValue<IntData>("TrainingSamplesStart", scope, true).Data;
+      int end = GetVariableValue<IntData>("TrainingSamplesEnd", scope, true).Data;
+      double punishmentFactor = GetVariableValue<DoubleData>("PunishmentFactor", scope, true).Data;
+
       string targetVariableName = ds.GetVariableName(targetVariable);
       ItemList inputVariables = GetVariableValue<ItemList>("InputVariables", scope, true);
@@ -53 +60 @@
       for (int i = 0; i < ds.Columns; i++) variableNames[ds.GetVariableName(i)] = i;
 
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("Predictor"), new Predictor(model, targetVariableName, variableNames)));
+      double mean = ds.GetMean(targetVariable, start, end);
+      double range = ds.GetRange(targetVariable, start, end);
+
+      Predictor predictor = new Predictor(model, targetVariableName, variableNames);
+      predictor.LowerPredictionLimit = mean - punishmentFactor * range;
+      predictor.UpperPredictionLimit = mean + punishmentFactor * range;
+      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("Predictor"), predictor));
       return null;
     }

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SVMModelView.cs

@@ -33 +33 @@
   public partial class SVMModelView : ViewBase {
     private SVMModel model;
-    
+    public SVMModelView() : base() {
+      InitializeComponent();
+    }    
     public SVMModelView(SVMModel model) : base() {
       InitializeComponent();
       this.model = model;
-      model.Changed += (sender, args) => UpdateControls();
+      model.Changed += (sender, args) => Refresh();
 
-      UpdateControls();
-    }
-
-    protected override void UpdateControls() {
-      base.UpdateControls();
-      numberOfSupportVectors.Text = model.Model.SupportVectorCount.ToString();
-      rho.Text = model.Model.Rho[0].ToString();
-      svmType.Text = model.Model.Parameter.SvmType.ToString();
-      kernelType.Text = model.Model.Parameter.KernelType.ToString();
-      gamma.Text = model.Model.Parameter.Gamma.ToString();
+      numberOfSupportVectors.DataBindings.Add(new Binding("Text", model.Model, "SupportVectorCount"));
+      rho.DataBindings.Add(new Binding("Text", model.Model, "Rho"));
+      svmType.DataBindings.Add(new Binding("Text", model.Model.Parameter, "SvmType"));
+      kernelType.DataBindings.Add(new Binding("Text", model.Model.Parameter, "KernelType"));
+      gamma.DataBindings.Add(new Binding("Text", model.Model.Parameter, "Gamma"));
     }
   }

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs

@@ -394 +394 @@
       injector.AddVariable(new HeuristicLab.Core.Variable("KernelType", new StringData("RBF")));
       injector.AddVariable(new HeuristicLab.Core.Variable("Type", new StringData("NU_SVR")));
+      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
 
       return injector;