public double[] Estimate(MuEstimationParameters <TDistribution> parameters)
{
if (_muUnivariate != null)
{
return(_muUnivariate);
}
_muUnivariate = new double[parameters.Model.N];
for (var n = 0; n < parameters.Model.N; n++)
{
var T = parameters.Observations.Count;
var mean = 0d;
var nK = 0d;
for (var t = 0; t < T; t++)
{
if (parameters.Model.Normalized)
{
nK += LogExtention.eExp(parameters.Gamma[t][n]);
mean += parameters.Observations[t].Value[0] * LogExtention.eExp(parameters.Gamma[t][n]);
}
else
{
nK += parameters.Gamma[t][n];
mean += parameters.Observations[t].Value[0] * parameters.Gamma[t][n];
}
}
_muUnivariate[n] = mean / nK;
}
return(_muUnivariate);
}
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 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 double[][] Estimate(MuEstimationParameters <TDistribution> parameters)
{
if (_muMultivariate != null)
{
return(_muMultivariate);
}
try
{
_muMultivariate = new double[parameters.Model.N][];
var K = parameters.Observations[0].Dimention; // Number of dimentions
var T = parameters.Observations.Count;
for (var n = 0; n < parameters.Model.N; n++)
{
var mean = new double[K];
var nK = 0d;
for (var t = 0; t < T; t++)
{
if (parameters.Model.Normalized)
{
nK += LogExtention.eExp(parameters.Gamma[t][n]);
mean = mean.Add(parameters.Observations[t].Value.Product(LogExtention.eExp(parameters.Gamma[t][n])));
}
else
{
nK += parameters.Gamma[t][n];
mean = mean.Add(parameters.Observations[t].Value.Product(parameters.Gamma[t][n]));
}
}
_muMultivariate[n] = mean.Product(1 / nK);
Debug.WriteLine(string.Format("HMM State {0} : Mu {1}", n, new Vector(_muMultivariate[n])));
}
}
catch (Exception)
{
for (var n = 0; n < parameters.Model.N; n++)
{
Debug.WriteLine(string.Format("HMM State {0} : Mu {1}", n, new Vector(_muMultivariate[n])));
}
throw;
}
return(_muMultivariate);
}
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);
}
