source: branches/gp-crossover/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover.cs @ 7072

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2011 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 System.Text;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Data;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic {

  [Item("ProbabilisticFunctionalCrossover", "An operator which performs subtree swapping based on behavioral similarity")]
  public sealed class SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover<T> : SymbolicDataAnalysisExpressionCrossover<T> where T : class, IDataAnalysisProblemData 
  {
    [StorableConstructor]
    private SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover(bool deserializing) : base(deserializing) { }
    private SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover(SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover<T> original, Cloner cloner)
      : base(original, cloner) {
    }
    public SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover()
      : base() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new SymbolicDataAnalysisExpressionProbabilisticFunctionalCrossover<T>(this, cloner);
    } 
    protected override ISymbolicExpressionTree Cross(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1) {
      ISymbolicDataAnalysisExpressionTreeInterpreter interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
      IEnumerable<int> rows = GenerateRowsToEvaluate();
      T problemData = ProblemDataParameter.ActualValue;
      return Cross(random, parent0, parent1, interpreter, problemData, rows, MaximumSymbolicExpressionTreeDepth.Value, MaximumSymbolicExpressionTreeLength.Value);
    }

    /// <summary>
    /// Takes two parent individuals P0 and P1. 
    /// Randomly choose a node i from the first parent, then for each matching node j from the second parent, calculate the behavioral distance based on the range:
    /// d(i,j) = 0.5 * ( abs(max(i) - max(j)) + abs(min(i) - min(j)) ).
    /// Next, assign probabilities for the selection of the second cross point based on the inversed and normalized behavioral distance and
    /// choose the second crosspoint via a random weighted selection procedure.
    /// </summary>
    public static ISymbolicExpressionTree Cross(IRandom random, ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1,
                                                ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, T problemData, IEnumerable<int> rows, int maxDepth, int maxLength) {
      List<CutPoint> crossoverPoints0 = new List<CutPoint>();
      parent0.Root.ForEachNodePostfix((n) => {
        if (n.Subtrees.Any() && n != parent0.Root) 
          foreach (var child in n.Subtrees) 
            crossoverPoints0.Add(new CutPoint(n, child));
      });
      CutPoint crossoverPoint0 = crossoverPoints0[random.Next(crossoverPoints0.Count)];
      int level = parent0.Root.GetBranchLevel(crossoverPoint0.Child);
      int length = parent0.Root.GetLength() - crossoverPoint0.Child.GetLength();

      List<ISymbolicExpressionTreeNode> allowedBranches = new List<ISymbolicExpressionTreeNode>();
      parent1.Root.ForEachNodePostfix((n) => {
        if (n.Subtrees.Any() && n != parent1.Root) 
          foreach (var child in n.Subtrees)
            if (crossoverPoint0.IsMatchingPointType(child) && (child.GetDepth() + level <= maxDepth) && (child.GetLength() + length <= maxLength))
              allowedBranches.Add(n);
      });

      // check if empty branch is allowed
      if (crossoverPoint0.IsMatchingPointType(null)) allowedBranches.Add(null);

      if (allowedBranches.Count == 0) 
        return parent0;

      var dataset = problemData.Dataset;

      // create symbols in order to improvize an ad-hoc tree so that the child can be evaluated
      var rootSymbol = new ProgramRootSymbol();
      var startSymbol = new StartSymbol();
      var tree0 = CreateTreeFromNode(random, crossoverPoint0.Child, rootSymbol, startSymbol);
      IEnumerable<double> estimatedValues0 = interpreter.GetSymbolicExpressionTreeValues(tree0, dataset, rows);
      double min0 = estimatedValues0.Min();
      double max0 = estimatedValues0.Max();

      List<double> weights = new List<double>();
      foreach (var node in allowedBranches) {
        var tree1 = CreateTreeFromNode(random, node, rootSymbol, startSymbol);
        IEnumerable<double> estimatedValues1 = interpreter.GetSymbolicExpressionTreeValues(tree1, dataset, rows);
        double min1 = estimatedValues1.Min();
        double max1 = estimatedValues1.Max();

        double behavioralDistance = (Math.Abs(min0 - min1) + Math.Abs(max0 - max1)) / 2;

        weights.Add(behavioralDistance);
      }

      ISymbolicExpressionTreeNode selectedBranch = SelectRandomBranch(random, allowedBranches, weights);

      // perform the actual swap
      if (crossoverPoint0.Child != null) {
        // manipulate the tree of parent0 in place
        // replace the branch in tree0 with the selected branch from tree1
        crossoverPoint0.Parent.RemoveSubtree(crossoverPoint0.ChildIndex);
        if (selectedBranch != null) {
          crossoverPoint0.Parent.InsertSubtree(crossoverPoint0.ChildIndex, selectedBranch);
        }
      } else {
        // child is null (additional child should be added under the parent)
        if (selectedBranch != null) {
          crossoverPoint0.Parent.AddSubtree(selectedBranch);
        }
      }

      return parent0;
    }

    private static ISymbolicExpressionTreeNode SelectRandomBranch(IRandom random, List<ISymbolicExpressionTreeNode> nodes, List<double> weights) {
      // transform similarity distances into probabilities by normalizing and inverting the values
      double sum = weights.Sum();
      for (int i = 0; i != weights.Count; ++i)
        weights[i] = (1 - weights[i] / sum);
      double r = weights.Sum() * random.NextDouble();
      for (int i = 0; i != nodes.Count; ++i) {
        if (r < weights[i]) 
          return nodes[i];        
        r -= weights[i];
      }
      return null;
    }
  }
}