Struct RandomizedPca 

pub struct RandomizedPca<A, R>
where
    A: Scalar,
    R: Rng,
{ /* private fields */ }

Principal component analysis using randomized singular value decomposition.

This uses randomized SVD (singular value decomposition) proposed by Halko et al. [1] to reduce the dimensionality of the input data. The data is centered for each feature before applying randomized SVD.

Examples

use petal_decomposition::RandomizedPcaBuilder;

let x = ndarray::arr2(&[[0_f64, 0_f64], [1_f64, 1_f64], [2_f64, 2_f64]]);
let mut pca = RandomizedPcaBuilder::new(1).build();
let y = pca.fit_transform(&x).unwrap();  // [-2_f64.sqrt(), 0_f64, 2_f64.sqrt()]
assert!((y[(0, 0)].abs() - 2_f64.sqrt()).abs() < 1e-8);
assert!(y[(1, 0)].abs() < 1e-8);
assert!((y[(2, 0)].abs() - 2_f64.sqrt()).abs() < 1e-8);

References

1. N. Halko, P. G. Martinsson, and J. A. Tropp. Finding Structure with Randomness: Probabilistic Algorithms for Constructing Approximate Matrix Decompositions. SIAM Review, 53(2), 217–288, 2011.

Implementations

impl<A> RandomizedPca<A, Mcg128Xsl64>

where A: Scalar,

pub fn new(n_components: usize) -> Self

Creates a PCA model based on randomized SVD.

The random matrix for randomized SVD is created from a PCG random number generator (the XSL 128/64 (MCG) variant on a 64-bit CPU and the XSH RR 64/32 (LCG) variant on a 32-bit CPU), initialized with a randomly-generated seed.

pub fn with_seed(n_components: usize, seed: u128) -> Self

Creates a PCA model based on randomized SVD, with a PCG random number generator initialized with the given seed.

It uses a PCG random number generator (the XSL 128/64 (MCG) variant on a 64-bit CPU and the XSH RR 64/32 (LCG) variant on a 32-bit CPU). Use with_rng for a different random number generator.

impl<A, R> RandomizedPca<A, R>

where A: Scalar, R: Rng,

pub fn with_rng(n_components: usize, rng: R) -> Self

Creates a PCA model with the given number of components and random number generator. The random number generator is used to create a random matrix for randomized SVD.

impl<A, R> RandomizedPca<A, R>

where A: Scalar + FromPrimitive + Lapack, A::Real: ScalarOperand + FromPrimitive, R: Rng,

pub fn components(&self) -> &Array2<A>

Returns the principal axes in feature space.

pub fn mean(&self) -> &Array1<A>

Returns the per-feature empirical mean.

pub fn n_components(&self) -> usize

Returns the number of components.

pub fn singular_values(&self) -> &Array1<A::Real>

Returns sigular values.

pub fn explained_variance_ratio(&self) -> Array1<A::Real>

Returns the ratio of explained variance for each component.

pub fn fit<S>( &mut self, input: &ArrayBase<S, Ix2>, ) -> Result<(), DecompositionError>

where S: Data<Elem = A>,

Fits the model with input.

Errors

• DecompositionError::InvalidInput if any of the dimensions of input is less than the number of components, or the layout of input is incompatible with LAPACK.
• DecompositionError::LinalgError if the underlying Singular Vector Decomposition routine fails.

pub fn transform<S>( &self, input: &ArrayBase<S, Ix2>, ) -> Result<Array2<A>, DecompositionError>

where S: Data<Elem = A>,

Applies dimensionality reduction to input.

Errors

• DecompositionError::InvalidInput if the number of features in input does not match that of the training data.

pub fn fit_transform<S>( &mut self, input: &ArrayBase<S, Ix2>, ) -> Result<Array2<A>, DecompositionError>

where S: Data<Elem = A>,

Fits the model with input and apply the dimensionality reduction on input.

This is equivalent to calling both fit and transform for the same input.

Errors

• DecompositionError::InvalidInput if any of the dimensions of input is less than the number of components, or the layout of input is incompatible with LAPACK.
• DecompositionError::LinalgError if the underlying Singular Vector Decomposition routine fails.

pub fn inverse_transform<S>( &self, input: &ArrayBase<S, Ix2>, ) -> Result<Array2<A>, DecompositionError>

where S: Data<Elem = A>,

Transforms data back to its original space.

Errors

Returns DecompositionError::InvalidInput if the number of rows of input is different from that of the training data, or the number of columns of input is different from the number of components.

Trait Implementations

impl<'de, A, R> Deserialize<'de> for RandomizedPca<A, R>

where for<'a> A: Scalar + Serialize + Deserialize<'a>, for<'a> R: Rng + Serialize + Deserialize<'a>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A, R> Serialize for RandomizedPca<A, R>

where for<'a> A: Scalar + Serialize + Deserialize<'a>, for<'a> R: Rng + Serialize + Deserialize<'a>,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.