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 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 double[][] Estimate(AdvancedEstimationParameters <TDistribution> parameters) { if (_gamma != null) { return(_gamma); } var denominator = new double[parameters.Observations.Count]; for (var t = 0; t < parameters.Observations.Count; t++) { denominator[t] = (parameters.Normalized) ? double.NaN : 0d; for (var i = 0; i < parameters.Model.N; i++) { if (parameters.Normalized) { denominator[t] = LogExtention.eLnSum(denominator[t], LogExtention.eLnProduct(parameters.Alpha[t][i], parameters.Beta[t][i])); } else { denominator[t] += parameters.Alpha[t][i] * parameters.Beta[t][i]; } } } try { _gamma = new double[parameters.Observations.Count][]; for (var t = 0; t < parameters.Observations.Count; t++) { _gamma[t] = new double[parameters.Model.N]; for (var i = 0; i < parameters.Model.N; i++) { if (parameters.Normalized) { _gamma[t][i] = LogExtention.eLnProduct(LogExtention.eLnProduct(parameters.Alpha[t][i], parameters.Beta[t][i]), -denominator[t]); } else { _gamma[t][i] = (parameters.Alpha[t][i] * parameters.Beta[t][i]) / denominator[t]; } } } } catch (Exception) { for (var t = 0; t < parameters.Observations.Count; t++) { for (var i = 0; i < parameters.Model.N; i++) { Debug.WriteLine("Gamma [{0}][{1}] : alpha : {2} , beta : {3} , denominator : {4} : gamma {5} ", t, i, parameters.Alpha[t][i], parameters.Beta[t][i], denominator[t], _gamma[t][i]); } } throw; } return(_gamma); }
public double[][,] Estimate(AdvancedEstimationParameters <TDistribution> parameters) { if (_ksi != null) { return(_ksi); } var denominator = new double[parameters.Observations.Count]; for (var t = 0; t < parameters.Observations.Count - 1; t++) { denominator[t] = (parameters.Normalized) ? double.NaN : 0d; for (var i = 0; i < parameters.Model.N; i++) { for (var j = 0; j < parameters.Model.N; j++) { var o = EstimatorUtilities.GetProbability(parameters.Model.Emission[j], parameters.Observations, t + 1); if (parameters.Normalized) { denominator[t] = LogExtention.eLnSum(denominator[t], LogExtention.eLnProduct(parameters.Alpha[t][i], LogExtention.eLnProduct(LogExtention.eLn(parameters.Model.TransitionProbabilityMatrix[i][j]), LogExtention.eLnProduct(parameters.Beta[t + 1][j], LogExtention.eLn(o))))); } else { denominator[t] += parameters.Alpha[t][i] * parameters.Model.TransitionProbabilityMatrix[i][j] * parameters.Beta[t + 1][j] * o; } } } } _ksi = new double[parameters.Observations.Count][, ]; for (var t = 0; t < parameters.Observations.Count - 1; t++) { _ksi[t] = new double[parameters.Model.N, parameters.Model.N]; for (var i = 0; i < parameters.Model.N; i++) { for (var j = 0; j < parameters.Model.N; j++) { var o = EstimatorUtilities.GetProbability(parameters.Model.Emission[j], parameters.Observations, t + 1); if (parameters.Normalized) { var nominator = LogExtention.eLnProduct(parameters.Alpha[t][i], LogExtention.eLnProduct(LogExtention.eLn(parameters.Model.TransitionProbabilityMatrix[i][j]), LogExtention.eLnProduct(parameters.Beta[t + 1][j], LogExtention.eLn(o)))); _ksi[t][i, j] = LogExtention.eLnProduct(nominator, -denominator[t]); } else { var nominator = parameters.Alpha[t][i] * parameters.Model.TransitionProbabilityMatrix[i][j] * parameters.Beta[t + 1][j] * o; _ksi[t][i, j] = nominator / denominator[t]; } } } } return(_ksi); }
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 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 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 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 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 Gamma_ErgodicAndNotNormalized_GammaCalculated() { 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) { 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>(); Assert.IsNotNull(estimator); for (int i = 0; i < observations.Length; i++) { for (int j = 0; j < NumberOfStates; j++) { Assert.IsTrue(estimator.Estimate(@params)[i][j] > 0 && estimator.Estimate(@params)[i][j] < 1, string.Format("Failed Gamma {0}, [{1}][{2}]", estimator.Estimate(@params)[i][j], i, j)); } } }
public double[][] Estimate(AdvancedEstimationParameters <TDistribution> parameters) { return(_gammaEstimator.Estimate(parameters)); }
public IHiddenMarkovModel <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 <IMultivariateDistribution> { Pi = _estimatedPi, TransitionProbabilityMatrix = _estimatedTransitionProbabilityMatrix, Emissions = _estimatedEmissions }); //new HiddenMarkovModelState<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); var @params = new AdvancedEstimationParameters <IMultivariateDistribution> { Alpha = forwardBackward.Alpha, Beta = forwardBackward.Beta, Observations = _observations, Model = _currentModel, Normalized = _currentModel.Normalized }; _gammaEstimator = new GammaEstimator <IMultivariateDistribution>(); _ksiEstimator = new KsiEstimator <IMultivariateDistribution>(); _muEstimator = new MuMultivariateEstimator <IMultivariateDistribution>(); _sigmaEstimator = new SigmaMultivariateEstimator <IMultivariateDistribution>(); EstimatePi(_gammaEstimator.Estimate(@params)); EstimateTransitionProbabilityMatrix(_gammaEstimator.Estimate(@params), _ksiEstimator.Estimate(@params), null, _observations.Count); // Estimate observation probabilities var muParams = new MuEstimationParameters <IMultivariateDistribution> { Gamma = _gammaEstimator.Estimate(@params), Model = _currentModel, Normalized = _currentModel.Normalized, Observations = _observations }; var muVector = _muEstimator.Estimate(muParams); var sigmaVector = _sigmaEstimator.Estimate(new SigmaEstimationParameters <IMultivariateDistribution, double[][]>(muParams) { Mean = muVector }); for (var n = 0; n < _currentModel.N; n++) { _estimatedEmissions[n] = new NormalDistribution(muVector[n], sigmaVector[n]); } _estimatedModel = HiddenMarkovModelStateFactory.GetState(new ModelCreationParameters <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); }
public void KsiEstimator_ABBAObservation_NotNormalizedTest() { var startDistribution = new[] { 0.85, 0.15 }; // s = 0, t = 1 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 model = HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <DiscreteDistribution>() { Pi = startDistribution, TransitionProbabilityMatrix = tpm, Emissions = emissions }); //new HiddenMarkovModel(startDistribution, tpm, emissions) { LogNormalized = false }; model.Normalized = false; var baseParameters = new BasicEstimationParameters <DiscreteDistribution> { Model = model, Observations = observations, Normalized = model.Normalized }; var alphaEstimator = new AlphaEstimator <DiscreteDistribution>(); var alpha = alphaEstimator.Estimate(baseParameters); var betaEstimator = new BetaEstimator <DiscreteDistribution>(); var beta = betaEstimator.Estimate(baseParameters); var @params = new AdvancedEstimationParameters <DiscreteDistribution> { Alpha = alpha, Beta = beta, Observations = observations, Model = model, Normalized = model.Normalized }; var ksiEstimator = new KsiEstimator <DiscreteDistribution>(); var ksi = ksiEstimator.Estimate(@params); Assert.AreEqual(0.28593281418422561, ksi[0][0, 0]); Assert.AreEqual(0.53991543690975563, ksi[0][0, 1]); Assert.AreEqual(0.021024471631193059, ksi[0][1, 0]); Assert.AreEqual(0.15312727727482567, ksi[0][1, 1]); Assert.AreEqual(1d, ksi[0].Sum()); Assert.AreEqual(0.10140018110107153, ksi[1][0, 0]); Assert.AreEqual(0.20555710471434716, ksi[1][0, 1]); Assert.AreEqual(0.0785838542018705, ksi[1][1, 0]); Assert.AreEqual(0.61445885998271088, ksi[1][1, 1]); Assert.AreEqual(1d, ksi[1].Sum()); Assert.AreEqual(0.045953370715644766, ksi[2][0, 0]); Assert.AreEqual(0.13403066458729723, ksi[2][0, 1]); Assert.AreEqual(0.06694007875078023, ksi[2][1, 0]); Assert.AreEqual(0.75307588594627772, ksi[2][1, 1]); Assert.AreEqual(1d, ksi[2].Sum()); }
public void GammaEstimator_ABBAObservations_NotNormalizedTest() { var startDistribution = new[] { 0.85, 0.15 }; // s = 0, t = 1 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 model = HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <DiscreteDistribution>() { Pi = startDistribution, TransitionProbabilityMatrix = tpm, Emissions = emissions }); //new HiddenMarkovModel(startDistribution, tpm, emissions) { LogNormalized = false }; model.Normalized = false; var baseParameters = new BasicEstimationParameters <DiscreteDistribution> { Model = model, Observations = observations, Normalized = model.Normalized }; var alphaEstimator = new AlphaEstimator <DiscreteDistribution>(); var alpha = alphaEstimator.Estimate(baseParameters); var betaEstimator = new BetaEstimator <DiscreteDistribution>(); var beta = betaEstimator.Estimate(baseParameters); var @params = new AdvancedEstimationParameters <DiscreteDistribution> { Alpha = alpha, Beta = beta, Observations = observations, Model = model }; var gammaEstimator = new GammaEstimator <DiscreteDistribution>(); var gamma = gammaEstimator.Estimate(@params); Assert.AreEqual(0.8258482510939813, gamma[0][0]); Assert.AreEqual(0.17415174890601867, gamma[0][1]); Assert.AreEqual(1d, gamma[0].Sum()); Assert.AreEqual(0.3069572858154187, gamma[1][0]); Assert.AreEqual(0.69304271418458141, gamma[1][1]); Assert.AreEqual(1d, gamma[1].Sum()); Assert.AreEqual(0.17998403530294202, gamma[2][0]); Assert.AreEqual(0.82001596469705806, gamma[2][1]); Assert.AreEqual(1d, gamma[2].Sum()); Assert.AreEqual(0.112893449466425, gamma[3][0]); Assert.AreEqual(0.887106550533575, gamma[3][1]); Assert.AreEqual(1d, gamma[2].Sum()); }