HiddenMarkovClassifierLearningTDistribution, TObservation Class

public class HiddenMarkovClassifierLearning<TDistribution, TObservation> : BaseHiddenMarkovClassifierLearning<HiddenMarkovClassifier<TDistribution, TObservation>, HiddenMarkovModel<TDistribution, TObservation>, TDistribution, TObservation>
where TDistribution : Object, IDistribution<TObservation>

Public Class HiddenMarkovClassifierLearning(Of TDistribution As {Object, IDistribution(Of TObservation)}, TObservation)
	Inherits BaseHiddenMarkovClassifierLearning(Of HiddenMarkovClassifier(Of TDistribution, TObservation), HiddenMarkovModel(Of TDistribution, TObservation), TDistribution, TObservation)

// Create a Continuous density Hidden Markov Model Sequence Classifier
// to detect a univariate sequence and the same sequence backwards.
double[][] sequences = new double[][]
{
    new double[] { 0,1,2,3,4 }, // This is the first  sequence with label = 0
    new double[] { 4,3,2,1,0 }, // This is the second sequence with label = 1
};

// Labels for the sequences
int[] labels = { 0, 1 };

// Creates a sequence classifier containing 2 hidden Markov Models
//  with 2 states and an underlying Normal distribution as density.
var density = new NormalDistribution();
var classifier = new HiddenMarkovClassifier<NormalDistribution, double>(2, new Ergodic(2), density);

// Configure the learning algorithms to train the sequence classifier
var teacher = new HiddenMarkovClassifierLearning<NormalDistribution, double>(classifier)
{
    // Train each model until the log-likelihood changes less than 0.001
    Learner = modelIndex => new BaumWelchLearning<NormalDistribution, double>(classifier.Models[modelIndex])
    {
        Tolerance = 0.0001,
        Iterations = 0
    }
};

// Train the sequence classifier using the algorithm
teacher.Learn(sequences, labels);

double logLikelihood = teacher.LogLikelihood;


// Calculate the probability that the given
//  sequences originated from the model
double likelihood1, likelihood2;

// Try to classify the first sequence (output should be 0)
int c1 = classifier.Decide(sequences[0]);
likelihood1 = classifier.Probability(sequences[0]);

// Try to classify the second sequence (output should be 1)
int c2 = classifier.Decide(sequences[1]);
likelihood2 = classifier.Probability(sequences[1]);

// Create a Continuous density Hidden Markov Model Sequence Classifier
// to detect a multivariate sequence and the same sequence backwards.

double[][][] sequences = new double[][][]
{
    new double[][]
    { 
        // This is the first  sequence with label = 0
        new double[] { 0, 1 },
        new double[] { 1, 2 },
        new double[] { 2, 3 },
        new double[] { 3, 4 },
        new double[] { 4, 5 },
    },

    new double[][]
    {
            // This is the second sequence with label = 1
        new double[] { 4,  3 },
        new double[] { 3,  2 },
        new double[] { 2,  1 },
        new double[] { 1,  0 },
        new double[] { 0, -1 },
    }
};

// Labels for the sequences
int[] labels = { 0, 1 };

// Initial emission density to be copied to each state
var initialDensity = new MultivariateNormalDistribution(2);

// Creates a sequence classifier containing 2 hidden Markov Models with 2 states
// and an underlying multivariate mixture of Normal distributions as density.
var classifier = new HiddenMarkovClassifier<MultivariateNormalDistribution, double[]>(
    classes: 2, topology: new Forward(2), initial: initialDensity);

// Configure the learning algorithms to train the sequence classifier
var teacher = new HiddenMarkovClassifierLearning<MultivariateNormalDistribution, double[]>(classifier)
{
    // Train each model until the log-likelihood changes less than 0.0001
    Learner = modelIndex => new BaumWelchLearning<MultivariateNormalDistribution, double[], NormalOptions>(classifier.Models[modelIndex])
    {
        Tolerance = 0.0001,
        Iterations = 0,

        FittingOptions = new NormalOptions()
        {
            Diagonal = true,      // only diagonal covariance matrices
            Regularization = 1e-5 // avoid non-positive definite errors
        }
    }
};

// Train the sequence classifier using the algorithm
teacher.Learn(sequences, labels);

double logLikelihood = teacher.LogLikelihood;


// Calculate the probability that the given
//  sequences originated from the model
double likelihood, likelihood2;

int c1 = classifier.Decide(sequences[0]);
likelihood = classifier.Probability(sequences[0]);

// Try to classify the second sequence (output should be 1)
int c2 = classifier.Decide(sequences[1]);
likelihood2 = classifier.Probability(sequences[1]);

// Ensure we get reproducible results
Accord.Math.Random.Generator.Seed = 0;

// Download the PENDIGITS dataset from UCI ML repository
var pendigits = new Pendigits(path: localDownloadPath);

// Get and pre-process the training set
double[][][] trainInputs = pendigits.Training.Item1;
int[] trainOutputs = pendigits.Training.Item2;

// Pre-process the digits so each of them is centered and scaled
trainInputs = trainInputs.Apply(Accord.Statistics.Tools.ZScores);

// Create some prior distributions to help initialize our parameters
var priorC = new WishartDistribution(dimension: 2, degreesOfFreedom: 5);
var priorM = new MultivariateNormalDistribution(dimension: 2);

// Create a new learning algorithm for creating continuous hidden Markov model classifiers
var teacher = new HiddenMarkovClassifierLearning<MultivariateNormalDistribution, double[]>()
{
    // This tells the generative algorithm how to train each of the component models. Note: The learning
    // algorithm is more efficient if all generic parameters are specified, including the fitting options
    Learner = (i) => new BaumWelchLearning<MultivariateNormalDistribution, double[], NormalOptions>()
    {
        Topology = new Forward(5), // Each model will have a forward topology with 5 states

        // Their emissions will be multivariate Normal distributions initialized using the prior distributions
        Emissions = (j) => new MultivariateNormalDistribution(mean: priorM.Generate(), covariance: priorC.Generate()),

        // We will train until the relative change in the average log-likelihood is less than 1e-6 between iterations
        Tolerance = 1e-6,
        MaxIterations = 1000, // or until we perform 1000 iterations (which is unlikely for this dataset)

        // We will prevent our covariance matrices from becoming degenerate by adding a small 
        // regularization value to their diagonal until they become positive-definite again:
        FittingOptions = new NormalOptions()
        {
            Regularization = 1e-6
        }
    }
};

// The following line is only needed to ensure reproducible results. Please remove it to enable full parallelization
teacher.ParallelOptions.MaxDegreeOfParallelism = 1; // (Remove, comment, or change this line to enable full parallelism)

// Use the learning algorithm to create a classifier
var hmmc = teacher.Learn(trainInputs, trainOutputs);

// Compute predictions for the training set
int[] trainPredicted = hmmc.Decide(trainInputs);

// Check the performance of the classifier by comparing with the ground-truth:
var m1 = new GeneralConfusionMatrix(predicted: trainPredicted, expected: trainOutputs);
double trainAcc = m1.Accuracy; // should be 0.84962835906232137


// Prepare the testing set
double[][][] testInputs = pendigits.Testing.Item1;
int[] testOutputs = pendigits.Testing.Item2;

// Apply the same normalizations
testInputs = testInputs.Apply(Accord.Statistics.Tools.ZScores);

// Compute predictions for the test set
int[] testPredicted = hmmc.Decide(testInputs);

// Check the performance of the classifier by comparing with the ground-truth:
var m2 = new GeneralConfusionMatrix(predicted: testPredicted, expected: testOutputs);
double testAcc = m2.Accuracy; // should be 0.8130504403522818