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

Timestamp:

11/15/17 12:14:18 (7 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

File:

• branches/CFSAP/HeuristicLab.Problems.Scheduling.CFSAP/3.3/MultiNestCFSAPSolvingStrategy.cs (modified) (7 diffs)

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