SVM Predictor — Machine Learning/Classical Models

SVM Predictor

Machine Learning / Classical Models

Evaluates a fitted support vector machine at inference, with the model baked in as configuration:

score = intercept + Σ_i coef_i·K(sv_i, u), and label = +1 when score ≥ 0, −1 otherwise.

The numbers come straight out of scikit-learn: support_vectors_, dual_coef_ and intercept_. Nothing is fitted here and no model file is read – that is what lets the block export to all ten targets and run with no interpreter.

Ports

• u – the feature vector, a column [d,1], where d must equal the number of columns of Support Vectors.
• score – a scalar [1,1]: the decision function. Its magnitude is the margin, in the units the kernel produces.
• label – a scalar [1,1]: +1 or −1. Emitted as a number rather than a boolean, so no backend needs a type the others lack.

Parameters

• Support Vectors – an [N,d] matrix, one support vector per row. This is scikit-learn's support_vectors_ orientation, so it pastes in without transposing.
• Dual Coefficients – N values, scikit-learn's dual_coef_. ⚠ These already carry the sign (they are y·α, not α), so the class labels must not be applied again. A row or a column is accepted; both spell the same sequence.
• Intercept – a scalar, scikit-learn's intercept_.
• Kernel – which K:
  • RBF (Gaussian) – exp(−γ·‖u−sv‖²). The default, and what a model fitted without thought about kernels almost certainly uses.
  • Linear – u·sv. See Code export: this one collapses to a single weight vector.
  • Polynomial – (γ·u·sv + coef0)^degree. Note γ multiplies the dot product inside the power, which is the detail that differs silently between libraries.
• Gamma – the kernel width for RBF and the scale inside Polynomial. Must be strictly positive for RBF; at zero every kernel value collapses to 1 and the block reports its bias whatever the input is. Ignored by Linear.
• Coef0 – the additive term inside the polynomial power. Ignored by the other two kernels.
• Degree – the polynomial power, a whole number ≥ 1, rounded from what is typed. Ignored by the other two kernels. It is unrolled into repeated multiplication at export, so a large degree makes a large core; values above 32 are refused for that reason.
• 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 model is baked into the body at export time; there is no tunable parameter, so a refitted model means a re-export.

The linear kernel folds. Because K is a dot product, Σ_i coef_i·(sv_i·u) is (Σ_i coef_i·sv_i)·u, so the whole support-vector set collapses to one weight vector at config load and the exported core performs a single multiply-accumulate over d features instead of N×d. That folded vector is exactly what scikit-learn calls coef_.

The HDL story depends on the kernel. Linear and Polynomial are multiply-accumulate only, so the three HDL targets carry them in genuine Q16.16 fixed point. RBF has an exponential and cannot: those three bodies are simulation-only real arithmetic that quantizes at the port boundary only. A polynomial of high degree in Q16.16 will also saturate long before the software targets do, since each factor multiplies the dynamic range.

Simulink bridge

None. Simulink's SVM prediction blocks belong to the Statistics and Machine Learning Toolbox, which is not installed on this machine, and they take a fitted model object rather than parameters – there is no ParamRule that could carry a support-vector set across. 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 every kernel.

Notes

• Algebraic and stateless: the outputs depend only on the current input, so the block cannot break an algebraic loop.
• Nonlinear, and deliberately carries no state space – even under the linear kernel, where the score is affine in u. A state space would let model reduction absorb the block into a neighbouring plant, and what that erases is the label output, which is a discontinuous function of the same input.
• The label is discontinuous at the boundary, so the three HDL targets can disagree with the simulation on a sample whose score sits within one Q16.16 quantum (about 1.5e-5) of zero: label then differs by 2, not by a rounding error. That is inherent to reducing a continuous quantity to a decision in fixed point. Threshold the score output downstream in floating point if an application cannot tolerate it.
• Multi-class is not this block. A one-vs-rest ensemble is several of these into Argmax Decision; a one-vs-one vote is several into a vote. Keeping the block binary is what keeps the config a matrix rather than a ragged set of them.