Struct MatrixCompletion 

pub struct MatrixCompletion<State = Untrained> {
    pub rank: Option<usize>,
    pub algorithm: CompletionAlgorithm,
    pub max_iter: usize,
    pub tol: f64,
    pub random_state: Option<u64>,
    pub learning_rate: f64,
    pub regularization: f64,
    pub use_bias: bool,
    /* private fields */
}

Matrix completion transformer

Fields

rank: Option<usize>

Rank of the matrix completion

algorithm: CompletionAlgorithm

Algorithm to use

max_iter: usize

Maximum number of iterations

tol: f64

Convergence tolerance

random_state: Option<u64>

Random state for reproducibility

learning_rate: f64

Learning rate for gradient-based methods

regularization: f64

Regularization parameter

use_bias: bool

Whether to use bias terms

Implementations

impl MatrixCompletion<Untrained>

pub fn new() -> Self

Create a new matrix completion transformer

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

Set the rank for matrix completion

pub fn algorithm(self, algorithm: CompletionAlgorithm) -> Self

Set the algorithm

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

Set maximum iterations

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

Set tolerance

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

Set random state

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

Set learning rate

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

Set regularization parameter

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

Set whether to use bias terms

impl MatrixCompletion<TrainedMatrixCompletion>

pub fn user_factors(&self) -> &Array2<f64>

Get the user factors

pub fn item_factors(&self) -> &Array2<f64>

Get the item factors

pub fn reconstruction_error(&self) -> f64

Get the reconstruction error

pub fn n_iter(&self) -> usize

Get the number of iterations

pub fn complete( &self, matrix: &Array2<f64>, mask: &Array2<bool>, ) -> Result<Array2<f64>>

Complete the matrix (fill in missing values)

pub fn predict(&self, user_id: usize, item_id: usize) -> Result<f64>

Predict rating for a specific user-item pair

Trait Implementations

impl<State: Clone> Clone for MatrixCompletion<State>

fn clone(&self) -> MatrixCompletion<State>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State: Debug> Debug for MatrixCompletion<State>

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

Formats the value using the given formatter.

impl Default for MatrixCompletion<Untrained>

fn default() -> Self

Returns the “default value” for a type.

impl Fit<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<bool>, Dim<[usize; 2]>>> for MatrixCompletion<Untrained>

type Fitted = MatrixCompletion<TrainedMatrixCompletion>

The fitted model type

fn fit(self, matrix: &Array2<f64>, mask: &Array2<bool>) -> Result<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