Changeset 12988 for branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SchemaDiversification/SchemaEvaluator.cs

Timestamp:

10/09/15 00:16:03 (9 years ago)

Author:

bburlacu

Message:

#1772: Performance improvement changes

• QueryMatch.cs: eliminate unnecessary ToList() call and expensive GetBranchLevel calls
• Diversification: eliminated creation of shallow copies of the individual subscopes as it was either too slow (due to events being registered/deregistered when variables are added to the scope) or too leaky (if attempting to clear the scopes without clearing the variables then the code is leaking EventHandlers)
• Aggregated diversification statistics separately with the help of some parameters set up in the SchemaCreator and SchemaEvaluator
• Made code in the UpdateEstimatedValuesOperator perform exactly as in the evaluator (updating quality and estimated values)
• Removed no longer needed SchemaCleanupOperator
• Do not evaluate intermediate vertices in the genealogy analyzer if the TrimOlderGenerations flag is activated

New functionality:

• parameter to control the fraction of the population to be considered by the diversification strategy
• parameter to control whether individuals may be matched by any schema and mutated only once (exclusive matching)
• parameter to control whether linear scaling should be applied to the estimated values used for the calculation of phenotypic similarity (default: yes)

File:

• branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SchemaDiversification/SchemaEvaluator.cs (modified) (11 diffs)

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SchemaDiversification/SchemaEvaluator.cs

@@ -50 +50 @@
     private const string MutatorParameterName = "Mutator";
     private const string RandomReplacementParameterName = "RandomReplacement";
-    private const string ChangedTreesParameterName = "ChangedTrees";
+    private const string NumberOfChangedTreesParameterName = "NumberOfChangedTrees";
     private const string ExecuteInParallelParameterName = "ExecuteInParallel";
     private const string MaxDegreeOfParalellismParameterName = "MaxDegreeOfParallelism";
+    private const string ExclusiveMatchingParameterName = "ExclusiveMatching";
     #endregion
 
     #region parameters
+    public ILookupParameter<BoolValue> ExclusiveMatchingParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters[ExclusiveMatchingParameterName]; }
+    }
     public ILookupParameter<BoolValue> ExecuteInParallelParameter {
       get { return (ILookupParameter<BoolValue>)Parameters[ExecuteInParallelParameterName]; }
@@ -101 +105 @@
       get { return (ILookupParameter<PercentValue>)Parameters[MinimumPhenotypicSimilarityParameterName]; }
     }
-    public LookupParameter<IntValue> ChangedTreesParameter {
-      get { return (LookupParameter<IntValue>)Parameters[ChangedTreesParameterName]; }
+    public LookupParameter<IntValue> NumberOfChangedTreesParameter {
+      get { return (LookupParameter<IntValue>)Parameters[NumberOfChangedTreesParameterName]; }
     }
     #endregion
@@ -111 +115 @@
     public PercentValue MinimumPhenotypicSimilarity { get { return MinimumPhenotypicSimilarityParameter.ActualValue; } }
     public BoolValue RandomReplacement { get { return RandomReplacementParameter.ActualValue; } }
+    public IntValue NumberOfChangedTrees { get { return NumberOfChangedTreesParameter.ActualValue; } }
     #endregion
 
@@ -122 +127 @@
     };
 
+    public ISymbolicExpressionTree Schema { get; set; }
+
     [Storable]
     private readonly UpdateEstimatedValuesOperator updateEstimatedValuesOperator;
@@ -128 +135 @@
       qm = new QueryMatch(comp) { MatchParents = true };
       this.updateEstimatedValuesOperator = new UpdateEstimatedValuesOperator();
-
+      #region add parameters
       Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SchemaParameterName, "The current schema to be evaluated"));
       Parameters.Add(new LookupParameter<PercentValue>(MinimumSchemaFrequencyParameterName));
@@ -142 +149 @@
       Parameters.Add(new LookupParameter<ISymbolicExpressionTreeManipulator>(MutatorParameterName));
       Parameters.Add(new LookupParameter<BoolValue>(RandomReplacementParameterName));
-      Parameters.Add(new LookupParameter<IntValue>(ChangedTreesParameterName));
+      Parameters.Add(new LookupParameter<IntValue>(NumberOfChangedTreesParameterName));
       Parameters.Add(new LookupParameter<BoolValue>(ExecuteInParallelParameterName));
       Parameters.Add(new LookupParameter<IntValue>(MaxDegreeOfParalellismParameterName));
+      Parameters.Add(new LookupParameter<BoolValue>(ExclusiveMatchingParameterName));
+      #endregion
     }
 
@@ -170 +179 @@
       var mutator = MutatorParameter.ActualValue;
 
-      var s = SchemaParameter.ActualValue;
+      var s = Schema;
       var sRoot = s.Root.GetSubtree(0).GetSubtree(0);
       int countThreshold = (int)Math.Max(2, Math.Round(MinimumSchemaFrequency.Value * individuals.Count));
 
       // first apply the length and root equality checks in order to filter the individuals
-      var filtered = (from ind in individuals
-                      let t = (ISymbolicExpressionTree)ind.Variables["SymbolicExpressionTree"].Value
-                      where t.Length >= s.Length && qm.Comparer.Equals(t.Root.GetSubtree(0).GetSubtree(0), sRoot)
-                      select ind).ToList();
+      var exclusiveMatching = ExclusiveMatchingParameter.ActualValue.Value;
+      var filtered = exclusiveMatching ? (from ind in individuals
+                                          where !ind.Variables.ContainsKey("AlreadyMatched")
+                                          let t = (ISymbolicExpressionTree)ind.Variables["SymbolicExpressionTree"].Value
+                                          where t.Length >= s.Length && qm.Comparer.Equals(t.Root.GetSubtree(0).GetSubtree(0), sRoot)
+                                          select ind).ToList()
+                                       : (from ind in individuals
+                                          let t = (ISymbolicExpressionTree)ind.Variables["SymbolicExpressionTree"].Value
+                                          where t.Length >= s.Length && qm.Comparer.Equals(t.Root.GetSubtree(0).GetSubtree(0), sRoot)
+                                          select ind).ToList();
 
       // if we don't have enough filtered individuals, then we are done
       if (filtered.Count < countThreshold) {
-        ChangedTreesParameter.ActualValue = new IntValue(0);
         return base.Apply();
       }
@@ -210 +224 @@
       } else {
         for (int i = 0; i < filtered.Count; ++i) {
-
           // break early if it becomes impossible to reach the minimum threshold
           if (matchingIndividuals.Count + filtered.Count - i < countThreshold)
@@ -223 +236 @@
       }
 
+      // additional condition: the average schema quality should be equal or greater than the population average quality
       if (matchingIndividuals.Count < countThreshold) {
-        ChangedTreesParameter.ActualValue = new IntValue(0);
         return base.Apply();
       }
@@ -230 +243 @@
       var similarity = CalculatePhenotypicSimilarity(matchingIndividuals, calculator, executeInParallel, maxDegreeOfParallelism);
       if (similarity < MinimumPhenotypicSimilarity.Value) {
-        ChangedTreesParameter.ActualValue = new IntValue(0);
         return base.Apply();
       }
@@ -244 +256 @@
         mutationOc.Add(mutatorOp);
         updateEstimatedValues.Add(updateOp);
-      }
-      ChangedTreesParameter.ActualValue = new IntValue(individualsToReplace.Count);
+        if (exclusiveMatching)
+          ind.Variables.Add(new Core.Variable("AlreadyMatched"));
+      }
+
+      NumberOfChangedTrees.Value += individualsToReplace.Count; // a lock is not necessary here because the SchemaEvaluators cannot be executed in parallel
+
       return new OperationCollection(mutationOc, updateEstimatedValues, base.Apply());
     }