ProbabilisticOutputCalibration Class

public class ProbabilisticOutputCalibration : ProbabilisticOutputCalibrationBase<SupportVectorMachine<IKernel<double[]>, double[]>, IKernel<double[]>, double[]>, 
	ISupportVectorMachineLearning, ISupportVectorMachineLearning<double[]>, ISupervisedBinaryLearning<ISupportVectorMachine<double[]>, double[]>, 
	ISupervisedMulticlassLearning<ISupportVectorMachine<double[]>, double[]>, ISupervisedMultilabelLearning<ISupportVectorMachine<double[]>, double[]>, 
	ISupervisedLearning<ISupportVectorMachine<double[]>, double[], int[]>, 
	ISupervisedLearning<ISupportVectorMachine<double[]>, double[], bool[]>, 
	ISupervisedLearning<ISupportVectorMachine<double[]>, double[], int>, 
	ISupervisedLearning<ISupportVectorMachine<double[]>, double[], bool>, 
	ISupervisedLearning<ISupportVectorMachine<double[]>, double[], double>

Public Class ProbabilisticOutputCalibration
	Inherits ProbabilisticOutputCalibrationBase(Of SupportVectorMachine(Of IKernel(Of Double()), Double()), IKernel(Of Double()), Double())
	Implements ISupportVectorMachineLearning, ISupportVectorMachineLearning(Of Double()), 
	ISupervisedBinaryLearning(Of ISupportVectorMachine(Of Double()), Double()), 
	ISupervisedMulticlassLearning(Of ISupportVectorMachine(Of Double()), Double()), 
	ISupervisedMultilabelLearning(Of ISupportVectorMachine(Of Double()), Double()), 
	ISupervisedLearning(Of ISupportVectorMachine(Of Double()), Double(), Integer()), 
	ISupervisedLearning(Of ISupportVectorMachine(Of Double()), Double(), Boolean()), 
	ISupervisedLearning(Of ISupportVectorMachine(Of Double()), Double(), Integer), 
	ISupervisedLearning(Of ISupportVectorMachine(Of Double()), Double(), Boolean), 
	ISupervisedLearning(Of ISupportVectorMachine(Of Double()), Double(), Double)

double[][] inputs = // Example XOR problem
{
    new double[] { 0, 0 }, // 0 xor 0: 1 (label +1)
    new double[] { 0, 1 }, // 0 xor 1: 0 (label -1)
    new double[] { 1, 0 }, // 1 xor 0: 0 (label -1)
    new double[] { 1, 1 }  // 1 xor 1: 1 (label +1)
};

int[] outputs = // XOR outputs
{
    1, 0, 0, 1
};

// Instantiate a new SMO learning algorithm for SVMs
var smo = new SequentialMinimalOptimization<Gaussian>()
{
    Kernel = new Gaussian(0.1),
    Complexity = 1.0
};

// Learn a SVM using the algorithm
var svm = smo.Learn(inputs, outputs);

// Predict labels for each input sample
bool[] predicted = svm.Decide(inputs);

// Compute classification error
double error = new ZeroOneLoss(outputs).Loss(predicted);

// Instantiate the probabilistic calibration (using Platt's scaling)
var calibration = new ProbabilisticOutputCalibration<Gaussian>(svm);

// Run the calibration algorithm
calibration.Learn(inputs, outputs); // returns the same machine

// Predict probabilities of each input sample
double[] probabilities = svm.Probability(inputs);

// Compute the error based on a hard decision
double loss = new BinaryCrossEntropyLoss(outputs).Loss(probabilities);

// Compute the decision output for one of the input vectors,
// while also retrieving the probability of the answer

bool decision;
double probability = svm.Probability(inputs[0], out decision);

// Let's say we have the following data to be classified
// into three possible classes. Those are the samples:
// 
double[][] inputs =
{
    //               input         output
    new double[] { 0, 1, 1, 0 }, //  0 
    new double[] { 0, 1, 0, 0 }, //  0
    new double[] { 0, 0, 1, 0 }, //  0
    new double[] { 0, 1, 1, 0 }, //  0
    new double[] { 0, 1, 0, 0 }, //  0
    new double[] { 1, 0, 0, 1 }, //  1
    new double[] { 0, 0, 0, 1 }, //  1
    new double[] { 0, 0, 0, 1 }, //  1
    new double[] { 1, 0, 1, 1 }, //  2
    new double[] { 1, 1, 0, 1 }, //  2
    new double[] { 0, 1, 1, 1 }, //  2
    new double[] { 1, 1, 1, 1 }, //  2
};

int[] outputs = // those are the class labels
{
    0, 0, 0, 0, 0,
    1, 1, 1,
    2, 2, 2, 2,
};

// Create the multi-class learning algorithm for the machine
var teacher = new MulticlassSupportVectorLearning<Gaussian>()
{
    // Configure the learning algorithm to use SMO to train the
    //  underlying SVMs in each of the binary class subproblems.
    Learner = (param) => new SequentialMinimalOptimization<Gaussian>()
    {
        // Estimate a suitable guess for the Gaussian kernel's parameters.
        // This estimate can serve as a starting point for a grid search.
        UseKernelEstimation = true
    }
};

// Learn a machine
var machine = teacher.Learn(inputs, outputs);


// Create the multi-class learning algorithm for the machine
var calibration = new MulticlassSupportVectorLearning<Gaussian>()
{
    Model = machine, // We will start with an existing machine

    // Configure the learning algorithm to use Platt's calibration
    Learner = (param) => new ProbabilisticOutputCalibration<Gaussian>()
    {
        Model = param.Model // Start with an existing machine
    }
};


// Configure parallel execution options
calibration.ParallelOptions.MaxDegreeOfParallelism = 1;

// Learn a machine
calibration.Learn(inputs, outputs);

// Obtain class predictions for each sample
int[] predicted = machine.Decide(inputs);

// Get class scores for each sample
double[] scores = machine.Score(inputs);

// Get log-likelihoods (should be same as scores)
double[][] logl = machine.LogLikelihoods(inputs);

// Get probability for each sample
double[][] prob = machine.Probabilities(inputs);

// Compute classification error
double error = new ZeroOneLoss(outputs).Loss(predicted);
double loss = new CategoryCrossEntropyLoss(outputs).Loss(prob);