Changeset 18214

Timestamp:

02/08/22 17:36:18 (3 years ago)

Author:

pfleck

Message:

#3040 Added first version of sampling segment optimization manipulator for vectorial sym reg.

Location:

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

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (1 diff)
• Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs (modified) (1 diff)
• Mutators/MultiSymbolicDataAnalysisExpressionManipulator.cs (modified) (1 diff)
• Mutators/SamplingSubVectorImprovementManipulator.cs (added)
• Mutators/SegmentOptimization/SamplingSegmentOptimizationManipulator.cs (modified) (13 diffs)

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

@@ -177 +177 @@
     <Compile Include="Interfaces\ISymbolicDataAnalysisExpressionManipulator.cs" />
     <Compile Include="Mutators\SegmentOptimization\SamplingSegmentOptimizationManipulator.cs" />
+    <Compile Include="Mutators\SamplingSubVectorImprovementManipulator.cs" />
     <Compile Include="Mutators\SymbolicDataAnalysisExpressionManipulator.cs" />
     <Compile Include="Crossovers\SymbolicDataAnalysisExpressionDiversityPreservingCrossover.cs" />

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs

@@ -729 +729 @@
         case OpCodes.SubVector: {
           DoubleVector SubVector(DoubleVector v , double start, double end) {
-            int Mod(int x, int m) => (x % m + m) % m;
-            int startIdx = Mod((int)Math.Round(start * v.Count), v.Count);
-            int endIdx = Mod((int)Math.Round(end * v.Count), v.Count);
-              int size = v.Count;
+            int size = v.Count;
+            int startIdx = Math.Abs((int)Math.Round(start * (size - 1)) % size);
+            int endIdx = Math.Abs((int)Math.Round(end * (size - 1)) % size);
             if (startIdx < endIdx) {
               return v.SubVector(startIdx, count: endIdx - startIdx);

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

@@ -124 +124 @@
 
     private void InitializeOperators() {
-      var list = ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeManipulator>().ToList();
+      var list = ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeManipulator>()
+        .Where(c => !(c is IMultiOperator<ISymbolicExpressionTreeManipulator>))
+        .ToList();
       var dataAnalysisManipulators = from type in ApplicationManager.Manager.GetTypes(typeof(ISymbolicDataAnalysisExpressionManipulator<T>))
                                    where this.GetType().Assembly == type.Assembly

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

@@ -46 +46 @@
       Full,
       RandomDirection,
-      RandomRange
+      RandomRange,
+      DirectedDirection,
+      DirectedRange
     }
     [StorableType("A9EBE01E-53DE-4EB7-94B3-26C624034A08")]
@@ -66 +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 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; } }
@@ -74 +77 @@
     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<EnumValue<SamplingType>> SamplingParameter => (ValueParameter<EnumValue<SamplingType>>)Parameters["Sampling"];
     public ValueParameter<IntValue> SampleCountParameter => (ValueParameter<IntValue>)Parameters["SampleCount"];
     public ValueParameter<EnumValue<SamplingPointsType>> SamplingPointsParameter => (ValueParameter<EnumValue<SamplingPointsType>>)Parameters["SamplingPoints"];
     public ValueParameter<BoolValue> CountSamplesAsEvaluationsParameter => (ValueParameter<BoolValue>)Parameters["CountSamplesAsEvaluations"];
+
     public LookupParameter<IntValue> EvaluatedSolutionsParameter => (LookupParameter<IntValue>)Parameters["EvaluatedSolutions"];
     #endregion
@@ -84 +89 @@
       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<EnumValue<SamplingType>>("Sampling", new EnumValue<SamplingType>(SamplingType.Exhaustive)));
       Parameters.Add(new ValueParameter<IntValue>("SampleCount")); // only used when sampling != Exhaustive
@@ -95 +101 @@
       return new SamplingSegmentOptimizationManipulator(this, cloner);
     }
+
     [StorableConstructor]
     public SamplingSegmentOptimizationManipulator(StorableConstructorFlag _) : base(_) { }
-   
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("SlopeCalculationRange"))
+        Parameters.Add(new ValueParameter<IntValue>("SlopeCalculationRange", 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);
+      var indices = CreateIndices(random, new IntegerVector(new [] { integerVector.Min(), integerVector.Max() }), bounds, Dimension, SearchRange, SlopeCalculationRange, DataParameter.ActualValue);
       
       if (SamplingPoints.HasFlag(SamplingPointsType.BeforeCombinations))
@@ -119 +131 @@
       }
 
-      var best = FindBest(solutions);
+      var best = FindBest(solutions, Evaluate);
       if (best != null) {
         CopyTo(best.Item1, integerVector);
@@ -125 +137 @@
     }
     
-    private static IEnumerable<int>[] CreateIndices(IRandom random, IntegerVector integerVector, IntMatrix bounds, DimensionType dimension, SearchRangeType indexRange) {
+    public static IEnumerable<int>[] CreateIndices(IRandom random, IntegerVector integerVector, IntMatrix bounds, DimensionType dimension, SearchRangeType indexRange, int gradientRange, DoubleMatrix data) {
       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, random).ToList();
+        indices[i] = CreateSingleIndices(bounds[i % bounds.Rows, 1], integerVector[i], searchRange, gradientRange, data, random).ToList();
         if (!indices[i].Any()) {
           throw new InvalidOperationException("no indices!");
@@ -139 +151 @@
     }
 
-    protected static IEnumerable<int> CreateSingleIndices(int length, int currentIndex, SearchRangeType searchRange, IRandom random) {
+    public static IEnumerable<int> CreateSingleIndices(int length, int currentIndex, SearchRangeType searchRange, int gradientRange, DoubleMatrix data, IRandom random) {
       switch (searchRange) {
         case SearchRangeType.Full:
@@ -152 +164 @@
           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
+            ? Enumerable.Range(0, currentIndex + 1) // left
+            : Enumerable.Range(currentIndex, length - currentIndex); // right
+        //case SearchRangeType.DirectedRange:
+        //  var slope = CalculateSlope(currentIndex, gradientRange, data);
         default:
           throw new ArgumentOutOfRangeException(nameof(searchRange), searchRange, null);
@@ -157 +176 @@
     }
 
-    protected static IEnumerable<IntegerVector> CreateCombinations(IEnumerable<int> startIndices, IEnumerable<int> endIndices) {
+    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];
+        }
+      }
+      
+      var  coefficients = MathNet.Numerics.LinearRegression.SimpleRegression.Fit(xs, ys);
+      var slope = coefficients.Item2;
+      
+      return slope;
+    }
+
+    public static IEnumerable<IntegerVector> CreateCombinations(IEnumerable<int> startIndices, IEnumerable<int> endIndices) {
       return 
         from s in startIndices
@@ -165 +206 @@
     }
 
-    protected static IEnumerable<T> SampleIndices<T>(IEnumerable<T> indices, SamplingType sampling, IRandom random, int count) {
+    public static IEnumerable<T> SampleIndices<T>(IEnumerable<T> indices, SamplingType sampling, IRandom random, int count) {
       switch (sampling) {
         case SamplingType.Exhaustive:
@@ -173 +214 @@
         case SamplingType.LinearSelection:
           var indicesList = indices.ToList();
+          // if single sample, the last is always returned
           var selected = MathNet.Numerics.Generate.LinearSpaced(count, 0, indicesList.Count - 1) // LinearSpaced stop is inclusive
             .Select(i => (int)Math.Floor(i))
@@ -182 +224 @@
     }
 
-    protected Tuple<IntegerVector, double> FindBest(IEnumerable<IntegerVector> solutions) {
-      var evaluatedSolutions = solutions.Select(s => Tuple.Create(s, Evaluate(s)));
-      var best = evaluatedSolutions.OrderBy(t => t.Item2).FirstOrDefault();
-      return best;
+    public static Tuple<T, double> FindBest<T>(IEnumerable<T> solutions, Func<T, double> evaluate, bool minimize = true) {
+      var evaluatedSolutions = solutions.Select(s => Tuple.Create(s, evaluate(s)));
+      var sorted = evaluatedSolutions.OrderBy(t => t.Item2);
+      return minimize ? sorted.FirstOrDefault() : sorted.LastOrDefault();
     }