Changeset 12860 for branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem/3.3/ExpertSystem.cs

Timestamp:

08/13/15 16:05:08 (9 years ago)

Author:

abeham

Message:

#2457: worked on expert system

File:

• branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem/3.3/ExpertSystem.cs (moved) (moved from branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem/3.3/ExpertSystemOptimizer.cs) (7 diffs)

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

@@ -24 +24 @@
 using System.Collections.Generic;
 using System.Drawing;
-
+using System.Linq;
+using HeuristicLab.Analysis;
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
@@ -30 +31 @@
 using HeuristicLab.Common;
 using HeuristicLab.Common.Resources;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.OptimizationExpertSystem {
-  [Item("Expert-System Optimizer", "Currently in experimental phase, an expert system that makes algorithm suggestions based on fitness landscape analysis features and an optimization knowledge base.")]
+  [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 = 118)]
-  public sealed class ExpertSystemOptimizer : ParameterizedNamedItem, IOptimizer, IStorableContent, INotifyPropertyChanged {
+  [Creatable(CreatableAttribute.Categories.TestingAndAnalysis, Priority = 119)]
+  public sealed class ExpertSystem : NamedItem, IStorableContent, INotifyPropertyChanged {
 
     public string Filename { get; set; }
@@ -51 +53 @@
         maximumEvaluations = value;
         OnPropertyChanged("MaximumEvaluations");
+        UpdateSuggestions();
       }
     }
@@ -58 +61 @@
     public RunCollection Runs {
       get { return runs; }
-      private set {
-        if (value == null) throw new ArgumentNullException("value");
-        if (runs == value) return;
-        runs = value;
-        OnPropertyChanged("Runs");
-      }
     }
 
     [Storable]
-    private ExecutionState executionState;
-    public ExecutionState ExecutionState {
-      get { return executionState; }
-      private set {
-        if (executionState != value) {
-          executionState = value;
-          OnPropertyChanged("ExecutionState");
-          OnExecutionStateChanged();
-          OnItemImageChanged();
-        }
-      }
+    private ItemList<IAlgorithm> algorithmInstances;
+    public ItemList<IAlgorithm> AlgorithmInstances {
+      get { return algorithmInstances; }
     }
 
     [Storable]
-    private TimeSpan executionTime;
-    public TimeSpan ExecutionTime {
-      get { return executionTime; }
-      private set {
-        if (executionTime == value) return;
-        executionTime = value;
-        OnPropertyChanged("ExecutionTime");
-        OnExecutionTimeChanged();
-      }
-    }
-
-    [Storable]
-    private RunCollection knowledgeBase;
-    public RunCollection KnowledgeBase {
-      get { return knowledgeBase; }
-      private set {
-        if (value == null) throw new ArgumentNullException("value");
-        if (knowledgeBase == value) return;
-        knowledgeBase = value;
-        OnPropertyChanged("KnowledgeBase");
-      }
-    }
-
-    [Storable]
-    private IProblem problem;
-    public IProblem Problem {
+    private ISingleObjectiveHeuristicOptimizationProblem problem;
+    public ISingleObjectiveHeuristicOptimizationProblem Problem {
       get { return problem; }
       set {
@@ -112 +77 @@
         problem = value;
         OnPropertyChanged("Problem");
+        UpdateSuggestions();
       }
     }
@@ -122 +88 @@
     }
 
-    public IEnumerable<IOptimizer> NestedOptimizers {
-      get { return SuggestedInstances; }
+    private bool Maximization {
+      get { return Problem != null && ((IValueParameter<BoolValue>)Problem.MaximizationParameter).Value.Value; }
     }
 
     [StorableConstructor]
-    private ExpertSystemOptimizer(bool deserializing) : base(deserializing) { }
-    private ExpertSystemOptimizer(ExpertSystemOptimizer original, Cloner cloner)
+    private ExpertSystem(bool deserializing) : base(deserializing) { }
+    private ExpertSystem(ExpertSystem original, Cloner cloner)
       : base(original, cloner) {
       runs = cloner.Clone(original.runs);
-      executionState = original.executionState;
-      executionTime = original.executionTime;
-      knowledgeBase = cloner.Clone(original.knowledgeBase);
+      algorithmInstances = cloner.Clone(original.algorithmInstances);
       problem = cloner.Clone(original.problem);
       suggestedInstances = cloner.Clone(original.suggestedInstances);
       readOnlySuggestedInstances = suggestedInstances.AsReadOnly();
+      RegisterEventHandlers();
     }
-    public ExpertSystemOptimizer() {
-      Runs = new RunCollection();
-      KnowledgeBase = new RunCollection();
+    public ExpertSystem() {
+      Name = ItemName;
+      Description = ItemDescription;
+      runs = new RunCollection();
+      algorithmInstances = new ItemList<IAlgorithm>();
       suggestedInstances = new ItemList<IAlgorithm>();
       readOnlySuggestedInstances = suggestedInstances.AsReadOnly();
-      ExecutionState = ExecutionState.Stopped;
-      ExecutionTime = TimeSpan.Zero;
+      RegisterEventHandlers();
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new ExpertSystemOptimizer(this, cloner);
+      return new ExpertSystem(this, cloner);
     }
 
@@ -154 +120 @@
     private void AfterDeserialization() {
       readOnlySuggestedInstances = suggestedInstances.AsReadOnly();
+      RegisterEventHandlers();
     }
 
-    public void Prepare() {
-      Prepare(false);
+    private void RegisterEventHandlers() {
+      runs.CollectionReset += InformationChanged;
+      runs.ItemsAdded += InformationChanged;
+      runs.ItemsRemoved += InformationChanged;
+      runs.Reset += InformationChanged;
+      runs.UpdateOfRunsInProgressChanged += InformationChanged;
+      algorithmInstances.CollectionReset += InformationChanged;
+      algorithmInstances.ItemsAdded += InformationChanged;
+      algorithmInstances.ItemsRemoved += InformationChanged;
     }
 
-    public void Prepare(bool clearRuns) {
-      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused) && (ExecutionState != ExecutionState.Stopped))
-        throw new InvalidOperationException(string.Format("Prepare not allowed in execution state \"{0}\".", ExecutionState));
-      if (clearRuns) Runs.Clear();
-      ExecutionTime = TimeSpan.Zero;
-      ExecutionState = ExecutionState.Prepared;
-      OnPrepared();
+    private void InformationChanged(object sender, EventArgs e) {
+      var runCollection = sender as RunCollection;
+      if (runCollection != null && runCollection.UpdateOfRunsInProgress) return;
+      UpdateSuggestions();
     }
 
-    public void Start() {
-      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
-        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
-      ExecutionState = ExecutionState.Started;
-      OnStarted();
-    }
+    private void UpdateSuggestions() {
+      if (Problem == null) return;
+      var instances = new SortedList<double, IAlgorithm>();
+      foreach (var instance in algorithmInstances) {
+        var relevantRuns = instance.Runs.Where(x => ((StringValue)x.Parameters["Problem Type"]).Value == Problem.GetType().Name);
+        var avgQuality = 0.0;
+        var counter = 0;
+        foreach (var run in relevantRuns) {
+          var performanceGraph = ((IndexedDataTable<double>)run.Results["QualityPerEvaluations"]);
+          try {
+            avgQuality += performanceGraph.Rows.First().Values.TakeWhile(x => x.Item1 < MaximumEvaluations).Last().Item2;
+            counter++;
+          } catch { continue; }
+        }
+        avgQuality /= counter;
+        instances.Add(avgQuality, instance);
+      }
 
-    public void Pause() {
-      if (ExecutionState != ExecutionState.Started)
-        throw new InvalidOperationException(string.Format("Pause not allowed in execution state \"{0}\".", ExecutionState));
-      ExecutionState = ExecutionState.Paused;
-      OnPaused();
-    }
-
-
-    public void Stop() {
-      if ((ExecutionState != ExecutionState.Started) && (ExecutionState != ExecutionState.Paused))
-        throw new InvalidOperationException(string.Format("Stop not allowed in execution state \"{0}\".", ExecutionState));
-      ExecutionState = ExecutionState.Stopped;
-      OnStopped();
-    }
-
-    public event EventHandler Prepared;
-    private void OnPrepared() {
-      var handler = Prepared;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    public event EventHandler Started;
-    private void OnStarted() {
-      var handler = Started;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    public event EventHandler Paused;
-    private void OnPaused() {
-      var handler = Paused;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    public event EventHandler Stopped;
-    private void OnStopped() {
-      var handler = Stopped;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    public event EventHandler<EventArgs<Exception>> ExceptionOccurred;
-    private void OnExceptionOccurred(Exception e) {
-      var handler = ExceptionOccurred;
-      if (handler != null) handler(this, new EventArgs<Exception>(e));
-    }
-
-    public event EventHandler ExecutionStateChanged;
-    private void OnExecutionStateChanged() {
-      var handler = ExecutionStateChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    public event EventHandler ExecutionTimeChanged;
-    private void OnExecutionTimeChanged() {
-      var handler = ExecutionTimeChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
+      suggestedInstances.Clear();
+      var instanceLadder = instances.Select(x => x.Value);
+      suggestedInstances.AddRange(Maximization ? instanceLadder.Reverse() : instanceLadder);
     }