Changeset 1275


Ignore:
Timestamp:
03/06/09 14:41:27 (10 years ago)
Author:
gkronber
Message:

Added more result values to be stored into the CEDMA db for each experiment. #419 (Refactor CEDMA plugins)

Location:
branches/CEDMA-Refactoring-Ticket419
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.DB.Interfaces/Ontology.cs

    r1130 r1275  
    116116      get { return new Entity(CedmaNameSpace + "ValidationMeanSquaredError"); }
    117117    }
     118    public static Entity TestMeanSquaredError {
     119      get { return new Entity(CedmaNameSpace + "TestMeanSquaredError"); }
     120    }
    118121    public static Entity TrainingMeanAbsolutePercentageError {
    119122      get { return new Entity(CedmaNameSpace + "TrainingMeanAbsolutePercentageError"); }
     
    121124    public static Entity ValidationMeanAbsolutePercentageError {
    122125      get { return new Entity(CedmaNameSpace + "ValidationMeanAbsolutePercentageError"); }
     126    }
     127    public static Entity TestMeanAbsolutePercentageError {
     128      get { return new Entity(CedmaNameSpace + "TestMeanAbsolutePercentageError"); }
     129    }
     130    public static Entity TrainingMeanAbsolutePercentageOfRangeError {
     131      get { return new Entity(CedmaNameSpace + "TrainingMeanAbsolutePercentageOfRangeError"); }
     132    }
     133    public static Entity ValidationMeanAbsolutePercentageOfRangeError {
     134      get { return new Entity(CedmaNameSpace + "ValidationMeanAbsolutePercentageOfRangeError"); }
     135    }
     136    public static Entity TestMeanAbsolutePercentageOfRangeError {
     137      get { return new Entity(CedmaNameSpace + "TestMeanAbsolutePercentageOfRangeError"); }
     138    }
     139    public static Entity TrainingCoefficientOfDetermination {
     140      get { return new Entity(CedmaNameSpace + "TrainingCoefficientOfDetermination"); }
     141    }
     142    public static Entity ValidationCoefficientOfDetermination {
     143      get { return new Entity(CedmaNameSpace + "ValidationCoefficientOfDetermination"); }
     144    }
     145    public static Entity TestCoefficientOfDetermination {
     146      get { return new Entity(CedmaNameSpace + "TestCoefficientOfDetermination"); }
     147    }
     148    public static Entity TrainingAccuracy {
     149      get { return new Entity(CedmaNameSpace + "TrainingAccuracy"); }
     150    }
     151    public static Entity ValidationAccuracy {
     152      get { return new Entity(CedmaNameSpace + "ValidationAccuracy"); }
     153    }
     154    public static Entity TestAccuracy {
     155      get { return new Entity(CedmaNameSpace + "TestAccuracy"); }
     156    }
     157    public static Entity TrainingTheilsInequalityCoefficient {
     158      get { return new Entity(CedmaNameSpace + "TrainingTheilsInequalityCoefficient"); }
     159    }
     160    public static Entity ValidationTheilsInequalityCoefficient {
     161      get { return new Entity(CedmaNameSpace + "ValidationTheilsInequalityCoefficient"); }
     162    }
     163    public static Entity TestTheilsInequalityCoefficient {
     164      get { return new Entity(CedmaNameSpace + "TestTheilsInequalityCoefficient"); }
    123165    }
    124166    public static Entity TreeSize {
     
    141183          new Statement(ValidationMeanSquaredError, PredicateInstanceOf, TypeOrdinalAttribute),
    142184          new Statement(ValidationMeanSquaredError, PredicateInstanceOf, TypeQualityAttribute),
     185          new Statement(TestMeanSquaredError, PredicateInstanceOf, TypeOrdinalAttribute),
     186          new Statement(TestMeanSquaredError, PredicateInstanceOf, TypeQualityAttribute),
    143187          new Statement(TrainingMeanAbsolutePercentageError, PredicateInstanceOf, TypeOrdinalAttribute),
    144188          new Statement(TrainingMeanAbsolutePercentageError, PredicateInstanceOf, TypeQualityAttribute),
    145189          new Statement(ValidationMeanAbsolutePercentageError, PredicateInstanceOf, TypeOrdinalAttribute),
    146190          new Statement(ValidationMeanAbsolutePercentageError, PredicateInstanceOf, TypeQualityAttribute),
     191          new Statement(TestMeanAbsolutePercentageError, PredicateInstanceOf, TypeOrdinalAttribute),
     192          new Statement(TestMeanAbsolutePercentageError, PredicateInstanceOf, TypeQualityAttribute),
     193          new Statement(TrainingMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeOrdinalAttribute),
     194          new Statement(TrainingMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeQualityAttribute),
     195          new Statement(ValidationMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeOrdinalAttribute),
     196          new Statement(ValidationMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeQualityAttribute),
     197          new Statement(TestMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeOrdinalAttribute),
     198          new Statement(TestMeanAbsolutePercentageOfRangeError, PredicateInstanceOf, TypeQualityAttribute),
     199          new Statement(TrainingCoefficientOfDetermination, PredicateInstanceOf, TypeOrdinalAttribute),
     200          new Statement(TrainingCoefficientOfDetermination, PredicateInstanceOf, TypeQualityAttribute),
     201          new Statement(ValidationCoefficientOfDetermination, PredicateInstanceOf, TypeOrdinalAttribute),
     202          new Statement(ValidationCoefficientOfDetermination, PredicateInstanceOf, TypeQualityAttribute),
     203          new Statement(TestCoefficientOfDetermination, PredicateInstanceOf, TypeOrdinalAttribute),
     204          new Statement(TestCoefficientOfDetermination, PredicateInstanceOf, TypeQualityAttribute),
     205          new Statement(TrainingAccuracy, PredicateInstanceOf, TypeOrdinalAttribute),
     206          new Statement(TrainingAccuracy, PredicateInstanceOf, TypeQualityAttribute),
     207          new Statement(ValidationAccuracy, PredicateInstanceOf, TypeOrdinalAttribute),
     208          new Statement(ValidationAccuracy, PredicateInstanceOf, TypeQualityAttribute),
     209          new Statement(TestAccuracy, PredicateInstanceOf, TypeOrdinalAttribute),
     210          new Statement(TestAccuracy, PredicateInstanceOf, TypeQualityAttribute),
     211          new Statement(TrainingTheilsInequalityCoefficient, PredicateInstanceOf, TypeOrdinalAttribute),
     212          new Statement(TrainingTheilsInequalityCoefficient, PredicateInstanceOf, TypeQualityAttribute),
     213          new Statement(ValidationTheilsInequalityCoefficient, PredicateInstanceOf, TypeOrdinalAttribute),
     214          new Statement(ValidationTheilsInequalityCoefficient, PredicateInstanceOf, TypeQualityAttribute),
     215          new Statement(TestTheilsInequalityCoefficient, PredicateInstanceOf, TypeOrdinalAttribute),
     216          new Statement(TestTheilsInequalityCoefficient, PredicateInstanceOf, TypeQualityAttribute),
     217
    147218          new Statement(TreeSize, PredicateInstanceOf, TypeOrdinalAttribute),
    148219          new Statement(TreeSize, PredicateInstanceOf, TypeComplexityAttribute),
     
    161232      get { return new Entity(null); }
    162233    }
    163 
    164234  }
    165235}
  • branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.Server/DispatcherBase.cs

    r1266 r1275  
    4949    };
    5050
     51    private static int MaxGenerations {
     52      get { return 3; }
     53    }
     54
     55    private static int MaxEvaluatedSolutions {
     56      get { return 3000; }
     57    }
     58
    5159    public DispatcherBase(IStore store) {
    5260      this.store = store;
     
    7078      DataSet dataSet = new DataSet(store, dataSetEntity);
    7179
    72       int targetVariable = SelectTargetVariable(dataSet, dataSet.Problem.AllowedInputVariables.ToArray());
     80      int targetVariable = SelectTargetVariable(dataSet, dataSet.Problem.AllowedTargetVariables.ToArray());
    7381      Algorithm selectedAlgorithm = SelectAlgorithm(dataSet, targetVariable, possibleAlgorithms[dataSet.Problem.LearningTask]);
    7482      string targetVariableName = dataSet.Problem.GetVariableName(targetVariable);
     
    92100        case Algorithm.StandardGpRegression: {
    93101            var algo = new HeuristicLab.GP.StructureIdentification.StandardGP();
    94             SetGpParameters(algo, complexity);
    95             SetProblemParameters(algo, problem, targetVariable);
    96             algo.MaxGenerations = 2;
     102            SetComplexityParameters(algo, complexity);
     103            SetProblemParameters(algo, problem, targetVariable);
     104            algo.PopulationSize = 10000;
     105            algo.MaxGenerations = MaxGenerations;
    97106            Execution exec = new Execution(algo.Engine);
    98107            exec.Description = "StandardGP - Complexity: " + complexity;
     
    101110        case Algorithm.OffspringGpRegression: {
    102111            var algo = new HeuristicLab.GP.StructureIdentification.OffspringSelectionGP();
    103             SetGpParameters(algo, complexity);
    104             SetProblemParameters(algo, problem, targetVariable);
    105             algo.MaxEvaluatedSolutions = 10000;
     112            SetComplexityParameters(algo, complexity);
     113            SetProblemParameters(algo, problem, targetVariable);
     114            algo.MaxEvaluatedSolutions = MaxEvaluatedSolutions;
    106115            Execution exec = new Execution(algo.Engine);
    107116            exec.Description = "OffspringGP - Complexity: " + complexity;
     
    110119        case Algorithm.StandardGpClassification: {
    111120            var algo = new HeuristicLab.GP.StructureIdentification.Classification.StandardGP();
    112             SetGpParameters(algo, complexity);
    113             SetProblemParameters(algo, problem, targetVariable);
    114             algo.MaxGenerations = 2;
     121            SetComplexityParameters(algo, complexity);
     122            SetProblemParameters(algo, problem, targetVariable);
     123            algo.PopulationSize = 10000;
     124            algo.MaxGenerations = MaxGenerations;
    115125            Execution exec = new Execution(algo.Engine);
    116126            exec.Description = "StandardGP - Complexity: " + complexity;
     
    119129        case Algorithm.OffspringGpClassification: {
    120130            var algo = new HeuristicLab.GP.StructureIdentification.Classification.OffspringSelectionGP();
    121             SetGpParameters(algo, complexity);
    122             SetProblemParameters(algo, problem, targetVariable);
    123             algo.MaxEvaluatedSolutions = 10000;
     131            SetComplexityParameters(algo, complexity);
     132            SetProblemParameters(algo, problem, targetVariable);
     133            algo.MaxEvaluatedSolutions = MaxEvaluatedSolutions;
    124134            Execution exec = new Execution(algo.Engine);
    125135            exec.Description = "OffspringGP - Complexity: " + complexity;
     
    128138        case Algorithm.StandardGpForecasting: {
    129139            var algo = new HeuristicLab.GP.StructureIdentification.TimeSeries.StandardGP();
    130             SetGpParameters(algo, complexity);
    131             SetProblemParameters(algo, problem, targetVariable);
    132             algo.MaxGenerations = 2;
     140            SetComplexityParameters(algo, complexity);
     141            SetProblemParameters(algo, problem, targetVariable);
     142            algo.PopulationSize = 10000;
     143            algo.MaxGenerations = MaxGenerations;
    133144            Execution exec = new Execution(algo.Engine);
    134145            exec.Description = "StandardGP - Complexity: " + complexity;
     
    137148        case Algorithm.OffspringGpForecasting: {
    138149            var algo = new HeuristicLab.GP.StructureIdentification.TimeSeries.OffspringSelectionGP();
    139             SetGpParameters(algo, complexity);
    140             SetProblemParameters(algo, problem, targetVariable);
    141             algo.MaxEvaluatedSolutions = 10000;
     150            SetComplexityParameters(algo, complexity);
     151            SetProblemParameters(algo, problem, targetVariable);
     152            algo.MaxEvaluatedSolutions = MaxEvaluatedSolutions;
    142153            Execution exec = new Execution(algo.Engine);
    143154            exec.Description = "OffspringGP - Complexity: " + complexity;
     
    150161    }
    151162
    152     private void SetGpParameters(AlgorithmBase algo, ModelComplexity complexity) {
    153       algo.SetSeedRandomly = true;
    154       algo.PopulationSize = 1000;
    155       algo.Elites = 1;
     163    private void SetComplexityParameters(AlgorithmBase algo, ModelComplexity complexity) {
    156164      switch (complexity) {
    157165        case ModelComplexity.Low: {
     
    196204
    197205    private IEnumerable<double> GetDifferentClassValues(HeuristicLab.DataAnalysis.Dataset dataset, int targetVariable) {
    198       throw new NotImplementedException();
     206      return Enumerable.Range(0, dataset.Rows).Select(x => dataset.GetValue(x, targetVariable)).Distinct();
    199207    }
    200208  }
  • branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.Server/Executer.cs

    r1217 r1275  
    133133      StoreModelAttribute(model, Ontology.TargetVariable, finishedExecution.TargetVariable);
    134134      Scope bestModelScope = finishedEngine.GlobalScope.GetVariableValue<Scope>("BestValidationSolution", false);
    135       StoreModelAttribute(model, Ontology.TrainingMeanSquaredError, bestModelScope.GetVariableValue<DoubleData>("Quality", false).Data);
    136       StoreModelAttribute(model, Ontology.ValidationMeanSquaredError, bestModelScope.GetVariableValue<DoubleData>("ValidationQuality", false).Data);
    137       StoreModelAttribute(model, Ontology.TrainingMeanAbsolutePercentageError, bestModelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data);
    138       StoreModelAttribute(model, Ontology.ValidationMeanAbsolutePercentageError, bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data);
    139       StoreModelAttribute(model, Ontology.TreeSize, bestModelScope.GetVariableValue<IntData>("TreeSize", false).Data);
    140       StoreModelAttribute(model, Ontology.TreeHeight, bestModelScope.GetVariableValue<IntData>("TreeHeight", false).Data);
    141       StoreModelAttribute(model, Ontology.EvaluatedSolutions, bestModelScope.GetVariableValue<IntData>("EvaluatedSolutions", false).Data);
     135      StoreModelVariable(model, Ontology.TrainingMeanSquaredError, bestModelScope, "Quality");
     136      StoreModelVariable(model, Ontology.ValidationMeanSquaredError, bestModelScope, "ValidationQuality");
     137      StoreModelVariable(model, Ontology.TestMeanSquaredError, bestModelScope, "TestQuality");
     138      StoreModelVariable(model, Ontology.TrainingMeanAbsolutePercentageError, bestModelScope, "TrainingMAPE");
     139      StoreModelVariable(model, Ontology.ValidationMeanAbsolutePercentageError, bestModelScope, "ValidationMAPE");
     140      StoreModelVariable(model, Ontology.TestMeanAbsolutePercentageError, bestModelScope, "TestMAPE");
     141      StoreModelVariable(model, Ontology.TrainingMeanAbsolutePercentageOfRangeError, bestModelScope, "TrainingMAPRE");
     142      StoreModelVariable(model, Ontology.ValidationMeanAbsolutePercentageOfRangeError, bestModelScope, "ValidationMAPRE");
     143      StoreModelVariable(model, Ontology.TestMeanAbsolutePercentageOfRangeError, bestModelScope, "TestMAPRE");
     144      StoreModelVariable(model, Ontology.TrainingCoefficientOfDetermination, bestModelScope, "TrainingR2");
     145      StoreModelVariable(model, Ontology.ValidationCoefficientOfDetermination, bestModelScope, "ValidationR2");
     146      StoreModelVariable(model, Ontology.TestCoefficientOfDetermination, bestModelScope, "TestR2");
     147      StoreModelVariable(model, Ontology.TrainingTheilsInequalityCoefficient, bestModelScope, "TrainingTheilInequalityCoefficient");
     148      StoreModelVariable(model, Ontology.ValidationTheilsInequalityCoefficient, bestModelScope, "ValidationTheilInequalityCoefficient");
     149      StoreModelVariable(model, Ontology.TestTheilsInequalityCoefficient, bestModelScope, "TestTheilInequalityCoefficient");
     150      StoreModelVariable(model, Ontology.TrainingAccuracy, bestModelScope, "TrainingAccuracy");
     151      StoreModelVariable(model, Ontology.ValidationAccuracy, bestModelScope, "ValidationAccuracy");
     152      StoreModelVariable(model, Ontology.TestAccuracy, bestModelScope, "TestAccuracy");
     153      StoreModelVariable(model, Ontology.TreeSize, bestModelScope, "TreeSize");
     154      StoreModelVariable(model, Ontology.TreeHeight, bestModelScope, "TreeHeight");
     155      StoreModelVariable(model, Ontology.EvaluatedSolutions, bestModelScope, "EvaluatedSolutions");
    142156
    143157      byte[] serializedModel = PersistenceManager.SaveToGZip(bestModelScope.GetVariableValue("FunctionTree", false));
    144158      store.Add(new Statement(model, Ontology.PredicateSerializedData, new Literal(Convert.ToBase64String(serializedModel))));
     159    }
     160
     161    private void StoreModelVariable(Entity model, Entity entity, Scope scope, string variableName) {
     162      if (scope.GetVariable(variableName) != null)
     163        StoreModelAttribute(model, entity, scope.GetVariableValue<ObjectData>(variableName, false).Data);
    145164    }
    146165
     
    154173        int i = 0;
    155174        foreach (Execution e in activeExecutions.Values) {
    156           retVal[i++] = "Target-Variable: "+e.TargetVariable+" "+e.Description;
     175          retVal[i++] = "Target-Variable: " + e.TargetVariable + " " + e.Description;
    157176        }
    158177        return retVal;
  • branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/AlgorithmBase.cs

    r1262 r1275  
    108108      engine.OperatorGraph.AddOperator(algo);
    109109      engine.OperatorGraph.InitialOperator = algo;
     110      SetSeedRandomly = true;
     111      Elites = 1;
     112      MutationRate = 0.15;
     113      PopulationSize = 1000;
     114      MaxTreeSize = 100;
     115      MaxTreeHeight = 10;
     116      Parents = 2000;
     117      PunishmentFactor = 10;
     118      UseEstimatedTargetValue = false;
    110119    }
    111120
  • branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/StandardGP.cs

    r1262 r1275  
    5858    }
    5959
     60    public int MinInitialTreeSize {
     61      get { return GetVariableInjector().GetVariable("MinInitialTreeSize").GetValue<IntData>().Data; }
     62      set { GetVariableInjector().GetVariable("MinInitialTreeSize").GetValue<IntData>().Data = value; }
     63    }
     64
     65    public override int MaxTreeSize {
     66      get {
     67        return base.MaxTreeSize;
     68      }
     69      set {
     70        base.MaxTreeSize = value;
     71        MinInitialTreeSize = value / 2;
     72      }
     73    }
     74
    6075    public override int PopulationSize {
    6176      get {
     
    104119      globalInjector.AddVariable(new HeuristicLab.Core.Variable("FullTreeShakingFactor", new DoubleData()));
    105120      globalInjector.AddVariable(new HeuristicLab.Core.Variable("OnePointShakingFactor", new DoubleData()));
     121      globalInjector.AddVariable(new HeuristicLab.Core.Variable("MinInitialTreeSize", new IntData()));
    106122      return globalInjector;
    107123    }
     
    118134      treeCreator.Name = "Tree generator";
    119135      treeCreator.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
    120       treeCreator.GetVariableInfo("MinTreeSize").Local = true;
    121       treeCreator.AddVariable(new HeuristicLab.Core.Variable("MinTreeSize", new IntData(30)));
     136      treeCreator.GetVariableInfo("MinTreeSize").ActualName = "MinInitialTreeSize";
    122137      return treeCreator;
    123138    }
     
    169184    protected internal override IOperator CreateBestSolutionProcessor() {
    170185      SequentialProcessor bestSolutionProcessor = new SequentialProcessor();
     186      MeanSquaredErrorEvaluator testMseEvaluator = new MeanSquaredErrorEvaluator();
     187      testMseEvaluator.Name = "TestMeanSquaredErrorEvaluator";
     188      testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestQuality";
     189      testMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     190      testMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
    171191      MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
    172192      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
     
    179199      validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
    180200      validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     201      MeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
     202      testMapeEvaluator.Name = "TestMapeEvaluator";
     203      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
     204      testMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     205      testMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
    181206      MeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
    182207      trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
     
    189214      validationMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
    190215      validationMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     216      MeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
     217      testMapreEvaluator.Name = "TestMapreEvaluator";
     218      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
     219      testMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     220      testMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     221      CoefficientOfDeterminationEvaluator trainingR2Evaluator = new CoefficientOfDeterminationEvaluator();
     222      trainingR2Evaluator.Name = "TrainingR2Evaluator";
     223      trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
     224      trainingR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     225      trainingR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
     226      CoefficientOfDeterminationEvaluator validationR2Evaluator = new CoefficientOfDeterminationEvaluator();
     227      validationR2Evaluator.Name = "ValidationR2Evaluator";
     228      validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
     229      validationR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     230      validationR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     231      CoefficientOfDeterminationEvaluator testR2Evaluator = new CoefficientOfDeterminationEvaluator();
     232      testR2Evaluator.Name = "TestR2Evaluator";
     233      testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
     234      testR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     235      testR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
    191236      ProgrammableOperator progOperator = new ProgrammableOperator();
    192237      progOperator.RemoveVariableInfo("Result");
     
    196241scope.AddVariable(new Variable(""EvaluatedSolutions"", new IntData(evalSolutions)));
    197242";
     243      bestSolutionProcessor.AddSubOperator(testMseEvaluator);
    198244      bestSolutionProcessor.AddSubOperator(trainingMapeEvaluator);
    199245      bestSolutionProcessor.AddSubOperator(validationMapeEvaluator);
     246      bestSolutionProcessor.AddSubOperator(testMapeEvaluator);
    200247      bestSolutionProcessor.AddSubOperator(trainingMapreEvaluator);
    201248      bestSolutionProcessor.AddSubOperator(validationMapreEvaluator);
     249      bestSolutionProcessor.AddSubOperator(testMapreEvaluator);
     250      bestSolutionProcessor.AddSubOperator(trainingR2Evaluator);
     251      bestSolutionProcessor.AddSubOperator(validationR2Evaluator);
     252      bestSolutionProcessor.AddSubOperator(testR2Evaluator);
    202253      bestSolutionProcessor.AddSubOperator(progOperator);
    203254      return bestSolutionProcessor;
Note: See TracChangeset for help on using the changeset viewer.