Changeset 3532

Timestamp:

04/26/10 14:21:03 (15 years ago)

Author:

gkronber

Message:

Implemented linear scaling. #938 (Data types and operators for regression problems)

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3

Files:

• HeuristicLab.Problems.DataAnalysis.Regression-3.3.csproj (modified) (1 diff)
• Symbolic/BestValidationSymbolicRegressionSolutionVisualizer.cs (modified) (10 diffs)
• Symbolic/SymbolicRegressionProblem.cs (modified) (5 diffs)
• Symbolic/SymbolicRegressionScaledMeanSquaredErrorEvaluator.cs (added)

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/HeuristicLab.Problems.DataAnalysis.Regression-3.3.csproj

@@ -87 +87 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Symbolic\BestValidationSymbolicRegressionSolutionVisualizer.cs" />
+    <Compile Include="Symbolic\SymbolicRegressionScaledMeanSquaredErrorEvaluator.cs" />
     <Compile Include="Symbolic\SymbolicRegressionSolution.cs" />
     <Compile Include="Symbolic\SymbolicRegressionModel.cs" />

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/BestValidationSymbolicRegressionSolutionVisualizer.cs

@@ -34 +34 @@
 using HeuristicLab.Analysis;
 
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols;
+
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic {
   /// <summary>
@@ -44 +46 @@
     private const string UpperEstimationLimitParameterName = "UpperEstimationLimit";
     private const string LowerEstimationLimitParameterName = "LowerEstimationLimit";
+    private const string AlphaParameterName = "Alpha";
+    private const string BetaParameterName = "Beta";
     private const string SymbolicRegressionModelParameterName = "SymbolicRegressionModel";
     private const string DataAnalysisProblemDataParameterName = "DataAnalysisProblemData";
@@ -73 +77 @@
       get { return (ILookupParameter<ItemArray<SymbolicExpressionTree>>)Parameters[SymbolicRegressionModelParameterName]; }
     }
+    public ILookupParameter<ItemArray<DoubleValue>> AlphaParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters[AlphaParameterName]; }
+    }
+    public ILookupParameter<ItemArray<DoubleValue>> BetaParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters[BetaParameterName]; }
+    }
     public ILookupParameter<DataAnalysisProblemData> DataAnalysisProblemDataParameter {
       get { return (ILookupParameter<DataAnalysisProblemData>)Parameters[DataAnalysisProblemDataParameterName]; }
@@ -124 +134 @@
       Parameters.Add(new LookupParameter<DataAnalysisProblemData>(DataAnalysisProblemDataParameterName, "The symbolic regression problme data on which the best solution should be evaluated."));
       Parameters.Add(new LookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used to calculate the output values of symbolic expression trees."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>(AlphaParameterName, "Alpha parameter for linear scaling of the estimated values."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>(BetaParameterName, "Beta parameter for linear scaling ot the estimated values."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper limit that should be used as cut off value for the output values of symbolic expression trees."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower limit that should be used as cut off value for the output values of symbolic expression trees."));
@@ -135 +147 @@
     public override IOperation Apply() {
       ItemArray<SymbolicExpressionTree> expressions = SymbolicExpressionTreeParameter.ActualValue;
+      ItemArray<DoubleValue> alphas = AlphaParameter.ActualValue;
+      ItemArray<DoubleValue> betas = BetaParameter.ActualValue;
+      var scaledExpressions = from i in Enumerable.Range(0, expressions.Count())
+                              let expr = expressions[i]
+                              let alpha = alphas[i].Value
+                              let beta = betas[i].Value
+                              select new { Expression = expr, Alpha = alpha, Beta = beta };
       DataAnalysisProblemData problemData = DataAnalysisProblemDataParameter.ActualValue;
       #region update variable frequencies
@@ -156 +175 @@
       double upperEstimationLimit = UpperEstimationLimit.Value;
       double lowerEstimationLimit = LowerEstimationLimit.Value;
-      var currentBestExpression = (from expression in expressions
+      var currentBestExpression = (from expression in scaledExpressions
                                    let validationQuality =
-                                     SymbolicRegressionMeanSquaredErrorEvaluator.Calculate(
-                                       SymbolicExpressionTreeInterpreter, expression,
+                                     SymbolicRegressionScaledMeanSquaredErrorEvaluator.CalculateWithScaling(
+                                       SymbolicExpressionTreeInterpreter, expression.Expression,
                                        lowerEstimationLimit, upperEstimationLimit,
                                        problemData.Dataset, problemData.TargetVariable.Value,
-                                       validationSamplesStart, validationSamplesEnd)
+                                       validationSamplesStart, validationSamplesEnd,
+                                       expression.Beta, expression.Alpha)
                                    select new { Expression = expression, ValidationQuality = validationQuality })
                                    .OrderBy(x => x.ValidationQuality)
@@ -172 +192 @@
       if (bestOfRunSolution == null) {
         // no best of run solution yet -> make a solution from the currentBestExpression
-        UpdateBestOfRunSolution(problemData, currentBestExpression.Expression, SymbolicExpressionTreeInterpreter, lowerEstimationLimit, upperEstimationLimit);
+        UpdateBestOfRunSolution(problemData, currentBestExpression.Expression.Expression, SymbolicExpressionTreeInterpreter, lowerEstimationLimit, upperEstimationLimit, currentBestExpression.Expression.Alpha, currentBestExpression.Expression.Beta);
       } else {
         // compare quality of current best with best of run solution
@@ -178 +198 @@
         var bestOfRunValidationQuality = SimpleMSEEvaluator.Calculate(validationValues, estimatedValidationValues);
         if (bestOfRunValidationQuality > currentBestExpression.ValidationQuality) {
-          UpdateBestOfRunSolution(problemData, currentBestExpression.Expression, SymbolicExpressionTreeInterpreter, lowerEstimationLimit, upperEstimationLimit);
+          UpdateBestOfRunSolution(problemData, currentBestExpression.Expression.Expression, SymbolicExpressionTreeInterpreter, lowerEstimationLimit, upperEstimationLimit, currentBestExpression.Expression.Alpha, currentBestExpression.Expression.Beta);
         }
       }
@@ -186 +206 @@
 
     private void UpdateBestOfRunSolution(DataAnalysisProblemData problemData, SymbolicExpressionTree tree, ISymbolicExpressionTreeInterpreter interpreter,
-      double lowerEstimationLimit, double upperEstimationLimit) {
-      var newBestSolution = CreateDataAnalysisSolution(problemData, tree, interpreter, lowerEstimationLimit, upperEstimationLimit);
+      double lowerEstimationLimit, double upperEstimationLimit,
+      double alpha, double beta) {
+      var newBestSolution = CreateDataAnalysisSolution(problemData, tree, interpreter, lowerEstimationLimit, upperEstimationLimit, alpha, beta);
       if (BestValidationSolutionParameter.ActualValue == null)
         BestValidationSolutionParameter.ActualValue = newBestSolution;
@@ -215 +236 @@
     }
 
-    private SymbolicRegressionSolution CreateDataAnalysisSolution(DataAnalysisProblemData problemData, SymbolicExpressionTree expression, ISymbolicExpressionTreeInterpreter interpreter,
-      double lowerEstimationLimit, double upperEstimationLimit) {
-      var model = new SymbolicRegressionModel(interpreter, expression, problemData.InputVariables.Select(s => s.Value));
+    private SymbolicRegressionSolution CreateDataAnalysisSolution(DataAnalysisProblemData problemData, SymbolicExpressionTree tree, ISymbolicExpressionTreeInterpreter interpreter,
+      double lowerEstimationLimit, double upperEstimationLimit,
+      double alpha, double beta) {
+      var mainBranch = tree.Root.SubTrees[0].SubTrees[0];
+      var scaledMainBranch = MakeSum(MakeProduct(beta, mainBranch), alpha);
+
+      // remove the main branch before cloning to prevent cloning of sub-trees
+      tree.Root.SubTrees[0].RemoveSubTree(0);
+      var scaledTree = (SymbolicExpressionTree)tree.Clone();
+      // insert main branch into the original tree again 
+      tree.Root.SubTrees[0].InsertSubTree(0, mainBranch);
+      // insert the scaled main branch into the cloned tree
+      scaledTree.Root.SubTrees[0].InsertSubTree(0, scaledMainBranch);
+      // create a new solution using the scaled tree
+      var model = new SymbolicRegressionModel(interpreter, scaledTree, problemData.InputVariables.Select(s => s.Value));
       return new SymbolicRegressionSolution(problemData, model, lowerEstimationLimit, upperEstimationLimit);
+    }
+
+    private SymbolicExpressionTreeNode MakeSum(SymbolicExpressionTreeNode treeNode, double alpha) {
+      var node = (new Addition()).CreateTreeNode();
+      var alphaConst = MakeConstant(alpha);
+      node.AddSubTree(treeNode);
+      node.AddSubTree(alphaConst);
+      return node;
+    }
+
+    private SymbolicExpressionTreeNode MakeProduct(double beta, SymbolicExpressionTreeNode treeNode) {
+      var node = (new Multiplication()).CreateTreeNode();
+      var betaConst = MakeConstant(beta);
+      node.AddSubTree(treeNode);
+      node.AddSubTree(betaConst);
+      return node;
+    }
+
+    private SymbolicExpressionTreeNode MakeConstant(double c) {
+      var node = (ConstantTreeNode)(new Constant()).CreateTreeNode();
+      node.Value = c;
+      return node;
     }
   }

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblem.cs

@@ -111 +111 @@
       set { MaxExpressionDepthParameter.Value = value; }
     }
+    public IntValue MaxFunctionDefiningBranches {
+      get { return MaxFunctionDefiningBranchesParameter.Value; }
+      set { MaxFunctionDefiningBranchesParameter.Value = value; }
+    }
+    public IntValue MaxFunctionArguments {
+      get { return MaxFunctionArgumentsParameter.Value; }
+      set { MaxFunctionArgumentsParameter.Value = value; }
+    }
     public SymbolicExpressionTreeCreator SolutionCreator {
       get { return SolutionCreatorParameter.Value; }
@@ -166 +174 @@
       : base() {
       SymbolicExpressionTreeCreator creator = new ProbabilisticTreeCreator();
-      var evaluator = new SymbolicRegressionMeanSquaredErrorEvaluator();
+      var evaluator = new SymbolicRegressionScaledMeanSquaredErrorEvaluator();
       var grammar = new ArithmeticExpressionGrammar();
       var globalGrammar = new GlobalSymbolicExpressionGrammar(grammar);
@@ -190 +198 @@
       DataAnalysisProblemDataParameter.ValueChanged += new EventHandler(DataAnalysisProblemDataParameter_ValueChanged);
       DataAnalysisProblemData.ProblemDataChanged += new EventHandler(DataAnalysisProblemData_Changed);
+      MaxFunctionArgumentsParameter.ValueChanged += new EventHandler(ArchitectureParameter_Changed);
+      MaxFunctionArgumentsParameter.Value.ValueChanged += new EventHandler(ArchitectureParameter_Changed);
+      MaxFunctionDefiningBranchesParameter.ValueChanged += new EventHandler(ArchitectureParameter_Changed);
+      MaxFunctionDefiningBranchesParameter.Value.ValueChanged += new EventHandler(ArchitectureParameter_Changed);
       ParameterizeSolutionCreator();
       ParameterizeEvaluator();
@@ -196 +208 @@
       Initialize();
     }
+
 
     [StorableConstructor]
@@ -214 +227 @@
       UpdateGrammar();
       UpdatePartitioningParameters();
+    }
+
+    void ArchitectureParameter_Changed(object sender, EventArgs e) {
+      var globalGrammar = FunctionTreeGrammar as GlobalSymbolicExpressionGrammar;
+      globalGrammar.MaxFunctionArguments = MaxFunctionArguments.Value;
+      globalGrammar.MaxFunctionDefinitions = MaxFunctionDefiningBranches.Value;
     }