public void Ksi_ErgodicNotNormalized_EachEntryMatrixIsSummedToOne()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(NumberOfStates, CreateEmissions(observations, NumberOfStates)) { LogNormalized = true };
model.Normalized = false;
var baseParameters = new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <NormalDistribution>();
var beta = betaEstimator.Estimate(baseParameters);
var @params = new AdvancedEstimationParameters <NormalDistribution>
{
Alpha = alpha,
Beta = beta,
Observations = Helper.Convert(observations),
Model = model,
Normalized = model.Normalized
};
var estimator = new KsiEstimator <NormalDistribution>();
for (int t = 0; t < observations.Length - 1; t++)
{
Assert.AreEqual(1.0d, Math.Round(estimator.Estimate(@params)[t].Sum(), 5), string.Format("Failed Ksi [{1}] :{0}", new Matrix(estimator.Estimate(@params)[t]), t));
}
}
public void Alpha_ErgodicAndNotNormalized_AlphaCalculated()
{
const int numberOfStates = 2;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = numberOfStates, Emissions = CreateEmissions(observations, numberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(numberOfStates, CreateEmissions(observations, numberOfStates)) { LogNormalized = true };
model.Normalized = false;
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
});
Assert.IsNotNull(alpha);
for (int i = 0; i < observations.Length; i++)
{
for (int j = 0; j < numberOfStates; j++)
{
Assert.IsTrue(alpha[i][j] > 0 && alpha[i][j] < 1, string.Format("Failed Alpha [{0}][{1}] : {2}", i, j, alpha[i][j]));
}
}
}
public void TestForwardRun1()
{
var states = new List <IState> {
new State(0, "H"), new State(1, "L")
};
var startDistribution = new [] { 0.5, 0.5 };
var tpm = new double[2][];
tpm[0] = new[] { 0.5, 0.5 };
tpm[1] = new[] { 0.4, 0.6 };
var observations = new List <IObservation>
{
new Observation(new double[] { 2 }, "G"),
new Observation(new double[] { 2 }, "G"),
new Observation(new double[] { 1 }, "C"),
new Observation(new double[] { 0 }, "A")
};
var emissions = new DiscreteDistribution[2];
emissions[0] = new DiscreteDistribution(new double[] { 0, 1, 2, 3 }, new[] { 0.2, 0.3, 0.3, 0.2 });
emissions[1] = new DiscreteDistribution(new double[] { 0, 1, 2, 3 }, new[] { 0.3, 0.2, 0.2, 0.3 });
var algo = new ForwardBackward(false);
var res = algo.RunForward(observations, HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution>()
{
Pi = startDistribution, TransitionProbabilityMatrix = tpm, Emissions = emissions
})); //new HiddenMarkovModelState<DiscreteDistribution>(startDistribution, tpm, emissions));
Assert.AreEqual(0.0038431500000000005, res);
}
public void TestForwardNormalizedRun2()
{
var states = new List <IState> {
new State(0, "s"), new State(1, "t")
};
var startDistribution = new [] { 0.85, 0.15 };
var tpm = new double[2][];
tpm[0] = new [] { 0.3, 0.7 };
tpm[1] = new [] { 0.1, 0.9 };
var observations = new List <IObservation>
{
new Observation(new double[] { 0 }, "A"),
new Observation(new double[] { 1 }, "B"),
new Observation(new double[] { 1 }, "B"),
new Observation(new double[] { 0 }, "A")
};
var emissions = new DiscreteDistribution[2];
emissions[0] = new DiscreteDistribution(new double[] { 0, 1 }, new[] { 0.4, 0.6 });
emissions[1] = new DiscreteDistribution(new double[] { 0, 1 }, new[] { 0.5, 0.5 });
var algo = new ForwardBackward(true);
var res = algo.RunForward(observations, HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution>()
{
Pi = startDistribution, TransitionProbabilityMatrix = tpm, Emissions = emissions
})); //new HiddenMarkovModelState<DiscreteDistribution>(startDistribution, tpm, emissions));
Assert.AreEqual(-2.9037969640415056, res);
}
public void Gamma_RightLeftNotNormalized_EachEntryMatrixIsSummedToOne()
{
var delta = 3;
var numberOfStatesRightLeft = 4;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = numberOfStatesRightLeft, Delta = delta, Emissions = CreateEmissions(observations, numberOfStatesRightLeft)
}); //new HiddenMarkovModelState<NormalDistribution>(numberOfStatesRightLeft, delta, CreateEmissions(observations, numberOfStatesRightLeft)) { LogNormalized = false };
model.Normalized = false;
var baseParameters = new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <NormalDistribution>();
var beta = betaEstimator.Estimate(baseParameters);
var @params = new AdvancedEstimationParameters <NormalDistribution>
{
Alpha = alpha,
Beta = beta,
Observations = Helper.Convert(observations),
Model = model,
Normalized = model.Normalized
};
var estimator = new GammaEstimator <NormalDistribution>();
for (int i = 0; i < observations.Length; i++)
{
Assert.AreEqual(1.0d, Math.Round(estimator.Estimate(@params)[i].Sum(), 5), string.Format("Failed Gamma Component [{1}] : {0}", estimator.Estimate(@params)[i], i));
}
}
public void GammaComponents_ErgodicNotNormalized_EachEntryMatrixIsSummedToOne()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates, NumberOfComponents)
}); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(NumberOfStates, CreateEmissions(observations, NumberOfStates, NumberOfComponents)) { LogNormalized = false };
model.Normalized = false;
var baseParameters = new BasicEstimationParameters <Mixture <IMultivariateDistribution> > {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <Mixture <IMultivariateDistribution> >();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <Mixture <IMultivariateDistribution> >();
var beta = betaEstimator.Estimate(baseParameters);
var estimator = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >();
var @params = new MixtureAdvancedEstimationParameters <Mixture <IMultivariateDistribution> >
{
Alpha = alpha,
Beta = beta,
L = model.Emission[0].Components.Length,
Model = model,
Normalized = model.Normalized,
Observations = Helper.Convert(observations)
};
var gammaComponents = estimator.Estimate(@params);
for (int t = 0; t < observations.Length; t++)
{
Assert.AreEqual(1.0d, Math.Round(gammaComponents[t].Sum(), 5), string.Format("Failed Gamma Components {0} at time {1}", new Matrix(gammaComponents[t]), t));
}
}
public BaumWelch(IList <IObservation> observations, IHiddenMarkovModel <DiscreteDistribution> model, IList <IObservation> symbols) : base(model)
{
_currentModel = model;
_observations = observations;
_discreteSymbols = new double[_currentModel.M];
_discreteObservations = new double[_observations.Count];
for (var i = 0; i < _currentModel.M; i++)
{
_discreteSymbols[i] = symbols[i].Value[0];
}
for (var i = 0; i < _observations.Count; i++)
{
_discreteObservations[i] = observations[i].Value[0];
}
_estimatedEmissions = new DiscreteDistribution[_currentModel.N];
for (var i = 0; i < _currentModel.N; i++)
{
_estimatedEmissions[i] = new DiscreteDistribution(_discreteSymbols, _discreteObservations);
}
_estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution> {
Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions
}); //new HiddenMarkovModelState<DiscreteDistribution>(_estimatedPi, _estimatedTransitionProbabilityMatrix, _estimatedEmissions);
Normalized = model.Normalized;
}
public void Beta_ErgodicLogNormalized_BetaCalculated()
{
const int numberOfStates = 2;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = numberOfStates, Emissions = CreateEmissions(observations, numberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(numberOfStates, CreateEmissions(observations, numberOfStates)) { LogNormalized = true };
model.Normalized = true;
var estimator = new BetaEstimator <NormalDistribution>();
var beta = estimator.Estimate(new BasicEstimationParameters <NormalDistribution>()
{
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
});
Assert.IsNotNull(beta);
for (int i = 0; i < observations.Length - 1; i++)
{
for (int j = 0; j < numberOfStates; j++)
{
Assert.IsTrue(beta[i][j] < 0, string.Format("Failed Beta [{0}][{1}] : {2}", i, j, beta[i][j]));
}
}
// Last observation has probability == 1
Assert.IsTrue(beta[observations.Length - 1][0] == 0);
Assert.IsTrue(beta[observations.Length - 1][1] == 0);
}
public void MixtureGammaEstimator_Parameters_MixtureGammaComponentsAndGammaInitialized()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates, NumberOfComponents)
}); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(NumberOfStates, CreateEmissions(observations, NumberOfStates, NumberOfComponents)) { LogNormalized = true };
model.Normalized = true;
var baseParameters = new BasicEstimationParameters <Mixture <IMultivariateDistribution> > {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <Mixture <IMultivariateDistribution> >();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <Mixture <IMultivariateDistribution> >();
var beta = betaEstimator.Estimate(baseParameters);
var gamma = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >();
var @params = new MixtureAdvancedEstimationParameters <Mixture <IMultivariateDistribution> >
{
Alpha = alpha,
Beta = beta,
L = model.Emission[0].Components.Length,
Model = model,
Normalized = model.Normalized,
Observations = Helper.Convert(observations)
};
Assert.IsNotNull(gamma.Estimate(@params as AdvancedEstimationParameters <Mixture <IMultivariateDistribution> >));
Assert.IsNotNull(gamma.Estimate(@params));
}
public void GetState_DiscreteDistributionParameters_DiscreteDistributionStateCreated()
{
var parameters = new ModelCreationParameters <DiscreteDistribution>()
{
NumberOfStates = NumberOfStates
};
var model = HiddenMarkovModelStateFactory.GetState(parameters);
Assert.IsInstanceOfType(model, typeof(HiddenMarkovModel <DiscreteDistribution>));
}
public void GetState_UnivariateAndNormalDistributionParameters_UnivariateAndNormalDistributionStateCreated()
{
var parameters = new ModelCreationParameters <HmmDotNet.Statistics.Distributions.Univariate.NormalDistribution>()
{
NumberOfStates = NumberOfStates
};
var model = HiddenMarkovModelStateFactory.GetState(parameters);
Assert.IsInstanceOfType(model, typeof(HiddenMarkovModel <HmmDotNet.Statistics.Distributions.Univariate.NormalDistribution>));
}
public void GetState_MixtureWithIMultivariateDistributionParameters_MixtureWithIMultivariateDistributionStateCreated()
{
var parameters = new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStates
};
var model = HiddenMarkovModelStateFactory.GetState(parameters);
Assert.IsInstanceOfType(model, typeof(HiddenMarkovModel <Mixture <IMultivariateDistribution> >));
}
public void Sigma_ErgodicAndObservationAndLogNormalized_SigmaCalculated()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var sequence = Helper.Convert(observations);
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(NumberOfStates, CreateEmissions(observations, NumberOfStates)) { LogNormalized = true };
model.Normalized = true;
var baseParameters = new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = sequence, Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <NormalDistribution>();
var beta = betaEstimator.Estimate(baseParameters);
var @params = new AdvancedEstimationParameters <NormalDistribution>
{
Alpha = alpha,
Beta = beta,
Observations = sequence,
Model = model
};
var gammaEstimator = new GammaEstimator <NormalDistribution>();
var muEstimator = new MuMultivariateEstimator <NormalDistribution>();
var estimator = new SigmaMultivariateEstimator <NormalDistribution>();
var muParams = new MuEstimationParameters <NormalDistribution>
{
Gamma = gammaEstimator.Estimate(@params),
Model = model,
Normalized = model.Normalized,
Observations = Helper.Convert(observations)
};
Assert.IsNotNull(estimator);
var sigma = estimator.Estimate(new SigmaEstimationParameters <NormalDistribution, double[][]>(muParams)
{
Mean = muEstimator.Estimate(muParams)
});
for (int n = 0; n < NumberOfStates; n++)
{
for (int i = 0; i < sequence[0].Dimention; i++)
{
for (int j = 0; j < sequence[0].Dimention; j++)
{
Assert.IsTrue(sigma[n][i, j] > 0, string.Format("Failed Sigma {0}", sigma[n][i, j]));
}
}
}
}
public void TestInitialized()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(NumberOfStates, CreateEmissions(observations, NumberOfStates)) { LogNormalized = true };
model.Normalized = true;
}
public void Sigma_RightLeftAndParametersAnnNotNormalized_SigmaCalculated()
{
var delta = 3;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStatesRightLeft, Delta = delta, Emissions = CreateEmissions(observations, NumberOfStatesRightLeft, NumberOfComponents)
}); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(NumberOfStatesRightLeft, delta, CreateEmissions(observations, NumberOfStatesRightLeft, NumberOfComponents)) { LogNormalized = false };
model.Normalized = false;
var baseParameters = new BasicEstimationParameters <Mixture <IMultivariateDistribution> > {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <Mixture <IMultivariateDistribution> >();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <Mixture <IMultivariateDistribution> >();
var beta = betaEstimator.Estimate(baseParameters);
var parameters = new ParameterEstimations <Mixture <IMultivariateDistribution> >(model, Helper.Convert(observations), alpha, beta);
var sigma = new MixtureSigmaEstimator <Mixture <IMultivariateDistribution> >();
var mixtureGammaEstimator = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >();
var mixtureMuEstimator = new MixtureMuEstimator <Mixture <IMultivariateDistribution> >();
var @params = new MixtureSigmaEstimationParameters <Mixture <IMultivariateDistribution> >
{
Model = model,
Normalized = model.Normalized,
Alpha = alpha,
Beta = beta,
Observations = Helper.Convert(observations),
L = model.Emission[0].Components.Length
};
var gamma = mixtureGammaEstimator.Estimate(@params as AdvancedEstimationParameters <Mixture <IMultivariateDistribution> >);
var gammaComponens = mixtureGammaEstimator.Estimate(@params);
@params.Gamma = gamma;
@params.GammaComponents = gammaComponens;
@params.Mu = mixtureMuEstimator.Estimate(@params);
for (int i = 0; i < NumberOfStatesRightLeft; i++)
{
for (int l = 0; l < NumberOfComponents; l++)
{
for (int rows = 0; rows < parameters.Observation[0].Dimention; rows++)
{
for (int cols = 0; cols < parameters.Observation[0].Dimention; cols++)
{
Assert.IsTrue(sigma.Estimate(@params)[i, l][rows, cols] > 0, string.Format("Failed Sigma {0}", sigma.Estimate(@params)[i, l][rows, cols]));
}
}
}
}
}
public void Denormalized_NormalizedEstimator_SigmaDenormalized()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates, NumberOfComponents)
}); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(NumberOfStates, CreateEmissions(observations, NumberOfStates, NumberOfComponents)) { LogNormalized = true };
model.Normalized = true;
var baseParameters = new BasicEstimationParameters <Mixture <IMultivariateDistribution> > {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <Mixture <IMultivariateDistribution> >();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <Mixture <IMultivariateDistribution> >();
var beta = betaEstimator.Estimate(baseParameters);
var parameters = new ParameterEstimations <Mixture <IMultivariateDistribution> >(model, Helper.Convert(observations), alpha, beta);
var coefficients = new MixtureCoefficientsEstimator <Mixture <IMultivariateDistribution> >();
var mixtureGammaEstimator = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >();
var @params = new MixtureCoefficientEstimationParameters <Mixture <IMultivariateDistribution> >
{
Model = model,
Normalized = model.Normalized,
Alpha = alpha,
Beta = beta,
Observations = Helper.Convert(observations),
L = model.Emission[0].Components.Length
};
var gamma = mixtureGammaEstimator.Estimate(@params as AdvancedEstimationParameters <Mixture <IMultivariateDistribution> >);
var gammaComponens = mixtureGammaEstimator.Estimate(@params);
@params.Gamma = gamma;
@params.GammaComponents = gammaComponens;
for (int i = 0; i < NumberOfStates; i++)
{
for (int l = 0; l < NumberOfComponents; l++)
{
Assert.IsTrue(coefficients.Estimate(@params)[i][l] < 0, string.Format("Failed Coefficients {0}", coefficients.Estimate(@params)[i][l]));
}
}
coefficients.Denormalize();
for (int i = 0; i < NumberOfStates; i++)
{
for (int l = 0; l < NumberOfComponents; l++)
{
Assert.IsTrue(coefficients.Estimate(@params)[i][l] > 0 && coefficients.Estimate(@params)[i][l] < 1, string.Format("Failed Coefficients {0}", coefficients.Estimate(@params)[i][l]));
}
}
}
public void Estimate_KsiGammaParameters_TransitionProbabilityMatrixCalculatedAndReturned()
{
const int numberOfStates = 2;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = numberOfStates, Emissions = CreateEmissions(observations, numberOfStates)
});
model.Normalized = true;
var observationsList = new List <IObservation>();
for (var i = 0; i < observations.Length; i++)
{
observationsList.Add(new Observation(observations[i], i.ToString()));
}
var baseEstimator = new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(baseEstimator);
var betaEstimator = new BetaEstimator <NormalDistribution>();
var beta = betaEstimator.Estimate(baseEstimator);
var @params = new AdvancedEstimationParameters <NormalDistribution>
{
Alpha = alpha,
Beta = beta,
Observations = observationsList,
Model = model,
Normalized = model.Normalized
};
var gammaEstimator = new GammaEstimator <NormalDistribution>();
var ksiEstimator = new KsiEstimator <NormalDistribution>();
var gamma = gammaEstimator.Estimate(@params);
var ksi = ksiEstimator.Estimate(@params);
var estimator = new TransitionProbabilityEstimator <NormalDistribution>();
var parameters = new KsiGammaTransitionProbabilityMatrixParameters <NormalDistribution>
{
Model = model,
Ksi = ksi,
Gamma = gamma,
T = observations.Length,
Normalized = model.Normalized
};
var estimatedTransitionProbabilityMatrix = estimator.Estimate(parameters);
Assert.AreEqual(1d, Math.Round(estimatedTransitionProbabilityMatrix[0][0] + estimatedTransitionProbabilityMatrix[0][1], 5));
Assert.AreEqual(1d, Math.Round(estimatedTransitionProbabilityMatrix[1][0] + estimatedTransitionProbabilityMatrix[1][1], 5));
}
public IHiddenMarkovModel <DiscreteDistribution> Run(int maxIterations, double likelihoodTolerance)
{
// Initialize responce object
var forwardBackward = new ForwardBackward(Normalized);
do
{
maxIterations--;
if (!_estimatedModel.Likelihood.EqualsTo(0))
{
_currentModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution> {
Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions
}); //new HiddenMarkovModelState<DiscreteDistribution>(_estimatedPi, _estimatedTransitionProbabilityMatrix, _estimatedEmissions);
_currentModel.Normalized = Normalized;
_currentModel.Likelihood = _estimatedModel.Likelihood;
}
// Run Forward-Backward procedure
forwardBackward.RunForward(_observations, _currentModel);
forwardBackward.RunBackward(_observations, _currentModel);
var @params = new AdvancedEstimationParameters <DiscreteDistribution>
{
Alpha = forwardBackward.Alpha,
Beta = forwardBackward.Beta,
Observations = _observations,
Model = _currentModel,
Normalized = _currentModel.Normalized
};
_gammaEstimator = new GammaEstimator <DiscreteDistribution>();
_ksiEstimator = new KsiEstimator <DiscreteDistribution>();
// Estimate transition probabilities and start distribution
EstimatePi(_gammaEstimator.Estimate(@params));
EstimateTransitionProbabilityMatrix(_gammaEstimator.Estimate(@params), _ksiEstimator.Estimate(@params), null, _observations.Count);
// Estimate Emmisions
for (var j = 0; j < _currentModel.N; j++)
{
_estimatedEmissions[j] = (DiscreteDistribution)_estimatedEmissions[j].Evaluate(_discreteObservations, _discreteSymbols, _gammaEstimator.Estimate(@params).GetColumn(j), Normalized);
}
_estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution> {
Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions
});
_estimatedModel.Normalized = Normalized;
_estimatedModel.Likelihood = forwardBackward.RunForward(_observations, _estimatedModel);
_likelihoodDelta = Math.Abs(Math.Abs(_currentModel.Likelihood) - Math.Abs(_estimatedModel.Likelihood));
Debug.WriteLine("Iteration {3} , Current {0}, Estimate {1} Likelihood delta {2}", _currentModel.Likelihood, _estimatedModel.Likelihood, _likelihoodDelta, maxIterations);
}while (_currentModel != _estimatedModel && maxIterations > 0 && _likelihoodDelta > likelihoodTolerance);
return(_estimatedModel);
}
public void SigmaEstimator_ModelAndObservations_SigmaEstimatorCreated()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates)
}); //new HiddenMarkovModelState<NormalDistribution>(NumberOfStates, CreateEmissions(observations, NumberOfStates)) { LogNormalized = true };
model.Normalized = true;
var estimator = new SigmaMultivariateEstimator <NormalDistribution>();
Assert.IsNotNull(estimator);
}
public void Mu_MultivariateAndRightLeftAndNotNormalized_MuCalculated()
{
var delta = 3;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var sequence = Helper.Convert(observations);
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = NumberOfStatesRightLeft, Delta = delta, Emissions = CreateEmissions(observations, NumberOfStatesRightLeft)
}); //new HiddenMarkovModelState<NormalDistribution>(NumberOfStatesRightLeft, delta, CreateEmissions(observations, NumberOfStatesRightLeft)) { LogNormalized = false };
model.Normalized = false;
var baseParameters = new BasicEstimationParameters <NormalDistribution> {
Model = model, Observations = sequence, Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <NormalDistribution>();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <NormalDistribution>();
var beta = betaEstimator.Estimate(baseParameters);
var @params = new AdvancedEstimationParameters <NormalDistribution>
{
Alpha = alpha,
Beta = beta,
Observations = sequence,
Model = model
};
var gammaEstimator = new GammaEstimator <NormalDistribution>();
var estimator = new MuMultivariateEstimator <NormalDistribution>();
var muParams = new MuEstimationParameters <NormalDistribution>
{
Gamma = gammaEstimator.Estimate(@params),
Model = model,
Normalized = model.Normalized,
Observations = sequence
};
Assert.IsNotNull(estimator);
var mu = estimator.Estimate(muParams);
for (int i = 0; i < NumberOfStatesRightLeft; i++)
{
for (int j = 0; j < sequence[0].Dimention; j++)
{
Assert.IsTrue(mu[i][j] > 0, string.Format("Failed Mu {0}", mu[i][j]));
}
}
}
public void HiddenMarkovModelState_NumberOfStateGreaterThanZero_ErgodicModelCreated()
{
var modelState = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = 4
}); //new HiddenMarkovModelState<IDistribution>(4);
Assert.AreEqual(ModelType.Ergodic, modelState.Type);
Assert.AreEqual(1, modelState.TransitionProbabilityMatrix[0].Sum());
Assert.AreEqual(1, modelState.TransitionProbabilityMatrix[1].Sum());
Assert.AreEqual(1, modelState.TransitionProbabilityMatrix[2].Sum());
Assert.AreEqual(1, modelState.TransitionProbabilityMatrix[3].Sum());
Assert.AreEqual(1, modelState.Pi.Sum());
}
public BaumWelchMultivariateDistribution(IList <IObservation> observations, IHiddenMarkovModel <IMultivariateDistribution> model) : base(model)
{
_currentModel = model;
_observations = observations;
_estimatedEmissions = new IMultivariateDistribution[model.N];
for (var i = 0; i < model.N; i++)
{
_estimatedEmissions[i] = new NormalDistribution(0);
}
_estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <IMultivariateDistribution> {
Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions
}); //new HiddenMarkovModelState<IMultivariateDistribution>(_estimatedPi, _estimatedTransitionProbabilityMatrix, _estimatedEmissions);
Normalized = _estimatedModel.Normalized = model.Normalized;
}
public IPredictionResult Predict(double[][] observations, double[] weights)
{
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution> {
Pi = _pi, TransitionProbabilityMatrix = _transitionProbabilityMatrix, Emissions = _emission
}); //new HiddenMarkovModelState<IMultivariateDistribution>(_pi, _transitionProbabilityMatrix, _emission);
var request = new PredictionRequest();
request.TrainingSet = observations;
request.NumberOfDays = 1;
request.Tolerance = 0.01;
var predictor = new LikelihoodBasedPredictor();
return(predictor.Predict((IHiddenMarkovModel <IDistribution>)model, request));
}
public void BetaEstimator_ModelAndObservations_BetaEstimatorCreated()
{
const int numberOfStates = 2;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = numberOfStates
}); //new HiddenMarkovModelState<NormalDistribution>(numberOfStates) { LogNormalized = true };
model.Normalized = true;
var estimator = new BetaEstimator <NormalDistribution>();
Assert.IsNotNull(estimator);
}
public void Mu_ErgodicAndLogNormalized_MuCalculated()
{
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStates, Emissions = CreateEmissions(observations, NumberOfStates, NumberOfComponents)
}); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(NumberOfStates, CreateEmissions(observations, NumberOfStates, NumberOfComponents)) { LogNormalized = true };
model.Normalized = true;
var baseParameters = new BasicEstimationParameters <Mixture <IMultivariateDistribution> > {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <Mixture <IMultivariateDistribution> >();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <Mixture <IMultivariateDistribution> >();
var beta = betaEstimator.Estimate(baseParameters);
var mu = new MixtureMuEstimator <Mixture <IMultivariateDistribution> >();
var mixtureGammaEstimator = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >();
var @params = new MixtureCoefficientEstimationParameters <Mixture <IMultivariateDistribution> >
{
Model = model,
Normalized = model.Normalized,
Alpha = alpha,
Beta = beta,
Observations = Helper.Convert(observations),
L = model.Emission[0].Components.Length
};
var gamma = mixtureGammaEstimator.Estimate(@params as AdvancedEstimationParameters <Mixture <IMultivariateDistribution> >);
var gammaComponens = mixtureGammaEstimator.Estimate(@params);
@params.Gamma = gamma;
@params.GammaComponents = gammaComponens;
for (int i = 0; i < NumberOfStates; i++)
{
for (int l = 0; l < NumberOfComponents; l++)
{
for (int d = 0; d < observations[0].Length; d++)
{
Assert.IsTrue(mu.Estimate(@params)[i, l][d] > 0, string.Format("Failed Mu {0}", mu.Estimate(@params)[i, l][d]));
}
}
}
}
public void HiddenMarkovModelState_CustomModelParametersPassed_ModelTypeIsCustom()
{
var pi = new double[] { 1d / 3d, 1d / 3d, 1d / 3d, 0 };
var tpm = new double[4][];
tpm[0] = new double[] { 1d / 3d, 1d / 3d, 1d / 3d, 0 };
tpm[1] = new double[] { 1d / 4d, 1d / 4d, 1d / 4d, 1d / 4d };
tpm[2] = new double[] { 1d / 3d, 1d / 3d, 1d / 3d, 0 };
tpm[3] = new double[] { 1d / 4d, 1d / 4d, 1d / 4d, 1d / 4d };
var modelState = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
Pi = pi, TransitionProbabilityMatrix = tpm, Emissions = new NormalDistribution[4]
}); //new HiddenMarkovModelState<IDistribution>(pi, tpm, new IDistribution[4]);
Assert.AreEqual(ModelType.Custom, modelState.Type);
}
public BaumWelchMixtureDistribution(IList <IObservation> observations, IHiddenMarkovModel <Mixture <IMultivariateDistribution> > model) : base(model)
{
_observations = observations;
_currentModel = model;
_estimatedEmissions = new Mixture <IMultivariateDistribution> [_currentModel.N];
for (var i = 0; i < model.N; i++)
{
// BUG : Update emmisions from model. Don't create new ones.
_estimatedEmissions[i] = new Mixture <IMultivariateDistribution>(model.Emission[0].Components.Length, model.Emission[0].Dimension);
}
_estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> > {
Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions
}); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(_estimatedPi, _estimatedTransitionProbabilityMatrix, _estimatedEmissions);
Normalized = _estimatedModel.Normalized = model.Normalized;
}
public void HiddenMarkovModelState_NumberOfStateAndDeltaGreaterThanZero_LeftRightModelCreated()
{
var modelState = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <NormalDistribution>()
{
NumberOfStates = 4, Delta = 2
}); //new HiddenMarkovModelState<IDistribution>(4, 2);
Assert.AreEqual(ModelType.LeftRight, modelState.Type);
Assert.AreEqual(1, modelState.TransitionProbabilityMatrix[0].Sum());
Assert.AreEqual(1, modelState.TransitionProbabilityMatrix[1].Sum());
Assert.AreEqual(1, modelState.TransitionProbabilityMatrix[2].Sum());
Assert.AreEqual(1, modelState.TransitionProbabilityMatrix[3].Sum());
Assert.AreEqual(1, modelState.Pi.Sum());
Assert.AreEqual(1, modelState.Pi[0]);
}
public void GammaComponents_RightLeftAndNotNormalized_GammaComponentsCalculated()
{
var delta = 3;
var util = new TestDataUtils();
var observations = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 11, 18), new DateTime(2011, 12, 18));
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> >()
{
NumberOfStates = NumberOfStatesRightLeft, Delta = delta, Emissions = CreateEmissions(observations, NumberOfStatesRightLeft, NumberOfComponents)
}); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(NumberOfStatesRightLeft, delta, CreateEmissions(observations, NumberOfStatesRightLeft, NumberOfComponents)) { LogNormalized = false };
model.Normalized = false;
var baseParameters = new BasicEstimationParameters <Mixture <IMultivariateDistribution> > {
Model = model, Observations = Helper.Convert(observations), Normalized = model.Normalized
};
var alphaEstimator = new AlphaEstimator <Mixture <IMultivariateDistribution> >();
var alpha = alphaEstimator.Estimate(baseParameters);
var betaEstimator = new BetaEstimator <Mixture <IMultivariateDistribution> >();
var beta = betaEstimator.Estimate(baseParameters);
var estimator = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >();
Assert.IsNotNull(estimator);
var @params = new MixtureAdvancedEstimationParameters <Mixture <IMultivariateDistribution> >
{
Alpha = alpha,
Beta = beta,
L = model.Emission[0].Components.Length,
Model = model,
Normalized = model.Normalized,
Observations = Helper.Convert(observations)
};
var gammaComponents = estimator.Estimate(@params);
for (int t = 0; t < observations.Length; t++)
{
for (int i = 0; i < NumberOfStatesRightLeft; i++)
{
for (int l = 0; l < NumberOfComponents; l++)
{
Assert.IsTrue(gammaComponents[t][i, l] >= 0 && gammaComponents[t][i, l] < 1, string.Format("Failed Gamma Components {0}, [{1}][{2},{3}]", gammaComponents[t][i, l], t, i, l));
}
}
}
}
public void Train(double[] observations)
{
if (_pi == null || _transitionProbabilityMatrix == null || _emission == null)
{
throw new ApplicationException("Initialize the model with initial valuesss");
}
var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution> {
Pi = _pi, TransitionProbabilityMatrix = _transitionProbabilityMatrix, Emissions = _emission
}); //new HiddenMarkovModelState<DiscreteDistribution>(_pi, _transitionProbabilityMatrix, _emission);
model.Normalized = Normalized;
var alg = new BaumWelch(Helper.Convert(observations), model, Helper.Convert(observations));
var estimatedParameters = alg.Run(100, 20);
_pi = estimatedParameters.Pi;
_transitionProbabilityMatrix = estimatedParameters.TransitionProbabilityMatrix;
_emission = estimatedParameters.Emission;
Likelihood = estimatedParameters.Likelihood;
}
