Changeset 14680 for branches/MemPRAlgorithm

Timestamp:

02/17/17 13:01:00 (8 years ago)

Author:

abeham

Message:

#2701: disabled learning

• updated HeuristicLab.Data to trunk

Location:

branches/MemPRAlgorithm

Files:

• HeuristicLab.Algorithms.MemPR/3.3 (modified) (1 prop)
• HeuristicLab.Algorithms.MemPR/3.3/MemPRAlgorithm.cs (modified) (1 diff)
• HeuristicLab.Algorithms.MemPR/3.3/MemPRContext.cs (modified) (9 diffs)
• HeuristicLab.Data (modified) (1 prop)
• HeuristicLab.Data/3.3 (modified) (1 prop)
• HeuristicLab.Data/3.3/EnumValue.cs (modified) (2 diffs)
• HeuristicLab.Data/3.3/HeuristicLab.Data-3.3.csproj (modified) (1 diff)
• HeuristicLab.Data/3.3/ValueTypeMatrix.cs (modified) (1 diff)
• HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj (modified) (1 diff)
• HeuristicLab.Encodings.BinaryVectorEncoding/3.3/SimilarityCalculators (added)
• HeuristicLab.Encodings.BinaryVectorEncoding/3.3/SimilarityCalculators/HammingSimilarityCalculator.cs (moved) (moved from branches/MemPRAlgorithm/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HammingSimilarityCalculator.cs)
• HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.cs (modified) (8 diffs)

branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3 ¶

@@ -9 +9 @@
 GeneratedArtifacts
 _Pvt_Extensions
+*.DotSettings

@@ -9 +9 @@
 GeneratedArtifacts
 _Pvt_Extensions
+*.DotSettings

branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRAlgorithm.cs ¶

@@ -248 +248 @@
           Context.AddToPopulation(child);
           Context.BestQuality = child.Fitness;
-          Analyze(token);
+          Analyze(CancellationToken.None);
           token.ThrowIfCancellationRequested();
           if (Terminate()) return;

branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRContext.cs ¶

@@ -346 +346 @@
     #region Breeding Performance
     public void AddBreedingResult(ISingleObjectiveSolutionScope<TSolution> a, ISingleObjectiveSolutionScope<TSolution> b, double parentDist, ISingleObjectiveSolutionScope<TSolution> child) {
+      return;
       if (IsBetter(a, b))
         breedingStat.Add(Tuple.Create(a.Fitness, b.Fitness, parentDist, child.Fitness));
@@ -352 +353 @@
     }
     public void RelearnBreedingPerformanceModel() {
+      return;
       breedingPerformanceModel = RunRegression(PrepareRegression(ToListRow(breedingStat)), breedingPerformanceModel).Model;
     }
     public bool BreedingSuited(ISingleObjectiveSolutionScope<TSolution> p1, ISingleObjectiveSolutionScope<TSolution> p2, double dist) {
+      return true;
       if (breedingPerformanceModel == null) return true;
       double minI1 = double.MaxValue, minI2 = double.MaxValue, maxI1 = double.MinValue, maxI2 = double.MinValue;
@@ -372 +375 @@
     #region Relinking Performance
     public void AddRelinkingResult(ISingleObjectiveSolutionScope<TSolution> a, ISingleObjectiveSolutionScope<TSolution> b, double parentDist, ISingleObjectiveSolutionScope<TSolution> child) {
+      return;
       if (IsBetter(a, b))
         relinkingStat.Add(Tuple.Create(a.Fitness, b.Fitness, parentDist, Maximization ? child.Fitness - a.Fitness : a.Fitness - child.Fitness));
@@ -378 +382 @@
     }
     public void RelearnRelinkingPerformanceModel() {
+      return;
       relinkingPerformanceModel = RunRegression(PrepareRegression(ToListRow(relinkingStat)), relinkingPerformanceModel).Model;
     }
     public bool RelinkSuited(ISingleObjectiveSolutionScope<TSolution> p1, ISingleObjectiveSolutionScope<TSolution> p2, double dist) {
+      return true;
       if (relinkingPerformanceModel == null) return true;
       double minI1 = double.MaxValue, minI2 = double.MaxValue, maxI1 = double.MinValue, maxI2 = double.MinValue;
@@ -401 +407 @@
     #region Delinking Performance
     public void AddDelinkingResult(ISingleObjectiveSolutionScope<TSolution> a, ISingleObjectiveSolutionScope<TSolution> b, double parentDist, ISingleObjectiveSolutionScope<TSolution> child) {
+      return;
       if (IsBetter(a, b))
         delinkingStat.Add(Tuple.Create(a.Fitness, b.Fitness, parentDist, Maximization ? child.Fitness - a.Fitness : a.Fitness - child.Fitness));
@@ -407 +414 @@
     }
     public void RelearnDelinkingPerformanceModel() {
+      return;
       delinkingPerformanceModel = RunRegression(PrepareRegression(ToListRow(delinkingStat)), delinkingPerformanceModel).Model;
     }
     public bool DelinkSuited(ISingleObjectiveSolutionScope<TSolution> p1, ISingleObjectiveSolutionScope<TSolution> p2, double dist) {
+      return true;
       if (delinkingPerformanceModel == null) return true;
       double minI1 = double.MaxValue, minI2 = double.MaxValue, maxI1 = double.MinValue, maxI2 = double.MinValue;
@@ -429 +438 @@
     #region Sampling Performance
     public void AddSamplingResult(ISingleObjectiveSolutionScope<TSolution> sample, double avgDist) {
+      return;
       samplingStat.Add(Tuple.Create(avgDist, sample.Fitness));
       if (samplingStat.Count % 10 == 0) RelearnSamplingPerformanceModel();
     }
     public void RelearnSamplingPerformanceModel() {
+      return;
       samplingPerformanceModel = RunRegression(PrepareRegression(ToListRow(samplingStat)), samplingPerformanceModel).Model;
     }
     public bool SamplingSuited(double avgDist) {
+      return true;
       if (samplingPerformanceModel == null) return true;
       if (avgDist < samplingStat.Min(x => x.Item1) || avgDist > samplingStat.Max(x => x.Item1)) return true;
@@ -444 +456 @@
     #region Hillclimbing Performance
     public void AddHillclimbingResult(ISingleObjectiveSolutionScope<TSolution> input, ISingleObjectiveSolutionScope<TSolution> outcome) {
+      return;
       hillclimbingStat.Add(Tuple.Create(input.Fitness, Maximization ? outcome.Fitness - input.Fitness : input.Fitness - outcome.Fitness));
       if (hillclimbingStat.Count % 10 == 0) RelearnHillclimbingPerformanceModel();
     }
     public void RelearnHillclimbingPerformanceModel() {
+      return;
       hillclimbingPerformanceModel = RunRegression(PrepareRegression(ToListRow(hillclimbingStat)), hillclimbingPerformanceModel).Model;
     }
     public bool HillclimbingSuited(double startingFitness) {
+      return true;
       if (hillclimbingPerformanceModel == null) return true;
       if (startingFitness < HillclimbingStat.Min(x => x.Item1) || startingFitness > HillclimbingStat.Max(x => x.Item1))
@@ -460 +475 @@
     #region Adaptivewalking Performance
     public void AddAdaptivewalkingResult(ISingleObjectiveSolutionScope<TSolution> input, ISingleObjectiveSolutionScope<TSolution> outcome) {
+      return;
       adaptivewalkingStat.Add(Tuple.Create(input.Fitness, Maximization ? outcome.Fitness - input.Fitness : input.Fitness - outcome.Fitness));
       if (adaptivewalkingStat.Count % 10 == 0) RelearnAdaptiveWalkPerformanceModel();
     }
     public void RelearnAdaptiveWalkPerformanceModel() {
+      return;
       adaptiveWalkPerformanceModel = RunRegression(PrepareRegression(ToListRow(adaptivewalkingStat)), adaptiveWalkPerformanceModel).Model;
     }
     public bool AdaptivewalkingSuited(double startingFitness) {
+      return true;
       if (adaptiveWalkPerformanceModel == null) return true;
       if (startingFitness < AdaptivewalkingStat.Min(x => x.Item1) || startingFitness > AdaptivewalkingStat.Max(x => x.Item1))

branches/MemPRAlgorithm/HeuristicLab.Data/3.3/EnumValue.cs ¶

@@ -52 +52 @@
     private EnumValue(EnumValue<T> original, Cloner cloner)
       : base(original, cloner) {
-      this.value = original.value;
-      this.readOnly = original.readOnly;
     }
 
@@ -64 +62 @@
     }
   }
+
+  public static class EnumHelper {
+    public static T SetFlag<T>(this Enum value, T flag, bool set) {
+      var baseType = Enum.GetUnderlyingType(value.GetType());
+      dynamic valueAsBase = Convert.ChangeType(value, baseType);
+      dynamic flagAsBase = Convert.ChangeType(flag, baseType);
+      if (set)
+        valueAsBase |= flagAsBase;
+      else
+        valueAsBase &= ~flagAsBase;
+      return (T)valueAsBase;
+    }
+  }
 }

branches/MemPRAlgorithm/HeuristicLab.Data/3.3/HeuristicLab.Data-3.3.csproj ¶

@@ -108 +108 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Microsoft.CSharp" />
     <Reference Include="System" />
     <Reference Include="System.Core">

branches/MemPRAlgorithm/HeuristicLab.Data/3.3/ValueTypeMatrix.cs ¶

@@ -201 +201 @@
     }
 
+    public virtual IEnumerable<T> GetRow(int row) {
+      for (var col = 0; col < Columns; col++) {
+        yield return matrix[row, col];
+      }
+    }
+
+    public virtual IEnumerable<T> GetColumn(int col) {
+      for (var row = 0; row < Rows; row++) {
+        yield return matrix[row, col];
+      }
+    }
+
     public override string ToString() {
       if (matrix.Length == 0) return "[]";

branches/MemPRAlgorithm/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj ¶

@@ -127 +127 @@
     <Compile Include="Crossovers\NPointCrossover.cs" />
     <Compile Include="BinaryVector.cs" />
-    <Compile Include="HammingSimilarityCalculator.cs" />
+    <Compile Include="SimilarityCalculators\HammingSimilarityCalculator.cs" />
     <Compile Include="Interfaces\IBinaryVectorMultiNeighborhoodShakingOperator.cs" />
     <Compile Include="Interfaces\IOneBitflipMoveOperator.cs" />

branches/MemPRAlgorithm/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionRLDView.cs ¶

@@ -30 +30 @@
 using HeuristicLab.Analysis;
 using HeuristicLab.Collections;
+using HeuristicLab.Common;
 using HeuristicLab.Core.Views;
 using HeuristicLab.Data;
@@ -334 +335 @@
       // aggregating over multiple problem instances      
       var maxEfforts = new Dictionary<ProblemDescription, double>();
+      var worstKnowns = new Dictionary<ProblemDescription, double>();
       double minEff = double.MaxValue, maxEff = double.MinValue;
       foreach (var group in groupedRuns) {
@@ -343 +345 @@
           var bestKnownTarget = problem.Value.Item1;
           var max = problem.Key.IsMaximization();
-          var worstTarget = (max ? (1 - targets.Max()) : (1 + targets.Max())) * bestKnownTarget;
-          var bestTarget = (max ? (1 - targets.Min()) : (1 + targets.Min())) * bestKnownTarget;
+          double worstTarget = 0, bestTarget = 0;
+          if (bestKnownTarget > 0) {
+            worstTarget = (max ? (1 - targets.Max()) : (1 + targets.Max())) * bestKnownTarget;
+            bestTarget = (max ? (1 - targets.Min()) : (1 + targets.Min())) * bestKnownTarget;
+          } else if (bestKnownTarget < 0) {
+            worstTarget = (max ? (1 + targets.Max()) : (1 - targets.Max())) * bestKnownTarget;
+            bestTarget = (max ? (1 + targets.Min()) : (1 - targets.Min())) * bestKnownTarget;
+          } else {
+            var initials = problem.Value.Item2.Select(x => ((IndexedDataTable<double>)x.Results[table]).Rows.First().Values.First().Item2);
+            var worstKnown = max ? initials.Min() : initials.Max();
+            if (!worstKnown.IsAlmost(0)) {
+              worstTarget = targets.Max() * worstKnown;
+              bestTarget = targets.Min() * worstKnown;
+              worstKnowns[problem.Key] = worstKnown;
+            }
+          }
           foreach (var run in problem.Value.Item2) {
             var row = ((IndexedDataTable<double>)run.Results[table]).Rows.First().Values;
@@ -389 +405 @@
 
             if (aggregateTargetsCheckBox.Checked) {
-              var length = CalculateHitsForAllTargets(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, maxEff);
+              var length = CalculateHitsForAllTargets(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, worstKnowns.ContainsKey(problem.Key) ? worstKnowns[problem.Key] : 0, maxEff);
               maxLength = Math.Max(length, maxLength);
             } else {
-              CalculateHitsForEachTarget(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, maxEff);
+              CalculateHitsForEachTarget(hits, misses, resultsTable.Rows.First(), problem.Key, group.Key, problem.Value.Item1, worstKnowns.ContainsKey(problem.Key) ? worstKnowns[problem.Key] : 0, maxEff);
             }
             noRuns++;
@@ -495 +511 @@
                                             Dictionary<string, SortedList<double, int>> misses,
                                             IndexedDataRow<double> row, ProblemDescription problem,
-                                            string group, double bestTarget, double maxEffort) {
-      foreach (var t in targets.Select(x => Tuple.Create((problem.IsMaximization() ? (1 - x) : (1 + x)) * bestTarget, x))) {
+                                            string group, double bestTarget, double worstKnown, double maxEffort) {
+      var max = problem.IsMaximization();
+      var targetValues = targets.Select(t => {
+        double target = 0;
+        if (bestTarget > 0) {
+          target = (max ? (1 - t) : (1 + t)) * bestTarget;
+        } else if (bestTarget < 0) {
+          target = (max ? (1 + t) : (1 - t)) * bestTarget;
+        } else {
+          if (!worstKnown.IsAlmost(0))
+            target = t * worstKnown;
+        }
+        return Tuple.Create(target, t);
+      });
+      foreach (var t in targetValues) {
         var l = t.Item1;
         var key = group + "_" + (t.Item2 * 100) + "%_" + l;
@@ -515 +544 @@
         }
         if (!hit) {
-          var max = Math.Min(row.Values.Last().Item1, maxEffort);
-          if (misses[key].ContainsKey(max))
-            misses[key][max]++;
-          else misses[key][max] = 1;
+          var maxEff = Math.Min(row.Values.Last().Item1, maxEffort);
+          if (misses[key].ContainsKey(maxEff))
+            misses[key][maxEff]++;
+          else misses[key][maxEff] = 1;
         }
       }
@@ -526 +555 @@
                                               Dictionary<string, SortedList<double, int>> misses,
                                               IndexedDataRow<double> row, ProblemDescription problem,
-                                              string group, double bestTarget, double maxEffort) {
+                                              string group, double bestTarget, double worstKnown, double maxEffort) {
       var values = row.Values;
       if (!hits.ContainsKey(group)) {
@@ -536 +565 @@
       var j = 0;
       while (i < targets.Length && j < values.Count) {
-        var target = (problem.IsMaximization() ? (1 - targets[i]) : (1 + targets[i])) * bestTarget;
+        var max = problem.IsMaximization();
+        double target = 0;
+        if (bestTarget > 0) {
+          target = (max ? (1 - targets[i]) : (1 + targets[i])) * bestTarget;
+        } else if (bestTarget < 0) {
+          target = (max ? (1 + targets[i]) : (1 - targets[i])) * bestTarget;
+        } else {
+          if (!worstKnown.IsAlmost(0))
+            target = targets[i] * worstKnown;
+        }
         var current = values[j];
         if (current.Item1 > maxEffort) break;

@@ -9 +9 @@
 GeneratedArtifacts
 _Pvt_Extensions
+*.DotSettings