source: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ReplaceBranchMultiMoveGenerator.cs @ 8206

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
  [Item("ReplaceBranchMultiMoveGenerator", "")]
  [StorableClass]
  public class ReplaceBranchMultiMoveGenerator : SingleSuccessorOperator, IStochasticOperator, ISymbolicExpressionTreeMoveOperator, IMultiMoveGenerator,
    ISymbolicDataAnalysisInterpreterOperator, ISymbolicExpressionTreeGrammarBasedOperator {
    public ILookupParameter<IRandom> RandomParameter {
      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
    }
    public IValueLookupParameter<IntValue> SampleSizeParameter {
      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
    }
    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> SymbolicDataAnalysisTreeInterpreterParameter {
      get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters["Interpreter"]; }
    }

    public IValueLookupParameter<ISymbolicExpressionGrammar> SymbolicExpressionTreeGrammarParameter {
      get { return (IValueLookupParameter<ISymbolicExpressionGrammar>)Parameters["Grammar"]; }
    }
    public ILookupParameter<IRegressionProblemData> ProblemDataParameter {
      get { return (ILookupParameter<IRegressionProblemData>)Parameters["ProblemData"]; }
    }

    public IntValue SampleSize {
      get { return SampleSizeParameter.Value; }
      set { SampleSizeParameter.Value = value; }
    }
    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]; }
    }
    public ILookupParameter<ReplaceBranchMove> ReplaceBranchMoveParameter {
      get { return (LookupParameter<ReplaceBranchMove>)Parameters["ReplaceBranchMove"]; }
    }

    public IValueParameter<IntValue> ReplacementBranchesPoolSize {
      get { return (IValueParameter<IntValue>)Parameters["ReplacementBranchesPoolSize"]; }
    }

    public IValueParameter<IntValue> MaxReplacementBranchLength {
      get { return (IValueParameter<IntValue>)Parameters["MaxReplacementBranchLength"]; }
    }

    public IValueParameter<IntValue> MaxReplacementBranchDepth {
      get { return (IValueParameter<IntValue>)Parameters["MaxReplacementBranchDepth"]; }
    }

    protected ScopeParameter CurrentScopeParameter {
      get { return (ScopeParameter)Parameters["CurrentScope"]; }
    }

    private IList<ISymbolicExpressionTree> trees;
    private IList<double[]> treeOutput;

    [StorableConstructor]
    protected ReplaceBranchMultiMoveGenerator(bool deserializing) : base(deserializing) { }
    protected ReplaceBranchMultiMoveGenerator(ReplaceBranchMultiMoveGenerator original, Cloner cloner) : base(original, cloner) { }
    public ReplaceBranchMultiMoveGenerator()
      : base() {
      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));

      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>("SymbolicExpressionTree", "The symbolic expression tree for which moves should be generated."));
      Parameters.Add(new LookupParameter<ReplaceBranchMove>("ReplaceBranchMove", "The moves that should be generated in subscopes."));
      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionGrammar>("Grammar"));
      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>("Interpreter"));
      Parameters.Add(new LookupParameter<IRegressionProblemData>("ProblemData"));
      Parameters.Add(new ValueParameter<IntValue>("ReplacementBranchesPoolSize", new IntValue(10000)));
      Parameters.Add(new ValueParameter<IntValue>("MaxReplacementBranchLength", new IntValue(8)));
      Parameters.Add(new ValueParameter<IntValue>("MaxReplacementBranchDepth", new IntValue(4)));
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new ReplaceBranchMultiMoveGenerator(this, cloner);
    }

    public override void ClearState() {
      trees = null;
      treeOutput = null;
      base.ClearState();
    }

    public override IOperation Apply() {
      var random = RandomParameter.ActualValue;
      if (trees == null || treeOutput == null) {
        InitializeOperator();
      }

      var tree = SymbolicExpressionTreeParameter.ActualValue;

      string moveParameterName = ReplaceBranchMoveParameter.ActualName;
      var moveScopes = new List<Scope>();
      int n = SampleSizeParameter.ActualValue.Value;

      var moves = GenerateMoves(tree, random, n);

      foreach (var m in moves) {
        var moveScope = new Scope(moveScopes.Count.ToString());
        moveScope.Variables.Add(new HeuristicLab.Core.Variable(moveParameterName, m));
        moveScopes.Add(moveScope);
      }
      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
      return base.Apply();
    }

    public IEnumerable<ReplaceBranchMove> GenerateMoves(ISymbolicExpressionTree tree, IRandom random, int n) {
      int count = 0;
      var possibleChildren = (from parent in tree.Root.GetSubtree(0).IterateNodesPrefix()
                              from i in Enumerable.Range(0, parent.SubtreeCount)
                              let currentChild = parent.GetSubtree(i)
                              select new { parent, i }).ToArray();

      var root = (new ProgramRootSymbol()).CreateTreeNode();
      var start = (new StartSymbol()).CreateTreeNode();
      root.AddSubtree(start);
      var t = new SymbolicExpressionTree(root);
      var interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
      var ds = ProblemDataParameter.ActualValue.Dataset;
      var rows = ProblemDataParameter.ActualValue.TrainingIndizes;

      while (count < n) {
        // select a random replacement point
        var selected = possibleChildren[random.Next(possibleChildren.Length)];
        // evaluate 
        start.AddSubtree(selected.parent.GetSubtree(selected.i));
        var output = interpreter.GetSymbolicExpressionTreeValues(t, ds, rows).ToArray();
        start.RemoveSubtree(0);

        var bestTrees = new SortedList<double, Tuple<ISymbolicExpressionTree, double[]>>();
        double bestSimilarity = 0.0;
        // iterate over the whole pool of branches for replacement
        for (int i = 0; i < trees.Count; i++) {
          // if the branch is allowed in the selected point
          if (tree.Root.Grammar.IsAllowedChildSymbol(selected.parent.Symbol, trees[i].Root.GetSubtree(0).GetSubtree(0).Symbol, selected.i)) {
            OnlineCalculatorError error;
            // calculate the similarity
            double similarity = OnlinePearsonsRSquaredCalculator.Calculate(output, treeOutput[i], out error);
            if (error != OnlineCalculatorError.None) similarity = 0.0;

            // if we found a new bestSimilarity then keep the replacement branch in a sorted list (keep maximally the 30 best for this replacement point)
            if (similarity > bestSimilarity && !similarity.IsAlmost(1.0)) {
              bestSimilarity = similarity;
              bestTrees.Add(similarity, Tuple.Create(trees[i], treeOutput[i]));
              if (bestTrees.Count > 30)
                bestTrees.RemoveAt(bestTrees.Count - 1);
            }
          }
        }
        // did not find a move better than similarity 0.0 => create a move to replace it with a random branch
        // this is necessary to make it possible to replace branches that evaluate to NaN or infinity
        if (bestTrees.Count == 0) {
          int r = random.Next(trees.Count);
          bestTrees.Add(0.0, Tuple.Create(trees[r], treeOutput[r]));
        }
        // yield moves (we need to add linear scaling parameters for the inserted tree)
        foreach (var pair in bestTrees.Values) {
          yield return
            new ReplaceBranchMove(tree, selected.parent, selected.i, pair.Item1.Root.GetSubtree(0).GetSubtree(0), output, pair.Item2);
          count++;
        }
      }
    }

    private void InitializeOperator() {
      // init locally and set only at the end in case of exceptions
      var trees = new List<ISymbolicExpressionTree>();
      var treeOutput = new List<double[]>();
      var random = RandomParameter.ActualValue;
      var g = SymbolicExpressionTreeGrammarParameter.ActualValue;
      var constSym = g.Symbols.Single(s => s is Constant);
      // temporarily disable constants
      double oldConstFreq = constSym.InitialFrequency;
      constSym.InitialFrequency = 0.0;
      var interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
      var ds = ProblemDataParameter.ActualValue.Dataset;
      var rows = ProblemDataParameter.ActualValue.TrainingIndizes;
      // create pool of random branches for replacement (no constants)
      // and evaluate the output
      // only keep trees if the output does not contain invalid values
      var n = ReplacementBranchesPoolSize.Value.Value;
      while (trees.Count < n) {
        var t = ProbabilisticTreeCreator.Create(random, g, MaxReplacementBranchLength.Value.Value, MaxReplacementBranchDepth.Value.Value);
        var output = interpreter.GetSymbolicExpressionTreeValues(t, ds, rows);
        if (!output.Any(x => double.IsInfinity(x) || double.IsNaN(x))) {
          trees.Add(t);
          treeOutput.Add(output.ToArray());
        }
      }
      // enable constants again
      constSym.InitialFrequency = oldConstFreq;
      this.trees = trees;
      this.treeOutput = treeOutput;
    }

  }
}