Changeset 2882 for trunk/sources/HeuristicLab.SGA

Timestamp:

02/27/10 03:35:11 (14 years ago)

Author:

swagner

Message:

Operator architecture refactoring (#95)

• worked on algorithms

Location:

trunk/sources/HeuristicLab.SGA/3.3

Files:

• SGA.cs (modified) (7 diffs)
• SGAOperator.cs (modified) (11 diffs)

trunk/sources/HeuristicLab.SGA/3.3/SGA.cs

@@ -29 +29 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.SGA {
@@ -42 +43 @@
     private SGAOperator sgaOperator;
 
-    private ConstrainedValueParameter<ICrossover> CrossoverOperatorParameter {
-      get { return (ConstrainedValueParameter<ICrossover>)Parameters["CrossoverOperator"]; }
+    private ValueParameter<IntData> PopulationSizeParameter {
+      get { return (ValueParameter<IntData>)Parameters["PopulationSize"]; }
     }
-    private ConstrainedValueParameter<IManipulator> MutationOperatorParameter {
-      get { return (ConstrainedValueParameter<IManipulator>)Parameters["MutationOperator"]; }
+    private ConstrainedValueParameter<ISelector> SelectorParameter {
+      get { return (ConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
+    }
+    private ConstrainedValueParameter<ICrossover> CrossoverParameter {
+      get { return (ConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
+    }
+    private ConstrainedValueParameter<IManipulator> MutatorParameter {
+      get { return (ConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
+    }
+    private ValueParameter<IntData> ElitesParameter {
+      get { return (ValueParameter<IntData>)Parameters["Elites"]; }
     }
 
@@ -62 +72 @@
       Parameters.Add(new ValueParameter<BoolData>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolData(true)));
       Parameters.Add(new ValueParameter<IntData>("PopulationSize", "The size of the population of solutions.", new IntData(100)));
-      Parameters.Add(new ConstrainedValueParameter<ICrossover>("CrossoverOperator", "The operator used to cross solutions."));
+      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
+      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
       Parameters.Add(new ValueParameter<DoubleData>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new DoubleData(0.05)));
-      Parameters.Add(new ConstrainedValueParameter<IManipulator>("MutationOperator", "The operator used to mutate solutions."));
+      Parameters.Add(new ConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
       Parameters.Add(new ValueParameter<IntData>("Elites", "The numer of elite solutions which are kept in each generation.", new IntData(1)));
       Parameters.Add(new ValueParameter<IntData>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntData(1000)));
+
+      PopulationSizeParameter.ValueChanged += new EventHandler(PopulationSizeParameter_ValueChanged);
+      ElitesParameter.ValueChanged += new EventHandler(ElitesParameter_ValueChanged);
 
       RandomCreator randomCreator = new RandomCreator();
@@ -83 +97 @@
       populationCreator.Successor = sgaOperator;
 
-      sgaOperator.CrossoverOperatorParameter.ActualName = "CrossoverOperator";
+      sgaOperator.SelectorParameter.ActualName = "Selector";
+      sgaOperator.CrossoverParameter.ActualName = "Crossover";
       sgaOperator.ElitesParameter.ActualName = "Elites";
       sgaOperator.MaximumGenerationsParameter.ActualName = "MaximumGenerations";
-      sgaOperator.MutationOperatorParameter.ActualName = "MutationOperator";
+      sgaOperator.MutatorParameter.ActualName = "Mutator";
       sgaOperator.MutationProbabilityParameter.ActualName = "MutationProbability";
       sgaOperator.RandomParameter.ActualName = "Random";
+      sgaOperator.ResultsParameter.ActualName = "Results";
 
       OperatorGraph.InitialOperator = randomCreator;
+
+      var selectors = ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector));
+      selectors.Select(x => x.CopySelected = new BoolData(true));
+      selectors.Select(x => x.NumberOfSelectedSubScopesParameter.Value = new IntData(2 * (PopulationSizeParameter.Value.Value - ElitesParameter.Value.Value)));
+      selectors.OfType<IStochasticOperator>().Select(x => x.RandomParameter.ActualName = "Random");
+      foreach (ISelector selector in selectors)
+        SelectorParameter.ValidValues.Add(selector);
     }
 
@@ -98 +121 @@
       clone.sgaOperator = (SGAOperator)cloner.Clone(sgaOperator);
       return clone;
+    }
+
+    private void ElitesParameter_ValueChanged(object sender, EventArgs e) {
+      SelectorParameter.ValidValues.Select(x => x.NumberOfSelectedSubScopesParameter.Value = new IntData(2 * (PopulationSizeParameter.Value.Value - ElitesParameter.Value.Value)));
+    }
+    private void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
+      SelectorParameter.ValidValues.Select(x => x.NumberOfSelectedSubScopesParameter.Value = new IntData(2 * (PopulationSizeParameter.Value.Value - ElitesParameter.Value.Value)));
     }
 
@@ -112 +142 @@
       if (Problem.SolutionCreator is IStochasticOperator) ((IStochasticOperator)Problem.SolutionCreator).RandomParameter.ActualName = "Random";
       if (Problem.Evaluator is IStochasticOperator) ((IStochasticOperator)Problem.Evaluator).RandomParameter.ActualName = "Random";
-      Problem.Operators.Where(x => x is IStochasticOperator).Select(x => (x as IStochasticOperator).RandomParameter.ActualName = "Random");
+      Problem.Operators.OfType<IStochasticOperator>().Select(x => x.RandomParameter.ActualName = "Random");
 
       populationCreator.SolutionCreatorParameter.Value = Problem.SolutionCreator;
-      populationCreator.SolutionEvaluatorParameter.Value = Problem.Evaluator;
+      populationCreator.EvaluatorParameter.Value = Problem.Evaluator;
       sgaOperator.MaximizationParameter.Value = Problem.Maximization;
       sgaOperator.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
-      sgaOperator.SolutionEvaluatorParameter.Value = Problem.Evaluator;
+      sgaOperator.EvaluatorParameter.Value = Problem.Evaluator;
 
-      CrossoverOperatorParameter.ValidValues.Clear();
-      var crossovers = from o in Problem.Operators
-                       where o is ICrossover
-                       select (ICrossover)o;
-      foreach (ICrossover crossover in crossovers)
-        CrossoverOperatorParameter.ValidValues.Add(crossover);
+      SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>().Select(x => x.MaximizationParameter.Value = Problem.Maximization);
+      SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>().Select(x => x.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName);
 
-      MutationOperatorParameter.ValidValues.Clear();
-      var mutators = from o in Problem.Operators
-                     where o is IManipulator
-                     select (IManipulator)o;
-      foreach (IManipulator mutator in mutators)
-        MutationOperatorParameter.ValidValues.Add(mutator);
+      CrossoverParameter.ValidValues.Clear();
+      foreach (ICrossover crossover in Problem.Operators.OfType<ICrossover>())
+        CrossoverParameter.ValidValues.Add(crossover);
+
+      MutatorParameter.ValidValues.Clear();
+      foreach (IManipulator mutator in Problem.Operators.OfType<IManipulator>())
+        MutatorParameter.ValidValues.Add(mutator);
 
       base.OnProblemChanged();
@@ -143 +170 @@
     protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
       if (Problem.Evaluator is IStochasticOperator) ((IStochasticOperator)Problem.Evaluator).RandomParameter.ActualName = "Random";
-      populationCreator.SolutionEvaluatorParameter.Value = Problem.Evaluator;
+      SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>().Select(x => x.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName);
+      populationCreator.EvaluatorParameter.Value = Problem.Evaluator;
       sgaOperator.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
-      sgaOperator.SolutionEvaluatorParameter.Value = Problem.Evaluator;
+      sgaOperator.EvaluatorParameter.Value = Problem.Evaluator;
       base.Problem_EvaluatorChanged(sender, e);
     }
     private void Problem_MaximizationChanged(object sender, EventArgs e) {
       sgaOperator.MaximizationParameter.Value = Problem.Maximization;
+      SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>().Select(x => x.MaximizationParameter.Value = Problem.Maximization);
     }
   }

trunk/sources/HeuristicLab.SGA/3.3/SGAOperator.cs

@@ -35 +35 @@
   [Creatable("Test")]
   public class SGAOperator : AlgorithmOperator {
-    [Storable]
-    private ProportionalSelector proportionalSelector;
-
     #region Parameter properties
     public ValueLookupParameter<IRandom> RandomParameter {
@@ -48 +45 @@
       get { return (SubScopesLookupParameter<DoubleData>)Parameters["Quality"]; }
     }
-    public ValueLookupParameter<IOperator> CrossoverOperatorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["CrossoverOperator"]; }
+    public ValueLookupParameter<IOperator> SelectorParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Selector"]; }
+    }
+    public ValueLookupParameter<IOperator> CrossoverParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Crossover"]; }
     }
     public ValueLookupParameter<DoubleData> MutationProbabilityParameter {
       get { return (ValueLookupParameter<DoubleData>)Parameters["MutationProbability"]; }
     }
-    public ValueLookupParameter<IOperator> MutationOperatorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["MutationOperator"]; }
+    public ValueLookupParameter<IOperator> MutatorParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Mutator"]; }
     }
-    public ValueLookupParameter<IOperator> SolutionEvaluatorParameter {
-      get { return (ValueLookupParameter<IOperator>)Parameters["SolutionEvaluator"]; }
+    public ValueLookupParameter<IOperator> EvaluatorParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
     }
     public ValueLookupParameter<IntData> ElitesParameter {
@@ -65 +65 @@
     public ValueLookupParameter<IntData> MaximumGenerationsParameter {
       get { return (ValueLookupParameter<IntData>)Parameters["MaximumGenerations"]; }
+    }
+    public ValueLookupParameter<VariableCollection> ResultsParameter {
+      get { return (ValueLookupParameter<VariableCollection>)Parameters["Results"]; }
     }
     private ScopeParameter CurrentScopeParameter {
@@ -81 +84 @@
       Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "True if the problem is a maximization problem, otherwise false."));
       Parameters.Add(new SubScopesLookupParameter<DoubleData>("Quality", "The value which represents the quality of a solution."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("CrossoverOperator", "The operator used to cross solutions."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
       Parameters.Add(new ValueLookupParameter<DoubleData>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("MutationOperator", "The operator used to mutate solutions."));
-      Parameters.Add(new ValueLookupParameter<IOperator>("SolutionEvaluator", "The operator used to evaluate solutions."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions."));
       Parameters.Add(new ValueLookupParameter<IntData>("Elites", "The numer of elite solutions which are kept in each generation."));
       Parameters.Add(new ValueLookupParameter<IntData>("MaximumGenerations", "The maximum number of generations which should be processed."));
+      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope which represents a population of solutions on which the SGA should be applied."));
       #endregion
@@ -92 +97 @@
       #region Create operator graph
       SubScopesSorter subScopesSorter1 = new SubScopesSorter();
-      proportionalSelector = new ProportionalSelector();
+      Placeholder selector = new Placeholder();
       SequentialSubScopesProcessor sequentialSubScopesProcessor1 = new SequentialSubScopesProcessor();
       ChildrenCreator childrenCreator = new ChildrenCreator();
@@ -108 +113 @@
       IntCounter intCounter = new IntCounter();
       Comparator comparator = new Comparator();
+      ResultsCollector resultsCollector = new ResultsCollector();
       ConditionalBranch conditionalBranch = new ConditionalBranch();
 
@@ -113 +119 @@
       subScopesSorter1.ValueParameter.ActualName = "Quality";
       OperatorGraph.InitialOperator = subScopesSorter1;
-      subScopesSorter1.Successor = proportionalSelector;
+      subScopesSorter1.Successor = selector;
 
-      proportionalSelector.CopySelected = new BoolData(true);
-      proportionalSelector.MaximizationParameter.ActualName = "Maximization";
-      // NOTE: NumberOfSelectedSubScopes is set dynamically when the operator is executed
-      proportionalSelector.QualityParameter.ActualName = "Quality";
-      proportionalSelector.RandomParameter.ActualName = "Random";
-      proportionalSelector.Windowing = new BoolData(true);
-      proportionalSelector.Successor = sequentialSubScopesProcessor1;
+      selector.Name = "Selector";
+      selector.OperatorParameter.ActualName = "Selector";
+      selector.Successor = sequentialSubScopesProcessor1;
 
       sequentialSubScopesProcessor1.Operators.Add(new EmptyOperator());
@@ -133 +135 @@
       uniformSequentialSubScopesProcessor.Successor = subScopesSorter2;
 
-      crossover.Name = "CrossoverOperator";
-      crossover.OperatorParameter.ActualName = "CrossoverOperator";
+      crossover.Name = "Crossover";
+      crossover.OperatorParameter.ActualName = "Crossover";
       crossover.Successor = stochasticBranch;
 
@@ -143 +145 @@
       stochasticBranch.Successor = evaluator;
 
-      mutator.Name = "MutationOperator";
-      mutator.OperatorParameter.ActualName = "MutationOperator";
+      mutator.Name = "Mutator";
+      mutator.OperatorParameter.ActualName = "Mutator";
       mutator.Successor = null;
 
-      evaluator.Name = "SolutionEvaluator";
-      evaluator.OperatorParameter.ActualName = "SolutionEvaluator";
+      evaluator.Name = "Evaluator";
+      evaluator.OperatorParameter.ActualName = "Evaluator";
       evaluator.Successor = subScopesRemover;
 
@@ -178 +180 @@
       comparator.ResultParameter.ActualName = "Terminate";
       comparator.RightSideParameter.ActualName = "MaximumGenerations";
-      comparator.Successor = conditionalBranch;
+      comparator.Successor = resultsCollector;
+
+      SubScopesLookupParameter<DoubleData> quality = new SubScopesLookupParameter<DoubleData>("Qualities");
+      quality.ActualName = "Quality";
+      resultsCollector.CollectedValues.Add(quality);
+      resultsCollector.ResultsParameter.ActualName = "Results";
+      resultsCollector.Successor = conditionalBranch;
 
       conditionalBranch.ConditionParameter.ActualName = "Terminate";
@@ -186 +194 @@
       #endregion
     }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      SGAOperator clone = (SGAOperator)base.Clone(cloner);
-      clone.proportionalSelector = (ProportionalSelector)cloner.Clone(proportionalSelector);
-      return clone;
-    }
-
-    public override IOperation Apply() {
-      int populationSize = CurrentScope.SubScopes.Count;
-      // dynamically set the number of parents which are selected for reproduction
-      proportionalSelector.NumberOfSelectedSubScopesParameter.Value = new IntData(2 * (populationSize - ElitesParameter.ActualValue.Value));
-      return base.Apply();
-    }
   }
 }