public IDistribution Evaluate(double[] observations, double[] symbols, double[] gamma)
{
var M = symbols.Length;
var T = observations.Length;
var probabilities = new double[M];
for (var k = 0; k < M; k++)
{
double den = 0, num = 0;
for (var t = 0; t < T; t++)
{
if (observations[t] == symbols[k])
{
num = num + gamma[t];
}
den = den + gamma[t];
}
probabilities[k] = 1e-10;
if (num.EqualsToZero())
{
probabilities[k] = den.EqualsToZero() ? 0.0 : LogExtention.eExp(LogExtention.eLnProduct(num, -den));
}
}
return(new DiscreteDistributionNormalized(symbols, probabilities));
}
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 eExp_XisNumber_ePowerXReturned()
{
var x = 1d;
var result = LogExtention.eExp(x);
Assert.AreEqual(Math.E, result);
}
public void eExp_XisNaN_ZeroReturned()
{
var x = double.NaN;
var result = LogExtention.eExp(x);
Assert.AreEqual(0, result);
}
private double CalculateTransitionProbabilityMatrixEntry(double nominator, double denominator, bool normalized)
{
if (denominator.EqualsToZero())
{
return(0);
}
return((normalized) ? LogExtention.eExp(LogExtention.eLnProduct(nominator, -denominator)) : nominator / denominator);
}
public double[][,] Estimate(SigmaEstimationParameters <TDistribution, double[][]> parameters)
{
if (_sigmaMultivariate != null)
{
return(_sigmaMultivariate);
}
try
{
_sigmaMultivariate = new double[parameters.Model.N][, ];
var K = parameters.Observations[0].Dimention;
var T = parameters.Observations.Count;
for (var n = 0; n < parameters.Model.N; n++)
{
var covariance = new double[K, K];
var nK = 0d;
for (var t = 0; t < T; t++)
{
var x = parameters.Observations[t].Value;
var z = x.Substruct(parameters.Mean[n]);
var m = z.OuterProduct(z);
if (parameters.Model.Normalized)
{
nK += LogExtention.eExp(parameters.Gamma[t][n]);
m = m.Product(LogExtention.eExp(parameters.Gamma[t][n]));
}
else
{
nK += parameters.Gamma[t][n];
m = m.Product(parameters.Gamma[t][n]);
}
covariance = covariance.Add(m);
}
_sigmaMultivariate[n] = covariance.Product(1 / nK);
var matrix = new Matrix(_sigmaMultivariate[n]);
if (!matrix.PositiviDefinite)
{
_sigmaMultivariate[n] = matrix.ConvertToPositiveDefinite();
Debug.WriteLine("HMM State {0} Sigma is not Positive Definite. Converting.", n);
Debug.WriteLine("{0}", matrix);
}
Debug.WriteLine("HMM State {0} Sigma : {1}", n, new Matrix(_sigmaMultivariate[n]));
}
}
catch (Exception)
{
for (var n = 0; n < parameters.Model.N; n++)
{
Debug.WriteLine("HMM State {0} Sigma : {1}", n, new Matrix(_sigmaMultivariate[n]));
}
throw;
}
return(_sigmaMultivariate);
}
public double[, ][,] Estimate(MixtureSigmaEstimationParameters <TDistribution> parameters)
{
if (_sigma != null)
{
return(_sigma);
}
try
{
_sigma = new double[parameters.Model.N, parameters.L][, ];
for (var i = 0; i < parameters.Model.N; i++)
{
for (var l = 0; l < parameters.L; l++)
{
var denominator = 0.0d;
var nominator = new double[parameters.Observations[0].Dimention, parameters.Observations[0].Dimention];
for (var t = 0; t < parameters.Observations.Count; t++)
{
// TODO : weights here
var weight = GetWeightValue(t, parameters.ObservationWeights);
var gammaComponents = (parameters.Model.Normalized) ? LogExtention.eExp(parameters.GammaComponents[t][i, l]) : parameters.GammaComponents[t][i, l];
var x = parameters.Observations[t].Value;
var z = x.Substruct(parameters.Mu[i, l]);
var m = z.OuterProduct(z);
m = m.Product(weight * gammaComponents);
denominator += weight * gammaComponents;
nominator = nominator.Add(m);
}
_sigma[i, l] = nominator.Product(1 / denominator);
var matrix = new Matrix(_sigma[i, l]);
if (!matrix.PositiviDefinite)
{
_sigma[i, l] = matrix.ConvertToPositiveDefinite();
Debug.WriteLine("HMM State [{0},{1}] Sigma is not Positive Definite. Converting.", i, l);
Debug.WriteLine("{0}", matrix);
}
}
}
}
catch (Exception)
{
for (var i = 0; i < parameters.Model.N; i++)
{
for (var l = 0; l < parameters.L; l++)
{
Debug.WriteLine("Mixture Sigma [{0},{1}] : {2}", i, l, new Matrix(_sigma[i, l]));
}
}
throw;
}
return(_sigma);
}
protected void EstimatePi(double[][] gamma)
{
var checksum = 0d;
for (var i = 0; i < _model.N; i++)
{
_estimatedPi[i] = (_model.Normalized) ? LogExtention.eExp(gamma[0][i]) : gamma[0][i];
checksum += _estimatedPi[i];
}
CheckPi(checksum);
}
public void Denormalize()
{
if (!_denormalized)
{
for (var i = 0; i < _parameters.Model.N; i++)
{
for (var l = 0; l < _parameters.L; l++)
{
_coefficients[i][l] = LogExtention.eExp(_coefficients[i][l]);
}
}
_denormalized = true;
}
}
public double[] Estimate(PiParameters parameters)
{
if (_estimatedPi != null)
{
return(_estimatedPi);
}
_estimatedPi = new double[parameters.N];
for (var i = 0; i < parameters.N; i++)
{
_estimatedPi[i] = (parameters.Normalized) ? LogExtention.eExp(parameters.Gamma[0][i]) : parameters.Gamma[0][i];
}
return(_estimatedPi);
}
public IDistribution Evaluate(double[] observations, double[] symbols, double[] gamma, bool logNormalized)
{
var M = symbols.Length;
var T = observations.Length;
var probabilities = new double[M];
for (var k = 0; k < M; k++)
{
double den = (logNormalized) ? double.NaN : 0, num = (logNormalized) ? double.NaN : 0;
for (var t = 0; t < T; t++)
{
if (observations[t] == symbols[k])
{
if (logNormalized)
{
num = LogExtention.eLnSum(num, gamma[t]);
}
else
{
num = num + gamma[t];
}
}
if (logNormalized)
{
den = LogExtention.eLnSum(den, gamma[t]);
}
else
{
den = den + gamma[t];
}
}
probabilities[k] = 1e-10;
if (!num.EqualsToZero())
{
if (logNormalized)
{
probabilities[k] = den.EqualsToZero() ? 0.0 : LogExtention.eExp(LogExtention.eLnProduct(num, -den));
}
else
{
probabilities[k] = den.EqualsToZero() ? 0.0 : num / den;
}
}
}
return(new DiscreteDistribution(symbols, probabilities));
}
public double[, ][] Estimate(MixtureCoefficientEstimationParameters <TDistribution> parameters)
{
if (_mu != null)
{
return(_mu);
}
try
{
_mu = new double[parameters.Model.N, parameters.L][];
for (var i = 0; i < parameters.Model.N; i++)
{
for (var l = 0; l < parameters.L; l++)
{
var denominator = 0.0d;
var nominator = new double[parameters.Observations[0].Dimention];
for (var t = 0; t < parameters.Observations.Count; t++)
{
// TODO : weights here
var weight = GetWeightValue(t, parameters.ObservationWeights);
var x = parameters.Observations[t].Value;
var gamma = (parameters.Model.Normalized) ? LogExtention.eExp(parameters.GammaComponents[t][i, l])
: parameters.GammaComponents[t][i, l];
denominator += weight * gamma;
x = x.Product(gamma * weight);
nominator = nominator.Add(x);
}
_mu[i, l] = nominator.Product(1 / denominator);
}
}
}
catch (Exception)
{
for (var i = 0; i < parameters.Model.N; i++)
{
for (var l = 0; l < parameters.L; l++)
{
Debug.WriteLine("Mixture Mu [{0},{1}] : {2}", i, l, new Vector(_mu[i, l]));
}
}
throw;
}
return(_mu);
}
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);
}
protected void EstimateTransitionProbabilityMatrix(double[][] gamma, double[][,] ksi, decimal[] observationWeights, int sequenceLength)
{
var checksum = new double[_model.N];
for (var i = 0; i < _model.N; i++)
{
_estimatedTransitionProbabilityMatrix[i] = new double[_model.N];
for (var j = 0; j < _model.N; j++)
{
double den = (_model.Normalized) ? double.NaN : 0, num = (_model.Normalized) ? double.NaN : 0;
for (var t = 0; t < sequenceLength - 1; t++)
{
var weight = GetWeightValue(t, observationWeights);
if (_model.Normalized)
{
num = LogExtention.eLnSum(num, LogExtention.eLnProduct(weight, ksi[t][i, j]));
den = LogExtention.eLnSum(den, LogExtention.eLnProduct(weight, gamma[t][i]));
}
else
{
num += weight * ksi[t][i, j];
den += weight * gamma[t][i];
}
}
if (_model.Normalized)
{
_estimatedTransitionProbabilityMatrix[i][j] = den.EqualsToZero() ? 0.0 : LogExtention.eExp(LogExtention.eLnProduct(num, -den));
}
else
{
_estimatedTransitionProbabilityMatrix[i][j] = den.EqualsToZero() ? 0.0 : num / den;
}
checksum[i] = checksum[i] + _estimatedTransitionProbabilityMatrix[i][j];
}
}
CheckTransitionProbabilityMatrix(checksum);
}
