Changeset 12952

Timestamp:

09/17/15 00:31:53 (9 years ago)

Author:

bburlacu

Message:

#1772: Add tracking of the number of trees that are mutated during the diversification phase by the SchemaEvaluator.

Location:

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

Files:

• SchemaCreator.cs (modified) (5 diffs)
• SchemaEvaluator.cs (modified) (6 diffs)

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

@@ -22 +22 @@
 using System;
 using System.Linq;
+using HeuristicLab.Analysis;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -27 +28 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.EvolutionTracking;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -99 +102 @@
       var schemaCleanupOperator = new SchemaCleanupOperator();
 
+      var changedTreesReducer = new DataReducer();
+      changedTreesReducer.ParameterToReduce.ActualName = schemaEvaluator.ChangedTreesParameter.ActualName;
+      changedTreesReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      changedTreesReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign); // asign the sum to the target parameter
+      changedTreesReducer.TargetParameter.ActualName = "NumberOfChangedTrees";
+
+      var valuesCollector = new DataTableValuesCollector();
+      valuesCollector.CollectedValues.Add(new LookupParameter<IntValue>("NumberOfChangedTrees"));
+      valuesCollector.DataTableParameter.ActualName = "Diversification";
+
+      var resultCollector = new ResultsCollector();
+      resultCollector.CollectedValues.Add(new LookupParameter<DataTable>("Diversification"));
+
+      var reduceChangedTrees = ExecutionContext.CreateChildOperation(changedTreesReducer);
+      var collectValues = ExecutionContext.CreateChildOperation(valuesCollector);
+      var collectResults = ExecutionContext.CreateChildOperation(resultCollector);
+
       var oc = new OperationCollection();
 
@@ -114 +134 @@
         var nodesToReplace = indices.Where(x => x >= 2).Select(x => nodes[x]).ToList();
         for (int i = nodesToReplace.Count - 1; i >= 0; --i) {
+          var node = nodesToReplace[i];
+
+          // do not replace the node with a wildcard if it would result in a length < MinimumSchemaLength
+          if ((schema.Length - node.GetLength() + 1) < MinimumSchemaLength)
+            continue;
+
           var replacement = anySubtreeSymbol.CreateTreeNode();
-          ReplaceSubtree(nodesToReplace[i], replacement, false);
+          ReplaceSubtree(node, replacement, false);
           replaced = true;
         }
@@ -131 +157 @@
       var cleanup = ExecutionContext.CreateChildOperation(schemaCleanupOperator);
       // return an operation collection containing all the scope operations + base.Apply()
-      return new OperationCollection { oc, cleanup, base.Apply() };
+      return new OperationCollection { oc, reduceChangedTrees, collectValues, collectResults, cleanup, base.Apply() };
     }
 

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

@@ -35 +35 @@
   [StorableClass]
   public class SchemaEvaluator : EvolutionTrackingOperator<ISymbolicExpressionTree> {
+    #region parameter names
     private const string MinimumSchemaFrequencyParameterName = "MinimumSchemaFrequency";
     private const string MinimumPhenotypicSimilarityParameterName = "MinimumPhenotypicSimilarity";
@@ -48 +49 @@
     private const string MutatorParameterName = "Mutator";
     private const string RandomReplacementParameterName = "RandomReplacement";
+    private const string ChangedTreesParameterName = "ChangedTrees";
+    #endregion
+
+    #region parameters
+    public ILookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData>> EvaluatorParameter {
+      get { return (ILookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData>>)Parameters[EvaluatorParameterName]; }
+    }
+    public ILookupParameter<IRegressionProblemData> ProblemDataParameter {
+      get { return (ILookupParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName]; }
+    }
+    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> InterpreterParameter {
+      get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[InterpreterParameterName]; }
+    }
+    public ILookupParameter<DoubleLimit> EstimationLimitsParameter {
+      get { return (ILookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
+    }
+    public ILookupParameter<BoolValue> ApplyLinearScalingParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
+    }
+    public ILookupParameter<BoolValue> RandomReplacementParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters[RandomReplacementParameterName]; }
+    }
+    public ILookupParameter<ISymbolicExpressionTreeManipulator> MutatorParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTreeManipulator>)Parameters[MutatorParameterName]; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters[RandomParameterName]; }
+    }
+    public ILookupParameter<IntValue> PopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters[PopulationSizeParameterName]; }
+    }
+    public ILookupParameter<ISymbolicExpressionTree> SchemaParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[SchemaParameterName]; }
+    }
+    public ILookupParameter<PercentValue> MinimumSchemaFrequencyParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters[MinimumSchemaFrequencyParameterName]; }
+    }
+    public ILookupParameter<PercentValue> ReplacementRatioParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters[ReplacementRatioParameterName]; }
+    }
+    public ILookupParameter<PercentValue> MinimumPhenotypicSimilarityParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters[MinimumPhenotypicSimilarityParameterName]; }
+    }
+    public LookupParameter<IntValue> ChangedTreesParameter {
+      get { return (LookupParameter<IntValue>)Parameters[ChangedTreesParameterName]; }
+    }
+
+    #endregion
+
+    #region parameter properties
+    public PercentValue MinimumSchemaFrequency {
+      get { return MinimumSchemaFrequencyParameter.ActualValue; }
+    }
+
+    public PercentValue ReplacementRatio {
+      get { return ReplacementRatioParameter.ActualValue; }
+    }
+
+    public PercentValue MinimumPhenotypicSimilarity {
+      get { return MinimumPhenotypicSimilarityParameter.ActualValue; }
+    }
+
+    public BoolValue RandomReplacement {
+      get { return RandomReplacementParameter.ActualValue; }
+    }
+    #endregion
 
     private readonly SymbolicExpressionTreePhenotypicSimilarityCalculator calculator = new SymbolicExpressionTreePhenotypicSimilarityCalculator();
+    private readonly QueryMatch qm;
 
     private readonly ISymbolicExpressionTreeNodeEqualityComparer comp = new SymbolicExpressionTreeNodeEqualityComparer {
@@ -57 +125 @@
     };
 
-    private readonly QueryMatch qm;
-
-    #region parameters
-    public ILookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData>> EvaluatorParameter {
-      get { return (ILookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData>>)Parameters[EvaluatorParameterName]; }
-    }
-    public ILookupParameter<IRegressionProblemData> ProblemDataParameter {
-      get { return (ILookupParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName]; }
-    }
-    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> InterpreterParameter {
-      get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[InterpreterParameterName]; }
-    }
-    public ILookupParameter<DoubleLimit> EstimationLimitsParameter {
-      get { return (ILookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
-    }
-    public ILookupParameter<BoolValue> ApplyLinearScalingParameter {
-      get { return (ILookupParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
-    }
-    public ILookupParameter<BoolValue> RandomReplacementParameter {
-      get { return (ILookupParameter<BoolValue>)Parameters[RandomReplacementParameterName]; }
-    }
-    public ILookupParameter<ISymbolicExpressionTreeManipulator> MutatorParameter {
-      get { return (ILookupParameter<ISymbolicExpressionTreeManipulator>)Parameters[MutatorParameterName]; }
-    }
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (ILookupParameter<IRandom>)Parameters[RandomParameterName]; }
-    }
-    public ILookupParameter<IntValue> PopulationSizeParameter {
-      get { return (ILookupParameter<IntValue>)Parameters[PopulationSizeParameterName]; }
-    }
-    public ILookupParameter<ISymbolicExpressionTree> SchemaParameter {
-      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[SchemaParameterName]; }
-    }
-    public ILookupParameter<PercentValue> MinimumSchemaFrequencyParameter {
-      get { return (ILookupParameter<PercentValue>)Parameters[MinimumSchemaFrequencyParameterName]; }
-    }
-    public ILookupParameter<PercentValue> ReplacementRatioParameter {
-      get { return (ILookupParameter<PercentValue>)Parameters[ReplacementRatioParameterName]; }
-    }
-    public ILookupParameter<PercentValue> MinimumPhenotypicSimilarityParameter {
-      get { return (ILookupParameter<PercentValue>)Parameters[MinimumPhenotypicSimilarityParameterName]; }
-    }
-    #endregion
-
-    #region parameter properties
-    public PercentValue MinimumSchemaFrequency {
-      get { return MinimumSchemaFrequencyParameter.ActualValue; }
-    }
-
-    public PercentValue ReplacementRatio {
-      get { return ReplacementRatioParameter.ActualValue; }
-    }
-
-    public PercentValue MinimumPhenotypicSimilarity {
-      get { return MinimumPhenotypicSimilarityParameter.ActualValue; }
-    }
-
-    public BoolValue RandomReplacement {
-      get { return RandomReplacementParameter.ActualValue; }
-    }
-    #endregion
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ChangedTreesParameterName))
+        Parameters.Add(new LookupParameter<IntValue>(ChangedTreesParameterName));
+    }
 
     public SchemaEvaluator() {
@@ -135 +148 @@
       Parameters.Add(new LookupParameter<ISymbolicExpressionTreeManipulator>(MutatorParameterName));
       Parameters.Add(new LookupParameter<BoolValue>(RandomReplacementParameterName));
+      Parameters.Add(new LookupParameter<IntValue>(ChangedTreesParameterName));
     }
 
@@ -171 +185 @@
                                               select ind);
 
-      if (matchingIndividuals.Count < MinimumSchemaFrequency.Value * individuals.Count)
+      if (matchingIndividuals.Count < MinimumSchemaFrequency.Value * individuals.Count) {
+        ChangedTreesParameter.ActualValue = new IntValue(0);
         return base.Apply();
+      }
 
       var similarity = CalculatePhenotypicSimilarity(matchingIndividuals, calculator);
-      if (similarity < MinimumPhenotypicSimilarity.Value)
+      if (similarity < MinimumPhenotypicSimilarity.Value) {
+        ChangedTreesParameter.ActualValue = new IntValue(0);
         return base.Apply();
+      }
 
       var oc = new OperationCollection();
-
       int n = (int)Math.Round(matchingIndividuals.Count * ReplacementRatio.Value);
-      var individualsToReplace = RandomReplacement.Value ? matchingIndividuals.SampleRandomWithoutRepetition(random, n)
-                                                         : matchingIndividuals.OrderBy(x => (DoubleValue)x.Variables["Quality"].Value).Take(n);
+      var individualsToReplace = RandomReplacement.Value ? matchingIndividuals.SampleRandomWithoutRepetition(random, n).ToList()
+                                                         : matchingIndividuals.OrderBy(x => (DoubleValue)x.Variables["Quality"].Value).Take(n).ToList();
       foreach (var ind in individualsToReplace) {
         var mutatorOp = ExecutionContext.CreateChildOperation(mutator, ind);
@@ -191 +208 @@
         oc.Add(updateEstimatedValuesOp);
       }
-
+      ChangedTreesParameter.ActualValue = new IntValue(individualsToReplace.Count);
       return new OperationCollection(oc, base.Apply());
     }