Changeset 5685 for branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective

Timestamp:

03/15/11 12:35:14 (13 years ago)

Author:

gkronber

Message:

#1418 Implemented validation best solution analyzers for symbolic classification and regression, added analyzers to symbolic data analysis problem classes and changed details of parameter wiring in problem classes.

Location:

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective

Files:

• SymbolicClassificationMultiObjectiveProblem.cs (modified) (4 diffs)
• SymbolicClassificationMultiObjectiveTrainingBestSolutionAnalyzer.cs (modified) (2 diffs)
• SymbolicClassificationMultiObjectiveValidationBestSolutionAnalyzer.cs (added)

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveProblem.cs

@@ -24 +24 @@
 using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
@@ -31 +32 @@
   public class SymbolicClassificationMultiObjectiveProblem : SymbolicDataAnalysisMultiObjectiveProblem<IClassificationProblemData, ISymbolicClassificationMultiObjectiveEvaluator, ISymbolicDataAnalysisSolutionCreator> {
     private const double PunishmentFactor = 10;
+    private const int InitialMaximumTreeDepth = 8;
+    private const int InitialMaximumTreeLength = 25;
+    private const string LowerEstimationLimitParameterName = "LowerEstimationLimit";
+    private const string UpperEstimationLimitParameterName = "UpperEstimationLimit";
+    private const string LowerEstimationLimitParameterDescription = "The lower limit for the estimated value that can be returned by the symbolic classification model.";
+    private const string UpperEstimationLimitParameterDescription = "The upper limit for the estimated value that can be returned by the symbolic classification model.";
 
+    #region parameter properties
+    public IFixedValueParameter<DoubleValue> LowerEstimationLimitParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
+    }
+    public IFixedValueParameter<DoubleValue> UpperEstimationLimitParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
+    }
+    #endregion
+    #region properties
+    public DoubleValue LowerEstimationLimit {
+      get { return LowerEstimationLimitParameter.Value; }
+    }
+    public DoubleValue UpperEstimationLimit {
+      get { return UpperEstimationLimitParameter.Value; }
+    }
+    #endregion
     [StorableConstructor]
     protected SymbolicClassificationMultiObjectiveProblem(bool deserializing) : base(deserializing) { }
@@ -39 +62 @@
     public SymbolicClassificationMultiObjectiveProblem()
       : base(new ClassificationProblemData(), new SymbolicClassificationMultiObjectiveMeanSquaredErrorTreeSizeEvaluator(), new SymbolicDataAnalysisExpressionTreeCreator()) {
+      Parameters.Add(new FixedValueParameter<DoubleValue>(LowerEstimationLimitParameterName, LowerEstimationLimitParameterDescription, new DoubleValue()));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(UpperEstimationLimitParameterName, UpperEstimationLimitParameterDescription, new DoubleValue()));
+
       Maximization = new BoolArray(new bool[] { false, false });
-      MaximumSymbolicExpressionTreeDepth.Value = 8;
-      MaximumSymbolicExpressionTreeLength.Value = 25;
+      MaximumSymbolicExpressionTreeDepth.Value = InitialMaximumTreeDepth;
+      MaximumSymbolicExpressionTreeLength.Value = InitialMaximumTreeLength;
+
+      InitializeOperators();
     }
 
-    protected override void UpdateEstimationLimits() {
+    private void InitializeOperators() {
+      Operators.Add(new SymbolicClassificationMultiObjectiveTrainingBestSolutionAnalyzer());
+      Operators.Add(new SymbolicClassificationMultiObjectiveValidationBestSolutionAnalyzer());
+      ParameterizeOperators();
+    }
+
+    private void UpdateEstimationLimits() {
       if (ProblemData.TrainingPartitionStart.Value < ProblemData.TrainingPartitionEnd.Value) {
         var targetValues = ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable, ProblemData.TrainingPartitionStart.Value, ProblemData.TrainingPartitionEnd.Value);
@@ -54 +88 @@
     }
 
+    protected override void OnProblemDataChanged() {
+      base.OnProblemDataChanged();
+      UpdateEstimationLimits();
+    }
+
+    protected new void ParameterizeOperators() {
+      base.ParameterizeOperators();
+      var operators = Parameters.OfType<IValueParameter>().Select(p => p.Value).OfType<IOperator>().Union(Operators);
+      foreach (var op in operators.OfType<ISymbolicDataAnalysisBoundedEvaluator<IClassificationProblemData>>()) {
+        op.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameterName;
+        op.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameterName;
+      }
+    }
+
     public override void ImportProblemDataFromFile(string fileName) {
       ClassificationProblemData problemData = ClassificationProblemData.ImportFromFile(fileName);

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveTrainingBestSolutionAnalyzer.cs

@@ -63 +63 @@
       : base() {
       Parameters.Add(new LookupParameter<IClassificationProblemData>(ProblemDataParameterName, "The problem data for the symbolic classification solution."));
+      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName, "The symbolic data analysis tree interpreter for the symbolic expression tree."));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -77 +78 @@
       var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreter, classValues, thresholds);
       return new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemData);
-    }  
+    }
   }
 }