source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs @ 15273

using System;

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
  using System.Linq;

  using Common;
  using Configuration;
  using Core;
  using HeuristicLab.Data;
  using HeuristicLab.Encodings.IntegerVectorEncoding;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
  using HeuristicLab.Problems.ProgramSynthesis.Push.ObjectPools.Random;
  using HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator;

  using Interpreter;
  using Optimization;
  using Parameters;
  using Persistence.Default.CompositeSerializers.Storable;

  [StorableClass]
  public abstract class PushProblem : SingleObjectiveBasicProblem<IntegerVectorEncoding> {
    [Storable]
    protected readonly PushConfigurationParameterCollection Config;

    protected PushInterpreterPool Pool;
    protected readonly SeededRandomPool RandomPool = new SeededRandomPool();

    [Storable]
    protected readonly IPushEvaluator PushEvaluator;

    private const string BEST_TRAINING_SOLUTION_RESULT_NAME = "Best Solution";
    private const string TEST_QUALITY_RESULT_NAME = "Test Quality";

    protected PushProblem(IPushEvaluator evaluator) {
      Config = new PushConfigurationParameterCollection();
      PushEvaluator = evaluator;

      InitData();
      InitEvents();
      InitParameters();
      InitEncoding();
      InitOperators();
    }

    [StorableConstructor]
    protected PushProblem(bool deserializing)
      : base(deserializing) {
    }

    protected PushProblem(PushProblem original, Cloner cloner)
      : base(original, cloner) {
      Config = cloner.Clone(original.Config);
      PushEvaluator = cloner.Clone(original.PushEvaluator);

      InitData();
      InitEvents();
    }

    [StorableHook(HookType.AfterDeserialization)]
    // ReSharper disable once UnusedMember.Local
    private void AfterDeserialization() {
      InitData();
      InitEvents();
      InitParameters();
    }

    private void InitData() {
      Pool = new PushInterpreterPool(Environment.ProcessorCount * 2, 4096, 1024, Config);
    }

    private void InitEvents() {
      Config.EnabledExpressionsChanged += EnabledExpressionsChanged;
      Reset += PushProblemReset;
    }

    private void EnabledExpressionsChanged(object sender, EnabledExpressionsChangedEventArgs e) {
      Encoding.Bounds[0, 1] = Config.EnabledExpressions.Count;
      Encoding.BoundsParameter.Value[0, 1] = Config.EnabledExpressions.Count;
    }

    private const string PUSH_CONFIGURATION_PARAMETER_NAME = "PushConfiguration";

    public const string CasesScopeParameterName = "CaseQualities";
    public const string CaseQualitiesScopeParameterName = "CaseQualities";

    private void InitParameters() {
      foreach (var paramater in Config.Parameters) {
        if (!Parameters.ContainsKey(paramater.Name)) {
          Parameters.Add(paramater);
        }
      }

      if (!Parameters.ContainsKey(PUSH_CONFIGURATION_PARAMETER_NAME))
        Parameters.Add(new ValueParameter<IReadOnlyPushConfiguration>(PUSH_CONFIGURATION_PARAMETER_NAME, Config) {
          Hidden = true
        });

      if (!Parameters.ContainsKey(CasesScopeParameterName))
        Parameters.Add(new LookupParameter<BoolArray>(CasesScopeParameterName, "The training cases that have been successfully executed."));

      if (!Parameters.ContainsKey(CaseQualitiesScopeParameterName))
        Parameters.Add(new LookupParameter<DoubleArray>(CaseQualitiesScopeParameterName, "The quality of every single training case for each individual"));
    }

    private void PushProblemReset(object sender, EventArgs e) {
      // clear pools and free reserved memory
      Pool.Clear();
      IndividualMapper.Clear();
      RandomPool.Clear();

      // reset seed
      Config.Seed = 0;
    }

    protected override void OnReset() {
      base.OnReset();

      // clear pools and free reserved memory
      Pool.Clear();
      IndividualMapper.Clear();
      RandomPool.Clear();
      Config.Seed = 0;
    }

    private void InitEncoding() {
      Encoding.Bounds[0, 0] = 0;
      Encoding.Bounds[0, 1] = Config.EnabledExpressions.Count;
      Encoding.Length = Config.MaxPointsInProgram;
    }

    private void InitOperators() {

      var solutionCreator = Operators.OfType<PushSolutionCreator>().FirstOrDefault();

      if (solutionCreator == null) {
        solutionCreator = new PushSolutionCreator();
        Operators.Add(solutionCreator);
      }

      solutionCreator.ErcOptions = Config.ErcOptions;

      if (!Operators.OfType<PushExpressionFrequencyAnalyzer>().Any()) {
        Operators.Add(new PushExpressionFrequencyAnalyzer());
      }

      SolutionCreator = solutionCreator;
    }

    public override bool Maximization { get { return false; } }

    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
      IndividualMapper.Reset();

      var bestQuality = Maximization ? qualities.Max() : qualities.Min();
      var bestIdx = Array.IndexOf(qualities, bestQuality);
      var vector = individuals[bestIdx].IntegerVector();

      var rand = RandomPool.ResetAndAllocate();
      var program = (PushProgram)vector.ToPushProgram(Config, rand).Clone();
      RandomPool.Free(rand);

      rand = RandomPool.ResetAndAllocate();
      var isIndividualBetter = AnalyzeBestTrainingSolution(program, bestQuality, results, rand);
      RandomPool.Free(rand);

      if (isIndividualBetter) {
        rand = RandomPool.ResetAndAllocate();
        AnalyzeBestTestSolution(program, results, rand);
        RandomPool.Free(rand);
      }
    }

    private void AnalyzeBestTestSolution(PushProgram program, ResultCollection results, IRandom random) {
      var testResult = PushEvaluator.EvaluateTraining(Pool, program, random);

      if (!results.ContainsKey(TEST_QUALITY_RESULT_NAME)) {
        results.Add(new Result(TEST_QUALITY_RESULT_NAME, new DoubleValue(testResult.AvgQuality)));
      } else {
        ((DoubleValue)results[TEST_QUALITY_RESULT_NAME].Value).Value = testResult.AvgQuality;
      }
    }

    private bool AnalyzeBestTrainingSolution(PushProgram program, double bestQuality, ResultCollection results, IRandom random) {
      if (!results.ContainsKey(BEST_TRAINING_SOLUTION_RESULT_NAME)) {
        var solution = CreatePushSolution(
            program,
            bestQuality,
            (IRandom)random.Clone(),
            (IReadOnlyPushConfiguration)Config.Clone());

        results.Add(new Result(BEST_TRAINING_SOLUTION_RESULT_NAME, solution));
        return true;
      }

      var currentBestQuality = ((PushSolution)results[BEST_TRAINING_SOLUTION_RESULT_NAME].Value).Quality;

      if ((!Maximization && currentBestQuality > bestQuality) ||
           (Maximization && currentBestQuality < bestQuality)) {
        results[BEST_TRAINING_SOLUTION_RESULT_NAME].Value = CreatePushSolution(
            program,
            bestQuality,
            random,
            Config);
        return true;
      }

      return false;
    }

    protected abstract PushSolution CreatePushSolution(
      PushProgram program,
      double bestQuality,
      IRandom random,
      IReadOnlyPushConfiguration config);

    public override double Evaluate(Individual individual, IRandom random) {
      // init seed of random pool
      //Interlocked.CompareExchange(ref RandomPool.Seed, random.Next(), 0);
      //Config.Seed = RandomPool.Seed;

      //var rand = RandomPool.ResetAndAllocate();
      var program = individual.ToPushProgram(Config, random);
      //RandomPool.Free(rand);

      //rand = RandomPool.ResetAndAllocate();
      var result = PushEvaluator.EvaluateTraining(Pool, program, random);
      //RandomPool.Free(rand);

      individual[CaseQualitiesScopeParameterName] = new DoubleArray(result.ExampleQualities);

      return result.AvgQuality;
    }
  }
}