Changeset 13713 for branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem.Common/3.3

Timestamp:

03/17/16 00:29:30 (9 years ago)

Author:

abeham

Message:

#2457: worked on seeding algorithm instances

Location:

branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem.Common/3.3

Files:

• ExpertSystem.cs (modified) (9 diffs)
• HeuristicLab.OptimizationExpertSystem.Common-3.3.csproj (modified) (2 diffs)
• SeedingStrategyTypes.cs (added)

branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem.Common/3.3/ExpertSystem.cs

@@ -40 +40 @@
 using RunCreationClient = HeuristicLab.Clients.OKB.RunCreation.RunCreationClient;
 using SingleObjectiveOKBProblem = HeuristicLab.Clients.OKB.RunCreation.SingleObjectiveOKBProblem;
+using SingleObjectiveOKBSolution = HeuristicLab.Clients.OKB.RunCreation.SingleObjectiveOKBSolution;
 
 namespace HeuristicLab.OptimizationExpertSystem.Common {
   [Item("Expert-System", "Currently in experimental phase, an expert system that makes algorithm suggestions based on fitness landscape analysis features and an optimization knowledge base.")]
-  [StorableClass]
   [Creatable(CreatableAttribute.Categories.TestingAndAnalysis, Priority = 119)]
   public sealed class ExpertSystem : NamedItem, IStorableContent, INotifyPropertyChanged {
@@ -123 +123 @@
     }
 
-    [Storable(Name = "newSolutionPool")]
-    private CheckedItemList<IScope> solutionPool;
-    public CheckedItemList<IScope> SolutionPool {
-      get { return solutionPool; }
-      set {
-        if (solutionPool == value) return;
-        solutionPool = value;
-        OnPropertyChanged("SolutionPool");
-      }
+    [Storable]
+    private CheckedItemList<IScope> solutionSeedingPool;
+    public CheckedItemList<IScope> SolutionSeedingPool {
+      get { return solutionSeedingPool; }
+      set { solutionSeedingPool = value; }
+    }
+
+    [Storable]
+    private EnumValue<SeedingStrategyTypes> seedingStrategy;
+    public EnumValue<SeedingStrategyTypes> SeedingStrategy {
+      get { return seedingStrategy; }
+      set { seedingStrategy = value; }
     }
     
@@ -167 +170 @@
       }
       currentResult = cloner.Clone(original.currentResult);
-      solutionPool = cloner.Clone(original.solutionPool);
+      solutionSeedingPool = cloner.Clone(original.solutionSeedingPool);
+      seedingStrategy = cloner.Clone(original.seedingStrategy);
       currentInstance = cloner.Clone(original.currentInstance);
       RegisterEventHandlers();
@@ -180 +184 @@
       problemInstances = new RunCollection();
       problem = new SingleObjectiveOKBProblem();
-      solutionPool = new CheckedItemList<IScope>();
       algorithmId2RunMapping = new BidirectionalLookup<long, IRun>();
       algorithmId2AlgorithmInstanceMapping = new BidirectionalDictionary<long, IAlgorithm>();
+      solutionSeedingPool = new CheckedItemList<IScope>();
+      seedingStrategy = new EnumValue<SeedingStrategyTypes>(SeedingStrategyTypes.NoSeeding);
       RegisterEventHandlers();
     }
 
     private void ProblemOnProblemChanged(object sender, EventArgs eventArgs) {
-      if (Problem == null) return;
+      
     }
 
@@ -202 +207 @@
     private void RegisterEventHandlers() {
       problem.ProblemChanged += ProblemOnProblemChanged;
+      problem.Solutions.ItemsAdded += ProblemSolutionsChanged;
+      problem.Solutions.ItemsReplaced += ProblemSolutionsChanged;
+      problem.Solutions.ItemsRemoved += ProblemSolutionsChanged;
+      problem.Solutions.CollectionReset += ProblemSolutionsChanged;
       runs.CollectionReset += InformationChanged;
       runs.ItemsAdded += InformationChanged;
@@ -210 +219 @@
       knowledgeBase.ItemsAdded += InformationChanged;
       knowledgeBase.ItemsRemoved += InformationChanged;
+    }
+
+    private void ProblemSolutionsChanged(object sender, EventArgs e) {
+      foreach (var sol in Problem.Solutions.Select(x => x.Solution).OfType<IScope>()) {
+        if (!SolutionSeedingPool.Contains(sol))
+          SolutionSeedingPool.Add(sol, false);
+      }
     }
 
@@ -354 +370 @@
     };
 
-    public void StartAlgorithmAsync(int index) {
+    public Task StartAlgorithmAsync(int index) {
       var selectedInstance = suggestedInstances[index];
-      var algorithm = (IAlgorithm)selectedInstance.Clone();
-      algorithm.Problem = Problem.CloneProblem();
-      algorithm.Prepare(true);
+      var algorithmClone = (IAlgorithm)selectedInstance.Clone();
+      var problemClone = Problem.CloneProblem() as ISingleObjectiveHeuristicOptimizationProblem;
+      if (problemClone == null) throw new InvalidOperationException("Problem is not of type " + typeof(ISingleObjectiveHeuristicOptimizationProblem).FullName);
+      // TODO: It is assumed the problem instance by default is configured using no preexisting solution creator
+      if (SeedingStrategy.Value != SeedingStrategyTypes.NoSeeding) {
+        if (!SolutionSeedingPool.CheckedItems.Any()) throw new InvalidOperationException("There are no solutions selected for seeding.");
+        // TODO: It would be necessary to specify the solution creator somewhere (property and GUI)
+        var seedingCreator = problemClone.Operators.OfType<IPreexistingSolutionCreator>().FirstOrDefault();
+        if (seedingCreator == null) throw new InvalidOperationException("The problem does not contain a solution creator that allows seeding.");
+        seedingCreator.PreexistingSolutionsParameter.Value.Replace(SolutionSeedingPool.CheckedItems.Select(x => x.Value));
+        seedingCreator.SampleFromPreexistingParameter.Value.Value = SeedingStrategy.Value == SeedingStrategyTypes.SeedBySampling;
+        // TODO: WHY!? WHY??!?
+        ((dynamic)problemClone.SolutionCreatorParameter).Value = (dynamic)seedingCreator;
+      }
+      algorithmClone.Problem = problemClone;
+      algorithmClone.Prepare(true);
       IParameter stopParam;
       var monitorStop = true;
-      if (algorithm.Parameters.TryGetValue("MaximumEvaluations", out stopParam)) {
+      if (algorithmClone.Parameters.TryGetValue("MaximumEvaluations", out stopParam)) {
         var maxEvalParam = stopParam as IValueParameter<Data.IntValue>;
         if (maxEvalParam != null) {
@@ -368 +397 @@
         }
       }
-      algorithm.ExecutionStateChanged += AlgorithmOnExecutionStateChanged;
-      algorithm.ExceptionOccurred += AlgorithmOnExceptionOccurred;
-      if (monitorStop) algorithm.ExecutionTimeChanged += AlgorithmOnExecutionTimeChanged;
-
-      algorithm.Start();
+
+      // TODO: The following can be simplified when we have async implementation patterns for our algorithms:
+      // TODO: The closures can be removed and replaced with private member methods
+      var waitHandle = new AutoResetEvent(false);
+
+      #region EventHandler closures
+      EventHandler exeStateChanged = (sender, e) => {
+        if (algorithmClone.ExecutionState == ExecutionState.Started) {
+          CurrentResult = algorithmClone.Results;
+        } else if (algorithmClone.ExecutionState == ExecutionState.Stopped) {
+          foreach (var solution in algorithmClone.Results.Where(x => x.Name.ToLower().Contains("solution")).Select(x => x.Value).OfType<IScope>()) {
+            Problem.Solutions.Add(new SingleObjectiveOKBSolution(Problem.ProblemId) {
+              Quality = solution.Variables.ContainsKey(Problem.Problem.Evaluator.QualityParameter.ActualName) ? ((DoubleValue)solution.Variables[Problem.Problem.Evaluator.QualityParameter.ActualName].Value).Value : double.NaN,
+              Solution = (IItem)solution.Clone()
+            });
+          }
+          Runs.Add(algorithmClone.Runs.Last());
+          waitHandle.Set();
+        }
+      };
+
+      EventHandler<EventArgs<Exception>> exceptionOccurred = (sender, e) => {
+        waitHandle.Set();
+      };
+
+      EventHandler timeChanged = (sender, e) => {
+        IResult evalSolResult;
+        if (!algorithmClone.Results.TryGetValue("EvaluatedSolutions", out evalSolResult) || !(evalSolResult.Value is Data.IntValue)) return;
+        var evalSols = ((Data.IntValue)evalSolResult.Value).Value;
+        if (evalSols >= MaximumEvaluations && algorithmClone.ExecutionState == ExecutionState.Started)
+          algorithmClone.Stop();
+      };
+      #endregion
+
+      algorithmClone.ExecutionStateChanged += exeStateChanged;
+      algorithmClone.ExceptionOccurred += exceptionOccurred;
+      if (monitorStop) algorithmClone.ExecutionTimeChanged += timeChanged;
+
+      return Task.Factory.StartNew(() => {
+        algorithmClone.Start();
+        waitHandle.WaitOne();
+        waitHandle.Dispose();
+      });
     }
 
     public void StartAlgorithm(int index) {
-      var selectedInstance = suggestedInstances[index];
-      var algorithm = (IAlgorithm)selectedInstance.Clone();
-      algorithm.Problem = Problem.CloneProblem();
-      algorithm.Prepare(true);
-      IParameter stopParam;
-      var monitorStop = true;
-      if (algorithm.Parameters.TryGetValue("MaximumEvaluations", out stopParam)) {
-        var maxEvalParam = stopParam as IValueParameter<Data.IntValue>;
-        if (maxEvalParam != null) {
-          maxEvalParam.Value.Value = MaximumEvaluations;
-          monitorStop = false;
-        }
-      }
-      algorithm.ExecutionStateChanged += AlgorithmOnExecutionStateChanged;
-      algorithm.ExceptionOccurred += AlgorithmOnExceptionOccurred;
-      if (monitorStop) algorithm.ExecutionTimeChanged += AlgorithmOnExecutionTimeChanged;
-
-      using (algWh = new AutoResetEvent(false)) {
-        algorithm.Start();
-        algWh.WaitOne();
-      }
-      algWh = null;
-    }
-
-    private AutoResetEvent algWh;
-
-    private void AlgorithmOnExecutionStateChanged(object sender, EventArgs eventArgs) {
-      var alg = sender as IAlgorithm;
-      if (alg == null) return;
-      if (alg.ExecutionState == ExecutionState.Started) {
-        CurrentResult = alg.Results;
-      } else if (alg.ExecutionState == ExecutionState.Stopped) {
-        alg.ExecutionStateChanged -= AlgorithmOnExecutionStateChanged;
-        alg.ExceptionOccurred -= AlgorithmOnExceptionOccurred;
-        alg.ExecutionTimeChanged -= AlgorithmOnExecutionTimeChanged;
-        foreach (var solution in alg.Results.Where(x => x.Name.ToLower().Contains("solution")).Select(x => x.Value).OfType<IScope>()) {
-          solutionPool.Add(solution);
-        }
-        Runs.Add(alg.Runs.Last());
-        if (algWh != null) algWh.Set();
-      }
-    }
-
-    private void AlgorithmOnExceptionOccurred(object sender, EventArgs<Exception> eventArgs) {
-      var alg = sender as IAlgorithm;
-      if (alg == null) return;
-      alg.ExecutionStateChanged -= AlgorithmOnExecutionStateChanged;
-      alg.ExceptionOccurred -= AlgorithmOnExceptionOccurred;
-      alg.ExecutionTimeChanged -= AlgorithmOnExecutionTimeChanged;
-      if (algWh != null) algWh.Set();
-    }
-
-    private void AlgorithmOnExecutionTimeChanged(object sender, EventArgs eventArgs) {
-      var alg = sender as IAlgorithm;
-      if (alg == null) return;
-      IResult evalSolResult;
-      if (!alg.Results.TryGetValue("EvaluatedSolutions", out evalSolResult) || !(evalSolResult.Value is Data.IntValue)) return;
-      var evalSols = ((Data.IntValue)evalSolResult.Value).Value;
-      if (evalSols >= MaximumEvaluations) alg.Stop();
+      StartAlgorithmAsync(index).Wait();
     }
 
@@ -613 +622 @@
       }
 
-      suggestedInstances.Clear();
       var instanceLadder = instances.Select(x => (IAlgorithm)x.Value.Clone()).ToList();
       if (Maximization) instanceLadder.Reverse();
-      suggestedInstances.AddRange(instanceLadder);
+      suggestedInstances.Replace(instanceLadder);
     }
 

branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem.Common/3.3/HeuristicLab.OptimizationExpertSystem.Common-3.3.csproj

@@ -109 +109 @@
       <Private>False</Private>
     </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
     <Reference Include="HeuristicLab.Persistence-3.3">
       <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
@@ -140 +145 @@
     <Compile Include="ExpertSystem.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="SeedingStrategyTypes.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
     <Compile Include="ProblemCharacteristicAnalysis\CharacteristicCalculator.cs" />