Changeset 14601 for branches/OptimizationNetworks/HeuristicLab.Networks.IntegratedOptimization.TravelingThief/3.3/TtpNetwork3.cs

Timestamp:

01/24/17 09:31:29 (7 years ago)

Author:

jkarder

Message:

#2205: worked on optimization networks

• created separate project for ttp optimization
• removed some unused classes

Location:

branches/OptimizationNetworks/HeuristicLab.Networks.IntegratedOptimization.TravelingThief

Files:

• . (added)
• 3.3 (added)
• 3.3/TtpNetwork3.cs (moved) (moved from branches/OptimizationNetworks/HeuristicLab.Networks.IntegratedOptimization/3.3/TtpNetwork3.cs) (1 diff)

branches/OptimizationNetworks/HeuristicLab.Networks.IntegratedOptimization.TravelingThief/3.3/TtpNetwork3.cs

@@ -1 @@
-//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.Persistence.Default.CompositeSerializers.Storable;
-
-//namespace HeuristicLab.Networks.IntegratedOptimization {
-//  [Item("TtpNetwork3", "An optimization network for the TTP.")]
-//  [Creatable("Optimization Networks")]
-//  [StorableClass]
-//  // standard ttp
-//  // cmaes variegates ksp values and tsp coordinates
-//  // 1) init cmaes (length = ksp.values.length)
-//  // 2) start cmaes
-//  // 3) evaluate vector as follows:
-//  // 4) change ksp values and tsp coordinates (mult by factor in vector)
-//  // 5) best ksp
-//  // 6) best tsp
-//  // 7) return ttp quality
-//  public sealed class TtpNetwork3 : Network {
-//    [StorableConstructor]
-//    private TtpNetwork3(bool deserializing) : base(deserializing) { }
-//    private TtpNetwork3(TtpNetwork3 original, Cloner cloner) : base(original, cloner) { }
-//    public TtpNetwork3() : base("TtpNetwork3") {
-//      var orchestratorNode = new TtpOrchestratorNode3();
-//      Nodes.Add(orchestratorNode);
-
-//      var metaSolverNode = new OrchestratedAlgorithmNode("MetaSolver");
-//      var cmaes = new CMAEvolutionStrategy();
-//      cmaes.MaximumEvaluatedSolutions = 3000;
-//      cmaes.Engine = new ParallelEngine.ParallelEngine();
-//      metaSolverNode.Algorithm = cmaes;
-//      orchestratorNode.MetaSolverOrchestrationPort.ConnectedPort = metaSolverNode.OrchestrationPort;
-//      Nodes.Add(metaSolverNode);
-
-//      var tspSolverNode = new OrchestratedAlgorithmNode("TspSolver") { CloneAlgorithm = true };
-//      var ls = new LocalSearch();
-//      ls.Problem = orchestratorNode.TspParameter.Value;
-//      ls.MaximumIterations.Value = 100;
-//      tspSolverNode.Algorithm = ls;
-//      orchestratorNode.TspSolverOrchestrationPort.ConnectedPort = tspSolverNode.OrchestrationPort;
-//      Nodes.Add(tspSolverNode);
-
-//      var kspSolverNode = new OrchestratedAlgorithmNode("KspSolver") { CloneAlgorithm = true };
-//      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_01.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
-//    }
-
-//    public override IDeepCloneable Clone(Cloner cloner) {
-//      return new TtpNetwork3(this, cloner);
-//    }
-//  }
-//}
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2017 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 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.TravelingThief {
+  [Item("TtpNetwork3", "Version 3 of a TTP optimization network.")]
+  [Creatable("Optimization Networks")]
+  [StorableClass]
+  public sealed class TtpNetwork3 : Network, IOptimizer {
+    #region Nodes
+    public TtpOrchestratorNode1 Orchestrator {
+      get { return (TtpOrchestratorNode1)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 TtpNetwork3(bool deserializing) : base(deserializing) { }
+    private TtpNetwork3(TtpNetwork3 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 TtpNetwork3() : base("TtpNetwork3") {
+      var orchestratorNode = new TtpOrchestratorNode3("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 ls = new LocalSearch();
+      ls.Problem = orchestratorNode.KspParameter.Value;
+      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_01.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 TtpNetwork3(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));
+    }
+  }
+}