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/StandardGP.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;
    3632
    37 namespace HeuristicLab.GP.StructureIdentification {
    38   public class StandardGP : AlgorithmBase, IEditable {
     33namespace HeuristicLab.GP.StructureIdentification.Classification {
     34  public class StandardGP :  HeuristicLab.GP.StructureIdentification.StandardGP {
     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";
    3941
    40     private IntData maxGenerations = new IntData();
    41     public int MaxGenerations {
    42       get { return maxGenerations.Data; }
    43       set { maxGenerations.Data = value; }
     42      AccuracyEvaluator validationAccuracy = new AccuracyEvaluator();
     43      validationAccuracy.GetVariableInfo("Accuracy").ActualName = "ValidationAccuracy";
     44      validationAccuracy.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     45      validationAccuracy.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     46
     47      AccuracyEvaluator testAccuracy = new AccuracyEvaluator();
     48      testAccuracy.GetVariableInfo("Accuracy").ActualName = "TestAccuracy";
     49      testAccuracy.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     50      testAccuracy.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     51
     52      ConfusionMatrixEvaluator trainingConfusionMatrix = new ConfusionMatrixEvaluator();
     53      trainingConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "TrainingConfusionMatrix";
     54      trainingConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
     55      trainingConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
     56
     57      ConfusionMatrixEvaluator validationConfusionMatrix = new ConfusionMatrixEvaluator();
     58      validationConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "ValidationConfusionMatrix";
     59      validationConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
     60      validationConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
     61
     62      ConfusionMatrixEvaluator testConfusionMatrix = new ConfusionMatrixEvaluator();
     63      testConfusionMatrix.GetVariableInfo("ConfusionMatrix").ActualName = "TestConfusionMatrix";
     64      testConfusionMatrix.GetVariableInfo("SamplesStart").ActualName = "TestSamplesStart";
     65      testConfusionMatrix.GetVariableInfo("SamplesEnd").ActualName = "TestSamplesEnd";
     66
     67      seq.AddSubOperator(trainingAccuracy);
     68      seq.AddSubOperator(validationAccuracy);
     69      seq.AddSubOperator(testAccuracy);
     70      return seq;
    4471    }
    45 
    46     private IntData tournamentSize = new IntData();
    47     public int TournamentSize {
    48       get { return tournamentSize.Data; }
    49       set { tournamentSize.Data = value; }
    50     }
    51 
    52     private DoubleData fullTreeShakingFactor = new DoubleData();
    53     public double FullTreeShakingFactor {
    54       get { return fullTreeShakingFactor.Data; }
    55       set { fullTreeShakingFactor.Data = value; }
    56     }
    57 
    58     private DoubleData onepointShakingFactor = new DoubleData();
    59     public double OnePointShakingFactor {
    60       get { return onepointShakingFactor.Data; }
    61       set { onepointShakingFactor.Data = value; }
    62     }
    63 
    64     public override int PopulationSize {
    65       get {
    66         return base.PopulationSize;
    67       }
    68       set {
    69         base.PopulationSize = value;
    70         Parents = 2 * value;
    71       }
    72     }
    73 
    74     public StandardGP()
    75       : base() {
    76       PopulationSize = 10000;
    77       MaxGenerations = 100;
    78       TournamentSize = 7;
    79       MutationRate = 0.15;
    80       Elites = 1;
    81       MaxTreeSize = 100;
    82       MaxTreeHeight = 10;
    83       FullTreeShakingFactor = 0.1;
    84       OnePointShakingFactor = 1.0;
    85 
    86       Engine = new SequentialEngine.SequentialEngine();
    87       IOperator algo = CreateAlgorithm();
    88       Engine.OperatorGraph.AddOperator(algo);
    89       Engine.OperatorGraph.InitialOperator = algo;
    90     }
    91 
    92     internal override IOperator CreateSelector() {
    93       TournamentSelector selector = new TournamentSelector();
    94       selector.Name = "Selector";
    95       selector.GetVariableInfo("Selected").ActualName = "Parents";
    96       selector.GetVariableInfo("GroupSize").Local = false;
    97       selector.RemoveVariable("GroupSize");
    98       selector.GetVariableInfo("GroupSize").ActualName = "TournamentSize";
    99       return selector;
    100     }
    101 
    102     internal override IOperator CreateGlobalInjector() {
    103       VariableInjector globalInjector = (VariableInjector)base.CreateGlobalInjector();
    104       globalInjector.AddVariable(new HeuristicLab.Core.Variable("TournamentSize", tournamentSize));
    105       globalInjector.AddVariable(new HeuristicLab.Core.Variable("MaxGenerations", maxGenerations));
    106       return globalInjector;
    107     }
    108 
    109     internal override IOperator CreateCrossover() {
    110       StandardCrossOver crossover = new StandardCrossOver();
    111       crossover.Name = "Crossover";
    112       crossover.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
    113       return crossover;
    114     }
    115 
    116     internal override IOperator CreateTreeCreator() {
    117       ProbabilisticTreeCreator treeCreator = new ProbabilisticTreeCreator();
    118       treeCreator.Name = "Tree generator";
    119       treeCreator.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
    120       treeCreator.GetVariableInfo("MinTreeSize").Local = true;
    121       treeCreator.AddVariable(new HeuristicLab.Core.Variable("MinTreeSize", new IntData(30)));
    122       return treeCreator;
    123     }
    124 
    125     internal override IOperator CreateFunctionLibraryInjector() {
    126       return new FunctionLibraryInjector();
    127     }
    128 
    129     internal override IOperator CreateManipulator() {
    130       CombinedOperator manipulator = new CombinedOperator();
    131       manipulator.Name = "Manipulator";
    132       StochasticMultiBranch multibranch = new StochasticMultiBranch();
    133       FullTreeShaker fullTreeShaker = new FullTreeShaker();
    134       fullTreeShaker.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
    135       fullTreeShaker.GetVariableInfo("ShakingFactor").Local = true;
    136       fullTreeShaker.AddVariable(new HeuristicLab.Core.Variable("ShakingFactor", fullTreeShakingFactor));
    137 
    138       OnePointShaker onepointShaker = new OnePointShaker();
    139       onepointShaker.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
    140       onepointShaker.GetVariableInfo("ShakingFactor").Local = true;
    141       onepointShaker.AddVariable(new HeuristicLab.Core.Variable("ShakingFactor", onepointShakingFactor));
    142       ChangeNodeTypeManipulation changeNodeTypeManipulation = new ChangeNodeTypeManipulation();
    143       changeNodeTypeManipulation.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
    144       CutOutNodeManipulation cutOutNodeManipulation = new CutOutNodeManipulation();
    145       cutOutNodeManipulation.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
    146       DeleteSubTreeManipulation deleteSubTreeManipulation = new DeleteSubTreeManipulation();
    147       deleteSubTreeManipulation.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
    148       SubstituteSubTreeManipulation substituteSubTreeManipulation = new SubstituteSubTreeManipulation();
    149       substituteSubTreeManipulation.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
    150 
    151       IOperator[] manipulators = new IOperator[] {
    152         onepointShaker, fullTreeShaker,
    153         changeNodeTypeManipulation,
    154         cutOutNodeManipulation,
    155         deleteSubTreeManipulation,
    156         substituteSubTreeManipulation};
    157 
    158       DoubleArrayData probabilities = new DoubleArrayData(new double[manipulators.Length]);
    159       for (int i = 0; i < manipulators.Length; i++) {
    160         probabilities.Data[i] = 1.0;
    161         multibranch.AddSubOperator(manipulators[i]);
    162       }
    163       multibranch.GetVariableInfo("Probabilities").Local = true;
    164       multibranch.AddVariable(new HeuristicLab.Core.Variable("Probabilities", probabilities));
    165 
    166       manipulator.OperatorGraph.AddOperator(multibranch);
    167       manipulator.OperatorGraph.InitialOperator = multibranch;
    168       return manipulator;
    169     }
    170 
    171     internal override IOperator CreateBestSolutionProcessor() {
    172       SequentialProcessor bestSolutionProcessor = new SequentialProcessor();
    173       MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
    174       trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
    175       trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
    176       trainingMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
    177       trainingMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
    178       MeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
    179       validationMapeEvaluator.Name = "ValidationMapeEvaluator";
    180       validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
    181       validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
    182       validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
    183       ProgrammableOperator progOperator = new ProgrammableOperator();
    184       progOperator.RemoveVariableInfo("Result");
    185       progOperator.AddVariableInfo(new HeuristicLab.Core.VariableInfo("EvaluatedSolutions", "", typeof(IntData), VariableKind.In));
    186       progOperator.Code = @"
    187 int evalSolutions = EvaluatedSolutions.Data;
    188 scope.AddVariable(new Variable(""EvaluatedSolutions"", new IntData(evalSolutions)));
    189 ";
    190       bestSolutionProcessor.AddSubOperator(trainingMapeEvaluator);
    191       bestSolutionProcessor.AddSubOperator(validationMapeEvaluator);
    192       bestSolutionProcessor.AddSubOperator(progOperator);
    193       return bestSolutionProcessor;
    194     }
    195 
    196     internal override IOperator CreateLoggingOperator() {
    197       CombinedOperator loggingOperator = new CombinedOperator();
    198       loggingOperator.Name = "Logging";
    199       SequentialProcessor seq = new SequentialProcessor();
    200 
    201       DataCollector collector = new DataCollector();
    202       ItemList<StringData> names = collector.GetVariable("VariableNames").GetValue<ItemList<StringData>>();
    203       names.Add(new StringData("BestQuality"));
    204       names.Add(new StringData("AverageQuality"));
    205       names.Add(new StringData("WorstQuality"));
    206       names.Add(new StringData("BestValidationQuality"));
    207       names.Add(new StringData("AverageValidationQuality"));
    208       names.Add(new StringData("WorstValidationQuality"));
    209       LinechartInjector lineChartInjector = new LinechartInjector();
    210       lineChartInjector.GetVariableInfo("Linechart").ActualName = "Quality Linechart";
    211       lineChartInjector.GetVariable("NumberOfLines").GetValue<IntData>().Data = 6;
    212       QualityLogger qualityLogger = new QualityLogger();
    213       QualityLogger validationQualityLogger = new QualityLogger();
    214       validationQualityLogger.Name = "ValidationQualityLogger";
    215       validationQualityLogger.GetVariableInfo("Quality").ActualName = "ValidationQuality";
    216       validationQualityLogger.GetVariableInfo("QualityLog").ActualName = "ValidationQualityLog";
    217 
    218       seq.AddSubOperator(collector);
    219       seq.AddSubOperator(lineChartInjector);
    220       seq.AddSubOperator(qualityLogger);
    221       seq.AddSubOperator(validationQualityLogger);
    222 
    223       loggingOperator.OperatorGraph.AddOperator(seq);
    224       loggingOperator.OperatorGraph.InitialOperator = seq;
    225       return loggingOperator;
    226     }
    227 
    228     public virtual IEditor CreateEditor() {
    229       return new StandardGpEditor(this);
    230     }
    231 
    232     public override IView CreateView() {
    233       return new StandardGpEditor(this);
    234     }
    235 
    236     public override object Clone(IDictionary<Guid, object> clonedObjects) {
    237       StandardGP clone = new StandardGP();
    238       clonedObjects.Add(Guid, clone);
    239       clone.Engine = (SequentialEngine.SequentialEngine)Auxiliary.Clone(Engine, clonedObjects);
    240       return clone;
    241     }
    242 
    243     #region SetReferences Method
    244     private void SetReferences() {
    245       // SGA
    246       CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
    247       // SequentialProcessor in SGA
    248       SequentialProcessor algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
    249       // RandomInjector
    250       RandomInjector ri = (RandomInjector)algorithm.SubOperators[1];
    251       // VariableInjector
    252       VariableInjector vi = (VariableInjector)algorithm.SubOperators[2];
    253       maxGenerations = vi.GetVariable("MaxGenerations").GetValue<IntData>();
    254       tournamentSize = vi.GetVariable("TournamentSize").GetValue<IntData>();
    255     }
    256     #endregion
    257 
    258     #region Persistence Methods
    259     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
    260       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
    261       node.AppendChild(PersistenceManager.Persist("Engine", Engine, document, persistedObjects));
    262       return node;
    263     }
    264     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
    265       base.Populate(node, restoredObjects);
    266       Engine = (SequentialEngine.SequentialEngine)PersistenceManager.Restore(node.SelectSingleNode("Engine"), restoredObjects);
    267       SetReferences();
    268     }
    269     #endregion
    27072  }
    27173}
Note: See TracChangeset for help on using the changeset viewer.