Changeset 13361 for branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid

Timestamp:

11/24/15 16:01:02 (9 years ago)

Author:

mkommend

Message:

#2521: Adapted real vector encoding, test function problems, P3, CMA-ES and optimization.

Location:

branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3

Files:

• EvaluationTracker.cs (modified) (6 diffs)
• HillClimber.cs (modified) (2 diffs)
• LinkageCrossover.cs (modified) (2 diffs)
• ParameterlessPopulationPyramid.cs (modified) (3 diffs)

branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs

@@ -22 +22 @@
 
 using System;
-using HeuristicLab.Common;
+using System.Collections.Generic;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
@@ -34 +31 @@
   // B. W. Goldman and W. F. Punch, "Parameter-less Population Pyramid," GECCO, pp. 785–792, 2014
   // and the original source code in C++11 available from: https://github.com/brianwgoldman/Parameter-less_Population_Pyramid
-  internal sealed class EvaluationTracker : SingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> {
-    private readonly ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem;
+  internal sealed class EvaluationTracker : ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> {
+    private readonly ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem;
 
     private int maxEvaluations;
@@ -60 +57 @@
     }
 
-    public new BinaryVectorEncoding Encoding {
+    public BinaryVectorEncoding Encoding {
       get { return problem.Encoding; }
     }
     #endregion
 
-    [StorableConstructor]
-    private EvaluationTracker(bool deserializing) : base(deserializing) { }
-    private EvaluationTracker(EvaluationTracker original, Cloner cloner)
-      : base(original, cloner) {
-      problem = cloner.Clone(original.problem);
-      maxEvaluations = original.maxEvaluations;
-      BestQuality = original.BestQuality;
-      Evaluations = original.Evaluations;
-      BestFoundOnEvaluation = original.BestFoundOnEvaluation;
-      BestSolution = cloner.Clone(BestSolution);
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new EvaluationTracker(this, cloner);
-    }
-    public EvaluationTracker(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, int maxEvaluations) {
+    public EvaluationTracker(ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, int maxEvaluations) {
       this.problem = problem;
       this.maxEvaluations = maxEvaluations;
@@ -86 +69 @@
       Evaluations = 0;
       BestFoundOnEvaluation = 0;
-
-      if (Parameters.ContainsKey("Maximization")) Parameters.Remove("Maximization");
-      Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
     }
 
-    public override double Evaluate(BinaryVector vector, IRandom random) {
+
+
+    public double Evaluate(BinaryVector vector, IRandom random) {
       if (Evaluations >= maxEvaluations) throw new OperationCanceledException("Maximum Evaluation Limit Reached");
       Evaluations++;
@@ -103 +85 @@
     }
 
-    public override bool Maximization {
+    public bool Maximization {
       get {
         if (problem == null) return false;
@@ -110 +92 @@
     }
 
-    public override bool IsBetter(double quality, double bestQuality) {
+    public bool IsBetter(double quality, double bestQuality) {
       return problem.IsBetter(quality, bestQuality);
     }
 
+    public void Analyze(BinaryVector[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      problem.Analyze(individuals, qualities, results, random);
+    }
+
+    public IEnumerable<BinaryVector> GetNeighbors(BinaryVector individual, IRandom random) {
+      return problem.GetNeighbors(individual, random);
+    }
   }
 }

branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HillClimber.cs

@@ -49 +49 @@
 
     public override Type ProblemType {
-      get { return typeof(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>); }
+      get { return typeof(ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector>); }
     }
-    public new ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> Problem {
-      get { return (ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>)base.Problem; }
-      set { base.Problem = value; }
+    public new ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> Problem {
+      get { return (ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector>)base.Problem; }
+      set { base.Problem = (IProblem)value; }
     }
 
@@ -97 +97 @@
     }
     // In the GECCO paper, Section 2.1
-    public static double ImproveToLocalOptimum(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, BinaryVector solution, double fitness, IRandom rand) {
+    public static double ImproveToLocalOptimum(ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, BinaryVector solution, double fitness, IRandom rand) {
       var tried = new HashSet<int>();
       do {

branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageCrossover.cs

@@ -33 +33 @@
   public static class LinkageCrossover {
     // In the GECCO paper, Figure 3
-    public static double ImproveUsingTree(LinkageTree tree, IList<BinaryVector> donors, BinaryVector solution, double fitness, ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, IRandom rand) {
+    public static double ImproveUsingTree(LinkageTree tree, IList<BinaryVector> donors, BinaryVector solution, double fitness, ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, IRandom rand) {
       var options = Enumerable.Range(0, donors.Count).ToArray();
       foreach (var cluster in tree.Clusters) {
@@ -48 +48 @@
     }
 
-    private static double Donate(BinaryVector solution, double fitness, BinaryVector source, IEnumerable<int> cluster, ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, IRandom rand, out bool changed) {
+    private static double Donate(BinaryVector solution, double fitness, BinaryVector source, IEnumerable<int> cluster, ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, IRandom rand, out bool changed) {
       // keep track of which bits flipped to make the donation
       List<int> flipped = new List<int>();

branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs

@@ -45 +45 @@
       get { return typeof(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>); }
     }
-    public new ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> Problem {
-      get { return (ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>)base.Problem; }
-      set { base.Problem = value; }
+    public new ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> Problem {
+      get { return (ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector>)base.Problem; }
+      set { base.Problem = (IProblem)value; }
     }
 
@@ -182 +182 @@
       if (seen.Contains(solution)) return;
       if (level == pyramid.Count) {
-        pyramid.Add(new Population(tracker.Encoding.Length, random));
+        pyramid.Add(new Population(Problem.Encoding.Length, random));
       }
       var copied = (BinaryVector)solution.Clone();
@@ -192 +192 @@
     private double iterate() {
       // Create a random solution
-      BinaryVector solution = new BinaryVector(tracker.Encoding.Length);
+      BinaryVector solution = new BinaryVector(Problem.Encoding.Length);
       for (int i = 0; i < solution.Length; i++) {
         solution[i] = random.Next(2) == 1;