Changeset 14873 for branches/HeuristicLab.ExpressionGenerator/HeuristicLab.ExpressionGenerator/3.4/ExpressionGenerator.cs

Timestamp:

04/15/17 08:44:15 (7 years ago)

Author:

gkronber

Message:

#2704: added possibility to automatically adjust constants based on the distributions of evaluated expressions to allow limiting distributions for arguments of functions (e.g. log should have positive args only, exp should have rather small args only)

File:

• branches/HeuristicLab.ExpressionGenerator/HeuristicLab.ExpressionGenerator/3.4/ExpressionGenerator.cs (modified) (5 diffs)

branches/HeuristicLab.ExpressionGenerator/HeuristicLab.ExpressionGenerator/3.4/ExpressionGenerator.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.InteropServices;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Random;
@@ -30 +32 @@
     public static IEnumerable<Expression> GenerateRandomDistributedVariables(int numberOfVariables, string variablePrefix, IRandom randomDistribution) {
       return Enumerable.Range(1, numberOfVariables).Select(x => Expression.RandomVariable(string.Format("{0}{1}", variablePrefix, x), randomDistribution));
+    }
+
+    public static Expression NonlinearExpression(IRandom uniformRandom, Expression[] variables, bool useLog, bool useExp) {
+      var scalingTemplate = ScaledExpression(uniformRandom, variables, varianceRandom: new UniformDistributedRandom(uniformRandom, 1, 10));
+      var scaledVars = Instantiate(scalingTemplate, uniformRandom, 100, "scaledVar");
+
+      var sumTemplate = new RandomArityTemplate(Sum, new UniformDistributedRandom(uniformRandom, 1, 3)) { Label = "+" };
+      sumTemplate.AddArguments(scaledVars);
+      var prodTemplate = new RandomArityTemplate(Product, new UniformDistributedRandom(uniformRandom, 1, 3)) { Label = "*" };
+      prodTemplate.AddArguments(variables);
+
+      var logTemplate = LogOfScaledExpression(uniformRandom, Instantiate(sumTemplate, uniformRandom, 100, "sumOfScaledVars"),
+        minValue: new UniformDistributedRandom(uniformRandom, 0.1, 2),
+        valueRange: new UniformDistributedRandom(uniformRandom, 1, 10));
+
+      var expTemplate = ExpOfScaledExpression(uniformRandom, Instantiate(prodTemplate, uniformRandom, 100, "prodOfVars"),
+        valueRange: new UniformDistributedRandom(uniformRandom, 1, 4)); // TODO should also specify an offset
+
+      var scaledExprTemplate = new ScalingTemplate(new UniformDistributedRandom(uniformRandom, 1, 10)) { Label = "*" };
+      if (useLog) scaledExprTemplate.AddArguments(Instantiate(logTemplate, uniformRandom, 100, "log"));
+      if (useExp) scaledExprTemplate.AddArguments(Instantiate(expTemplate, uniformRandom, 100, "exp"));
+
+      var mainTemplate = new RandomArityTemplate(Sum, new UniformDistributedRandom(uniformRandom, 3, 5));
+      mainTemplate.AddArguments(scaledVars);
+      if (useLog || useExp) {
+        mainTemplate.AddArguments(Instantiate(scaledExprTemplate, uniformRandom, 100, "scaledExpr"));
+      }
+      mainTemplate.Label = "+";
+
+      return mainTemplate.Instantiate("main", uniformRandom, false);
     }
 
@@ -70 +102 @@
     }
 
+    // variance random must have support only positive numbers
+    private static ExpressionTemplate ScaledExpression(IRandom uniformRandom, IEnumerable<Expression> arguments, IRandom varianceRandom) {
+      var scalingTemplate = new ScalingTemplate(scaledVariance: varianceRandom);
+      scalingTemplate.AddArguments(arguments);
+      scalingTemplate.Label = "*";
+      return scalingTemplate;
+    }
+
+    /// template scales and translates the argument expression first to guarantee positive values
+    private static ExpressionTemplate LogOfScaledExpression(IRandom uniformRandom, IEnumerable<Expression> arguments,
+      IRandom minValue = null, IRandom valueRange = null) {
+      var limitToRangeTemplate = new RangeTemplate(minValue, valueRange);
+      limitToRangeTemplate.AddArguments(arguments);
+
+      var logTemplate = new FixedArityTemplate(Log, 1) { Label = "log" };
+      logTemplate.AddArguments(Enumerable.Range(1, 100).Select(i => limitToRangeTemplate.Instantiate(string.Format("log{0}", i), uniformRandom, false)));
+      return logTemplate;
+    }
+
+    /// template scales the argument expression first to guarantee reasonable values
+    private static ExpressionTemplate ExpOfScaledExpression(IRandom uniformRandom, IEnumerable<Expression> arguments,
+      IRandom valueRange = null) {
+      var limitToRangeTemplate = new RangeTemplate(null, valueRange);
+      limitToRangeTemplate.AddArguments(arguments);
+
+      var expTemplate = new FixedArityTemplate(Exp, 1) { Label = "exp" };
+      expTemplate.AddArguments(Enumerable.Range(1, 100).Select(i => limitToRangeTemplate.Instantiate(string.Format("exp{0}", i), uniformRandom, false)));
+      return expTemplate;
+    }
+
+    public static IEnumerable<Expression> Instantiate(ExpressionTemplate template, IRandom random, int count, string name) {
+      return Enumerable.Range(1, count).Select(i => template.Instantiate(name + i, random, false));
+    }
+
     #region static functions
-    private static double Sum(IEnumerable<double> args) {
+    public static double Sum(IEnumerable<double> args) {
       return args.Sum();
     }
 
-    private static double Product(IEnumerable<double> args) {
+    public static double Product(IEnumerable<double> args) {
       return args.Aggregate((x, y) => x * y);
     }
 
-    private static double Division(IEnumerable<double> args) {
+    public static double Division(IEnumerable<double> args) {
       if (args.Count() == 1)
         return 1 / args.First();
@@ -86 +152 @@
     }
 
-    private static double Subtraction(IEnumerable<double> args) {
+    public static double Subtraction(IEnumerable<double> args) {
       if (args.Count() == 1)
         return -args.First();
@@ -93 +159 @@
     }
 
-    private static double Exp(IEnumerable<double> args) {
+    public static double Exp(IEnumerable<double> args) {
       return Math.Exp(args.Single());
     }
 
-    private static double Log(IEnumerable<double> args) {
+    public static double Log(IEnumerable<double> args) {
       return Math.Log(args.Single());
     }
 
-    private static double Square(IEnumerable<double> args) {
+    public static double Square(IEnumerable<double> args) {
       var v = args.Single();
       return v * v;