source: branches/2974_Constants_Optimization/Benchmarks/Benchmarks/ConstantsOptimizationPerformance.cs @ 16525

using BenchmarkDotNet.Attributes;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Problems.DataAnalysis.Symbolic.ConstantsOptimization;
using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
using HeuristicLab.Problems.Instances.DataAnalysis;
using HeuristicLab.Random;
using System.Collections.Generic;
using System.Linq;

namespace HeuristicLab.Benchmarks {
  [ClrJob]
  [MinColumn, MaxColumn, MeanColumn, MedianColumn]
  public class ConstantsOptimizationPerformance {
    private static readonly int seed = 1234;
    private static readonly int maxTreeSize = 50;
    private static readonly int nTrees = 1000;

    private ISymbolicExpressionTree[] trees;
    private IRegressionProblemData problemData;
    private TypeCoherentExpressionGrammar grammar;
    private int[] rows;

    private readonly ISymbolicDataAnalysisExpressionTreeInterpreter interpreter = new SymbolicDataAnalysisExpressionTreeLinearInterpreter();

    [GlobalSetup]
    public void Setup() {
      var twister = new MersenneTwister((uint)seed);
      problemData = new RegressionRealWorldInstanceProvider().LoadData(new Tower());
      rows = Enumerable.Range(0, Rows).ToArray();

      grammar = new TypeCoherentExpressionGrammar();
      grammar.ConfigureAsDefaultRegressionGrammar();

      trees = Util.CreateRandomTrees(twister, problemData.Dataset, grammar, nTrees, 1, maxTreeSize, 0, 0);
      foreach (SymbolicExpressionTree tree in trees) {
        Util.InitTree(tree, twister, problemData.AllowedInputVariables.ToList());
      }
    }

    //public IEnumerable<int> RowsValues => Util.IntRange(100, 5000, 100, closed: true);
    //public IEnumerable<int> RowsValues => new[] { 100, 250, 500, 750, 1000, 1500, 2000, 3000, 4000, 4999 };
    public IEnumerable<int> RowsValues => new[] { 4999 };
    public IEnumerable<int> IterationsValues => Util.IntRange(5, 30, 5, closed: true);
    //public IEnumerable<int> IterationsValues => new[] { 0 };

    [ParamsSource(nameof(RowsValues))]
    public int Rows { get; set; }

    [ParamsSource(nameof(IterationsValues))]
    public int Iterations { get; set; }

    [Benchmark]
    public double Tower() {
      double avgQuality = 0;

      if (Iterations > 0) {
        for (int i = 0; i < trees.Length; i++) {
          avgQuality += LMConstantsOptimizer.OptimizeConstants(trees[i], problemData.Dataset, problemData.TargetVariable, rows, true, Iterations);
        }
      } else {
        for (int i = 0; i < trees.Length; i++) {
          avgQuality += SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, trees[i], double.MinValue, double.MaxValue, problemData, rows, true);
        }
      }
      return avgQuality / trees.Length;
    }
  }
}