Changeset 5499 for branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ReplaceBranchManipulation.cs

Timestamp:

02/16/11 19:01:00 (14 years ago)

Author:

gkronber

Message:

#1418 changes in symbolic expression tree encoding.

Location:

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4

Files:

• . (modified) (1 prop)
• Manipulators/ReplaceBranchManipulation.cs (modified) (3 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4

@@ -2 +2 @@
 obj
 HeuristicLabEncodingsSymbolicExpressionTreeEncodingPlugin.cs
+*.user

@@ -2 +2 @@
 obj
 HeuristicLabEncodingsSymbolicExpressionTreeEncodingPlugin.cs
+*.user

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ReplaceBranchManipulation.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Creators;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
 
-namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Manipulators {
+namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
   [StorableClass]
   [Item("ReplaceBranchManipulation", "Selects a branch of the tree randomly and replaces it with a newly initialized branch (using PTC2).")]
-  public sealed class ReplaceBranchManipulation : SymbolicExpressionTreeManipulator {
+  public sealed class ReplaceBranchManipulation : SymbolicExpressionTreeManipulator, ISymbolicExpressionTreeSizeConstraintOperator {
+    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
+    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
+    #region Parameter Properties
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
+    }
+    #endregion
+    #region Properties
+    public IntValue MaximumSymbolicExpressionTreeLength {
+      get { return MaximumSymbolicExpressionTreeLengthParameter.ActualValue; }
+    }
+    public IntValue MaximumSymbolicExpressionTreeDepth {
+      get { return MaximumSymbolicExpressionTreeDepthParameter.ActualValue; }
+    }
+    #endregion
+
     [StorableConstructor]
     private ReplaceBranchManipulation(bool deserializing) : base(deserializing) { }
     private ReplaceBranchManipulation(ReplaceBranchManipulation original, Cloner cloner) : base(original, cloner) { }
-    public ReplaceBranchManipulation() : base() { }
+    public ReplaceBranchManipulation()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, "The maximal length (number of nodes) of the symbolic expression tree."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
+    }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -43 +65 @@
     }
 
-    protected override void Manipulate(IRandom random, SymbolicExpressionTree symbolicExpressionTree, ISymbolicExpressionGrammar grammar, IntValue maxTreeSize, IntValue maxTreeHeight, out bool success) {
-      ReplaceRandomBranch(random, symbolicExpressionTree, grammar, maxTreeSize.Value, maxTreeHeight.Value, out success);
+    protected override void Manipulate(IRandom random, ISymbolicExpressionTree symbolicExpressionTree) {
+      ReplaceRandomBranch(random, symbolicExpressionTree, MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value);
     }
 
-    public static void ReplaceRandomBranch(IRandom random, SymbolicExpressionTree symbolicExpressionTree, ISymbolicExpressionGrammar grammar, int maxTreeSize, int maxTreeHeight, out bool success) {
-      success = false;
+    public static void ReplaceRandomBranch(IRandom random, ISymbolicExpressionTree symbolicExpressionTree, int maxTreeLength, int maxTreeDepth) {
       // select any node as parent (except the root node)
       var manipulationPoint = (from parent in symbolicExpressionTree.Root.IterateNodesPrefix().Skip(1)
                                from subtree in parent.SubTrees
-                               select new { Parent = parent, Node = subtree, Index = parent.SubTrees.IndexOf(subtree) }).SelectRandom(random);
+                               select new { Parent = parent, Node = subtree, Index = parent.IndexOfSubTree(subtree) })
+                               .SelectRandom(random);
 
-      int maxSize = maxTreeSize - symbolicExpressionTree.Size + manipulationPoint.Node.GetSize();
-      int maxHeight = maxTreeHeight - symbolicExpressionTree.Height + manipulationPoint.Node.GetHeight();
+      int maxLength = maxTreeLength - symbolicExpressionTree.Size + manipulationPoint.Node.GetSize();
+      int maxDepth = maxTreeDepth - symbolicExpressionTree.Height + manipulationPoint.Node.GetHeight();
       // find possible symbols for the node (also considering the existing branches below it)
-      var allowedSymbols = from symbol in manipulationPoint.Parent.GetAllowedSymbols(manipulationPoint.Index)
-                           where manipulationPoint.Node.Grammar.GetMinExpressionDepth(symbol) <= maxHeight
-                           where manipulationPoint.Node.Grammar.GetMinExpressionLength(symbol) <= maxSize
-                           select symbol;
+      var allowedSymbols = (from symbol in manipulationPoint.Parent.GetAllowedSymbols(manipulationPoint.Index)
+                            where manipulationPoint.Node.Grammar.GetMinExpressionDepth(symbol) <= maxDepth
+                            where manipulationPoint.Node.Grammar.GetMinExpressionLength(symbol) <= maxLength
+                            select symbol).ToList();
       if (allowedSymbols.Count() == 0) return;
-
-      var seedSymbol = SelectRandomSymbol(random, allowedSymbols);  // replace the old node with the new node
+      var weights = allowedSymbols.Select(s => s.InitialFrequency).ToList();
+      var seedSymbol = allowedSymbols.SelectRandom(weights, random);
+      // replace the old node with the new node
       var seedNode = seedSymbol.CreateTreeNode();
       if (seedNode.HasLocalParameters)
@@ -70 +93 @@
       manipulationPoint.Parent.RemoveSubTree(manipulationPoint.Index);
       manipulationPoint.Parent.InsertSubTree(manipulationPoint.Index, seedNode);
-      seedNode = ProbabilisticTreeCreator.PTC2(random, seedNode, maxSize, maxHeight, 0, 0);
-      success = true;
-    }
-
-    private static Symbol SelectRandomSymbol(IRandom random, IEnumerable<Symbol> symbols) {
-      var symbolList = symbols.ToList();
-      var ticketsSum = symbolList.Select(x => x.InitialFrequency).Sum();
-      if (ticketsSum == 0.0) throw new ArgumentException("The initial frequency of all allowed symbols is zero.");
-      var r = random.NextDouble() * ticketsSum;
-      double aggregatedTickets = 0;
-      for (int i = 0; i < symbolList.Count; i++) {
-        aggregatedTickets += symbolList[i].InitialFrequency;
-        if (aggregatedTickets > r) {
-          return symbolList[i];
-        }
-      }
-      // this should never happen
-      throw new ArgumentException("There is a problem with the initial frequency setting of allowed symbols.");
+      seedNode = ProbabilisticTreeCreator.PTC2(random, seedNode, maxLength, maxDepth, 0, 0);
     }
   }

@@ -2 +2 @@
 obj
 HeuristicLabEncodingsSymbolicExpressionTreeEncodingPlugin.cs
+*.user