source: branches/HeuristicLab.Problems.GPDL/CodeGenerator/RandomSearchCodeGen.cs @ 10086

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using HeuristicLab.Grammars;
using Attribute = HeuristicLab.Grammars.Attribute;

namespace CodeGenerator {
  public class RandomSearchCodeGen {

    private string usings = @"
using System.Collections.Generic;
using System.Linq;
using System;
";

    private string solverTemplate = @"
namespace ?PROBLEMNAME? {
  public sealed class ?IDENT?Solver {
    public sealed class SolverState {
      private int currentSeed;
      public Random random;
      public int depth;
      public int steps;
      public int maxDepth;
      public SolverState(int seed) {
        this.currentSeed = seed;
      }

      public SolverState IncDepth() {
        depth++;
        if(depth>maxDepth) maxDepth = depth;
        return this;
      }
      public SolverState Prepare() {
        this.random = new Random(currentSeed);
        depth = 0;
        maxDepth = 0;
        steps = 0;
        return this;
      }
    }

    public static void Main(string[] args) {
      var solver = new ?IDENT?Solver();
      solver.Start();
    }

    public ?IDENT?Solver() { 
      Initialize();
    }    

    private void Initialize() {
      ?INITCODE?
    }

    private bool IsBetter(double a, double b) { 
      return ?MAXIMIZATION? ? a > b : a < b;
    }

    private double TerminalProbForDepth(int depth) {
      const double baseProb = 0.05;  // 5% of all samples are only a terminal node
      const double probIncPerLevel = 0.05; // for each level the probability to sample a terminal grows by 5%
      return baseProb + depth * probIncPerLevel;
    }

    private SolverState _state;
    private void Start() {
      var seedRandom = new Random();
      var bestF = ?MAXIMIZATION? ? double.NegativeInfinity : double.PositiveInfinity;
      int n = 0;
      var sw = new System.Diagnostics.Stopwatch();
      sw.Start();
      while (true) {

        // must make sure that calling the start-symbol multiple times in the fitness function always leads to the same path through the grammar
        // so we use a PRNG for generating seeds for a separate PRNG that is reset each time the start symbol is called
        
        _state = new SolverState(seedRandom.Next());

        var f = Calculate();

        n++;
        if (IsBetter(f, bestF)) {
          bestF = f;
          Console.WriteLine(""{0}\t{1}\t(depth={2})"", n, bestF, _state.maxDepth);
        }
        if (n % 1000 == 0) {
          sw.Stop();
          Console.WriteLine(""{0}\t{1}\t{2}\t({3:0.00} sols/ms)"", n, bestF, f, 1000.0 / sw.ElapsedMilliseconds);
          sw.Reset();
          sw.Start();
        }
      }
    }

    public double Calculate() {
      ?FITNESSFUNCTION?
    }

    ?ADDITIONALCODE?

    ?INTERPRETERSOURCE?

    ?CONSTRAINTSSOURCE?
  }
}";


    /// <summary>
    /// Generates the source code for a brute force searcher that can be compiled with a C# compiler
    /// </summary>
    /// <param name="ast">An abstract syntax tree for a GPDL file</param>
    public void Generate(GPDefNode ast) {
      var problemSourceCode = new StringBuilder();
      problemSourceCode.AppendLine(usings);

      GenerateProblem(ast, problemSourceCode);

      problemSourceCode.Replace("?PROBLEMNAME?", ast.Name);

      // write the source file to disk
      using (var stream = new StreamWriter(ast.Name + ".cs")) {
        stream.WriteLine(problemSourceCode.ToString());
      }
    }

    private void GenerateProblem(GPDefNode ast, StringBuilder problemSourceCode) {
      var grammar = CreateGrammarFromAst(ast);
      var problemClassCode =
        solverTemplate
          .Replace("?MAXIMIZATION?", ast.FitnessFunctionNode.Maximization.ToString().ToLowerInvariant())
          .Replace("?IDENT?", ast.Name)
          .Replace("?FITNESSFUNCTION?", ast.FitnessFunctionNode.SrcCode)
          .Replace("?INTERPRETERSOURCE?", GenerateInterpreterSource(grammar))
          .Replace("?INITCODE?", ast.InitCodeNode.SrcCode)
          .Replace("?ADDITIONALCODE?", ast.ClassCodeNode.SrcCode)
          .Replace("?CONSTRAINTSSOURCE?", GenerateConstraintMethods(ast.Terminals))
          ;

      problemSourceCode.AppendLine(problemClassCode).AppendLine();
    }

    #region create grammar instance from AST
    private AttributedGrammar CreateGrammarFromAst(GPDefNode ast) {

      var nonTerminals = ast.NonTerminals.Select(t => new Symbol(t.Ident, GetSymbolAttributes(t.FormalParameters))).ToArray();
      var terminals = ast.Terminals.Select(t => new Symbol(t.Ident, GetSymbolAttributes(t.FormalParameters))).ToArray();
      string startSymbolName = ast.Rules.First().NtSymbol;

      // create startSymbol
      var startSymbol = nonTerminals.Single(s => s.Name == startSymbolName);
      var g = new AttributedGrammar(startSymbol, nonTerminals, terminals);

      // add all production rules
      foreach (var rule in ast.Rules) {
        var ntSymbol = nonTerminals.Single(s => s.Name == rule.NtSymbol);
        foreach (var alt in GetAlternatives(rule.Alternatives, nonTerminals.Concat(terminals))) {
          g.AddProductionRule(ntSymbol, alt);
        }
        // local initialization code
        if (!string.IsNullOrEmpty(rule.LocalCode)) g.AddLocalDefinitions(ntSymbol, rule.LocalCode);
      }
      return g;
    }

    private IEnumerable<IAttribute> GetSymbolAttributes(string formalParameters) {
      return (from fieldDef in Util.ExtractParameters(formalParameters)
              select new Attribute(fieldDef.Identifier, fieldDef.Type, AttributeType.Parse(fieldDef.RefOrOut))).
        ToList();
    }

    private IEnumerable<Sequence> GetAlternatives(AlternativesNode altNode, IEnumerable<ISymbol> allSymbols) {
      foreach (var alt in altNode.Alternatives) {
        yield return GetSequence(alt.Sequence, allSymbols);
      }
    }

    private Sequence GetSequence(IEnumerable<RuleExprNode> sequence, IEnumerable<ISymbol> allSymbols) {
      Debug.Assert(sequence.All(s => s is CallSymbolNode || s is RuleActionNode));
      var l = new List<ISymbol>();
      foreach (var node in sequence) {
        var callSymbolNode = node as CallSymbolNode;
        var actionNode = node as RuleActionNode;
        if (callSymbolNode != null) {
          Debug.Assert(allSymbols.Any(s => s.Name == callSymbolNode.Ident));
          // create a new symbol with actual parameters
          l.Add(new Symbol(callSymbolNode.Ident, GetSymbolAttributes(callSymbolNode.ActualParameter)));
        } else if (actionNode != null) {
          l.Add(new SemanticSymbol("SEM", actionNode.SrcCode));
        }
      }
      return new Sequence(l);
    }
    #endregion

    #region helper methods for terminal symbols
    // produces helper methods for the attributes of all terminal nodes
    private string GenerateConstraintMethods(List<SymbolNode> symbols) {
      var sb = new StringBuilder();
      var terminals = symbols.OfType<TerminalNode>();
      foreach (var t in terminals) {
        sb.AppendLine(GenerateConstraintMethods(t));
      }
      return sb.ToString();
    }

    // generates helper methods for the attributes of a given terminal node
    private string GenerateConstraintMethods(TerminalNode t) {
      var sb = new StringBuilder();
      foreach (var c in t.Constraints) {
        var fieldType = t.FieldDefinitions.First(d => d.Identifier == c.Ident).Type;
        if (c.Type == ConstraintNodeType.Range) {
          sb.AppendFormat("public {0} GetMax{1}_{2}() {{ return {3}; }}", fieldType, t.Ident, c.Ident, c.RangeMaxExpression).AppendLine();
          sb.AppendFormat("public {0} GetMin{1}_{2}() {{ return {3}; }}", fieldType, t.Ident, c.Ident, c.RangeMinExpression).AppendLine();
          sb.AppendFormat("public {0} GetRandom{1}_{2}(SolverState _state) {{ return _state.random.NextDouble() * (GetMax{1}_{2}() - GetMin{1}_{2}()) + GetMin{1}_{2}(); }}", fieldType, t.Ident, c.Ident).AppendLine();
        } else if (c.Type == ConstraintNodeType.Set) {
          sb.AppendFormat("public IEnumerable<{0}> GetAllowed{1}_{2}() {{ return {3}; }}", fieldType, t.Ident, c.Ident, c.SetExpression).AppendLine();
          sb.AppendFormat("public {0} GetRandom{1}_{2}(SolverState _state) {{ var tmp = GetAllowed{1}_{2}().ToArray(); return tmp[_state.random.Next(tmp.Length)]; }}", fieldType, t.Ident, c.Ident).AppendLine();
        }
      }
      return sb.ToString();
    }
    #endregion

    private string GenerateInterpreterSource(AttributedGrammar grammar) {
      var sb = new StringBuilder();

      // generate methods for all nonterminals and terminals using the grammar instance
      foreach (var s in grammar.NonTerminalSymbols) {
        sb.AppendLine(GenerateInterpreterMethod(grammar, s));
      }
      foreach (var s in grammar.TerminalSymbols) {
        sb.AppendLine(GenerateTerminalInterpreterMethod(s));
      }
      return sb.ToString();
    }

    private string GenerateInterpreterMethod(AttributedGrammar g, ISymbol s) {
      var sb = new StringBuilder();

      // if this is the start symbol we additionally have to create the method which can be called from the fitness function
      if (g.StartSymbol.Equals(s)) {
        if (!s.Attributes.Any())
          sb.AppendFormat("private void {0}() {{", s.Name);
        else
          sb.AppendFormat("private void {0}({1}) {{", s.Name, s.GetAttributeString());

        // get formal parameters of start symbol
        var attr = g.StartSymbol.Attributes;

        // actual parameter are the same as formalparameter only without type identifier
        string actualParameter;
        if (attr.Any())
          actualParameter = attr.Skip(1).Aggregate(attr.First().AttributeType + " " + attr.First().Name, (str, a) => str + ", " + a.AttributeType + " " + a.Name);
        else
          actualParameter = string.Empty;

        sb.AppendFormat("{0}(_state.Prepare(), {1});", g.StartSymbol.Name, actualParameter).AppendLine();
        sb.AppendLine("}");
      }

      if (!s.Attributes.Any())
        sb.AppendFormat("private void {0}(SolverState _state) {{", s.Name);
      else
        sb.AppendFormat("private void {0}(SolverState _state, {1}) {{", s.Name, s.GetAttributeString());

      // generate local definitions
      sb.AppendLine(g.GetLocalDefinitions(s));


      var altsWithSemActions = g.GetAlternativesWithSemanticActions(s).ToArray();
      var terminalAlts = altsWithSemActions.Where(alt => alt.Count(g.IsNonTerminal) == 0);
      var nonTerminalAlts = altsWithSemActions.Where(alt => alt.Count(g.IsNonTerminal) > 0);
      bool hasTerminalAlts = terminalAlts.Any();
      bool hasNonTerminalAlts = nonTerminalAlts.Any();

      if (altsWithSemActions.Length > 1) {
        // here we need to bias the selection of alternatives (non-terminal vs terminal alternatives) to make sure that
        // terminals are selected with a certain probability to make sure that:
        // 1) we don't create the same small trees all the time (terminals have high probability to be selected)
        // 2) we don't create very big trees by recursing to deep (leads to stack-overflow) (terminals have a low probability to be selected)
        // so we first decide if we want to generate a terminal or non-terminal (50%, 50%) and then choose a symbol in the class randomly
        // the probability of choosing terminals should depend on the depth of the tree (small likelihood to choose terminals for small depths, large likelihood for large depths)
        if (hasTerminalAlts && hasNonTerminalAlts) {
          sb.AppendLine("if(_state.random.NextDouble() < TerminalProbForDepth(_state.depth)) {");
          // terminals
          sb.AppendLine("// terminals ");
          GenerateSwitchStatement(sb, terminalAlts);
          sb.AppendLine("} else {");
          // non-terminals
          sb.AppendLine("// non-terminals ");
          GenerateSwitchStatement(sb, nonTerminalAlts);
          sb.AppendLine("}");
        } else if (hasTerminalAlts) {
          sb.AppendLine("// terminals ");
          GenerateSwitchStatement(sb, terminalAlts);
        } else if (hasNonTerminalAlts) {
          sb.AppendLine("// non-terminals ");
          GenerateSwitchStatement(sb, nonTerminalAlts);
        }
      } else {
        foreach (var altSymb in altsWithSemActions.Single()) {
          sb.AppendLine(GenerateSourceForAction(altSymb));
        }
      }
      sb.AppendLine("}");
      return sb.ToString();
    }

    private void GenerateSwitchStatement(StringBuilder sb, IEnumerable<Sequence> alts) {
      sb.AppendFormat("switch(_state.random.Next({0})) {{", alts.Count());
      // generate a case for each alternative
      int i = 0;
      foreach (var alt in alts) {
        sb.AppendFormat("case {0}: {{ ", i).AppendLine();

        // this only works for alternatives with a single non-terminal symbol (ignoring semantic symbols) so far!
        // a way to handle this is through grammar transformation (the examplary grammars all have the correct from)
        Debug.Assert(alt.Count(symb => !(symb is SemanticSymbol)) == 1);
        foreach (var altSymb in alt) {
          sb.AppendLine(GenerateSourceForAction(altSymb));
        }
        i++;
        sb.AppendLine("break;").AppendLine("}");
      }
      sb.AppendLine("default: throw new System.InvalidOperationException();").AppendLine("}");

    }

    // helper for generating calls to other symbol methods
    private string GenerateSourceForAction(ISymbol s) {
      var action = s as SemanticSymbol;
      if (action != null) {
        return action.Code + ";";
      } else {
        if (!s.Attributes.Any())
          return string.Format("{0}(_state.IncDepth()); _state.depth--;", s.Name);
        else
          return string.Format("{0}(_state.IncDepth(), {1}); _state.depth--;", s.Name, s.GetAttributeString());
      }
    }

    private string GenerateTerminalInterpreterMethod(ISymbol s) {
      var sb = new StringBuilder();
      // if the terminal symbol has attributes then we must samples values for these attributes
      if (!s.Attributes.Any())
        sb.AppendFormat("private void {0}(SolverState _state) {{", s.Name);
      else
        sb.AppendFormat("private void {0}(SolverState _state, {1}) {{", s.Name, s.GetAttributeString());

      // each field must match a formal parameter, assign a value for each parameter
      foreach (var element in s.Attributes) {
        sb.AppendFormat("{{ {0} = GetRandom{1}_{0}(_state); }} ", element.Name, s.Name);
      }
      sb.AppendLine("}");
      return sb.ToString();
    }
  }
}