rust-imbalanced-learn 0.1.0

High-performance resampling techniques for imbalanced datasets in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! # rust-imbalanced-learn
//!
//! High-performance resampling techniques for imbalanced datasets in Rust.
//!
//! This crate provides a comprehensive suite of algorithms for handling imbalanced
//! datasets in machine learning applications, with a focus on performance, safety,
//! and ease of use.
//!
//! ## Features
//!
//! - **SMOTE** (Synthetic Minority Over-sampling Technique)
//! - **ADASYN** (Adaptive Synthetic Sampling)
//! - **RandomUnderSampler** for majority class reduction
//! - **Comprehensive metrics** for model evaluation
//! - **Type-safe abstractions** with compile-time guarantees
//! - **High performance** with SIMD and parallel processing support
//!
//! ## Quick Start
//!
//! ```rust
//! use rust_imbalanced_learn::prelude::*;
//! use ndarray::{Array1, Array2};
//!
//! // Create sample imbalanced dataset
//! let x = Array2::from_shape_vec((4, 2), vec![
//!     1.0, 2.0,
//!     2.0, 3.0,
//!     3.0, 4.0,
//!     10.0, 11.0,
//! ]).unwrap();
//! let y = Array1::from_vec(vec![0, 0, 0, 1]);
//!
//! // Apply SMOTE resampling
//! let smote = SmoteStrategy::new(2);
//! let config = SmoteConfig::default();
//! let (x_resampled, y_resampled) = smote.resample(x.view(), y.view(), &config).unwrap();
//!
//! println!("Original samples: {}", y.len());
//! println!("Resampled samples: {}", y_resampled.len());
//! ```
//!
//! ## Architecture
//!
//! The library is organized into focused modules:
//!
//! - [`core`] - Core traits and abstractions
//! - [`sampling`] - Resampling algorithms (SMOTE, ADASYN, etc.)
//! - [`ensemble`] - Ensemble methods for imbalanced data
//! - [`metrics`] - Evaluation metrics and reports
//!
//! ## Performance
//!
//! Built with performance in mind:
//! - Zero-cost abstractions
//! - SIMD acceleration support
//! - Parallel processing with Rayon
//! - Memory-efficient algorithms
//! - Type-safe compile-time optimizations

#![deny(missing_docs)]
#![warn(clippy::all, clippy::pedantic)]
#![allow(clippy::module_name_repetitions)]

/// Re-export of imbalanced-core for core traits and abstractions
pub use imbalanced_core as core;

/// Re-export of imbalanced-sampling for resampling algorithms
pub use imbalanced_sampling as sampling;

/// Re-export of imbalanced-ensemble for ensemble methods
pub use imbalanced_ensemble as ensemble;

/// Re-export of imbalanced-metrics for evaluation metrics
pub use imbalanced_metrics as metrics;

/// Convenient prelude that imports commonly used items
pub mod prelude {
    pub use crate::core::prelude::*;
    pub use crate::sampling::prelude::*;
    pub use crate::ensemble::prelude::*;
    pub use crate::metrics::prelude::*;
    
    // Re-export config types for convenience
    pub use crate::sampling::{
        smote::SmoteConfig,
        adasyn::AdasynConfig,
        random_undersampler::RandomUnderSamplerConfig,
    };
}