Struct linfa_clustering::KMeansHyperParams

pub struct KMeansHyperParams<F: Float, R: Rng> { /* fields omitted */ }

The set of hyperparameters that can be specified for the execution of the K-means algorithm.

Implementations

impl<F: Float> KMeansHyperParams<F, Isaac64Rng>

pub fn new(n_clusters: usize) -> KMeansHyperParamsBuilder<F, Isaac64Rng>

impl<F: Float, R: Rng + Clone> KMeansHyperParams<F, R>

pub fn new_with_rng(n_clusters: usize, rng: R) -> KMeansHyperParamsBuilder<F, R>

new lets us configure our training algorithm parameters:

• we will be looking for n_clusters in the training dataset;
• the training is considered complete if the euclidean distance between the old set of centroids and the new set of centroids after a training iteration is lower or equal than tolerance;
• we exit the training loop when the number of training iterations exceeds max_n_iterations even if the tolerance convergence condition has not been met.
• As KMeans convergence depends on centroids initialization we run the algorithm n_runs times and we keep the best outputs in terms of inertia that the ones which minimizes the sum of squared euclidean distances to the closest centroid for all observations.

n_clusters is mandatory.

Defaults are provided if optional parameters are not specified:

• tolerance = 1e-4;
• max_n_iterations = 300.

pub fn n_runs(&self) -> usize

The final results will be the best output of n_runs consecutive runs in terms of inertia.

pub fn tolerance(&self) -> F

The training is considered complete if the euclidean distance between the old set of centroids and the new set of centroids after a training iteration is lower or equal than tolerance.

pub fn max_n_iterations(&self) -> u64

We exit the training loop when the number of training iterations exceeds max_n_iterations even if the tolerance convergence condition has not been met.

pub fn n_clusters(&self) -> usize

The number of clusters we will be looking for in the training dataset.

pub fn init_method(&self) -> &KMeansInit<F>

Cluster initialization strategy

pub fn rng(&self) -> R

Returns a clone of the random generator

Trait Implementations

impl<F: Clone + Float, R: Clone + Rng> Clone for KMeansHyperParams<F, R>

fn clone(&self) -> KMeansHyperParams<F, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Float, R: Debug + Rng> Debug for KMeansHyperParams<F, R>

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

Formats the value using the given formatter.

impl<F: Float, R: Rng + Clone + SeedableRng, D: Data<Elem = F>, T> Fit<ArrayBase<D, Dim<[usize; 2]>>, T, KMeansError> for KMeansHyperParams<F, R>

type Object = KMeans<F>

fn fit(
    &self,
    dataset: &DatasetBase<ArrayBase<D, Ix2>, T>
) -> Result<Self::Object, KMeansError>

Given an input matrix observations, with shape (n_observations, n_features), fit identifies n_clusters centroids based on the training data distribution.

An instance of KMeans is returned.

impl<'a, F: Float, R: Rng + Clone + SeedableRng, D: Data<Elem = F>, T> IncrementalFit<'a, ArrayBase<D, Dim<[usize; 2]>>, T> for KMeansHyperParams<F, R>

type ObjectIn = Option<KMeans<F>>

type ObjectOut = (KMeans<F>, bool)

fn fit_with(
    &self,
    model: Self::ObjectIn,
    dataset: &'a DatasetBase<ArrayBase<D, Ix2>, T>
) -> Self::ObjectOut

Performs a single batch update of the Mini-Batch K-means algorithm.

Given an input matrix observations, with shape (n_batch, n_features) and a previous KMeans model, the model’s centroids are updated with the input matrix. If model is None, then it’s initialized using the specified initialization algorithm. The return value consists of the updated model and a bool value that indicates whether the algorithm has converged.

impl<F: PartialEq + Float, R: PartialEq + Rng> PartialEq<KMeansHyperParams<F, R>> for KMeansHyperParams<F, R>

fn eq(&self, other: &KMeansHyperParams<F, R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &KMeansHyperParams<F, R>) -> bool

This method tests for !=.

impl<F: Float, R: Rng> StructuralPartialEq for KMeansHyperParams<F, R>