Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
09/07/09 18:55:50 (15 years ago)
Author:
gkronber
Message:

Fixed some issues in the GP algorithms for time-series prognosis and classification. #720

Location:
branches/gp-algorithms-refactoring-#720/sources/HeuristicLab.GP.StructureIdentification/3.3
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • branches/gp-algorithms-refactoring-#720/sources/HeuristicLab.GP.StructureIdentification/3.3/DefaultStructureIdentificationOperators.cs

    r2337 r2340  
    2626using HeuristicLab.Modeling;
    2727using HeuristicLab.Logging;
     28using HeuristicLab.Selection;
     29using HeuristicLab.Data;
    2830
    2931namespace HeuristicLab.GP.StructureIdentification {
    30   internal static class DefaultStructureIdentificationAlgorithmOperators {
    31     internal static IOperator CreateFunctionLibraryInjector() {
     32  public static class DefaultStructureIdentificationAlgorithmOperators {
     33    public static IOperator CreateFunctionLibraryInjector() {
    3234      CombinedOperator op = new CombinedOperator();
    3335      op.Name = "FunctionLibraryInjector";
    3436      SequentialProcessor seq = new SequentialProcessor();
    3537      seq.AddSubOperator(new FunctionLibraryInjector());
    36       seq.AddSubOperator(new HL2TreeEvaluatorInjector());
     38      seq.AddSubOperator(new HL3TreeEvaluatorInjector());
    3739      op.OperatorGraph.AddOperator(seq);
    3840      op.OperatorGraph.InitialOperator = seq;
    … …  
    4042    }
    4143
    42     internal static IOperator CreateProblemInjector() {
    43       return new ProblemInjector();
    44     }
    45 
    46     internal static IOperator CreateInitialPopulationEvaluator() {
     44    public static IOperator CreateProblemInjector() {
     45      CombinedOperator op = new CombinedOperator();
     46      op.Name = "ProblemInjector";
     47      SequentialProcessor seq = new SequentialProcessor();
     48
     49      seq.AddSubOperator(new ProblemInjector());
     50      DatasetShuffler shuffler = new DatasetShuffler();
     51      shuffler.GetVariableInfo("ShuffleStart").ActualName = "TrainingSamplesStart";
     52      shuffler.GetVariableInfo("ShuffleEnd").ActualName = "TrainingSamplesEnd";
     53      seq.AddSubOperator(shuffler);
     54      op.OperatorGraph.AddOperator(seq);
     55      op.OperatorGraph.InitialOperator = seq;
     56      return op;
     57    }
     58
     59    public static IOperator CreateInitialPopulationEvaluator() {
    4760      MeanSquaredErrorEvaluator eval = new MeanSquaredErrorEvaluator();
    4861      eval.Name = "Evaluator";
    … …  
    5366    }
    5467
    55     internal static IOperator CreateEvaluator() {
     68    public static IOperator CreateEvaluator() {
    5669      return CreateInitialPopulationEvaluator();
    5770    }
    5871
    59     internal static IOperator CreateGenerationStepHook() {
     72    public static IOperator CreateGenerationStepHook() {
    6073      CombinedOperator op = new CombinedOperator();
    6174      SequentialProcessor seq = new SequentialProcessor();
    … …  
    91104      return op;
    92105    }
     106
     107    public static IOperator CreatePostProcessingOperator() {
     108      CombinedOperator op = new CombinedOperator();
     109      op.Name = "ModelAnalyser";
     110      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 MSE
     129      MeanSquaredErrorEvaluator trainingMseEvaluator = new MeanSquaredErrorEvaluator();
     130      trainingMseEvaluator.Name = "TrainingMseEvaluator";
     131      trainingMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     132      trainingMseEvaluator.GetVariableInfo("MSE").ActualName = "TrainingMSE";
     133      trainingMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     134      trainingMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
     135      MeanSquaredErrorEvaluator validationMseEvaluator = new MeanSquaredErrorEvaluator();
     136      validationMseEvaluator.Name = "ValidationMseEvaluator";
     137      validationMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     138      validationMseEvaluator.GetVariableInfo("MSE").ActualName = "ValidationMSE";
     139      validationMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     140      validationMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     141      MeanSquaredErrorEvaluator testMseEvaluator = new MeanSquaredErrorEvaluator();
     142      testMseEvaluator.Name = "TestMeanSquaredErrorEvaluator";
     143      testMseEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     144      testMseEvaluator.GetVariableInfo("MSE").ActualName = "TestMSE";
     145      testMseEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     146      testMseEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     147      #endregion
     148      #region MAPE
     149      MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
     150      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
     151      trainingMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     152      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
     153      trainingMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     154      trainingMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
     155      MeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
     156      validationMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     157      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
     158      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
     159      validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     160      validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     161      MeanAbsolutePercentageErrorEvaluator testMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
     162      testMapeEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     163      testMapeEvaluator.Name = "TestMapeEvaluator";
     164      testMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TestMAPE";
     165      testMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     166      testMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     167      #endregion
     168      #region MAPRE
     169      MeanAbsolutePercentageOfRangeErrorEvaluator trainingMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
     170      trainingMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     171      trainingMapreEvaluator.Name = "TrainingMapreEvaluator";
     172      trainingMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TrainingMAPRE";
     173      trainingMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     174      trainingMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
     175      MeanAbsolutePercentageOfRangeErrorEvaluator validationMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
     176      validationMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     177      validationMapreEvaluator.Name = "ValidationMapreEvaluator";
     178      validationMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "ValidationMAPRE";
     179      validationMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     180      validationMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     181      MeanAbsolutePercentageOfRangeErrorEvaluator testMapreEvaluator = new MeanAbsolutePercentageOfRangeErrorEvaluator();
     182      testMapreEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     183      testMapreEvaluator.Name = "TestMapreEvaluator";
     184      testMapreEvaluator.GetVariableInfo("MAPRE").ActualName = "TestMAPRE";
     185      testMapreEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     186      testMapreEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     187      #endregion MAPRE
     188      #region R2
     189      CoefficientOfDeterminationEvaluator trainingR2Evaluator = new CoefficientOfDeterminationEvaluator();
     190      trainingR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     191      trainingR2Evaluator.Name = "TrainingR2Evaluator";
     192      trainingR2Evaluator.GetVariableInfo("R2").ActualName = "TrainingR2";
     193      trainingR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     194      trainingR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
     195      CoefficientOfDeterminationEvaluator validationR2Evaluator = new CoefficientOfDeterminationEvaluator();
     196      validationR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     197      validationR2Evaluator.Name = "ValidationR2Evaluator";
     198      validationR2Evaluator.GetVariableInfo("R2").ActualName = "ValidationR2";
     199      validationR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     200      validationR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     201      CoefficientOfDeterminationEvaluator testR2Evaluator = new CoefficientOfDeterminationEvaluator();
     202      testR2Evaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     203      testR2Evaluator.Name = "TestR2Evaluator";
     204      testR2Evaluator.GetVariableInfo("R2").ActualName = "TestR2";
     205      testR2Evaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     206      testR2Evaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     207      #endregion
     208      #region VAF
     209      VarianceAccountedForEvaluator trainingVAFEvaluator = new VarianceAccountedForEvaluator();
     210      trainingVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     211      trainingVAFEvaluator.Name = "TrainingVAFEvaluator";
     212      trainingVAFEvaluator.GetVariableInfo("VAF").ActualName = "TrainingVAF";
     213      trainingVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     214      trainingVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
     215      VarianceAccountedForEvaluator validationVAFEvaluator = new VarianceAccountedForEvaluator();
     216      validationVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     217      validationVAFEvaluator.Name = "ValidationVAFEvaluator";
     218      validationVAFEvaluator.GetVariableInfo("VAF").ActualName = "ValidationVAF";
     219      validationVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     220      validationVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     221      VarianceAccountedForEvaluator testVAFEvaluator = new VarianceAccountedForEvaluator();
     222      testVAFEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     223      testVAFEvaluator.Name = "TestVAFEvaluator";
     224      testVAFEvaluator.GetVariableInfo("VAF").ActualName = "TestVAF";
     225      testVAFEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     226      testVAFEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     227      #endregion
     228
     229      solutionProc.AddSubOperator(evaluatorInjector);
     230      solutionProc.AddSubOperator(trainingMseEvaluator);
     231      solutionProc.AddSubOperator(validationMseEvaluator);
     232      solutionProc.AddSubOperator(testMseEvaluator);
     233      solutionProc.AddSubOperator(trainingMapeEvaluator);
     234      solutionProc.AddSubOperator(validationMapeEvaluator);
     235      solutionProc.AddSubOperator(testMapeEvaluator);
     236      solutionProc.AddSubOperator(trainingMapreEvaluator);
     237      solutionProc.AddSubOperator(validationMapreEvaluator);
     238      solutionProc.AddSubOperator(testMapreEvaluator);
     239      solutionProc.AddSubOperator(trainingR2Evaluator);
     240      solutionProc.AddSubOperator(validationR2Evaluator);
     241      solutionProc.AddSubOperator(testR2Evaluator);
     242      solutionProc.AddSubOperator(trainingVAFEvaluator);
     243      solutionProc.AddSubOperator(validationVAFEvaluator);
     244      solutionProc.AddSubOperator(testVAFEvaluator);
     245
     246      #region variable impacts
     247      // calculate and set variable impacts
     248      VariableNamesExtractor namesExtractor = new VariableNamesExtractor();
     249      namesExtractor.GetVariableInfo("VariableNames").ActualName = "InputVariableNames";
     250      PredictorBuilder predictorBuilder = new PredictorBuilder();
     251      predictorBuilder.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
     252
     253      VariableEvaluationImpactCalculator evaluationImpactCalculator = new VariableEvaluationImpactCalculator();
     254      evaluationImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     255      evaluationImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
     256      VariableQualityImpactCalculator qualityImpactCalculator = new VariableQualityImpactCalculator();
     257      qualityImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     258      qualityImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
     259
     260      solutionProc.AddSubOperator(namesExtractor);
     261      solutionProc.AddSubOperator(predictorBuilder);
     262      solutionProc.AddSubOperator(evaluationImpactCalculator);
     263      solutionProc.AddSubOperator(qualityImpactCalculator);
     264      #endregion
     265
     266      op.OperatorGraph.AddOperator(seq);
     267      op.OperatorGraph.InitialOperator = seq;
     268      return op;
     269    }
     270
     271    public static IAnalyzerModel CreateGPModel(IScope bestModelScope) {
     272      IAnalyzerModel model = new AnalyzerModel();
     273      model.Predictor = bestModelScope.GetVariableValue<IPredictor>("Predictor", true);
     274      Dataset ds = bestModelScope.GetVariableValue<Dataset>("Dataset", true);
     275      model.Dataset = ds;
     276      model.TargetVariable = ds.GetVariableName(bestModelScope.GetVariableValue<IntData>("TargetVariable", true).Data);
     277      model.TrainingSamplesStart = bestModelScope.GetVariableValue<IntData>("TrainingSamplesStart", true).Data;
     278      model.TrainingSamplesEnd = bestModelScope.GetVariableValue<IntData>("TrainingSamplesEnd", true).Data;
     279      model.ValidationSamplesStart = bestModelScope.GetVariableValue<IntData>("ValidationSamplesStart", true).Data;
     280      model.ValidationSamplesEnd = bestModelScope.GetVariableValue<IntData>("ValidationSamplesEnd", true).Data;
     281      model.TestSamplesStart = bestModelScope.GetVariableValue<IntData>("TestSamplesStart", true).Data;
     282      model.TestSamplesEnd = bestModelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
     283
     284      model.TrainingMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TrainingMSE", false).Data;
     285      model.ValidationMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("ValidationMSE", false).Data;
     286      model.TestMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TestMSE", false).Data;
     287      model.TrainingCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data;
     288      model.ValidationCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("ValidationR2", false).Data;
     289      model.TestCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TestR2", false).Data;
     290      model.TrainingMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPE", false).Data;
     291      model.ValidationMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPE", false).Data;
     292      model.TestMeanAbsolutePercentageError = bestModelScope.GetVariableValue<DoubleData>("TestMAPE", false).Data;
     293      model.TrainingMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TrainingMAPRE", false).Data;
     294      model.ValidationMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("ValidationMAPRE", false).Data;
     295      model.TestMeanAbsolutePercentageOfRangeError = bestModelScope.GetVariableValue<DoubleData>("TestMAPRE", false).Data;
     296      model.TrainingVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TrainingVAF", false).Data;
     297      model.ValidationVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data;
     298      model.TestVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TestVAF", false).Data;
     299
     300      ItemList evaluationImpacts = bestModelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
     301      ItemList qualityImpacts = bestModelScope.GetVariableValue<ItemList>("VariableQualityImpacts", false);
     302      foreach (ItemList row in evaluationImpacts) {
     303        string variableName = ((StringData)row[0]).Data;
     304        double impact = ((DoubleData)row[1]).Data;
     305        model.SetVariableEvaluationImpact(variableName, impact);
     306        model.AddInputVariable(variableName);
     307      }
     308      foreach (ItemList row in qualityImpacts) {
     309        string variableName = ((StringData)row[0]).Data;
     310        double impact = ((DoubleData)row[1]).Data;
     311        model.SetVariableQualityImpact(variableName, impact);
     312        model.AddInputVariable(variableName);
     313      }
     314
     315      return model;
     316    }
    93317  }
    94318}

  • branches/gp-algorithms-refactoring-#720/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/GPEvaluatorBase.cs

    r2328 r2340  
    3636      AddVariableInfo(new VariableInfo("SamplesStart", "Start index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
    3737      AddVariableInfo(new VariableInfo("SamplesEnd", "End index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
    38       AddVariableInfo(new VariableInfo("UseEstimatedTargetValue", "Wether to use the original (measured) or the estimated (calculated) value for the target variable for autoregressive modelling", typeof(BoolData), VariableKind.In));
     38      AddVariableInfo(new VariableInfo("UseEstimatedTargetValue", "(optional) Wether to use the original (measured) or the estimated (calculated) value for the target variable for autoregressive modelling", typeof(BoolData), VariableKind.In));
    3939    }
    4040
    … …  
    4747      int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
    4848      int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
    49       bool useEstimatedValues = GetVariableValue<BoolData>("UseEstimatedTargetValue", scope, true).Data;
     49      BoolData useEstimatedValuesData = GetVariableValue<BoolData>("UseEstimatedTargetValue", scope, true, false);
     50      bool useEstimatedValues = useEstimatedValuesData == null ? false : useEstimatedValuesData.Data;
    5051      ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
    5152      evaluator.PrepareForEvaluation(dataset, gpModel.FunctionTree);

  • branches/gp-algorithms-refactoring-#720/sources/HeuristicLab.GP.StructureIdentification/3.3/HeuristicLab.GP.StructureIdentification-3.3.csproj

    r2337 r2340  
    8484    <Compile Include="BaseClasses\FunctionTreeBase.cs" />
    8585    <Compile Include="BaseClasses\TreeEvaluatorBase.cs" />
    86     <Compile Include="IStructureIdentificationAlgorithm.cs" />
     86    <Compile Include="DefaultStructureIdentificationOperators.cs" />
    8787    <Compile Include="HL3TreeEvaluatorInjector.cs" />
    8888    <Compile Include="HL2TreeEvaluatorInjector.cs" />

  • branches/gp-algorithms-refactoring-#720/sources/HeuristicLab.GP.StructureIdentification/3.3/OffspringSelectionGP.cs

    r2337 r2340  
    3030using HeuristicLab.Selection.OffspringSelection;
    3131using HeuristicLab.Modeling;
     32using HeuristicLab.DataAnalysis;
    3233
    3334namespace HeuristicLab.GP.StructureIdentification {
    34   public class OffspringSelectionGP : HeuristicLab.GP.Algorithms.OffspringSelectionGP {
     35  public class OffspringSelectionGP : HeuristicLab.GP.Algorithms.OffspringSelectionGP, IAlgorithm {
    3536    public override string Name { get { return "OffspringSelectionGP - StructureIdentification"; } }
    3637
    37     public HeuristicLab.DataAnalysis.Dataset Dataset {
    38       get {
    39         throw new NotImplementedException();
    40       }
    41       set {
    42         throw new NotImplementedException();
    43       }
     38    public virtual int TargetVariable {
     39      get { return ProblemInjector.GetVariableValue<IntData>("TargetVariable", null, false).Data; }
     40      set { ProblemInjector.GetVariableValue<IntData>("TargetVariable", null, false).Data = value; }
    4441    }
    4542
    46     public int TargetVariable {
    47       get {
    48         throw new NotImplementedException();
    49       }
    50       set {
    51         throw new NotImplementedException();
    52       }
     43    public virtual Dataset Dataset {
     44      get { return ProblemInjector.GetVariableValue<Dataset>("Dataset", null, false); }
     45      set { ProblemInjector.GetVariable("Dataset").Value = value; }
    5346    }
    5447
    55     public IAnalyzerModel Model {
    56       get { throw new NotImplementedException(); }
     48    public virtual IAnalyzerModel Model {
     49      get {
     50        if (!Engine.Terminated)
     51          throw new InvalidOperationException("The algorithm is still running. Wait until the algorithm is terminated to retrieve the result.");
     52        else
     53          return CreateGPModel();
     54      }
    5755    }
    5856
    … …  
    6058      get { return GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data; }
    6159      set { GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data = value; }
     60    }
     61
     62    public override IOperator ProblemInjector {
     63      get { return GetProblemInjector().OperatorGraph.InitialOperator.SubOperators[0]; }
     64      set {
     65        value.Name = "ProblemInjector";
     66        CombinedOperator problemInjector = GetProblemInjector();
     67        problemInjector.OperatorGraph.RemoveOperator(ProblemInjector.Guid);
     68        problemInjector.OperatorGraph.AddOperator(value);
     69        problemInjector.OperatorGraph.InitialOperator.AddSubOperator(value, 0);
     70      }
    6271    }
    6372
    … …  
    9099    protected override VariableInjector CreateGlobalInjector() {
    91100      VariableInjector injector = base.CreateGlobalInjector();
    92       injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
    93101      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData()));
    94102      return injector;
    95103    }
     104
    96105
    97106    protected override IOperator CreateLoggingOperator() {
    … …  
    123132    }
    124133
     134    protected override IOperator CreatePostProcessingOperator() {
     135      return DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator();
     136    }
     137
    125138    public override object Clone(IDictionary<Guid, object> clonedObjects) {
    126139      OffspringSelectionGP clone = (OffspringSelectionGP)base.Clone(clonedObjects);
    … …  
    128141      return clone;
    129142    }
     143
     144    protected CombinedOperator GetProblemInjector() {
     145      return (CombinedOperator)GetInitializationOperator().SubOperators[0];
     146    }
     147
     148    private IAnalyzerModel CreateGPModel() {
     149      IScope bestModelScope = Engine.GlobalScope.SubScopes[0];
     150      return DefaultStructureIdentificationAlgorithmOperators.CreateGPModel(bestModelScope);
     151    }
    130152  }
    131153}

  • branches/gp-algorithms-refactoring-#720/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs

    r2337 r2340  
    2929using System.Collections.Generic;
    3030using System;
     31using HeuristicLab.DataAnalysis;
    3132
    3233namespace HeuristicLab.GP.StructureIdentification {
    … …  
    3536    public override string Name { get { return "StandardGP - StructureIdentification"; } }
    3637
    37     public HeuristicLab.DataAnalysis.Dataset Dataset {
    38       get {
    39         throw new NotImplementedException();
    40       }
    41       set {
    42         throw new NotImplementedException();
    43       }
     38    public virtual int TargetVariable {
     39      get { return ProblemInjector.GetVariableValue<IntData>("TargetVariable", null, false).Data; }
     40      set { ProblemInjector.GetVariableValue<IntData>("TargetVariable", null, false).Data = value; }
    4441    }
    4542
    46     public int TargetVariable {
    47       get {
    48         throw new NotImplementedException();
    49       }
    50       set {
    51         throw new NotImplementedException();
    52       }
     43    public virtual Dataset Dataset {
     44      get { return ProblemInjector.GetVariableValue<Dataset>("Dataset", null, false); }
     45      set { ProblemInjector.GetVariable("Dataset").Value = value; }
    5346    }
    5447
    55     public IAnalyzerModel Model {
    56       get { throw new NotImplementedException(); }
     48    public virtual IAnalyzerModel Model {
     49      get {
     50        if (!Engine.Terminated)
     51          throw new InvalidOperationException("The algorithm is still running. Wait until the algorithm is terminated to retrieve the result.");
     52        else
     53          return CreateGPModel();
     54      }
    5755    }
    5856
    … …  
    6058      get { return GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data; }
    6159      set { GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data = value; }
     60    }
     61
     62    public override IOperator ProblemInjector {
     63      get { return GetProblemInjector().OperatorGraph.InitialOperator.SubOperators[0]; }
     64      set {
     65        value.Name = "ProblemInjector";
     66        CombinedOperator problemInjector = GetProblemInjector();
     67        problemInjector.OperatorGraph.RemoveOperator(ProblemInjector.Guid);
     68        problemInjector.OperatorGraph.AddOperator(value);
     69        problemInjector.OperatorGraph.InitialOperator.AddSubOperator(value, 0);
     70      }
    6271    }
    6372
    … …  
    8190
    8291    protected override IOperator CreateEvaluationOperator() {
    83       return DefaultStructureIdentificationAlgorithmOperators.CreateEvaluator();     
     92      return DefaultStructureIdentificationAlgorithmOperators.CreateEvaluator();
    8493    }
    8594
    … …  
    91100    protected override VariableInjector CreateGlobalInjector() {
    92101      VariableInjector injector = base.CreateGlobalInjector();
    93       injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
    94102      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData()));
    95103      return injector;
    … …  
    123131    }
    124132
     133    protected override IOperator CreatePostProcessingOperator() {
     134      return DefaultStructureIdentificationAlgorithmOperators.CreatePostProcessingOperator();
     135    }
     136
    125137    public override object Clone(IDictionary<Guid, object> clonedObjects) {
    126138      StandardGP clone = (StandardGP)base.Clone(clonedObjects);
    … …  
    128140      return clone;
    129141    }
     142
     143    protected CombinedOperator GetProblemInjector() {
     144      return (CombinedOperator)GetInitializationOperator().SubOperators[0];
     145    }
     146
     147    private IAnalyzerModel CreateGPModel() {
     148      IScope bestModelScope = Engine.GlobalScope.SubScopes[0];
     149      return DefaultStructureIdentificationAlgorithmOperators.CreateGPModel(bestModelScope);
     150    }
    130151  }
    131152}
Note: See TracChangeset for help on using the changeset viewer.