Auto Ordinal Node

AI/ML/Tuning

Automatically finds the best model for a target whose levels are ORDERED (1 < 2 < ... < 5, or low < medium < high). Cross-validates the ordinal families - Proportional Odds and Ordered Probit, the all-threshold model and its support-vector form, Ordinal Ridge, Continuation Ratio and Adjacent Category, plus an optional rank-consistent neural family that is off by default because it costs far more than all the others combined - on identical folds, ranks them by an ordinal metric that knows how far a miss was, then retrains the winner on the full data. Use this rather than Auto Classifier, which resolves the target without its order and ranks by accuracy or macro-F1, scoring a five-level miss exactly like a one-level one. Every candidate here is a gradient or a least-squares fit on the raw columns, so scale your features with the Fit Feature Scaler node first: unscaled columns change which family wins, not just how fast it converges.

ai_ml_tuning_auto_ordinalml

Inputs12

Outputs5

Security exposure6/10

Packageml

Ratings

Scores range from 0 to 10. Higher values mean more impact, exposure, or operational weight.

SecurityAttack surface and exposure impact.

6/10Medium

PrivacyPotential sensitivity of processed data.

6/10Medium

PerformanceRuntime or resource pressure.

3/10Low

GovernancePolicy, audit, or compliance impact.

8/10High

ReliabilityOperational stability considerations.

7/10High

CostExternal or compute cost impact.

3/10Low

Input Pins

Input

Execution

exec_in

Execution trigger that starts the ordinal model search

Data Source

String

source

Choose which backend supplies the training data

Default Database

Database

Class Order

String

class_order

Comma-separated level labels from LOWEST to HIGHEST, e.g. `low, medium, high`. Leave empty when the levels are numeric and their numeric order is the order you want. Non-numeric labels have no inferable order, so the search fails rather than guessing one. The level set is resolved once here and handed to every family, so a level that a fold happens to miss cannot renumber the ranks for that fold.

CV Folds

Integer

cv_folds

How many folds the rows are split into. Every family is scored on the SAME folds, so the comparison is paired rather than a race between different splits. More folds mean a less noisy score and proportionally more fitting, since the whole sweep is repeated once per fold.

Default 5

Range 2 to 50

Metric

String

metric

What the leaderboard is ranked by. Quadratic Kappa is chance-corrected agreement that forgives a near miss and punishes a distant one four times as hard - the standard headline metric for ordered targets. Linear Kappa charges the same for every step along the scale, which is what you want when one level is one unit of loss. Mean Rank Error is the average number of levels a prediction is off by, and Macro Rank Error is the same averaged per true level so a rare level counts as much as the majority one - both are ERROR metrics, so the leaderboard ranks their smallest value first. Kendall Tau-b and Spearman ask only whether the rows come out in the right order and ignore calibration entirely, so a model whose levels are all shifted by one still scores perfectly.

Default Quadratic Kappa

Quadratic KappaLinear KappaMean Rank ErrorMacro Rank ErrorKendall Tau-bSpearman

Seed

Integer

seed

Seed for the fold shuffle. The same seed reproduces the same folds and therefore the same leaderboard; change it to check whether a narrow win survives a different split.

Default 42

Range 0 to 4294967295

Include Proportional Odds

Boolean

include_proportional_odds

Try the cumulative-link model under a logit and a probit link. The only family here that yields calibrated per-level probabilities and coefficients that read as a direction along the ordering, but it assumes one shared effect across all cut points.

Default true

Include All-Threshold

Boolean

include_all_threshold

Try the all-threshold model under a logistic and a hinge margin. It drops the proportional-odds assumption by fitting cut-point placement instead of a likelihood, which is often more robust when that assumption fails; the hinge entry is support vector ordinal regression. Neither yields per-level probabilities.

Default true

Include Ordinal Ridge

Boolean

include_ordinal_ridge

Try rank regression with learned cut points across a small L2 sweep. Closed-form, so it is by far the cheapest candidate and stays cheap as levels and features grow - but it treats the ranks as numbers, so it is the family most likely to be beaten when the levels are not evenly spaced.

Default true

Include Continuation Ratio

Boolean

include_continuation_ratio

Try the sequential model, `P(stop at level k | reached level k)`. The right shape when reaching a level genuinely requires passing the ones below it (stages, escalation, dropout). It fits K-1 sub-models on shrinking subsets and refuses to fit at all when a middle level is missing from a fold, in which case it is dropped from the leaderboard and the other families continue.

Default true

Include Adjacent Category

Boolean

include_adjacent_category

Try the adjacent-category model, which contrasts neighbouring levels instead of splitting the scale cumulatively. Reach for it when the interesting comparison is `this level versus the next one` rather than `at most this level versus above it`.

Default true

Include Neural

Boolean

include_neural

Try a small neural network under a rank-consistent head, as two candidates: a CORAL head, which shares one latent score across the cut points and lets them differ only by biases that cannot cross, and a CORN head, which fits one conditional task per cut point on the rows that reached it. OFF by default, unlike every other family here, and the default is the recommendation: a network is orders of magnitude more expensive to fit than the linear families, it is refitted from scratch on EVERY fold, and it is the one candidate that can dominate the runtime of the whole sweep. Switch it on when you suspect the levels are not separated by a single monotone direction in the features - the hidden layer is the entire contribution, and it is the only thing here that can represent such a boundary at all. On a problem that is linear in the features it can only match the simpler families, never beat them: with no hidden layer CORAL is EXACTLY the all-threshold model with a logistic margin and CORN is EXACTLY Continuation Ratio, so prefer those better-tested candidates when they win. Both use a fixed initialization seed, so the leaderboard stays reproducible. CORN is dropped from the leaderboard on any fold that omits a level nothing reaches, since its task for that level would have no rows; CORAL has no such failure mode.

Default false

Output Pins

Done

Execution

exec_out

Activated once the search completes

Results

Struct

results

Leaderboard of every configuration that finished, best first, plus the ones that were dropped and why. `higher_is_better` states which end of `cv_score` won.

Best Model

Struct

best_model

The winning configuration retrained on the full dataset. Predictions come back as your original level labels.

Schema enforced

Best Model Type

String

best_model_type

Model kind of the winner, e.g. `OrdinalLogistic`. Read back off the retrained model, so it always matches what the rest of the catalog calls it.

Levels

Struct

levels

The level order every candidate was trained on, lowest first, plus whether it came from your Class Order list (Explicit) or from reading the labels as numbers (Numeric). Check this first when the leaderboard looks upside down.

Node Info

Internal name: ai_ml_tuning_auto_ordinal
Category: AI/ML/Tuning
Version: 1