Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/DefaultStructureIdentificationOperators.cs @ 2553

Last change on this file since 2553 was 2553, checked in by gkronber, 14 years ago

Implemented #813 (GP structure-identification algorithms that use only a simple function library).
File size: 13.2 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using HeuristicLab.Core;
23using HeuristicLab.DataAnalysis;
24using HeuristicLab.GP.Interfaces;
25using HeuristicLab.Operators;
26using HeuristicLab.Modeling;
27using HeuristicLab.Logging;
28using HeuristicLab.Selection;
29using HeuristicLab.Data;
30
31namespace HeuristicLab.GP.StructureIdentification {
32  public static class DefaultStructureIdentificationOperators {
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
44    public static IOperator CreateSimpleFunctionLibraryInjector() {
45      CombinedOperator op = new CombinedOperator();
46      op.Name = "FunctionLibraryInjector";
47      SequentialProcessor seq = new SequentialProcessor();
48      var funLibInjector = new FunctionLibraryInjector();
49      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.CONSTANTS_ALLOWED, null, false).Data = true;
50      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.VARIABLES_ALLOWED, null, false).Data = true;
51      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.ADDITION_ALLOWED, null, false).Data = true;
52      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.SUBTRACTION_ALLOWED, null, false).Data = true;
53      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.MULTIPLICATION_ALLOWED, null, false).Data = true;
54
55      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.AND_ALLOWED, null, false).Data = false;
56      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.AVERAGE_ALLOWED, null, false).Data = false;
57      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.COSINUS_ALLOWED, null, false).Data = false;
58      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.DIFFERENTIALS_ALLOWED, null, false).Data = false;
59      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.DIVISION_ALLOWED, null, false).Data = false;
60      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.EQUAL_ALLOWED, null, false).Data = false;
61      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.EXPONENTIAL_ALLOWED, null, false).Data = false;
62      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.GREATERTHAN_ALLOWED, null, false).Data = false;
63      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.IFTHENELSE_ALLOWED, null, false).Data = false;
64      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.LESSTHAN_ALLOWED, null, false).Data = false;
65      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.LOGARTIHM_ALLOWED, null, false).Data = false;
66      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.NOT_ALLOWED, null, false).Data = false;
67      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.OR_ALLOWED, null, false).Data = false;
68      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.POWER_ALLOWED, null, false).Data = false;
69      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.SIGNUM_ALLOWED, null, false).Data = false;
70      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.SINUS_ALLOWED, null, false).Data = false;
71      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.SQRT_ALLOWED, null, false).Data = false;
72      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.TANGENS_ALLOWED, null, false).Data = false;
73      funLibInjector.GetVariableValue<BoolData>(FunctionLibraryInjector.XOR_ALLOWED, null, false).Data = false;
74      seq.AddSubOperator(funLibInjector);
75      seq.AddSubOperator(new HL3TreeEvaluatorInjector());
76      op.OperatorGraph.AddOperator(seq);
77      op.OperatorGraph.InitialOperator = seq;
78      return op;
79    }
80
81    public static IOperator CreateInitialPopulationEvaluator() {
82      MeanSquaredErrorEvaluator eval = new MeanSquaredErrorEvaluator();
83      eval.Name = "Evaluator";
84      eval.GetVariableInfo("MSE").ActualName = "Quality";
85      eval.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
86      eval.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
87      return eval;
88    }
89
90    public static IOperator CreateEvaluator() {
91      return CreateInitialPopulationEvaluator();
92    }
93
94    public static IOperator CreateGenerationStepHook() {
95      CombinedOperator op = new CombinedOperator();
96      SequentialProcessor seq = new SequentialProcessor();
97      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
98      SequentialProcessor individualProc = new SequentialProcessor();
99      MeanSquaredErrorEvaluator validationEvaluator = new MeanSquaredErrorEvaluator();
100      validationEvaluator.Name = "ValidationEvaluator";
101      validationEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
102      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
103      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
104
105      individualProc.AddSubOperator(validationEvaluator);
106
107      Counter bestValidationSolutionAgeCounter = new Counter();
108      bestValidationSolutionAgeCounter.Name = "BestSolutionAgeCounter";
109      bestValidationSolutionAgeCounter.GetVariableInfo("Value").ActualName = "BestValidationSolutionAge";
110
111      BestSolutionStorer solutionStorer = new BestSolutionStorer();
112      solutionStorer.GetVariableInfo("BestSolution").ActualName = "BestValidationSolution";
113      solutionStorer.GetVariableInfo("Quality").ActualName = "ValidationQuality";
114
115      OperatorExtractor bestSolutionProcessor = new OperatorExtractor();
116      bestSolutionProcessor.Name = "BestSolutionProcessor (extr.)";
117      bestSolutionProcessor.GetVariableInfo("Operator").ActualName = "BestSolutionProcessor";
118
119      solutionStorer.AddSubOperator(bestSolutionProcessor);
120
121      BestAverageWorstQualityCalculator validationQualityCalculator = new BestAverageWorstQualityCalculator();
122      validationQualityCalculator.Name = "BestAverageWorstValidationQualityCalculator";
123      validationQualityCalculator.GetVariableInfo("Quality").ActualName = "ValidationQuality";
124      validationQualityCalculator.GetVariableInfo("BestQuality").ActualName = "BestValidationQuality";
125      validationQualityCalculator.GetVariableInfo("AverageQuality").ActualName = "AverageValidationQuality";
126      validationQualityCalculator.GetVariableInfo("WorstQuality").ActualName = "WorstValidationQuality";
127
128      subScopesProc.AddSubOperator(individualProc);
129
130      seq.AddSubOperator(subScopesProc);
131      seq.AddSubOperator(bestValidationSolutionAgeCounter);
132      seq.AddSubOperator(solutionStorer);
133      seq.AddSubOperator(validationQualityCalculator);
134
135      op.OperatorGraph.AddOperator(seq);
136      op.OperatorGraph.InitialOperator = seq;
137      return op;
138    }
139
140
141    public static IOperator CreatePreparationForPostProcessingOperator() {
142      SequentialProcessor seq = new SequentialProcessor();
143      LeftReducer cleanUp = new LeftReducer();
144      cleanUp.Name = "Reset Population";
145      seq.AddSubOperator(cleanUp);
146
147      SolutionExtractor extractor = new SolutionExtractor();
148      extractor.GetVariableInfo("Scope").ActualName = "BestValidationSolution";
149      SequentialSubScopesProcessor seqSubScopeProc = new SequentialSubScopesProcessor();
150      SequentialProcessor solutionProc = new SequentialProcessor();
151
152      seq.AddSubOperator(extractor);
153      seq.AddSubOperator(seqSubScopeProc);
154      seqSubScopeProc.AddSubOperator(solutionProc);
155
156      HL3TreeEvaluatorInjector evaluatorInjector = new HL3TreeEvaluatorInjector();
157      evaluatorInjector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
158      evaluatorInjector.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
159
160      #region simple evaluators
161      SimpleEvaluator trainingEvaluator = new SimpleEvaluator();
162      trainingEvaluator.Name = "TrainingEvaluator";
163      trainingEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
164      trainingEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
165      trainingEvaluator.GetVariableInfo("Values").ActualName = "TrainingValues";
166      trainingEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
167      SimpleEvaluator validationEvaluator = new SimpleEvaluator();
168      validationEvaluator.Name = "ValidationEvaluator";
169      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
170      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
171      validationEvaluator.GetVariableInfo("Values").ActualName = "ValidationValues";
172      validationEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
173      SimpleEvaluator testEvaluator = new SimpleEvaluator();
174      testEvaluator.Name = "TestEvaluator";
175      testEvaluator.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
176      testEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
177      testEvaluator.GetVariableInfo("Values").ActualName = "TestValues";
178      testEvaluator.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
179      solutionProc.AddSubOperator(evaluatorInjector);
180      solutionProc.AddSubOperator(trainingEvaluator);
181      solutionProc.AddSubOperator(validationEvaluator);
182      solutionProc.AddSubOperator(testEvaluator);
183      #endregion
184
185      #region variable impacts
186      // calculate and set variable impacts
187      VariableNamesExtractor namesExtractor = new VariableNamesExtractor();
188      namesExtractor.GetVariableInfo("VariableNames").ActualName = "InputVariableNames";
189      PredictorBuilder predictorBuilder = new PredictorBuilder();
190      predictorBuilder.GetVariableInfo("TreeEvaluator").ActualName = "ModelAnalysisTreeEvaluator";
191
192      solutionProc.AddSubOperator(namesExtractor);
193      solutionProc.AddSubOperator(predictorBuilder);
194      VariableQualityImpactCalculator qualityImpactCalculator = new VariableQualityImpactCalculator();
195      qualityImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
196      qualityImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
197
198      solutionProc.AddSubOperator(qualityImpactCalculator);
199
200      NodeBasedVariableImpactCalculator nodeImpactCalculator = new NodeBasedVariableImpactCalculator();
201      nodeImpactCalculator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
202      nodeImpactCalculator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
203
204      solutionProc.AddSubOperator(nodeImpactCalculator);
205
206      #endregion
207
208      return seq;
209    }
210
211    public static void PopulateAnalyzerModel(IScope bestModelScope, IAnalyzerModel model) {
212      model.SetMetaData("EvaluatedSolutions", bestModelScope.GetVariableValue<IntData>("EvaluatedSolutions", false).Data);
213      IGeneticProgrammingModel gpModel = bestModelScope.GetVariableValue<IGeneticProgrammingModel>("FunctionTree", false);
214      model.SetMetaData("TreeSize", gpModel.Size);
215      model.SetMetaData("TreeHeight", gpModel.Height);
216      #region variable impacts
217      ItemList qualityImpacts = bestModelScope.GetVariableValue<ItemList>(ModelingResult.VariableQualityImpact.ToString(), false);
218      foreach (ItemList row in qualityImpacts) {
219        string variableName = ((StringData)row[0]).Data;
220        double impact = ((DoubleData)row[1]).Data;
221        model.SetVariableResult(ModelingResult.VariableQualityImpact, variableName, impact);
222        model.AddInputVariable(variableName);
223      }
224      ItemList nodeImpacts = bestModelScope.GetVariableValue<ItemList>(ModelingResult.VariableNodeImpact.ToString(), false);
225      foreach (ItemList row in nodeImpacts) {
226        string variableName = ((StringData)row[0]).Data;
227        double impact = ((DoubleData)row[1]).Data;
228        model.SetVariableResult(ModelingResult.VariableNodeImpact, variableName, impact);
229        model.AddInputVariable(variableName);
230      }
231      #endregion
232
233    }
234  }
235}
Note: See TracBrowser for help on using the repository browser.