Struct KMeansClassifier 

pub struct KMeansClassifier<InitAlg: Initializer> { /* private fields */ }

K-Means Classification model.

Contains option for centroids. Specifies iterations and number of classes.

Usage

This model is used through the UnSupModel trait. The model is trained via the train function with a matrix containing rows of feature vectors.

The model will not check to ensure the data coming in is all valid. This responsibility lies with the user (for now).

Implementations

impl KMeansClassifier<KPlusPlus>

pub fn new(k: usize) -> KMeansClassifier<KPlusPlus>

Constructs untrained k-means classifier model.

Requires number of classes to be specified. Defaults to 100 iterations and kmeans++ initialization.

Examples

use rusty_machine::learning::k_means::KMeansClassifier;

let model = KMeansClassifier::new(5);

Examples found in repository

examples/k-means_generating_cluster.rs (line 59)

fn main() {
    println!("K-Means clustering example:");

    const SAMPLES_PER_CENTROID: usize = 2000;

    println!("Generating {0} samples from each centroids:",
             SAMPLES_PER_CENTROID);
    // Choose two cluster centers, at (-0.5, -0.5) and (0, 0.5).
    let centroids = Matrix::new(2, 2, vec![-0.5, -0.5, 0.0, 0.5]);
    println!("{}", centroids);

    // Generate some data randomly around the centroids
    let samples = generate_data(&centroids, SAMPLES_PER_CENTROID, 0.4);

    // Create a new model with 2 clusters
    let mut model = KMeansClassifier::new(2);

    // Train the model
    println!("Training the model...");
    // Our train function returns a Result<(), E>
    model.train(&samples).unwrap();

    let centroids = model.centroids().as_ref().unwrap();
    println!("Model Centroids:\n{:.3}", centroids);

    // Predict the classes and partition into
    println!("Classifying the samples...");
    let classes = model.predict(&samples).unwrap();
    let (first, second): (Vec<usize>, Vec<usize>) = classes.data().iter().partition(|&x| *x == 0);

    println!("Samples closest to first centroid: {}", first.len());
    println!("Samples closest to second centroid: {}", second.len());
}

impl<InitAlg: Initializer> KMeansClassifier<InitAlg>

pub fn new_specified( k: usize, iters: usize, algo: InitAlg, ) -> KMeansClassifier<InitAlg>

Constructs untrained k-means classifier model.

Requires number of classes, number of iterations, and the initialization algorithm to use.

Examples

use rusty_machine::learning::k_means::{KMeansClassifier, Forgy};

let model = KMeansClassifier::new_specified(5, 42, Forgy);

pub fn k(&self) -> usize

Get the number of classes.

pub fn iters(&self) -> usize

Get the number of iterations.

pub fn init_algorithm(&self) -> &InitAlg

Get the initialization algorithm.

pub fn centroids(&self) -> &Option<Matrix<f64>>

Get the centroids Option<Matrix<f64>>.

Examples found in repository

examples/k-means_generating_cluster.rs (line 66)

fn main() {
    println!("K-Means clustering example:");

    const SAMPLES_PER_CENTROID: usize = 2000;

    println!("Generating {0} samples from each centroids:",
             SAMPLES_PER_CENTROID);
    // Choose two cluster centers, at (-0.5, -0.5) and (0, 0.5).
    let centroids = Matrix::new(2, 2, vec![-0.5, -0.5, 0.0, 0.5]);
    println!("{}", centroids);

    // Generate some data randomly around the centroids
    let samples = generate_data(&centroids, SAMPLES_PER_CENTROID, 0.4);

    // Create a new model with 2 clusters
    let mut model = KMeansClassifier::new(2);

    // Train the model
    println!("Training the model...");
    // Our train function returns a Result<(), E>
    model.train(&samples).unwrap();

    let centroids = model.centroids().as_ref().unwrap();
    println!("Model Centroids:\n{:.3}", centroids);

    // Predict the classes and partition into
    println!("Classifying the samples...");
    let classes = model.predict(&samples).unwrap();
    let (first, second): (Vec<usize>, Vec<usize>) = classes.data().iter().partition(|&x| *x == 0);

    println!("Samples closest to first centroid: {}", first.len());
    println!("Samples closest to second centroid: {}", second.len());
}

pub fn set_iters(&mut self, iters: usize)

Set the number of iterations.

Trait Implementations

impl<InitAlg: Debug + Initializer> Debug for KMeansClassifier<InitAlg>

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

Formats the value using the given formatter.

impl<InitAlg: Initializer> UnSupModel<Matrix<f64>, Vector<usize>> for KMeansClassifier<InitAlg>

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<usize>>

Predict classes from data.

Model must be trained.

fn train(&mut self, inputs: &Matrix<f64>) -> LearningResult<()>

Train the classifier using input data.