Changeset 17076

Timestamp:

07/05/19 10:26:41 (5 years ago)

Author:

gkronber

Message:

#2950: made some small changes while reviewing.

Location:

trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• Crossovers/SymbolicDataAnalysisExpressionDiversityPreservingCrossover.cs (modified) (3 diffs)
• Hashing/HashExtensions.cs (modified) (6 diffs)
• Hashing/SymbolicExpressionTreeHash.cs (modified) (4 diffs)
• Selectors/DiversitySelector.cs (modified) (6 diffs)

trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDiversityPreservingCrossover.cs

@@ -42 +42 @@
     private const string StrictHashingParameterName = "StrictHashing";
 
-    private static readonly Func<byte[], ulong> hashFunction = HashUtil.JSHash;
+    private static readonly Func<byte[], ulong> hashFunction = HashUtil.DJBHash;
 
     #region Parameter Properties
@@ -88 +88 @@
     }
 
-    public SymbolicDataAnalysisExpressionDiversityPreservingCrossover() {
-      name = "DiversityCrossover";
+    public SymbolicDataAnalysisExpressionDiversityPreservingCrossover() : base() {
       Parameters.Add(new ValueLookupParameter<PercentValue>(InternalCrossoverPointProbabilityParameterName, "The probability to select an internal crossover point (instead of a leaf node).", new PercentValue(0.9)));
       Parameters.Add(new ValueLookupParameter<BoolValue>(WindowingParameterName, "Use proportional sampling with windowing for cutpoint selection.", new BoolValue(false)));
@@ -96 +95 @@
     }
 
-    private SymbolicDataAnalysisExpressionDiversityPreservingCrossover(SymbolicDataAnalysisExpressionDiversityPreservingCrossover<T> original, Cloner cloner) : base(original, cloner) {
-    }
+    private SymbolicDataAnalysisExpressionDiversityPreservingCrossover(SymbolicDataAnalysisExpressionDiversityPreservingCrossover<T> original, Cloner cloner) : base(original, cloner) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {

trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/HashExtensions.cs

@@ -25 +25 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   public static class SymbolicExpressionHashExtensions {
+    /// <summary>
+    /// Holds data that is necessary to handle tree nodes in hashing / simplification.
+    /// </summary>
+    /// <typeparam name="T">The tree node type</typeparam>
     public sealed class HashNode<T> : IComparable<HashNode<T>>, IEquatable<HashNode<T>> where T : class {
       public T Data;
@@ -38 +42 @@
       public SimplifyAction Simplify;
 
-      //public IComparer<T> Comparer;
-
       public bool IsLeaf => Arity == 0;
-
-      //public HashNode(IComparer<T> comparer) {
-      //  Comparer = comparer;
-      //}
-
-      //public HashNode() { }
 
       public int CompareTo(HashNode<T> other) {
@@ -170 +166 @@
 
     /// <summary>
-    /// Get a function node's child indicest
+    /// Get a function node's child indices
     /// </summary>
     /// <typeparam name="T">The data type encapsulated by a hash node</typeparam>
-    /// <param name="nodes">An array of hash nodes with up-to-date node sizes</param>
+    /// <param name="nodes">An array of hash nodes with up-to-date node sizes (see UpdateNodeSizes)</param>
     /// <param name="i">The index in the array of hash nodes of the node whose children we want to iterate</param>
     /// <returns>An array containing child indices</returns>
@@ -188 +184 @@
     }
 
+    /// <summary>
+    /// Determines size of each branch and sets the results for each node.
+    /// </summary>
+    /// <typeparam name="T">The data type encapsulated by a hash node</typeparam>
+    /// <param name="nodes">An array of hash nodes in postfix order.</param>
+    /// <returns>The array with updated node sizes. The array is not copied.</returns>
     public static HashNode<T>[] UpdateNodeSizes<T>(this HashNode<T>[] nodes) where T : class {
       for (int i = 0; i < nodes.Length; ++i) {
@@ -196 +198 @@
         }
         node.Size = node.Arity;
-
+        // visit all children and sum up their size (assumes postfix order).
         for (int j = i - 1, k = 0; k < node.Arity; j -= 1 + nodes[j].Size, ++k) {
           node.Size += nodes[j].Size;
@@ -204 +206 @@
     }
 
+    // disables duplicate branches and removes the disabled nodes
     public static HashNode<T>[] Reduce<T>(this HashNode<T>[] nodes) where T : class {
       int count = 0;

trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/SymbolicExpressionTreeHash.cs

@@ -48 +48 @@
       ulong hashFunction(byte[] input) => HashUtil.DJBHash(input);
 
-      var hashNodes = simplify ? node.MakeNodes(strict).Simplify(hashFunction) : node.MakeNodes(strict).Sort(hashFunction);
+      var hashNodes = simplify ? node.MakeNodes(strict).Simplify(hashFunction) : node.MakeNodes(strict).Sort(hashFunction); // simplify sorts implicitly
       var hashes = new ulong[hashNodes.Length];
       for (int i = 0; i < hashes.Length; ++i) {
@@ -210 +210 @@
       var treeNodes = nodes.Select(x => x.Data.Symbol.CreateTreeNode()).ToArray();
 
+      // construct tree top down (assumes postfix order for nodes)
       for (int i = nodes.Length - 1; i >= 0; --i) {
         var node = nodes[i];
@@ -244 +245 @@
     // (in other words simplification should be applied in a bottom-up fashion)
     public static ISymbolicExpressionTree Simplify(ISymbolicExpressionTree tree) {
-      ulong hashFunction(byte[] bytes) => HashUtil.JSHash(bytes);
-      var root = tree.Root.GetSubtree(0).GetSubtree(0);
+      ulong hashFunction(byte[] bytes) => HashUtil.DJBHash(bytes);
+      var root = tree.ActualRoot();
       var nodes = root.MakeNodes();
       var simplified = nodes.Simplify(hashFunction);
@@ -369 +370 @@
         nodes[i].Enabled = false;
       } else if ((parentSymbol is Exponential && childSymbol is Logarithm) || (parentSymbol is Logarithm && childSymbol is Exponential)) {
+        // exp(log(x)) == x only for positive x. We consider this as equivalent for hashing anyway.
         child.Enabled = parent.Enabled = false;
       }

trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Selectors/DiversitySelector.cs

@@ -66 +66 @@
     }
 
-    public bool StrictSimilarity { get { return StrictSimilarityParameter.Value.Value; } }
-
-    public double SimilarityWeight { get { return SimilarityWeightParameter.Value.Value; } }
+    public bool StrictSimilarity {
+      get { return StrictSimilarityParameter.Value.Value; }
+      set { StrictSimilarityParameter.Value.Value = value; }
+    }
+
+    public double SimilarityWeight {
+      get { return SimilarityWeightParameter.Value.Value; }
+      set { SimilarityWeightParameter.Value.Value = value; }
+    }
 
     public DiversitySelector() : base() {
@@ -74 +80 @@
       Parameters.Add(new FixedValueParameter<DoubleValue>(SimilarityWeightParameterName, "Weight of the diversity term.", new DoubleValue(1)));
       Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees that should be analyzed."));
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(DiversityParameterName));
       Parameters.Add(new ValueParameter<ISingleObjectiveSelector>(SelectorParameterName, "The inner selection operator to select the parents.", new TournamentSelector()));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(DiversityParameterName, "The diversity value calcuated by the operator (output). The inner selector uses this value."));
 
       RegisterParameterEventHandlers();
@@ -81 +87 @@
 
     [StorableConstructor]
-    private DiversitySelector(StorableConstructorFlag deserializing) : base(deserializing) { }
+    private DiversitySelector(StorableConstructorFlag _) : base(_) { }
 
     private DiversitySelector(DiversitySelector original, Cloner cloner) : base(original, cloner) { }
@@ -91 +97 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      RegisterParameterEventHandlers();
-
       if (!Parameters.ContainsKey(DiversityParameterName)) {
         Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(DiversityParameterName));
       }
+
+      RegisterParameterEventHandlers();
     }
 
@@ -103 +109 @@
       CopySelectedParameter.ValueChanged += CopySelectedParameter_ValueChanged;
       CopySelected.ValueChanged += CopySelected_ValueChanged;
-    }
+
+      MaximizationParameter.NameChanged += MaximizationParameter_NameChanged;
+      QualityParameter.NameChanged += QualityParameter_NameChanged;
+      RandomParameter.NameChanged += RandomParameter_NameChanged;
+    }
+
+    private void RandomParameter_NameChanged(object sender, EventArgs e) { ParameterizeSelector(Selector); }
+    private void QualityParameter_NameChanged(object sender, EventArgs e) { ParameterizeSelector(Selector); }
+    private void MaximizationParameter_NameChanged(object sender, EventArgs e) { ParameterizeSelector(Selector); }
 
     private void CopySelectedParameter_ValueChanged(object sender, EventArgs e) {
@@ -127 +141 @@
       if (w.IsAlmost(0)) {
         ApplyInnerSelector();
-        return CurrentScope.SubScopes[1].SubScopes.ToArray();
+        return CurrentScope.SubScopes[1].SubScopes.ToArray();  // return selected individuals (selectors create two sub-scopes with remaining and selected)
       }