source: branches/2205_OptimizationNetworks/HeuristicLab.Networks.IntegratedOptimization.SurrogateModeling/3.3/FullEvaluationAlgorithm.cs

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
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.TestFunctions;

namespace HeuristicLab.Networks.IntegratedOptimization.SurrogateModeling {
  [Item("Full Evaluation Algorithm", "")]
  [Creatable]
  [StorableClass]
  public sealed class FullEvaluationAlgorithm : BasicAlgorithm {
    private readonly object locker = new object();

    private SemaphoreSlim tickets;
    private LimitedPriorityQueue exploitationQueue;
    private LimitedPriorityQueue explorationQueue;

    public override bool SupportsPause { get { return true; } }

    public override Type ProblemType { get { return typeof(SingleObjectiveTestFunctionProblem); } }
    public new SingleObjectiveTestFunctionProblem Problem {
      get { return (SingleObjectiveTestFunctionProblem)base.Problem; }
      set { base.Problem = value; }
    }

    public Action<RealVector, double> NotifyEvaluation { get; set; }

    #region Parameter Names
    private const string MaxEvaluationsParameterName = "MaxEvaluations";
    private const string MaxConcurrentEvaluationsParameterName = "MaxConcurrentEvaluations";
    private const string MaxBufferLengthParameterName = "MaxBufferLength";
    private const string AdditionalEvaluationDurationParameterName = "AdditionalEvaluationDuration";
    private const string RegressionSolutionParameterName = "RegressionSolution";
    private const string SortAccordingToExpectedImprovementParameterName = "SortAccordingToExpectedImprovement";
    #endregion Parameter Names

    #region Parameters
    public IValueParameter<IntValue> MaxEvaluationsParameter {
      get { return (IValueParameter<IntValue>)Parameters[MaxEvaluationsParameterName]; }
    }

    public IValueParameter<IntValue> MaxConcurrentEvaluationsParameter {
      get { return (IValueParameter<IntValue>)Parameters[MaxConcurrentEvaluationsParameterName]; }
    }

    public IValueParameter<IntValue> MaxBufferLengthParameter {
      get { return (IValueParameter<IntValue>)Parameters[MaxBufferLengthParameterName]; }
    }

    public IValueParameter<TimeSpanValue> AdditionalEvaluationDurationParameter {
      get { return (IValueParameter<TimeSpanValue>)Parameters[AdditionalEvaluationDurationParameterName]; }
    }

    public IValueParameter<IRegressionSolution> RegressionSolutionParameter {
      get { return (IValueParameter<IRegressionSolution>)Parameters[RegressionSolutionParameterName]; }
    }

    public IValueParameter<BoolValue> SortAccordingToExpectedImprovementParameter {
      get { return (IValueParameter<BoolValue>)Parameters[SortAccordingToExpectedImprovementParameterName]; }
    }
    #endregion Parameters

    #region Parameter Properties
    private IntValue MaxEvaluations {
      get { return MaxEvaluationsParameter.Value; }
      set { MaxEvaluationsParameter.Value = value; }
    }

    public int MaxConcurrentEvaluations {
      get { return MaxConcurrentEvaluationsParameter.Value.Value; }
      set { MaxConcurrentEvaluationsParameter.Value.Value = value; }
    }

    public int MaxBufferLength {
      get { return MaxBufferLengthParameter.Value.Value; }
      set { MaxBufferLengthParameter.Value.Value = value; }
    }

    public TimeSpan AdditionalEvaluationDuration {
      get { return AdditionalEvaluationDurationParameter.Value.Value; }
      set { AdditionalEvaluationDurationParameter.Value.Value = value; }
    }

    public IRegressionSolution RegressionSolution {
      get { return RegressionSolutionParameter.Value; }
      set { RegressionSolutionParameter.Value = value; }
    }

    public BoolValue SortAccordingToExpectedImprovement {
      get { return SortAccordingToExpectedImprovementParameter.Value; }
      set { SortAccordingToExpectedImprovementParameter.Value = value; }
    }
    #endregion Parameter Properties

    #region Result Names
    private const string EvaluatedSolutionsResultName = "EvaluatedSolutions";
    private const string EvaluatedExplorationSolutionsResultName = "EvaluatedExplorationSolutions";
    private const string EvaluatedExploitationSolutionsResultName = "EvaluatedExploitationSolutions";
    private const string FullEvaluationQualitiesResultName = "FullEvaluationQualities";
    #endregion Result Names

    #region Results
    private IntValue EvaluatedSolutionsResult {
      get { return (IntValue)Results[EvaluatedSolutionsResultName].Value; }
    }

    private IItemList<RealVector> EvaluatedExplorationSolutionsResult {
      get { return (IItemList<RealVector>)Results[EvaluatedExplorationSolutionsResultName].Value; }
    }

    private IItemList<RealVector> EvaluatedExploitationSolutionsResult {
      get { return (IItemList<RealVector>)Results[EvaluatedExploitationSolutionsResultName].Value; }
    }

    private DataTable FullEvaluationQualitiesResult {
      get { return (DataTable)Results[FullEvaluationQualitiesResultName].Value; }
    }
    #endregion Results

    #region Constructors & Cloning
    [StorableConstructor]
    private FullEvaluationAlgorithm(bool deserializing) : base(deserializing) { }
    private FullEvaluationAlgorithm(FullEvaluationAlgorithm original, Cloner cloner) : base(original, cloner) {
      RegressionSolutionParameter.ValueChanged += RegressionSolutionParameter_ValueChanged;
    }
    public FullEvaluationAlgorithm() {
      Parameters.Add(new ValueParameter<IntValue>(MaxEvaluationsParameterName, new IntValue(200)));
      Parameters.Add(new ValueParameter<IntValue>(MaxConcurrentEvaluationsParameterName, new IntValue(1)));
      Parameters.Add(new ValueParameter<IntValue>(MaxBufferLengthParameterName, new IntValue(100)));
      Parameters.Add(new ValueParameter<TimeSpanValue>(AdditionalEvaluationDurationParameterName, new TimeSpanValue(TimeSpan.FromSeconds(5.0))));
      Parameters.Add(new ValueParameter<IRegressionSolution>(RegressionSolutionParameterName, ""));
      Parameters.Add(new ValueParameter<BoolValue>(SortAccordingToExpectedImprovementParameterName, "", new BoolValue(true)));

      RegressionSolutionParameter.ValueChanged += RegressionSolutionParameter_ValueChanged;

      Problem = new SingleObjectiveTestFunctionProblem();
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new FullEvaluationAlgorithm(this, cloner);
    }
    #endregion Constructors & Cloning

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      RegressionSolutionParameter.ValueChanged += RegressionSolutionParameter_ValueChanged;
    }

    private void RegressionSolutionParameter_ValueChanged(object sender, EventArgs e) {
      lock (exploitationQueue) {
        var points = exploitationQueue.Select(x => x.Item2).ToArray();
        var solution = RegressionSolutionParameter.Value;
        var useExpectedImprovement = SortAccordingToExpectedImprovement.Value;

        var results = ExpectedImprovementHelpers.Evaluate(points, solution, useExpectedImprovement);
        var targets = (useExpectedImprovement ? results.Select(x => -x) : results).ToArray();

        exploitationQueue.Clear();
        for (int i = 0; i < points.Length; i++)
          exploitationQueue.Enqueue(targets[i], points[i]);
      }
    }

    protected override void Initialize(CancellationToken cancellationToken) {
      var maxConcurrentEvals = MaxConcurrentEvaluationsParameter.Value.Value;
      tickets = new SemaphoreSlim(maxConcurrentEvals, maxConcurrentEvals);

      var maxBufferLength = MaxBufferLengthParameter.Value.Value;
      exploitationQueue = new LimitedPriorityQueue(maxBufferLength, new LimitedPriorityQueue.AscendingPriorityComparer());
      explorationQueue = new LimitedPriorityQueue(maxBufferLength, new LimitedPriorityQueue.DescendingPriorityComparer());

      Results.Add(new Result(EvaluatedSolutionsResultName, new IntValue(0)));
      Results.Add(new Result(EvaluatedExplorationSolutionsResultName, new ItemList<RealVector>()));
      Results.Add(new Result(EvaluatedExploitationSolutionsResultName, new ItemList<RealVector>()));
      Results.Add(new Result(FullEvaluationQualitiesResultName, new DataTable(FullEvaluationQualitiesResultName) {
        Rows = { new DataRow("Exploration"), new DataRow("Exploitation"), new DataRow("Best") }
      }));
    }

    protected override void Run(CancellationToken cancellationToken) {
      bool doExploration = false;

      while (!cancellationToken.IsCancellationRequested && EvaluatedSolutionsResult.Value < MaxEvaluations.Value) {
        try { tickets.Wait(cancellationToken); } catch (OperationCanceledException) { break; }

        RealVector realVector;
        if (doExploration = !doExploration) {
          lock (explorationQueue) {
            if (explorationQueue.TryDequeue(out realVector)) {
              DoFullEvaluationAsync(realVector, EvaluationSolutionType.Exploration, cancellationToken);
            } else {
              tickets.Release();
            }
          }
        } else {
          lock (exploitationQueue) {
            if (exploitationQueue.TryDequeue(out realVector)) {
              DoFullEvaluationAsync(realVector, EvaluationSolutionType.Exploitation, cancellationToken);
            } else {
              tickets.Release();
            }
          }
        }
      }

      for (int i = 0; i < tickets.CurrentCount; i++) tickets.Release();

      // signal that we are done ...
      NotifyEvaluation(new RealVector(), double.NaN); // TODO: improve this
    }

    #region Helpers
    private enum EvaluationSolutionType { Exploration, Exploitation }

    public void EnqueueForExploitation(RealVector realVector, double priority) {
      lock (exploitationQueue) exploitationQueue.Enqueue(priority, realVector);
    }

    public void EnqueueForExploration(RealVector realVector, double priority) {
      lock (explorationQueue) explorationQueue.Enqueue(priority, realVector);
    }

    private async Task DoFullEvaluationAsync(RealVector realVector, EvaluationSolutionType evaluationSolutionType, CancellationToken cancellationToken) {
      var quality = double.NaN;

      try {
        await Task.Delay(AdditionalEvaluationDurationParameter.Value.Value, cancellationToken);
        quality = Problem.Evaluator.Evaluate(realVector);
      } catch (OperationCanceledException) {
      } finally {
        tickets.Release();
      }

      if (EvaluatedSolutionsResult.Value >= MaxEvaluations.Value) return;

      lock (locker) {
        EvaluatedSolutionsResult.Value++;

        var explorationValues = FullEvaluationQualitiesResult.Rows["Exploration"].Values;
        var actualExplorationValues = explorationValues.Where(x => !double.IsNaN(x));
        var minExplorationValue = actualExplorationValues.Where(x => !double.IsNaN(x)).Any() ? actualExplorationValues.Min() : double.MaxValue;
        var lastExplorationValue = actualExplorationValues.Any() ? actualExplorationValues.Last() : double.NaN;

        var exploitationValues = FullEvaluationQualitiesResult.Rows["Exploitation"].Values;
        var actualExploitationValues = exploitationValues.Where(x => !double.IsNaN(x));
        var minExploitationValue = actualExploitationValues.Any() ? actualExploitationValues.Min() : double.MaxValue;
        var lastExploitationValue = actualExploitationValues.Any() ? actualExploitationValues.Last() : double.NaN;

        switch (evaluationSolutionType) {
          case EvaluationSolutionType.Exploration:
            EvaluatedExplorationSolutionsResult.Add(realVector);
            explorationValues.Add(quality);
            exploitationValues.Add(lastExploitationValue);
            break;
          case EvaluationSolutionType.Exploitation:
            EvaluatedExploitationSolutionsResult.Add(realVector);
            exploitationValues.Add(quality);
            explorationValues.Add(lastExplorationValue);
            break;
          default: throw new ArgumentOutOfRangeException();
        }

        var minEvaluatedValue = Math.Min(minExplorationValue, minExploitationValue);
        var minValue = Math.Min(minEvaluatedValue, quality);

        FullEvaluationQualitiesResult.Rows["Best"].Values.Add(minValue);
      }

      NotifyEvaluation((RealVector)realVector.Clone(), quality);
    }
    #endregion Helpers
  }
}