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 void Mu_MultivariateAndErgodicAndLogNormalized_MuCalculated() { 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 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 < NumberOfStates; 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 Estimate_ParametersPassed_PiCalculatedAndReturned() { 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 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 = observationsList, Model = model, Normalized = model.Normalized }; var gammaEstimator = new GammaEstimator <NormalDistribution>(); var estimator = new PiEstimator(); var parameters = new PiParameters { Gamma = gammaEstimator.Estimate(@params), N = model.N, Normalized = model.Normalized }; var estimatedPi = estimator.Estimate(parameters); Assert.AreEqual(1d, Math.Round(estimatedPi[0] + estimatedPi[1], 5)); }
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 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 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 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 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 Ksi_RightLeftAndNotNormalized_KsiCalculated() { 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 = 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>(); Assert.IsNotNull(estimator); for (int t = 0; t < observations.Length - 1; t++) { for (int i = 0; i < numberOfStatesRightLeft; i++) { for (int j = 0; j < numberOfStatesRightLeft; j++) { Assert.IsTrue(estimator.Estimate(@params)[t][i, j] >= 0 && estimator.Estimate(@params)[t][i, j] < 1, string.Format("Failed Ksi [{1}][{2},{3}]:{0}", estimator.Estimate(@params)[t][i, j], t, i, j)); } } } }
public void TestBackwardRun2() { 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(false); var res = algo.RunBackward(observations, HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution>() { Pi = startDistribution, TransitionProbabilityMatrix = tpm, Emissions = emissions })); //new HiddenMarkovModelState<DiscreteDistribution>(startDistribution, tpm, emissions)); Assert.AreEqual(0.25499, res); Assert.AreEqual(1, algo.Beta[3][0]); Assert.AreEqual(1, algo.Beta[3][1]); Assert.AreEqual(0.47, algo.Beta[2][0]); Assert.AreEqual(0.49, algo.Beta[2][1]); Assert.AreEqual(0.2561, algo.Beta[1][0]); Assert.AreEqual(0.2487, algo.Beta[1][1]); Assert.AreEqual(0.133143, algo.Beta[0][0]); Assert.AreEqual(0.127281, algo.Beta[0][1]); }
public void TestBackwardNormalizedRun2() { 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.RunBackward(observations, HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution>() { Pi = startDistribution, TransitionProbabilityMatrix = tpm, Emissions = emissions })); //new HiddenMarkovModelState<DiscreteDistribution>(startDistribution, tpm, emissions)); Assert.AreEqual(-1.3665309502789404, res); Assert.AreEqual(0d, algo.Beta[3][0]); Assert.AreEqual(0d, algo.Beta[3][1]); Assert.AreEqual(-0.75502258427803293, algo.Beta[2][0]); Assert.AreEqual(-0.71334988787746456, algo.Beta[2][1]); Assert.AreEqual(-1.3621872857766575, algo.Beta[1][0]); Assert.AreEqual(-1.3915079281727778, algo.Beta[1][1]); Assert.AreEqual(-2.0163315403910613, algo.Beta[0][0]); Assert.AreEqual(-2.0613580382895655, algo.Beta[0][1]); }
public void Ksi_ErgodicAndLogNormalized_KsiCalculated() { 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 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>(); Assert.IsNotNull(estimator); for (int t = 0; t < observations.Length - 1; t++) { for (int i = 0; i < NumberOfStates; i++) { for (int j = 0; j < NumberOfStates; j++) { Assert.IsTrue(estimator.Estimate(@params)[t][i, j] < 0, string.Format("Failed Ksi {0}", estimator.Estimate(@params)[t][i, j])); } } } }
public void Estimate_AlphaBetaParameters_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 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 weights = new double[observations.Length]; var estimator = new TransitionProbabilityEstimator <NormalDistribution>(); var parameters = new AlphaBetaTransitionProbabiltyMatrixParameters <NormalDistribution> { Alpha = alpha, Beta = beta, Model = model, Observations = observations, Normalized = model.Normalized, Weights = weights }; 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 void Train(double[][] observations, int numberOfIterations, double likelihoodTolerance) { if (_initialize) { Initialize(observations); } if (_pi == null || _transitionProbabilityMatrix == null || _emission == null) { throw new ApplicationException("Initialize the model with initial valuesss"); } var model = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> > { Pi = _pi, TransitionProbabilityMatrix = _transitionProbabilityMatrix, Emissions = _emission }); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(_pi, _transitionProbabilityMatrix, _emission); model.Normalized = Normalized; var alg = new BaumWelchMixtureDistribution(Helper.Convert(observations), model); var estimatedParameters = alg.Run(numberOfIterations, likelihoodTolerance); _pi = estimatedParameters.Pi; _transitionProbabilityMatrix = estimatedParameters.TransitionProbabilityMatrix; _emission = estimatedParameters.Emission; Likelihood = estimatedParameters.Likelihood; }
public void TestForwardNormalizedRun1() { 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(true); var res = algo.RunForward(observations, HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <DiscreteDistribution>() { Pi = startDistribution, TransitionProbabilityMatrix = tpm, Emissions = emissions })); //new HiddenMarkovModelState<DiscreteDistribution>(startDistribution, tpm, emissions)); // TODO : Check for Log Assert.AreEqual(-5.5614629361549142, res); }
public void Compare_AlphaBetaAndKsiGammaCalculation_EqualTransitionProbabilityMatrixes() { 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>(); var weights = new double[observations.Length]; for (var i = 0; i < observations.Length; i++) { observationsList.Add(new Observation(observations[i], i.ToString())); } 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 = observationsList, Model = model, Normalized = model.Normalized }; var gammaEstimator = new GammaEstimator <NormalDistribution>(); var ksiEstimator = new KsiEstimator <NormalDistribution>(); var estimatorKsiGamma = new TransitionProbabilityEstimator <NormalDistribution>(); var parametersKsiGamma = new KsiGammaTransitionProbabilityMatrixParameters <NormalDistribution> { Model = model, Ksi = ksiEstimator.Estimate(@params), Gamma = gammaEstimator.Estimate(@params), T = observations.Length, Normalized = model.Normalized }; var estimatorAlphaBeta = new TransitionProbabilityEstimator <NormalDistribution>(); var parametersAlphaBeta = new AlphaBetaTransitionProbabiltyMatrixParameters <NormalDistribution> { Alpha = alpha, Beta = beta, Model = model, Observations = observations, Normalized = model.Normalized, Weights = weights }; var estimatedTransitionProbabilityMatrixKsiGamma = estimatorKsiGamma.Estimate(parametersKsiGamma); var estimatedTransitionProbabilityMatrixAlphaBeta = estimatorAlphaBeta.Estimate(parametersAlphaBeta); Assert.AreEqual(Math.Round(estimatedTransitionProbabilityMatrixKsiGamma[0][0], 5), Math.Round(estimatedTransitionProbabilityMatrixAlphaBeta[0][0], 5)); Assert.AreEqual(Math.Round(estimatedTransitionProbabilityMatrixKsiGamma[0][1], 5), Math.Round(estimatedTransitionProbabilityMatrixAlphaBeta[0][1], 5)); Assert.AreEqual(Math.Round(estimatedTransitionProbabilityMatrixKsiGamma[1][0], 5), Math.Round(estimatedTransitionProbabilityMatrixAlphaBeta[1][0], 5)); Assert.AreEqual(Math.Round(estimatedTransitionProbabilityMatrixKsiGamma[1][1], 5), Math.Round(estimatedTransitionProbabilityMatrixAlphaBeta[1][1], 5)); }
public IHiddenMarkovModel <Mixture <IMultivariateDistribution> > 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 <Mixture <IMultivariateDistribution> > { Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions }); //new HiddenMarkovModelState<Mixture<IMultivariateDistribution>>(_estimatedPi, _estimatedTransitionProbabilityMatrix, _estimatedEmissions) { LogNormalized = _estimatedModel.LogNormalized }; _currentModel.Normalized = Normalized; _currentModel.Likelihood = _estimatedModel.Likelihood; } // Run Forward-Backward procedure forwardBackward.RunForward(_observations, _currentModel); forwardBackward.RunBackward(_observations, _currentModel); // Calculate Gamma and Xi var @params = new MixtureSigmaEstimationParameters <Mixture <IMultivariateDistribution> > { Alpha = forwardBackward.Alpha, Beta = forwardBackward.Beta, Observations = _observations, Model = _currentModel, Normalized = _currentModel.Normalized, L = _currentModel.Emission[0].Components.Length }; _gammaEstimator = new GammaEstimator <Mixture <IMultivariateDistribution> >(); _ksiEstimator = new KsiEstimator <Mixture <IMultivariateDistribution> >(); var mixtureCoefficientsEstimator = new MixtureCoefficientsEstimator <Mixture <IMultivariateDistribution> >(); var mixtureMuEstimator = new MixtureMuEstimator <Mixture <IMultivariateDistribution> >(); // Mean var mixtureSigmaEstimator = new MixtureSigmaEstimator <Mixture <IMultivariateDistribution> >(); // Covariance var mixtureGammaEstimator = new MixtureGammaEstimator <Mixture <IMultivariateDistribution> >(); @params.Gamma = _gammaEstimator.Estimate(@params); @params.GammaComponents = mixtureGammaEstimator.Estimate(@params); EstimatePi(_gammaEstimator.Estimate(@params)); EstimateTransitionProbabilityMatrix(_gammaEstimator.Estimate(@params), _ksiEstimator.Estimate(@params), null, _observations.Count); for (var n = 0; n < _currentModel.N; n++) { var mixturesComponents = _currentModel.Emission[n].Coefficients.Length; var distributions = new IMultivariateDistribution[mixturesComponents]; // Calculate coefficients for state n var coefficients = mixtureCoefficientsEstimator.Estimate(@params)[n]; if (Normalized) { mixtureCoefficientsEstimator.Denormalize(); } @params.Mu = mixtureMuEstimator.Estimate(@params); for (var l = 0; l < mixturesComponents; l++) { distributions[l] = new NormalDistribution(mixtureMuEstimator.Estimate(@params)[n, l], mixtureSigmaEstimator.Estimate(@params)[n, l]); } _estimatedEmissions[n] = new Mixture <IMultivariateDistribution>(coefficients, distributions); } _estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <Mixture <IMultivariateDistribution> > { 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); }