Changeset 15338

Timestamp:

08/22/17 15:01:46 (7 years ago)

Author:

bwerth

Message:

#2745 fixed bug concerning new Start and StartAsync methods; passed CancellationToken to sub algorithms

Location:

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO

Files:

• AdaptiveSamplingAlgorithm.cs (modified) (20 diffs)
• EfficientGlobalOptimizationAlgorithm.cs (modified) (8 diffs)
• EgoUtilities.cs (modified) (3 diffs)
• HeuristicLab.Algorithms.EGO-3.4.csproj (modified) (1 diff)
• InfillCriteria/NeighbourDistance.cs (modified) (2 diffs)
• Interfaces/ICancellableOperator.cs (added)
• Interfaces/IResultsOperator.cs (added)
• Operators/CorrelationAnalyzer.cs (modified) (1 diff)
• Operators/EvaluatedSolutionsAnalyzer.cs (modified) (1 diff)
• Operators/FitnessClusteringAnalyzer.cs (modified) (4 diffs)
• Operators/InfillSolver.cs (modified) (6 diffs)
• Operators/ModelBuilder.cs (modified) (7 diffs)
• Operators/ModelQualityAnalyzer.cs (modified) (1 diff)
• Operators/VariableVariabilityAnalyzer.cs (modified) (1 diff)

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/AdaptiveSamplingAlgorithm.cs

@@ -2 +2 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using HeuristicLab.Algorithms.DataAnalysis;
 using HeuristicLab.Analysis;
@@ -49 +50 @@
     public IValueParameter<Algorithm> InfillOptimizationAlgorithmParameter => Parameters[InfillOptimizationAlgorithmParameterName] as IValueParameter<Algorithm>;
     public IValueParameter<IDataAnalysisAlgorithm<IRegressionProblem>> RegressionAlgorithmParameter => Parameters[RegressionAlgorithmParameterName] as IValueParameter<IDataAnalysisAlgorithm<IRegressionProblem>>;
-    private IFixedValueParameter<MultiAnalyzer> AnalyzerParameter => (IFixedValueParameter<MultiAnalyzer>)Parameters[AnalyzerParameterName];
+    public IFixedValueParameter<MultiAnalyzer> AnalyzerParameter => (IFixedValueParameter<MultiAnalyzer>)Parameters[AnalyzerParameterName];
     public IFixedValueParameter<BoolValue> RemoveDuplicatesParameter => (IFixedValueParameter<BoolValue>)Parameters[RemoveDuplicatesParamterName];
     public IFixedValueParameter<IntValue> MaxModelSizeParameter => (IFixedValueParameter<IntValue>)Parameters[MaxModelSizeParameterName];
@@ -65 +66 @@
     public bool RemoveDuplicates => RemoveDuplicatesParameter.Value.Value;
     public int MaxModelSize => MaxModelSizeParameter.Value.Value;
-    #endregion
-
-    #region Helper Properties
     private SolutionsCreator SolutionsCreator => OperatorGraph.Iterate().OfType<SolutionsCreator>().First();
     #endregion
 
+
+
+    #region Operators
+
+    [Storable]
+    private OperatorList Operators;
+
     #region Preconfigured Analyzers
     [Storable]
@@ -102 +107 @@
     [Storable]
     private SolutionsCreator infillSolutionsCreator;
+    #endregion
     #endregion
 
@@ -123 +129 @@
       modelAnalyzer = cloner.Clone(original.modelAnalyzer);
       fitnessClusterAnalyzer = cloner.Clone(original.fitnessClusterAnalyzer);
+
+      Operators = cloner.Clone(original.Operators);
       Initialize();
     }
@@ -163 +171 @@
 
       #region Create operators
+      Operators = new OperatorList();
+
       var randomCreator = new RandomCreator();
+      Operators.Add(randomCreator);
       var variableCreator = new VariableCreator { Name = "Initialize Variables" };
+      Operators.Add(variableCreator);
       var resultsCollector = new ResultsCollector();
+      Operators.Add(resultsCollector);
       var solutionCreator = new SolutionsCreator { Name = "Create Initial Solutions" };
+      Operators.Add(solutionCreator);
       var analyzerPlaceholder = new Placeholder { Name = "Analyzer (Placeholder)" };
+      Operators.Add(analyzerPlaceholder);
       var evaluationsCounter = new IntCounter { Name = "Increment EvaluatedSolutions" };
+      Operators.Add(evaluationsCounter);
       var solutionsCollectorProcessor = new UniformSubScopesProcessor { Name = "Collect Samples to Dataset" };
+      Operators.Add(solutionsCollectorProcessor);
       var phaseChecker = new ConditionalBranch { Name = "Inital Samples evaluated?" };
+      Operators.Add(phaseChecker);
       var initialPhaseChecker = new Comparator { Name = "Compare Initial Samples to evaluated Solutions" };
+      Operators.Add(initialPhaseChecker);
       var modelbuilder = new ModelBuilder { Name = "Build Model" };
+      Operators.Add(modelbuilder);
+
       sampleCollector = new SampleCollector { Name = "Collect Sample" };
+      Operators.Add(sampleCollector);
       infillSolutionsCreator = new SolutionsCreator { Name = "Create Adaptive Solutions" };
+      Operators.Add(infillSolutionsCreator);
       infillSolver = new InfillSolver();
+      Operators.Add(infillSolver);
+
       var subScopesRemover = new SubScopesRemover();
+      Operators.Add(subScopesRemover);
       var iterationsCounter = new IntCounter { Name = "Increment Iterations" };
+      Operators.Add(iterationsCounter);
       var terminationOperator = new TerminationOperator();
+      Operators.Add(terminationOperator);
       #endregion
 
@@ -218 +246 @@
       modelbuilder.ModelParameter.ActualName = modelVariableName;
       modelbuilder.RegressionAlgorithmParameter.ActualName = RegressionAlgorithmParameter.Name;
-      ParameterizeStochasticOperator(modelbuilder);
+
       modelbuilder.Successor = infillSolutionsCreator;
       modelbuilder.MaxModelSizeParameter.ActualName = MaxModelSizeParameter.Name;
@@ -265 +293 @@
       iterationsCounter.Successor = terminationOperator;
 
-
-
       terminationOperator.TerminatorParameter.ActualName = TerminatorParameter.Name;
       terminationOperator.ContinueBranch = phaseChecker;
-
       #endregion
 
       #region Create analyzers
       singleObjectiveQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      Operators.Add(singleObjectiveQualityAnalyzer);
+
       correlationAnalyzer = new CorrelationAnalyzer();
       correlationAnalyzer.ModelParameter.ActualName = modelVariableName;
+      Operators.Add(correlationAnalyzer);
 
       sampleAnalyzer = new EvaluatedSolutionsAnalyzer();
       sampleAnalyzer.PhaseParameter.ActualName = initialPhaseVariableName;
+      Operators.Add(sampleAnalyzer);
 
       modelAnalyzer = new ModelQualityAnalyzer();
       modelAnalyzer.ModelParameter.ActualName = modelVariableName;
+      Operators.Add(modelAnalyzer);
 
       variabilityAnalyzer = new VariableVariabilityAnalyzer();
       variabilityAnalyzer.DatasetParameter.ActualName = datasetVariableName;
       variabilityAnalyzer.InitialEvaluationsParameter.ActualName = InitialEvaluationsParameter.Name;
+      Operators.Add(variabilityAnalyzer);
 
       fitnessClusterAnalyzer = new FitnessClusteringAnalyzer();
       fitnessClusterAnalyzer.DatasetParameter.ActualName = datasetVariableName;
+      Operators.Add(fitnessClusterAnalyzer);
       #endregion
 
       #region Create terminators
 
-      evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less,
-        new IntValue(1000)) { Name = "Evaluated solutions." };
+      evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(1000)) { Name = "Evaluated solutions." };
+      Operators.Add(evaluationsTerminator);
       qualityTerminator = new SingleObjectiveQualityTerminator { Name = "Quality" };
+      Operators.Add(qualityTerminator);
       executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
-
+      Operators.Add(executionTimeTerminator);
       #endregion
 
@@ -303 +336 @@
       UpdateAnalyzers();
       ParameterizeAnalyzers();
+      ParameterizeStochasticOperators(Operators);
       UpdateTerminators();
       #endregion
@@ -308 +342 @@
       Initialize();
     }
-    #endregion
 
     private void Initialize() {
       if (SingleObjectiveProblem != null) {
-        SingleObjectiveProblem.Evaluator.QualityParameter.ActualNameChanged +=
-         Evaluator_QualityParameter_ActualNameChanged;
+        SingleObjectiveProblem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
       }
-
-      singleObjectiveQualityAnalyzer.CurrentBestQualityParameter.NameChanged +=
-        QualityAnalyzer_CurrentBestQualityParameter_NameChanged;
+      singleObjectiveQualityAnalyzer.CurrentBestQualityParameter.NameChanged += QualityAnalyzer_CurrentBestQualityParameter_NameChanged;
       RegisterParameterEvents();
+    }
+    #endregion
+
+    public override void Start(CancellationToken cancellationToken) {
+      ParameterizeProblemSpecificOperators();
+      ((InfillProblem)InfillOptimizationAlgorithm.Problem).InfillCriterion = InfillCriterion;
+      ParameterizeCancellableOperators(cancellationToken);
+      base.Start(cancellationToken);
+    }
+    public override void Stop() {
+      if (InfillOptimizationAlgorithm.ExecutionState == ExecutionState.Started || InfillOptimizationAlgorithm.ExecutionState == ExecutionState.Paused)
+        InfillOptimizationAlgorithm.Stop();
+      if (RegressionAlgorithm.ExecutionState == ExecutionState.Started || RegressionAlgorithm.ExecutionState == ExecutionState.Paused)
+        RegressionAlgorithm.Stop();
+      base.Stop();
+    }
+    public override void Pause() {
+      if (InfillOptimizationAlgorithm.ExecutionState == ExecutionState.Started) InfillOptimizationAlgorithm.Pause();
+      if (RegressionAlgorithm.ExecutionState == ExecutionState.Started) RegressionAlgorithm.Pause();
+      base.Pause();
     }
 
@@ -328 +378 @@
     }
     private void ParameterizeAnalyzers() {
-      //TODO how to guarantee ResultsParameters and QualityParameters are really there? This seems hardcoded
+      foreach (var op in Operators.OfType<IResultsOperator>()) {
+        op.ResultsParameter.ActualName = "Results";
+        op.ResultsParameter.Hidden = true;
+      }
+
       singleObjectiveQualityAnalyzer.ResultsParameter.ActualName = "Results";
       singleObjectiveQualityAnalyzer.ResultsParameter.Hidden = true;
       singleObjectiveQualityAnalyzer.QualityParameter.Depth = 1;
-      correlationAnalyzer.ResultsParameter.ActualName = "Results";
-      correlationAnalyzer.ResultsParameter.Hidden = true;
       correlationAnalyzer.QualityParameter.Depth = 1;
       correlationAnalyzer.RealVectorParameter.Depth = 1;
-      sampleAnalyzer.ResultsParameter.ActualName = "Results";
-      sampleAnalyzer.ResultsParameter.Hidden = true;
       sampleAnalyzer.QualityParameter.Depth = 1;
       sampleAnalyzer.RealVectorParameter.Depth = 1;
-      modelAnalyzer.ResultsParameter.ActualName = "Results";
-      modelAnalyzer.ResultsParameter.Hidden = true;
-      fitnessClusterAnalyzer.ResultsParameter.ActualName = "Results";
-      fitnessClusterAnalyzer.ResultsParameter.Hidden = true;
-
 
       if (SingleObjectiveProblem == null) return;
@@ -362 +407 @@
       SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
       infillSolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
-    }
-    private void ParameterizeStochasticOperator(IOperator @operator) {
-      var stochasticOperator = @operator as IStochasticOperator;
-      if (stochasticOperator == null) return;
-      stochasticOperator.RandomParameter.ActualName = "Random";
-      stochasticOperator.RandomParameter.Hidden = true;
+      ParameterizeStochasticOperators(new[] { SolutionsCreator, infillSolutionsCreator });
+    }
+    private static void ParameterizeStochasticOperators(IEnumerable<IItem> operators) {
+      foreach (var op in operators.OfType<IStochasticOperator>()) {
+        op.RandomParameter.ActualName = "Random";
+        op.RandomParameter.Hidden = true;
+      }
     }
     private void ParameterizeProblemSpecificOperators() {
@@ -374 +420 @@
       var rcreator = Problem.SolutionCreator as IRealVectorCreator;
       if (rcreator == null) throw new ArgumentException("Adaptive sampling requires real vectors as solution candidates");
+
       infillSolver.LengthParameter.ActualName = rcreator.LengthParameter.ActualName;
       infillSolver.BoundsParameter.ActualName = rcreator.BoundsParameter.ActualName;
-      // if (rcreator.LengthParameter.Value != null)
       infillSolver.LengthParameter.Value = rcreator.LengthParameter.Value;
-      // if (rcreator.BoundsParameter.Value != null)
       infillSolver.BoundsParameter.Value = rcreator.BoundsParameter.Value;
       infillSolver.RealVectorParameter.ActualName = rcreator.RealVectorParameter.ActualName;
@@ -388 +433 @@
       sampleAnalyzer.RealVectorParameter.ActualName = rcreator.RealVectorParameter.ActualName;
     }
-    #endregion
-
-    public override void Start() {
-      ParameterizeProblemSpecificOperators();
-      ((InfillProblem)InfillOptimizationAlgorithm.Problem).InfillCriterion = InfillCriterion;
-      base.Start();
-    }
-    public override void Stop() {
-      if (InfillOptimizationAlgorithm.ExecutionState == ExecutionState.Started || InfillOptimizationAlgorithm.ExecutionState == ExecutionState.Paused)
-        InfillOptimizationAlgorithm.Stop();
-      if (RegressionAlgorithm.ExecutionState == ExecutionState.Started || RegressionAlgorithm.ExecutionState == ExecutionState.Paused)
-        RegressionAlgorithm.Stop();
-      base.Stop();
-    }
-    public override void Pause() {
-      if (InfillOptimizationAlgorithm.ExecutionState == ExecutionState.Started) InfillOptimizationAlgorithm.Pause();
-      if (RegressionAlgorithm.ExecutionState == ExecutionState.Started) RegressionAlgorithm.Pause();
-      base.Pause();
-    }
-
-    #region events
+    private void ParameterizeCancellableOperators(CancellationToken cancellation) {
+      foreach (var op in Operators.OfType<ICancellableOperator>())
+        op.Cancellation = cancellation;
+    }
+
+    private void UnParameterizeCancellableOperators(CancellationToken cancellation) {
+      foreach (var op in Operators.OfType<ICancellableOperator>())
+        op.Cancellation = CancellationToken.None;
+    }
+    #endregion
+
+    #region Events
     private void RegisterParameterEvents() {
       InfillOptimizationAlgorithmParameter.ValueChanged += OnInfillAlgorithmChanged;
@@ -428 +464 @@
       InfillOptimizationAlgorithm.ProblemChanged += OnInfillProblemChanged;
     }
+
     protected override void OnProblemChanged() {
       base.OnProblemChanged();
-      ParameterizeStochasticOperator(Problem.SolutionCreator);
-      foreach (var @operator in Problem.Operators.OfType<IOperator>())
-        ParameterizeStochasticOperator(@operator);
-
-      //TODO ParameterizeIterationBasedOperators();
-
-      ParameterizeSolutionsCreators();
-      ParameterizeAnalyzers();
-      ParameterizeTerminators();
-
-      if (SingleObjectiveProblem != null)
-        SingleObjectiveProblem.Evaluator.QualityParameter.ActualNameChanged +=
-          Evaluator_QualityParameter_ActualNameChanged;
-
+      ParameterizeStochasticOperators(Problem.Operators);
       UpdateAnalyzers();
       UpdateTerminators();
+      ParameterizeSolutionsCreators();
+      if (SingleObjectiveProblem != null)
+        SingleObjectiveProblem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
     }
     protected override void RegisterProblemEvents() {
@@ -460 +487 @@
     protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
       base.Problem_SolutionCreatorChanged(sender, e);
-      ParameterizeStochasticOperator(Problem.SolutionCreator);
-
-      if (SingleObjectiveProblem != null) SingleObjectiveProblem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
-
+      ParameterizeStochasticOperators(Problem.SolutionCreator.ToEnumerable());
+      SingleObjectiveProblem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
       ParameterizeSolutionsCreators();
       ParameterizeAnalyzers();
@@ -469 +494 @@
     protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
       base.Problem_EvaluatorChanged(sender, e);
-      foreach (var @operator in Problem.Operators.OfType<IOperator>())
-        ParameterizeStochasticOperator(@operator);
-
-      UpdateAnalyzers();
-
+      ParameterizeStochasticOperators(Problem.Operators);
       ParameterizeSolutionsCreators();
     }
     protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
       base.Problem_OperatorsChanged(sender, e);
-      //TODO ParameterizeIterationBasedOperators();
+      UpdateAnalyzers();
       UpdateTerminators();
     }
     private void MaximizationParameter_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAnalyzers();
       ParameterizeTerminators();
     }
@@ -490 +512 @@
       ParameterizeTerminators();
     }
+
     #endregion
 
@@ -495 +518 @@
     private void UpdateAnalyzers() {
       Analyzer.Operators.Clear();
-      if (Problem == null) return;
-      if (SingleObjectiveProblem != null) {
-        Analyzer.Operators.Add(singleObjectiveQualityAnalyzer, singleObjectiveQualityAnalyzer.EnabledByDefault);
-        Analyzer.Operators.Add(correlationAnalyzer, correlationAnalyzer.EnabledByDefault);
-        Analyzer.Operators.Add(sampleAnalyzer, sampleAnalyzer.EnabledByDefault);
-        Analyzer.Operators.Add(modelAnalyzer, modelAnalyzer.EnabledByDefault);
-        Analyzer.Operators.Add(variabilityAnalyzer, variabilityAnalyzer.EnabledByDefault);
-        Analyzer.Operators.Add(fitnessClusterAnalyzer, fitnessClusterAnalyzer.EnabledByDefault);
-      }
-      foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>())
+      if (SingleObjectiveProblem == null) return;
+      foreach (var analyzer in Operators.OfType<IAnalyzer>().Concat(SingleObjectiveProblem.Operators.OfType<IAnalyzer>()))
         Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
+      ParameterizeAnalyzers();
     }
     private void UpdateTerminators() {
@@ -519 +535 @@
         }
       };
-      if (Problem != null) {
-        if (SingleObjectiveProblem != null)
-          newTerminators.Add(qualityTerminator,
-            Terminator.Operators.Contains(qualityTerminator) && Terminator.Operators.ItemChecked(qualityTerminator));
+      if (SingleObjectiveProblem != null) {
+        newTerminators.Add(qualityTerminator, Terminator.Operators.Contains(qualityTerminator) && Terminator.Operators.ItemChecked(qualityTerminator));
         foreach (var terminator in Problem.Operators.OfType<ITerminator>())
-          newTerminators.Add(terminator,
-            !Terminator.Operators.Contains(terminator) || Terminator.Operators.ItemChecked(terminator));
+          newTerminators.Add(terminator, !Terminator.Operators.Contains(terminator) || Terminator.Operators.ItemChecked(terminator));
       }
-
       Terminator.Operators.Clear();
       foreach (var newTerminator in newTerminators)
         Terminator.Operators.Add(newTerminator.Key, newTerminator.Value);
-    }
-    #endregion
-
+      ParameterizeTerminators();
+    }
+    #endregion
   }
 

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/EfficientGlobalOptimizationAlgorithm.cs

@@ -45 +45 @@
     public override bool SupportsPause => true;
     public override Type ProblemType => typeof(SingleObjectiveBasicProblem<IEncoding>);
-    public new SingleObjectiveBasicProblem<IEncoding> Problem
-    {
+    public new SingleObjectiveBasicProblem<IEncoding> Problem {
       get { return (SingleObjectiveBasicProblem<IEncoding>)base.Problem; }
       set { base.Problem = value; }
@@ -130 +129 @@
 
     #region ResultsProperties
-    private double ResultsBestQuality
-    {
+    private double ResultsBestQuality {
       get { return ((DoubleValue)Results[BestQualityResultName].Value).Value; }
       set { ((DoubleValue)Results[BestQualityResultName].Value).Value = value; }
     }
-    private RealVector ResultsBestSolution
-    {
+    private RealVector ResultsBestSolution {
       get { return (RealVector)Results[BestSolutionResultName].Value; }
       set { Results[BestSolutionResultName].Value = value; }
     }
-    private int ResultsEvaluations
-    {
+    private int ResultsEvaluations {
       get { return ((IntValue)Results[EvaluatedSoultionsResultName].Value).Value; }
       set { ((IntValue)Results[EvaluatedSoultionsResultName].Value).Value = value; }
     }
-    private int ResultsIterations
-    {
+    private int ResultsIterations {
       get { return ((IntValue)Results[IterationsResultName].Value).Value; }
       set { ((IntValue)Results[IterationsResultName].Value).Value = value; }
@@ -154 +149 @@
     private DataRow ResultsQualitiesWorst => ResultsQualities.Rows[WorstQualitiesRowResultName];
     private DataRow ResultsQualitiesIteration => ResultsQualities.Rows[CurrentQualitiesRowResultName];
-    private IRegressionSolution ResultsModel
-    {
+    private IRegressionSolution ResultsModel {
       get { return (IRegressionSolution)Results[RegressionSolutionResultName].Value; }
       set { Results[RegressionSolutionResultName].Value = value; }
@@ -252 +246 @@
             Samples.Add(Evaluate(t));
             cancellationToken.ThrowIfCancellationRequested();
-          }
-          finally {
+          } finally {
             Analyze();
           }
@@ -271 +264 @@
           }
 
-        }
-        finally {
+        } finally {
           Analyze();
         }
@@ -348 +340 @@
 
       while (solution == null && i++ < 100) {
-        var results = EgoUtilities.SyncRunSubAlgorithm(RegressionAlgorithm, Random.Next(int.MaxValue));
+        var results = EgoUtilities.SyncRunSubAlgorithm(RegressionAlgorithm, Random.Next(int.MaxValue), cancellationToken);
         solution = results.Select(x => x.Value).OfType<IRegressionSolution>().SingleOrDefault();
         cancellationToken.ThrowIfCancellationRequested();
@@ -371 +363 @@
             solution = sol;
           }
-        }
-        catch (ArgumentException) { }
+        } catch (ArgumentException) { }
       }
 
@@ -405 +396 @@
       for (var i = 0; i < InfillOptimizationRestarts; i++) {
         //optimize
-        var res = EgoUtilities.SyncRunSubAlgorithm(InfillOptimizationAlgorithm, Random.Next(int.MaxValue));
+        var res = EgoUtilities.SyncRunSubAlgorithm(InfillOptimizationAlgorithm, Random.Next(int.MaxValue), cancellationToken);
         cancellationToken.ThrowIfCancellationRequested();
         //extract results

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/EgoUtilities.cs

@@ -24 +24 @@
 using System.Linq;
 using System.Threading;
-using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
@@ -64 +63 @@
 
     //Sub-ALgorithms
-    public static ResultCollection SyncRunSubAlgorithm(IAlgorithm alg, int random) {
-
+    public static ResultCollection SyncRunSubAlgorithm(IAlgorithm alg, int random, CancellationToken cancellation) {
       if (alg.Parameters.ContainsKey("SetSeedRandomly") && alg.Parameters.ContainsKey("Seed")) {
         var setSeed = alg.Parameters["SetSeedRandomly"].ActualValue as BoolValue;
@@ -72 +70 @@
         setSeed.Value = false;
         seed.Value = random;
-
       }
-
-
-      EventWaitHandle trigger = new AutoResetEvent(false);
-      Exception ex = null;
-      EventHandler<EventArgs<Exception>> exhandler = (sender, e) => { ex = e.Value; trigger.Set(); };
-      EventHandler stoppedHandler = (sender, e) => trigger.Set();
-
-      alg.ExceptionOccurred -= exhandler; //avoid double attaching in case of pause
-      alg.ExceptionOccurred += exhandler;
-      alg.Stopped -= stoppedHandler;
-      alg.Stopped += stoppedHandler;
-      alg.Paused -= stoppedHandler;
-      alg.Paused += stoppedHandler;
-
       if (alg.ExecutionState != ExecutionState.Paused) alg.Prepare();
-      alg.Start();
-      trigger.WaitOne();
-      alg.ExceptionOccurred -= exhandler;
-      alg.Stopped -= stoppedHandler;
-      if (ex != null) throw ex;
+      alg.Start(cancellation);
       return alg.Results;
     }
 
     //RegressionModel extensions
-    public const double DuplicateResolution = 0.0001;
+    private const double DuplicateResolution = 0.0001;
     public static Dataset GetDataSet(IReadOnlyList<Tuple<RealVector, double>> samples, bool removeDuplicates) {
       if (removeDuplicates) samples = RemoveDuplicates(samples); //TODO duplicate removal leads to incorrect uncertainty values in models

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/HeuristicLab.Algorithms.EGO-3.4.csproj

@@ -118 +118 @@
     <Compile Include="InfillCriteria\InfillCriterionBase.cs" />
     <Compile Include="InfillCriteria\ExpectedImprovement.cs" />
+    <Compile Include="Interfaces\IResultsOperator.cs" />
+    <Compile Include="Interfaces\ICancellableOperator.cs" />
     <Compile Include="Interfaces\IInitialSampling.cs" />
     <Compile Include="Interfaces\ISurrogateAlgorithm.cs" />

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/InfillCriteria/NeighbourDistance.cs

@@ -36 +36 @@
   public class NeighbourDistance : InfillCriterionBase {
 
-    private IVantagePointTree<IEnumerable<double>> Points;
+    private VantagePointTree<IEnumerable<double>> Points;
     #region Constructors, Serialization and Cloning 
     [StorableConstructor]
     protected NeighbourDistance(bool deserializing) : base(deserializing) { }
-
-    protected NeighbourDistance(NeighbourDistance original, Cloner cloner) : base(original, cloner) {
-    }
+    protected NeighbourDistance(NeighbourDistance original, Cloner cloner) : base(original, cloner) { }
     public NeighbourDistance() { }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new NeighbourDistance(this, cloner);
-    }
+    public override IDeepCloneable Clone(Cloner cloner) { return new NeighbourDistance(this, cloner); }
     #endregion
 
@@ -55 +51 @@
       Points.Search(vector, 1, out neighbours, out distances);
       return distances[0];
-      //return RegressionSolution.ProblemData.AllIndices.Min(i => DistanceToSample(vector, i));
     }
 
     public override void Initialize() {
       Points = CreateTree();
-    }
-
-    private double DistanceToSample(RealVector vector, int i) {
-      throw new NotImplementedException();
     }
 

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Operators/CorrelationAnalyzer.cs

@@ -36 +36 @@
   [Item("CorrelationAnalyzer", "Analyzes the correlation between perdictions and actual fitness values")]
   [StorableClass]
-  public class CorrelationAnalyzer : SingleSuccessorOperator, IAnalyzer {
+  public class CorrelationAnalyzer : SingleSuccessorOperator, IAnalyzer, IResultsOperator {
     public override bool CanChangeName => true;
     public bool EnabledByDefault => false;

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Operators/EvaluatedSolutionsAnalyzer.cs

@@ -38 +38 @@
   [Item("EvaluatedSolutionsAnalyzer", "Displays the evaluated Solutions for one or two dimensional problems")]
   [StorableClass]
-  public class EvaluatedSolutionsAnalyzer : SingleSuccessorOperator, IAnalyzer {
+  public class EvaluatedSolutionsAnalyzer : SingleSuccessorOperator, IAnalyzer, IResultsOperator {
     public override bool CanChangeName => true;
     public bool EnabledByDefault => false;

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Operators/FitnessClusteringAnalyzer.cs

@@ -22 +22 @@
 using System;
 using System.Linq;
+using System.Threading;
 using HeuristicLab.Algorithms.DataAnalysis;
 using HeuristicLab.Analysis;
@@ -32 +33 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.DataAnalysis;
-using HeuristicLab.Problems.SurrogateProblem;
 
 namespace HeuristicLab.Algorithms.EGO {
   [Item("FitnessClusteringAnalyzer", "Analyzes the correlation between perdictions and actual fitness values")]
   [StorableClass]
-  public class FitnessClusteringAnalyzer : SingleSuccessorOperator, IAnalyzer, IStochasticOperator {
+  public class FitnessClusteringAnalyzer : SingleSuccessorOperator, IAnalyzer, IStochasticOperator, IResultsOperator {
     public override bool CanChangeName => true;
     public bool EnabledByDefault => false;
@@ -95 +95 @@
         Problem = prob
       };
-      tsne.ClassesParameter.Value.Value = "cluster";
-      var res = EgoUtilities.SyncRunSubAlgorithm(tsne, random.Next());
+      tsne.ClassesNameParameter.Value = tsne.ClassesNameParameter.ValidValues.FirstOrDefault(x => x.Value.Equals("cluster"));
+      var res = EgoUtilities.SyncRunSubAlgorithm(tsne, random.Next(), CancellationToken.None);
       return res.Select(r => r.Value).OfType<ScatterPlot>().First();
     }
@@ -106 +106 @@
       pd.TrainingPartition.Start = 0;
       pd.TrainingPartition.End = dataset.Rows;
-
-      return ObservationWeightedKMeans.CreateKMeansSolution(pd, GetWeights(dataset), KParameter.Value.Value, 1000, random);
+      return KMeansClustering.CreateKMeansSolution(pd, KParameter.Value.Value, 1);
     }
     private double[] GetWeights(ModifiableDataset dataset) {

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Operators/InfillSolver.cs

@@ -21 +21 @@
 
 using System;
+using System.Threading;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -36 +37 @@
   [Item("InfillSolver", "A RealVectorCreator that creates candidates by optimizing an infill-subproblem")]
   [StorableClass]
-  public class InfillSolver : RealVectorCreator {
+  public class InfillSolver : RealVectorCreator, ICancellableOperator {
 
     public ILookupParameter<IAlgorithm> InfillOptimizationAlgorithmParamter => (ILookupParameter<IAlgorithm>)Parameters["InfillAlgorithm"];
@@ -44 +45 @@
     public IFixedValueParameter<DoubleValue> DuplicateCutoffParameter => (IFixedValueParameter<DoubleValue>)Parameters["Duplicates Cutoff"];
     public ILookupParameter<DoubleMatrix> InfillBoundsParameter => (ILookupParameter<DoubleMatrix>)Parameters["InfillBounds"];
+
+    public CancellationToken Cancellation { get; set; }
 
     [StorableConstructor]
@@ -77 +80 @@
     }
 
-    public static RealVector OptimizeInfillProblem(IAlgorithm algorithm, IRegressionSolution model, bool maximization, DoubleMatrix bounds, int length, IRandom random) {
+    private RealVector OptimizeInfillProblem(IAlgorithm algorithm, IRegressionSolution model, bool maximization, DoubleMatrix bounds, int length, IRandom random) {
       var infillProblem = algorithm.Problem as InfillProblem;
       if (infillProblem == null) throw new ArgumentException("The algortihm has no InfillProblem to solve");
@@ -83 +86 @@
       infillProblem.Encoding.Bounds = bounds;
       infillProblem.Initialize(model, maximization);
-      var res = EgoUtilities.SyncRunSubAlgorithm(algorithm, random.Next(int.MaxValue));
+      var res = EgoUtilities.SyncRunSubAlgorithm(algorithm, random.Next(int.MaxValue), Cancellation);
       var v = res[InfillProblem.BestInfillSolutionResultName].Value as RealVector;
       algorithm.Runs.Clear();
@@ -104 +107 @@
 
 
+
   }
 }

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Operators/ModelBuilder.cs

@@ -22 +22 @@
 using System;
 using System.Linq;
+using System.Threading;
 using HeuristicLab.Algorithms.DataAnalysis;
 using HeuristicLab.Common;
@@ -31 +32 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Problems.SurrogateProblem;
 
 namespace HeuristicLab.Algorithms.EGO {
@@ -38 +40 @@
   [Item("ModelBuilder", "Builds a model from a dataset and a given RegressionAlgorithm")]
   [StorableClass]
-  public class ModelBuilder : InstrumentedOperator, IStochasticOperator {
+  public class ModelBuilder : InstrumentedOperator, IStochasticOperator, ICancellableOperator {
     public override bool CanChangeName => true;
+    public CancellationToken Cancellation { get; set; }
 
+    #region Parameter properties
     public ILookupParameter<IDataAnalysisAlgorithm<IRegressionProblem>> RegressionAlgorithmParameter => (ILookupParameter<IDataAnalysisAlgorithm<IRegressionProblem>>)Parameters["RegressionAlgorithm"];
     public ILookupParameter<IRegressionSolution> ModelParameter => (ILookupParameter<IRegressionSolution>)Parameters["Model"];
@@ -47 +51 @@
     public ILookupParameter<IntValue> MaxModelSizeParameter => (ILookupParameter<IntValue>)Parameters["Maximal Model Size"];
     public ILookupParameter<DoubleMatrix> InfillBoundsParameter => (ILookupParameter<DoubleMatrix>)Parameters["InfillBounds"];
+    #endregion
 
     [StorableConstructor]
@@ -93 +98 @@
     }
 
-    private static IRegressionSolution BuildModel(IRandom random, IDataAnalysisAlgorithm<IRegressionProblem> regressionAlgorithm, IDataset dataset, IRegressionSolution oldSolution) {
+    private IRegressionSolution BuildModel(IRandom random, IDataAnalysisAlgorithm<IRegressionProblem> regressionAlgorithm, IDataset dataset, IRegressionSolution oldSolution) {
       //var dataset = EgoUtilities.GetDataSet(dataSamples, RemoveDuplicates);
       var problemdata = new RegressionProblemData(dataset, dataset.VariableNames.Where(x => !x.Equals("output")), "output");
@@ -108 +113 @@
 
       while (solution == null && i++ < 100) {
-        var results = EgoUtilities.SyncRunSubAlgorithm(regressionAlgorithm, random.Next(int.MaxValue));
+        var results = EgoUtilities.SyncRunSubAlgorithm(regressionAlgorithm, random.Next(int.MaxValue), Cancellation);
         solution = results.Select(x => x.Value).OfType<IRegressionSolution>().SingleOrDefault();
       }
 
-      //try creating a model with old hyperparameters and new dataset;
-      var gp = regressionAlgorithm as GaussianProcessRegression;
-      var oldmodel = oldSolution as GaussianProcessRegressionSolution;
-      if (gp != null && oldmodel != null) {
-        var mean = (IMeanFunction)oldmodel.Model.MeanFunction.Clone();
-        var cov = (ICovarianceFunction)oldmodel.Model.CovarianceFunction.Clone();
-        try {
-          var model = new GaussianProcessModel(problemdata.Dataset, problemdata.TargetVariable,
-            problemdata.AllowedInputVariables, problemdata.TrainingIndices, new[] { 0.0 }, mean, cov);
-          model.FixParameters();
-          var sol = new GaussianProcessRegressionSolution(model, problemdata);
-          if (solution == null || solution.TrainingMeanSquaredError > sol.TrainingMeanSquaredError) {
-            solution = sol;
-          }
-        }
-        catch (ArgumentException) { }
-      }
+      if (regressionAlgorithm is GaussianProcessRegression && oldSolution != null)
+        solution = SanitizeGaussianProcess(oldSolution as GaussianProcessRegressionSolution, solution as GaussianProcessRegressionSolution, Cancellation);
+
+      if (regressionAlgorithm is M5RegressionTree && oldSolution != null)
+        solution = SanitizeM5Regression(oldSolution.Model as M5Model, solution, random, Cancellation);
+
 
       regressionAlgorithm.Runs.Clear();
@@ -134 +128 @@
 
     }
+
+    private static IRegressionSolution SanitizeM5Regression(M5Model oldmodel, IRegressionSolution newSolution, IRandom random, CancellationToken cancellation) {
+      var problemdata = newSolution.ProblemData;
+      oldmodel.UpdateLeafModels(problemdata, problemdata.AllIndices, random, cancellation);
+      var oldSolution = oldmodel.CreateRegressionSolution(problemdata);
+      var magicDecision = newSolution.TrainingRSquared < oldSolution.TrainingRSquared - 0.05;
+      return magicDecision ? newSolution : oldmodel.CreateRegressionSolution(problemdata);
+    }
+
+    //try creating a model with old hyperparameters and new dataset;
+    private static IRegressionSolution SanitizeGaussianProcess(GaussianProcessRegressionSolution oldmodel, GaussianProcessRegressionSolution newSolution, CancellationToken cancellation) {
+      var problemdata = newSolution.ProblemData;
+      var mean = (IMeanFunction)oldmodel.Model.MeanFunction.Clone();
+      var cov = (ICovarianceFunction)oldmodel.Model.CovarianceFunction.Clone();
+      try {
+        var model = new GaussianProcessModel(problemdata.Dataset, problemdata.TargetVariable, problemdata.AllowedInputVariables, problemdata.TrainingIndices, new[] { 0.0 }, mean, cov);
+        cancellation.ThrowIfCancellationRequested();
+        model.FixParameters();
+        var sol = new GaussianProcessRegressionSolution(model, problemdata);
+        if (newSolution.TrainingMeanSquaredError > sol.TrainingMeanSquaredError) {
+          newSolution = sol;
+        }
+      } catch (ArgumentException) { }
+      return newSolution;
+    }
+
   }
 }

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Operators/ModelQualityAnalyzer.cs

@@ -35 +35 @@
   [Item("ModelQualityAnalyzer", "Collects RealVectors into a modifiablbe dataset")]
   [StorableClass]
-  public class ModelQualityAnalyzer : SingleSuccessorOperator, IAnalyzer {
+  public class ModelQualityAnalyzer : SingleSuccessorOperator, IAnalyzer, IResultsOperator {
     public override bool CanChangeName => true;
     public bool EnabledByDefault => false;

branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/Operators/VariableVariabilityAnalyzer.cs

@@ -35 +35 @@
   [Item("VariableVariabilityAnalyzer", "Analyzes the correlation between perdictions and actual fitness values")]
   [StorableClass]
-  public class VariableVariabilityAnalyzer : SingleSuccessorOperator, IAnalyzer {
+  public class VariableVariabilityAnalyzer : SingleSuccessorOperator, IAnalyzer, IResultsOperator {
     public override bool CanChangeName => true;
     public bool EnabledByDefault => false;