HiddenMarkovModelTDistribution, TObservation Class

[SerializableAttribute]
public class HiddenMarkovModel<TDistribution, TObservation> : LikelihoodTaggerBase<TObservation>, 
	ICloneable
where TDistribution : Object, IDistribution<TObservation>

<SerializableAttribute>
Public Class HiddenMarkovModel(Of TDistribution As {Object, IDistribution(Of TObservation)}, TObservation)
	Inherits LikelihoodTaggerBase(Of TObservation)
	Implements ICloneable

// Create the transition matrix A
double[,] transitions =
{
    { 0.7, 0.3 },
    { 0.4, 0.6 }
};

// Create the vector of emission densities B
GeneralDiscreteDistribution[] emissions =
{
    new GeneralDiscreteDistribution(0.1, 0.4, 0.5),
    new GeneralDiscreteDistribution(0.6, 0.3, 0.1)
};

// Create the initial probabilities pi
double[] initial =
{
    0.6, 0.4
};

// Create a new hidden Markov model with discrete probabilities
var hmm = new HiddenMarkovModel<GeneralDiscreteDistribution, double>(transitions, emissions, initial);

// After that, one could, for example, query the probability
// of a sequence occurring. We will consider the sequence
double[] sequence = new double[] { 0, 1, 2 };

// And now we will evaluate its likelihood
double logLikelihood = hmm.LogLikelihood(sequence);

// At this point, the log-likelihood of the sequence
// occurring within the model is -3.3928721329161653.

// We can also get the Viterbi path of the sequence
int[] path = hmm.Decide(sequence);

// Or also its Viterbi likelihood alongside the path
double viterbi = hmm.LogLikelihood(sequence, ref path);

// At this point, the state path will be 1-0-0 and the
// log-likelihood will be -4.3095199438871337

// Continuous Markov Models can operate using any
// probability distribution, including discrete ones. 

// In the following example, we will try to create a
// Continuous Hidden Markov Model using a discrete
// distribution to detect if a given sequence starts
// with a zero and has any number of ones after that.

int[][] sequences = new double[][]
{
    new double[] { 0,1,1,1,1,0,1,1,1,1 },
    new double[] { 0,1,1,1,0,1,1,1,1,1 },
    new double[] { 0,1,1,1,1,1,1,1,1,1 },
    new double[] { 0,1,1,1,1,1         },
    new double[] { 0,1,1,1,1,1,1       },
    new double[] { 0,1,1,1,1,1,1,1,1,1 },
    new double[] { 0,1,1,1,1,1,1,1,1,1 },
}.ToInt32();

// Create a new Hidden Markov Model with 3 states and
//  a generic discrete distribution with two symbols
var hmm = HiddenMarkovModel.CreateDiscrete(3, 2);

// Try to fit the model to the data until the difference in
//  the average log-likelihood changes only by as little as 0.0001
var teacher = new BaumWelchLearning<GeneralDiscreteDistribution, int>(hmm)
{
    Tolerance = 0.0001,
    Iterations = 0
};

// Learn the model
teacher.Learn(sequences);

double ll = Math.Exp(teacher.LogLikelihood);

// Calculate the probability that the given
//  sequences originated from the model
double l1 = hmm.Probability(new int[] { 0, 1 });       // 0.999
double l2 = hmm.Probability(new int[] { 0, 1, 1, 1 }); // 0.916

// Sequences which do not start with zero have much lesser probability.
double l3 = hmm.Probability(new int[] { 1, 1 });       // 0.000
double l4 = hmm.Probability(new int[] { 1, 0, 0, 0 }); // 0.000

// Sequences which contains few errors have higher probability
//  than the ones which do not start with zero. This shows some
//  of the temporal elasticity and error tolerance of the HMMs.
double l5 = hmm.Probability(new int[] { 0, 1, 0, 1, 1, 1, 1, 1, 1 }); // 0.034
double l6 = hmm.Probability(new int[] { 0, 1, 1, 1, 1, 1, 1, 0, 1 }); // 0.034

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

// Let's say we have the following data about credit card transactions,
// where the data is organized in order of transaction, per credit card 
// holder. Everytime the "Time" column starts at zero, denotes that the
// sequence of observations follow will correspond to transactions of the
// same person:

double[,] data =
{
    // "Time", "V1",   "V2",  "V3", "V4", "V5", "Amount",  "Fraud"
    {      0,   0.521, 0.124, 0.622, 15.2, 25.6,   2.70,      0 }, // first person, ok
    {      1,   0.121, 0.124, 0.822, 12.2, 25.6,   42.0,      0 }, // first person, ok

    {      0,   0.551, 0.124, 0.422, 17.5, 25.6,   20.0,      0 }, // second person, ok
    {      1,   0.136, 0.154, 0.322, 15.3, 25.6,   50.0,      0 }, // second person, ok
    {      2,   0.721, 0.240, 0.422, 12.2, 25.6,   100.0,     1 }, // second person, fraud!
    {      3,   0.222, 0.126, 0.722, 18.1, 25.8,   10.0,      0 }, // second person, ok
};

// Transform the above data into a jagged matrix
double[][][] input;
int[][] states;
transform(data, out input, out states);

// Determine here the number of dimensions in the observations (in this case, 6)
int observationDimensions = 6; // 6 columns: "V1", "V2", "V3", "V4", "V5", "Amount"

// Create some prior distributions to help initialize our parameters
var priorC = new WishartDistribution(dimension: observationDimensions, degreesOfFreedom: 10); // this 10 is just some random number, you might have to tune as if it was a hyperparameter
var priorM = new MultivariateNormalDistribution(dimension: observationDimensions);

// Configure the learning algorithms to train the sequence classifier
var teacher = new MaximumLikelihoodLearning<MultivariateNormalDistribution, double[]>()
{
    // Their emissions will be multivariate Normal distributions initialized using the prior distributions
    Emissions = (j) => new MultivariateNormalDistribution(mean: priorM.Generate(), covariance: priorC.Generate()),

    // 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
    },
};

// Use the teacher to learn a new HMM 
var hmm = teacher.Learn(input, states);

// Use the HMM to predict whether the transations were fradulent or not:
int[] firstPerson = hmm.Decide(input[0]); // predict the first person, output should be: 0, 0

int[] secondPerson = hmm.Decide(input[1]); // predict the second person, output should be: 0, 0, 1, 0

private static void transform(double[,] data, out double[][][] input, out int[][] states)
{
    var sequences = new List<double[][]>();
    var classLabels = new List<int[]>();

    List<double[]> currentSequence = null;
    List<int> currentLabels = null;
    for (int i = 0; i < data.Rows(); i++)
    {
        // Check if the first column contains a zero, this would be an indication
        // that a new sequence (for a different person) is beginning:
        if (data[i, 0] == 0)
        {
            // Yes, this is a new sequence. Check if we were building
            // a sequence before, and if yes, save it to the list:
            if (currentSequence != null)
            {
                // Save the sequence we had so far 
                sequences.Add(currentSequence.ToArray());
                classLabels.Add(currentLabels.ToArray());

                currentSequence = null;
                currentLabels = null;
            }

            // We will be starting a new sequence
            currentSequence = new List<double[]>();
            currentLabels = new List<int>();
        }

        double[] features = data.GetRow(i).Get(1, 7); // Get values in columns from 1 (inclusive) to 7 (exclusive), meaning "V1", "V2", "V3", "V4", "V5", and "Amount"
        int classLabel = (int)data[i, 7]; // The seventh index corresponds to the class label column ("Class")

        // Save this information:
        currentSequence.Add(features);
        currentLabels.Add(classLabel);
    }

    // Check if there are any sequences and labels that we haven't saved yet:
    if (currentSequence != null)
    {
        // Yes there are: save them
        sequences.Add(currentSequence.ToArray());
        classLabels.Add(currentLabels.ToArray());
    }

    input = sequences.ToArray();
    states = classLabels.ToArray();
}

// We will try to create a Hidden Markov Model which
// can recognize (and predict) the following sequences:
double[][] sequences =
{
    new double[] { 1, 3, 5, 7, 9, 11, 13 },
    new double[] { 1, 3, 5, 7, 9, 11 },
    new double[] { 1, 3, 5, 7, 9, 11, 13 },
    new double[] { 1, 3, 3, 7, 7, 9, 11, 11, 13, 13 },
    new double[] { 1, 3, 7, 9, 11, 13 },
};

// Create a Baum-Welch HMM algorithm:
var teacher = new BaumWelchLearning<NormalDistribution, double, NormalOptions>()
{
    // Let's creates a left-to-right (forward)
    // Hidden Markov Model with 7 hidden states
    Topology = new Forward(7),

    FittingOptions = new NormalOptions()
    {
        Regularization = 1e-8
    },

    // We'll try to fit the model to the data until the difference in
    // the average log-likelihood changes only by as little as 0.0001
    Tolerance = 0.0001,
    Iterations = 0 // do not impose a limit on the number of iterations
};

// Use the algorithm to learn a new Markov model:
HiddenMarkovModel<NormalDistribution, double> hmm = teacher.Learn(sequences);

// Now, we will try to predict the next 1 observation in a base symbol sequence
double[] prediction = hmm.Predict(observations: new double[] { 1, 3, 5, 7, 9 }, next: 1);

// At this point, prediction should be around double[] { 11.909090909090905 }
double nextObservation = prediction[0]; // should be comparatively near 11.