Struct FactorAnalysis 

pub struct FactorAnalysis<State = Untrained> {
    pub config: FactorAnalysisConfig,
    /* private fields */
}

Factor Analysis transformer using the EM algorithm.

Implements the classical factor analysis model: X = μ + W * F + ε with F ~ N(0, I) and ε ~ N(0, Ψ) where Ψ is diagonal.

Fields

config: FactorAnalysisConfig

Model configuration

Implementations

impl FactorAnalysis<Untrained>

pub fn new(n_components: usize) -> Self

Create a new factor analysis model with the given number of components

pub fn em(self, em: EMAlgorithm) -> Self

Set EM algorithm configuration

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

Set random seed for reproducibility

impl FactorAnalysis<TrainedFactorAnalysis>

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

Return the loading matrix W — shape (n_features, n_components).

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

Return the diagonal noise variances Ψ — shape (n_features,).

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

Return the per-feature training mean.

pub fn log_likelihood(&self) -> Float

Return the log-likelihood at convergence.

pub fn n_iter(&self) -> usize

Return the number of EM iterations run.

pub fn loadings_plot_data( &self, feature_names: Option<Vec<String>>, ) -> LoadingsPlotData

Return loading heatmap data suitable for visualisation.

Returns a LoadingsPlotData struct containing the loading matrix, feature labels, and component labels.

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

Return a scree-plot-like DataFrame with communalities (proportion of each feature’s variance explained by all factors).

communality[j] = Σ_k W[j,k]² / (Σ_k W[j,k]² + ψ_j)

pub fn sample( &self, n_samples: usize, random_state: Option<u64>, ) -> Result<Array2<Float>>

Draw n_samples new observations from the fitted factor model.

F_new ~ N(0, I_q)
ε_new ~ N(0, Ψ)
X_new = μ + W F_new + ε_new

pub fn aic(&self) -> Float

Return AIC for this model: AIC = -2 log L + 2 * n_params.

n_params = p*q + p - q*(q-1)/2 (loadings + noise variances minus rotation indeterminacy)

pub fn bic(&self) -> Float

Return BIC for this model: BIC = -2 log L + log(n) * n_params.

pub fn n_free_params(&self) -> usize

Number of free parameters (accounting for rotation indeterminacy).

n_params = p*q + p - q*(q-1)/2

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

Reconstruct the full model covariance matrix Σ = W Wᵀ + Ψ.

Trait Implementations

impl<State: Clone> Clone for FactorAnalysis<State>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State: Debug> Debug for FactorAnalysis<State>

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

Formats the value using the given formatter.

impl<'de, State> Deserialize<'de> for FactorAnalysis<State>

where State: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

type Fitted = FactorAnalysis<TrainedFactorAnalysis>

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<State> Serialize for FactorAnalysis<State>

where State: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Transform<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>> for FactorAnalysis<TrainedFactorAnalysis>

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

Compute posterior mean factor scores for each observation.

Returns matrix of shape (n_samples, n_components).