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

Timestamp:

04/20/17 18:21:01 (7 years ago)

Author:

gkronber

Message:

#2704: added more expression templates

File:

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

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

@@ -24 +24 @@
 using System.Linq;
 using HeuristicLab.Core;
+using HeuristicLab.ExpressionGenerator.Interfaces;
 using HeuristicLab.Random;
 
@@ -32 +33 @@
     }
 
-    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 = "+" };
+    public static Expression RationalExpression(IRandom uniformRandom, Expression[] variables, bool useLog, bool useExp) {
+      var numerators =
+        Enumerable.Range(0, 20)
+          .Select(
+            i =>
+              NonlinearExpressionTemplate(uniformRandom, variables, useLog, useExp, false)
+                .Instantiate("numerator" + i, uniformRandom, sampleWithRepetition: false))
+          .ToArray();
+      var denominators =
+        Enumerable.Range(0, 20)
+          .Select(
+            i =>
+              NonlinearExpressionTemplate(uniformRandom, variables, useLog, useExp, false)
+                .Instantiate("denominator" + i, uniformRandom, sampleWithRepetition: false))
+          .ToArray();
+
+
+      var scaledNumeratorTemplate = new ScalingTemplate(new PointDistribution<double>(1.0));
+      scaledNumeratorTemplate.AddArguments(numerators);
+
+      var scaledDenominatorTemplate = new RangeTemplate(
+        minValue: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 0.01, 1)),
+        valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 2, 10)));
+      scaledDenominatorTemplate.AddArguments(denominators);
+
+
+      var scaledNumerators =
+        Enumerable.Range(0, 20)
+          .Select(i => scaledNumeratorTemplate.Instantiate("scaledNumerator" + i, uniformRandom, false));
+
+      var scaledDenominators =
+        Enumerable.Range(0, 20)
+          .Select(i => scaledDenominatorTemplate.Instantiate("scaledDenom" + i, uniformRandom, false));
+
+      var template = new BinaryOperatorTemplate(Division) { Label = "/" };
+      template.AddLeftArguments(scaledNumerators);
+      template.AddRightArguments(scaledDenominators);
+
+      return template.Instantiate("rational", uniformRandom, false);
+    }
+
+    public static Expression SumOfCompactNonlinearTerms(IRandom uniformRandom, Expression[] variables, bool useLog,
+      bool useExp, bool useFrac) {
+      var numInstances = 2 * variables.Length;
+
+      var scalingVarsTemplate = new ScalingTemplate(new DoublePrngDistribution(new GammaDistributedRandom(uniformRandom, 2, 2))); // exp(x) = 1, var(x) = 8
+      scalingVarsTemplate.AddArguments(variables);
+      var scaledVars = Instantiate(scalingVarsTemplate, uniformRandom, numInstances, "scaledVar");
+
+      var sumOfScaledVarsTemplate = new RandomArityTemplate(Sum, new DiscreteUniformDistribution(uniformRandom, 1, 3)) { Label = "+" };
+      sumOfScaledVarsTemplate.AddArguments(scaledVars);
+      var sumOfScaledVars = Instantiate(sumOfScaledVarsTemplate, uniformRandom, numInstances, "sumOfScaledVars");
+
+      var prodTemplate = new RandomArityTemplate(Product, new DiscreteUniformDistribution(uniformRandom, 1, 3)) { Label = "*" };
+      prodTemplate.AddArguments(variables);
+
+      var logTermsTemplate = LogOfScaledExpression(uniformRandom, sumOfScaledVars,
+      minValue: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 0.1, 2)),
+      valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 1, 10)));
+      var logTerms = Instantiate(logTermsTemplate, uniformRandom, numInstances, "log");
+
+      var expTemplate = ExpOfScaledExpression(uniformRandom, Instantiate(prodTemplate, uniformRandom, numInstances, "prodOfVars"),
+                           minValue: new PointDistribution<double>(-2.0),
+                           valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 4, 6)));
+      var expTerms = Instantiate(expTemplate, uniformRandom, numInstances, "exp");
+
+      var fracTemplate = new BinaryOperatorTemplate(Division) { Label = "/" };
+      fracTemplate.AddLeftArgument(Expression.Constant("const", 1.0), variables.Length);
+      fracTemplate.AddLeftArguments(variables);
+      fracTemplate.AddRightArguments(sumOfScaledVars);
+      var fracTerms = Enumerable.Range(1, numInstances).Select(i => fracTemplate.Instantiate("frac" + i, uniformRandom, false));
+
+      var prodOfFactorsTemplate = new RandomArityTemplate(Product, new DiscreteUniformDistribution(uniformRandom, 1, 4)) { Label = "*" };
+      prodOfFactorsTemplate.AddArguments(variables, variables.Select(_ => 1.0));
+      if (useLog) prodOfFactorsTemplate.AddArguments(logTerms, logTerms.Select(_ => .3));
+      if (useExp) prodOfFactorsTemplate.AddArguments(expTerms, expTerms.Select(_ => .3));
+      if (useFrac) prodOfFactorsTemplate.AddArguments(fracTerms, fracTerms.Select(_ => .3));
+      var prodFactors = Instantiate(prodOfFactorsTemplate, uniformRandom, numInstances, "prod");
+
+      var scaledTermsTemplate =
+        new ScalingTemplate(new DoublePrngDistribution(new GammaDistributedRandom(uniformRandom, 2, 2))); // exp(x) = 1, var(x) = 8
+      scaledTermsTemplate.AddArguments(variables, variables.Select(_ => 1.0));
+      if (useLog) scaledTermsTemplate.AddArguments(logTerms, logTerms.Select(_ => 1.0));
+      if (useExp) scaledTermsTemplate.AddArguments(expTerms, expTerms.Select(_ => 1.0));
+      if (useFrac) scaledTermsTemplate.AddArguments(fracTerms, fracTerms.Select(_ => 1.0));
+      scaledTermsTemplate.AddArguments(prodFactors, prodFactors.Select(_ => 4.0));
+
+      var scaledTerms = Instantiate(scaledTermsTemplate, uniformRandom, 100, "scaledTerm");
+
+      var sumTemplate = new RandomArityTemplate(Sum, arityDistribution: new DiscreteUniformDistribution(uniformRandom, 5, 25)) { Label = "+" };
+      sumTemplate.AddArguments(scaledTerms);
+
+      return sumTemplate.Instantiate("sum", uniformRandom, false);
+    }
+
+    public static Expression NonlinearExpression(IRandom uniformRandom, Expression[] variables, bool useLog, bool useExp, bool useFrac) {
+      return NonlinearExpressionTemplate(uniformRandom, variables, useLog, useExp, useFrac)
+        .Instantiate("nonlinearexpr", uniformRandom, sampleWithRepetition: false);
+    }
+
+    public static ExpressionTemplate NonlinearExpressionTemplate(IRandom uniformRandom, Expression[] variables, bool useLog, bool useExp, bool useFrac) {
+      var scalingTemplate = ScaledExpression(uniformRandom, variables, varianceDistribution: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 1, 10)));
+      var scaledVars = Instantiate(scalingTemplate, uniformRandom, variables.Length, "scaledVar");
+
+      var sumTemplate = new RandomArityTemplate(Sum, new DiscreteUniformDistribution(uniformRandom, 1, 3)) { Label = "+" };
       sumTemplate.AddArguments(scaledVars);
-      var prodTemplate = new RandomArityTemplate(Product, new UniformDistributedRandom(uniformRandom, 1, 3)) { Label = "*" };
+      var prodTemplate = new RandomArityTemplate(Product, new DiscreteUniformDistribution(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"),
-        minValue: new PointDistribution(-3),
-        valueRange: new UniformDistributedRandom(uniformRandom, 4, 6)); 
-
-      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));
+      var logTemplate = LogOfScaledExpression(uniformRandom, Instantiate(sumTemplate, uniformRandom, scaledVars.Count(), "sumOfScaledVars"),
+        minValue: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 0.1, 2)),
+        valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 1, 10)));
+
+      var expTemplate = ExpOfScaledExpression(uniformRandom, Instantiate(prodTemplate, uniformRandom, variables.Length, "prodOfVars"),
+        minValue: new PointDistribution<double>(-3.0),
+        valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 4, 6)));
+
+      var variableSumTemplate = new RandomArityTemplate(Sum, new DiscreteUniformDistribution(uniformRandom, 1, 4)) { Label = "+" };
+      variableSumTemplate.AddArguments(variables);
+      var variableSums = Instantiate(variableSumTemplate, uniformRandom, variables.Length * 2, "varsum");
+
+      var scaledVariableSumTemplate =
+        new RangeTemplate(minValue: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 0.1, 1)),
+          valueRange: new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 1, 5))) { Label = "*" };
+      scaledVariableSumTemplate.AddArguments(variableSums);
+      var scaledVariableSums = Instantiate(scaledVariableSumTemplate, uniformRandom, variables.Length * 2,
+        "scaledvarsum");
+
+      var fracTemplate = new BinaryOperatorTemplate(Division) { Label = "/" };
+      fracTemplate.AddLeftArguments(variables);
+      fracTemplate.AddRightArguments(scaledVariableSums);
+
+      var scaledExprTemplate = new ScalingTemplate(new DoublePrngDistribution(new UniformDistributedRandom(uniformRandom, 1, 10))) { Label = "*" };
+      if (useLog) scaledExprTemplate.AddArguments(Instantiate(logTemplate, uniformRandom, scaledVars.Count(), "log"));
+      if (useExp) scaledExprTemplate.AddArguments(Instantiate(expTemplate, uniformRandom, variables.Length, "exp"));
+      if (useFrac) scaledExprTemplate.AddArguments(Enumerable.Range(0, 20).Select(i => fracTemplate.Instantiate("frac" + i, uniformRandom, false)));
+
+      var mainTemplate = new RandomArityTemplate(Sum, arityDistribution: new DiscreteUniformDistribution(uniformRandom, 3, 5));
       mainTemplate.AddArguments(scaledVars);
       if (useLog || useExp) {
-        mainTemplate.AddArguments(Instantiate(scaledExprTemplate, uniformRandom, 100, "scaledExpr"));
+        mainTemplate.AddArguments(Instantiate(scaledExprTemplate, uniformRandom, 20, "scaledExpr"));
       }
       mainTemplate.Label = "+";
 
-      return mainTemplate.Instantiate("main", uniformRandom, false);
+      return mainTemplate;
     }
 
@@ -67 +184 @@
       int i = 1;
       // the main template
-      var template = new RandomArityTemplate(Sum, new UniformDistributedRandom(uniformRandom, 2, count)) { Label = "+" };
+      var template = new RandomArityTemplate(Sum, arityDistribution: new DiscreteUniformDistribution(uniformRandom, 2, count)) { Label = "+" };
       template.AddArguments(variables);
 
-      var sumTemplate = new RandomArityTemplate(Sum, new UniformDistributedRandom(uniformRandom, 1, variables.Length)) { Label = "+" };
+      var sumTemplate = new RandomArityTemplate(Sum, arityDistribution: new DiscreteUniformDistribution(uniformRandom, 1, variables.Length)) { Label = "+" };
       sumTemplate.AddArguments(variables);
 
-      var productTemplate = new RandomArityTemplate(Product, new UniformDistributedRandom(uniformRandom, 1, variables.Length)) { Label = "*" };
+      var productTemplate = new RandomArityTemplate(Product, arityDistribution: new DiscreteUniformDistribution(uniformRandom, 1, variables.Length)) { Label = "*" };
       productTemplate.AddArguments(variables);
 
@@ -102 +219 @@
 
     // 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);
+    private static ExpressionTemplate ScaledExpression(IRandom uniformRandom, IEnumerable<Expression> arguments, IDistribution<double> varianceDistribution) {
+      var scalingTemplate = new ScalingTemplate(scaledVariance: varianceDistribution);
       scalingTemplate.AddArguments(arguments);
       scalingTemplate.Label = "*";
@@ -111 +228 @@
     /// 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) {
+      IDistribution<double> minValue = null, IDistribution<double> 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)));
+      logTemplate.AddArguments(Enumerable.Range(1, arguments.Count()).Select(i => limitToRangeTemplate.Instantiate(string.Format("log{0}", i), uniformRandom, false)));
       return logTemplate;
     }
@@ -122 +239 @@
     /// template scales the argument expression first to guarantee reasonable values
     private static ExpressionTemplate ExpOfScaledExpression(IRandom uniformRandom, IEnumerable<Expression> arguments,
-      IRandom minValue = null,
-      IRandom valueRange = null) {
+      IDistribution<double> minValue = null,
+      IDistribution<double> valueRange = null) {
       var limitToRangeTemplate = new RangeTemplate(minValue, 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)));
+      expTemplate.AddArguments(Enumerable.Range(1, arguments.Count()).Select(i => limitToRangeTemplate.Instantiate(string.Format("exp{0}", i), uniformRandom, false)));
       return expTemplate;
     }