KMeans Class

[SerializableAttribute]
public class KMeans : ParallelLearningBase, IUnsupervisedLearning<KMeansClusterCollection, double[], int>, 
	IClusteringAlgorithm<double[], double>, IClusteringAlgorithm<double[]>, 
	IUnsupervisedLearning<IClusterCollection<double[]>, double[], int>

<SerializableAttribute>
Public Class KMeans
	Inherits ParallelLearningBase
	Implements IUnsupervisedLearning(Of KMeansClusterCollection, Double(), Integer), 
	IClusteringAlgorithm(Of Double(), Double), IClusteringAlgorithm(Of Double()), 
	IUnsupervisedLearning(Of IClusterCollection(Of Double()), Double(), Integer)

Accord.Math.Random.Generator.Seed = 0;

// Declare some observations
double[][] observations =
{
    new double[] { -5, -2, -1 },
    new double[] { -5, -5, -6 },
    new double[] {  2,  1,  1 },
    new double[] {  1,  1,  2 },
    new double[] {  1,  2,  2 },
    new double[] {  3,  1,  2 },
    new double[] { 11,  5,  4 },
    new double[] { 15,  5,  6 },
    new double[] { 10,  5,  6 },
};

// Create a new K-Means algorithm
KMeans kmeans = new KMeans(k: 3);

// Compute and retrieve the data centroids
var clusters = kmeans.Learn(observations);

// Use the centroids to parition all the data
int[] labels = clusters.Decide(observations);

Accord.Math.Random.Generator.Seed = 0;

// A common desire when doing clustering is to attempt to find how to 
// weight the different components / columns of a dataset, giving them 
// different importances depending on the end goal of the clustering task.

// Declare some observations
double[][] observations =
{
    new double[] { -5, -2, -1 },
    new double[] { -5, -5, -6 },
    new double[] {  2,  1,  1 },
    new double[] {  1,  1,  2 },
    new double[] {  1,  2,  2 },
    new double[] {  3,  1,  2 },
    new double[] { 11,  5,  4 },
    new double[] { 15,  5,  6 },
    new double[] { 10,  5,  6 },
};

// Create a new K-Means algorithm
KMeans kmeans = new KMeans(k: 3)
{
    // For example, let's say we would like to consider the importance of 
    // the first column as 0.1, the second column as 0.7 and the third 0.9
    Distance = new WeightedSquareEuclidean(new double[] { 0.1, 0.7, 1.1 })
};

// Compute and retrieve the data centroids
var clusters = kmeans.Learn(observations);

// Use the centroids to parition all the data
int[] labels = clusters.Decide(observations);

Accord.Math.Random.Generator.Seed = 0;

// Declare some mixed discrete and continuous observations
double[][] observations =
{
    //             (categorical) (discrete) (continuous)
    new double[] {       1,          -1,        -2.2      },
    new double[] {       1,          -6,        -5.5      },
    new double[] {       2,           1,         1.1      },
    new double[] {       2,           2,         1.2      },
    new double[] {       2,           2,         2.6      },
    new double[] {       3,           2,         1.4      },
    new double[] {       3,           4,         5.2      },
    new double[] {       1,           6,         5.1      },
    new double[] {       1,           6,         5.9      },
};

// Create a new codification algorithm to convert 
// the mixed variables above into all continuous:
var codification = new Codification<double>()
{
    CodificationVariable.Categorical,
    CodificationVariable.Discrete,
    CodificationVariable.Continuous
};

// Learn the codification from observations
var model = codification.Learn(observations);

// Transform the mixed observations into only continuous:
double[][] newObservations = model.ToDouble().Transform(observations);

// (newObservations will be equivalent to)
double[][] expected =
{
    //               (one hot)    (discrete)    (continuous)
    new double[] {    1, 0, 0,        -1,          -2.2      },
    new double[] {    1, 0, 0,        -6,          -5.5      },
    new double[] {    0, 1, 0,         1,           1.1      },
    new double[] {    0, 1, 0,         2,           1.2      },
    new double[] {    0, 1, 0,         2,           2.6      },
    new double[] {    0, 0, 1,         2,           1.4      },
    new double[] {    0, 0, 1,         4,           5.2      },
    new double[] {    1, 0, 0,         6,           5.1      },
    new double[] {    1, 0, 0,         6,           5.9      },
};

// Create a new K-Means algorithm
KMeans kmeans = new KMeans(k: 3);

// Compute and retrieve the data centroids
var clusters = kmeans.Learn(observations);

// Use the centroids to parition all the data
int[] labels = clusters.Decide(observations);

// Load a test image (shown in a picture box below)
var sampleImages = new TestImages(path: basePath);
Bitmap image = sampleImages.GetImage("airplane.png");

// ImageBox.Show("Original", image).Hold();

// Create converters to convert between Bitmap images and double[] arrays
var imageToArray = new ImageToArray(min: -1, max: +1);
var arrayToImage = new ArrayToImage(image.Width, image.Height, min: -1, max: +1);

// Transform the image into an array of pixel values
double[][] pixels; imageToArray.Convert(image, out pixels);


// Create a K-Means algorithm using given k and a
//  square Euclidean distance as distance metric.
KMeans kmeans = new KMeans(k: 5)
{
    Distance = new SquareEuclidean(),

    // We will compute the K-Means algorithm until cluster centroids
    // change less than 0.5 between two iterations of the algorithm
    Tolerance = 0.05
};


// Learn the clusters from the data
var clusters = kmeans.Learn(pixels);

// Use clusters to decide class labels
int[] labels = clusters.Decide(pixels);

// Replace every pixel with its corresponding centroid
double[][] replaced = pixels.Apply((x, i) => clusters.Centroids[labels[i]]);

// Retrieve the resulting image (shown in a picture box)
Bitmap result; arrayToImage.Convert(replaced, out result);

// ImageBox.Show("k-Means clustering", result).Hold();