source: branches/CMAES/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.3/CMAEvolutionStrategyMainLoop.cs @ 9121

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Operators;
using HeuristicLab.Optimization.Operators;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Selection;

namespace HeuristicLab.Algorithms.CMAEvolutionStrategy {
  [Item("CMAEvolutionStrategyMainLoop", "An operator which represents the main loop of a CMA evolution strategy.")]
  [StorableClass]
  public sealed class CMAEvolutionStrategyMainLoop : AlgorithmOperator {
    #region Parameter properties
    public IValueLookupParameter<IRandom> RandomParameter {
      get { return (IValueLookupParameter<IRandom>)Parameters["Random"]; }
    }
    public IValueLookupParameter<BoolValue> MaximizationParameter {
      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
    }
    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
    }
    public IValueLookupParameter<DoubleValue> BestKnownQualityParameter {
      get { return (IValueLookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
    }
    public IValueLookupParameter<IntValue> PopulationSizeParameter {
      get { return (IValueLookupParameter<IntValue>)Parameters["PopulationSize"]; }
    }
    public IValueLookupParameter<IntValue> MaximumGenerationsParameter {
      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumGenerations"]; }
    }
    public IValueLookupParameter<IntValue> MaximumEvaluatedSolutionsParameter {
      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumEvaluatedSolutions"]; }
    }
    public IValueLookupParameter<IOperator> MutatorParameter {
      get { return (IValueLookupParameter<IOperator>)Parameters["Mutator"]; }
    }
    public IValueLookupParameter<IOperator> RecombinatorParameter {
      get { return (IValueLookupParameter<IOperator>)Parameters["Recombinator"]; }
    }
    public IValueLookupParameter<IOperator> EvaluatorParameter {
      get { return (IValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
    }
    public IValueLookupParameter<VariableCollection> ResultsParameter {
      get { return (IValueLookupParameter<VariableCollection>)Parameters["Results"]; }
    }
    public IValueLookupParameter<IOperator> AnalyzerParameter {
      get { return (IValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
    }
    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
    }
    public ILookupParameter<IntValue> GenerationsParameter {
      get { return (ILookupParameter<IntValue>)Parameters["Generations"]; }
    }
    public ILookupParameter<IntValue> MuParameter {
      get { return (ILookupParameter<IntValue>)Parameters["Mu"]; }
    }
    public IValueLookupParameter<IOperator> CMAESUpdaterParameter {
      get { return (IValueLookupParameter<IOperator>)Parameters["CMAESUpdater"]; }
    }
    #endregion

    [StorableConstructor]
    private CMAEvolutionStrategyMainLoop(bool deserializing) : base(deserializing) { }
    private CMAEvolutionStrategyMainLoop(CMAEvolutionStrategyMainLoop original, Cloner cloner)
      : base(original, cloner) {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CMAEvolutionStrategyMainLoop(this, cloner);
    }
    public CMAEvolutionStrategyMainLoop()
      : base() {
      Initialize();
    }

    private void Initialize() {
      #region Create parameters
      Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
      Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "λ (lambda) - the size of the population."));
      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumEvaluatedSolutions", "The maximum number of evaluated solutions that should be computed."));
      Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
      Parameters.Add(new ValueLookupParameter<IOperator>("Recombinator", "The operator used to cross solutions."));
      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
      Parameters.Add(new LookupParameter<IntValue>("Generations", "The current generation that is being processed."));
      Parameters.Add(new LookupParameter<IntValue>("Mu", "The number of offspring considered for updating of the strategy parameters."));
      Parameters.Add(new ValueLookupParameter<IOperator>("CMAESUpdater", "The operator to update the strategy parameters."));
      #endregion

      #region Create operators
      var analyzer = new Placeholder();
      var selector = new LeftSelector();
      var ssp1 = new SubScopesProcessor();
      var eo1 = new EmptyOperator();
      var childrenCreator = new ChildrenCreator();
      var ssp2 = new SubScopesProcessor();
      var ussp1 = new UniformSubScopesProcessor();
      var mutator = new Placeholder();
      var ussp2 = new UniformSubScopesProcessor();
      var evaluator1 = new Placeholder();
      var evaluationsCounter = new IntCounter();
      var selector2 = new BestSelector();
      var reducer2 = new RightReducer();
      var recombinator = new Placeholder();
      var evaluator2 = new Placeholder();
      var updater = new Placeholder();
      var reducer1 = new RightReducer();
      var ssp3 = new SubScopesProcessor();
      var subScopesRemover = new SubScopesRemover();
      var generationsCounter = new IntCounter();
      var comparatorEvaluations = new Comparator();
      var branchEvaluations = new ConditionalBranch();
      var comparatorGenerations = new Comparator();
      var branchGenerations = new ConditionalBranch();
      var analyzer2 = new Placeholder();

      analyzer.Name = "Analyzer (placeholder)";
      analyzer.OperatorParameter.ActualName = AnalyzerParameter.Name;

      selector.CopySelected = new BoolValue(true);
      selector.NumberOfSelectedSubScopesParameter.ActualName = PopulationSizeParameter.Name;

      childrenCreator.ParentsPerChild = null;
      childrenCreator.ParentsPerChildParameter.ActualName = PopulationSizeParameter.Name;

      ussp1.Name = "Mutate Offspring";
      ussp1.Parallel = new BoolValue(false);

      mutator.Name = "Mutator (placeholder)";
      mutator.OperatorParameter.ActualName = MutatorParameter.Name;

      ussp2.Name = "Evaluate Offspring";
      ussp2.Parallel = new BoolValue(true);

      evaluator1.Name = "Evaluator (placeholder)";
      evaluator1.OperatorParameter.ActualName = EvaluatorParameter.Name;

      evaluationsCounter.Name = "Count EvaluatedSolutions";
      evaluationsCounter.Increment = null;
      evaluationsCounter.IncrementParameter.ActualName = PopulationSizeParameter.Name;

      selector2.MaximizationParameter.ActualName = MaximizationParameter.Name;
      selector2.QualityParameter.ActualName = QualityParameter.Name;
      selector2.NumberOfSelectedSubScopesParameter.ActualName = MuParameter.Name;
      selector2.CopySelected = new BoolValue(false);

      reducer2.Name = "Drop Worst";

      recombinator.Name = "Update Mean (placeholder)";
      recombinator.OperatorParameter.ActualName = RecombinatorParameter.Name;

      evaluator2.Name = "Evaluator (placeholder)";
      evaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;

      updater.Name = "Update Strategy Parameters";
      updater.OperatorParameter.ActualName = CMAESUpdaterParameter.Name;

      reducer1.Name = "Move to new mean";

      ssp3.Name = "Cleanup";

      subScopesRemover.Name = "Drop Best Offspring";
      subScopesRemover.RemoveAllSubScopes = true;

      generationsCounter.Name = "Generations++";
      generationsCounter.Increment = new IntValue(1);
      generationsCounter.ValueParameter.ActualName = "Generations";

      comparatorEvaluations.Name = "Compare EvaluatedSolutions";
      comparatorEvaluations.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
      comparatorEvaluations.LeftSideParameter.ActualName = "EvaluatedSolutions";
      comparatorEvaluations.ResultParameter.ActualName = "Terminate";
      comparatorEvaluations.RightSideParameter.ActualName = MaximumEvaluatedSolutionsParameter.Name;

      branchEvaluations.Name = "Terminate on MaximumEvaluations";
      branchEvaluations.ConditionParameter.ActualName = "Terminate";

      comparatorGenerations.Name = "Compare Generations";
      comparatorGenerations.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
      comparatorGenerations.LeftSideParameter.ActualName = "Generations";
      comparatorGenerations.ResultParameter.ActualName = "Terminate";
      comparatorGenerations.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;

      branchGenerations.Name = "Terminate on MaximumGenerations";
      branchGenerations.ConditionParameter.ActualName = "Terminate";

      analyzer2.Name = "Analyzer (Placeholder)";
      analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
      #endregion

      #region Create operator graph
      OperatorGraph.InitialOperator = analyzer;
      analyzer.Successor = selector;
      selector.Successor = ssp1;
      ssp1.Operators.Add(eo1);
      ssp1.Operators.Add(childrenCreator);
      ssp1.Successor = generationsCounter;
      eo1.Successor = null;
      childrenCreator.Successor = ssp2;
      ssp2.Operators.Add(ussp1);
      ssp2.Successor = null;
      ussp1.Operator = mutator;
      ussp1.Successor = ussp2;
      mutator.Successor = null;
      ussp2.Operator = evaluator1;
      ussp2.Successor = evaluationsCounter;
      evaluator1.Successor = null;
      evaluationsCounter.Successor = selector2;
      selector2.Successor = reducer2;
      reducer2.Successor = recombinator;
      recombinator.Successor = evaluator2;
      evaluator2.Successor = null;
      generationsCounter.Successor = updater;
      updater.Successor = reducer1;
      reducer1.Successor = ssp3;
      ssp3.Operators.Add(subScopesRemover);
      ssp3.Successor = comparatorEvaluations;
      subScopesRemover.Successor = null;
      comparatorEvaluations.Successor = branchEvaluations;
      branchEvaluations.FalseBranch = comparatorGenerations;
      branchEvaluations.TrueBranch = analyzer2;
      branchEvaluations.Successor = null;
      comparatorGenerations.Successor = branchGenerations;
      branchGenerations.FalseBranch = analyzer;
      branchGenerations.TrueBranch = analyzer2;
      branchGenerations.Successor = null;
      analyzer2.Successor = null;
      #endregion
    }

    public override IOperation Apply() {
      if (MutatorParameter.ActualValue == null || RecombinatorParameter.ActualValue == null)
        return null;
      return base.Apply();
    }
  }
}