public void LikelihoodConstructorTest()
{
int[] o = null; // TODO: инициализация подходящего значения
HMM_QPN model = null; // TODO: инициализация подходящего значения
Likelihood target = new Likelihood(o, model);
Assert.Inconclusive("TODO: реализуйте код для проверки целевого объекта");
}
public double b(int i, int d, int t)//t - правая граница
{
Debug.WriteLine("b(" + i + "," + d + "," + t + "): ");
if (t - d <= 0 && t <= 0 || t - d > O.Length)
{
Debug.WriteLine("b(" + i + "," + d + "," + t + "): " + 0);
return(0);//или t > O.Length
}
else
{
double prod = 1;
double[] fi = HMM_QPN.integral(Model.Ro[i], Model.Ro[i].Length, d);
//TODO: Хранить фи
int m = 1;
int k = d;
if (t - d > 0)
{
m = 1;
Debug.WriteLine("m: t - d > 0 " + m);
}
else
{
m = 1 - t + d;
Debug.WriteLine("m: t - d <= 0 " + m);
}
if (t <= O.Length)
{
k = d;
Debug.WriteLine("k:t <= O.Length " + k);
}
else
{
k = O.Length - t + d;
Debug.WriteLine("k: t > O.Length " + k);
}
Debug.WriteLine("from " + m + "; to " + k);
for (int theta = m; theta <= k; theta++)
{
int I = MultiplicativeGroupIndicator(O[t - d + theta], Model.q);
Debug.Write(" position: " + (t - d + theta) + " I(" + O[t - d + theta] + ", " + Model.q + "): " + I);
Debug.Write(" fi: " + fi[theta - 1]);
Debug.Write(" Per: " + (double)Model.Per[i]);
Debug.Write(" d: " + (double)d);
double mult = (I == 1) ? (double)fi[theta - 1] * (double)Model.Per[i] * (double)d * (double)Model.B[i, O[t - d + theta] - 1] : (1 - (double)fi[theta - 1] * (double)Model.Per[i] * d);
if (I == 1)
{
Debug.Write(" B: " + (double)Model.B[i, O[t - d + theta] - 1]);
}
Debug.WriteLine(" mult(" + theta + "): " + mult);
prod *= mult;
}
Debug.WriteLine("b(" + i + "," + d + "," + t + "): " + prod);
return(prod);
}
}
public void Max_PeriodTest()
{
HMM_QPN Model = null; // TODO: инициализация подходящего значения
int expected = 0; // TODO: инициализация подходящего значения
int actual;
actual = HMM_PSM_Accessor.Max_Period(Model);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Проверьте правильность этого метода теста.");
}
public void IsCorrectTest()
{
string filename = string.Empty; // TODO: инициализация подходящего значения
HMM_QPN target = new HMM_QPN(filename); // TODO: инициализация подходящего значения
int expected = 0; // TODO: инициализация подходящего значения
int actual;
actual = target.IsCorrect();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Проверьте правильность этого метода теста.");
}
public void LikelihoodExtended1Test()
{
HMM_QPN Model = null; // TODO: инициализация подходящего значения
int[] O = null; // TODO: инициализация подходящего значения
double expected = 0F; // TODO: инициализация подходящего значения
double actual;
actual = HMM_PSM.LikelihoodExtended1(Model, O);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Проверьте правильность этого метода теста.");
}
public void LikelihoodExtendedTest()
{
HMM_QPN Model = new HMM_QPN("F:/аспирантура/Programs/10.12.12/HSMPQApplication/M_1.txt");
int[] O = { 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0 }; // TODO: инициализация подходящего значения
double expected = 0F; // TODO: инициализация подходящего значения
double actual;
actual = HMM_PSM.LikelihoodExtended(Model, O);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Проверьте правильность этого метода теста.");
}
public void ProbabilityFromDistributionTest()
{
string filename = string.Empty; // TODO: инициализация подходящего значения
HMM_QPN target = new HMM_QPN(filename); // TODO: инициализация подходящего значения
DistributionPare[] DP = null; // TODO: инициализация подходящего значения
double[] expected = null; // TODO: инициализация подходящего значения
double[] actual;
actual = target.ProbabilityFromDistribution(DP);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Проверьте правильность этого метода теста.");
}
private void btOMCCalculateProbability_Click(object sender, EventArgs e)
{
if (lbOMCModelPath.Text != "" && lbOMCSequencePath.Text != "" && tbOMCSegmentLength.Text != "" && tbOMCSequenceLength.Text != "")
{
int segmentSize = Int32.Parse(tbOMCSegmentLength.Text); //добавить проверку
int sequenceLength = Int32.Parse(tbOMCSequenceLength.Text); //добавить проверку
HMM_QPN Model = new HMM_QPN(lbOMCModelPath.Text);
if (Model.IsCorrect() == 1)
{
int[] res = new int[sequenceLength + 1];
try
{
res = HMM_PSM.GetOutputSequence(lbOMCSequencePath.Text, sequenceLength);
}
catch (Exception)
{
MessageBox.Show("Желаемая длина последовательности превышает размер файла");
return;
}
ModelObject model = new ModelObject(lbOMCModelPath.Text, Model);
SequenceObject sequence = new SequenceObject(lbOMCSequencePath.Text, res);
OneModelComputation computor = new OneModelComputation(model, sequence, segmentSize, sequenceLength);
List <double> probabilities = computor.compute();
string s = "Model: " + model.ModelName + "\r\n Sequence: " + sequence.SequenceName + "\r\n Sequence length: " + sequenceLength + "\r\n Segment size: " + segmentSize + "\r\n";
for (int i = 0; i < probabilities.Count(); i++)
{
s += probabilities.ElementAt(i) + ",";
}
OutStreamer os = new OutStreamer("omc.txt", FileOpenMode.RewriteMode);
os.StringToFile(s);
if (saveFileDialogExperiment.ShowDialog() == DialogResult.OK)
{
StreamReader f = File.OpenText("omc.txt");
string Buf = f.ReadToEnd();
StreamWriter sw = new StreamWriter(File.Create(saveFileDialogExperiment.FileName));
sw.Write(Buf);
sw.Close();
f.Close();
}
}
else
{
MessageBox.Show("Модель некорректна");
}
}
else
{
MessageBox.Show("Не все параметры заданы");
}
}
public void FullProbabilityTest()
{
int[] o = null; // TODO: инициализация подходящего значения
HMM_QPN model = null; // TODO: инициализация подходящего значения
Likelihood target = new Likelihood(o, model); // TODO: инициализация подходящего значения
int t = 0; // TODO: инициализация подходящего значения
double expected = 0F; // TODO: инициализация подходящего значения
double actual;
actual = target.FullProbability(t);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Проверьте правильность этого метода теста.");
}
private void GenerateBtn_Click(object sender, EventArgs e)
{
HMM_QPN Model = new HMM_QPN(filestr);
int seq_length;
if (int.TryParse(textBox3.Text, out seq_length))
{
if (Model.IsCorrect() == 1)
{
panel1.Enabled = false;
textBox1.Enabled = false;
DateTime startTime = DateTime.Now;
DateTime endTime;
Model.StartGenerator(seq_length, HSMPQApplication.Mode.Release, HSMPQApplication.PRNGMode.Random);
endTime = DateTime.Now;
TimeSpan employedTime = endTime - startTime;
lbEmployedTime.Text = "Время, затраченное на генерацию " + employedTime.ToString();
panel1.Enabled = true;
textBox1.Enabled = true;
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
StreamReader f = File.OpenText("res.txt");
string Buf = f.ReadToEnd();
StreamWriter sw = new StreamWriter(File.Create(saveFileDialog1.FileName));
sw.Write(Buf);
sw.Close();
f.Close();
}
}
else if (Model.IsCorrect() == 3)
{
MessageBox.Show("Для параметров не выполняются необходимые условия стохастичности");
}
else if (Model.IsCorrect() == 4)
{
MessageBox.Show("Для параметров не выполняются необходимые условия адаптированности");
}
else if (Model.IsCorrect() == 0)
{
MessageBox.Show("Размерности вводимых параметров не соответствуют");
}
else if (Model.IsCorrect() == 2)
{
MessageBox.Show("Не все параметры заданы");
}
}
else
{
MessageBox.Show("Введите длину последовательости ошибок");
}
}
public static double SymbolFinalProbability(HMM_QPN Model, double fi, int d, int i, int symbol)
{
double smb_final_prob = 0;
if (symbol == 0)
{
smb_final_prob = 1 - fi * Model.Per[i] * d;
}
else
{
smb_final_prob = fi * Model.Per[i] * d * Model.B[i, symbol - 1];
}
return(smb_final_prob);
}
public void SymbolFinalProbabilityTest()
{
HMM_QPN Model = null; // TODO: инициализация подходящего значения
double fi = 0F; // TODO: инициализация подходящего значения
int d = 0; // TODO: инициализация подходящего значения
int i = 0; // TODO: инициализация подходящего значения
int symbol = 0; // TODO: инициализация подходящего значения
double expected = 0F; // TODO: инициализация подходящего значения
double actual;
actual = HMM_PSM.SymbolFinalProbability(Model, fi, d, i, symbol);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Проверьте правильность этого метода теста.");
}
public void alphaTest()
{
HMM_QPN Model = null; // TODO: инициализация подходящего значения
int[] O = null; // TODO: инициализация подходящего значения
int d = 0; // TODO: инициализация подходящего значения
int i = 0; // TODO: инициализация подходящего значения
int t = 0; // TODO: инициализация подходящего значения
double expected = 0F; // TODO: инициализация подходящего значения
double actual;
actual = HMM_PSM_Accessor.alpha(Model, O, d, i, t);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Проверьте правильность этого метода теста.");
}
public Likelihood(int[] o, HMM_QPN model)
{
O = o;
Model = model;
int D = model.MaxPeriodOverall();
alpha = new double[model.n, D + 1, o.Length + Model.MaxPeriodOverall()];
P = new double[o.Length + Model.MaxPeriodOverall()];
for (int r = 0; r < o.Length + Model.MaxPeriodOverall(); r++)
{
for (int i = 0; i < model.n; i++)
for (int d = 0; d <= D; d++)
alpha[i, d, r] = -1;
P[r] = -1;
}
}
public void bTest()
{
HMM_QPN Model = new HMM_QPN("H:/аспирантура/Programs/10.12.12/HSMPQApplication/13.01.txt");
int[] O = { 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0 };
int i = 0; // TODO: инициализация подходящего значения
int t = 25; // TODO: инициализация подходящего значения
double expected = 0.0000066483263599150104576F; // TODO: инициализация подходящего значения
double actual;
actual = HMM_PSM_Accessor.b(Model, O, i, t, O.Length);
double epsilon = 0.00000001F;
bool correct = Math.Abs(actual - expected) <= epsilon;
Assert.AreEqual(correct, true);
}
private static int Max_Period(HMM_QPN Model)
{
int max_period = 0;//максимальная длительность по всем состояниям (у Рабинера D)
int i = 0;
for (i = 0; i <= Model.A.GetLength(0) - 1; i++)//определяем max_period
{
double[] f_values = Model.ValueFromDistribution(Model.F[i]);
int max_in_state = (int)HMM_QPN.MaxElementOfArray(f_values);
if (max_in_state > max_period)
{
max_period = max_in_state;
}
}
return(max_period);
}
/// <summary>
/// Функция вычисления вероятности наблюдения частичной последовательности O_{t-d+1:t} в состоянии i, где d = O.length
/// </summary>
/// <param name="O">частичная последовательность</param>
/// <param name="i">состояние</param>
/// <param name="t">момент времени соответствующий концу частичной последовательности внутри целой</param>
/// <param name="d">длинна квазипериода</param>
/// <returns></returns>
private static double b(HMM_QPN Model, int[] O, int i, int t, int d)
{
if (t <= 0)
{
return(1);
}
else
{
double prod = 1;
if (O == null || O.Length == 0)
{
return(1);
}
else
{
//int o = O.Length;
if (d == 0)
{
return(1);
}
int q = Model.B.GetLength(1) + 1;//мощность поля Галуа
double[] fi = HMM_QPN.integral(Model.Ro[i], Model.Ro[i].Length, d);
int theta;
for (theta = 0; theta < O.Length; theta++)
{
try
{
int I = MultiplicativeGroupIndicator(O[theta], q);//-1 из-за того что в реализации массив нумеруется с 0
prod *= (I == 1) ? fi[d - O.Length + theta] * Model.Per[i] * d * Model.B[i, O[theta] - 1] : (1 - fi[theta] * Model.Per[i] * d);
}
catch
{ }
}
;
return(prod);
}
}
}
public double[] calculateSplitedLikelihood(HMM_QPN model, int[] O)
{
if (segment_size <= 0)
{
return(null);
}
else
{
int h = O.Length / segment_size;
double[] result = new double[h];
for (int i = 0; i < h; i++)
{
int[] subseq = new int[segment_size + 1];
for (int j = 1; j <= segment_size; j++)
{
subseq[j] = O[i * segment_size + j];
}
Likelihood lk = new Likelihood(subseq, model);
result[i] = lk.FullProbability(subseq.Length - 1);
}
return(result);
}
}
public void MinElementOfArrayTest()
{
double[] p = { 0.7F, 0.3F, 0.1F };
double expected = 0.1F;
double actual;
actual = HMM_QPN.MinElementOfArray(p);
Assert.AreEqual(expected, actual);
// наибольший последний
double[] p1 = { 0.1F, 0.3F, 0.7F };
expected = 0.1F;
actual = HMM_QPN.MaxElementOfArray(p1);
Assert.AreEqual(expected, actual);
//наибольший в середине
double[] p2 = { 0.1F, 0.3F, 0.7F };
expected = 0.1F;
actual = HMM_QPN.MaxElementOfArray(p2);
Assert.AreEqual(expected, actual);
//всего 1 элемент
double[] p3 = { 0.7F };
expected = 0.1F;
actual = HMM_QPN.MaxElementOfArray(p3);
Assert.AreEqual(expected, actual);
}
public List <ModelObject> getModelsList()
{
if (this.modelsFolderPath == null)
{
return(null);
}
try
{
string[] files = Directory.GetFiles(this.modelsFolderPath);
if (files == null && files.Length == 0)
{
return(null);
}
List <ModelObject> result = new List <ModelObject>();
for (int i = 0; i <= files.Length; i++)
{
try
{
HMM_QPN Model = new HMM_QPN(files[i]);
if (Model.IsCorrect() == 1)
{
result.Add(new ModelObject(files[i], Model));
}
}
catch
{
//TODO do smth or change try to if
}
}
return(result);
}
catch
{
return(null);
}
}
public static double Likelihood(HMM_QPN Model, int[] res, out double[,] norm_alpha_par, out double[,] alpha_par, out double[] norm_coeff, out double prob)// считает вероятность того, что последовательность наблюдений res получена с помощью модели Model
//res numeruetsya ot 1
{
#region Описание переменных
int n = Model.A.GetLength(0); //число состояний
int T = res.Length - 1; //длина последовательности наблюдений
double[,] alpha = new double[n, T + 1]; //прямая переменная
double[,] auxiliary_alpha = new double[n, T + 1];
double[,] norm_alpha = new double[n, T + 1]; //нормированная прямая переменная
double[] c = new double[T + 1]; //коэффициенты нормировки
int max_period = 0; //максимальная длительность по всем состояниям (у Рабинера D)
#endregion
#region Определение максимальной длительности по всем состояниям
int i = 0;
for (i = 0; i < n; i++)//определяем max_period
{
double[] f_values = Model.ValueFromDistribution(Model.F[i]);
int max_in_state = (int)HMM_QPN.MaxElementOfArray(f_values);
if (max_in_state > max_period)
{
max_period = max_in_state;
}
}
#endregion
//преобразуем p_i(d) к виду ряда распределения где d принадлежит от 1 до D(то есть) max_period,а вероятность =0 если такой длины нет
#region Матрица плотностей длительностей состояний
float[,] length_density = new float[n, max_period + 1];//матрица плотностей длительности состояний.
//Второй индекс соответствует длине, значение - вероятности
for (i = 0; i < n; i++)
{
for (int d = 1; d <= max_period; d++)
{
length_density[i, d] = 0;//занулили все элементы матрицы
}
for (int j = 0; j < Model.F[i].Length; j++)
{
length_density[i, Model.F[i][j].value] = Model.F[i][j].probability;//изменили те элементы, для которых вероятность нулю не равна
}
}
#endregion
#region Старый вариант формул
//#region Для t=1
////для t=1
//c[1] = 0;
//for (i=0; i<n; i++)
//{
// if (length_density[i, 1] > 0)
// {
// float[] fi = new float[1];
// fi = HMM_QPN.integral(Model.Ro[i], Model.Ro[i].Length, 1);
// alpha[i, 1] = SymbolFinalProbability(Model, fi[0], 1, i, res[1]) * Model.Pi[i] * length_density[i, 1];
// auxiliary_alpha[i, 1] = SymbolFinalProbability(Model, fi[0], 1, i, res[1]) * Model.Pi[i] * length_density[i, 1];
// }
// else
// {
// alpha[i, 1] = 0;
// auxiliary_alpha[i, 1] =0;
// }
// c[1] += auxiliary_alpha[i, 1];
//}
//c[1] =(c[1]!=0)?1 / c[1]:0;//вычислили нормировочный коэффициент
//for (i = 0; i < n; i++)
//{
// norm_alpha[i, 1] = auxiliary_alpha[i, 1] * c[1];
//}
//#endregion
//#region Для 1<t<=D
////вторая строчка формулы
//int t=2;
//for (t = 2; (t <= max_period)&&(t<=T); t++)
//{
// c[t] = 0;
// for (i = 0; i < n; i++)
// {
// //первое слагаемое формулы 2
// float term1 = 0;
// if (length_density[i, t] > 0)
// {
// float[] fi = new float[t];
// fi = HMM_QPN.integral(Model.Ro[i], Model.Ro[i].Length, t);
// float prod_tilda_b1 = 1;//переменная для произведения b c волной
// for (int s = 1; s <= t; s++)
// {
// prod_tilda_b1 *= SymbolFinalProbability(Model, fi[s - 1], t, i, res[s]);
// }
// term1 = Model.Pi[i] * length_density[i, t] * prod_tilda_b1;
// }
// float term2 = 0;
// float norm_term2 = 0;
// for (int d = 1; d <= t - 1; d++)
// for (int j = 0; j < n; j++)
// {
// float prod_tilda_b2 = 1;
// if (length_density[i, d] > 0)
// {
// float[] fi2 = new float[d];
// fi2 = HMM_QPN.integral(Model.Ro[i], Model.Ro[i].Length, d);
// for (int s = t - d + 1; s <= t; s++)
// {
// prod_tilda_b2 *= SymbolFinalProbability(Model, fi2[s - t + d - 1],d, i, res[s]);
// }
// term2 += alpha[j, t - d] * Model.A[j, i] * length_density[i, d] * prod_tilda_b2;
// norm_term2 += norm_alpha[j, t - d] * Model.A[j, i] * length_density[i, d] * prod_tilda_b2;
// }
// }
// alpha[i, t] = term1 + term2;
// auxiliary_alpha[i, t] = term1 + norm_term2;
// c[t] += auxiliary_alpha[i, t];
// }
// c[t] = (c[t] != 0) ? 1 / c[t] : 0;
// for (i = 0; i < n; i++)
// {
// norm_alpha[i, t] = auxiliary_alpha[i, t] * c[t];
// }
//}
//#endregion
//#region Для t>D
////третья строчка формулы
//for (t = max_period + 1; t <= T; t++)
//{
// c[t] = 0;
// for (i = 0; i < n; i++)
// {
// float term = 0;
// float norm_term = 0;
// for (int d = 1; d <= max_period; d++)
// for (int j = 0; j < n; j++)
// {
// if (length_density[i, d] > 0)
// {
// float prod_tilda_b = 1;
// float[] fi = new float[d];
// fi = HMM_QPN.integral(Model.Ro[i], Model.Ro[i].Length, d);
// for (int s = t - d + 1; s <= t; s++)
// {
// prod_tilda_b *= SymbolFinalProbability(Model, fi[s - t + d - 1], d, i, res[s]);
// }
// term += alpha[j, t - d] * Model.A[j, i] * length_density[i, d] * prod_tilda_b;
// norm_term += norm_alpha[j, t - d] * Model.A[j, i] * length_density[i, d] * prod_tilda_b;
// }
// }
// alpha[i, t] = term;
// auxiliary_alpha[i, t] = norm_term;
// c[t] += auxiliary_alpha[i, t];
// }
// c[t] = (c[t] != 0) ? 1 / c[t] : 0;
// for (i = 0; i < n; i++)
// {
// norm_alpha[i, t] = auxiliary_alpha[i, t] * c[t];
// }
//}
// #endregion
#endregion Старый вариант формул
#region Для t=1
//для t=1
c[1] = 0;
for (i = 0; i < n; i++)
{
if (length_density[i, 1] > 0)
{
double[] fi = new double[1];
fi = HMM_QPN.integral(Model.Ro[i], Model.Ro[i].Length, 1);
alpha[i, 1] = SymbolFinalProbability(Model, fi[0], 1, i, res[1]) * Model.Pi[i] * length_density[i, 1];
auxiliary_alpha[i, 1] = SymbolFinalProbability(Model, fi[0], 1, i, res[1]) * Model.Pi[i] * length_density[i, 1];
}
else
{
alpha[i, 1] = 0;
auxiliary_alpha[i, 1] = 0;
}
c[1] += auxiliary_alpha[i, 1];
}
c[1] = (c[1] != 0) ? 1 / c[1] : 0;//вычислили нормировочный коэффициент
for (i = 0; i < n; i++)
{
norm_alpha[i, 1] = auxiliary_alpha[i, 1] * c[1];
}
#endregion
#region Для t<T
int t = 2;
for (t = 2; t <= T; t++)
{
c[t] = 0;
for (i = 0; i < n; i++)
{
double term = 0;
double norm_term = 0;
int D = max_period >= t ? t : max_period;
for (int d = 1; d <= D; d++)
{
for (int j = 0; j < n; j++)
{
if (length_density[i, d] > 0)
{
double prod_tilda_b = 1;
double[] fi = new double[d];
fi = HMM_QPN.integral(Model.Ro[i], Model.Ro[i].Length, d);
for (int s = t - d + 1; s <= t; s++)
{
prod_tilda_b *= SymbolFinalProbability(Model, fi[s - t + d - 1], d, i, res[s]);
}
term += alpha[j, t - d] * Model.A[j, i] * length_density[i, d] * prod_tilda_b;
norm_term += norm_alpha[j, t - d] * Model.A[j, i] * length_density[i, d] * prod_tilda_b;
}
}
}
alpha[i, t] = term;
auxiliary_alpha[i, t] = norm_term;
c[t] += auxiliary_alpha[i, t];
}
c[t] = (c[t] != 0) ? 1 / c[t] : 0;
for (i = 0; i < n; i++)
{
norm_alpha[i, t] = auxiliary_alpha[i, t] * c[t];
}
}
#endregion Для t<T
double probability = 0;
prob = 0;
double coeffsum = 0;
for (i = 0; i < n; i++)
{
// probability+=norm_alpha[i,T];
prob += alpha[i, T];
}
for (t = 1; t <= T; t++)
{
coeffsum += c[t];
}
probability = 1 / coeffsum;
alpha_par = alpha;
norm_alpha_par = norm_alpha;
norm_coeff = c;
return(probability);
}
/// <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);
}
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);
}
}
}
private void CountProbBtn_Click(object sender, EventArgs e)
{
HMM_QPN Model = new HMM_QPN(label1.Text);
if (Model.IsCorrect() == 1)
{
int smbnubmer = 10;
if (textBox2.Text != "")
{
try
{
smbnubmer = int.Parse(textBox2.Text);
}
catch (Exception)
{
}
}
;
int[] res = new int[smbnubmer + 1];
try
{
res = HMM_PSM.GetOutputSequence(label2.Text, smbnubmer);
}
catch (Exception)
{
MessageBox.Show("Желаемая длина последовательности превышает размер файла");
return;
}
panel3.Enabled = false;
if (radioButton1.Checked)
{
//try
//{
Likelihood lk = new Likelihood(res, Model);
//label3.Text = lk.Probability(res.Length - 1).ToString();
label3.Text = lk.FullProbability(res.Length - 1).ToString();
//}
//catch (Exception)
// { MessageBox.Show("В процессе расчета возникла ошибка!"); };
panel3.Enabled = true;
}
else
{
if (radioButton2.Checked)
{
LikelihoodSimple lk = new LikelihoodSimple(res, Model);
//label3.Text = lk.Probability(res.Length - 1).ToString();
label3.Text = lk.Probability(res.Length - 1).ToString();
panel3.Enabled = true;
}
else
{
if (tbSegmentNumber.Text != "")
{
int segment_size = 0;
if (Int32.TryParse(tbSegmentNumber.Text, out segment_size))
{
LikelihoodSplit ls = new LikelihoodSplit(segment_size);
double [] result = ls.calculateSplitedLikelihood(Model, res);
double total = 0;
tbSplitResultDetails.Text = "";
for (int i = 0; i < result.Length; i++)
{
tbSplitResultDetails.Text += "P[O(" + i * segment_size + "," + ((i + 1) * segment_size) + ")] = " + result[i] + "\r\n";
total += result[i];
}
label3.Text = (total / result.Length).ToString();
panel3.Enabled = true;
}
else
{
MessageBox.Show("Размер сегмента разбиения должен быть целым");
}
}
else
{
MessageBox.Show("Задайте размер сегмента разбиения");
}
}
}
}
else
{
MessageBox.Show("Модель задана некорректно");
}
}
public ModelObject(string modelName, HMM_QPN model)
{
this.model_name = modelName;
this.model = model;
}
