Changeset 18217 for branches

Timestamp:

02/15/22 15:59:24 (3 years ago)

Author:

pfleck

Message:

#3040 Added guided direction and range sampling using approximated gradients.

Location:

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• Mutators/SamplingSubVectorImprovementManipulator.cs (modified) (2 diffs)
• Mutators/SegmentOptimization/SamplingSegmentOptimizationManipulator.cs (modified) (8 diffs)
• SegmentOptimization/SegmentOptimizationProblem.cs (modified) (1 diff)

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Mutators/SamplingSubVectorImprovementManipulator.cs

@@ -98 +98 @@
           var current = GetIndices(node, length);
 
+          var evaluate = new Func<IntegerVector, double>(integerVector => {
+            var original = GetIndices(node, length);
+            UpdateNode(node, integerVector, length);
+            var quality = evaluator.Evaluate(context, symbolicExpressionTree, problemData, rows);
+            UpdateNode(node, original, length);
+            return quality;
+          });
+
           var indices = SamplingSegmentOptimizationManipulator.CreateIndices(
-            random, current, bounds, dimension, searchRange, 0, null);
+            random, current, bounds, dimension, searchRange, evaluate, !evaluator.Maximization, 0.0, 0);
 
           if (samplingPoints.HasFlag(SamplingSegmentOptimizationManipulator.SamplingPointsType.BeforeCombinations))
@@ -114 +122 @@
             solutions = SamplingSegmentOptimizationManipulator.SampleIndices(solutions, sampling, random, sampleCount);
 
-          var evaluate = new Func<IntegerVector, double>(integerVector => {
-            UpdateNode(node, integerVector, length);
-            return evaluator.Evaluate(context, symbolicExpressionTree, problemData, rows);
-          });
+
           var best = SamplingSegmentOptimizationManipulator.FindBest(solutions, evaluate, minimize: !evaluator.Maximization);
           UpdateNode(node, best.Item1, length);

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Mutators/SegmentOptimization/SamplingSegmentOptimizationManipulator.cs

@@ -68 +68 @@
     public DimensionType Dimension { get { return DimensionParameter.Value.Value; } set { DimensionParameter.Value.Value = value; } }
     public SearchRangeType SearchRange { get { return SearchRangeParameter.Value.Value; } set { SearchRangeParameter.Value.Value = value; } }
-    public int SlopeCalculationRange { get { return SlopeCalculationRangeParameter.Value.Value; } set { SlopeCalculationRangeParameter.Value.Value = value; } }
+    public double DirectedRangeStepSize { get { return DirectedRangeStepSizeParameter.Value.Value; } set { DirectedRangeStepSizeParameter.Value.Value = value; } }
+    public int DirectedRangeRange { get { return DirectedRangeRangeParameter.Value.Value; } set { DirectedRangeRangeParameter.Value.Value = value; } }
     public SamplingType Sampling { get { return SamplingParameter.Value.Value; } set { SamplingParameter.Value.Value = value; } }
     public int SampleCount { get { return SampleCountParameter.Value.Value; } set { SampleCountParameter.Value.Value = value; } }
@@ -77 +78 @@
     public ValueParameter<EnumValue<DimensionType>> DimensionParameter => (ValueParameter<EnumValue<DimensionType>>)Parameters["Dimension"];
     public ValueParameter<EnumValue<SearchRangeType>> SearchRangeParameter => (ValueParameter<EnumValue<SearchRangeType>>)Parameters["SearchRange"];
-    public ValueParameter<IntValue> SlopeCalculationRangeParameter => (ValueParameter<IntValue>)Parameters["SlopeCalculationRange"];
+    public ValueParameter<DoubleValue> DirectedRangeStepSizeParameter => (ValueParameter<DoubleValue>)Parameters["DirectedRangeStepSize"];
+    public ValueParameter<IntValue> DirectedRangeRangeParameter => (ValueParameter<IntValue>)Parameters["DirectedRangeRange"];
     public ValueParameter<EnumValue<SamplingType>> SamplingParameter => (ValueParameter<EnumValue<SamplingType>>)Parameters["Sampling"];
     public ValueParameter<IntValue> SampleCountParameter => (ValueParameter<IntValue>)Parameters["SampleCount"];
@@ -89 +91 @@
       Parameters.Add(new ValueParameter<EnumValue<DimensionType>>("Dimension", new EnumValue<DimensionType>(DimensionType.All)));
       Parameters.Add(new ValueParameter<EnumValue<SearchRangeType>>("SearchRange", new EnumValue<SearchRangeType>(SearchRangeType.Full)));
-      Parameters.Add(new ValueParameter<IntValue>("SlopeCalculationRange", new IntValue(5)));
+      Parameters.Add(new ValueParameter<DoubleValue>("DirectedRangeStepSize", new DoubleValue(1.5)));
+      Parameters.Add(new ValueParameter<IntValue>("DirectedRangeRange", new IntValue(5)));
       Parameters.Add(new ValueParameter<EnumValue<SamplingType>>("Sampling", new EnumValue<SamplingType>(SamplingType.Exhaustive)));
       Parameters.Add(new ValueParameter<IntValue>("SampleCount")); // only used when sampling != Exhaustive
@@ -106 +109 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      if (!Parameters.ContainsKey("SlopeCalculationRange"))
-        Parameters.Add(new ValueParameter<IntValue>("SlopeCalculationRange", new IntValue(5)));
+      if (Parameters.ContainsKey("SlopeCalculationRange"))
+        Parameters.Remove("SlopeCalculationRange");
+      if (!Parameters.ContainsKey("DirectedRangeStepSize"))
+        Parameters.Add(new ValueParameter<DoubleValue>("DirectedRangeStepSize", new DoubleValue(1.5)));
+      if (!Parameters.ContainsKey("DirectedRangeRange"))
+        Parameters.Add(new ValueParameter<IntValue>("DirectedRangeRange", new IntValue(5)));
     }
 
     protected override void ManipulateBounded(IRandom random, IntegerVector integerVector, IntMatrix bounds) {
-      var indices = CreateIndices(random, new IntegerVector(new [] { integerVector.Min(), integerVector.Max() }), bounds, Dimension, SearchRange, SlopeCalculationRange, DataParameter.ActualValue);
+      var indices = CreateIndices(random, new IntegerVector(new [] { integerVector.Min(), integerVector.Max() }), bounds, Dimension, SearchRange, Evaluate, true,
+        this.DirectedRangeStepSize, this.DirectedRangeRange);
       
       if (SamplingPoints.HasFlag(SamplingPointsType.BeforeCombinations))
@@ -137 +145 @@
     }
     
-    public static IEnumerable<int>[] CreateIndices(IRandom random, IntegerVector integerVector, IntMatrix bounds, DimensionType dimension, SearchRangeType indexRange, int gradientRange, DoubleMatrix data) {
+    public static IEnumerable<int>[] CreateIndices(IRandom random, IntegerVector integerVector, IntMatrix bounds, DimensionType dimension, SearchRangeType indexRange, Func<IntegerVector, double> evaluate, bool minimize,
+      double directedRangeStepSize, int directedRangeRange) {
       var indices = new IEnumerable<int>[integerVector.Length];
       int targetIndex = random.Next(indices.Length); // first or second index
       for (int i = 0; i < indices.Length; i++) {
         var searchRange = dimension == DimensionType.All || targetIndex == i ? indexRange : SearchRangeType.None;
-        indices[i] = CreateSingleIndices(bounds[i % bounds.Rows, 1], integerVector[i], searchRange, gradientRange, data, random).ToList();
+        indices[i] = CreateSingleIndices(integerVector, i, bounds, searchRange, evaluate, minimize, random, directedRangeStepSize, directedRangeRange).ToList();
         if (!indices[i].Any()) {
           throw new InvalidOperationException("no indices!");
@@ -151 +160 @@
     }
 
-    public static IEnumerable<int> CreateSingleIndices(int length, int currentIndex, SearchRangeType searchRange, int gradientRange, DoubleMatrix data, IRandom random) {
+    public static IEnumerable<int> CreateSingleIndices(IntegerVector integerVector, int dim, IntMatrix bounds, SearchRangeType searchRange, Func<IntegerVector, double> evaluate, bool minimize, IRandom random,
+      double directedRangeStepSize, int directedRangeRange) {
+      int currentIndex = integerVector[dim];
+      int length = bounds[dim % bounds.Rows, 1];
       switch (searchRange) {
         case SearchRangeType.Full:
@@ -161 +173 @@
             ? Enumerable.Range(0, currentIndex + 1) // left
             : Enumerable.Range(currentIndex, length - currentIndex); // right
-        case SearchRangeType.RandomRange: // random range around current index, not completely random range
+        case SearchRangeType.RandomRange: {
+          // random range around current index, not completely random range
           int start = random.Next(0, currentIndex + 1), end = random.Next(currentIndex, length);
           return Enumerable.Range(start, end - start + 1);
-        case SearchRangeType.DirectedDirection:
-          var slope = CalculateSlope(currentIndex, gradientRange, data); // slope of original data, non-aggregated
-          return slope < 0
+        }
+        case SearchRangeType.DirectedDirection: {
+          var slope = CalculateSlope(integerVector, dim, evaluate);
+          if (!minimize) slope = -slope;
+          return slope > 0 // assume minimization: positive slope -> try lower indices to reduce objective
             ? Enumerable.Range(0, currentIndex + 1) // left
             : Enumerable.Range(currentIndex, length - currentIndex); // right
-        //case SearchRangeType.DirectedRange:
-        //  var slope = CalculateSlope(currentIndex, gradientRange, data);
+        }
+        case SearchRangeType.DirectedRange: {
+          var slope = CalculateSlope(integerVector, dim, evaluate);
+          if (!minimize) slope = -slope;
+          
+          double stepSize = directedRangeStepSize;
+          int range = directedRangeRange;
+
+          double target = currentIndex - stepSize * slope;
+          int targetStart = (int)Math.Round(target - range / 2.0), targetEnd = (int)Math.Round(target + range / 2.0);
+
+          int start = Math.Min(Math.Max(targetStart, 0), currentIndex + 1);
+          int end = Math.Min(Math.Max(targetEnd, currentIndex), length);
+          return Enumerable.Range(start, end - start + 1);
+          }
         default:
           throw new ArgumentOutOfRangeException(nameof(searchRange), searchRange, null);
@@ -176 +204 @@
     }
 
-    private static double CalculateSlope(int position, int range, DoubleMatrix data) {
-      int begin = Math.Max((int)(position - range / 2.0), 0);
-      int remaining = data.Columns - begin;
-      var indices = Enumerable.Range(begin, Math.Min(range, remaining)).ToArray();
-
-      int num = data.Rows * indices.Length;
-      double[] xs = new double[num], ys = new double[num];
-
-      for (int i = 0; i < data.Rows; i++) {
-        for (int j = 0; j < indices.Length; j++) {
-          int idx = i * indices.Length + j;
-          xs[idx] = indices[j];
-          ys[idx] = data[i, j];
-        }
+    private static double CalculateSlope(IntegerVector position, int dim, Func<IntegerVector, double> evaluate) {
+      double f(int i) {
+        var modified = new IntegerVector(position);
+        modified[dim] = i;
+        return evaluate(modified);
       }
       
-      var  coefficients = MathNet.Numerics.LinearRegression.SimpleRegression.Fit(xs, ys);
-      var slope = coefficients.Item2;
-      
+      int x = position[dim];
+      var slope = ( // five-point stencil with h = 1
+        + 1 * f(x - 2)
+        - 8 * f(x - 1)
+        + 8 * f(x + 1)
+        - 1 * f(x + 2)
+      ) / 12;
+
       return slope;
     }

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SegmentOptimization/SegmentOptimizationProblem.cs

@@ -305 +305 @@
       
       int removedQualities = 0;
-      // foreach (var run in content.GetObjectGraphObjects(excludeStaticMembers: true).OfType<IRun>()) {
-      //   if (run.Results.ContainsKey("Qualities")) {
-      //     run.Results.Remove("Qualities");
-      //     removedQualities++;
-      //   }
-      // }
+      foreach (var run in content.GetObjectGraphObjects(excludeStaticMembers: true).OfType<IRun>()) {
+        if (run.Results.ContainsKey("Qualities")) {
+          run.Results.Remove("Qualities");
+          removedQualities++;
+        }
+      }
 
       return Tuple.Create(overallTests, removedDuplicated, removedQualities);