Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
03/04/09 16:12:31 (15 years ago)
Author:
gkronber
Message:
  • Moved DatasetShuffler from plugin HeuristicLab.GP.StructureIdentification.Classification to plugin HeuristicLab.DataAnalysis.
  • Added variants of StandardGP and OffspringSelectionGP for Classification and time-series analysis.

#224 (Simple frontend for GP for non-expert users (similar to HeurisicLab.SGA))

File:
1 copied

Legend:

Unmodified
Added
Removed

  • branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification.Classification/OffspringSelectionGP.cs

    r1244 r1245  
    2828using System.Diagnostics;
    2929using HeuristicLab.DataAnalysis;
    30 using HeuristicLab.Operators;
    3130using HeuristicLab.Random;
    32 using HeuristicLab.Selection;
    33 using HeuristicLab.Logging;
    3431using HeuristicLab.Data;
    35 using HeuristicLab.Operators.Programmable;
    36 using HeuristicLab.Selection.OffspringSelection;
    3732
    38 namespace HeuristicLab.GP.StructureIdentification {
    39   public class OffspringSelectionGP : StandardGP {
     33namespace HeuristicLab.GP.StructureIdentification.Classification {
     34  public class OffspringSelectionGP : HeuristicLab.GP.StructureIdentification.OffspringSelectionGP {
     35    protected override IOperator CreateBestSolutionProcessor() {
     36      IOperator seq = base.CreateBestSolutionProcessor();
     37      AccuracyEvaluator trainingAccuracy = new AccuracyEvaluator();
     38      trainingAccuracy.GetVariableInfo("Accuracy").ActualName = "TrainingAccuracy";
     39      trainingAccuracy.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     40      trainingAccuracy.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
    4041
    41     private IntData maxEvaluatedSolutions = new IntData();
    42     public int MaxEvaluatedSolutions {
    43       get { return maxEvaluatedSolutions.Data; }
    44       set { maxEvaluatedSolutions.Data = value; }
    45     }
     42      AccuracyEvaluator validationAccuracy = new AccuracyEvaluator();
     43      validationAccuracy.GetVariableInfo("Accuracy").ActualName = "ValidationAccuracy";
     44      validationAccuracy.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     45      validationAccuracy.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
    4646
    47     private DoubleData selectionPressureLimit = new DoubleData();
    48     public double SelectionPressureLimit {
    49       get { return selectionPressureLimit.Data; }
    50       set { selectionPressureLimit.Data = value; }
    51     }
     47      AccuracyEvaluator testAccuracy = new AccuracyEvaluator();
     48      testAccuracy.GetVariableInfo("Accuracy").ActualName = "TestAccuracy";
     49      testAccuracy.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     50      testAccuracy.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
    5251
    53     private DoubleData comparisonFactor = new DoubleData();
    54     public double ComparisonFactor {
    55       get { return comparisonFactor.Data; }
    56       set { comparisonFactor.Data = value; }
    57     }
     52      ConfusionMatrixEvaluator trainingConfusionMatrix = new ConfusionMatrixEvaluator();
     53      trainingConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "TrainingConfusionMatrix";
     54      trainingConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     55      trainingConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
    5856
    59     private DoubleData successRatioLimit = new DoubleData();
    60     public double SuccessRatioLimit {
    61       get { return successRatioLimit.Data; }
    62       set { successRatioLimit.Data = value; }
    63     }
     57      ConfusionMatrixEvaluator validationConfusionMatrix = new ConfusionMatrixEvaluator();
     58      validationConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "ValidationConfusionMatrix";
     59      validationConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     60      validationConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
    6461
    65     public OffspringSelectionGP() : base() {
    66       PopulationSize = 1000;
    67       Parents = 20;
    68       MaxEvaluatedSolutions = 1000000;
    69       SelectionPressureLimit = 300;
    70       ComparisonFactor = 1.0;
    71       SuccessRatioLimit = 1.0;
    72     }
     62      ConfusionMatrixEvaluator testConfusionMatrix = new ConfusionMatrixEvaluator();
     63      testConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "TestConfusionMatrix";
     64      testConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     65      testConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
    7366
    74     internal override IOperator CreateGlobalInjector() {
    75       VariableInjector injector = (VariableInjector)base.CreateGlobalInjector();
    76       injector.RemoveVariable("TournamentSize");
    77       injector.RemoveVariable("MaxGenerations");
    78       injector.AddVariable(new HeuristicLab.Core.Variable("MaxEvaluatedSolutions", maxEvaluatedSolutions));
    79       injector.AddVariable(new HeuristicLab.Core.Variable("ComparisonFactor", comparisonFactor));
    80       injector.AddVariable(new HeuristicLab.Core.Variable("SelectionPressureLimit", selectionPressureLimit));
    81       injector.AddVariable(new HeuristicLab.Core.Variable("SuccessRatioLimit", successRatioLimit));
    82       return injector;
    83     }
    84 
    85     internal override IOperator CreateSelector() {
    86       CombinedOperator selector = new CombinedOperator();
    87       selector.Name = "Selector";
    88       SequentialProcessor seq = new SequentialProcessor();
    89       seq.Name = "Selector";
    90       EmptyOperator emptyOp = new EmptyOperator();
    91       ProportionalSelector femaleSelector = new ProportionalSelector();
    92       femaleSelector.GetVariableInfo("Selected").ActualName = "Parents";
    93       femaleSelector.GetVariableValue<BoolData>("CopySelected", null, false).Data = true;
    94 
    95       RandomSelector maleSelector = new RandomSelector();
    96       maleSelector.GetVariableInfo("Selected").ActualName = "Parents";
    97       maleSelector.GetVariableValue<BoolData>("CopySelected", null, false).Data = true;
    98       SequentialSubScopesProcessor seqSubScopesProc = new SequentialSubScopesProcessor();
    99       RightChildReducer rightChildReducer = new RightChildReducer();
    100       SubScopesMixer mixer = new SubScopesMixer();
    101 
    102       seqSubScopesProc.AddSubOperator(femaleSelector);
    103       seqSubScopesProc.AddSubOperator(emptyOp);
    104 
    105       seq.AddSubOperator(maleSelector);
    106       seq.AddSubOperator(seqSubScopesProc);
    107       seq.AddSubOperator(rightChildReducer);
    108       seq.AddSubOperator(mixer);
    109 
    110       selector.OperatorGraph.AddOperator(seq);
    111       selector.OperatorGraph.InitialOperator = seq;
    112       return selector;
    113     }
    114 
    115     internal override IOperator CreateChildCreater() {
    116       CombinedOperator childCreater = new CombinedOperator();
    117       childCreater.Name = "Create children";
    118       SequentialProcessor seq = new SequentialProcessor();
    119       SequentialProcessor offspringSelectionSeq = new SequentialProcessor();
    120       OperatorExtractor selector = new OperatorExtractor();
    121       selector.Name = "Selector (extr.)";
    122       selector.GetVariableInfo("Operator").ActualName = "Selector";
    123       SequentialSubScopesProcessor seqSubScopesProc = new SequentialSubScopesProcessor();
    124       EmptyOperator emptyOp = new EmptyOperator();
    125       OffspringSelector offspringSelector = new OffspringSelector();
    126       OffspringAnalyzer offspringAnalyzer = new OffspringAnalyzer();
    127       SequentialProcessor selectedProc = new SequentialProcessor();
    128       OperatorExtractor crossover = new OperatorExtractor();
    129       crossover.Name = "Crossover (extr.)";
    130       crossover.GetVariableInfo("Operator").ActualName = "Crossover";
    131       UniformSequentialSubScopesProcessor individualProc = new UniformSequentialSubScopesProcessor();
    132       SequentialProcessor individualSeqProc = new SequentialProcessor();
    133       StochasticBranch cond = new StochasticBranch();
    134       cond.GetVariableInfo("Probability").ActualName = "MutationRate";
    135       OperatorExtractor manipulator = new OperatorExtractor();
    136       manipulator.Name = "Manipulator (extr.)";
    137       manipulator.GetVariableInfo("Operator").ActualName = "Manipulator";
    138       OperatorExtractor evaluator = new OperatorExtractor();
    139       evaluator.Name = "Evaluator (extr.)";
    140       evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
    141       Counter evalCounter = new Counter();
    142       evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
    143 
    144       Sorter sorter = new Sorter();
    145       sorter.GetVariableInfo("Descending").ActualName = "Maximization";
    146       sorter.GetVariableInfo("Value").ActualName = "Quality";
    147 
    148       UniformSequentialSubScopesProcessor validationEvaluator = new UniformSequentialSubScopesProcessor();
    149       MeanSquaredErrorEvaluator validationQualityEvaluator = new MeanSquaredErrorEvaluator();
    150       validationQualityEvaluator.Name = "ValidationMeanSquaredErrorEvaluator";
    151       validationQualityEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
    152       validationQualityEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
    153       validationQualityEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
    154 
    155       seqSubScopesProc.AddSubOperator(emptyOp);
    156       seqSubScopesProc.AddSubOperator(offspringAnalyzer);
    157 
    158       seq.AddSubOperator(offspringSelectionSeq);
    159       offspringSelectionSeq.AddSubOperator(selector);
    160       offspringSelectionSeq.AddSubOperator(seqSubScopesProc);
    161       offspringSelectionSeq.AddSubOperator(offspringSelector);
    162       offspringSelector.AddSubOperator(offspringSelectionSeq);
    163 
    164       offspringAnalyzer.AddSubOperator(selectedProc);
    165       selectedProc.AddSubOperator(crossover);
    166       selectedProc.AddSubOperator(individualProc);
    167       individualProc.AddSubOperator(individualSeqProc);
    168       individualSeqProc.AddSubOperator(cond);
    169       cond.AddSubOperator(manipulator);
    170       individualSeqProc.AddSubOperator(evaluator);
    171       individualSeqProc.AddSubOperator(evalCounter);
    172 
    173       SequentialSubScopesProcessor seqSubScopesProc2 = new SequentialSubScopesProcessor();
    174       seq.AddSubOperator(seqSubScopesProc2);
    175       seqSubScopesProc2.AddSubOperator(emptyOp);
    176 
    177       SequentialProcessor newGenProc = new SequentialProcessor();
    178       newGenProc.AddSubOperator(sorter);
    179       newGenProc.AddSubOperator(validationEvaluator);
    180       seqSubScopesProc2.AddSubOperator(newGenProc);
    181 
    182       validationEvaluator.AddSubOperator(validationQualityEvaluator);
    183 
    184       childCreater.OperatorGraph.AddOperator(seq);
    185       childCreater.OperatorGraph.InitialOperator = seq;
    186       return childCreater;
    187     }
    188 
    189     internal override IOperator CreateLoopCondition(IOperator loop) {
    190       SequentialProcessor seq = new SequentialProcessor();
    191       seq.Name = "Loop Condition";
    192       LessThanComparator generationsComparator = new LessThanComparator();
    193       generationsComparator.GetVariableInfo("LeftSide").ActualName = "EvaluatedSolutions";
    194       generationsComparator.GetVariableInfo("RightSide").ActualName = "MaxEvaluatedSolutions";
    195       generationsComparator.GetVariableInfo("Result").ActualName = "EvaluatedSolutionsCondition";
    196 
    197       LessThanComparator selPresComparator = new LessThanComparator();
    198       selPresComparator.GetVariableInfo("LeftSide").ActualName = "SelectionPressure";
    199       selPresComparator.GetVariableInfo("RightSide").ActualName = "SelectionPressureLimit";
    200       selPresComparator.GetVariableInfo("Result").ActualName = "SelectionPressureCondition";
    201      
    202       ConditionalBranch generationsCond = new ConditionalBranch();
    203       generationsCond.GetVariableInfo("Condition").ActualName = "EvaluatedSolutionsCondition";
    204 
    205       ConditionalBranch selPresCond = new ConditionalBranch();
    206       selPresCond.GetVariableInfo("Condition").ActualName = "SelectionPressureCondition";
    207 
    208       seq.AddSubOperator(generationsComparator);
    209       seq.AddSubOperator(selPresComparator);
    210       seq.AddSubOperator(generationsCond);
    211       generationsCond.AddSubOperator(selPresCond);
    212       selPresCond.AddSubOperator(loop);
    213 
     67      seq.AddSubOperator(trainingAccuracy);
     68      seq.AddSubOperator(validationAccuracy);
     69      seq.AddSubOperator(testAccuracy);
    21470      return seq;
    21571    }
    216 
    217     internal override IOperator CreateLoggingOperator() {
    218       CombinedOperator loggingOperator = new CombinedOperator();
    219       loggingOperator.Name = "Logging";
    220       SequentialProcessor seq = new SequentialProcessor();
    221 
    222       DataCollector collector = new DataCollector();
    223       ItemList<StringData> names = collector.GetVariable("VariableNames").GetValue<ItemList<StringData>>();
    224       names.Add(new StringData("BestQuality"));
    225       names.Add(new StringData("AverageQuality"));
    226       names.Add(new StringData("WorstQuality"));
    227       names.Add(new StringData("BestValidationQuality"));
    228       names.Add(new StringData("AverageValidationQuality"));
    229       names.Add(new StringData("WorstValidationQuality"));
    230       names.Add(new StringData("EvaluatedSolutions"));
    231       names.Add(new StringData("SelectionPressure"));
    232       QualityLogger qualityLogger = new QualityLogger();
    233       QualityLogger validationQualityLogger = new QualityLogger();
    234       validationQualityLogger.Name = "ValidationQualityLogger";
    235       validationQualityLogger.GetVariableInfo("Quality").ActualName = "ValidationQuality";
    236       validationQualityLogger.GetVariableInfo("QualityLog").ActualName = "ValidationQualityLog";
    237 
    238       seq.AddSubOperator(collector);
    239       seq.AddSubOperator(qualityLogger);
    240       seq.AddSubOperator(validationQualityLogger);
    241 
    242       loggingOperator.OperatorGraph.AddOperator(seq);
    243       loggingOperator.OperatorGraph.InitialOperator = seq;
    244       return loggingOperator;
    245     }
    246 
    247 
    248     public override IEditor CreateEditor() {
    249       return new OffspringSelectionGpEditor(this);
    250     }
    251 
    252     public override IView CreateView() {
    253       return new OffspringSelectionGpEditor(this);
    254     }
    255 
    256     public override object Clone(IDictionary<Guid, object> clonedObjects) {
    257       OffspringSelectionGP clone = (OffspringSelectionGP)base.Clone(clonedObjects);
    258       clone.SelectionPressureLimit = SelectionPressureLimit;
    259       clone.SuccessRatioLimit = SuccessRatioLimit;
    260       clone.ComparisonFactor = ComparisonFactor;
    261       return clone;
    262     }
    263 
    264     #region SetReferences Method
    265     private void SetReferences() {
    266       // SGA
    267       CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
    268       // SequentialProcessor in SGA
    269       SequentialProcessor algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
    270       // RandomInjector
    271       RandomInjector ri = (RandomInjector)algorithm.SubOperators[1];
    272       // VariableInjector
    273       VariableInjector vi = (VariableInjector)algorithm.SubOperators[2];
    274       selectionPressureLimit = vi.GetVariable("SelectionPressureLimit").GetValue<DoubleData>();
    275       successRatioLimit = vi.GetVariable("SuccessRatioLimit").GetValue<DoubleData>();
    276       comparisonFactor = vi.GetVariable("ComparisonFactor").GetValue<DoubleData>();
    277     }
    278     #endregion
    279 
    280     #region Persistence Methods
    281     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
    282       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
    283       return node;
    284     }
    285     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
    286       base.Populate(node, restoredObjects);
    287       SetReferences();
    288     }
    289     #endregion
    29072  }
    29173}
Note: See TracChangeset for help on using the changeset viewer.