source: branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionConstantOptimizationEvaluator.cs @ 14232

Last change on this file since 14232 was 14232, checked in by gkronber, 3 years ago

created a feature branch for #2650 (support for categorical variables in symb reg) with a first set of changes

work in progress...

File size: 25.1 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Linq;
25using AutoDiff;
26using HeuristicLab.Common;
27using HeuristicLab.Core;
28using HeuristicLab.Data;
29using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
30using HeuristicLab.Parameters;
31using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
32
33namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
34  [Item("Constant Optimization Evaluator", "Calculates Pearson R² of a symbolic regression solution and optimizes the constant used.")]
35  [StorableClass]
36  public class SymbolicRegressionConstantOptimizationEvaluator : SymbolicRegressionSingleObjectiveEvaluator {
37    private const string ConstantOptimizationIterationsParameterName = "ConstantOptimizationIterations";
38    private const string ConstantOptimizationImprovementParameterName = "ConstantOptimizationImprovement";
39    private const string ConstantOptimizationProbabilityParameterName = "ConstantOptimizationProbability";
40    private const string ConstantOptimizationRowsPercentageParameterName = "ConstantOptimizationRowsPercentage";
41    private const string UpdateConstantsInTreeParameterName = "UpdateConstantsInSymbolicExpressionTree";
42    private const string UpdateVariableWeightsParameterName = "Update Variable Weights";
43
44    public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter {
45      get { return (IFixedValueParameter<IntValue>)Parameters[ConstantOptimizationIterationsParameterName]; }
46    }
47    public IFixedValueParameter<DoubleValue> ConstantOptimizationImprovementParameter {
48      get { return (IFixedValueParameter<DoubleValue>)Parameters[ConstantOptimizationImprovementParameterName]; }
49    }
50    public IFixedValueParameter<PercentValue> ConstantOptimizationProbabilityParameter {
51      get { return (IFixedValueParameter<PercentValue>)Parameters[ConstantOptimizationProbabilityParameterName]; }
52    }
53    public IFixedValueParameter<PercentValue> ConstantOptimizationRowsPercentageParameter {
54      get { return (IFixedValueParameter<PercentValue>)Parameters[ConstantOptimizationRowsPercentageParameterName]; }
55    }
56    public IFixedValueParameter<BoolValue> UpdateConstantsInTreeParameter {
57      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateConstantsInTreeParameterName]; }
58    }
59    public IFixedValueParameter<BoolValue> UpdateVariableWeightsParameter {
60      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateVariableWeightsParameterName]; }
61    }
62
63
64    public IntValue ConstantOptimizationIterations {
65      get { return ConstantOptimizationIterationsParameter.Value; }
66    }
67    public DoubleValue ConstantOptimizationImprovement {
68      get { return ConstantOptimizationImprovementParameter.Value; }
69    }
70    public PercentValue ConstantOptimizationProbability {
71      get { return ConstantOptimizationProbabilityParameter.Value; }
72    }
73    public PercentValue ConstantOptimizationRowsPercentage {
74      get { return ConstantOptimizationRowsPercentageParameter.Value; }
75    }
76    public bool UpdateConstantsInTree {
77      get { return UpdateConstantsInTreeParameter.Value.Value; }
78      set { UpdateConstantsInTreeParameter.Value.Value = value; }
79    }
80
81    public bool UpdateVariableWeights {
82      get { return UpdateVariableWeightsParameter.Value.Value; }
83      set { UpdateVariableWeightsParameter.Value.Value = value; }
84    }
85
86    public override bool Maximization {
87      get { return true; }
88    }
89
90    [StorableConstructor]
91    protected SymbolicRegressionConstantOptimizationEvaluator(bool deserializing) : base(deserializing) { }
92    protected SymbolicRegressionConstantOptimizationEvaluator(SymbolicRegressionConstantOptimizationEvaluator original, Cloner cloner)
93      : base(original, cloner) {
94    }
95    public SymbolicRegressionConstantOptimizationEvaluator()
96      : base() {
97      Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsParameterName, "Determines how many iterations should be calculated while optimizing the constant of a symbolic expression tree (0 indicates other or default stopping criterion).", new IntValue(10), true));
98      Parameters.Add(new FixedValueParameter<DoubleValue>(ConstantOptimizationImprovementParameterName, "Determines the relative improvement which must be achieved in the constant optimization to continue with it (0 indicates other or default stopping criterion).", new DoubleValue(0), true) { Hidden = true });
99      Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationProbabilityParameterName, "Determines the probability that the constants are optimized", new PercentValue(1), true));
100      Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for constant optimization", new PercentValue(1), true));
101      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateConstantsInTreeParameterName, "Determines if the constants in the tree should be overwritten by the optimized constants.", new BoolValue(true)) { Hidden = true });
102      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be  optimized.", new BoolValue(true)) { Hidden = true });
103    }
104
105    public override IDeepCloneable Clone(Cloner cloner) {
106      return new SymbolicRegressionConstantOptimizationEvaluator(this, cloner);
107    }
108
109    [StorableHook(HookType.AfterDeserialization)]
110    private void AfterDeserialization() {
111      if (!Parameters.ContainsKey(UpdateConstantsInTreeParameterName))
112        Parameters.Add(new FixedValueParameter<BoolValue>(UpdateConstantsInTreeParameterName, "Determines if the constants in the tree should be overwritten by the optimized constants.", new BoolValue(true)));
113      if (!Parameters.ContainsKey(UpdateVariableWeightsParameterName))
114        Parameters.Add(new FixedValueParameter<BoolValue>(UpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be  optimized.", new BoolValue(true)));
115    }
116
117    public override IOperation InstrumentedApply() {
118      var solution = SymbolicExpressionTreeParameter.ActualValue;
119      double quality;
120      if (RandomParameter.ActualValue.NextDouble() < ConstantOptimizationProbability.Value) {
121        IEnumerable<int> constantOptimizationRows = GenerateRowsToEvaluate(ConstantOptimizationRowsPercentage.Value);
122        quality = OptimizeConstants(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, ProblemDataParameter.ActualValue,
123           constantOptimizationRows, ApplyLinearScalingParameter.ActualValue.Value, ConstantOptimizationIterations.Value, updateVariableWeights: UpdateVariableWeights, lowerEstimationLimit: EstimationLimitsParameter.ActualValue.Lower, upperEstimationLimit: EstimationLimitsParameter.ActualValue.Upper, updateConstantsInTree: UpdateConstantsInTree);
124
125        if (ConstantOptimizationRowsPercentage.Value != RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value) {
126          var evaluationRows = GenerateRowsToEvaluate();
127          quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, evaluationRows, ApplyLinearScalingParameter.ActualValue.Value);
128        }
129      } else {
130        var evaluationRows = GenerateRowsToEvaluate();
131        quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, evaluationRows, ApplyLinearScalingParameter.ActualValue.Value);
132      }
133      QualityParameter.ActualValue = new DoubleValue(quality);
134
135      return base.InstrumentedApply();
136    }
137
138    public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows) {
139      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
140      EstimationLimitsParameter.ExecutionContext = context;
141      ApplyLinearScalingParameter.ExecutionContext = context;
142
143      // Pearson R² evaluator is used on purpose instead of the const-opt evaluator,
144      // because Evaluate() is used to get the quality of evolved models on
145      // different partitions of the dataset (e.g., best validation model)
146      double r2 = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, ApplyLinearScalingParameter.ActualValue.Value);
147
148      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
149      EstimationLimitsParameter.ExecutionContext = null;
150      ApplyLinearScalingParameter.ExecutionContext = null;
151
152      return r2;
153    }
154
155    #region derivations of functions
156    // create function factory for arctangent
157    private readonly Func<Term, UnaryFunc> arctan = UnaryFunc.Factory(
158      eval: Math.Atan,
159      diff: x => 1 / (1 + x * x));
160    private static readonly Func<Term, UnaryFunc> sin = UnaryFunc.Factory(
161      eval: Math.Sin,
162      diff: Math.Cos);
163    private static readonly Func<Term, UnaryFunc> cos = UnaryFunc.Factory(
164       eval: Math.Cos,
165       diff: x => -Math.Sin(x));
166    private static readonly Func<Term, UnaryFunc> tan = UnaryFunc.Factory(
167      eval: Math.Tan,
168      diff: x => 1 + Math.Tan(x) * Math.Tan(x));
169    private static readonly Func<Term, UnaryFunc> erf = UnaryFunc.Factory(
170      eval: alglib.errorfunction,
171      diff: x => 2.0 * Math.Exp(-(x * x)) / Math.Sqrt(Math.PI));
172    private static readonly Func<Term, UnaryFunc> norm = UnaryFunc.Factory(
173      eval: alglib.normaldistribution,
174      diff: x => -(Math.Exp(-(x * x)) * Math.Sqrt(Math.Exp(x * x)) * x) / Math.Sqrt(2 * Math.PI));
175    #endregion
176
177
178    public static double OptimizeConstants(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling, int maxIterations, bool updateVariableWeights = true, double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue, bool updateConstantsInTree = true) {
179
180      List<AutoDiff.Variable> variables = new List<AutoDiff.Variable>();
181      List<AutoDiff.Variable> parameters = new List<AutoDiff.Variable>();
182      List<string> variableNames = new List<string>();
183      List<string> categoricalVariableValues = new List<string>();
184
185      AutoDiff.Term func;
186      if (!TryTransformToAutoDiff(tree.Root.GetSubtree(0), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out func))
187        throw new NotSupportedException("Could not optimize constants of symbolic expression tree due to not supported symbols used in the tree.");
188      if (variableNames.Count == 0) return 0.0; // gkronber: constant expressions always have a R² of 0.0
189
190      AutoDiff.IParametricCompiledTerm compiledFunc = func.Compile(variables.ToArray(), parameters.ToArray());
191
192      List<SymbolicExpressionTreeTerminalNode> terminalNodes = null; // gkronber only used for extraction of initial constants
193      if (updateVariableWeights)
194        terminalNodes = tree.Root.IterateNodesPrefix().OfType<SymbolicExpressionTreeTerminalNode>().ToList();
195      else
196        terminalNodes = new List<SymbolicExpressionTreeTerminalNode>(tree.Root.IterateNodesPrefix().OfType<ConstantTreeNode>());
197
198      //extract inital constants
199      double[] c = new double[variables.Count];
200      {
201        c[0] = 0.0;
202        c[1] = 1.0;
203        int i = 2;
204        foreach (var node in terminalNodes) {
205          ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
206          VariableTreeNode variableTreeNode = node as VariableTreeNode;
207          if (constantTreeNode != null)
208            c[i++] = constantTreeNode.Value;
209          else if (updateVariableWeights && variableTreeNode != null)
210            c[i++] = variableTreeNode.Weight;
211        }
212      }
213      double[] originalConstants = (double[])c.Clone();
214      double originalQuality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling);
215
216      alglib.lsfitstate state;
217      alglib.lsfitreport rep;
218      int info;
219
220      IDataset ds = problemData.Dataset;
221      double[,] x = new double[rows.Count(), variableNames.Count];
222      int row = 0;
223      foreach (var r in rows) {
224        for (int col = 0; col < variableNames.Count; col++) {
225          if (ds.VariableHasType<double>(variableNames[col])) {
226            x[row, col] = ds.GetDoubleValue(variableNames[col], r);
227          } else if (ds.VariableHasType<string>(variableNames[col])) {
228            x[row, col] = ds.GetStringValue(variableNames[col], r) == categoricalVariableValues[col] ? 1 : 0;
229          } else throw new InvalidProgramException("found a variable of unknown type");
230        }
231        row++;
232      }
233      double[] y = ds.GetDoubleValues(problemData.TargetVariable, rows).ToArray();
234      int n = x.GetLength(0);
235      int m = x.GetLength(1);
236      int k = c.Length;
237
238      alglib.ndimensional_pfunc function_cx_1_func = CreatePFunc(compiledFunc);
239      alglib.ndimensional_pgrad function_cx_1_grad = CreatePGrad(compiledFunc);
240
241      try {
242        alglib.lsfitcreatefg(x, y, c, n, m, k, false, out state);
243        alglib.lsfitsetcond(state, 0.0, 0.0, maxIterations);
244        //alglib.lsfitsetgradientcheck(state, 0.001);
245        alglib.lsfitfit(state, function_cx_1_func, function_cx_1_grad, null, null);
246        alglib.lsfitresults(state, out info, out c, out rep);
247      }
248      catch (ArithmeticException) {
249        return originalQuality;
250      }
251      catch (alglib.alglibexception) {
252        return originalQuality;
253      }
254
255      //info == -7  => constant optimization failed due to wrong gradient
256      if (info != -7) UpdateConstants(tree, c.Skip(2).ToArray(), updateVariableWeights);
257      var quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling);
258
259      if (!updateConstantsInTree) UpdateConstants(tree, originalConstants.Skip(2).ToArray(), updateVariableWeights);
260      if (originalQuality - quality > 0.001 || double.IsNaN(quality)) {
261        UpdateConstants(tree, originalConstants.Skip(2).ToArray(), updateVariableWeights);
262        return originalQuality;
263      }
264      return quality;
265    }
266
267    private static void UpdateConstants(ISymbolicExpressionTree tree, double[] constants, bool updateVariableWeights) {
268      int i = 0;
269      foreach (var node in tree.Root.IterateNodesPrefix().OfType<SymbolicExpressionTreeTerminalNode>()) {
270        ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
271        VariableTreeNode variableTreeNode = node as VariableTreeNode;
272        if (constantTreeNode != null)
273          constantTreeNode.Value = constants[i++];
274        else if (updateVariableWeights && variableTreeNode != null)
275          variableTreeNode.Weight = constants[i++];
276      }
277    }
278
279    private static alglib.ndimensional_pfunc CreatePFunc(AutoDiff.IParametricCompiledTerm compiledFunc) {
280      return (double[] c, double[] x, ref double func, object o) => {
281        func = compiledFunc.Evaluate(c, x);
282      };
283    }
284
285    private static alglib.ndimensional_pgrad CreatePGrad(AutoDiff.IParametricCompiledTerm compiledFunc) {
286      return (double[] c, double[] x, ref double func, double[] grad, object o) => {
287        var tupel = compiledFunc.Differentiate(c, x);
288        func = tupel.Item2;
289        Array.Copy(tupel.Item1, grad, grad.Length);
290      };
291    }
292
293    private static bool TryTransformToAutoDiff(ISymbolicExpressionTreeNode node, List<AutoDiff.Variable> variables, List<AutoDiff.Variable> parameters,
294      List<string> variableNames, List<string> categoricalVariableValues, bool updateVariableWeights, out AutoDiff.Term term) {
295      if (node.Symbol is Constant) {
296        var var = new AutoDiff.Variable();
297        variables.Add(var);
298        term = var;
299        return true;
300      }
301      if (node.Symbol is Variable) {
302        var varNode = node as VariableTreeNode;
303        var par = new AutoDiff.Variable();
304        parameters.Add(par);
305        variableNames.Add(varNode.VariableName);
306        categoricalVariableValues.Add(string.Empty);   // as a value as placeholder (variableNames.Length == catVariableValues.Length)
307
308        if (updateVariableWeights) {
309          var w = new AutoDiff.Variable();
310          variables.Add(w);
311          term = AutoDiff.TermBuilder.Product(w, par);
312        } else {
313          term = par;
314        }
315        return true;
316      }
317      if (node.Symbol is FactorVariable) {
318        // nothing to update in this case (like a variable without a weight)
319        // values are only 0 or 1 and set in x accordingly
320        var factorNode = node as FactorVariableTreeNode;
321        var par = new AutoDiff.Variable();
322        parameters.Add(par);
323        variableNames.Add(factorNode.VariableName);
324        categoricalVariableValues.Add(factorNode.VariableValue);
325        term = par;
326        return true;
327      }
328      if (node.Symbol is Addition) {
329        List<AutoDiff.Term> terms = new List<Term>();
330        foreach (var subTree in node.Subtrees) {
331          AutoDiff.Term t;
332          if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
333            term = null;
334            return false;
335          }
336          terms.Add(t);
337        }
338        term = AutoDiff.TermBuilder.Sum(terms);
339        return true;
340      }
341      if (node.Symbol is Subtraction) {
342        List<AutoDiff.Term> terms = new List<Term>();
343        for (int i = 0; i < node.SubtreeCount; i++) {
344          AutoDiff.Term t;
345          if (!TryTransformToAutoDiff(node.GetSubtree(i), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
346            term = null;
347            return false;
348          }
349          if (i > 0) t = -t;
350          terms.Add(t);
351        }
352        if (terms.Count == 1) term = -terms[0];
353        else term = AutoDiff.TermBuilder.Sum(terms);
354        return true;
355      }
356      if (node.Symbol is Multiplication) {
357        List<AutoDiff.Term> terms = new List<Term>();
358        foreach (var subTree in node.Subtrees) {
359          AutoDiff.Term t;
360          if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
361            term = null;
362            return false;
363          }
364          terms.Add(t);
365        }
366        if (terms.Count == 1) term = terms[0];
367        else term = terms.Aggregate((a, b) => new AutoDiff.Product(a, b));
368        return true;
369
370      }
371      if (node.Symbol is Division) {
372        List<AutoDiff.Term> terms = new List<Term>();
373        foreach (var subTree in node.Subtrees) {
374          AutoDiff.Term t;
375          if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
376            term = null;
377            return false;
378          }
379          terms.Add(t);
380        }
381        if (terms.Count == 1) term = 1.0 / terms[0];
382        else term = terms.Aggregate((a, b) => new AutoDiff.Product(a, 1.0 / b));
383        return true;
384      }
385      if (node.Symbol is Logarithm) {
386        AutoDiff.Term t;
387        if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
388          term = null;
389          return false;
390        } else {
391          term = AutoDiff.TermBuilder.Log(t);
392          return true;
393        }
394      }
395      if (node.Symbol is Exponential) {
396        AutoDiff.Term t;
397        if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
398          term = null;
399          return false;
400        } else {
401          term = AutoDiff.TermBuilder.Exp(t);
402          return true;
403        }
404      }
405      if (node.Symbol is Square) {
406        AutoDiff.Term t;
407        if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
408          term = null;
409          return false;
410        } else {
411          term = AutoDiff.TermBuilder.Power(t, 2.0);
412          return true;
413        }
414      }
415      if (node.Symbol is SquareRoot) {
416        AutoDiff.Term t;
417        if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
418          term = null;
419          return false;
420        } else {
421          term = AutoDiff.TermBuilder.Power(t, 0.5);
422          return true;
423        }
424      }
425      if (node.Symbol is Sine) {
426        AutoDiff.Term t;
427        if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
428          term = null;
429          return false;
430        } else {
431          term = sin(t);
432          return true;
433        }
434      }
435      if (node.Symbol is Cosine) {
436        AutoDiff.Term t;
437        if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
438          term = null;
439          return false;
440        } else {
441          term = cos(t);
442          return true;
443        }
444      }
445      if (node.Symbol is Tangent) {
446        AutoDiff.Term t;
447        if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
448          term = null;
449          return false;
450        } else {
451          term = tan(t);
452          return true;
453        }
454      }
455      if (node.Symbol is Erf) {
456        AutoDiff.Term t;
457        if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
458          term = null;
459          return false;
460        } else {
461          term = erf(t);
462          return true;
463        }
464      }
465      if (node.Symbol is Norm) {
466        AutoDiff.Term t;
467        if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out t)) {
468          term = null;
469          return false;
470        } else {
471          term = norm(t);
472          return true;
473        }
474      }
475      if (node.Symbol is StartSymbol) {
476        var alpha = new AutoDiff.Variable();
477        var beta = new AutoDiff.Variable();
478        variables.Add(beta);
479        variables.Add(alpha);
480        AutoDiff.Term branchTerm;
481        if (TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, categoricalVariableValues, updateVariableWeights, out branchTerm)) {
482          term = branchTerm * alpha + beta;
483          return true;
484        } else {
485          term = null;
486          return false;
487        }
488      }
489      term = null;
490      return false;
491    }
492
493    public static bool CanOptimizeConstants(ISymbolicExpressionTree tree) {
494      var containsUnknownSymbol = (
495        from n in tree.Root.GetSubtree(0).IterateNodesPrefix()
496        where
497         !(n.Symbol is Variable) &&
498         !(n.Symbol is FactorVariable) &&
499         !(n.Symbol is Constant) &&
500         !(n.Symbol is Addition) &&
501         !(n.Symbol is Subtraction) &&
502         !(n.Symbol is Multiplication) &&
503         !(n.Symbol is Division) &&
504         !(n.Symbol is Logarithm) &&
505         !(n.Symbol is Exponential) &&
506         !(n.Symbol is SquareRoot) &&
507         !(n.Symbol is Square) &&
508         !(n.Symbol is Sine) &&
509         !(n.Symbol is Cosine) &&
510         !(n.Symbol is Tangent) &&
511         !(n.Symbol is Erf) &&
512         !(n.Symbol is Norm) &&
513         !(n.Symbol is StartSymbol)
514        select n).
515      Any();
516      return !containsUnknownSymbol;
517    }
518  }
519}
Note: See TracBrowser for help on using the repository browser.