Gradient Boosted Trees — Machine Learning/Classical Models

Gradient Boosted Trees

Machine Learning / Classical Models

Evaluates an additive ensemble of regression trees:

score = base + rate · Σ_t w_t · leaf_t(u), then y = score, y = 1/(1 + e^−score) or y = ±1 on its sign.

This is the inference half of XGBoost, LightGBM and sklearn's GradientBoosting – all three dump a model that reduces to exactly this. Boosting adds where a random forest averages, and that one difference is the only thing separating this block from Random Forest: they share the stacked node table, the leaf marker and the walker.

It is also AdaBoost. Give each tree its own weight in Tree Weights and take the verdict off Sign, and the sum above is AdaBoost's weighted vote H(u) = sign(Σ_t α_t h_t(u)) written out – the same stacked node table, the same walker, one more column of numbers.

Ports

• u – the feature column [d,1]. d is read off the largest Feature Index the tree table actually uses, so it needs no setting of its own.
• y – a scalar [1,1]: the prediction, after whatever Output selects.

Parameters

• Feature Index, Threshold, Left Child, Right Child, Leaf Value – the node table, one row per node, stacked across every tree, exactly as Decision Tree and Random Forest take it. A sample goes left when u[Feature Index] ≤ Threshold, which is scikit-learn's sense. A negative Left Child marks a leaf (TREE_LEAF), and at a leaf the feature and threshold are ignored, so tree_ pastes in unchanged.
• Tree Roots – one row per tree, giving that tree's first node. Its length is the number of trees.
• Base Score – the ensemble's starting prediction, before any tree. XGBoost calls it base_score; sklearn's initial estimator contributes it.
• Learning Rate – the shrinkage applied to the tree sum. ⚠ Which exporter you came from decides this, and nothing in the numbers can tell you:
  • XGBoost and LightGBM bake the shrinkage into the leaf values when they dump a model, so leave this at 1.
  • sklearn's GradientBoosting keeps raw leaves and applies learning_rate at predict time – paste that value here.
  Getting it wrong is a silent constant factor across the whole prediction.
• Tree Weights – the weight each tree votes with, w_t above. Either a single row, which gives every tree that same weight, or a column of exactly one row per tree, in Tree Roots' order. The default is 1: plain boosting, every tree counting the same. Paste AdaBoost's estimator_weights_ here to get its weighted vote. Anything else – a column that is neither 1 nor T rows – is refused rather than padded.
• Output – the link applied to the score:
  • Raw (regression) – the score itself. The default.
  • Logistic (binary probability) – 1/(1 + e^−s), which is what a binary classifier's margin means.
  • Sign (weighted vote) – +1 when the score is strictly positive and −1 otherwise, which is AdaBoost's verdict. A score of exactly zero gives −1, the same side scikit-learn's classes_[(decision > 0)] sends it.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. The whole ensemble is baked into the body: the traversal is emitted as a nested if cascade rather than a loop over the table, so each node appears exactly once, no index arithmetic exists anywhere, and the emitted code is O(nodes) rather than O(nodes×depth).

The Output settings differ in hardware, and it is worth knowing which you are exporting. In Raw the block is comparisons, adds and one multiply – exact in every target and genuine synthesizable Q16.16 on the three HDLs. Sign adds one comparison and so stays there too. Logistic adds an exponential, so those three targets fall back to simulation-only real arithmetic for that setting alone, quantizing only at the port boundary.

Tree Weights costs nothing anywhere. Both the weight and the leaf value are known when the code is written, so their product is folded into the one constant the cascade already carried: no target multiplies per tree, the three HDLs quantize once instead of twice, and at the default weight of 1 the emitted body is exactly what it was without the setting.

Simulink bridge

None. Boosted-tree inference belongs to the Statistics and Machine Learning Toolbox, which is not installed here, and its interface takes a fitted model object rather than parameters – which no parameter rule could carry even if it were present. The bridge reports the block rather than dropping it silently, and it has no parity testbench, which is the documented consequence of Support::None rather than a gap.

Notes

• Algebraic and stateless: the prediction depends only on the current sample.
• Nonlinear and discontinuous, and deliberately carries no state space: the output steps at every split, so no A/B/C/D describes it and model reduction correctly refuses the block.
• Children must have a higher row number than their parent, which every fitted exporter satisfies. It is checked, because a backward-pointing table would send the code emitter into unbounded recursion – a stack overflow at export time, far from the configuration that caused it.
• The rate multiplies the SUM, not each leaf – the same number in exact arithmetic, and one multiply instead of one per tree. The tree weight cannot be treated that way and is not: it is per tree, so it is folded into that tree's leaves instead.
• Sign is the one setting a fixed-point export can disagree with the live run about. The score is a sum of baked constants, so it takes only as many values as the ensemble has leaf combinations; place them clear of zero and every target agrees exactly, put one within Q16.16's 1.5×10⁻⁵ of zero and the three HDL targets may call it the other way.