Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
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/HeuristicLab.GP.StructureIdentification/3.3
Files:
10 edited

Legend:

Unmodified
Added
Removed

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

    r2319 r2328  
    3333using HeuristicLab.Random;
    3434using HeuristicLab.Selection;
     35using HeuristicLab.Operators.Programmable;
    3536
    3637namespace HeuristicLab.GP.StructureIdentification {
    … …  
    7576        if (!engine.Terminated) throw new InvalidOperationException("The algorithm is still running. Wait until the algorithm is terminated to retrieve the result.");
    7677        if (model == null) {
    77           IScope bestModelScope = engine.GlobalScope.GetVariableValue<IScope>("BestValidationSolution", false);
     78          IScope bestModelScope = engine.GlobalScope.SubScopes[0];
    7879          model = CreateGPModel(bestModelScope);
    7980        }
    … …  
    140141
    141142      IOperator globalInjector = CreateGlobalInjector();
     143      IOperator treeEvaluatorInjector = new HL2TreeEvaluatorInjector();
    142144      IOperator initialization = CreateInitialization();
    143145      IOperator funLibInjector = CreateFunctionLibraryInjector();
    … …  
    163165      seq.AddSubOperator(problemInjector);
    164166      seq.AddSubOperator(globalInjector);
     167      seq.AddSubOperator(treeEvaluatorInjector);
    165168      seq.AddSubOperator(funLibInjector);
    166169      seq.AddSubOperator(initialization);
    167170      seq.AddSubOperator(mainLoop);
    168171      seq.AddSubOperator(cleanUp);
     172      seq.AddSubOperator(CreateModelAnalysisOperator());
    169173
    170174      initialization.AddSubOperator(treeCreator);
    … …  
    179183      this.algorithm = seq;
    180184      return algo;
     185    }
     186
     187    protected internal virtual IOperator CreateModelAnalysisOperator() {
     188      CombinedOperator op = new CombinedOperator();
     189      SequentialProcessor seq = new SequentialProcessor();
     190      SolutionExtractor extractor = new SolutionExtractor();
     191      extractor.GetVariableInfo("Scope").ActualName = "BestValidationSolution";
     192      SequentialSubScopesProcessor seqSubScopeProc = new SequentialSubScopesProcessor();
     193      SequentialProcessor solutionProc = new SequentialProcessor();
     194
     195      seq.AddSubOperator(extractor);
     196      seq.AddSubOperator(seqSubScopeProc);
     197      seqSubScopeProc.AddSubOperator(solutionProc);
     198
     199      HL2TreeEvaluatorInjector evaluatorInjector = new HL2TreeEvaluatorInjector();
     200      evaluatorInjector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
     201      evaluatorInjector.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     202
     203      #region MSE
     204      MeanSquaredErrorEvaluator trainingMseEvaluator = new MeanSquaredErrorEvaluator();
     205      trainingMseEvaluator.Name = "TrainingMseEvaluator";
     206      trainingMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     207      trainingMseEvaluator.GetVariableInfo("MSE").ActualName = "TrainingMSE";
     208      trainingMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     209      trainingMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
     210      MeanSquaredErrorEvaluator validationMseEvaluator = new MeanSquaredErrorEvaluator();
     211      validationMseEvaluator.Name = "ValidationMseEvaluator";
     212      validationMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     213      validationMseEvaluator.GetVariableInfo("MSE").ActualName = "ValidationMSE";
     214      validationMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     215      validationMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     216      MeanSquaredErrorEvaluator testMseEvaluator = new MeanSquaredErrorEvaluator();
     217      testMseEvaluator.Name = "TestMeanSquaredErrorEvaluator";
     218      testMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     219      testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestMSE";
     220      testMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     221      testMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     222      #endregion
     223      #region MAPE
     224      MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
     225      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
     226      trainingMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     227      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
     228      trainingMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
     229      trainingMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
     230      MeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
     231      validationMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     232      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
     233      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
     234      validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     235      validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     236      MeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
     237      testMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     238      testMapeEvaluator.Name = "TestMapeEvaluator";
     239      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
     240      testMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     241      testMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     242      #endregion
     243      #region MAPRE
     244      MeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
     245      trainingMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     246      trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
     247      trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TrainingMAPRE";
     248      trainingMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
     249      trainingMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
     250      MeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
     251      validationMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     252      validationMapreEvaluator.Name = "ValidationMapreEvaluator";
     253      validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "ValidationMAPRE";
     254      validationMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     255      validationMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     256      MeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
     257      testMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     258      testMapreEvaluator.Name = "TestMapreEvaluator";
     259      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
     260      testMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     261      testMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     262      #endregion MAPRE
     263      #region R2
     264      CoefficientOfDeterminationEvaluator trainingR2Evaluator = new CoefficientOfDeterminationEvaluator();
     265      trainingR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     266      trainingR2Evaluator.Name = "TrainingR2Evaluator";
     267      trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
     268      trainingR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
     269      trainingR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
     270      CoefficientOfDeterminationEvaluator validationR2Evaluator = new CoefficientOfDeterminationEvaluator();
     271      validationR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     272      validationR2Evaluator.Name = "ValidationR2Evaluator";
     273      validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
     274      validationR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     275      validationR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     276      CoefficientOfDeterminationEvaluator testR2Evaluator = new CoefficientOfDeterminationEvaluator();
     277      testR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     278      testR2Evaluator.Name = "TestR2Evaluator";
     279      testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
     280      testR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     281      testR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     282      #endregion
     283      #region VAF
     284      VarianceAccountedForEvaluator trainingVAFEvaluator = new VarianceAccountedForEvaluator();
     285      trainingVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     286      trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
     287      trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = "TrainingVAF";
     288      trainingVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
     289      trainingVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
     290      VarianceAccountedForEvaluator validationVAFEvaluator = new VarianceAccountedForEvaluator();
     291      validationVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     292      validationVAFEvaluator.Name = "ValidationVAFEvaluator";
     293      validationVAFEvaluator.GetVariableInfo("VAF").ActualName = "ValidationVAF";
     294      validationVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     295      validationVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     296      VarianceAccountedForEvaluator testVAFEvaluator = new VarianceAccountedForEvaluator();
     297      testVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     298      testVAFEvaluator.Name = "TestVAFEvaluator";
     299      testVAFEvaluator.GetVariableInfo("VAF").ActualName = "TestVAF";
     300      testVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     301      testVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     302      #endregion
     303
     304      solutionProc.AddSubOperator(evaluatorInjector);
     305      solutionProc.AddSubOperator(trainingMseEvaluator);
     306      solutionProc.AddSubOperator(validationMseEvaluator);
     307      solutionProc.AddSubOperator(testMseEvaluator);
     308      solutionProc.AddSubOperator(trainingMapeEvaluator);
     309      solutionProc.AddSubOperator(validationMapeEvaluator);
     310      solutionProc.AddSubOperator(testMapeEvaluator);
     311      solutionProc.AddSubOperator(trainingMapreEvaluator);
     312      solutionProc.AddSubOperator(validationMapreEvaluator);
     313      solutionProc.AddSubOperator(testMapreEvaluator);
     314      solutionProc.AddSubOperator(trainingR2Evaluator);
     315      solutionProc.AddSubOperator(validationR2Evaluator);
     316      solutionProc.AddSubOperator(testR2Evaluator);
     317      solutionProc.AddSubOperator(trainingVAFEvaluator);
     318      solutionProc.AddSubOperator(validationVAFEvaluator);
     319      solutionProc.AddSubOperator(testVAFEvaluator);
     320
     321      #region variable impacts
     322      // calculate and set variable impacts
     323      VariableNamesExtractor namesExtractor = new VariableNamesExtractor();
     324      namesExtractor.GetVariableInfo("VariableNames").ActualName = "InputVariableNames";
     325      PredictorBuilder predictorBuilder = new PredictorBuilder();
     326      predictorBuilder.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     327      predictorBuilder.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
     328
     329      VariableEvaluationImpactCalculator evaluationImpactCalculator = new VariableEvaluationImpactCalculator();
     330      evaluationImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
     331      evaluationImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
     332      VariableQualityImpactCalculator qualityImpactCalculator = new VariableQualityImpactCalculator();
     333      qualityImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
     334      qualityImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
     335
     336      solutionProc.AddSubOperator(namesExtractor);
     337      solutionProc.AddSubOperator(predictorBuilder);
     338      solutionProc.AddSubOperator(evaluationImpactCalculator);
     339      solutionProc.AddSubOperator(qualityImpactCalculator);
     340      #endregion
     341
     342      op.OperatorGraph.AddOperator(seq);
     343      op.OperatorGraph.InitialOperator = seq;
     344      return op;
    181345    }
    182346
    … …  
    207371      injector.AddVariable(new HeuristicLab.Core.Variable("Parents", new IntData()));
    208372      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
    209       injector.AddVariable(new HeuristicLab.Core.Variable("TreeEvaluator", new HL2TreeEvaluator()));
     373      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(10.0)));
    210374      return injector;
    211375    }
    … …  
    312476    protected internal virtual IOperator CreateBestSolutionProcessor() {
    313477      SequentialProcessor seq = new SequentialProcessor();
    314       // calculate and set variable impacts
    315       VariableNamesExtractor namesExtractor = new VariableNamesExtractor();
    316       namesExtractor.GetVariableInfo("VariableNames").ActualName = "InputVariableNames";
    317       PredictorBuilder predictorBuilder = new PredictorBuilder();
    318 
    319       VariableEvaluationImpactCalculator evaluationImpactCalculator = new VariableEvaluationImpactCalculator();
    320       evaluationImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
    321       evaluationImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
    322       VariableQualityImpactCalculator qualityImpactCalculator = new VariableQualityImpactCalculator();
    323       qualityImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
    324       qualityImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
    325 
    326       seq.AddSubOperator(namesExtractor);
    327       seq.AddSubOperator(predictorBuilder);
    328       seq.AddSubOperator(evaluationImpactCalculator);
    329       seq.AddSubOperator(qualityImpactCalculator);
     478      ProgrammableOperator progOperator = new ProgrammableOperator();
     479      progOperator.RemoveVariableInfo("Result");
     480      progOperator.AddVariableInfo(new HeuristicLab.Core.VariableInfo("EvaluatedSolutions", "", typeof(IntData), VariableKind.In));
     481      progOperator.Code = @"
     482int evalSolutions = EvaluatedSolutions.Data;
     483scope.AddVariable(new Variable(""EvaluatedSolutions"", new IntData(evalSolutions)));
     484";
     485      seq.AddSubOperator(progOperator);
    330486      return seq;
    331487    }
    … …  
    439595      model.TestSamplesEnd = bestModelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
    440596
    441       model.TrainingMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("Quality", false).Data;
    442       model.ValidationMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("ValidationQuality", false).Data;
     597      model.TrainingMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TrainingMSE", false).Data;
     598      model.ValidationMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("ValidationMSE", false).Data;
     599      model.TestMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TestMSE", false).Data;
     600      model.TrainingCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data;
     601      model.ValidationCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data;
     602      model.TestCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TestR2", false).Data;
     603      model.TrainingMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data;
     604      model.ValidationMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data;
     605      model.TestMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data;
     606      model.TrainingMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data;
     607      model.ValidationMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data;
     608      model.TestMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data;
     609      model.TrainingVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data;
     610      model.ValidationVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data;
     611      model.TestVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TestVAF", false).Data;
    443612
    444613      ItemList evaluationImpacts = bestModelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
    … …  
    456625        model.AddInputVariable(variableName);
    457626      }
    458       Engine.GlobalScope.RemoveSubScope(bestModelScope);
     627
    459628      return model;
    460629    }

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

    r2285 r2328  
    3333  public abstract class TreeEvaluatorBase : ItemBase, ITreeEvaluator {
    3434    protected const double EPSILON = 1.0e-7;
    35     protected double maxValue = double.MaxValue;
    36     protected double minValue = double.MinValue;
    37     private double punishmentFactor = 10.0; // we should provide a view for treeevaluators that allows to change this value
    3835
    3936    protected class Instr {
    … …  
    5047    protected int sampleIndex;
    5148
     49    public double UpperEvaluationLimit { get; set; }
     50    public double LowerEvaluationLimit { get; set; }
     51
     52    public TreeEvaluatorBase() // for persistence
     53      : this(double.MinValue, double.MaxValue) {
     54    }
     55
     56    public TreeEvaluatorBase(double minEstimatedValue, double maxEstimatedValue)
     57      : base() {
     58      UpperEvaluationLimit = maxEstimatedValue;
     59      LowerEvaluationLimit = minEstimatedValue;
     60    }
     61
    5262    public void PrepareForEvaluation(Dataset dataset, IFunctionTree functionTree) {
    5363      this.dataset = dataset;
    … …  
    5767        codeArr[i++] = TranslateToInstr(tree);
    5868      }
    59     }
    60 
    61     public void PrepareForEvaluation(Dataset dataset, int targetVariable, int start, int end, IFunctionTree functionTree) {
    62       // calculate upper and lower bounds for the estimated value (mean +/- punishmentFactor * range)
    63       double mean = dataset.GetMean(targetVariable, start, end);
    64       double range = dataset.GetRange(targetVariable, start, end);
    65       maxValue = mean + punishmentFactor * range;
    66       minValue = mean - punishmentFactor * range;
    67       PrepareForEvaluation(dataset, functionTree);
    6869    }
    6970
    … …  
    106107      this.sampleIndex = sampleIndex;
    107108
    108       double estimated = EvaluateBakedCode();
    109       if (double.IsNaN(estimated) || double.IsInfinity(estimated)) estimated = maxValue;
    110       else if (estimated < minValue) estimated = minValue;
    111       else if (estimated > maxValue) estimated = maxValue;
     109      double estimated = Math.Min(Math.Max(EvaluateBakedCode(), LowerEvaluationLimit), UpperEvaluationLimit);
     110      if (double.IsNaN(estimated)) estimated = UpperEvaluationLimit;
    112111      return estimated;
    113112    }
    … …  
    126125    public override object Clone(IDictionary<Guid, object> clonedObjects) {
    127126      TreeEvaluatorBase clone = (TreeEvaluatorBase)base.Clone(clonedObjects);
    128       clone.maxValue = maxValue;
    129       clone.minValue = minValue;
    130       clone.punishmentFactor = punishmentFactor;
     127      clone.UpperEvaluationLimit = UpperEvaluationLimit;
     128      clone.LowerEvaluationLimit = LowerEvaluationLimit;
    131129      return clone;
    132130    }
    … …  
    134132    public override System.Xml.XmlNode GetXmlNode(string name, System.Xml.XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
    135133      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
    136       XmlAttribute maxValueAttribute = document.CreateAttribute("MaxPredictionValue");
    137       XmlAttribute minValueAttribute = document.CreateAttribute("MinPredictionValue");
    138       XmlAttribute punishmentFactorAttribute = document.CreateAttribute("PunishmentFactor");
    139       maxValueAttribute.Value = XmlConvert.ToString(maxValue);
    140       minValueAttribute.Value = XmlConvert.ToString(minValue);
    141       punishmentFactorAttribute.Value = XmlConvert.ToString(punishmentFactor);
    142 
    143       node.Attributes.Append(punishmentFactorAttribute);
     134      XmlAttribute maxValueAttribute = document.CreateAttribute("UpperEvaluationLimit");
     135      XmlAttribute minValueAttribute = document.CreateAttribute("LowerEvaluationLimit");
     136      maxValueAttribute.Value = XmlConvert.ToString(UpperEvaluationLimit);
     137      minValueAttribute.Value = XmlConvert.ToString(LowerEvaluationLimit);
    144138      node.Attributes.Append(minValueAttribute);
    145139      node.Attributes.Append(maxValueAttribute);
    … …  
    149143    public override void Populate(System.Xml.XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
    150144      base.Populate(node, restoredObjects);
    151       minValue = XmlConvert.ToDouble(node.Attributes["MinPredictionValue"].Value);
    152       maxValue = XmlConvert.ToDouble(node.Attributes["MaxPredictionValue"].Value);
    153       punishmentFactor = XmlConvert.ToDouble(node.Attributes["PunishmentFactor"].Value);
     145      LowerEvaluationLimit = XmlConvert.ToDouble(node.Attributes["LowerEvaluationLimit"].Value);
     146      UpperEvaluationLimit = XmlConvert.ToDouble(node.Attributes["UpperEvaluationLimit"].Value);
    154147    }
    155148  }

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

    r2285 r2328  
    3434      AddVariableInfo(new VariableInfo("TargetVariable", "Index of the column of the dataset that holds the target variable", typeof(IntData), VariableKind.In));
    3535      AddVariableInfo(new VariableInfo("TotalEvaluatedNodes", "Number of evaluated nodes", typeof(DoubleData), VariableKind.In | VariableKind.Out));
    36       AddVariableInfo(new VariableInfo("TrainingSamplesStart", "Start index of training samples in dataset", typeof(IntData), VariableKind.In));
    37       AddVariableInfo(new VariableInfo("TrainingSamplesEnd", "End index of training samples in dataset", typeof(IntData), VariableKind.In));
    3836      AddVariableInfo(new VariableInfo("SamplesStart", "Start index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
    3937      AddVariableInfo(new VariableInfo("SamplesEnd", "End index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
    … …  
    4745      IGeneticProgrammingModel gpModel = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", scope, true);
    4846      double totalEvaluatedNodes = scope.GetVariableValue<DoubleData>("TotalEvaluatedNodes", true).Data;
    49       int trainingStart = GetVariableValue<IntData>("TrainingSamplesStart", scope, true).Data;
    50       int trainingEnd = GetVariableValue<IntData>("TrainingSamplesEnd", scope, true).Data;
    5147      int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
    5248      int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
    5349      bool useEstimatedValues = GetVariableValue<BoolData>("UseEstimatedTargetValue", scope, true).Data;
    5450      ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
    55       evaluator.PrepareForEvaluation(dataset, targetVariable, trainingStart, trainingEnd, gpModel.FunctionTree);
     51      evaluator.PrepareForEvaluation(dataset, gpModel.FunctionTree);
    5652
    5753      double[] backupValues = null;

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

    r2222 r2328  
    2828  /// </summary>
    2929  public class HL2TreeEvaluator : TreeEvaluatorBase {
     30    public HL2TreeEvaluator() : base() { } // for persistence
     31    public HL2TreeEvaluator(double minValue, double maxValue) : base(minValue, maxValue) { }
    3032
    3133    protected override double EvaluateBakedCode() {

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

    r2324 r2328  
    3030  /// </summary>
    3131  public class HL3TreeEvaluator : TreeEvaluatorBase {
     32    public HL3TreeEvaluator() : base() { } // for persistence
     33    public HL3TreeEvaluator(double minValue, double maxValue) : base(minValue, maxValue) { }
     34
    3235    protected override double EvaluateBakedCode() {
    3336      Instr currInstr = codeArr[PC++];

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

    r2324 r2328  
    8585    <Compile Include="BaseClasses\FunctionTreeBase.cs" />
    8686    <Compile Include="BaseClasses\TreeEvaluatorBase.cs" />
     87    <Compile Include="HL3TreeEvaluatorInjector.cs" />
     88    <Compile Include="HL2TreeEvaluatorInjector.cs" />
    8789    <Compile Include="PredictorBuilder.cs" />
    8890    <Compile Include="Predictor.cs" />
    8991    <Compile Include="Evaluators\SimpleGPEvaluatorBase.cs" />
    9092    <Compile Include="HL3TreeEvaluator.cs" />
     93    <Compile Include="PredictorView.cs">
     94      <SubType>UserControl</SubType>
     95    </Compile>
     96    <Compile Include="PredictorView.Designer.cs">
     97      <DependentUpon>PredictorView.cs</DependentUpon>
     98    </Compile>
    9199    <Compile Include="Symbols\Addition.cs" />
    92100    <Compile Include="Symbols\And.cs" />
    … …  
    222230      <DependentUpon>OffSpringSelectionGpEditor.cs</DependentUpon>
    223231    </EmbeddedResource>
     232    <EmbeddedResource Include="PredictorView.resx">
     233      <DependentUpon>PredictorView.cs</DependentUpon>
     234    </EmbeddedResource>
    224235    <EmbeddedResource Include="StandardGpEditor.resx">
    225236      <DependentUpon>StandardGpEditor.cs</DependentUpon>

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

    r2285 r2328  
    2626namespace HeuristicLab.GP.StructureIdentification {
    2727  public interface ITreeEvaluator : IItem {
    28     void PrepareForEvaluation(Dataset dataset, int targetVariable, int start, int end, IFunctionTree functionTree);
     28    double LowerEvaluationLimit { get; set; }
     29    double UpperEvaluationLimit { get; set; }
    2930    void PrepareForEvaluation(Dataset dataset, IFunctionTree functionTree);
    3031    double Evaluate(int sampleIndex);

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

    r2317 r2328  
    3131
    3232namespace HeuristicLab.GP.StructureIdentification {
    33   public class Predictor : ItemBase, IPredictor {
     33  public class Predictor : PredictorBase {
    3434    private ITreeEvaluator treeEvaluator;
    35    
    36 
    37     public Predictor() : base() { } // for persistence
    38     public Predictor(ITreeEvaluator evaluator, IGeneticProgrammingModel tree)
    39       : base() {
    40       this.treeEvaluator = evaluator;
    41       this.functionTree = tree;
    42     }
    4335
    4436    private IGeneticProgrammingModel functionTree;
    … …  
    4638      get { return functionTree; }
    4739    }
     40    public Predictor() : base() { } // for persistence
     41    public Predictor(ITreeEvaluator evaluator, IGeneticProgrammingModel tree, double lowerPredictionLimit, double upperPredictionLimit)
     42      : base(lowerPredictionLimit, upperPredictionLimit) {
     43      this.treeEvaluator = evaluator;
     44      this.functionTree = tree;
     45    }
    4846
    49     public double[] Predict(Dataset input, int start, int end) {
     47    public override double[] Predict(Dataset input, int start, int end) {
     48      treeEvaluator.UpperEvaluationLimit = UpperPredictionLimit;
     49      treeEvaluator.LowerEvaluationLimit = LowerPredictionLimit;
     50
    5051      if (start < 0 || end <= start) throw new ArgumentException("start must be larger than zero and strictly smaller than end");
    5152      if (end > input.Rows) throw new ArgumentOutOfRangeException("number of rows in input is smaller then end");
    … …  
    5960
    6061    public override IView CreateView() {
    61       return functionTree.CreateView();
     62      return new PredictorView(this);
    6263    }
    6364

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

    r2319 r2328  
    2828using HeuristicLab.GP.Interfaces;
    2929using HeuristicLab.Modeling;
     30using HeuristicLab.DataAnalysis;
    3031
    3132namespace HeuristicLab.GP.StructureIdentification {
    … …  
    3536      AddVariableInfo(new VariableInfo("FunctionTree", "The function tree", typeof(IGeneticProgrammingModel), VariableKind.In));
    3637      AddVariableInfo(new VariableInfo("TreeEvaluator", "The tree evaluator used to evaluate the model", typeof(ITreeEvaluator), VariableKind.In));
     38      AddVariableInfo(new VariableInfo("PunishmentFactor", "The punishment factor limits the estimated values to a certain range", typeof(DoubleData), VariableKind.In));
     39      AddVariableInfo(new VariableInfo("Dataset", "The dataset", typeof(Dataset), VariableKind.In));
     40      AddVariableInfo(new VariableInfo("TrainingSamplesStart", "Start index of training set", typeof(DoubleData), VariableKind.In));
     41      AddVariableInfo(new VariableInfo("TrainingSamplesEnd", "End index of training set", typeof(DoubleData), VariableKind.In));
     42      AddVariableInfo(new VariableInfo("TargetVariable", "Index of the target variable", typeof(IntData), VariableKind.In));
    3743      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));
    3844    }
    … …  
    4450    public override IOperation Apply(IScope scope) {
    4551      IGeneticProgrammingModel model = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", scope, true);
    46       ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
    47       scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("Predictor"), new Predictor(evaluator, model)));
     52      ITreeEvaluator evaluator = (ITreeEvaluator)GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true).Clone();
     53      double punishmentFactor = GetVariableValue<DoubleData>("PunishmentFactor", scope, true).Data;
     54      Dataset dataset = GetVariableValue<Dataset>("Dataset", scope, true);
     55      int start = GetVariableValue<IntData>("TrainingSamplesStart", scope, true).Data;
     56      int end = GetVariableValue<IntData>("TrainingSamplesEnd", scope, true).Data;
     57      int targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
     58      double mean = dataset.GetMean(targetVariable, start, end);
     59      double range = dataset.GetRange(targetVariable, start, end);
     60      double minEstimatedValue = mean - punishmentFactor * range;
     61      double maxEstimatedValue = mean + punishmentFactor * range;
     62      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("Predictor"), new Predictor(evaluator, model, minEstimatedValue, maxEstimatedValue)));
    4863      return null;
    4964    }

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

    r2319 r2328  
    115115
    116116    protected internal override IOperator CreateProblemInjector() {
    117       SequentialProcessor seq = new SequentialProcessor();     
     117      SequentialProcessor seq = new SequentialProcessor();
    118118      var probInject = new ProblemInjector();
    119119      probInject.GetVariableInfo("MaxNumberOfTrainingSamples").Local = true;
    … …  
    201201      manipulator.OperatorGraph.InitialOperator = multibranch;
    202202      return manipulator;
    203     }
    204 
    205     protected internal override IOperator CreateBestSolutionProcessor() {     
    206       SequentialProcessor bestSolutionProcessor = new SequentialProcessor();
    207       bestSolutionProcessor.AddSubOperator(base.CreateBestSolutionProcessor());
    208 
    209       #region MSE
    210       MeanSquaredErrorEvaluator testMseEvaluator = new MeanSquaredErrorEvaluator();
    211       testMseEvaluator.Name = "TestMeanSquaredErrorEvaluator";
    212       testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestQuality";
    213       testMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
    214       testMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
    215       #endregion
    216       #region MAPE
    217       MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
    218       trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
    219       trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
    220       trainingMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
    221       trainingMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
    222       MeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
    223       validationMapeEvaluator.Name = "ValidationMapeEvaluator";
    224       validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
    225       validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
    226       validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
    227       MeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
    228       testMapeEvaluator.Name = "TestMapeEvaluator";
    229       testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
    230       testMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
    231       testMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
    232       #endregion
    233       #region MAPRE
    234       MeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
    235       trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
    236       trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TrainingMAPRE";
    237       trainingMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
    238       trainingMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
    239       MeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
    240       validationMapreEvaluator.Name = "ValidationMapreEvaluator";
    241       validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "ValidationMAPRE";
    242       validationMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
    243       validationMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
    244       MeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
    245       testMapreEvaluator.Name = "TestMapreEvaluator";
    246       testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
    247       testMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
    248       testMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
    249       #endregion MAPRE
    250       #region R2
    251       CoefficientOfDeterminationEvaluator trainingR2Evaluator = new CoefficientOfDeterminationEvaluator();
    252       trainingR2Evaluator.Name = "TrainingR2Evaluator";
    253       trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
    254       trainingR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
    255       trainingR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
    256       CoefficientOfDeterminationEvaluator validationR2Evaluator = new CoefficientOfDeterminationEvaluator();
    257       validationR2Evaluator.Name = "ValidationR2Evaluator";
    258       validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
    259       validationR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
    260       validationR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
    261       CoefficientOfDeterminationEvaluator testR2Evaluator = new CoefficientOfDeterminationEvaluator();
    262       testR2Evaluator.Name = "TestR2Evaluator";
    263       testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
    264       testR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
    265       testR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
    266       #endregion
    267       #region VAF
    268       VarianceAccountedForEvaluator trainingVAFEvaluator = new VarianceAccountedForEvaluator();
    269       trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
    270       trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = "TrainingVAF";
    271       trainingVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
    272       trainingVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
    273       VarianceAccountedForEvaluator validationVAFEvaluator = new VarianceAccountedForEvaluator();
    274       validationVAFEvaluator.Name = "ValidationVAFEvaluator";
    275       validationVAFEvaluator.GetVariableInfo("VAF").ActualName = "ValidationVAF";
    276       validationVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
    277       validationVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
    278       VarianceAccountedForEvaluator testVAFEvaluator = new VarianceAccountedForEvaluator();
    279       testVAFEvaluator.Name = "TestVAFEvaluator";
    280       testVAFEvaluator.GetVariableInfo("VAF").ActualName = "TestVAF";
    281       testVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
    282       testVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
    283       #endregion
    284       ProgrammableOperator progOperator = new ProgrammableOperator();
    285       progOperator.RemoveVariableInfo("Result");
    286       progOperator.AddVariableInfo(new HeuristicLab.Core.VariableInfo("EvaluatedSolutions", "", typeof(IntData), VariableKind.In));
    287       progOperator.Code = @"
    288 int evalSolutions = EvaluatedSolutions.Data;
    289 scope.AddVariable(new Variable(""EvaluatedSolutions"", new IntData(evalSolutions)));
    290 ";
    291       bestSolutionProcessor.AddSubOperator(testMseEvaluator);
    292       bestSolutionProcessor.AddSubOperator(trainingMapeEvaluator);
    293       bestSolutionProcessor.AddSubOperator(validationMapeEvaluator);
    294       bestSolutionProcessor.AddSubOperator(testMapeEvaluator);
    295       bestSolutionProcessor.AddSubOperator(trainingMapreEvaluator);
    296       bestSolutionProcessor.AddSubOperator(validationMapreEvaluator);
    297       bestSolutionProcessor.AddSubOperator(testMapreEvaluator);
    298       bestSolutionProcessor.AddSubOperator(trainingR2Evaluator);
    299       bestSolutionProcessor.AddSubOperator(validationR2Evaluator);
    300       bestSolutionProcessor.AddSubOperator(testR2Evaluator);
    301       bestSolutionProcessor.AddSubOperator(trainingVAFEvaluator);
    302       bestSolutionProcessor.AddSubOperator(validationVAFEvaluator);
    303       bestSolutionProcessor.AddSubOperator(testVAFEvaluator);
    304       bestSolutionProcessor.AddSubOperator(progOperator);
    305       return bestSolutionProcessor;
    306203    }
    307204
    … …  
    338235    }
    339236
    340     protected internal override IAnalyzerModel CreateGPModel(IScope bestModelScope) {
    341       IAnalyzerModel model = base.CreateGPModel(bestModelScope);
    342       model.TestMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TestQuality", false).Data;
    343       model.TrainingCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data;
    344       model.ValidationCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data;
    345       model.TestCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TestR2", false).Data;
    346       model.TrainingMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data;
    347       model.ValidationMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data;
    348       model.TestMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data;
    349       model.TrainingMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data;
    350       model.ValidationMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data;
    351       model.TestMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data;
    352       model.TrainingVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data;
    353       model.ValidationVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data;
    354       model.TestVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TestVAF", false).Data;
    355 
    356       return model;
    357     }
    358 
    359237    public virtual IEditor CreateEditor() {
    360238      return new StandardGpEditor(this);
Note: See TracChangeset for help on using the changeset viewer.