Changeset 15472 for branches/CFSAP/HeuristicLab.Problems.Scheduling.CFSAP/3.3

Timestamp:

11/15/17 12:14:18 (6 years ago)

Author:

abeham

Message:

#2747: worked on the CFSAP

• merged HeuristicLab.Problems.Instances from trunk
• updated best known qualities
• reduced memory footprint of run
• added convergence graph result to solving strategy

Location:

branches/CFSAP/HeuristicLab.Problems.Scheduling.CFSAP/3.3

Files:

• CFSAP.cs (modified) (2 diffs)
• HeuristicLab.Problems.Scheduling.CFSAP-3.3.csproj (modified) (1 diff)
• MultiNestCFSAP.cs (modified) (3 diffs)
• MultiNestCFSAPSolvingStrategy.cs (modified) (7 diffs)
• Plugin.cs.frame (modified) (2 diffs)

branches/CFSAP/HeuristicLab.Problems.Scheduling.CFSAP/3.3/CFSAP.cs

@@ -64 +64 @@
       : base(original, cloner) {}
     public CFSAP() {
-      Parameters.Add(new ValueParameter<IntMatrix>("ProcessingTimes", "The processing times of each machine and each job."));
-      Parameters.Add(new ValueParameter<ItemList<IntMatrix>>("SetupTimes", "The sequence dependent set up times of each machine and between all jobs."));
+      Parameters.Add(new ValueParameter<IntMatrix>("ProcessingTimes", "The processing times of each machine and each job.") { GetsCollected = false });
+      Parameters.Add(new ValueParameter<ItemList<IntMatrix>>("SetupTimes", "The sequence dependent set up times of each machine and between all jobs.") { GetsCollected = false });
 
       ProcessingTimesParameter.Value = new IntMatrix(new int[,] {
@@ -90 +90 @@
       Encoding.Add(new PermutationEncoding("sequence", 5, PermutationTypes.RelativeDirected));
       Encoding.Add(new BinaryVectorEncoding("assignment", 5));
+
+      EncodingParameter.GetsCollected = false;
+      foreach (var param in ((IEncoding)Encoding).Parameters.OfType<IValueParameter>().ToList()) {
+        param.GetsCollected = false;
+      }
 
       Operators.RemoveAll(x => x is SingleObjectiveMoveGenerator);

branches/CFSAP/HeuristicLab.Problems.Scheduling.CFSAP/3.3/HeuristicLab.Problems.Scheduling.CFSAP-3.3.csproj

@@ -76 +76 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.PermutationEncoding-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
       <Private>False</Private>
     </Reference>

branches/CFSAP/HeuristicLab.Problems.Scheduling.CFSAP/3.3/MultiNestCFSAP.cs

@@ -41 +41 @@
       : base(original, cloner) { }
     public MultiNestCFSAP() {
-      Parameters.Add(new ValueParameter<ItemList<IntMatrix>>("ProcessingTimes", "The processing times of each nest, each machine, each job."));
-      Parameters.Add(new ValueParameter<ItemList<ItemList<IntMatrix>>>("SetupTimes", "The sequence dependent set up times for each nest, each machine, and each job to each other."));
+      Parameters.Add(new ValueParameter<ItemList<IntMatrix>>("ProcessingTimes", "The processing times of each nest, each machine, each job.") { GetsCollected = false });
+      Parameters.Add(new ValueParameter<ItemList<ItemList<IntMatrix>>>("SetupTimes", "The sequence dependent set up times for each nest, each machine, and each job to each other.") { GetsCollected = false });
 
       ProcessingTimesParameter.Value = new ItemList<IntMatrix>() {
@@ -69 +69 @@
       Encoding.Add(new PermutationEncoding("seq0", 5, PermutationTypes.RelativeDirected));
       Encoding.Add(new BinaryVectorEncoding("assign0", 5));
+
+      EncodingParameter.GetsCollected = false;
+      foreach (var param in ((IEncoding)Encoding).Parameters.OfType<IValueParameter>().ToList()) {
+        param.GetsCollected = false;
+      }
 
       Operators.RemoveAll(x => x is SingleObjectiveMoveGenerator);
@@ -124 +129 @@
         Encoding.Add(new BinaryVectorEncoding("assign" + n, data.Jobs));
       }
+
+      #region Reduce run size by removing collected parameters
+      foreach (var param in ((IEncoding)Encoding).Parameters.OfType<IValueParameter>().ToList())
+        param.GetsCollected = false;
+
+      var solCreator = SolutionCreator as IParameterizedItem;
+      if (solCreator != null) {
+        foreach (var param in solCreator.Parameters.OfType<IValueParameter>().ToList()) {
+          param.GetsCollected = false;
+          var secondLevel = param.Value as IParameterizedItem;
+          if (secondLevel != null) {
+            foreach (var secondLevelParam in secondLevel.Parameters.OfType<IValueParameter>().ToList())
+              secondLevelParam.GetsCollected = false;
+          }
+        }
+      }
+      #endregion
+
       Name = data.Name;
       Description = data.Description;

branches/CFSAP/HeuristicLab.Problems.Scheduling.CFSAP/3.3/MultiNestCFSAPSolvingStrategy.cs

@@ -3 +3 @@
 using System.Linq;
 using System.Threading;
+using HeuristicLab.Analysis;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -32 +33 @@
     }
 
+
+    public IFixedValueParameter<StringValue> EvaluatedSolutionsNameParameter {
+      get { return (IFixedValueParameter<StringValue>)Parameters["EvaluatedSolutionsName"]; }
+    }
+
+    public IAlgorithm Solver {
+      get { return SolverParameter.Value; }
+      set { SolverParameter.Value = value; }
+    }
+
     public TimeSpan MaximumRuntime {
       get { return MaximumRuntimeParameter.Value.Value; }
       set { MaximumRuntimeParameter.Value.Value = value; }
+    }
+
+    public string EvaluatedSolutionsName {
+      get { return EvaluatedSolutionsNameParameter.Value.Value; }
+      set { EvaluatedSolutionsNameParameter.Value.Value = value; }
     }
 
@@ -47 +63 @@
       if (original.algorithmsResults != null)
         algorithmsResults = cloner.Clone(original.algorithmsResults);
+      if (original.qualityPerClock != null)
+        qualityPerClock = cloner.Clone(original.qualityPerClock);
+      if (original.qualityPerEvaluations != null)
+        qualityPerEvaluations = cloner.Clone(original.qualityPerEvaluations);
     }
     public MultiNestCFSAPSolvingStrategy() {
-      Parameters.Add(new ValueParameter<IAlgorithm>("Solver", "The actual solver template."));
+      Parameters.Add(new ValueParameter<IAlgorithm>("Solver", "The actual solver template.") { GetsCollected = false });
       Parameters.Add(new FixedValueParameter<TimeSpanValue>("MaximumRuntime", "The maximum time that the strategy should run.", new TimeSpanValue(TimeSpan.FromSeconds(60))));
+      Parameters.Add(new FixedValueParameter<StringValue>("EvaluatedSolutionsName", "The name of the result that shows the number of evaluated solutions by the actual solver.", new StringValue("EvaluatedSolutions")));
     }
     
     public override IDeepCloneable Clone(Cloner cloner) {
       return new MultiNestCFSAPSolvingStrategy(this, cloner);
+    }
+
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("EvaluatedSolutionsName"))
+        Parameters.Add(new FixedValueParameter<StringValue>("EvaluatedSolutionsName", "The name of the result that shows the number of evaluated solutions by the actual solver.", new StringValue("EvaluatedSolutions")));
     }
 
@@ -63 +91 @@
     [Storable]
     private ResultCollection algorithmsResults;
+    [Storable]
+    private IndexedDataTable<double> qualityPerClock;
+    [Storable]
+    private IndexedDataTable<double> qualityPerEvaluations;
 
     protected override void OnPrepared() {
@@ -68 +100 @@
       algorithms = null;
       qualities = null;
+      algorithmsResults = null;
+      qualityPerClock = null;
+      qualityPerEvaluations = null;
     }
 
@@ -89 +124 @@
       var min = worst.Quality;
 
+      qualityPerClock = new IndexedDataTable<double>("Quality per Clock");
+      var qpcRow = new IndexedDataRow<double>("First-hit Graph");
+      qpcRow.Values.Add(Tuple.Create(ExecutionTime.TotalSeconds, (double)min));
+      qpcRow.Values.Add(Tuple.Create(ExecutionTime.TotalSeconds, (double)min));
+      qualityPerClock.Rows.Add(qpcRow);
+      qualityPerEvaluations = new IndexedDataTable<double>("Quality per Evaluations");
+      var qpeRow = new IndexedDataRow<double>("First-hit Graph");
+      qualityPerEvaluations.Rows.Add(qpeRow);
+      double evaluations = GetEvaluatedSolutions();
+      qpeRow.Values.Add(Tuple.Create((double)evaluations, (double)min));
+      qpeRow.Values.Add(Tuple.Create((double)evaluations, (double)min));
+
       Results.Add(new Result("Nest with maximum T", new IntValue(worst.Index + 1)));
       Results.Add(new Result("Maximum T", new IntValue(min)));
+      Results.Add(new Result("BestQuality", new DoubleValue(min)));
       Results.Add(new Result("Best Solution Found At", new TimeSpanValue(ExecutionTime)));
       Results.Add(new Result("Delta T", new PercentValue((min - Problem.BestKnownQuality) / Problem.BestKnownQuality)));
       Results.Add(new Result("Nest Results", algorithmsResults));
+      Results.Add(new Result("QualityPerClock", qualityPerClock));
+      Results.Add(new Result("QualityPerEvaluations", qualityPerEvaluations));
 
       base.Initialize(cancellationToken);
+    }
+
+    private double GetEvaluatedSolutions() {
+      if (algorithmsResults == null) throw new InvalidOperationException("Strategy has not been started yet.");
+      return algorithmsResults.Select(x => {
+        IResult res;
+        if (((ResultCollection)x.Value).TryGetValue(EvaluatedSolutionsName, out res)) {
+          var itm = res.Value;
+          if (itm is IntValue) return ((IntValue)itm).Value;
+          else if (itm is DoubleValue) return ((DoubleValue)itm).Value;
+        }
+        throw new InvalidOperationException("No result " + EvaluatedSolutionsName + " in the collection of " + x.Name);
+      }).Sum();
     }
 
@@ -106 +169 @@
         qualities[worst.Index] = (int)((DoubleValue)algorithms[worst.Index].Results["BestQuality"].Value).Value;
         worst = qualities.Select((v, i) => new { Index = i, Quality = v }).MaxItems(x => x.Quality).First();
+
+        var evaluations = GetEvaluatedSolutions();
+        var time = ExecutionTime.TotalSeconds;
+        var qpcRow = qualityPerClock.Rows.First();
+        var qpeRow = qualityPerEvaluations.Rows.First();
+        qpcRow.Values[qpcRow.Values.Count - 1] = Tuple.Create(time, (double)min);
+        qpeRow.Values[qpeRow.Values.Count - 1] = Tuple.Create(evaluations, (double)min);
+
         if (worst.Quality < min) {
           min = worst.Quality;
-          Results["Nest with maximum T"].Value = new IntValue(worst.Index + 1);
-          Results["Maximum T"].Value = new IntValue(min);
-          Results["Best Solution Found At"].Value = new TimeSpanValue(ExecutionTime);
-          Results["Delta T"].Value = new PercentValue((min - Problem.BestKnownQuality) / Problem.BestKnownQuality);
+          ((IntValue)Results["Nest with maximum T"].Value).Value = worst.Index + 1;
+          ((IntValue)Results["Maximum T"].Value).Value = min;
+          ((DoubleValue)Results["BestQuality"].Value).Value = min;
+          ((TimeSpanValue)Results["Best Solution Found At"].Value).Value = TimeSpan.FromSeconds(time);
+          ((PercentValue)Results["Delta T"].Value).Value = (min - Problem.BestKnownQuality) / Problem.BestKnownQuality;
+          qpcRow.Values.Add(Tuple.Create(time, (double)min));
+          qpeRow.Values.Add(Tuple.Create(evaluations, (double)min));
         }
+
         if (cancellationToken.IsCancellationRequested) return;
       }

branches/CFSAP/HeuristicLab.Problems.Scheduling.CFSAP/3.3/Plugin.cs.frame

@@ -30 +30 @@
   [PluginDependency("HeuristicLab.Collections", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
-  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
   [PluginDependency("HeuristicLab.Core", "3.3")]
   [PluginDependency("HeuristicLab.Data", "3.3")]
@@ -38 +37 @@
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
-  [PluginDependency("HeuristicLab.SimSharp", "3.0.9")]
+  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
   public class HeuristicLabProblemsSchedulingCFSAPPlugin : PluginBase  {
   }