public void GradientTest3()
{
var hmm = NormalHiddenMarkovClassifierPotentialFunctionTest.CreateModel1();
var function = new NormalMarkovClassifierFunction(hmm);
var model = new HiddenConditionalRandomField <double>(function);
var target = new QuasiNewtonHiddenLearning <double>(model);
target.Regularization = 2;
FiniteDifferences diff = new FiniteDifferences(function.Weights.Length);
diff.Function = parameters => func(model, parameters, target.Regularization);
double[] expected = diff.Compute(function.Weights);
double[] actual = target.Gradient(function.Weights, inputs, outputs);
for (int i = 0; i < actual.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 1e-2);
Assert.IsFalse(double.IsNaN(actual[i]));
Assert.IsFalse(double.IsNaN(expected[i]));
}
}
public void RunTest()
{
var hmm = MultivariateNormalHiddenMarkovClassifierPotentialFunctionTest.CreateModel1();
var function = new MultivariateNormalMarkovClassifierFunction(hmm);
var model = new HiddenConditionalRandomField <double[]>(function);
var target = new QuasiNewtonHiddenLearning <double[]>(model);
var inputs = inputs1;
var outputs = outputs1;
double[] actual = new double[inputs.Length];
double[] expected = new double[inputs.Length];
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
for (int i = 0; i < inputs.Length; i++)
{
Assert.AreEqual(expected[i], actual[i]);
}
double llm = hmm.LogLikelihood(inputs, outputs);
double ll0 = model.LogLikelihood(inputs, outputs);
Assert.AreEqual(llm, ll0, 1e-10);
Assert.IsFalse(double.IsNaN(llm));
Assert.IsFalse(double.IsNaN(ll0));
double error = target.RunEpoch(inputs, outputs);
double ll1 = model.LogLikelihood(inputs, outputs);
Assert.AreEqual(-ll1, error, 1e-10);
Assert.IsFalse(double.IsNaN(ll1));
Assert.IsFalse(double.IsNaN(error));
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
Assert.AreEqual(-0.0000041736023117522336, ll0, 1e-10);
Assert.AreEqual(error, -ll1);
Assert.IsFalse(Double.IsNaN(ll0));
Assert.IsFalse(Double.IsNaN(error));
for (int i = 0; i < inputs.Length; i++)
{
Assert.AreEqual(expected[i], actual[i]);
}
Assert.IsTrue(ll1 > ll0);
}
public void RunTest()
{
HiddenMarkovClassifier hmm = HiddenMarkovClassifierPotentialFunctionTest.CreateModel1();
var function = new DiscreteMarkovClassifierFunction(hmm);
var model = new HiddenConditionalRandomField <int>(function);
var target = new QuasiNewtonHiddenLearning <int>(model);
double[] actual = new double[inputs.Length];
double[] expected = new double[inputs.Length];
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
for (int i = 0; i < inputs.Length; i++)
{
Assert.AreEqual(expected[i], actual[i]);
}
double ll0 = model.LogLikelihood(inputs, outputs);
double error = target.RunEpoch(inputs, outputs);
double ll1 = model.LogLikelihood(inputs, outputs);
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
Assert.AreEqual(-0.00046872579976353634, ll0, 1e-10);
Assert.AreEqual(0.00012170806701733428, error, 1e-10);
Assert.AreEqual(error, -ll1);
Assert.IsFalse(Double.IsNaN(ll0));
Assert.IsFalse(Double.IsNaN(error));
for (int i = 0; i < inputs.Length; i++)
{
Assert.AreEqual(expected[i], actual[i]);
}
Assert.IsTrue(ll1 > ll0);
}
public void RunTest2()
{
Accord.Math.Tools.SetupGenerator(0);
var function = new DiscreteMarkovClassifierFunction(2, 2, 2);
var model = new HiddenConditionalRandomField <int>(function);
var target = new QuasiNewtonHiddenLearning <int>(model);
double[] actual = new double[inputs.Length];
double[] expected = new double[inputs.Length];
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
double ll0 = model.LogLikelihood(inputs, outputs);
double error = target.RunEpoch(inputs, outputs);
double ll1 = model.LogLikelihood(inputs, outputs);
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
Assert.AreEqual(-5.5451774444795623, ll0, 1e-10);
Assert.AreEqual(3.0990811490142045, error, 1e-10);
Assert.IsFalse(double.IsNaN(error));
for (int i = 0; i < inputs.Length; i++)
{
Assert.AreEqual(expected[i], actual[i]);
}
Assert.IsTrue(ll1 > ll0);
}
public void GradientTest()
{
var function = new DiscreteMarkovClassifierFunction(2, 2, 2);
var model = new HiddenConditionalRandomField <int>(function);
var target = new QuasiNewtonHiddenLearning <int>(model);
FiniteDifferences diff = new FiniteDifferences(function.Weights.Length);
diff.Function = parameters => func(model, parameters);
double[] expected = diff.Compute(function.Weights);
double[] actual = target.Gradient(function.Weights, inputs, outputs);
for (int i = 0; i < actual.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 1e-4);
Assert.IsFalse(double.IsNaN(actual[i]));
Assert.IsFalse(double.IsNaN(expected[i]));
}
}
public void GradientTest()
{
// Creates a sequence classifier containing 2 hidden Markov Models
// with 2 states and an underlying Normal distribution as density.
MultivariateNormalDistribution density = new MultivariateNormalDistribution(3);
var hmm = new HiddenMarkovClassifier <MultivariateNormalDistribution>(2, new Ergodic(2), density);
double[][][] inputs =
{
new [] { new double[] { 0, 1, 0 }, new double[] { 0, 1, 0 }, new double[] { 0, 1, 0 } },
new [] { new double[] { 1, 6, 2 }, new double[] { 2, 1, 6 }, new double[] { 1, 1, 0 } },
new [] { new double[] { 9, 1, 0 }, new double[] { 0, 1, 5 }, new double[] { 0, 0, 0 } },
};
int[] outputs =
{
0, 0, 1
};
var function = new MultivariateNormalMarkovClassifierFunction(hmm);
var model = new HiddenConditionalRandomField <double[]>(function);
var target = new QuasiNewtonHiddenLearning <double[]>(model);
FiniteDifferences diff = new FiniteDifferences(function.Weights.Length);
diff.Function = parameters => func(model, parameters, inputs, outputs);
double[] expected = diff.Compute(function.Weights);
double[] actual = target.Gradient(function.Weights, inputs, outputs);
for (int i = 0; i < actual.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 0.05);
Assert.IsFalse(double.IsNaN(actual[i]));
Assert.IsFalse(double.IsNaN(expected[i]));
}
}
public void GradientTest3()
{
var hmm = MultivariateNormalHiddenMarkovClassifierPotentialFunctionTest.CreateModel1();
var function = new MultivariateNormalMarkovClassifierFunction(hmm);
var model = new HiddenConditionalRandomField<double[]>(function);
var target = new QuasiNewtonHiddenLearning<double[]>(model);
target.Regularization = 2;
var inputs = inputs1;
var outputs = outputs1;
FiniteDifferences diff = new FiniteDifferences(function.Weights.Length);
diff.Function = parameters => func(model, parameters, inputs, outputs, target.Regularization);
double[] expected = diff.Compute(function.Weights);
double[] actual = target.Gradient(function.Weights, inputs, outputs);
for (int i = 0; i < actual.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 1e-3);
Assert.IsFalse(double.IsNaN(actual[i]));
Assert.IsFalse(double.IsNaN(expected[i]));
}
}
public void GradientTest()
{
// Creates a sequence classifier containing 2 hidden Markov Models
// with 2 states and an underlying Normal distribution as density.
MultivariateNormalDistribution density = new MultivariateNormalDistribution(3);
var hmm = new HiddenMarkovClassifier<MultivariateNormalDistribution>(2, new Ergodic(2), density);
double[][][] inputs =
{
new [] { new double[] { 0, 1, 0 }, new double[] { 0, 1, 0 }, new double[] { 0, 1, 0 } },
new [] { new double[] { 1, 6, 2 }, new double[] { 2, 1, 6 }, new double[] { 1, 1, 0 } },
new [] { new double[] { 9, 1, 0 }, new double[] { 0, 1, 5 }, new double[] { 0, 0, 0 } },
};
int[] outputs =
{
0, 0, 1
};
var function = new MultivariateNormalMarkovClassifierFunction(hmm);
var model = new HiddenConditionalRandomField<double[]>(function);
var target = new QuasiNewtonHiddenLearning<double[]>(model);
FiniteDifferences diff = new FiniteDifferences(function.Weights.Length);
diff.Function = parameters => func(model, parameters, inputs, outputs);
double[] expected = diff.Compute(function.Weights);
double[] actual = target.Gradient(function.Weights, inputs, outputs);
for (int i = 0; i < actual.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 0.05);
Assert.IsFalse(double.IsNaN(actual[i]));
Assert.IsFalse(double.IsNaN(expected[i]));
}
}
public void RunTest()
{
var hmm = MultivariateNormalHiddenMarkovClassifierPotentialFunctionTest.CreateModel1();
var function = new MultivariateNormalMarkovClassifierFunction(hmm);
var model = new HiddenConditionalRandomField<double[]>(function);
var target = new QuasiNewtonHiddenLearning<double[]>(model);
var inputs = inputs1;
var outputs = outputs1;
double[] actual = new double[inputs.Length];
double[] expected = new double[inputs.Length];
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
for (int i = 0; i < inputs.Length; i++)
Assert.AreEqual(expected[i], actual[i]);
double llm = hmm.LogLikelihood(inputs, outputs);
double ll0 = model.LogLikelihood(inputs, outputs);
Assert.AreEqual(llm, ll0, 1e-10);
Assert.IsFalse(double.IsNaN(llm));
Assert.IsFalse(double.IsNaN(ll0));
double error = target.RunEpoch(inputs, outputs);
double ll1 = model.LogLikelihood(inputs, outputs);
Assert.AreEqual(-ll1, error, 1e-10);
Assert.IsFalse(double.IsNaN(ll1));
Assert.IsFalse(double.IsNaN(error));
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
Assert.AreEqual(-0.0000041736023117522336, ll0, 1e-10);
Assert.AreEqual(error, -ll1);
Assert.IsFalse(Double.IsNaN(ll0));
Assert.IsFalse(Double.IsNaN(error));
for (int i = 0; i < inputs.Length; i++)
Assert.AreEqual(expected[i], actual[i]);
Assert.IsTrue(ll1 > ll0);
}
public void GradientTest2()
{
HiddenMarkovClassifier hmm = HiddenMarkovClassifierPotentialFunctionTest.CreateModel1();
var function = new DiscreteMarkovClassifierFunction(hmm);
var model = new HiddenConditionalRandomField<int>(function);
var target = new QuasiNewtonHiddenLearning<int>(model);
FiniteDifferences diff = new FiniteDifferences(function.Weights.Length);
diff.Function = parameters => func(model, parameters);
double[] expected = diff.Compute(function.Weights);
double[] actual = target.Gradient(function.Weights, inputs, outputs);
for (int i = 0; i < actual.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 1e-5);
Assert.IsFalse(double.IsNaN(actual[i]));
Assert.IsFalse(double.IsNaN(expected[i]));
}
}
public void RunTest2()
{
Accord.Math.Tools.SetupGenerator(0);
var function = new DiscreteMarkovClassifierFunction(2, 2, 2);
var model = new HiddenConditionalRandomField<int>(function);
var target = new QuasiNewtonHiddenLearning<int>(model);
double[] actual = new double[inputs.Length];
double[] expected = new double[inputs.Length];
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
double ll0 = model.LogLikelihood(inputs, outputs);
double error = target.RunEpoch(inputs, outputs);
double ll1 = model.LogLikelihood(inputs, outputs);
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
Assert.AreEqual(-5.5451774444795623, ll0, 1e-10);
Assert.AreEqual(3.0990811490142045, error, 1e-10);
Assert.IsFalse(double.IsNaN(error));
for (int i = 0; i < inputs.Length; i++)
Assert.AreEqual(expected[i], actual[i]);
Assert.IsTrue(ll1 > ll0);
}
public void RunTest()
{
HiddenMarkovClassifier hmm = HiddenMarkovClassifierPotentialFunctionTest.CreateModel1();
var function = new DiscreteMarkovClassifierFunction(hmm);
var model = new HiddenConditionalRandomField<int>(function);
var target = new QuasiNewtonHiddenLearning<int>(model);
double[] actual = new double[inputs.Length];
double[] expected = new double[inputs.Length];
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
for (int i = 0; i < inputs.Length; i++)
Assert.AreEqual(expected[i], actual[i]);
double ll0 = model.LogLikelihood(inputs, outputs);
double error = target.RunEpoch(inputs, outputs);
double ll1 = model.LogLikelihood(inputs, outputs);
for (int i = 0; i < inputs.Length; i++)
{
actual[i] = model.Compute(inputs[i]);
expected[i] = outputs[i];
}
Assert.AreEqual(-0.00046872579976353634, ll0, 1e-10);
Assert.AreEqual(0.00012170806701733428, error, 1e-10);
Assert.AreEqual(error, -ll1);
Assert.IsFalse(Double.IsNaN(ll0));
Assert.IsFalse(Double.IsNaN(error));
for (int i = 0; i < inputs.Length; i++)
Assert.AreEqual(expected[i], actual[i]);
Assert.IsTrue(ll1 > ll0);
}
