Random Forest — Machine Learning/Classical Models

Random Forest

Machine Learning / Classical Models

A fitted forest, evaluated at inference. Every tree is walked exactly as Decision Tree walks one – left when u[Feature] ≤ Threshold – and the leaves the T trees reach are combined:

• Average (regression) – y = (1/T)·Σ leafValue, the mean of the trees' predictions.
• Vote (classification) – each tree's leaf names a class, and y is the class the most trees chose.

The whole forest arrives as one stacked table: every tree's nodes laid end to end in the same five columns a single tree uses, plus a Tree Roots column naming the row each tree starts at. That is what RandomForestClassifier.estimators_ gives you once flattened, and it is the same table Gradient Boosted Trees and Isolation Forest Score read.

Ports

• u – the feature column, [d,1]. Every entry of Feature Index must name a row of it.
• y – a [1,1] scalar: the averaged prediction, or the winning class label.

Parameters

The five node columns are all [N,1], one row per node across the whole forest, in the layout scikit-learn's tree_ already uses.

• Feature Index – which entry of u the node tests, zero-based. Ignored at leaves.
• Threshold – the value it is tested against. Ignored at leaves.
• Left Child – the row taken when u[Feature] ≤ Threshold. A negative entry marks a leaf, scikit-learn's own convention.
• Right Child – the row taken otherwise. Ignored at leaves.
• Leaf Value – under Average, the value this leaf predicts; under Vote, the class index it votes for, a whole number from 0 to Class Count−1.
• Tree Roots – a [T,1] column: the row each tree's root sits at. Its height is the number of trees, and it is the only thing that tells one tree from the next in the stacked table.
• Aggregation – how the T leaves are combined. Each is a different code path, so each is verified as a mode of its own:
  • Average (regression) – the mean of the leaf values.
  • Vote (classification) – the most-chosen class.
• Class Count – how many classes the vote ranges over, used by Vote only. Leaf values must then be whole numbers in [0, Class Count−1].
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

Children must have a higher row number than their parent, counted in the stacked table's own numbering. Every fitted-tree exporter emits them that way, and requiring it means a malformed table is reported at the start of the run rather than sending the code generator into an endless walk.

Ties in the vote go to the lowest class index – the scan replaces its best only on a strictly greater count. That is Argmax Decision's rule, used here deliberately rather than re-decided, so a diagram holding both blocks cannot get two different answers to the same question.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. Every target is exact, and the three HDL targets are genuinely synthesizable Q16.16: the body is comparisons, additions of baked constants, and one constant multiply by 1/T, which is folded at configuration load so that no divider ever appears.

The forest is emitted as nested if cascades, one per tree, for the reason Decision Tree documents: a literal walk needs a data-dependent index into five arrays per level, which in hardware is a multiplexer over every node. Under Vote the block emits one cascade per class, in which a leaf contributes 1 if it votes for that class and 0 if it does not – so the emitted size is proportional to nodes × classes, and a forest with many classes produces a correspondingly large core.

Simulink bridge

None, for exactly the reasons Decision Tree gives: the reference would be the Statistics and Machine Learning Toolbox, which is not installed on this machine, so a bridge could not be run against a parity testbench even if one were written – and its predict blocks take a fitted model object from a workspace variable, which no parameter mapping can carry. That is why the forest is pasted here as plain columns. The bridge reports the block rather than dropping it silently, and it has no parity testbench, which is the documented consequence of Support::None. Code export verification still covers it across all ten languages, in both modes.

Notes

• Algebraic and stateless: the output depends only on the current sample.
• Piecewise constant in both modes, so no state space, for the reason Decision Tree gives: no A/B/C/D is true of a staircase, and model reduction correctly refuses the block.
• Averaging is what a forest is for. A single tree's output jumps at every split; T of them averaged jump by roughly 1/T as much, which is the whole reason a forest is smoother and more accurate than its members.
• The comparison is ≤ going left, matching scikit-learn. A sample landing exactly on a threshold goes left, and in fixed point that is not rare: an HDL port delivers Q16.16, so an exactly representable threshold is landed on rather than approached.
• Under Vote the HDL targets can disagree at a near-tie, the way Argmax Decision documents: they compare Q16.16 counts, and a sample whose features sit within one quantum of a split can send a tree the other way and move the winning class by a whole index. That is inherent to reducing a continuous quantity to a discrete decision in fixed point.