AdaBoostTModel Class

public class AdaBoost<TModel> : ISupervisedBinaryLearning<Boost<TModel>, double[]>, 
	ISupervisedMulticlassLearning<Boost<TModel>, double[]>, ISupervisedMultilabelLearning<Boost<TModel>, double[]>, 
	ISupervisedLearning<Boost<TModel>, double[], int[]>, ISupervisedLearning<Boost<TModel>, double[], bool[]>, 
	ISupervisedLearning<Boost<TModel>, double[], int>, ISupervisedLearning<Boost<TModel>, double[], bool>
where TModel : Object, IClassifier<double[], int>

Public Class AdaBoost(Of TModel As {Object, IClassifier(Of Double(), Integer)})
	Implements ISupervisedBinaryLearning(Of Boost(Of TModel), Double()), 
	ISupervisedMulticlassLearning(Of Boost(Of TModel), Double()), ISupervisedMultilabelLearning(Of Boost(Of TModel), Double()), 
	ISupervisedLearning(Of Boost(Of TModel), Double(), Integer()), 
	ISupervisedLearning(Of Boost(Of TModel), Double(), Boolean()), 
	ISupervisedLearning(Of Boost(Of TModel), Double(), Integer), 
	ISupervisedLearning(Of Boost(Of TModel), Double(), Boolean)

// 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

// This example shows how to use AdaBoost to train more complex
// models than a simple DecisionStump. For example, we will use
// it to train a boosted Logistic Regression classifier.

// Let's use some synthetic data for that: The Yin-Yang dataset is 
// a simple 2D binary non-linear decision problem where the points 
// belong to each of the classes interwine in a Yin-Yang shape:
var dataset = new YinYang();
double[][] inputs = dataset.Instances;
int[] outputs = Classes.ToZeroOne(dataset.ClassLabels);

// Create an AdaBoost for Logistic Regression as:
var teacher = new AdaBoost<LogisticRegression>()
{
    // Here we can specify how each regression should be learned:
    Learner = (param) => new IterativeReweightedLeastSquares<LogisticRegression>()
    {
        ComputeStandardErrors = false,
        MaxIterations = 50,
        Tolerance = 0
    },

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

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

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

double error = cm.Error;  // should be 0.11
double acc = cm.Accuracy; // should be 0.89
double kappa = cm.Kappa;  // should be 0.78

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

// This example shows how to use AdaBoost to train more complex
// models than a simple DecisionStump. For example, we will use
// it to train a boosted Decision Trees.

// Let's use some synthetic data for that: The Yin-Yang dataset is 
// a simple 2D binary non-linear decision problem where the points 
// belong to each of the classes interwine in a Yin-Yang shape:
var dataset = new YinYang();
double[][] inputs = dataset.Instances;
int[] outputs = Classes.ToZeroOne(dataset.ClassLabels);

// Create an AdaBoost for Logistic Regression as:
var teacher = new AdaBoost<DecisionTree>()
{
    // Here we can specify how each regression should be learned:
    Learner = (param) => new C45Learning()
    {
        // i.e.
        // MaxHeight = 
        // MaxVariables = 
    },

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

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

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

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