Changeset 17741

Timestamp:

09/10/20 09:57:02 (4 years ago)

Author:

pfleck

Message:

#3040 Added new benchmark and some minor bugfixes.

Location:

branches/3040_VectorBasedGP

Files:

• HeuristicLab.Common/3.3/Statistics/EnumerableStatisticExtensions.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/ModifiableDataset.cs (modified) (1 diff)
• HeuristicLab.Problems.Instances.DataAnalysis/3.3/HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj (modified) (1 diff)
• HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/AzzaliBenchmark3.cs (modified) (3 diffs)
• HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/AzzaliKorns5.cs (modified) (1 diff)
• HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataInstanceProvider.cs (modified) (1 diff)
• HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataTestFour.cs (copied) (copied from branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataTestOne.cs) (8 diffs)

branches/3040_VectorBasedGP/HeuristicLab.Common/3.3/Statistics/EnumerableStatisticExtensions.cs

@@ -230 +230 @@
       if (min > max) throw new ArgumentException(string.Format("Minimum {0} is larger than maximum {1}.", min, max));
       foreach (var x in values) {
-        /*if (double.IsNaN(x)) yield return (max + min) / 2.0;
-        else */
-        if (x < min) yield return min;
+        if (double.IsNaN(x)) yield return (max + min) / 2.0;
+        else if (x < min) yield return min;
         else if (x > max) yield return max;
         else yield return x;

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs

@@ -118 +118 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingIndices.Any()) {
+      if (ProblemData.TrainingIndices.Any() && ProblemData.Dataset.VariableHasType<double>(ProblemData.TargetVariable)) {
         var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToList();
         var mean = targetValues.Average();

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis/3.4/ModifiableDataset.cs

@@ -141 +141 @@
       if (values.Count != variableValues[variableName].Count)
         throw new ArgumentException("The number of values must coincide with the number of dataset rows.");
-      if (GetVariableType(variableName) != values[0].GetType())
+      //if (GetVariableType(variableName) != values[0].GetType())
+      if (!GetVariableType(variableName).IsInstanceOfType(values[0]))
         throw new ArgumentException("The type of the provided value does not match the variable type.");
       variableValues[variableName] = values;

branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj

@@ -262 +262 @@
     <Compile Include="Regression\VectorData\RandomExtensions.cs" />
     <Compile Include="Regression\VectorData\VectorDataInstanceProvider.cs" />
+    <Compile Include="Regression\VectorData\VectorDataTestFour.cs" />
     <Compile Include="Regression\VectorData\VectorDataTestThree.cs" />
     <Compile Include="Regression\VectorData\VectorDataTestTwo.cs" />

branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/AzzaliBenchmark3.cs

@@ -28 +28 @@
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Random;
-
+using MathNet.Numerics.Statistics;
 using DoubleVector = MathNet.Numerics.LinearAlgebra.Vector<double>;
 
@@ -38 +38 @@
     protected override string TargetVariable { get { return "B3"; } }
     protected override string[] VariableNames { get { return AllowedInputVariables.Concat(new[] { TargetVariable }).ToArray(); } }
-    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2", "X3", "X4" }; } }
+    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2", "X3", "X4", "X5" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
     protected override int TrainingPartitionEnd { get { return 70; } }
@@ -85 +85 @@
         x3Column.Add(x3);
         x4Column.Add(x4);
+        x5Column.Add(x5);
         b3Column.Add(b3);
       }

branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/AzzaliKorns5.cs

@@ -28 +28 @@
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Random;
-
+using MathNet.Numerics.Statistics;
 using DoubleVector = MathNet.Numerics.LinearAlgebra.Vector<double>;
 

branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataInstanceProvider.cs

@@ -62 +62 @@
         new VectorDataTestThreeC(rand.Next()),
         new VectorDataTestThreeD(rand.Next()),
+        new VectorDataTestFourA(rand.Next()),
+        new VectorDataTestFourB(rand.Next()),
+        new VectorDataTestFourC(rand.Next()),
+        new VectorDataTestFourD(rand.Next()),
         new AzzaliBenchmark1(rand.Next()),
         new AzzaliBenchmark2(rand.Next()),

branches/3040_VectorBasedGP/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/VectorData/VectorDataTestFour.cs

@@ -30 +30 @@
 
 namespace HeuristicLab.Problems.Instances.DataAnalysis {
-  public abstract class VectorDataTestOne : ArtificialRegressionDataDescriptor {
+  public abstract class VectorDataTestFour : ArtificialRegressionDataDescriptor {
 
-    protected const int Rows = 1000;
+    protected const int Rows = 10000;
 
     public override string Description { get { return ""; } }
 
     protected override string TargetVariable { get { return "Y"; } }
-    protected override string[] VariableNames { get { return new string[] { "X1", "X2", "X3", "V1", "V2", "Y" }; } }
-    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2", "X3", "V1", "V2" }; } }
+    protected override string[] VariableNames { get { return new string[] { "X1", "X2", "X3", "X4", "X5", "V1", "V2", "V3", "V4", "V5", "Y" }; } }
+    protected override string[] AllowedInputVariables { get { return new string[] { "X1", "X2", "X3", "X4", "X5", "V1", "V2", "V3", "V4", "V5" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
     protected override int TrainingPartitionEnd { get { return Rows * 3 / 4; } }
@@ -46 +46 @@
     public int Seed { get; private set; }
 
-    protected VectorDataTestOne()
+    protected VectorDataTestFour()
       : this((int)DateTime.Now.Ticks) { }
-    protected VectorDataTestOne(int seed)
+    protected VectorDataTestFour(int seed)
       : base() {
       Seed = seed;
@@ -58 +58 @@
       var rand = new MersenneTwister((uint)Seed);
 
-      double x1, x2, x3;
-      DoubleVector v1, v2;
+      double x1, x2, x3, x4, x5;
+      DoubleVector v1, v2, v3, v4, v5;
       double y;
 
@@ -65 +65 @@
       var x2Column = new List<double>(Rows);
       var x3Column = new List<double>(Rows);
+      var x4Column = new List<double>(Rows);
+      var x5Column = new List<double>(Rows);
       var v1Column = new List<DoubleVector>(Rows);
       var v2Column = new List<DoubleVector>(Rows);
+      var v3Column = new List<DoubleVector>(Rows);
+      var v4Column = new List<DoubleVector>(Rows);
+      var v5Column = new List<DoubleVector>(Rows);
       var yColumn = new List<double>(Rows);
 
@@ -74 +79 @@
         x2 = rand.NextDouble(2, 6);
         x3 = rand.NextDouble(0, 1);
-        int v1Length = vectorLengths[0][i];
-        int v2Length = vectorLengths[1][i];
-        v1 = rand.NextDoubleVector(2, 6, v1Length);
-        v2 = rand.NextDoubleVector(3, 5, v2Length);
+        x4 = rand.NextDouble(30, 100);
+        x5 = rand.NextDouble(150, 200);
+        v1 = rand.NextDoubleVector(2, 6, vectorLengths[0][i]);
+        v2 = rand.NextDoubleVector(3, 5, vectorLengths[1][i]);
+        v3 = rand.NextDoubleVector(-10, 50, vectorLengths[2][i]);
+        v4 = rand.NextDoubleVector(0, 200, vectorLengths[3][i]);
+        v5 = rand.NextDoubleVector(200, 220, vectorLengths[4][i]);
 
-        y = x1 * v1.Sum() + x2 * v2.Mean();
+        var t1 = ((v1 + Math.Log(10 * x5)) * (v4 - 50 * v2.PointwiseSin()).Mean() * x1).Mean() / 10;  // mean 50
+        var t2 = (v5.StandardDeviation() + v2.PointwisePower(2.0)).Mean();  // mean 18 + 6 = 24
+        var t3 = Math.Exp(3 * x3) + v2.PointwiseMultiply(v3).Mean() / 10;     // mean 7 + 8 = 15
+        y = t1 - 0.1 * t2 * t3;
 
         x1Column.Add(x1);
         x2Column.Add(x2);
         x3Column.Add(x3);
+        x4Column.Add(x4);
+        x5Column.Add(x5);
         v1Column.Add(v1);
         v2Column.Add(v2);
+        v3Column.Add(v3);
+        v4Column.Add(v4);
+        v5Column.Add(v5);
         yColumn.Add(y);
       }
 
-      return new List<IList> { x1Column, x2Column, x3Column, v1Column, v2Column, yColumn };
+      return new List<IList> {
+        x1Column, x2Column, x3Column, x4Column, x5Column,
+        v1Column, v2Column, v3Column, v4Column, v5Column,
+        yColumn
+      };
     }
 
@@ -95 +115 @@
   }
 
-  public class VectorDataTestOneA : VectorDataTestOne {
+  public class VectorDataTestFourA : VectorDataTestFour {
     public override string Name {
-      get { return "Vector Data Test - I [fully-constrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; }
+      get { return "Vector Data Test - IV [fully-constrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; }
     }
 
-    public VectorDataTestOneA() : base() { }
-    public VectorDataTestOneA(int seed) : base(seed) { }
+    public VectorDataTestFourA() : base() { }
+    public VectorDataTestFourA(int seed) : base(seed) { }
 
     protected override List<int>[] GetVectorLengths(IRandom rand) {
       // always same length
-      const int length = 5;
-      return new List<int>[2] {
+      const int length = 40;
+      return new List<int>[5] {
+        Enumerable.Repeat(length, Rows).ToList(),
+        Enumerable.Repeat(length, Rows).ToList(),
+        Enumerable.Repeat(length, Rows).ToList(),
         Enumerable.Repeat(length, Rows).ToList(),
         Enumerable.Repeat(length, Rows).ToList()
@@ -113 +136 @@
   }
 
-  public class VectorDataTestOneB : VectorDataTestOne {
-    public override string Name { get { return "Vector Data Test - I [row-constrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; } }
+  public class VectorDataTestFourB : VectorDataTestFour {
+    public override string Name { get { return "Vector Data Test - IV [row-constrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; } }
 
-    public VectorDataTestOneB() : base() { }
-    public VectorDataTestOneB(int seed) : base(seed) { }
+    public VectorDataTestFourB() : base() { }
+    public VectorDataTestFourB(int seed) : base(seed) { }
 
     protected override List<int>[] GetVectorLengths(IRandom rand) {
-      // length between length 4 and 8, same row always the same length
-      var lengths = Enumerable.Range(0, Rows).Select(i => rand.Next(4, 8)).ToList();
-      return new List<int>[2] {
+      // length between length 40 and 80, same row always the same length
+      var lengths = Enumerable.Range(0, Rows).Select(i => rand.Next(40, 80)).ToList();
+      return new List<int>[5] {
+        Enumerable.Range(0, Rows).Select(i => lengths[i]).ToList(),
+        Enumerable.Range(0, Rows).Select(i => lengths[i]).ToList(),
+        Enumerable.Range(0, Rows).Select(i => lengths[i]).ToList(),
         Enumerable.Range(0, Rows).Select(i => lengths[i]).ToList(),
         Enumerable.Range(0, Rows).Select(i => lengths[i]).ToList()
@@ -129 +155 @@
   }
 
-  public class VectorDataTestOneC : VectorDataTestOne {
-    public override string Name { get { return "Vector Data Test - I [column-constrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; } }
+  public class VectorDataTestFourC : VectorDataTestFour {
+    public override string Name { get { return "Vector Data Test - IV [column-constrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; } }
 
-    public VectorDataTestOneC() : base() { }
-    public VectorDataTestOneC(int seed) : base(seed) { }
+    public VectorDataTestFourC() : base() { }
+    public VectorDataTestFourC(int seed) : base(seed) { }
 
     protected override List<int>[] GetVectorLengths(IRandom rand) {
-      // length between length 4 and 8; each feature is same length
-      // force two different lengths
-      int v1Length = rand.Next(4, 8);
+      // length between length 40 and 80; each feature is same length
+      int v1Length = rand.Next(40, 80);
       int v2Length;
-      do {
-        v2Length = rand.Next(4, 8);
-      } while (v1Length != v2Length);
-      return new List<int>[2] {
+      do { v2Length = rand.Next(40, 80); } while (v1Length != v2Length);
+      int v3Length = rand.Next(40, 80);
+      int v4Length;
+      do { v4Length = rand.Next(40, 80); } while (v3Length != v4Length);
+      int v5Length = rand.Next(40, 80);
+      return new List<int>[5] {
         Enumerable.Repeat(v1Length, Rows).ToList(),
-        Enumerable.Repeat(v2Length, Rows).ToList()
+        Enumerable.Repeat(v2Length, Rows).ToList(),
+        Enumerable.Repeat(v3Length, Rows).ToList(),
+        Enumerable.Repeat(v4Length, Rows).ToList(),
+        Enumerable.Repeat(v5Length, Rows).ToList()
       };
     }
   }
 
-  public class VectorDataTestOneD : VectorDataTestOne {
-    public override string Name { get { return "Vector Data Test - I [unconstrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; } }
+  public class VectorDataTestFourD : VectorDataTestFour {
+    public override string Name { get { return "Vector Data Test - IV [unconstrained]: Y = X1 * sum(V1) + X2 * mean(V2)"; } }
 
-    public VectorDataTestOneD() : base() { }
-    public VectorDataTestOneD(int seed) : base(seed) { }
+    public VectorDataTestFourD() : base() { }
+    public VectorDataTestFourD(int seed) : base(seed) { }
 
     protected override List<int>[] GetVectorLengths(IRandom rand) {
-      // always random between 4 and 8
-      return new List<int>[2] {
-          Enumerable.Range(0, Rows).Select(i => rand.Next(4, 8)).ToList(),
-          Enumerable.Range(0, Rows).Select(i => rand.Next(4, 8)).ToList()
-        };
+      // always random between 40 and 80
+      return new List<int>[5] {
+        Enumerable.Range(0, Rows).Select(i => rand.Next(40, 80)).ToList(),
+        Enumerable.Range(0, Rows).Select(i => rand.Next(40, 80)).ToList(),
+        Enumerable.Range(0, Rows).Select(i => rand.Next(40, 80)).ToList(),
+        Enumerable.Range(0, Rows).Select(i => rand.Next(40, 80)).ToList(),
+        Enumerable.Range(0, Rows).Select(i => rand.Next(40, 80)).ToList()
+      };
     }
   }