Struct ManifoldRegularization 

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

Manifold Regularization classifier

Manifold regularization extends supervised learning by incorporating the geometry of the marginal distribution P(X). It optimizes both the empirical risk on labeled data and the smoothness of the function with respect to the data manifold.

The objective function is: min Σ V(yi, f(xi)) + λA ||f||²_K + λI ∫ ||∇f||² dP(x)

where:

• V is the loss function
• λA controls Tikhonov regularization in RKHS
• λI controls manifold regularization
• The integral term enforces smoothness on the manifold

Parameters

• lambda_a - Ambient regularization parameter (RKHS regularization)
• lambda_i - Intrinsic regularization parameter (manifold regularization)
• kernel - Kernel function (‘rbf’, ‘linear’, ‘polynomial’)
• gamma - Parameter for RBF kernel
• degree - Degree for polynomial kernel
• graph_kernel - Kernel for graph construction (‘knn’ or ‘rbf’)
• n_neighbors - Number of neighbors for graph construction
• max_iter - Maximum iterations for optimization
• tol - Convergence tolerance

Examples

use scirs2_core::array;
use sklears_semi_supervised::ManifoldRegularization;
use sklears_core::traits::{Predict, Fit};


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

let mr = ManifoldRegularization::new()
    .lambda_a(0.01)
    .lambda_i(0.1)
    .kernel("rbf".to_string())
    .gamma(1.0);
let fitted = mr.fit(&X.view(), &y.view()).unwrap();
let predictions = fitted.predict(&X.view()).unwrap();

Implementations

impl ManifoldRegularization<Untrained>

pub fn new() -> Self

Create a new ManifoldRegularization instance

pub fn lambda_a(self, lambda_a: f64) -> Self

Set ambient regularization parameter

pub fn lambda_i(self, lambda_i: f64) -> Self

Set intrinsic regularization parameter

pub fn kernel(self, kernel: String) -> Self

Set the kernel function

pub fn gamma(self, gamma: f64) -> Self

Set gamma parameter for RBF kernel

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

Set degree for polynomial kernel

pub fn graph_kernel(self, graph_kernel: String) -> Self

Set graph kernel for manifold construction

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

Set number of neighbors for graph construction

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

Set maximum iterations

pub fn tol(self, tol: f64) -> Self

Set convergence tolerance

Trait Implementations

impl<S: Clone> Clone for ManifoldRegularization<S>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for ManifoldRegularization<S>

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

Formats the value using the given formatter.

impl Default for ManifoldRegularization<Untrained>

fn default() -> Self

Returns the “default value” for a type.

impl Estimator for ManifoldRegularization<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 ManifoldRegularization<Untrained>

type Fitted = ManifoldRegularization<ManifoldRegularizationTrained>

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 ManifoldRegularization<ManifoldRegularizationTrained>

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