ConfusionMatrix Class

[SerializableAttribute]
public class ConfusionMatrix

<SerializableAttribute>
Public Class ConfusionMatrix

// Let's say we have a decision problem involving 3 classes. In a typical
// machine learning problem, have a set of expected, ground truth values:
// 
int[] expected = { 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2 };

// And we have a set of values that have been predicted by a machine model:
// 
int[] predicted = { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1 };

// We can get different performance measures to assess how good our model was at 
// predicting the true, expected, ground-truth labels for the decision problem:
var cm = new GeneralConfusionMatrix(classes: 3, expected: expected, predicted: predicted);

// We can obtain the proper confusion matrix using:
int[,] matrix = cm.Matrix;

// The values of this matrix should be the same as:
int[,] expectedMatrix =
{
    //              expected
    /*predicted*/ { 4, 0, 0 },
                  { 0, 4, 4 },
                  { 0, 0, 0 },
};


// We can get more information about our problem as well:
int classes = cm.NumberOfClasses; // should be 3
int samples = cm.NumberOfSamples; // should be 12

// And multiple performance measures:
double accuracy = cm.Accuracy;                      // should be 0.66666666666666663
double error = cm.Error;                            // should be 0.33333333333333337
double chanceAgreement = cm.ChanceAgreement;        // should be 0.33333333333333331
double geommetricAgreement = cm.GeometricAgreement; // should be 0 (the classifier completely missed one class)
double pearson = cm.Pearson;                        // should be 0.70710678118654757
double kappa = cm.Kappa;                            // should be 0.49999999999999994
double tau = cm.Tau;                                // should be 0.49999999999999994
double chiSquare = cm.ChiSquare;                    // should be 12

// and some of their standard errors:
double kappaStdErr = cm.StandardError;              // should be 0.15590239111558091
double kappaStdErr0 = cm.StandardErrorUnderNull;    // should be 0.16666666666666663

// Let's say we want to classify the following 2-dimensional 
// data samples into 2 possible classes, either true or false:
double[][] inputs =
{
    new double[] {  10, 42 },
    new double[] { 162, 96 },
    new double[] { 125, 20 },
    new double[] {  96,  6 },
    new double[] {   2, 73 },
    new double[] {  52, 51 },
    new double[] {  71, 49 },
};

// And those are their associated class labels
bool[] outputs =
{
    false, false, true, true, false, false, true
};

// We can create an AdaBoost algorithm as:
var learner = new AdaBoost<DecisionStump>()
{
    Learner = (p) => new ThresholdLearning(),

    // Train until:
    MaxIterations = 5,
    Tolerance = 1e-3
};

// Now, we can use the Learn method to learn a boosted classifier
Boost<DecisionStump> classifier = learner.Learn(inputs, outputs);

// And we can test its performance using (error should be 0):
ConfusionMatrix cm = ConfusionMatrix.Estimate(classifier, inputs, outputs);

double error = cm.Error;  // should be 0.0
double acc = cm.Accuracy; // should be 1.0
double kappa = cm.Kappa;  // should be 1.0

// And compute a decision for a single data point using:
bool y = classifier.Decide(inputs[0]); // result should false