Struct DemocraticCoLearning 

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

Democratic Co-Learning classifier for semi-supervised learning

Democratic co-learning extends traditional co-training by using multiple classifiers trained on different views of the data. Instead of pairwise labeling, all classifiers vote democratically on which unlabeled samples should be added to the training set.

Parameters

• views - Feature indices for each view
• k_add - Number of samples to add per iteration
• max_iter - Maximum number of iterations
• confidence_threshold - Minimum confidence threshold for pseudo-labeling
• min_agreement - Minimum number of classifiers that must agree
• verbose - Whether to print progress information

Examples

use sklears_semi_supervised::DemocraticCoLearning;
use sklears_core::traits::{Predict, Fit};


let X = array![[1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
               [2.0, 3.0, 4.0, 5.0, 6.0, 7.0],
               [3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
               [4.0, 5.0, 6.0, 7.0, 8.0, 9.0]];
let y = array![0, 1, -1, -1]; // -1 indicates unlabeled

let dcl = DemocraticCoLearning::new()
    .views(vec![vec![0, 1], vec![2, 3], vec![4, 5]])
    .k_add(1)
    .min_agreement(2)
    .max_iter(10);
let fitted = dcl.fit(&X.view(), &y.view()).unwrap();
let predictions = fitted.predict(&X.view()).unwrap();

Implementations

impl DemocraticCoLearning<Untrained>

pub fn new() -> Self

Create a new DemocraticCoLearning instance

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

Set the feature views

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

Set the number of samples to add per iteration

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

Set the maximum number of iterations

pub fn confidence_threshold(self, threshold: f64) -> Self

Set the confidence threshold

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

Set the minimum number of classifiers that must agree

pub fn verbose(self, verbose: bool) -> Self

Set verbosity

pub fn selection_strategy(self, strategy: String) -> Self

Set selection strategy for choosing samples to add

Trait Implementations

impl<S: Clone> Clone for DemocraticCoLearning<S>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for DemocraticCoLearning<S>

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

Formats the value using the given formatter.

impl Default for DemocraticCoLearning<Untrained>

fn default() -> Self

Returns the “default value” for a type.

impl Estimator for DemocraticCoLearning<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<ViewRepr<&i32>, Dim<[usize; 1]>>> for DemocraticCoLearning<Untrained>

type Fitted = DemocraticCoLearning<DemocraticCoLearningTrained>

The fitted model type

fn fit( self, X: &ArrayView2<'_, Float>, y: &ArrayView1<'_, 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; 1]>>> for DemocraticCoLearning<DemocraticCoLearningTrained>

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

Make predictions on the provided data

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

Make predictions with confidence intervals