source: branches/EfficientGlobalOptimization/HeuristicLab.Algorithms.EGO/EfficientGlobalOptimizationAlgorithm.cs @ 15012

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Windows.Forms;
using HeuristicLab.Algorithms.DataAnalysis;
using HeuristicLab.Analysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.RealVectorEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.Instances.DataAnalysis;
using HeuristicLab.Problems.Instances.DataAnalysis.Views;
using HeuristicLab.Random;

namespace HeuristicLab.Algorithms.EGO {
  [StorableClass]
  [Creatable(CreatableAttribute.Categories.Algorithms, Priority = 95)]
  [Item("EfficientGlobalOptimizationAlgortihm", "Solves a problem by sequentially learning a model, solving a subproblem on the model and evaluating the best found solution for this subproblem.")]
  public class EfficientGlobalOptimizationAlgorithm : BasicAlgorithm, ISurrogateAlgorithm<RealVector> {
    #region Basic-Alg-Essentials
    public override bool SupportsPause => true;
    public override Type ProblemType => typeof(SingleObjectiveBasicProblem<IEncoding>);
    public new SingleObjectiveBasicProblem<IEncoding> Problem
    {
      get { return (SingleObjectiveBasicProblem<IEncoding>)base.Problem; }
      set { base.Problem = value; }
    }
    #endregion

    #region ParameterNames
    private const string GenerationSizeParameterName = "GenerationSize";
    private const string InfillCriterionParameterName = "InfillCriterion";
    private const string InfillOptimizationAlgorithmParameterName = "InfillOptimizationAlgorithm";
    private const string InfillOptimizationRestartsParameterName = "InfillOptimizationRestarts";
    private const string InitialEvaluationsParameterName = "Initial Evaluations";
    private const string MaximumEvaluationsParameterName = "Maximum Evaluations";
    private const string MaximumRuntimeParameterName = "Maximum Runtime";
    private const string RegressionAlgorithmParameterName = "RegressionAlgorithm";
    private const string SeedParameterName = "Seed";
    private const string SetSeedRandomlyParameterName = "SetSeedRandomly";
    private const string MaximalDataSetSizeParameterName = "MaximalDataSetSize";
    private const string RemoveDuplicatesParamterName = "RemoveDuplicates";
    private const string InitialSamplesParameterName = "InitialSamplesFile";
    private const string BaselineVectorParameterName = "BaselineVector";
    private const string InitialSamplingPlanParamterName = "InitialSamplingPlan";
    #endregion

    #region ResultNames
    private const string BestQualityResultName = "Best Quality";
    private const string BestSolutionResultName = "Best Solution";
    private const string EvaluatedSoultionsResultName = "EvaluatedSolutions";
    private const string IterationsResultName = "Iterations";
    private const string RegressionSolutionResultName = "Model";
    private const string QualitiesChartResultName = "Qualities";
    private const string BestQualitiesRowResultName = "Best Quality";
    private const string CurrentQualitiesRowResultName = "Current Quality";
    private const string WorstQualitiesRowResultName = "Worst Quality";
    #endregion

    #region TransmissionResultNames
    public const string BestInfillSolutionResultName = "BestInfillSolution";
    public const string BestInfillQualityResultName = "BestInfillQuality";
    #endregion

    #region ParameterProperties
    public IFixedValueParameter<IntValue> GenerationSizeParemeter => Parameters[GenerationSizeParameterName] as IFixedValueParameter<IntValue>;
    public IConstrainedValueParameter<IInfillCriterion> InfillCriterionParameter => Parameters[InfillCriterionParameterName] as IConstrainedValueParameter<IInfillCriterion>;
    public IValueParameter<Algorithm> InfillOptimizationAlgorithmParameter => Parameters[InfillOptimizationAlgorithmParameterName] as IValueParameter<Algorithm>;
    public IFixedValueParameter<IntValue> InfillOptimizationRestartsParemeter => Parameters[InfillOptimizationRestartsParameterName] as IFixedValueParameter<IntValue>;
    public IFixedValueParameter<IntValue> InitialEvaluationsParameter => Parameters[InitialEvaluationsParameterName] as IFixedValueParameter<IntValue>;
    public IFixedValueParameter<IntValue> MaximumEvaluationsParameter => Parameters[MaximumEvaluationsParameterName] as IFixedValueParameter<IntValue>;
    public IFixedValueParameter<IntValue> MaximumRuntimeParameter => Parameters[MaximumRuntimeParameterName] as IFixedValueParameter<IntValue>;
    public IValueParameter<IDataAnalysisAlgorithm<IRegressionProblem>> RegressionAlgorithmParameter => Parameters[RegressionAlgorithmParameterName] as IValueParameter<IDataAnalysisAlgorithm<IRegressionProblem>>;
    public IFixedValueParameter<IntValue> SeedParameter => Parameters[SeedParameterName] as IFixedValueParameter<IntValue>;
    public IFixedValueParameter<BoolValue> SetSeedRandomlyParameter => Parameters[SetSeedRandomlyParameterName] as IFixedValueParameter<BoolValue>;
    public IFixedValueParameter<IntValue> MaximalDataSetSizeParameter => Parameters[MaximalDataSetSizeParameterName] as IFixedValueParameter<IntValue>;
    public IFixedValueParameter<BoolValue> RemoveDuplicatesParameter => Parameters[RemoveDuplicatesParamterName] as IFixedValueParameter<BoolValue>;
    public IFixedValueParameter<FileValue> InitialSamplesParameter => Parameters[InitialSamplesParameterName] as IFixedValueParameter<FileValue>;
    public IValueParameter<RealVector> BaselineVectorParameter => Parameters[BaselineVectorParameterName] as IValueParameter<RealVector>;
    public IConstrainedValueParameter<IInitialSampling> InitialSamplingPlanParameter => Parameters[InitialSamplingPlanParamterName] as IConstrainedValueParameter<IInitialSampling>;
    #endregion

    #region Properties

    public int GenerationSize => GenerationSizeParemeter.Value.Value;
    public IInfillCriterion InfillCriterion => InfillCriterionParameter.Value;
    public Algorithm InfillOptimizationAlgorithm => InfillOptimizationAlgorithmParameter.Value;
    public int InfillOptimizationRestarts => InfillOptimizationRestartsParemeter.Value.Value;
    public int InitialEvaluations => InitialEvaluationsParameter.Value.Value;
    public int MaximumEvaluations => MaximumEvaluationsParameter.Value.Value;
    public int MaximumRuntime => MaximumRuntimeParameter.Value.Value;
    public IDataAnalysisAlgorithm<IRegressionProblem> RegressionAlgorithm => RegressionAlgorithmParameter.Value;
    public int Seed => SeedParameter.Value.Value;
    public bool SetSeedRandomly => SetSeedRandomlyParameter.Value.Value;
    public int MaximalDatasetSize => MaximalDataSetSizeParameter.Value.Value;
    private IEnumerable<Tuple<RealVector, double>> DataSamples => Samples.Count > MaximalDatasetSize && MaximalDatasetSize > 0
      ? Samples.Skip(Samples.Count - MaximalDatasetSize)
      : Samples;

    private bool RemoveDuplicates => RemoveDuplicatesParameter.Value.Value;
    private RealVector BaselineVector => BaselineVectorParameter.Value;
    private IInitialSampling InitialSamplingPlan => InitialSamplingPlanParameter.Value;
    #endregion

    #region StorableProperties
    [Storable]
    private IRandom Random = new MersenneTwister();
    [Storable]
    private List<Tuple<RealVector, double>> Samples;
    [Storable]
    private List<Tuple<RealVector, double>> InitialSamples;
    #endregion

    #region ResultsProperties
    private double ResultsBestQuality
    {
      get { return ((DoubleValue)Results[BestQualityResultName].Value).Value; }
      set { ((DoubleValue)Results[BestQualityResultName].Value).Value = value; }
    }
    private RealVector ResultsBestSolution
    {
      get { return (RealVector)Results[BestSolutionResultName].Value; }
      set { Results[BestSolutionResultName].Value = value; }
    }
    private int ResultsEvaluations
    {
      get { return ((IntValue)Results[EvaluatedSoultionsResultName].Value).Value; }
      set { ((IntValue)Results[EvaluatedSoultionsResultName].Value).Value = value; }
    }
    private int ResultsIterations
    {
      get { return ((IntValue)Results[IterationsResultName].Value).Value; }
      set { ((IntValue)Results[IterationsResultName].Value).Value = value; }
    }
    private DataTable ResultsQualities => (DataTable)Results[QualitiesChartResultName].Value;
    private DataRow ResultsQualitiesBest => ResultsQualities.Rows[BestQualitiesRowResultName];

    private DataRow ResultsQualitiesWorst => ResultsQualities.Rows[WorstQualitiesRowResultName];

    private DataRow ResultsQualitiesIteration => ResultsQualities.Rows[CurrentQualitiesRowResultName];

    private IRegressionSolution ResultsModel
    {
      get { return (IRegressionSolution)Results[RegressionSolutionResultName].Value; }
      set { Results[RegressionSolutionResultName].Value = value; }
    }
    #endregion

    #region HLConstructors
    [StorableConstructor]
    protected EfficientGlobalOptimizationAlgorithm(bool deserializing) : base(deserializing) { }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeseialization() {
      RegisterEventhandlers();
    }
    protected EfficientGlobalOptimizationAlgorithm(EfficientGlobalOptimizationAlgorithm original, Cloner cloner)
      : base(original, cloner) {
      Random = cloner.Clone(Random);
      if (original.Samples != null) Samples = original.Samples.Select(x => new Tuple<RealVector, double>(cloner.Clone(x.Item1), x.Item2)).ToList();
      if (original.InitialSamples != null) Samples = original.InitialSamples.Select(x => new Tuple<RealVector, double>(cloner.Clone(x.Item1), x.Item2)).ToList();
      RegisterEventhandlers();
    }
    public override IDeepCloneable Clone(Cloner cloner) { return new EfficientGlobalOptimizationAlgorithm(this, cloner); }
    public EfficientGlobalOptimizationAlgorithm() {
      var cmaes = new CMAEvolutionStrategy.CMAEvolutionStrategy {
        MaximumGenerations = 300,
        PopulationSize = 50
      };
      var model = new GaussianProcessRegression {
        Problem = new RegressionProblem()
      };
      model.CovarianceFunctionParameter.Value = new CovarianceRationalQuadraticIso();
      Parameters.Add(new FixedValueParameter<IntValue>(MaximumEvaluationsParameterName, "", new IntValue(int.MaxValue)));
      Parameters.Add(new FixedValueParameter<IntValue>(InitialEvaluationsParameterName, "", new IntValue(10)));
      Parameters.Add(new FixedValueParameter<IntValue>(MaximumRuntimeParameterName, "The maximum runtime in seconds after which the algorithm stops. Use -1 to specify no limit for the runtime", new IntValue(-1)));
      Parameters.Add(new FixedValueParameter<IntValue>(SeedParameterName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
      Parameters.Add(new FixedValueParameter<BoolValue>(SetSeedRandomlyParameterName, "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
      Parameters.Add(new ValueParameter<IDataAnalysisAlgorithm<IRegressionProblem>>(RegressionAlgorithmParameterName, "The model used to approximate the problem", model));
      Parameters.Add(new ValueParameter<Algorithm>(InfillOptimizationAlgorithmParameterName, "The algorithm used to solve the expected improvement subproblem", cmaes));
      Parameters.Add(new FixedValueParameter<IntValue>(InfillOptimizationRestartsParameterName, "Number of restarts of the SubAlgortihm to avoid local optima", new IntValue(1)));
      Parameters.Add(new FixedValueParameter<IntValue>(GenerationSizeParameterName, "Number points that are sampled every iteration (stadard EGO: 1)", new IntValue(1)));
      Parameters.Add(new ConstrainedValueParameter<IInfillCriterion>(InfillCriterionParameterName, "Decision what value should decide the next sample"));
      InfillCriterionParameter.ValidValues.Add(new ExpectedImprovement());
      InfillCriterionParameter.ValidValues.Add(new AugmentedExpectedImprovement());
      InfillCriterionParameter.ValidValues.Add(new ExpectedQuality());
      var eqi = new ExpectedQuantileImprovement();
      InfillCriterionParameter.ValidValues.Add(eqi);
      eqi.MaxEvaluationsParameter.Value = MaximumEvaluationsParameter.Value;
      InfillCriterionParameter.ValidValues.Add(new MinimalQuantileCriterium());
      InfillCriterionParameter.ValidValues.Add(new RobustImprovement());
      InfillCriterionParameter.ValidValues.Add(new PluginExpectedImprovement());
      Parameters.Add(new FixedValueParameter<IntValue>(MaximalDataSetSizeParameterName, "The maximum number of sample points used to generate the model. Set 0 or less to use always all samples ", new IntValue(-1)));
      Parameters.Add(new FixedValueParameter<BoolValue>(RemoveDuplicatesParamterName, "Wether duplicate samples should be replaced by a single sample with an averaged quality. This GREATLY decreases the chance of ill conditioned models (unbuildable models) but is not theoretically sound as the model ignores the increasing certainty in this region"));
      Parameters.Add(new FixedValueParameter<FileValue>(InitialSamplesParameterName, "The file specifying some initial samples used to jump start the algorithm. These samples are not counted as evaluations. If InitialEvaluations is more than the samples specified in the file, the rest is uniformly random generated and evaluated.", new FileValue()));
      Parameters.Add(new ValueParameter<RealVector>(BaselineVectorParameterName, "A vector used to create a baseline, this vector is evaluated once and is not part of the modeling process (has no influence on algorithm performance)"));
      var intialSamplingPlans = new ItemSet<IInitialSampling> { new UniformRandomSampling(), new LatinHyperCubeDesign() };
      Parameters.Add(new ConstrainedValueParameter<IInitialSampling>(InitialSamplingPlanParamterName, intialSamplingPlans, intialSamplingPlans.First()));

      SetInfillProblem();
      RegisterEventhandlers();
    }
    #endregion

    protected override void Initialize(CancellationToken cancellationToken) {
      base.Initialize(cancellationToken);
      //encoding
      var enc = Problem.Encoding as RealVectorEncoding;
      if (enc == null) throw new ArgumentException("The EGO algorithm can only be applied to RealVectorEncodings");
      var infillProblem = InfillOptimizationAlgorithm.Problem as InfillProblem;
      if (infillProblem == null) throw new ArgumentException("InfillOptimizationAlgorithm has no InfillProblem. Troubles with Eventhandling?");
      infillProblem.Problem = Problem;


      //random
      if (SetSeedRandomly) SeedParameter.Value.Value = new System.Random().Next();
      Random.Reset(Seed);
      Samples = InitialSamples?.ToList() ?? new List<Tuple<RealVector, double>>();

      //results
      Results.Add(new Result(IterationsResultName, new IntValue(0)));
      Results.Add(new Result(EvaluatedSoultionsResultName, new IntValue(Samples.Count)));
      Results.Add(new Result(BestSolutionResultName, new RealVector(1)));
      Results.Add(new Result(BestQualityResultName, new DoubleValue(Problem.Maximization ? double.MinValue : double.MaxValue)));
      Results.Add(new Result(RegressionSolutionResultName, typeof(IRegressionSolution)));
      var table = new DataTable(QualitiesChartResultName);
      table.Rows.Add(new DataRow(BestQualitiesRowResultName));
      table.Rows.Add(new DataRow(WorstQualitiesRowResultName));
      table.Rows.Add(new DataRow(CurrentQualitiesRowResultName));
      Results.Add(new Result(QualitiesChartResultName, table));
      if (BaselineVector != null && BaselineVector.Length == enc.Length) Results.Add(new Result("BaselineValue", new DoubleValue(Evaluate(BaselineVector).Item2)));



    }

    protected override void Run(CancellationToken cancellationToken) {
      //initial samples
      if (Samples.Count < InitialEvaluations) {
        var points = InitialSamplingPlan.GetSamples(InitialEvaluations - Samples.Count, Samples.Select(x => x.Item1).ToArray(), (RealVectorEncoding)Problem.Encoding, Random);
        foreach (var t in points) {
          try {
            Samples.Add(Evaluate(t));
            cancellationToken.ThrowIfCancellationRequested();
          }
          finally {
            Analyze();
          }
        }
      }
      //adaptive samples
      for (ResultsIterations = 0; ResultsEvaluations < MaximumEvaluations; ResultsIterations++) {
        try {
          ResultsModel = BuildModel(cancellationToken);
          if (ResultsModel == null) break;
          cancellationToken.ThrowIfCancellationRequested();
          for (var i = 0; i < GenerationSize; i++) {
            var samplepoint = OptimizeInfillProblem(cancellationToken);
            var sample = Evaluate(samplepoint);
            Samples.Add(sample);
            cancellationToken.ThrowIfCancellationRequested();
          }

        }
        finally {
          Analyze();
        }
      }
    }

    public void SetInitialSamples(RealVector[] individuals, double[] qualities) {
      InitialSamples = individuals.Zip(qualities, (individual, d) => new Tuple<RealVector, double>(individual, d)).ToList();
    }

    #region Eventhandling
    private void RegisterEventhandlers() {
      DeregisterEventhandlers();
      RegressionAlgorithmParameter.ValueChanged += OnModelAlgorithmChanged;
      InfillOptimizationAlgorithmParameter.ValueChanged += OnInfillOptimizationAlgorithmChanged;
      InfillOptimizationAlgorithm.ProblemChanged += InfillOptimizationProblemChanged;
      InfillCriterionParameter.ValueChanged += InfillCriterionChanged;
      InitialSamplesParameter.ToStringChanged += OnInitialSamplesChanged;


    }
    private void DeregisterEventhandlers() {
      RegressionAlgorithmParameter.ValueChanged -= OnModelAlgorithmChanged;
      InfillOptimizationAlgorithmParameter.ValueChanged -= OnInfillOptimizationAlgorithmChanged;
      InfillOptimizationAlgorithm.ProblemChanged -= InfillOptimizationProblemChanged;
      InfillCriterionParameter.ValueChanged -= InfillCriterionChanged;
      InitialSamplesParameter.ToStringChanged -= OnInitialSamplesChanged;
    }
    private void OnInfillOptimizationAlgorithmChanged(object sender, EventArgs args) {
      SetInfillProblem();
      InfillOptimizationAlgorithm.ProblemChanged -= InfillOptimizationProblemChanged;
      InfillOptimizationAlgorithm.ProblemChanged += InfillOptimizationProblemChanged;
    }
    private void InfillOptimizationProblemChanged(object sender, EventArgs e) {
      InfillOptimizationAlgorithm.ProblemChanged -= InfillOptimizationProblemChanged;
      SetInfillProblem();
      InfillOptimizationAlgorithm.ProblemChanged += InfillOptimizationProblemChanged;
    }
    private void InfillCriterionChanged(object sender, EventArgs e) {
      var infillProblem = InfillOptimizationAlgorithm.Problem as InfillProblem;
      if (infillProblem == null) throw new ArgumentException("InfillOptimizationAlgorithm has no InfillProblem. Troubles with Eventhandling?");
      infillProblem.InfillCriterion = InfillCriterion;
    }
    private void OnModelAlgorithmChanged(object sender, EventArgs args) {
      RegressionAlgorithm.Problem = new RegressionProblem();
    }
    private void OnInitialSamplesChanged(object sender, EventArgs args) {
      IRegressionProblemData samplesData = null;
      using (var importTypeDialog = new RegressionImportTypeDialog()) {
        if (importTypeDialog.ShowDialog() != DialogResult.OK) return;
        samplesData = new RegressionCSVInstanceProvider().ImportData(importTypeDialog.Path, importTypeDialog.ImportType, importTypeDialog.CSVFormat);
        InitialSamplesParameter.ToStringChanged -= OnInitialSamplesChanged;
        InitialSamplesParameter.Value.Value = importTypeDialog.Path;
        InitialSamplesParameter.ToStringChanged -= OnInitialSamplesChanged;

      }



      var solutions = new RealVector[samplesData.Dataset.Rows];
      var qualities = new double[samplesData.Dataset.Rows];
      var inputVariables = samplesData.InputVariables.CheckedItems.ToArray();
      for (var i = 0; i < solutions.Length; i++) {
        qualities[i] = samplesData.Dataset.GetDoubleValue(samplesData.TargetVariable, i);
        solutions[i] = new RealVector(inputVariables.Length);
        for (var j = 0; j < inputVariables.Length; j++) solutions[i][j] = samplesData.Dataset.GetDoubleValue(inputVariables[j].Value.Value, i);
      }

      SetInitialSamples(solutions, qualities);

    }

    protected override void OnExecutionTimeChanged() {
      base.OnExecutionTimeChanged();
      if (CancellationTokenSource == null) return;
      if (MaximumRuntime == -1) return;
      if (ExecutionTime.TotalSeconds > MaximumRuntime) CancellationTokenSource.Cancel();
    }
    public override void Pause() {
      if (InfillOptimizationAlgorithm.ExecutionState == ExecutionState.Started || InfillOptimizationAlgorithm.ExecutionState == ExecutionState.Paused) InfillOptimizationAlgorithm.Stop();
      if (RegressionAlgorithm.ExecutionState == ExecutionState.Started || RegressionAlgorithm.ExecutionState == ExecutionState.Paused) RegressionAlgorithm.Stop();
      base.Pause();
    }
    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();
    }
    protected override void OnProblemChanged() {
      base.OnProblemChanged();
      var infillProblem = InfillOptimizationAlgorithm.Problem as InfillProblem;
      if (infillProblem == null) throw new ArgumentException("InfillOptimizationAlgorithm has no InfillProblem. Troubles with Eventhandling?");
      infillProblem.Problem = Problem;
    }
    #endregion

    #region helpers
    private void SetInfillProblem() {
      var infillProblem = new InfillProblem {
        InfillCriterion = InfillCriterion,
        Problem = Problem
      };
      InfillOptimizationAlgorithm.Problem = infillProblem;
    }
    private IRegressionSolution BuildModel(CancellationToken cancellationToken) {
      var dataset = EgoUtilities.GetDataSet(DataSamples.ToList(), RemoveDuplicates);
      var problemdata = new RegressionProblemData(dataset, dataset.VariableNames.Where(x => !x.Equals("output")), "output");
      problemdata.TrainingPartition.Start = 0;
      problemdata.TrainingPartition.End = dataset.Rows;
      problemdata.TestPartition.Start = dataset.Rows;
      problemdata.TestPartition.End = dataset.Rows;

      //train 
      var problem = (RegressionProblem)RegressionAlgorithm.Problem;
      problem.ProblemDataParameter.Value = problemdata;
      var i = 0;
      IRegressionSolution solution = null;

      while (solution == null && i++ < 100) {  //TODO: Question: Why does GP degenerate to NaN so often? Answer: There is not even the slightest mitigation strategy for "almost duplicates" that ill-condition the covariance matrix.
        var results = EgoUtilities.SyncRunSubAlgorithm(RegressionAlgorithm, Random.Next(int.MaxValue));
        solution = results.Select(x => x.Value).OfType<IRegressionSolution>().SingleOrDefault();
        cancellationToken.ThrowIfCancellationRequested();
      }

      //try creating a model with old hyperparameters and new dataset;
      var gp = RegressionAlgorithm as GaussianProcessRegression;
      var oldmodel = ResultsModel as GaussianProcessRegressionSolution;
      if (gp != null && oldmodel != null) {
        var n = Samples.First().Item1.Length;
        var mean = (IMeanFunction)oldmodel.Model.MeanFunction.Clone();
        var cov = (ICovarianceFunction)oldmodel.Model.CovarianceFunction.Clone();
        if (mean.GetNumberOfParameters(n) != 0 || cov.GetNumberOfParameters(n) != 0) throw new ArgumentException("DEBUG: assumption about fixed paramters wrong");
        var noise = 0.0;
        double[] hyp = { noise };
        try {
          var model = new GaussianProcessModel(problemdata.Dataset, problemdata.TargetVariable,
            problemdata.AllowedInputVariables, problemdata.TrainingIndices, hyp, mean, cov);
          model.FixParameters();
          var sol = new GaussianProcessRegressionSolution(model, problemdata);
          if (solution == null || solution.TrainingMeanSquaredError > sol.TrainingMeanSquaredError) {
            solution = sol;
          }
        }
        catch (ArgumentException) { }
      }


      if (!ResultsQualities.Rows.ContainsKey("DEBUG: Degenerates")) ResultsQualities.Rows.Add(new DataRow("DEBUG: Degenerates"));
      var row = ResultsQualities.Rows["DEBUG: Degenerates"];
      row.Values.Add(i - 1);
      if (solution == null) Results.Add(new Result("Status", new StringValue("The Algorithm did not return a Model")));
      else {
        if (!ResultsQualities.Rows.ContainsKey("DEBUG: RMSE")) ResultsQualities.Rows.Add(new DataRow("DEBUG: RMSE"));
        row = ResultsQualities.Rows["DEBUG: RMSE"];
        row.Values.Add(Math.Sqrt(solution.TrainingMeanSquaredError));
      }

      RegressionAlgorithm.Runs.Clear();
      return solution;
    }
    private RealVector OptimizeInfillProblem(CancellationToken cancellationToken) {
      //parameterize and check InfillProblem
      var infillProblem = InfillOptimizationAlgorithm.Problem as InfillProblem;
      if (infillProblem == null) throw new ArgumentException("InfillOptimizationAlgorithm does not have InfillProblem. Problem with Eventhandling?");
      if (infillProblem.InfillCriterion != InfillCriterion) throw new ArgumentException("InfillCiriterion for Problem is not correct. Problem with Eventhandling?");
      if (infillProblem.Problem != Problem) throw new ArgumentException("Expensive real problem is not correctly set in InfillProblem. Problem with Eventhandling?");
      InfillCriterion.Initialize(ResultsModel, Problem.Maximization, infillProblem.Encoding);

      RealVector bestVector = null;
      var bestValue = infillProblem.Maximization ? double.NegativeInfinity : double.PositiveInfinity;

      for (var i = 0; i < InfillOptimizationRestarts; i++) {
        //optimize
        var res = EgoUtilities.SyncRunSubAlgorithm(InfillOptimizationAlgorithm, Random.Next(int.MaxValue));
        cancellationToken.ThrowIfCancellationRequested();
        //extract results
        if (!res.ContainsKey(BestInfillSolutionResultName)) throw new ArgumentException("The InfillOptimizationAlgorithm did not return a best solution");
        var v = res[BestInfillSolutionResultName].Value as RealVector;
        if (!res.ContainsKey(BestInfillQualityResultName)) throw new ArgumentException("The InfillOptimizationAlgorithm did not return a best quality");
        var d = res[BestInfillQualityResultName].Value as DoubleValue;
        if (d == null || v == null) throw new ArgumentException("The InfillOptimizationAlgorithm did not return the expected result types");

        //check for improvement
        if (infillProblem.Maximization != d.Value > bestValue) continue;
        bestValue = d.Value;
        bestVector = v;
      }

      InfillOptimizationAlgorithm.Runs.Clear();
      return bestVector;
    }
    private Tuple<RealVector, double> Evaluate(RealVector point) {
      return new Tuple<RealVector, double>(point, Problem.Evaluate(GetIndividual(point), Random));
    }
    private void Analyze() {
      ResultsEvaluations = Samples.Count;
      var max = Samples.ArgMax(x => x.Item2);
      var min = Samples.ArgMin(x => x.Item2);
      var best = Samples[Problem.Maximization ? max : min];
      ResultsBestQuality = best.Item2;
      ResultsBestSolution = best.Item1;
      ResultsQualitiesBest.Values.Add(ResultsBestQuality);
      ResultsQualitiesIteration.Values.Add(Samples[Samples.Count - 1].Item2);
      ResultsQualitiesWorst.Values.Add(Samples[Problem.Maximization ? min : max].Item2);
      Problem.Analyze(Samples.Select(x => GetIndividual(x.Item1)).ToArray(), Samples.Select(x => x.Item2).ToArray(), Results, Random);

      if (Samples.Count != 0 && Samples[0].Item1.Length == 2) {
        var plotname = "DEBUG:Sample Distribution";
        var rowInit = "Initial Samples";
        var rowAll = "All Samples";
        if (!Results.ContainsKey(plotname)) Results.Add(new Result(plotname, new ScatterPlot()));
        var plot = Results[plotname].Value as ScatterPlot;
        if (!plot.Rows.ContainsKey(rowInit) && InitialSamples != null && InitialSamples.Count > 0)
          plot.Rows.Add(new ScatterPlotDataRow(rowInit, "samples from inital file (already evaulated)", InitialSamples.Select(x => new Point2D<double>(x.Item1[0], x.Item1[1]))));
        if (!plot.Rows.ContainsKey(rowAll)) plot.Rows.Add(new ScatterPlotDataRow(rowAll, "All samples", new Point2D<double>[0]));
        else { plot.Rows[rowAll].Points.Clear(); }
        plot.Rows[rowAll].Points.AddRange(Samples.Select(x => new Point2D<double>(x.Item1[0], x.Item1[1])));


      }
    }
    private Individual GetIndividual(RealVector r) {
      var scope = new Scope();
      scope.Variables.Add(new Variable(Problem.Encoding.Name, r));
      return new SingleEncodingIndividual(Problem.Encoding, scope);
    }
    #endregion
  }
}