Struct ClassifierChain 

pub struct ClassifierChain<S = Untrained> { /* private fields */ }

Classifier Chain

A multi-label model that arranges binary classifiers into a chain. Each model makes a prediction in the order specified by the chain using all of the available features provided to the model plus the predictions of models that are earlier in the chain.

Examples

use sklears_multioutput::chains::ClassifierChain;
// Use SciRS2-Core for arrays and random number generation (SciRS2 Policy)
use scirs2_core::ndarray::array;

// This is a simple example showing the structure
let data = array![[1.0, 2.0], [2.0, 3.0], [3.0, 1.0]];
let labels = array![[0, 1], [1, 0], [1, 1]];

Implementations

impl ClassifierChain<Untrained>

pub fn new() -> Self

Create a new ClassifierChain instance

pub fn order(self, order: Vec<usize>) -> Self

Set the chain order

pub fn cv(self, cv: usize) -> Self

Set cross-validation folds for training

pub fn random_state(self, random_state: u64) -> Self

Set random state for reproducibility

impl ClassifierChain<Untrained>

pub fn fit_simple( self, X: &ArrayView2<'_, Float>, y: &Array2<i32>, ) -> SklResult<ClassifierChain<ClassifierChainTrained>>

Fit the classifier chain using a simple mock approach

impl ClassifierChain<ClassifierChainTrained>

pub fn predict_proba( &self, X: &ArrayView2<'_, Float>, ) -> SklResult<Array2<Float>>

Predict probabilities for each label

pub fn chain_order(&self) -> &[usize]

Get the chain order used during training

pub fn n_models(&self) -> usize

Get the number of models in the chain

pub fn n_targets(&self) -> usize

Get number of targets/labels

pub fn predict_simple( &self, X: &ArrayView2<'_, Float>, ) -> SklResult<Array2<i32>>

Simple prediction method (alias for predict)

pub fn predict_monte_carlo( &self, X: &ArrayView2<'_, Float>, n_samples: usize, random_state: Option<u64>, ) -> SklResult<Array2<Float>>

Monte Carlo prediction (simplified)

pub fn predict_monte_carlo_labels( &self, X: &ArrayView2<'_, Float>, n_samples: usize, random_state: Option<u64>, ) -> SklResult<Array2<i32>>

Monte Carlo prediction for labels (simplified)

Trait Implementations

impl<S: Clone> Clone for ClassifierChain<S>

fn clone(&self) -> ClassifierChain<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for ClassifierChain<S>

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

Formats the value using the given formatter.

impl Default for ClassifierChain<Untrained>

fn default() -> Self

Returns the “default value” for a type.

impl Estimator for ClassifierChain<Untrained>

type Config = ()

Configuration type for the estimator

type Error = SklearsError

Error type for the estimator

type Float = f64

The numeric type used by this estimator

fn config(&self) -> &Self::Config

Get estimator configuration

fn validate_config(&self) -> Result<(), SklearsError>

Validate estimator configuration with detailed error context

fn check_compatibility( &self, n_samples: usize, n_features: usize, ) -> Result<(), SklearsError>

Check if estimator is compatible with given data dimensions

fn metadata(&self) -> EstimatorMetadata

Get estimator metadata

impl Fit<ArrayBase<ViewRepr<&f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<i32>, Dim<[usize; 2]>>, ClassifierChainTrained> for ClassifierChain<Untrained>

type Fitted = ClassifierChain<ClassifierChainTrained>

The fitted model type

fn fit( self, X: &ArrayView2<'_, Float>, y: &Array2<i32>, ) -> SklResult<Self::Fitted>

Fit the model to the provided data with validation

fn fit_with_validation( self, x: &X, y: &Y, _x_val: Option<&X>, _y_val: Option<&Y>, ) -> Result<(Self::Fitted, FitMetrics), SklearsError>

where Self: Sized,

Fit with custom validation and early stopping

impl Predict<ArrayBase<ViewRepr<&f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<i32>, Dim<[usize; 2]>>> for ClassifierChain<ClassifierChainTrained>

fn predict(&self, X: &ArrayView2<'_, Float>) -> SklResult<Array2<i32>>

Make predictions on the provided data

fn predict_with_uncertainty( &self, x: &X, ) -> Result<(Output, UncertaintyMeasure), SklearsError>

Make predictions with confidence intervals