source: branches/OptimizationNetworks/HeuristicLab.Networks.IntegratedOptimization/3.3/TtpNetwork5.cs @ 14600

using System;
using System.Collections.Generic;
using HeuristicLab.Algorithms.CMAEvolutionStrategy;
using HeuristicLab.Algorithms.LocalSearch;
using HeuristicLab.Algorithms.ParameterlessPopulationPyramid;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Core.Networks;
using HeuristicLab.Data;
using HeuristicLab.Optimization;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Networks.IntegratedOptimization {
  [Item("TtpNetwork5", "An optimization network for the TTP.")]
  [Creatable("Optimization Networks")]
  [StorableClass]
  // standard ttp
  // cmaes variegates ksp values (factors)
  // 1) init cmaes (length = ksp.values.length)
  // 2) start cmaes
  // 3) evaluate vector as follows:
  // 4) change ksp values (mult by factor in vector)
  // 5) best ksp
  // 6) best tsp for ksp selection
  // 7) return ttp quality
  public sealed class TtpNetwork5 : Network, IOptimizer {
    #region Nodes
    public TtpOrchestratorNode5 Orchestrator {
      get { return (TtpOrchestratorNode5)Nodes["Orchestrator"]; }
    }

    public OrchestratedAlgorithmNode MetaSolver {
      get { return (OrchestratedAlgorithmNode)Nodes["MetaSolver"]; }
    }

    public OrchestratedAlgorithmNode TspSolver {
      get { return (OrchestratedAlgorithmNode)Nodes["TspSolver"]; }
    }

    public OrchestratedAlgorithmNode KspSolver {
      get { return (OrchestratedAlgorithmNode)Nodes["KspSolver"]; }
    }
    #endregion

    [StorableConstructor]
    private TtpNetwork5(bool deserializing) : base(deserializing) { }
    private TtpNetwork5(TtpNetwork5 original, Cloner cloner) : base(original, cloner) {
      RegisterEvents();
    }

    private void RegisterEvents() {
      MetaSolver.Algorithm.ExecutionStateChanged += OnExecutionStateChanged;
      MetaSolver.Algorithm.ExecutionTimeChanged += OnExecutionTimeChanged;
      MetaSolver.Algorithm.Prepared += OnPrepared;
      MetaSolver.Algorithm.Started += OnStarted;
      MetaSolver.Algorithm.Paused += OnPaused;
      MetaSolver.Algorithm.Stopped += OnStopped;
      MetaSolver.Algorithm.ExceptionOccurred += OnExceptionOccurred;
    }

    public TtpNetwork5() : base("TtpNetwork5") {
      var orchestratorNode = new TtpOrchestratorNode5("Orchestrator");
      Nodes.Add(orchestratorNode);

      var metaSolverNode = new OrchestratedAlgorithmNode("MetaSolver");
      var cmaes = new CMAEvolutionStrategy();
      cmaes.Problem = new VariegationProblem();
      cmaes.MaximumGenerations = 80;
      metaSolverNode.Algorithm = cmaes;
      orchestratorNode.MetaSolverOrchestrationPort.ConnectedPort = metaSolverNode.OrchestrationPort;
      Nodes.Add(metaSolverNode);

      //var tspSolverNode = new OrchestratedAlgorithmNode("TspSolver");
      //var osga = new OffspringSelectionGeneticAlgorithm();
      //osga.Problem = new TourProfitProblem();
      //osga.ComparisonFactorLowerBound.Value = 1.0;
      //osga.ComparisonFactorModifier = null;
      //osga.ComparisonFactorUpperBound.Value = 1.0;
      //var crossover = (MultiPermutationCrossover)(osga.Crossover = osga.CrossoverParameter.ValidValues.First(x => x is MultiPermutationCrossover));
      //foreach (var c in crossover.Operators)
      //  crossover.Operators.SetItemCheckedState(c, c is CosaCrossover || c is OrderCrossover2 || c is PartiallyMatchedCrossover);
      //osga.MaximumSelectionPressure.Value = 200;
      //osga.Mutator = osga.MutatorParameter.ValidValues.First(x => x is MultiPermutationManipulator);
      //osga.PopulationSize.Value = 200;
      //osga.Selector = osga.SelectorParameter.ValidValues.First(x => x is RandomSelector);
      //tspSolverNode.Algorithm = osga;
      //orchestratorNode.TspSolverOrchestrationPort.ConnectedPort = tspSolverNode.OrchestrationPort;
      //Nodes.Add(tspSolverNode);

      var tspSolverNode = new OrchestratedAlgorithmNode("TspSolver");
      var ls = new LocalSearch();
      ls.Problem = new TourProfitProblem();
      ls.MaximumIterations.Value = 100;
      ls.SampleSize.Value = 2000;
      tspSolverNode.Algorithm = ls;
      orchestratorNode.TspSolverOrchestrationPort.ConnectedPort = tspSolverNode.OrchestrationPort;
      Nodes.Add(tspSolverNode);

      var kspSolverNode = new OrchestratedAlgorithmNode("KspSolver");
      var p3 = new ParameterlessPopulationPyramid();
      p3.Problem = orchestratorNode.KspParameter.Value;
      p3.MaximumRuntime = 3;
      kspSolverNode.Algorithm = p3;
      orchestratorNode.KspSolverOrchestrationPort.ConnectedPort = kspSolverNode.OrchestrationPort;
      Nodes.Add(kspSolverNode);

      #region Import
      DoubleMatrix tspCoordinates;
      IntValue kspCapacity; IntArray kspItemWeights; IntArray kspItemValues;
      IntArray ttpAvailability; DoubleValue ttpMinSpeed; DoubleValue ttpMaxSpeed; DoubleValue ttpRentingRatio;
      TtpImporter.ImportTtpInstance(@"ttp-instances\berlin52-ttp\berlin52_n51_uncorr-similar-weights_05.ttp",
          out tspCoordinates,
          out kspCapacity, out kspItemValues, out kspItemWeights,
          out ttpAvailability, out ttpMinSpeed, out ttpMaxSpeed, out ttpRentingRatio);

      var tsp = orchestratorNode.TspParameter.Value;
      tsp.Coordinates = tspCoordinates;

      var ksp = orchestratorNode.KspParameter.Value;
      ksp.KnapsackCapacity = kspCapacity;
      ksp.Encoding.Length = kspItemValues.Length;
      ksp.Values = kspItemValues;
      ksp.Weights = kspItemWeights;

      orchestratorNode.AvailabilityParameter.Value = ttpAvailability;
      orchestratorNode.MinSpeedParameter.Value = ttpMinSpeed;
      orchestratorNode.MaxSpeedParameter.Value = ttpMaxSpeed;
      orchestratorNode.RentingRatioParameter.Value = ttpRentingRatio;
      #endregion

      RegisterEvents();
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new TtpNetwork5(this, cloner);
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      RegisterEvents();
    }

    #region IOptimizer Members
    public RunCollection Runs { get { return MetaSolver.Algorithm.Runs; } }
    public IEnumerable<IOptimizer> NestedOptimizers { get { yield break; } }
    public ExecutionState ExecutionState { get { return MetaSolver.Algorithm.ExecutionState; } }
    public TimeSpan ExecutionTime { get { return MetaSolver.Algorithm.ExecutionTime; } }

    public void Prepare(bool clearRuns) { Prepare(); }
    public void Prepare() { Orchestrator.Prepare(); }
    public void Start() {
      if (MetaSolver.Algorithm.ExecutionState == ExecutionState.Prepared)
        Orchestrator.Prepare();
      Orchestrator.StartAsync();
    }
    public void Pause() { Orchestrator.Pause(); }
    public void Stop() { Orchestrator.Stop(); }
    #endregion

    private void OnExecutionStateChanged(object sender, EventArgs e) { OnExecutionStateChanged(); }
    private void OnExecutionTimeChanged(object sender, EventArgs e) { OnExecutionTimeChanged(); }
    private void OnPrepared(object sender, EventArgs e) { OnPrepared(); }
    private void OnStarted(object sender, EventArgs e) { OnStarted(); }
    private void OnPaused(object sender, EventArgs e) { OnPaused(); }
    private void OnStopped(object sender, EventArgs e) { OnStopped(); }
    private void OnExceptionOccurred(object sender, EventArgs<Exception> e) { OnExceptionOccurred(e.Value); }

    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);
    }

    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 exception) {
      var handler = ExceptionOccurred;
      if (handler != null) handler(this, new EventArgs<Exception>(exception));
    }
  }
}