Struct KernelPCA 

pub struct KernelPCA<State = Untrained> { /* private fields */ }

Kernel Principal Component Analysis (Kernel PCA)

Non-linear dimensionality reduction through the use of kernels. It uses the kernel trick to perform PCA in a potentially infinite-dimensional feature space without explicitly computing the features.

Examples

use sklears_decomposition::{KernelPCA, KernelFunction};
use sklears_core::traits::{Transform, Fit};
use scirs2_core::ndarray::array;

let x = array![
    [1.0, 2.0],
    [3.0, 4.0],
    [5.0, 6.0],
    [7.0, 8.0],
];

let kpca = KernelPCA::new()
    .n_components(2)
    .kernel(KernelFunction::Rbf { gamma: 0.1 })
    .fit(&x, &())?;

let x_transformed = kpca.transform(&x)?;

Implementations

impl KernelPCA<Untrained>

pub fn new() -> Self

Create a new Kernel PCA

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

Set the number of components to keep

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

Set the kernel function

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

Set the tolerance for eigenvalue computation

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

Set the maximum number of iterations

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

Set whether to center the kernel matrix

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

Set whether to copy the input data

pub fn approximation(self, approximation: KernelApproximation) -> Self

Set the kernel matrix approximation method

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

Set the random state for reproducible approximations

impl KernelPCA<Trained>

pub fn eigenvalues(&self) -> &Array1<Float>

Get the eigenvalues

pub fn eigenvectors(&self) -> &Array2<Float>

Get the eigenvectors (alphas)

pub fn n_components(&self) -> usize

Get the number of components

pub fn n_features_in(&self) -> usize

Get the number of features in the input

pub fn n_samples(&self) -> usize

Get the number of samples in the training data

pub fn x_fit(&self) -> &Array2<Float>

Get the training data

pub fn inverse_transform( &self, x_transformed: &Array2<Float>, max_iter: usize, tol: Float, ) -> Result<Array2<Float>>

Pre-image reconstruction using fixed-point iteration

Reconstructs the original space representation from the transformed features. This is useful for understanding what the transformed features represent in the original input space.

Arguments

• x_transformed - The transformed data to reconstruct (n_samples, n_components)
• max_iter - Maximum number of iterations for fixed-point iteration
• tol - Tolerance for convergence

Returns

Reconstructed data in original space (n_samples, n_features)

pub fn mds_preimage( &self, x_transformed: &Array2<Float>, ) -> Result<Array2<Float>>

Multi-dimensional scaling (MDS) based pre-image approximation

An alternative pre-image reconstruction method using MDS to preserve distances in the original space.

impl KernelPCA<Untrained>

Kernel PCA with automatic kernel selection

pub fn fit_with_kernel_selection( self, x: &Array2<Float>, kernel_candidates: Option<&[KernelFunction]>, cv_folds: usize, ) -> Result<KernelPCA<Trained>>

Fit Kernel PCA with automatic kernel selection

Trait Implementations

impl<State: Clone> Clone for KernelPCA<State>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State: Debug> Debug for KernelPCA<State>

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

Formats the value using the given formatter.

impl Default for KernelPCA<Untrained>

fn default() -> Self

Returns the “default value” for a type.

impl Fit<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ()> for KernelPCA<Untrained>

type Fitted = KernelPCA<Trained>

The fitted model type

fn fit(self, x: &Array2<Float>, _y: &()) -> 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

impl Transform<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>> for KernelPCA<Trained>

fn transform(&self, x: &Array2<Float>) -> Result<Array2<Float>>

Transform the input data