KNearestNeighborsTInput Class

[SerializableAttribute]
public class KNearestNeighbors<TInput> : BaseKNearestNeighbors<KNearestNeighbors<TInput>, TInput, IDistance<TInput>>, 
	IParallel, ISupportsCancellation

<SerializableAttribute>
Public Class KNearestNeighbors(Of TInput)
	Inherits BaseKNearestNeighbors(Of KNearestNeighbors(Of TInput), TInput, IDistance(Of TInput))
	Implements IParallel, ISupportsCancellation

// Create some sample learning data. In this data,
// the first two instances belong to a class, the
// four next belong to another class and the last
// three to yet another.

double[][] inputs =
{
    // The first two are from class 0
    new double[] { -5, -2, -1 },
    new double[] { -5, -5, -6 },

    // The next four are from class 1
    new double[] {  2,  1,  1 },
    new double[] {  1,  1,  2 },
    new double[] {  1,  2,  2 },
    new double[] {  3,  1,  2 },

    // The last three are from class 2
    new double[] { 11,  5,  4 },
    new double[] { 15,  5,  6 },
    new double[] { 10,  5,  6 },
};

int[] outputs =
{
    0, 0,        // First two from class 0
    1, 1, 1, 1,  // Next four from class 1
    2, 2, 2      // Last three from class 2
};


// Now we will create the K-Nearest Neighbors algorithm. For this
// example, we will be choosing k = 4. This means that, for a given
// instance, its nearest 4 neighbors will be used to cast a decision.
var knn = new KNearestNeighbors(k: 4);

// We learn the algorithm:
knn.Learn(inputs, outputs);

// After the algorithm has been created, we can classify a new instance:
int answer = knn.Decide(new double[] { 11, 5, 4 }); // answer will be 2.

// Let's say we would like to compute the error matrix for the classifier:
var cm = GeneralConfusionMatrix.Estimate(knn, inputs, outputs);

// We can use it to estimate measures such as 
double error = cm.Error;  // should be 
double acc = cm.Accuracy; // should be 
double kappa = cm.Kappa;  // should be

// After we have created and learned our model, let's say we would 
// like to save it to disk. For this, we can import the Accord.IO 
// namespace at the top of our source file namespace, and then use 
// Serializer's extension method Save:

// Save to a file called "knn.bin" in the basePath directory:
knn.Save(Path.Combine(basePath, "knn.bin"));

// To load it back from the disk, we might need to use the Serializer class directly:
var loaded_knn = Serializer.Load<KNearestNeighbors>(Path.Combine(basePath, "knn.bin"));

// At this point, knn and loaded_knn should be 
// two different instances of identical objects.

// Create some sample learning data. In this data,
// the first two instances belong to a class, the
// four next belong to another class and the last
// three to yet another.

double[][] inputs =
{
    // The first two are from class 0
    new double[] { -5, -2, -1 },
    new double[] { -5, -5, -6 },

    // The next four are from class 1
    new double[] {  2,  1,  1 },
    new double[] {  1,  1,  2 },
    new double[] {  1,  2,  2 },
    new double[] {  3,  1,  2 },

    // The last three are from class 2
    new double[] { 11,  5,  4 },
    new double[] { 15,  5,  6 },
    new double[] { 10,  5,  6 },
};

int[] outputs =
{
    0, 0,        // First two from class 0
    1, 1, 1, 1,  // Next four from class 1
    2, 2, 2      // Last three from class 2
};


// Now we will create the K-Nearest Neighbors algorithm. For this
// example, we will be choosing k = 4. This means that, for a given
// instance, its nearest 4 neighbors will be used to cast a decision.
var knn = new KNearestNeighbors<double[]>(k: 4, distance: new SquareEuclidean());

// We learn the algorithm:
knn.Learn(inputs, outputs);

// After the algorithm has been created, we can classify a new instance:
int answer = knn.Decide(new double[] { 11, 5, 4 }); // answer will be 2.

// Let's say we would like to compute the error matrix for the classifier:
var cm = GeneralConfusionMatrix.Estimate(knn, inputs, outputs);

// We can use it to estimate measures such as 
double error = cm.Error;  // should be 0
double acc = cm.Accuracy; // should be 1
double kappa = cm.Kappa;  // should be 1

// The k-Nearest Neighbors algorithm can be used with
// any kind of data. In this example, we will see how
// it can be used to compare, for example, Strings.

string[] inputs =
{
    "Car",     // class 0
    "Bar",     // class 0
    "Jar",     // class 0

    "Charm",   // class 1
    "Chair"    // class 1
};

int[] outputs =
{
    0, 0, 0,  // First three are from class 0
    1, 1,     // And next two are from class 1
};


// Now we will create the K-Nearest Neighbors algorithm. For this
// example, we will be choosing k = 1. This means that, for a given
// instance, only its nearest neighbor will be used to cast a new
// decision. 

// In order to compare strings, we will be using Levenshtein's string distance
var knn = new KNearestNeighbors<string>(k: 1, distance: new Levenshtein());

// We learn the algorithm:
knn.Learn(inputs, outputs);

// After the algorithm has been created, we can use it:
int answer = knn.Decide("Chars"); // answer should be 1.

// Let's say we would like to compute the error matrix for the classifier:
var cm = ConfusionMatrix.Estimate(knn, inputs, outputs);

// We can use it to estimate measures such as 
double error = cm.Error;  // should be 0
double acc = cm.Accuracy; // should be 1
double kappa = cm.Kappa;  // should be 1