HiddenMarkovModel Class

[SerializableAttribute]
public class HiddenMarkovModel : HiddenMarkovModel<GeneralDiscreteDistribution, int>, 
	IHiddenMarkovModel, ICloneable

<SerializableAttribute>
Public Class HiddenMarkovModel
	Inherits HiddenMarkovModel(Of GeneralDiscreteDistribution, Integer)
	Implements IHiddenMarkovModel, ICloneable

// In this example, we will reproduce the example on the Viterbi algorithm
// available on Wikipedia: http://en.wikipedia.org/wiki/Viterbi_algorithm

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

// Create the emission matrix B
double[,] emission =
{
    { 0.1, 0.4, 0.5 },
    { 0.6, 0.3, 0.1 }
};

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

// Create a new hidden Markov model
var hmm = new HiddenMarkovModel(transition, emission, initial);

// After that, one could, for example, query the probability
// of a sequence occurring. We will consider the sequence
int[] sequence = new int[] { 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.Decode(sequence);

// And the likelihood along the Viterbi path is
double viterbi; hmm.Decode(sequence, out viterbi);

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

// We will create a Hidden Markov Model to detect 
// whether a given sequence starts with a zero.
int[][] sequences = new int[][]
{
    new int[] { 0,1,1,1,1,0,1,1,1,1 },
    new int[] { 0,1,1,1,0,1,1,1,1,1 },
    new int[] { 0,1,1,1,1,1,1,1,1,1 },
    new int[] { 0,1,1,1,1,1         },
    new int[] { 0,1,1,1,1,1,1       },
    new int[] { 0,1,1,1,1,1,1,1,1,1 },
    new int[] { 0,1,1,1,1,1,1,1,1,1 },
};

// Create the learning algorithm
var teacher = new BaumWelchLearning()
{
    Topology = new Ergodic(3), // Create a new Hidden Markov Model with 3 states for
    NumberOfSymbols = 2,       // an output alphabet of two characters (zero and one)
    Tolerance = 0.0001,        // train until log-likelihood changes less than 0.0001
    Iterations = 0             // and use as many iterations as needed
};

// Estimate the model
var hmm = teacher.Learn(sequences);

// Now we can calculate the probability that the given
// sequences originated from the model. We can compute
// those probabilities using the Viterbi algorithm:
double vl1; hmm.Decode(new int[] { 0, 1 }, out vl1);        // -0.69317855
double vl2; hmm.Decode(new int[] { 0, 1, 1, 1 }, out vl2);  // -2.16644878

// Sequences which do not start with zero have much lesser probability.
double vl3; hmm.Decode(new int[] { 1, 1 }, out vl3);        // -11.3580034
double vl4; hmm.Decode(new int[] { 1, 0, 0, 0 }, out vl4);  // -38.6759130

// 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 vl5; hmm.Decode(new int[] { 0, 1, 0, 1, 1, 1, 1, 1, 1 }, out vl5); // -8.22665
double vl6; hmm.Decode(new int[] { 0, 1, 1, 1, 1, 1, 1, 0, 1 }, out vl6); // -8.22665


// Additionally, we can also compute the probability 
// of those sequences using the forward algorithm:
double fl1 = hmm.LogLikelihood(new int[] { 0, 1 });        // -0.000031369
double fl2 = hmm.LogLikelihood(new int[] { 0, 1, 1, 1 });  // -0.087005121

// Sequences which do not start with zero have much lesser probability.
double fl3 = hmm.LogLikelihood(new int[] { 1, 1 });        // -10.66485629
double fl4 = hmm.LogLikelihood(new int[] { 1, 0, 0, 0 });  // -36.61788687

// 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 fl5 = hmm.LogLikelihood(new int[] { 0, 1, 0, 1, 1, 1, 1, 1, 1 }); // -3.3744416
double fl6 = hmm.LogLikelihood(new int[] { 0, 1, 1, 1, 1, 1, 1, 0, 1 }); // -3.3744416

Accord.Math.Random.Generator.Seed = 42;

// Let's say we have the following set of sequences
string[][] phrases =
{
    new[] { "those", "are", "sample", "words", "from", "a", "dictionary" },
    new[] { "those", "are", "sample", "words" },
    new[] { "sample", "words", "are", "words" },
    new[] { "those", "words" },
    new[] { "those", "are", "words" },
    new[] { "words", "from", "a", "dictionary" },
    new[] { "those", "are", "words", "from", "a", "dictionary" }
};

// Let's begin by transforming them to sequence of
// integer labels using a codification codebook:
var codebook = new Codification("Words", phrases);

// Now we can create the training data for the models:
int[][] sequence = codebook.Translate("Words", phrases);

// To create the models, we will specify a forward topology,
// as the sequences have definite start and ending points.
// 
var topology = new Forward(states: 4);
int symbols = codebook["Words"].Symbols; // We have 7 different words

// Create the hidden Markov model
var hmm = new HiddenMarkovModel(topology, symbols);

// Create the learning algorithm
var teacher = new BaumWelchLearning(hmm);

// Teach the model
teacher.Learn(sequence);

// Now, we can ask the model to generate new samples
// from the word distributions it has just learned:
// 
int[] sample = hmm.Generate(3);

// And the result will be: "those", "are", "words".
string[] result = codebook.Translate("Words", sample);

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

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

    // 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 hmm = teacher.Learn(sequences);

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

// At this point, prediction should be int[] { 11 }
int nextSymbol = prediction[0]; // should be 11.

// We can try to predict further, but this might not work very 
// well due the Markov assumption between the transition states:
int[] nextSymbols = hmm.Predict(observations: new[] { 1, 3, 5, 7 }, next: 2);

// At this point, nextSymbols should be int[] { 9, 11 }
int nextSymbol1 = nextSymbols[0]; // 9
int nextSymbol2 = nextSymbols[1]; // 11