Enum StackingStrategy 

pub enum StackingStrategy {
    Ridge {
        alpha: f32,
        rank_transform: bool,
        fit_intercept: bool,
        min_weight: f32,
    },
    Average,
}

Stacking strategy for ensemble combination

Specifies how to combine predictions from multiple ensemble members.

This is a serializable alternative to the Box<dyn Stacker> trait object, enabling full persistence of ensemble configurations. UniversalModel stores this enum and constructs the appropriate stacker at runtime.

Variants

• Ridge: Uses Ridge regression to learn optimal weights for each ensemble member. Recommended when ensemble members have different prediction scales or accuracies.

• Average: Simple equal-weight averaging across all members. Recommended for homogeneous ensembles where all members have similar quality.

Note on Extensibility

Only Ridge and Average strategies are currently exposed because they are the most commonly used and both are fully serializable. If you need custom stacking logic, train multiple independent models and combine them manually, or use the TrainedMember API directly with EnsembleBuilder.

Variants

Ridge

Ridge regression stacking with regularization

Learns optimal weights via Ridge regression on out-of-fold predictions. Ridge regularization prevents overfitting when stacking.

Fields

alpha: f32

Ridge regularization parameter (alpha). Higher values = stronger regularization. Typical range: 0.001 to 0.1. Default: 0.01

rank_transform: bool

Whether to apply rank transformation to member predictions before stacking. Useful when members have different prediction scales (e.g., one predicts [0, 100], another [0, 1]). Rank transformation makes them comparable. Default: false

fit_intercept: bool

Whether to fit an intercept term. Set to false if you want zero-centered predictions. Default: true

min_weight: f32

Minimum weight magnitude threshold. Weights smaller than this are set to zero, creating sparse stacking weights. Typical range: 0.0 to 0.1. Default: 0.01

Average

Simple averaging (equal weights)

Combines members by simple arithmetic mean: (pred_1 + pred_2 + ... + pred_n) / n No learning required. Fast and effective for balanced, diverse ensembles.

Trait Implementations

impl Archive for StackingStrategy

where f32: Archive, bool: Archive,

type Archived = ArchivedStackingStrategy

The archived representation of this type.

type Resolver = StackingStrategyResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for StackingStrategy

fn clone(&self) -> StackingStrategy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StackingStrategy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for StackingStrategy

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for StackingStrategy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<StackingStrategy, __D> for Archived<StackingStrategy>

where f32: Archive, <f32 as Archive>::Archived: Deserialize<f32, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<StackingStrategy, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for StackingStrategy

where f32: Serialize<__S>, bool: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for StackingStrategy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.