Struct GraphStructureLearning 

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

Graph Structure Learning for Semi-Supervised Learning

This method learns an optimal graph structure that balances data fidelity and sparsity constraints. The learned graph is then used for label propagation.

The method solves the optimization problem: min_W ||X - W * X||_F^2 + λ * ||W||_1 + β * tr(F^T * L_W * F)

where W is the graph adjacency matrix, L_W is the graph Laplacian, and F is the label matrix.

Parameters

• lambda_sparse - Sparsity regularization parameter
• beta_smoothness - Smoothness regularization parameter
• max_iter - Maximum number of iterations
• tol - Convergence tolerance
• learning_rate - Learning rate for optimization
• adaptive_lr - Whether to use adaptive learning rate

Examples

use scirs2_core::array;
use sklears_semi_supervised::GraphStructureLearning;
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 gsl = GraphStructureLearning::new()
    .lambda_sparse(0.1)
    .beta_smoothness(1.0);
let fitted = gsl.fit(&X.view(), &y.view()).unwrap();
let predictions = fitted.predict(&X.view()).unwrap();

Implementations

impl GraphStructureLearning<Untrained>

pub fn new() -> Self

Create a new GraphStructureLearning instance

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

Set the sparsity regularization parameter

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

Set the smoothness regularization parameter

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

Set the maximum number of iterations

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

Set the convergence tolerance

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

Set the learning rate

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

Enable/disable adaptive learning rate

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

Enable/disable symmetry enforcement

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

Enable/disable weight normalization

Trait Implementations

impl<S: Clone> Clone for GraphStructureLearning<S>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for GraphStructureLearning<S>

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

Formats the value using the given formatter.

impl Default for GraphStructureLearning<Untrained>

fn default() -> Self

Returns the “default value” for a type.

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

type Fitted = GraphStructureLearning<GraphStructureLearningTrained>

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 GraphStructureLearning<GraphStructureLearningTrained>

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

impl PredictProba<ArrayBase<ViewRepr<&f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>> for GraphStructureLearning<GraphStructureLearningTrained>

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

Predict class probabilities