public double Alpha(int i, int d, int t)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + ")");
//для такого случая Pi должно быть предельными вероятностями матрицы переходов.
if (t <= 0)
{
double alp = Model.Pi[i] * Model.ProbabilityByValueAndState(d, i);
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + "): " +alp);
return alp;
}
else if (alpha[i, d, t] != -1)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + "): " + alpha[i, d, t]);
return alpha[i, d, t];
}
else
{
Debug.WriteLine("Calculation:");
double sum = 0;
for (int i1 = 0; i1 < Model.n; i1++)
for (int d1 = 1; d1 <= Model.MaxPeriodOverall(); d1++)
{
Debug.WriteLine("new period:" + d1);
Debug.WriteLine("A: " + Model.A[i1, i] + "; p(d):" + Model.ProbabilityByValueAndState(d, i));
double prod = Model.A[i1, i] * Model.ProbabilityByValueAndState(d, i);
Debug.WriteLine("Production: " + prod);
if (prod != 0F)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + ") calls calculation of Alpha(" + i1 + "," + d1 + "," + (t - d) + ")");
prod *= Alpha(i1, d1, t - d);
Debug.WriteLine("Production: " + prod);
}
if (prod != 0F)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + ") calls calculation of b(" + i1 + "," + d1 + "," + (t - d) + ")");
prod *= b(i1, d1, t - d);
Debug.WriteLine("Production: " + prod);
}
if (prod != 0F)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + ") calls calculation of Probability(" + (t - d - d1) + ")");
prod *= Probability(t - d - d1);
Debug.WriteLine("Production: " + prod);
}
if (prod != 0F)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + ") calls calculation of Probability(" + (t - d) + ")");
prod /= Probability(t - d);
Debug.WriteLine("Devision: " + prod);
}
sum += prod;
}
alpha[i, d, t] = sum;
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + "): " + sum);
return sum;
}
}
public double Alpha(int i, int d, int t)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + ")");
if (t - d < 0)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + "): " + 0);
return(0);
}
else
if (t == d)
{
if (alpha[i, d, t] != -1)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + "): " + alpha[i, d, t]);
return(alpha[i, d, t]);
}
Debug.WriteLine("Pi: " + Model.Pi[i] + "; p(d): " + Model.ProbabilityByValueAndState(d, i));
//см лист 11.03.14 №1
alpha[i, d, t] = Model.Pi[i] * Model.ProbabilityByValueAndState(d, i);
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + "): " + alpha[i, d, t]);
return(alpha[i, d, t]);
}
else if (alpha[i, d, t] != -1)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + "): " + alpha[i, d, t]);
return(alpha[i, d, t]);
}
else
{
Debug.WriteLine("Calculation:");
double sum = 0;
for (int i1 = 0; i1 < Model.n; i1++)
// for (int d1 = 1; d1 <= Model.MaxPeriodOverall(); d1++)
{ // Типа одна длина возможна
int d1 = Model.MaxPeriodOverall();
Debug.WriteLine("max period:" + d1);
Debug.WriteLine("A: " + Model.A[i1, i] + "; p(d):" + Model.ProbabilityByValueAndState(d, i));
double prod = Model.A[i1, i] * Model.ProbabilityByValueAndState(d, i);
Debug.WriteLine("Production: " + prod);
if (prod != 0F)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + ") calls calculation of Alpha(" + i1 + "," + d1 + "," + (t - d) + ")");
prod *= Alpha(i1, d1, t - d);
Debug.WriteLine("Production: " + prod);
}
// если первый множитель 0, то остальные можно не считать.
if (prod != 0F)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + ") calls calculation of b(" + i1 + "," + d1 + "," + (t - d) + ")");
prod *= b(i1, d1, t - d);
Debug.WriteLine("Production: " + prod);
}
if (prod != 0F)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + ") calls calculation of Probability(" + (t - d - d1) + ")");
prod *= Probability(t - d - d1);
Debug.WriteLine("Production: " + prod);
}
if (prod != 0F)
{
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + ") calls calculation of Probability(" + (t - d) + ")");
prod /= Probability(t - d);
Debug.WriteLine("Devision: " + prod);
}
sum += prod;
}
alpha[i, d, t] = sum;
Debug.WriteLine("Alpha(" + i + ", " + d + ", " + t + "): " + sum);
return(sum);
}
}
private static double alpha(HMM_QPN Model, int[] O, int d, int i, int t)
{
double d_prob = Model.ProbabilityByValueAndState(d, i);
// по первой ветке
if (t <= 0)
{
return
(Model.Pi[i] * d_prob);//вероятность наблюдать длину d в состоянии i
}
else //по второй ветке
{
// если вероятность длительности в состоянии нулевая, то и альфа будет нулевой
if (d_prob == 0)
{
alphav[i, d, t] = 0;
return(0);
}
else
{
//если вероятность не нулевая, то считаем по формуле
double sum = 0;
//внешняя сумма по всем состояниям
for (int i_prime = 0; i_prime < Model.n; i_prime++)
{
//смотрим посчитана ли вероятность P[O_1:t-d|lambda], это общий множитель для всех слагаемых
double formerlikelihood1;
if (t - d >= 0 && likelihood[t - d] != -1)// вторая часть так как изначально все элементы массива =-1
{
formerlikelihood1 = likelihood[t - d];
}
else
{
formerlikelihood1 = LikelihoodExtended(Model, SubSequence(O, 0, t - d - 1));
if (t - d >= 0)
{
likelihood[t - d] = formerlikelihood1;
}
}
//по всем длительностям
for (int d_prime = 1; d_prime <= D; d_prime++)
{
//смотрим посчитана ли вероятность P[O_1:t-d-d_prime|lambda]
double formerlikelihood2;
if (t - d - d_prime >= 0 && likelihood[t - d - d_prime] != -1)
{
formerlikelihood2 = likelihood[t - d - d_prime];
}
else
{
formerlikelihood2 = LikelihoodExtended(Model, SubSequence(O, 0, t - d - d_prime - 1));
if (t - d - d_prime >= 0)
{
likelihood[t - d - d_prime] = formerlikelihood2;
}
}
//смотрим посчитана ли вероятность alfa_t-d(i_prime,d_prime)
double formeralpha;
if (t - d >= 0 && alphav[i_prime, d_prime, t - d] != -1)
{
formeralpha = alphav[i_prime, d_prime, t - d];
}
else
{
formeralpha = alpha(Model, O, d_prime, i_prime, t - d);
if (t - d >= 0)
{
alphav[i_prime, d_prime, t - d] = formeralpha;
}
}
sum += d_prob * formeralpha *
(b(Model, SubSequence(O, t - d - d_prime, t - d - 1), i_prime, t - d, d_prime) *
Model.A[i_prime, i] * formerlikelihood2) / formerlikelihood1;
}
}
alphav[i, d, t] = sum;
return(sum);
}
}
}
/// <summary>
/// Метод вычисляющий вероятность наблюдать последовательность O при заданной модели Model
/// </summary>
/// <param name="Model"></param>
/// <param name="O"></param>
/// <returns></returns>
public static double LikelihoodExtended(HMM_QPN Model, int[] O)
{
//Первый запуск метода. Заполняем элементы массивов alphav и likelihood -1
//(поскольку это вероятности, значение -1 больше никак появиться не может,
//то есть это признак незаполненности элемента)
if (D == -1)
{
D = Max_Period(Model);
int N = Model.n; //число состояний
// O нумеруется начиная с первого элемента, а не с нулевого. как и длительности
alphav = new double[N, D + 1, O.Length + 1]; //1-i, 2-d, 3-t
likelihood = new double[O.Length + 1]; //1-i, 2-d, 3-t
for (int r = 0; r <= O.Length; r++)
{
for (int i = 0; i < N; i++)
{
for (int d = 0; d <= D; d++)
{
alphav[i, d, r] = -1;
}
}
likelihood[r] = -1;
}
}
//если последовательность пустая, то вероятность 1. Это может быть в случае, если мы забрались в отрицательную область по t
if (O == null || O.Length == 0)
{
return(1);
}
int t = O.Length;//число элементов последвательности
double sum = 0;
for (int i = 0; i < Model.n; i++)
{
for (int d = 1; d <= D; d++)
{
if (Model.ProbabilityByValueAndState(d, i) == 0)
{
alphav[i, d, t] = 0; continue;
}
//смотрим посчитана ли вероятность P[O_1:t-d|lambda]
double formerlikelihood;
if (t - d >= 0 && likelihood[t - d] != -1)
{ //эта вероятность уже была посчитана раньше и записана в массив
formerlikelihood = likelihood[t - d];
}
else
{ //еще не была посчитана и должны посчитать
formerlikelihood = LikelihoodExtended(Model, SubSequence(O, 0, t - d - 1));
//и записать в массив
if (t - d >= 0)
{
likelihood[t - d] = formerlikelihood;
}
}
//смотрим посчитана ли вероятность alfa_t(i,d)
double formeralpha;
if (t >= 0 && alphav[i, d, t] != -1)
{ //эта вероятность уже была посчитана раньше и записана в массив
formeralpha = alphav[i, d, t];
}
else
{ //еще не была посчитана и должны посчитать
formeralpha = alpha(Model, O, d, i, t);
//и записать в массив
if (t >= 0)
{
alphav[i, d, t] = formeralpha;
}
}
sum += formerlikelihood * formeralpha * b(Model, SubSequence(O, t - d, t - 1), i, t, d);
}
}
likelihood[t] = sum;
return(sum);
}