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 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 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 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(BasicEstimationParameters <TDistribution> parameters)
{
if (_beta != null)
{
return(_beta);
}
var T = parameters.Observations.Count;
try
{
_beta = new double[T][];
_beta[T - 1] = new double[parameters.Model.N];
for (var i = 0; i < parameters.Model.N; i++)
{
_beta[T - 1][i] = (parameters.Normalized) ? 0d : 1d;
}
for (var t = T - 2; t >= 0; t--)
{
_beta[t] = new double[parameters.Model.N];
for (var i = 0; i < parameters.Model.N; i++)
{
_beta[t][i] = (parameters.Normalized) ? double.NaN : 0d;
for (var j = 0; j < parameters.Model.N; j++)
{
var o = EstimatorUtilities.GetProbability(parameters.Model.Emission[j], parameters.Observations, t + 1);
if (parameters.Normalized)
{
_beta[t][i] = LogExtention.eLnSum(_beta[t][i],
LogExtention.eLnProduct(LogExtention.eLn(parameters.Model.TransitionProbabilityMatrix[i][j]),
LogExtention.eLnProduct(LogExtention.eLn(o), _beta[t + 1][j])));
}
else
{
_beta[t][i] += parameters.Model.TransitionProbabilityMatrix[i][j] * o * _beta[t + 1][j];
}
}
}
}
}
catch (Exception)
{
for (var t = T - 2; t >= 0; t--)
{
for (var i = 0; i < parameters.Model.N; i++)
{
for (var j = 0; j < parameters.Model.N; j++)
{
Debug.WriteLine("[{0}][{1}] : beta : {2}", t, i, _beta[t][i]);
}
}
}
throw;
}
return(_beta);
}
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 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 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(BasicEstimationParameters <TDistribution> parameters)
{
if (_alpha != null)
{
return(_alpha);
}
_alpha = new double[parameters.Observations.Count][];
_alpha[0] = new double[parameters.Model.N];
// Initialize
for (var i = 0; i < parameters.Model.N; i++)
{
var o = EstimatorUtilities.GetProbability(parameters.Model.Emission[i], parameters.Observations, 0);
_alpha[0][i] = (parameters.Normalized) ? LogExtention.eLnProduct(LogExtention.eLn(parameters.Model.Pi[i]), LogExtention.eLn(o)) : parameters.Model.Pi[i] * o;
}
// Induction
for (var t = 1; t < parameters.Observations.Count; t++)
{
_alpha[t] = new double[parameters.Model.N];
for (var j = 0; j < parameters.Model.N; j++)
{
var sum = (parameters.Normalized) ? double.NaN : 0d;
for (var i = 0; i < parameters.Model.N; i++)
{
if (parameters.Normalized)
{
sum = LogExtention.eLnSum(sum, LogExtention.eLnProduct(_alpha[t - 1][i], LogExtention.eLn(parameters.Model.TransitionProbabilityMatrix[i][j])));
}
else
{
sum += _alpha[t - 1][i] * parameters.Model.TransitionProbabilityMatrix[i][j];
}
}
var o = EstimatorUtilities.GetProbability(parameters.Model.Emission[j], parameters.Observations, t);
if (parameters.Normalized)
{
_alpha[t][j] = LogExtention.eLnProduct(sum, LogExtention.eLn(o));
}
else
{
_alpha[t][j] = sum * o;
}
}
}
return(_alpha);
}
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 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 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 Coefficients_RightLeftAndNotNormilized_EachEntryMatrixIsSummedToOne()
{
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 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++)
{
Assert.AreEqual(1.0d, Math.Round(coefficients.Estimate(@params)[i].Sum(), 5), string.Format("Failed Coefficients {0} at component {1}", new Vector(coefficients.Estimate(@params)[i]), i));
}
}
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 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 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());
}
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());
}
