public void chunking_dataset_markov()
{
Chunking chunking = new Chunking(path: Path.GetTempPath());
// Learn a mapping between each word to an integer class label:
var wordMap = new Codification().Learn(chunking.Words);
// Learn a mapping between each tag to an integer class labels:
var tagMap = new Codification().Learn(chunking.Tags);
// Convert the training and testing sets into integer labels:
int[][] trainX = wordMap.Transform(chunking.Training.Item1);
int[][] testX = wordMap.Transform(chunking.Testing.Item1);
// Convert the training and testing tags into integer labels:
int[][] trainY = tagMap.Transform(chunking.Training.Item2);
int[][] testY = tagMap.Transform(chunking.Testing.Item2);
// Learn one Markov model using the training data
var teacher = new MaximumLikelihoodLearning()
{
UseLaplaceRule = true,
UseWeights = true
};
// Use the teacher to learn a Markov model
var markov = teacher.Learn(trainX, trainY);
// Use the model to predict instances:
int[][] predY = markov.Decide(testX);
// Check the accuracy of the model:
var cm = new GeneralConfusionMatrix(
predicted: predY.Concatenate(),
expected: testY.Concatenate());
double acc = cm.Accuracy;
#if NET35
Assert.AreEqual(0.51725520822339954d, acc, 1e-10);
#else
Assert.AreEqual(0.43987588914452158, acc, 1e-10);
#endif
}
private static void hmm(int[][] trainX, int[][] trainY, int[][] testX, int[][] testY)
{
// Learn one Markov model using the training data
var teacher = new MaximumLikelihoodLearning()
{
UseLaplaceRule = true,
UseWeights = true
};
// Use the teacher to learn a Markov model
var markov = teacher.Learn(trainX, trainY);
// Use the model to predict instances:
int[][] predY = markov.Decide(testX);
// Check the accuracy of the model:
var cm = new ConfusionMatrix(predicted: predY.Concatenate(), expected: testY.Concatenate());
}
public void learn_test()
{
#region doc_learn
// Example from
// http://www.cs.columbia.edu/4761/notes07/chapter4.3-HMM.pdf
// Inputs
int[][] observations =
{
new int[] { 0, 0, 0, 1, 0, 0 },
new int[] { 1, 0, 0, 1, 0, 0 },
new int[] { 0, 0, 1, 0, 0, 0 },
new int[] { 0, 0, 0, 0, 1, 0 },
new int[] { 1, 0, 0, 0, 1, 0 },
new int[] { 0, 0, 0, 1, 1, 0 },
new int[] { 1, 0, 0, 0, 0, 0 },
new int[] { 1, 0, 1, 0, 0, 0 },
};
// Outputs
int[][] paths =
{
new int[] { 0, 0, 1, 0, 1, 0 },
new int[] { 1, 0, 1, 0, 1, 0 },
new int[] { 1, 0, 0, 1, 1, 0 },
new int[] { 1, 0, 1, 1, 1, 0 },
new int[] { 1, 0, 0, 1, 0, 1 },
new int[] { 0, 0, 1, 0, 0, 1 },
new int[] { 0, 0, 1, 1, 0, 1 },
new int[] { 0, 1, 1, 1, 0, 0 },
};
// Create a hidden Markov model with 2 states for 2 symbols
var model = new HiddenMarkovModel(states: 2, symbols: 2);
// Create a Maximum Likelihood learning algorithm
var target = new MaximumLikelihoodLearning(model)
{
UseLaplaceRule = false // don't use Laplace smoothing (to reproduce the example)
};
// Learn the Markov model
target.Learn(observations, paths);
// Recover the learned parameters
var pi = model.LogInitial.Exp();
var A = model.LogTransitions.Exp();
var B = model.LogEmissions.Exp();
#endregion
Assert.AreEqual(0.5, pi[0]);
Assert.AreEqual(0.5, pi[1]);
Assert.AreEqual(7 / 20.0, A[0][0], 1e-5);
Assert.AreEqual(13 / 20.0, A[0][1], 1e-5);
Assert.AreEqual(14 / 20.0, A[1][0], 1e-5);
Assert.AreEqual(6 / 20.0, A[1][1], 1e-5);
Assert.AreEqual(17 / 25.0, B[0][0], 1e-5);
Assert.AreEqual(8 / 25.0, B[0][1], 1e-5);
Assert.AreEqual(19 / 23.0, B[1][0], 1e-5);
Assert.AreEqual(4 / 23.0, B[1][1], 1e-5);
}
public void sequence_parsing_test()
{
#region doc_learn_fraud_analysis
// 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
#endregion
Assert.AreEqual(new[] { 0, 0 }, firstPerson);
Assert.AreEqual(new[] { 0, 0, 1, 0 }, secondPerson);
}
public void learnTest()
{
#region doc_learn
// Example from
// http://www.cs.columbia.edu/4761/notes07/chapter4.3-HMM.pdf
// Inputs
int[][] observations =
{
new int[] { 0, 0, 0, 1, 0, 0 },
new int[] { 1, 0, 0, 1, 0, 0 },
new int[] { 0, 0, 1, 0, 0, 0 },
new int[] { 0, 0, 0, 0, 1, 0 },
new int[] { 1, 0, 0, 0, 1, 0 },
new int[] { 0, 0, 0, 1, 1, 0 },
new int[] { 1, 0, 0, 0, 0, 0 },
new int[] { 1, 0, 1, 0, 0, 0 },
};
// Outputs
int[][] paths =
{
new int[] { 0, 0, 1, 0, 1, 0 },
new int[] { 1, 0, 1, 0, 1, 0 },
new int[] { 1, 0, 0, 1, 1, 0 },
new int[] { 1, 0, 1, 1, 1, 0 },
new int[] { 1, 0, 0, 1, 0, 1 },
new int[] { 0, 0, 1, 0, 0, 1 },
new int[] { 0, 0, 1, 1, 0, 1 },
new int[] { 0, 1, 1, 1, 0, 0 },
};
// Create the initial discrete distributions for 2 symbols
var initial = new GeneralDiscreteDistribution(symbols: 2);
// Create a generic hidden Markov model based on the initial distribution with 2 states
var model = new HiddenMarkovModel <GeneralDiscreteDistribution, int>(states: 2, emissions: initial);
// Create a new (fully supervised) Maximum Likelihood learning algorithm for HMMs
var target = new MaximumLikelihoodLearning <GeneralDiscreteDistribution, int>(model)
{
UseLaplaceRule = false // don't use Laplace smoothing (to reproduce the example)
};
// Learn the Markov model
target.Learn(observations, paths);
// Recover the learned parameters
var pi = model.LogInitial.Exp();
var A = model.LogTransitions.Exp();
var B = model.Emissions;
#endregion
Assert.AreEqual(0.5, pi[0]);
Assert.AreEqual(0.5, pi[1]);
Assert.AreEqual(7 / 20.0, A[0][0], 1e-5);
Assert.AreEqual(13 / 20.0, A[0][1], 1e-5);
Assert.AreEqual(14 / 20.0, A[1][0], 1e-5);
Assert.AreEqual(6 / 20.0, A[1][1], 1e-5);
Assert.AreEqual(17 / 25.0, B[0].ProbabilityMassFunction(0));
Assert.AreEqual(8 / 25.0, B[0].ProbabilityMassFunction(1));
Assert.AreEqual(19 / 23.0, B[1].ProbabilityMassFunction(0));
Assert.AreEqual(4 / 23.0, B[1].ProbabilityMassFunction(1));
}
public HiddenMarkovModel TrainModel(int[][] X, int[][] y)
{
Teacher.Learn(X, y);
return(HMM);
}
