Changeset 12892 for branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic

Timestamp:

08/23/15 13:21:12 (9 years ago)

Author:

bburlacu

Message:

#1772: Made GenealogyAnalyzer class abstract and added abstract method EvaluateIntermediateChildren in order to assign qualities to intermediate vertices in the genealogy graph. Implemented SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer which shows parent-child quality statistics for crossover and mutation.

Location:

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

Files:

• Analyzers/SymbolicDataAnalysisGenealogyAnalyzer.cs (modified) (1 diff)
• Analyzers/SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs (added)
• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (1 diff)
• SymbolicDataAnalysisSingleObjectiveProblem.cs (modified) (3 diffs)

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGenealogyAnalyzer.cs

@@ -1 @@
-using HeuristicLab.Core;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.EvolutionTracking;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [Item("SymbolicDataAnalysisGenealogyAnalyzer", "")]
+  [Item("SymbolicDataAnalysisGenealogyAnalyzer", "Genealogy analyzer for symbolic data analysis problems")]
   [StorableClass]
   public class SymbolicDataAnalysisGenealogyAnalyzer : GenealogyAnalyzer<ISymbolicExpressionTree> {
-    public SymbolicDataAnalysisGenealogyAnalyzer() { }
+    private const string EvaluatorParameterName = "Evaluator";
+    private const string ProblemDataParameterName = "ProblemData";
+    private const string InterpreterParameterName = "SymbolicExpressionTreeInterpreter";
+    private const string EstimationLimitsParameterName = "EstimationLimits";
+    private const string ApplyLinearScalingParameterName = "ApplyLinearScaling";
+
+    #region parameters
+    public ILookupParameter<ISingleObjectiveEvaluator> EvaluatorParameter {
+      get {
+        return (ILookupParameter<ISingleObjectiveEvaluator>)Parameters[EvaluatorParameterName];
+      }
+    }
+
+    public ILookupParameter<IDataAnalysisProblemData> ProblemDataParameter {
+      get {
+        return (ILookupParameter<IDataAnalysisProblemData>)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]; }
+    }
+    #endregion
+
+    public SymbolicDataAnalysisGenealogyAnalyzer() {
+      Parameters.Add(new LookupParameter<ISingleObjectiveEvaluator>(EvaluatorParameterName));
+      Parameters.Add(new LookupParameter<IDataAnalysisProblemData>(ProblemDataParameterName));
+      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(InterpreterParameterName));
+      Parameters.Add(new LookupParameter<DoubleLimit>(EstimationLimitsParameterName));
+      Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName));
+    }
+
+    public SymbolicDataAnalysisGenealogyAnalyzer(SymbolicDataAnalysisGenealogyAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicDataAnalysisGenealogyAnalyzer(this, cloner);
+    }
 
     [StorableConstructor]
-    protected SymbolicDataAnalysisGenealogyAnalyzer(bool deserializing) : base(deserializing) { }
+    protected SymbolicDataAnalysisGenealogyAnalyzer(bool deserializing) : base(deserializing) {
+    }
+
+    protected override void EvaluateIntermediateChildren() {
+      var results = ResultsParameter.ActualValue;
+      var graph = (IGenealogyGraph<ISymbolicExpressionTree>)results["PopulationGraph"].Value;
+      var population = PopulationParameter.ActualValue;
+      var generation = GenerationsParameter.ActualValue.Value;
+      var problemData = ProblemDataParameter.ActualValue;
+
+      var vertices = population.Select(graph.GetByContent).Where(x => x.InDegree == 1).Select(x => x.Parents.First());
+      var intermediateVertices = vertices.Where(x => x.Rank.IsAlmost(generation - 0.5));
+
+      var classificationProblemData = problemData as IClassificationProblemData;
+      var regressionProblemData = problemData as IRegressionProblemData;
+      if (classificationProblemData != null) {
+        var evaluator = (ISymbolicDataAnalysisSingleObjectiveEvaluator<IClassificationProblemData>)EvaluatorParameter.ActualValue;
+        foreach (var v in intermediateVertices) {
+          var child = v.Data;
+          v.Quality = evaluator.Evaluate(this.ExecutionContext, child, classificationProblemData, classificationProblemData.TrainingIndices);
+        }
+      } else if (regressionProblemData != null) {
+        var evaluator = (ISymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData>)EvaluatorParameter.ActualValue;
+        foreach (var v in intermediateVertices) {
+          var child = v.Data;
+          v.Quality = evaluator.Evaluate(this.ExecutionContext, child, regressionProblemData, problemData.TrainingIndices);
+        }
+      }
+    }
   }
 }

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -183 +183 @@
     <Compile Include="Analyzers\BuildingBlockAnalyzers\SymbolicDataAnalysisPoly10Analyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisBottomUpDiversityAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectivePruningAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisGenealogyAnalyzer.cs" />

branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSingleObjectiveProblem.cs

@@ -25 +25 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.EvolutionTracking;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -34 +32 @@
   [StorableClass]
   public abstract class SymbolicDataAnalysisSingleObjectiveProblem<T, U, V> : SymbolicDataAnalysisProblem<T, U, V>, ISymbolicDataAnalysisSingleObjectiveProblem
-    where T : class,IDataAnalysisProblemData
+    where T : class, IDataAnalysisProblemData
     where U : class, ISymbolicDataAnalysisSingleObjectiveEvaluator<T>
     where V : class, ISymbolicDataAnalysisSolutionCreator {
@@ -118 +116 @@
       }
 
-      foreach (var op in Operators.OfType<GenealogyAnalyzer<ISymbolicExpressionTree>>()) {
+      foreach (var op in Operators.OfType<SymbolicDataAnalysisGenealogyAnalyzer>()) {
         op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
         op.PopulationParameter.ActualName = Evaluator.SymbolicExpressionTreeParameter.ActualName;