Changeset 11546 for branches

Timestamp:

11/12/14 23:48:56 (10 years ago)

Author:

mkommend

Message:

#2174: Extracted wiring of real vector operators from the single objective programmable problem to the real encoding.

Location:

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3

Files:

• Encodings/Encoding.cs (modified) (1 diff)
• Encodings/RealEncoding.cs (modified) (7 diffs)
• MultiObjectiveProgrammableProblem.cs (modified) (1 diff)
• SingleObjectiveProgrammableProblem.cs (modified) (7 diffs)

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs

@@ -45 +45 @@
     }
 
-    //public event EventHandler ParameterConfigurationChanged;
+    public event EventHandler ParameterConfigurationChanged;
     protected virtual void OnParameterConfigurationChanged() {
-    //  var handler = ParameterConfigurationChanged;
-    //  if (handler != null) handler(this, EventArgs.Empty);
+      var handler = ParameterConfigurationChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
     }
   }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
@@ -31 +32 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Problems.Programmable {
@@ -42 +44 @@
       get { return lengthParameter; }
       set {
-        if(value == null) throw new ArgumentNullException("Length parameter must not be null.");
+        if (value == null) throw new ArgumentNullException("Length parameter must not be null.");
         if (lengthParameter == value) return;
         lengthParameter = value;
@@ -74 +76 @@
     }
 
-    public ISolutionCreator SolutionCreator {
+    public IRealVectorCreator DefaultSolutionCreator {
       get {
         var creator = new UniformRandomRealVectorCreator();
@@ -83 +85 @@
       }
     }
-      
+
     [StorableConstructor]
     private RealEncoding(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new RealEncoding(this, cloner); }
     private RealEncoding(RealEncoding original, Cloner cloner)
       : base(original, cloner) {
       lengthParameter = cloner.Clone(original.lengthParameter);
       boundsParameter = cloner.Clone(original.boundsParameter);
-    }
+      RegisterParameterEvents();
+    }
+
     public RealEncoding(string name, int length, double min, double max)
       : base(name) {
@@ -101 +111 @@
       lengthParameter = new FixedValueParameter<IntValue>(Name + "Length", new IntValue(length));
       boundsParameter = new ValueParameter<DoubleMatrix>(Name + "Bounds", bounds);
-    }
+      RegisterParameterEvents();
+    }
+
     public RealEncoding(string name, int length, IList<double> min, IList<double> max)
       : base(name) {
@@ -115 +127 @@
       lengthParameter = new FixedValueParameter<IntValue>(Name + "Length", new IntValue(length));
       boundsParameter = new ValueParameter<DoubleMatrix>(Name + "Bounds", bounds);
-    }  
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RealEncoding(this, cloner);
+      RegisterParameterEvents();
     }
 
     private void OnLengthParameterChanged() {
-       //TODO rewire parameters
-    }
-
+      RegisterLengthParameterEvents();
+    }
     private void OnBoundsParameterChanged() {
-      //TODO rewire parameters      
-    }
-
-
+      RegisterBoundsParameterEvents();
+    }
+    private void RegisterParameterEvents()
+    {
+      RegisterLengthParameterEvents();
+      RegisterBoundsParameterEvents();
+    }
+    private void RegisterLengthParameterEvents() {
+      //TODO fire correct event
+      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
+      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
+    }
+    private void RegisterBoundsParameterEvents() {
+      //TODO fire correct event
+      BoundsParameter.ValueChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
+      boundsParameter.Value.ToStringChanged += (o, s) => ConfigureOperators(Enumerable.Empty<IOperator>());
+    }
+
+    public void DiscoverOperators() {
+      var types = new List<Type>()
+      {
+        typeof (IRealVectorCreator),
+        typeof (IRealVectorCrossover),
+        typeof (IRealVectorManipulator),
+        typeof (IRealVectorStdDevStrategyParameterOperator),
+        typeof (IRealVectorParticleCreator),
+        typeof (IRealVectorParticleUpdater),
+        typeof (IRealVectorParticleUpdater),
+      };
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(types, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t)).ToList();
+    }
+
+    public void ConfigureOperators(IEnumerable<IOperator> operators) {
+      ConfigureCreators(operators.OfType<IRealVectorCreator>());
+      ConfigureCrossovers(operators.OfType<IRealVectorCrossover>());
+      ConfigureManipulators(operators.OfType<IRealVectorManipulator>());
+      ConfigureStdDevStrategyParameterOperators(operators.OfType<IRealVectorStdDevStrategyParameterOperator>());
+      ConfigureSwarmUpdaters(operators.OfType<IRealVectorSwarmUpdater>());
+      ConfigureParticleCreators(operators.OfType<IRealVectorParticleCreator>());
+      ConfigureParticleUpdaters(operators.OfType<IRealVectorParticleUpdater>());
+      ConfigureShakingOperators(operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>());
+    }
+
+    private void ConfigureCreators(IEnumerable<IRealVectorCreator> creators) {
+      foreach (var creator in creators) {
+        creator.RealVectorParameter.ActualName = Name;
+        creator.LengthParameter.ActualName = LengthParameter.Name;
+        creator.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureCrossovers(IEnumerable<IRealVectorCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ChildParameter.ActualName = Name;
+        crossover.ParentsParameter.ActualName = Name;
+        crossover.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureManipulators(IEnumerable<IRealVectorManipulator> manipulators) {
+      foreach (var manipulator in manipulators) {
+        manipulator.RealVectorParameter.ActualName = Name;
+        manipulator.BoundsParameter.ActualName = BoundsParameter.Name;
+        manipulator.BoundsParameter.Hidden = true;
+        var sm = manipulator as ISelfAdaptiveManipulator;
+        if (sm != null) {
+          var p = sm.StrategyParameterParameter as ILookupParameter;
+          if (p != null) {
+            p.ActualName = Name + "Strategy";
+            p.Hidden = true;
+          }
+        }
+      }
+    }
+    private void ConfigureStdDevStrategyParameterOperators(IEnumerable<IRealVectorStdDevStrategyParameterOperator> strategyOperators) {
+      var bounds = (DoubleMatrix)Bounds.Clone();
+      for (var i = 0; i < bounds.Rows; i++) {
+        bounds[i, 1] = 0.1 * (bounds[i, 1] - bounds[i, 0]);
+        bounds[i, 0] = 0;
+      }
+      foreach (var s in strategyOperators) {
+        var c = s as IRealVectorStdDevStrategyParameterCreator;
+        if (c != null) {
+          c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+          c.LengthParameter.ActualName = LengthParameter.Name;
+          c.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+        var m = s as IRealVectorStdDevStrategyParameterManipulator;
+        if (m != null) {
+          m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+          m.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+        var mm = s as StdDevStrategyVectorManipulator;
+        if (mm != null) {
+          mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Length));
+          mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(Length)));
+        }
+        var x = s as IRealVectorStdDevStrategyParameterCrossover;
+        if (x != null) {
+          x.ParentsParameter.ActualName = Name + "Strategy";
+          x.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+      }
+    }
+    private void ConfigureSwarmUpdaters(IEnumerable<IRealVectorSwarmUpdater> swarmUpdaters) {
+      foreach (var su in swarmUpdaters) {
+        su.RealVectorParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureParticleCreators(IEnumerable<IRealVectorParticleCreator> particleCreators) {
+      foreach (var particleCreator in particleCreators) {
+        particleCreator.RealVectorParameter.ActualName = Name;
+        particleCreator.BoundsParameter.ActualName = BoundsParameter.Name;
+        particleCreator.ProblemSizeParameter.ActualName = LengthParameter.Name;
+      }
+    }
+    private void ConfigureParticleUpdaters(IEnumerable<IRealVectorParticleUpdater> particleUpdaters) {
+      foreach (var particleUpdater in particleUpdaters) {
+        particleUpdater.RealVectorParameter.ActualName = Name;
+        particleUpdater.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+    private void ConfigureShakingOperators(IEnumerable<IRealVectorMultiNeighborhoodShakingOperator> shakingOperators) {
+      foreach (var shakingOperator in shakingOperators) {
+        shakingOperator.RealVectorParameter.ActualName = Name;
+      }
+    }
   }
-}                            
+}

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs

@@ -218 +218 @@
       if (realEnc != null) {
         DynamicEncodingParameters.AddRange(realEnc.EncodingParameters);
-        return realEnc.SolutionCreator;
+        return realEnc.DefaultSolutionCreator;
       }
       #endregion

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs

@@ -107 +107 @@
     private void RegisterEventHandlers() {
       ProblemDefinitionParameter.ValueChanged += ProblemDefinitionParameterOnValueChanged;
-      RegisterHostInstanceChanges();
+      RegisterProblemDefinitionEventHandlers();
     }
 
     private void ProblemDefinitionParameterOnValueChanged(object sender, EventArgs eventArgs) {
-      RegisterHostInstanceChanges();
+      RegisterProblemDefinitionEventHandlers();
       Parameterize();
     }
 
-    private void RegisterHostInstanceChanges() {
+    private void RegisterProblemDefinitionEventHandlers() {
       ProblemDefinitionParameter.Value.ProblemDefinitionChanged += ProblemDefinitionChanged;
-      ProblemDefinitionParameter.Value.NameChanged += ProblemDefinitionHostOnNameChanged;
-    }
-
-    private void ProblemDefinitionHostOnNameChanged(object sender, EventArgs eventArgs) {
+      ProblemDefinitionParameter.Value.NameChanged += ProblemDefinitionNameChanged;
+    }
+
+    private void ProblemDefinitionNameChanged(object sender, EventArgs eventArgs) {
       if (sender != ProblemDefinitionParameter.Value) return;
       Name = ProblemDefinitionParameter.Value.Name;
@@ -182 +182 @@
 
     protected virtual ISolutionCreator ConfigureCreator(Encoding encoding) {
+      #region Configure RealVector Creator
+      var realEnc = encoding as RealEncoding;
+      if (realEnc != null) {
+        DynamicEncodingParameters.AddRange(realEnc.EncodingParameters);
+        return realEnc.DefaultSolutionCreator;
+      }
+      #endregion
       #region Configure MultiEncoding Creator
       var multiEncoding = encoding as MultiEncoding;
@@ -220 +227 @@
       }
       #endregion
-      #region Configure RealVector Creator
-      var realEnc = encoding as RealEncoding;
-      if (realEnc != null) {
-        DynamicEncodingParameters.AddRange(realEnc.EncodingParameters);        
-        return realEnc.SolutionCreator;
-      }
-      #endregion
       #region Configure Permutation Creator
       var permEnc = encoding as PermutationEncoding;
@@ -243 +243 @@
     }
 
+
+    private IEnumerable<IOperator> GetDiscoveredOperators<T>() where T : class,IOperator
+    {
+        return ApplicationManager.Manager.GetInstances<T>()
+            .Except(Operators.OfType<T>(), new TypeEqualityComparer<T>());
+    }
     protected virtual void ConfigureSingleEncodingOperators(ISolutionCreator newCreator, Encoding encoding) {
       // remove all multiencoding operators
@@ -249 +255 @@
                             || x is MultiEncodingCreator);
 
+      #region Configure Operators for RealVectorEncoding
+      var realCreator = newCreator as IRealVectorCreator;
+      var realEncoding = encoding as RealEncoding;
+      if (realEncoding != null) {
+        // do not replace a real vector creator that was manually set
+        if (!(SolutionCreator is IRealVectorCreator)
+            ||
+            ((IRealVectorCreator)SolutionCreator).RealVectorParameter.ActualName !=
+            realCreator.RealVectorParameter.ActualName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+
+        Operators.AddRange(GetDiscoveredOperators<IRealVectorCrossover>());
+        Operators.AddRange(GetDiscoveredOperators<IRealVectorManipulator>());
+        Operators.AddRange(GetDiscoveredOperators<IRealVectorStdDevStrategyParameterOperator>());
+        Operators.AddRange(GetDiscoveredOperators<IRealVectorParticleCreator>());
+        Operators.AddRange(GetDiscoveredOperators<IRealVectorParticleUpdater>());
+        Operators.AddRange(GetDiscoveredOperators<IRealVectorSwarmUpdater>());
+        Operators.AddRange(GetDiscoveredOperators<IRealVectorMultiNeighborhoodShakingOperator>());
+
+        foreach (var su in Operators.OfType<IRealVectorSwarmUpdater>()) {
+          su.MaximizationParameter.ActualName = MaximizationParameter.Name;
+        }
+        realEncoding.ConfigureOperators(Operators.OfType<IOperator>());
+      
+      } else {
+        Operators.RemoveAll(x => x is IRealVectorCrossover
+          || x is IRealVectorManipulator
+          || x is IRealVectorStdDevStrategyParameterOperator
+          || x is IRealVectorParticleCreator
+          || x is IRealVectorParticleUpdater
+          || x is IRealVectorSwarmUpdater
+          || x is IRealVectorMultiNeighborhoodShakingOperator);
+      }
+      #endregion
       #region Configure Operators for BinaryVectorEncoding
       var binCreator = newCreator as IBinaryVectorCreator;
@@ -402 +445 @@
           || x is IIntegerVectorStdDevStrategyParameterOperator
           || x is IIntegerVectorMultiNeighborhoodShakingOperator);
-      }
-      #endregion
-      #region Configure Operators for RealVectorEncoding
-      var realCreator = newCreator as IRealVectorCreator;
-      if (realCreator != null) {
-        var paramName = realCreator.RealVectorParameter.ActualName;
-        // do not replace a real vector creator that was manually set
-        if (!(SolutionCreator is IRealVectorCreator)
-            || ((IRealVectorCreator)SolutionCreator).RealVectorParameter.ActualName != realCreator.RealVectorParameter.ActualName) {
-          Operators.Remove(SolutionCreator);
-          SolutionCreator = newCreator;
-          Operators.Add(SolutionCreator);
-        }
-
-        #region Wire RealVector Crossovers
-        var crossovers = Operators.OfType<IRealVectorCrossover>()
-          .Union(ApplicationManager.Manager.GetInstances<IRealVectorCrossover>(), new TypeEqualityComparer<IRealVectorCrossover>())
-          .ToList();
-        foreach (var xo in crossovers) {
-          xo.ChildParameter.ActualName = paramName;
-          xo.ChildParameter.Hidden = true;
-          xo.ParentsParameter.ActualName = paramName;
-          xo.ParentsParameter.Hidden = true;
-          xo.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
-          xo.BoundsParameter.Hidden = true;
-        }
-        Operators.AddRange(crossovers.Except(Operators.OfType<IRealVectorCrossover>()));
-        #endregion
-        #region Wire RealVector Manipulators
-        var manipulators = Operators.OfType<IRealVectorManipulator>()
-          .Union(ApplicationManager.Manager.GetInstances<IRealVectorManipulator>(), new TypeEqualityComparer<IRealVectorManipulator>())
-          .ToList();
-        foreach (var m in manipulators) {
-          m.RealVectorParameter.ActualName = paramName;
-          m.RealVectorParameter.Hidden = true;
-          m.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
-          m.BoundsParameter.Hidden = true;
-          var sm = m as ISelfAdaptiveManipulator;
-          if (sm != null) {
-            var p = sm.StrategyParameterParameter as ILookupParameter;
-            if (p != null) {
-              p.ActualName = paramName + "Strategy";
-              p.Hidden = true;
-            }
-          }
-        }
-        Operators.AddRange(manipulators.Except(Operators.OfType<IRealVectorManipulator>()));
-        #region Wire RealVector Strategy Parameters for SelfAdaptiveManipulators
-        var strategyOperators = Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()
-          .Union(ApplicationManager.Manager.GetInstances<IRealVectorStdDevStrategyParameterOperator>(), new TypeEqualityComparer<IRealVectorStdDevStrategyParameterOperator>())
-          .ToList();
-        var problemSize = ((RealEncoding)encoding).Length;
-        var bounds = (DoubleMatrix)((RealEncoding)encoding).Bounds.Clone();
-        for (var i = 0; i < bounds.Rows; i++) {
-          bounds[i, 1] = 0.1 * (bounds[i, 1] - bounds[i, 0]);
-          bounds[i, 0] = 0;
-        }
-        foreach (var s in strategyOperators) {
-          var c = s as IRealVectorStdDevStrategyParameterCreator;
-          if (c != null) {
-            c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
-            c.LengthParameter.ActualName = realCreator.LengthParameter.ActualName;
-            c.StrategyParameterParameter.ActualName = paramName + "Strategy";
-          }
-          var m = s as IRealVectorStdDevStrategyParameterManipulator;
-          if (m != null) {
-            m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
-            m.StrategyParameterParameter.ActualName = paramName + "Strategy";
-          }
-          var mm = s as Encodings.RealVectorEncoding.StdDevStrategyVectorManipulator;
-          if (mm != null) {
-            mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * problemSize));
-            mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(problemSize)));
-          }
-          var x = s as IRealVectorStdDevStrategyParameterCrossover;
-          if (x != null) {
-            x.ParentsParameter.ActualName = paramName + "Strategy";
-            x.StrategyParameterParameter.ActualName = paramName + "Strategy";
-          }
-        }
-        Operators.AddRange(strategyOperators.Except(Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()));
-        #endregion
-        #endregion
-        #region Wire RealVector ParticleCreators
-        var particleCreators = Operators.OfType<IRealVectorParticleCreator>()
-          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleCreator>(), new TypeEqualityComparer<IRealVectorParticleCreator>())
-          .ToList();
-        foreach (var pc in particleCreators) {
-          pc.RealVectorParameter.ActualName = paramName;
-          pc.RealVectorParameter.Hidden = true;
-          pc.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
-          pc.BoundsParameter.Hidden = true;
-          pc.ProblemSizeParameter.ActualName = realCreator.LengthParameter.ActualName;
-          pc.ProblemSizeParameter.Hidden = true;
-        }
-        Operators.AddRange(particleCreators.Except(Operators.OfType<IRealVectorParticleCreator>()));
-        #endregion
-        #region Wire RealVector ParticleUpdaters
-        var particleUpdaters = Operators.OfType<IRealVectorParticleUpdater>()
-          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleUpdater>(), new TypeEqualityComparer<IRealVectorParticleUpdater>())
-          .ToList();
-        foreach (var pu in particleUpdaters) {
-          pu.RealVectorParameter.ActualName = paramName;
-          pu.RealVectorParameter.Hidden = true;
-          pu.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
-          pu.BoundsParameter.Hidden = true;
-        }
-        Operators.AddRange(particleUpdaters.Except(Operators.OfType<IRealVectorParticleUpdater>()));
-        #endregion
-        #region Wire RealVector SwarmUpdaters
-        var swarmUpdaters = Operators.OfType<IRealVectorSwarmUpdater>()
-          .Union(ApplicationManager.Manager.GetInstances<IRealVectorSwarmUpdater>(), new TypeEqualityComparer<IRealVectorSwarmUpdater>())
-          .ToList();
-        foreach (var su in swarmUpdaters) {
-          su.RealVectorParameter.ActualName = paramName;
-          su.RealVectorParameter.Hidden = true;
-          su.MaximizationParameter.ActualName = MaximizationParameter.Name;
-          su.MaximizationParameter.Hidden = true;
-        }
-        Operators.AddRange(swarmUpdaters.Except(Operators.OfType<IRealVectorSwarmUpdater>()));
-        #endregion
-        #region Wire RealVector ShakingOperators
-        var shakingOperators = Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()
-          .Union(ApplicationManager.Manager.GetInstances<IRealVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IRealVectorMultiNeighborhoodShakingOperator>())
-          .ToList();
-        foreach (var so in shakingOperators) {
-          so.RealVectorParameter.ActualName = paramName;
-          so.RealVectorParameter.Hidden = true;
-        }
-        Operators.AddRange(shakingOperators.Except(Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()));
-        #endregion
-      } else {
-        Operators.RemoveAll(x => x is IRealVectorCrossover
-          || x is IRealVectorManipulator
-          || x is IRealVectorStdDevStrategyParameterOperator
-          || x is IRealVectorParticleCreator
-          || x is IRealVectorParticleUpdater
-          || x is IRealVectorSwarmUpdater
-          || x is IRealVectorMultiNeighborhoodShakingOperator);
       }
       #endregion
@@ -795 +699 @@
       }
     }
-
     protected virtual void UpdateMoveOperators() {
       if (!Operators.Any(x => x is SingleObjectiveMoveGenerator))