source: branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/GrammarEnumerationAlgorithm.cs @ 15812

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.GrammarEnumeration;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;

namespace HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration {
  [Item("Grammar Enumeration Symbolic Regression", "Iterates all possible model structures for a fixed grammar.")]
  [StorableClass]
  [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 250)]
  public class GrammarEnumerationAlgorithm : FixedDataAnalysisAlgorithm<IRegressionProblem> {
    #region properties and result names
    private readonly string BestTrainingQualityName = "Best R² (Training)";
    private readonly string BestTrainingSolutionName = "Best solution (Training)";
    private readonly string SearchStructureSizeName = "Search Structure Size";
    private readonly string GeneratedPhrasesName = "Generated/Archived Phrases";
    private readonly string GeneratedSentencesName = "Generated Sentences";
    private readonly string DistinctSentencesName = "Distinct Sentences";
    private readonly string PhraseExpansionsName = "Phrase Expansions";
    private readonly string AverageTreeLengthName = "Avg. Sentence Length among Distinct";
    private readonly string GeneratedEqualSentencesName = "Generated equal sentences";


    private readonly string SearchDataStructureParameterName = "Search Data Structure";
    private readonly string MaxTreeSizeParameterName = "Max. Tree Nodes";
    private readonly string GuiUpdateIntervalParameterName = "GUI Update Interval";

    public override bool SupportsPause { get { return false; } }

    protected IValueParameter<IntValue> MaxTreeSizeParameter {
      get { return (IValueParameter<IntValue>)Parameters[MaxTreeSizeParameterName]; }
    }
    public int MaxTreeSize {
      get { return MaxTreeSizeParameter.Value.Value; }
      set { MaxTreeSizeParameter.Value.Value = value; }
    }

    protected IValueParameter<IntValue> GuiUpdateIntervalParameter {
      get { return (IValueParameter<IntValue>)Parameters[GuiUpdateIntervalParameterName]; }
    }
    public int GuiUpdateInterval {
      get { return GuiUpdateIntervalParameter.Value.Value; }
      set { GuiUpdateIntervalParameter.Value.Value = value; }
    }

    protected IValueParameter<EnumValue<StorageType>> SearchDataStructureParameter {
      get { return (IValueParameter<EnumValue<StorageType>>)Parameters[SearchDataStructureParameterName]; }
    }
    public StorageType SearchDataStructure {
      get { return SearchDataStructureParameter.Value.Value; }
      set { SearchDataStructureParameter.Value.Value = value; }
    }

    public SymbolString BestTrainingSentence;

    #endregion

    public Dictionary<int, SymbolString> DistinctSentences { get; private set; }  // Semantically distinct sentences in a run.
    public Dictionary<int, List<SymbolString>> AllSentences { get; private set; } // All sentences ever generated in a run.
    public HashSet<int> ArchivedPhrases { get; private set; }

    internal SearchDataStore OpenPhrases { get; private set; }                    // Stack/Queue/etc. for fetching the next node in the search tree.  

    public int EqualGeneratedSentences { get; private set; } // It is not guaranteed that shorter solutions are found first. 
                                                             // When longer solutions are overwritten with shorter ones, 
                                                             // this counter is increased.
    public int Expansions { get; private set; }              // Number, how many times a nonterminal symbol is replaced with a production rule.
    public Grammar Grammar { get; private set; }

    private readonly string dotFileName = Environment.GetFolderPath(System.Environment.SpecialFolder.DesktopDirectory) + @"\searchgraph.dot";

    #region ctors
    public override IDeepCloneable Clone(Cloner cloner) {
      return new GrammarEnumerationAlgorithm(this, cloner);
    }

    public GrammarEnumerationAlgorithm() {
      Problem = new RegressionProblem() {
        ProblemData = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenFunctionNine(seed: 1234).GenerateRegressionData()
      };

      Parameters.Add(new ValueParameter<IntValue>(MaxTreeSizeParameterName, "The number of clusters.", new IntValue(6)));
      Parameters.Add(new ValueParameter<IntValue>(GuiUpdateIntervalParameterName, "Number of generated sentences, until GUI is refreshed.", new IntValue(1000)));
      Parameters.Add(new ValueParameter<EnumValue<StorageType>>(SearchDataStructureParameterName, new EnumValue<StorageType>(StorageType.Stack)));
    }

    public GrammarEnumerationAlgorithm(GrammarEnumerationAlgorithm original, Cloner cloner) : base(original, cloner) { }
    #endregion

    protected override void Run(CancellationToken cancellationToken) {
      #region init
      InitResults();

      AllSentences = new Dictionary<int, List<SymbolString>>();
      ArchivedPhrases = new HashSet<int>();

      DistinctSentences = new Dictionary<int, SymbolString>();
      Expansions = 0;
      EqualGeneratedSentences = 0;

      Grammar = new Grammar(Problem.ProblemData.AllowedInputVariables.ToArray());

      OpenPhrases = new SearchDataStore(SearchDataStructure); // Select search strategy
      var phrase0 = new SymbolString(new[] { Grammar.StartSymbol });
      var phrase0Hash = Grammar.CalcHashCode(phrase0);
      #endregion

      using (TextWriterTraceListener dotFileTrace = new TextWriterTraceListener(new FileStream(dotFileName, FileMode.Create))) {
        LogSearchGraph(dotFileTrace, "digraph searchgraph {");

        OpenPhrases.Store(phrase0Hash, phrase0);
        while (OpenPhrases.Count > 0) {
          if (cancellationToken.IsCancellationRequested) break;

          StoredSymbolString fetchedPhrase = OpenPhrases.GetNext();
          SymbolString currPhrase = fetchedPhrase.SymbolString;
#if DEBUG
          LogSearchGraph(dotFileTrace, $"{fetchedPhrase.Hash} [label=\"{Grammar.PostfixToInfixParser(fetchedPhrase.SymbolString)}\"];");
#endif
          ArchivedPhrases.Add(fetchedPhrase.Hash);

          // expand next nonterminal symbols
          int nonterminalSymbolIndex = currPhrase.FindIndex(s => s is NonterminalSymbol);
          NonterminalSymbol expandedSymbol = currPhrase[nonterminalSymbolIndex] as NonterminalSymbol;

          foreach (Production productionAlternative in expandedSymbol.Alternatives) {
            SymbolString newPhrase = new SymbolString(currPhrase.Count + productionAlternative.Count);
            newPhrase.AddRange(currPhrase);
            newPhrase.RemoveAt(nonterminalSymbolIndex);     // TODO: removeat and insertRange are both O(n)
            newPhrase.InsertRange(nonterminalSymbolIndex, productionAlternative);

            Expansions++;
            if (newPhrase.Count <= MaxTreeSize) {
              var phraseHash = Grammar.CalcHashCode(newPhrase);
#if DEBUG
              LogSearchGraph(dotFileTrace, $"{fetchedPhrase.Hash} -> {phraseHash} [label=\"{expandedSymbol.StringRepresentation} + &rarr; {productionAlternative}\"];");
#endif
              if (newPhrase.IsSentence()) {
                // Sentence was generated.
                SaveToAllSentences(phraseHash, newPhrase);

                if (!DistinctSentences.ContainsKey(phraseHash) || DistinctSentences[phraseHash].Count > newPhrase.Count) {
                  if (DistinctSentences.ContainsKey(phraseHash)) EqualGeneratedSentences++; // for analysis only

                  DistinctSentences[phraseHash] = newPhrase;
                  EvaluateSentence(newPhrase);

#if DEBUG
                  LogSearchGraph(dotFileTrace, $"{phraseHash} [label=\"{Grammar.PostfixToInfixParser(newPhrase)}\", style=\"filled\"];");
#endif
                }
                UpdateView();

              } else if (!OpenPhrases.Contains(phraseHash) && !ArchivedPhrases.Contains(phraseHash)) {
                OpenPhrases.Store(phraseHash, newPhrase);
              }
            }
          }
        }
#if DEBUG
        // Overwrite formatting of start search node and best found solution.
        LogSearchGraph(dotFileTrace, $"{Grammar.CalcHashCode(BestTrainingSentence)} [label=\"{Grammar.PostfixToInfixParser(BestTrainingSentence)}\", shape=Mcircle, style=\"filled,bold\"];");
        LogSearchGraph(dotFileTrace, $"{phrase0Hash} [label=\"{Grammar.PostfixToInfixParser(phrase0)}\", shape=doublecircle];}}");
        dotFileTrace.Flush();
#endif
      }

      UpdateView(force: true);
      UpdateFinalResults();
    }

    // Store sentence to "MultiDictionary"
    private void SaveToAllSentences(int hash, SymbolString sentence) {
      if (AllSentences.ContainsKey(hash))
        AllSentences[hash].Add(sentence);
      else
        AllSentences[hash] = new List<SymbolString> { sentence }; //TODO: here we store all sentences even if they have the same hash value, this is not strictly necessary
    }

#region Evaluation of generated models.

    // Evaluate sentence within an algorithm run.
    private void EvaluateSentence(SymbolString symbolString) {
      SymbolicExpressionTree tree = Grammar.ParseSymbolicExpressionTree(symbolString);
      SymbolicRegressionModel model = new SymbolicRegressionModel(
        Problem.ProblemData.TargetVariable,
        tree,
        new SymbolicDataAnalysisExpressionTreeLinearInterpreter());

      var probData = Problem.ProblemData;
      var target = probData.TargetVariableTrainingValues;
      var estVals = model.GetEstimatedValues(probData.Dataset, probData.TrainingIndices);
      OnlineCalculatorError error;
      var r2 = OnlinePearsonsRSquaredCalculator.Calculate(target, estVals, out error);
      if (error != OnlineCalculatorError.None) r2 = 0.0;

      var bestR2 = ((DoubleValue)Results[BestTrainingQualityName].Value).Value;
      if (r2 > bestR2) {
        ((DoubleValue)Results[BestTrainingQualityName].Value).Value = r2;
        BestTrainingSentence = symbolString;
      }
    }

#endregion

#region Visualization in HL
    // Initialize entries in result set.
    private void InitResults() {
      BestTrainingSentence = null;

      Results.Add(new Result(BestTrainingQualityName, new DoubleValue(-1.0)));

      Results.Add(new Result(GeneratedPhrasesName, new IntValue(0)));
      Results.Add(new Result(SearchStructureSizeName, new IntValue(0)));
      Results.Add(new Result(GeneratedSentencesName, new IntValue(0)));
      Results.Add(new Result(DistinctSentencesName, new IntValue(0)));
      Results.Add(new Result(PhraseExpansionsName, new IntValue(0)));
      Results.Add(new Result(GeneratedEqualSentencesName, new IntValue(0)));
      Results.Add(new Result(AverageTreeLengthName, new DoubleValue(1.0)));
    }

    // Update the view for intermediate results in an algorithm run.
    private int updates;
    private void UpdateView(bool force = false) {
      updates++;

      if (force || updates % GuiUpdateInterval == 1) {
        var allGeneratedEnum = AllSentences.Values.SelectMany(x => x).ToArray();
        ((IntValue)Results[GeneratedPhrasesName].Value).Value = ArchivedPhrases.Count;
        ((IntValue)Results[SearchStructureSizeName].Value).Value = OpenPhrases.Count;
        ((IntValue)Results[GeneratedSentencesName].Value).Value = allGeneratedEnum.Length;
        ((IntValue)Results[DistinctSentencesName].Value).Value = DistinctSentences.Count;
        ((IntValue)Results[PhraseExpansionsName].Value).Value = Expansions;
        ((IntValue)Results[GeneratedEqualSentencesName].Value).Value = EqualGeneratedSentences;
        ((DoubleValue)Results[AverageTreeLengthName].Value).Value = allGeneratedEnum.Select(sentence => sentence.Count).Average();
      }
    }

    // Generate all Results after an algorithm run.
    private void UpdateFinalResults() {
      SymbolicExpressionTree tree = Grammar.ParseSymbolicExpressionTree(BestTrainingSentence);
      SymbolicRegressionModel model = new SymbolicRegressionModel(
        Problem.ProblemData.TargetVariable,
        tree,
        new SymbolicDataAnalysisExpressionTreeLinearInterpreter());

      IRegressionSolution bestTrainingSolution = new RegressionSolution(model, Problem.ProblemData);
      Results.AddOrUpdateResult(BestTrainingSolutionName, bestTrainingSolution);

      // Print generated sentences.
      string[,] sentencesMatrix = new string[AllSentences.Values.SelectMany(x => x).Count(), 3];

      int i = 0;
      foreach (var sentenceSet in AllSentences) {
        foreach (var sentence in sentenceSet.Value) {
          sentencesMatrix[i, 0] = sentence.ToString();
          sentencesMatrix[i, 1] = Grammar.PostfixToInfixParser(sentence).ToString();
          sentencesMatrix[i, 2] = sentenceSet.Key.ToString();
          i++;
        }
      }
      Results.Add(new Result("All generated sentences", new StringMatrix(sentencesMatrix)));

      string[,] distinctSentencesMatrix = new string[DistinctSentences.Count, 3];
      i = 0;
      foreach (KeyValuePair<int, SymbolString> distinctSentence in DistinctSentences) {
        distinctSentencesMatrix[i, 0] = distinctSentence.Key.ToString();
        distinctSentencesMatrix[i, 1] = Grammar.PostfixToInfixParser(distinctSentence.Value).ToString();
        distinctSentencesMatrix[i, 2] = distinctSentence.Key.ToString();
        i++;
      }
      Results.Add(new Result("Distinct generated sentences", new StringMatrix(distinctSentencesMatrix)));
    }

    private void LogSearchGraph(TraceListener listener, string msg) {
      listener.Write(msg);
    }
#endregion

  }
}