Changeset 5618 for branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs

Timestamp:

03/07/11 14:23:26 (14 years ago)

Author:

mkommend

Message:

#1418: Added symbolic data analysis problems.

File:

• branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs (modified) (5 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs

@@ -22 +22 @@
 using System;
 using System.Drawing;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Common.Resources;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+//TODO configure training start / end
+//TODO configure analyzer validation
+//TODO configure grammar with ADF usage
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -71 +78 @@
       get { return (IValueParameter<ISymbolicDataAnalysisTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
     }
-    public IValueParameter<DoubleValue> LowerEstimationLimitParameter {
-      get { return (IValueParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
-    }
-    public IValueParameter<DoubleValue> UpperEstimationLimitParameter {
-      get { return (IValueParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
-    }
-    public IValueParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
-      get { return (IValueParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
-    }
-    public IValueParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
-      get { return (IValueParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
-    }
-    public IValueParameter<IntValue> MaximumFunctionDefinitionsParameter {
-      get { return (IValueParameter<IntValue>)Parameters[MaximumFunctionDefinitionsParameterName]; }
-    }
-    public IValueParameter<IntValue> MaximumFunctionArgumentsParameter {
-      get { return (IValueParameter<IntValue>)Parameters[MaximumFunctionArgumentsParameterName]; }
+    public IFixedValueParameter<DoubleValue> LowerEstimationLimitParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
+    }
+    public IFixedValueParameter<DoubleValue> UpperEstimationLimitParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> MaximumFunctionDefinitionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumFunctionDefinitionsParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> MaximumFunctionArgumentsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumFunctionArgumentsParameterName]; }
     }
     #endregion
@@ -100 +107 @@
     public T ProblemData {
       get { return ProblemDataParameter.Value; }
+      set { ProblemDataParameter.Value = value; }
     }
 
     public ISymbolicDataAnalysisGrammar SymbolicExpressionTreeGrammar {
       get { return SymbolicExpressionTreeGrammarParameter.Value; }
-      protected set { SymbolicExpressionTreeGrammarParameter.Value = value; }
+      set { SymbolicExpressionTreeGrammarParameter.Value = value; }
     }
     public ISymbolicDataAnalysisTreeInterpreter SymbolicExpressionTreeInterpreter {
       get { return SymbolicExpressionTreeInterpreterParameter.Value; }
-      protected set { SymbolicExpressionTreeInterpreterParameter.Value = value; }
+      set { SymbolicExpressionTreeInterpreterParameter.Value = value; }
     }
 
@@ -128 +136 @@
     }
     public IntValue MaximumFunctionArguments {
-      get { return MaximumFunctionArguments; }
+      get { return MaximumFunctionArgumentsParameter.Value; }
     }
     #endregion
@@ -134 +142 @@
     [StorableConstructor]
     protected SymbolicDataAnalysisProblem(bool deserializing) : base(deserializing) { }
-    protected SymbolicDataAnalysisProblem(SymbolicDataAnalysisProblem<T, U, V> original, Cloner cloner) : base(original, cloner) { }
-
-    protected SymbolicDataAnalysisProblem()
-      : base() {
-      Parameters.Add(new ValueParameter<T>(ProblemDataParameterName, ProblemDataParameterDescription));
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+    protected SymbolicDataAnalysisProblem(SymbolicDataAnalysisProblem<T, U, V> original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEventHandlers();
+    }
+
+    protected SymbolicDataAnalysisProblem(T problemData, U evaluator, V solutionCreator)
+      : base(evaluator, solutionCreator) {
+      Parameters.Add(new ValueParameter<T>(ProblemDataParameterName, ProblemDataParameterDescription, problemData));
       Parameters.Add(new ValueParameter<ISymbolicDataAnalysisGrammar>(SymbolicExpressionTreeGrammarParameterName, SymbolicExpressionTreeGrammarParameterDescription));
       Parameters.Add(new ValueParameter<ISymbolicDataAnalysisTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, SymoblicExpressionTreeInterpreterParameterDescription));
-      Parameters.Add(new ValueParameter<DoubleValue>(LowerEstimationLimitParameterName, LowerEstimationLimitParameterDescription));
-      Parameters.Add(new ValueParameter<DoubleValue>(UpperEstimationLimitParameterName, UpperEstimationLimitParameterDescription));
-      Parameters.Add(new ValueParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, MaximumSymbolicExpressionTreeDepthParameterDescription));
-      Parameters.Add(new ValueParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, MaximumSymbolicExpressionTreeLengthParameterDescription));
-      Parameters.Add(new ValueParameter<IntValue>(MaximumFunctionDefinitionsParameterName, MaximumFunctionDefinitionsParameterDescription));
-      Parameters.Add(new ValueParameter<IntValue>(MaximumFunctionArgumentsParameterName, MaximumFunctionArgumentsParameterDescription));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(LowerEstimationLimitParameterName, LowerEstimationLimitParameterDescription, new DoubleValue()));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(UpperEstimationLimitParameterName, UpperEstimationLimitParameterDescription, new DoubleValue()));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, MaximumSymbolicExpressionTreeDepthParameterDescription, new IntValue()));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, MaximumSymbolicExpressionTreeLengthParameterDescription, new IntValue()));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumFunctionDefinitionsParameterName, MaximumFunctionDefinitionsParameterDescription, new IntValue()));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumFunctionArgumentsParameterName, MaximumFunctionArgumentsParameterDescription, new IntValue()));
+
+      SymbolicExpressionTreeGrammar = new TypeCoherentExpressionGrammar();
+      SymbolicExpressionTreeInterpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
+
+      UpdateGrammar();
+      UpdateEstimationLimits();
+      RegisterEventHandlers();
+      InitializeOperators();
+    }
+
+    protected abstract void UpdateEstimationLimits();
+
+    private void InitializeOperators() {
+      Operators.AddRange(ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>());
+      Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
+      Operators.Add(new MinAverageMaxSymbolicExpressionTreeLengthAnalyzer());
+      ParameterizeOperators();
+    }
+
+    private void ProblemDataParameter_ValueChanged(object sender, EventArgs e) {
+      ProblemDataParameter.Value.Changed += (object s, EventArgs args) => OnProblemDataChanged();
+
+      OnProblemDataChanged();
+    }
+    private void RegisterEventHandlers() {
+      ProblemDataParameter.ValueChanged += new EventHandler(ProblemDataParameter_ValueChanged);
+      ProblemDataParameter.Value.Changed += (object sender, EventArgs e) => OnProblemDataChanged();
+
+      MaximumFunctionArguments.ValueChanged += new EventHandler(ArchitectureParameterValue_ValueChanged);
+      MaximumFunctionDefinitions.ValueChanged += new EventHandler(ArchitectureParameterValue_ValueChanged);
+      MaximumSymbolicExpressionTreeDepth.ValueChanged += new EventHandler(MaximumSymbolicExpressionTreeDepth_ValueChanged);
+    }
+
+    private void ArchitectureParameterValue_ValueChanged(object sender, EventArgs e) {
+      UpdateGrammar();
+    }
+    protected virtual void UpdateGrammar() {
+      foreach (var varSymbol in SymbolicExpressionTreeGrammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.Variable>()) {
+        varSymbol.VariableNames = ProblemData.AllowedInputVariables;
+      }
+      foreach (var varSymbol in SymbolicExpressionTreeGrammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.VariableCondition>()) {
+        varSymbol.VariableNames = ProblemData.AllowedInputVariables;
+      }
+    }
+
+    private void MaximumSymbolicExpressionTreeDepth_ValueChanged(object sender, EventArgs e) {
+      if (MaximumSymbolicExpressionTreeDepth != null && MaximumSymbolicExpressionTreeDepth.Value < 3)
+        MaximumSymbolicExpressionTreeDepth.Value = 3;
+    }
+
+    protected override void OnSolutionCreatorChanged() {
+      base.OnSolutionCreatorChanged();
+      SolutionCreator.SymbolicExpressionTreeParameter.ActualNameChanged += new EventHandler(SolutionCreator_SymbolicExpressionTreeParameter_ActualNameChanged);
+      ParameterizeOperators();
+    }
+    private void SolutionCreator_SymbolicExpressionTreeParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeOperators();
+    }
+
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
     }
 
     public event EventHandler ProblemDataChanged;
     protected virtual void OnProblemDataChanged() {
+      UpdateGrammar();
+      UpdateEstimationLimits();
       var handler = ProblemDataChanged;
       if (handler != null) handler(this, EventArgs.Empty);
+
+      OnReset();
+    }
+
+    private void ParameterizeOperators() {
+      var operators = Parameters.OfType<IValueParameter>().Select(p => p.Value).OfType<IOperator>().Union(Operators);
+
+      foreach (var op in operators.OfType<ISymbolicExpressionTreeGrammarBasedOperator>()) {
+        op.SymbolicExpressionTreeGrammarParameter.ActualName = SymbolicExpressionTreeGrammarParameter.Name;
+      }
+      foreach (var op in operators.OfType<ISymbolicExpressionTreeSizeConstraintOperator>()) {
+        op.MaximumSymbolicExpressionTreeDepthParameter.ActualName = MaximumSymbolicExpressionTreeDepthParameter.Name;
+        op.MaximumSymbolicExpressionTreeLengthParameter.ActualName = MaximumSymbolicExpressionTreeLengthParameter.Name;
+      }
+      foreach (var op in operators.OfType<ISymbolicExpressionTreeArchitectureAlteringOperator>()) {
+        op.MaximumFunctionArgumentsParameter.ActualName = MaximumFunctionArgumentsParameter.Name;
+        op.MaximumFunctionDefinitionsParameter.ActualName = MaximumFunctionDefinitionsParameter.Name;
+      }
+      foreach (var op in operators.OfType<ISymbolicDataAnalysisEvaluator<T>>()) {
+        op.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
+        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+        op.SamplesStartParameter.Value.Value = ProblemData.TrainingPartitionStart.Value;
+        op.SamplesEndParameter.Value.Value = ProblemData.TrainingPartitionEnd.Value;
+      }
+      foreach (var op in operators.OfType<ISymbolicDataAnalysisBoundedEvaluator<T>>()) {
+        op.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameter.Name;
+        op.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameter.Name;
+      }
+      foreach (var op in operators.OfType<ISymbolicExpressionTreeCrossover>()) {
+        op.ParentsParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+        op.ChildParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+      }
+      foreach (var op in operators.OfType<ISymbolicExpressionTreeManipulator>()) {
+        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+      }
+      foreach (var op in operators.OfType<ISymbolicExpressionTreeAnalyzer>()) {
+        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+      }
     }
   }