Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
09/15/09 14:01:47 (15 years ago)
Author:
gkronber
Message:

Moved common (not algorithm specific) model analyzer code (same operator tree in all regression/classification/time-series-prognosis engines) to HL.Modeling. #625, #705, #739.

Location:
trunk/sources/HeuristicLab.Modeling/3.2
Files:
1 edited
1 copied
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Modeling/3.2/DefaultClassificationOperators.cs

    r2354 r2356  
    2222using HeuristicLab.Core;
    2323using HeuristicLab.DataAnalysis;
    24 using HeuristicLab.GP.Interfaces;
    2524using HeuristicLab.Operators;
    2625using HeuristicLab.Modeling;
    2726using HeuristicLab.Data;
    2827
    29 namespace HeuristicLab.GP.StructureIdentification.Classification {
    30   public static class DefaultClassificationAlgorithmOperators {
     28namespace HeuristicLab.Modeling {
     29  public static class DefaultClassificationOperators {
    3130    public static IOperator CreatePostProcessingOperator() {
     31      CombinedOperator op = new CombinedOperator();
     32      op.Name = "Classification model analyzer";
     33
    3234      SequentialProcessor seq = new SequentialProcessor();
    33       seq.AddSubOperator(DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator());
     35      seq.AddSubOperator(DefaultRegressionOperators.CreatePostProcessingOperator());
    3436
    35       UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
    36       SequentialProcessor individualProc = new SequentialProcessor();
    37       subScopesProc.AddSubOperator(individualProc);
    38       seq.AddSubOperator(subScopesProc);
    3937      SimpleAccuracyEvaluator trainingAccuracy = new SimpleAccuracyEvaluator();
    4038      trainingAccuracy.Name = "TrainingAccuracyEvaluator";
    … …  
    5250      testAccuracy.GetVariableInfo("Values").ActualName = "TestValues";
    5351
    54       individualProc.AddSubOperator(trainingAccuracy);
    55       individualProc.AddSubOperator(validationAccuracy);
    56       individualProc.AddSubOperator(testAccuracy);
    57       return seq;
     52      SimpleConfusionMatrixEvaluator trainingConfusionMatrixEvaluator = new SimpleConfusionMatrixEvaluator();
     53      trainingConfusionMatrixEvaluator.Name = "TrainingConfusionMatrixEvaluator";
     54      trainingConfusionMatrixEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
     55      trainingConfusionMatrixEvaluator.GetVariableInfo("ConfusionMatrix").ActualName = "TrainingConfusionMatrix";
     56      SimpleConfusionMatrixEvaluator validationConfusionMatrixEvaluator = new SimpleConfusionMatrixEvaluator();
     57      validationConfusionMatrixEvaluator.Name = "ValidationConfusionMatrixEvaluator";
     58      validationConfusionMatrixEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
     59      validationConfusionMatrixEvaluator.GetVariableInfo("ConfusionMatrix").ActualName = "ValidationConfusionMatrix";
     60      SimpleConfusionMatrixEvaluator testConfusionMatrixEvaluator = new SimpleConfusionMatrixEvaluator();
     61      testConfusionMatrixEvaluator.Name = "TestConfusionMatrixEvaluator";
     62      testConfusionMatrixEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
     63      testConfusionMatrixEvaluator.GetVariableInfo("ConfusionMatrix").ActualName = "TestConfusionMatrix";
     64
     65      seq.AddSubOperator(trainingAccuracy);
     66      seq.AddSubOperator(validationAccuracy);
     67      seq.AddSubOperator(testAccuracy);
     68      seq.AddSubOperator(trainingConfusionMatrixEvaluator);
     69      seq.AddSubOperator(validationConfusionMatrixEvaluator);
     70      seq.AddSubOperator(testConfusionMatrixEvaluator);
     71
     72      op.OperatorGraph.AddOperator(seq);
     73      op.OperatorGraph.InitialOperator = seq;
     74
     75      return op;
    5876    }
    5977
    6078    public static IOperator CreateProblemInjector() {
    61       CombinedOperator op = new CombinedOperator();
    62       op.Name = "ProblemInjector";
    63       SequentialProcessor seq = new SequentialProcessor();
    64       seq.AddSubOperator(new ProblemInjector());
    65       seq.AddSubOperator(new TargetClassesCalculator());
    66       op.OperatorGraph.AddOperator(seq);
    67       op.OperatorGraph.InitialOperator = seq;
    68       return op;
     79      return DefaultRegressionOperators.CreateProblemInjector();
    6980    }
    7081
    71     public static void SetModelData(IAnalyzerModel model, IScope scope) {
    72       model.SetResult("TrainingAccuracy", scope.GetVariableValue<DoubleData>("TrainingAccuracy", true).Data);
    73       model.SetResult("ValidationAccuracy", scope.GetVariableValue<DoubleData>("ValidationAccuracy", true).Data);
    74       model.SetResult("TestAccuracy", scope.GetVariableValue<DoubleData>("TestAccuracy", true).Data);
     82    public static IAnalyzerModel PopulateAnalyzerModel(IScope modelScope, IAnalyzerModel model) {
     83      DefaultRegressionOperators.PopulateAnalyzerModel(modelScope, model);
     84      model.SetResult("TrainingAccuracy", modelScope.GetVariableValue<DoubleData>("TrainingAccuracy", false).Data);
     85      model.SetResult("ValidationAccuracy", modelScope.GetVariableValue<DoubleData>("ValidationAccuracy", false).Data);
     86      model.SetResult("TestAccuracy", modelScope.GetVariableValue<DoubleData>("TestAccuracy", false).Data);
     87      return model;
    7588    }
    7689  }

  • trunk/sources/HeuristicLab.Modeling/3.2/DefaultRegressionOperators.cs

    r2354 r2356  
    2222using HeuristicLab.Core;
    2323using HeuristicLab.DataAnalysis;
    24 using HeuristicLab.GP.Interfaces;
    2524using HeuristicLab.Operators;
    2625using HeuristicLab.Modeling;
    27 using HeuristicLab.Logging;
    28 using HeuristicLab.Selection;
    2926using HeuristicLab.Data;
    3027
    31 namespace HeuristicLab.GP.StructureIdentification {
    32   public static class DefaultStructureIdentificationAlgorithmOperators {
    33     public static IOperator CreateFunctionLibraryInjector() {
    34       CombinedOperator op = new CombinedOperator();
    35       op.Name = "FunctionLibraryInjector";
    36       SequentialProcessor seq = new SequentialProcessor();
    37       seq.AddSubOperator(new FunctionLibraryInjector());
    38       seq.AddSubOperator(new HL3TreeEvaluatorInjector());
    39       op.OperatorGraph.AddOperator(seq);
    40       op.OperatorGraph.InitialOperator = seq;
    41       return op;
    42     }
    43 
     28namespace HeuristicLab.Modeling {
     29  public static class DefaultRegressionOperators {
    4430    public static IOperator CreateProblemInjector() {
    4531      CombinedOperator op = new CombinedOperator();
    … …  
    5743    }
    5844
    59     public static IOperator CreateInitialPopulationEvaluator() {
    60       MeanSquaredErrorEvaluator eval = new MeanSquaredErrorEvaluator();
    61       eval.Name = "Evaluator";
    62       eval.GetVariableInfo("MSE").ActualName = "Quality";
    63       eval.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
    64       eval.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
    65       return eval;
    66     }
    67 
    68     public static IOperator CreateEvaluator() {
    69       return CreateInitialPopulationEvaluator();
    70     }
    71 
    72     public static IOperator CreateGenerationStepHook() {
    73       CombinedOperator op = new CombinedOperator();
    74       SequentialProcessor seq = new SequentialProcessor();
    75       UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
    76       SequentialProcessor individualProc = new SequentialProcessor();
    77       MeanSquaredErrorEvaluator validationEvaluator = new MeanSquaredErrorEvaluator();
    78       validationEvaluator.Name = "ValidationEvaluator";
    79       validationEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
    80       validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
    81       validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
    82 
    83       individualProc.AddSubOperator(validationEvaluator);
    84 
    85       BestSolutionStorer solutionStorer = new BestSolutionStorer();
    86       solutionStorer.GetVariableInfo("BestSolution").ActualName = "BestValidationSolution";
    87       solutionStorer.GetVariableInfo("Quality").ActualName = "ValidationQuality";
    88 
    89       BestAverageWorstQualityCalculator validationQualityCalculator = new BestAverageWorstQualityCalculator();
    90       validationQualityCalculator.Name = "BestAverageWorstValidationQualityCalculator";
    91       validationQualityCalculator.GetVariableInfo("Quality").ActualName = "ValidationQuality";
    92       validationQualityCalculator.GetVariableInfo("BestQuality").ActualName = "BestValidationQuality";
    93       validationQualityCalculator.GetVariableInfo("AverageQuality").ActualName = "AverageValidationQuality";
    94       validationQualityCalculator.GetVariableInfo("WorstQuality").ActualName = "WorstValidationQuality";
    95 
    96       subScopesProc.AddSubOperator(individualProc);
    97 
    98       seq.AddSubOperator(subScopesProc);
    99       seq.AddSubOperator(solutionStorer);
    100       seq.AddSubOperator(validationQualityCalculator);
    101 
    102       op.OperatorGraph.AddOperator(seq);
    103       op.OperatorGraph.InitialOperator = seq;
    104       return op;
    105     }
    106 
    10745    public static IOperator CreatePostProcessingOperator() {
    10846      CombinedOperator op = new CombinedOperator();
    109       op.Name = "ModelAnalyser";
     47      op.Name = "Regression model analyser";
    11048      SequentialProcessor seq = new SequentialProcessor();
    111       LeftReducer cleanUp = new LeftReducer();
    112       cleanUp.Name = "Reset Population";
    113       seq.AddSubOperator(cleanUp);
    114 
    115       SolutionExtractor extractor = new SolutionExtractor();
    116       extractor.GetVariableInfo("Scope").ActualName = "BestValidationSolution";
    117       SequentialSubScopesProcessor seqSubScopeProc = new SequentialSubScopesProcessor();
    118       SequentialProcessor solutionProc = new SequentialProcessor();
    119 
    120       seq.AddSubOperator(extractor);
    121       seq.AddSubOperator(seqSubScopeProc);
    122       seqSubScopeProc.AddSubOperator(solutionProc);
    123 
    124       HL3TreeEvaluatorInjector evaluatorInjector = new HL3TreeEvaluatorInjector();
    125       evaluatorInjector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
    126       evaluatorInjector.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
    127 
    128       #region simple evaluators
    129       SimpleEvaluator trainingEvaluator = new SimpleEvaluator();
    130       trainingEvaluator.Name = "TrainingEvaluator";
    131       trainingEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
    132       trainingEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
    133       trainingEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
    134       trainingEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
    135       SimpleEvaluator validationEvaluator = new SimpleEvaluator();
    136       validationEvaluator.Name = "ValidationEvaluator";
    137       validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
    138       validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
    139       validationEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
    140       validationEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
    141       SimpleEvaluator testEvaluator = new SimpleEvaluator();
    142       testEvaluator.Name = "TestEvaluator";
    143       testEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
    144       testEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
    145       testEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
    146       testEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
    147       #endregion
    14849      #region MSE
    14950      SimpleMSEEvaluator trainingMseEvaluator = new SimpleMSEEvaluator();
    … …  
    217118      #endregion
    218119
    219       solutionProc.AddSubOperator(evaluatorInjector);
    220       solutionProc.AddSubOperator(trainingEvaluator);
    221       solutionProc.AddSubOperator(validationEvaluator);
    222       solutionProc.AddSubOperator(testEvaluator);
    223       solutionProc.AddSubOperator(trainingMseEvaluator);
    224       solutionProc.AddSubOperator(validationMseEvaluator);
    225       solutionProc.AddSubOperator(testMseEvaluator);
    226       solutionProc.AddSubOperator(trainingMapeEvaluator);
    227       solutionProc.AddSubOperator(validationMapeEvaluator);
    228       solutionProc.AddSubOperator(testMapeEvaluator);
    229       solutionProc.AddSubOperator(trainingMapreEvaluator);
    230       solutionProc.AddSubOperator(validationMapreEvaluator);
    231       solutionProc.AddSubOperator(testMapreEvaluator);
    232       solutionProc.AddSubOperator(trainingR2Evaluator);
    233       solutionProc.AddSubOperator(validationR2Evaluator);
    234       solutionProc.AddSubOperator(testR2Evaluator);
    235       solutionProc.AddSubOperator(trainingVAFEvaluator);
    236       solutionProc.AddSubOperator(validationVAFEvaluator);
    237       solutionProc.AddSubOperator(testVAFEvaluator);
     120      seq.AddSubOperator(trainingMseEvaluator);
     121      seq.AddSubOperator(validationMseEvaluator);
     122      seq.AddSubOperator(testMseEvaluator);
     123      seq.AddSubOperator(trainingMapeEvaluator);
     124      seq.AddSubOperator(validationMapeEvaluator);
     125      seq.AddSubOperator(testMapeEvaluator);
     126      seq.AddSubOperator(trainingMapreEvaluator);
     127      seq.AddSubOperator(validationMapreEvaluator);
     128      seq.AddSubOperator(testMapreEvaluator);
     129      seq.AddSubOperator(trainingR2Evaluator);
     130      seq.AddSubOperator(validationR2Evaluator);
     131      seq.AddSubOperator(testR2Evaluator);
     132      seq.AddSubOperator(trainingVAFEvaluator);
     133      seq.AddSubOperator(validationVAFEvaluator);
     134      seq.AddSubOperator(testVAFEvaluator);
    238135
    239136      #region variable impacts
    240       // calculate and set variable impacts
    241       VariableNamesExtractor namesExtractor = new VariableNamesExtractor();
    242       namesExtractor.GetVariableInfo("VariableNames").ActualName = "InputVariableNames";
    243       PredictorBuilder predictorBuilder = new PredictorBuilder();
    244       predictorBuilder.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
    245 
    246137      VariableEvaluationImpactCalculator evaluationImpactCalculator = new VariableEvaluationImpactCalculator();
    247138      evaluationImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
    … …  
    251142      qualityImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
    252143
    253       solutionProc.AddSubOperator(namesExtractor);
    254       solutionProc.AddSubOperator(predictorBuilder);
    255       solutionProc.AddSubOperator(evaluationImpactCalculator);
    256       solutionProc.AddSubOperator(qualityImpactCalculator);
     144      seq.AddSubOperator(evaluationImpactCalculator);
     145      seq.AddSubOperator(qualityImpactCalculator);
    257146      #endregion
    258147
    … …  
    262151    }
    263152
    264     public static IAnalyzerModel CreateGPModel(IScope bestModelScope) {
    265       IAnalyzerModel model = new AnalyzerModel();
    266       model.Predictor = bestModelScope.GetVariableValue<IPredictor>("Predictor", true);
    267       Dataset ds = bestModelScope.GetVariableValue<Dataset>("Dataset", true);
     153    public static IAnalyzerModel PopulateAnalyzerModel(IScope modelScope, IAnalyzerModel model) {
     154      model.Predictor = modelScope.GetVariableValue<IPredictor>("Predictor", false);
     155      Dataset ds = modelScope.GetVariableValue<Dataset>("Dataset", true);
    268156      model.Dataset = ds;
    269       model.TargetVariable = ds.GetVariableName(bestModelScope.GetVariableValue<IntData>("TargetVariable", true).Data);
    270       model.TrainingSamplesStart = bestModelScope.GetVariableValue<IntData>("TrainingSamplesStart", true).Data;
    271       model.TrainingSamplesEnd = bestModelScope.GetVariableValue<IntData>("TrainingSamplesEnd", true).Data;
    272       model.ValidationSamplesStart = bestModelScope.GetVariableValue<IntData>("ValidationSamplesStart", true).Data;
    273       model.ValidationSamplesEnd = bestModelScope.GetVariableValue<IntData>("ValidationSamplesEnd", true).Data;
    274       model.TestSamplesStart = bestModelScope.GetVariableValue<IntData>("TestSamplesStart", true).Data;
    275       model.TestSamplesEnd = bestModelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
     157      model.TargetVariable = ds.GetVariableName(modelScope.GetVariableValue<IntData>("TargetVariable", true).Data);
     158      model.TrainingSamplesStart = modelScope.GetVariableValue<IntData>("TrainingSamplesStart", true).Data;
     159      model.TrainingSamplesEnd = modelScope.GetVariableValue<IntData>("TrainingSamplesEnd", true).Data;
     160      model.ValidationSamplesStart = modelScope.GetVariableValue<IntData>("ValidationSamplesStart", true).Data;
     161      model.ValidationSamplesEnd = modelScope.GetVariableValue<IntData>("ValidationSamplesEnd", true).Data;
     162      model.TestSamplesStart = modelScope.GetVariableValue<IntData>("TestSamplesStart", true).Data;
     163      model.TestSamplesEnd = modelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
    276164
    277       model.SetResult("TrainingMeanSquaredError", bestModelScope.GetVariableValue<DoubleData>("TrainingMSE", false).Data);
    278       model.SetResult("ValidationMeanSquaredError", bestModelScope.GetVariableValue<DoubleData>("ValidationMSE", false).Data);
    279       model.SetResult("TestMeanSquaredError", bestModelScope.GetVariableValue<DoubleData>("TestMSE", false).Data);
    280       model.SetResult("TrainingCoefficientOfDetermination", bestModelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data);
    281       model.SetResult("ValidationCoefficientOfDetermination", bestModelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data);
    282       model.SetResult("TestCoefficientOfDetermination", bestModelScope.GetVariableValue<DoubleData>("TestR2", false).Data);
    283       model.SetResult("TrainingMeanAbsolutePercentageError", bestModelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data);
    284       model.SetResult("ValidationMeanAbsolutePercentageError", bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data);
    285       model.SetResult("TestMeanAbsolutePercentageError", bestModelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data);
    286       model.SetResult("TrainingMeanAbsolutePercentageOfRangeError", bestModelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data);
    287       model.SetResult("ValidationMeanAbsolutePercentageOfRangeError", bestModelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data);
    288       model.SetResult("TestMeanAbsolutePercentageOfRangeError", bestModelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data);
    289       model.SetResult("TrainingVarianceAccountedFor", bestModelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data);
    290       model.SetResult("ValidationVarianceAccountedFor", bestModelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data);
    291       model.SetResult("TestVarianceAccountedFor", bestModelScope.GetVariableValue<DoubleData>("TestVAF", false).Data);
     165      model.SetResult("TrainingMeanSquaredError", modelScope.GetVariableValue<DoubleData>("TrainingMSE", false).Data);
     166      model.SetResult("ValidationMeanSquaredError", modelScope.GetVariableValue<DoubleData>("ValidationMSE", false).Data);
     167      model.SetResult("TestMeanSquaredError", modelScope.GetVariableValue<DoubleData>("TestMSE", false).Data);
     168      model.SetResult("TrainingCoefficientOfDetermination", modelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data);
     169      model.SetResult("ValidationCoefficientOfDetermination", modelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data);
     170      model.SetResult("TestCoefficientOfDetermination", modelScope.GetVariableValue<DoubleData>("TestR2", false).Data);
     171      model.SetResult("TrainingMeanAbsolutePercentageError", modelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data);
     172      model.SetResult("ValidationMeanAbsolutePercentageError", modelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data);
     173      model.SetResult("TestMeanAbsolutePercentageError", modelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data);
     174      model.SetResult("TrainingMeanAbsolutePercentageOfRangeError", modelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data);
     175      model.SetResult("ValidationMeanAbsolutePercentageOfRangeError", modelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data);
     176      model.SetResult("TestMeanAbsolutePercentageOfRangeError", modelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data);
     177      model.SetResult("TrainingVarianceAccountedFor", modelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data);
     178      model.SetResult("ValidationVarianceAccountedFor", modelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data);
     179      model.SetResult("TestVarianceAccountedFor", modelScope.GetVariableValue<DoubleData>("TestVAF", false).Data);
    292180
    293       model.SetMetaData("EvaluatedSolutions", bestModelScope.GetVariableValue<DoubleData>("EvaluatedSolutions", true).Data);
    294       IGeneticProgrammingModel gpModel = bestModelScope.GetVariableValue<IGeneticProgrammingModel>("FunctionTree", true);
    295       model.SetMetaData("TreeSize", gpModel.Size);
    296       model.SetMetaData("TreeHeight", gpModel.Height);
    297 
    298       ItemList evaluationImpacts = bestModelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
    299       ItemList qualityImpacts = bestModelScope.GetVariableValue<ItemList>("VariableQualityImpacts", false);
     181      ItemList evaluationImpacts = modelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
     182      ItemList qualityImpacts = modelScope.GetVariableValue<ItemList>("VariableQualityImpacts", false);
    300183      foreach (ItemList row in evaluationImpacts) {
    301184        string variableName = ((StringData)row[0]).Data;

  • trunk/sources/HeuristicLab.Modeling/3.2/DefaultTimeSeriesOperators.cs

    r2354 r2356  
    2222using HeuristicLab.Core;
    2323using HeuristicLab.DataAnalysis;
    24 using HeuristicLab.GP.Interfaces;
    2524using HeuristicLab.Operators;
    2625using HeuristicLab.Modeling;
    27 using HeuristicLab.Logging;
    2826using HeuristicLab.Data;
    2927
    30 namespace HeuristicLab.GP.StructureIdentification.TimeSeries {
    31   internal static class DefaultTimeSeriesOperators {
    32     internal static IOperator CreateFunctionLibraryInjector() {
    33       CombinedOperator op = new CombinedOperator();
    34       op.Name = "FunctionLibraryInjector";
    35       SequentialProcessor seq = new SequentialProcessor();
    36       FunctionLibraryInjector funLibInjector = new FunctionLibraryInjector();
    37       funLibInjector.GetVariable("Differentials").Value = new BoolData(true);
    38       seq.AddSubOperator(funLibInjector);
    39       seq.AddSubOperator(new HL3TreeEvaluatorInjector());
    40       op.OperatorGraph.AddOperator(seq);
    41       op.OperatorGraph.InitialOperator = seq;
    42       return op;
    43     }
    44 
    45     internal static IOperator CreateProblemInjector() {
     28namespace HeuristicLab.Modeling {
     29  public static class DefaultTimeSeriesOperators {
     30    public static IOperator CreateProblemInjector() {
    4631      CombinedOperator op = new CombinedOperator();
    4732      op.Name = "ProblemInjector";
    … …  
    5338    }
    5439
    55     internal static IOperator CreatePostProcessingOperator() {
     40    public static IOperator CreatePostProcessingOperator() {
     41      CombinedOperator op = new CombinedOperator();
     42      op.Name = "Time series prognosis model analyzer";
     43
    5644      SequentialProcessor seq = new SequentialProcessor();
    57       seq.AddSubOperator(DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator());
    58 
    59       UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
    60       SequentialProcessor individualProc = new SequentialProcessor();
    61       subScopesProc.AddSubOperator(individualProc);
    62       seq.AddSubOperator(subScopesProc);
     45      seq.AddSubOperator(DefaultRegressionOperators.CreatePostProcessingOperator());
    6346
    6447      SimpleTheilInequalityCoefficientEvaluator trainingTheil = new SimpleTheilInequalityCoefficientEvaluator();
    … …  
    7558      testTheil.GetVariableInfo("TheilInequalityCoefficient").ActualName = "TestTheilInequalityCoefficient";
    7659
    77       individualProc.AddSubOperator(trainingTheil);
    78       individualProc.AddSubOperator(validationTheil);
    79       individualProc.AddSubOperator(testTheil);
    80       return seq;
     60      seq.AddSubOperator(trainingTheil);
     61      seq.AddSubOperator(validationTheil);
     62      seq.AddSubOperator(testTheil);
     63
     64      op.OperatorGraph.AddOperator(seq);
     65      op.OperatorGraph.InitialOperator = seq;
     66      return op;
    8167    }
    8268
    83     internal static void SetModelData(IAnalyzerModel model, IScope scope) {
    84       model.SetResult("TrainingTheilInequalityCoefficient", scope.GetVariableValue<DoubleData>("TrainingTheilInequalityCoefficient", true).Data);
    85       model.SetResult("ValidationTheilInequalityCoefficient", scope.GetVariableValue<DoubleData>("ValidationTheilInequalityCoefficient", true).Data);
    86       model.SetResult("TestTheilInequalityCoefficient", scope.GetVariableValue<DoubleData>("TestTheilInequalityCoefficient", true).Data);
     69    public static IAnalyzerModel PopulateAnalyzerModel(IScope modelScope, IAnalyzerModel model) {
     70      DefaultRegressionOperators.PopulateAnalyzerModel(modelScope, model);
     71      model.SetResult("TrainingTheilInequalityCoefficient", modelScope.GetVariableValue<DoubleData>("TrainingTheilInequalityCoefficient", true).Data);
     72      model.SetResult("ValidationTheilInequalityCoefficient", modelScope.GetVariableValue<DoubleData>("ValidationTheilInequalityCoefficient", true).Data);
     73      model.SetResult("TestTheilInequalityCoefficient", modelScope.GetVariableValue<DoubleData>("TestTheilInequalityCoefficient", true).Data);
     74
     75      return model;
    8776    }
    8877  }

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

    r2351 r2356  
    8484    <Compile Include="AnalyzerModel.cs" />
    8585    <Compile Include="BestSolutionStorer.cs" />
     86    <Compile Include="DefaultClassificationOperators.cs" />
     87    <Compile Include="DefaultRegressionOperators.cs" />
     88    <Compile Include="DefaultTimeSeriesOperators.cs" />
    8689    <Compile Include="SimpleAccuracyEvaluator.cs" />
    8790    <Compile Include="SimpleConfusionMatrixEvaluator.cs" />
    … …  
    133136      <Name>HeuristicLab.Data-3.2</Name>
    134137    </ProjectReference>
     138    <ProjectReference Include="..\..\HeuristicLab.Operators\3.2\HeuristicLab.Operators-3.2.csproj">
     139      <Project>{A9983BA2-B3B2-475E-8E2C-62050B71D1C5}</Project>
     140      <Name>HeuristicLab.Operators-3.2</Name>
     141    </ProjectReference>
    135142    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\HeuristicLab.PluginInfrastructure.csproj">
    136143      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
Note: See TracChangeset for help on using the changeset viewer.