на тему рефераты Информационно-образоательный портал
Рефераты, курсовые, дипломы, научные работы,
на тему рефераты
на тему рефераты
МЕНЮ|
на тему рефераты
поиск
Распознавание слов естественного языка с использованием нейросетей
p align="left">res.letter = sLetter;

results.Add(res);

sLetter = "";

goto k;

}

m:

res.letter = sLetter;

res.Class = Scaning(sLetter, N_HID, beta, m, Epoch, flag);

results.Add(res);

if (sText[i] == '.')

{

res.Class = "точка";

res.letter = sText[i].ToString();

results.Add(res);

goto k;

}

if (sText[i] == ',')

{

res.Class = "запятая";

res.letter = sText[i].ToString();

results.Add(res);

goto k;

}

if (sText[i] == '!')

{

res.Class = "восклицательный знак";

res.letter = sText[i].ToString();

results.Add(res);

goto k;

}

if (sText[i] == '?')

{

res.Class = "вопросительный знак";

res.letter = sText[i].ToString();

results.Add(res);

goto k;

}

if (sText[i] == '-')

{

res.Class = "тире";

res.letter = sText[i].ToString();

results.Add(res);

goto k;

}

if (sText[i] == ':')

{

res.Class = "двоеточие";

res.letter = sText[i].ToString();

results.Add(res);

goto k;

}

if (sText[i] == ';')

{

res.Class = "точка с запятой";

res.letter = sText[i].ToString();

results.Add(res);

goto k;

}

k: sLetter = "";

}

else

{

sLetter = sLetter + sText[i].ToString();

}

}

}

public List<Results> GetResult()

{

return results;

}

bool flag_oy = false, flag_om = false, flag_im = false, flag_em = false, flag_ie = false, flag_mi = false;

private string GetNeuroResult(string sLetter, string sFileName, int N_HID, double beta, double m, int Epoch, bool flag)

{

string[] techears = File.ReadAllLines(sFileName + ".txt");

Binarization binar = new Binarization(techears);//проводим бинаризацию

double[,] inp = new double[1, 1], outp = new double[1, 1]; double[] test = new double[1]; //обучающая выборка, выходы, тестовая выборка

int max_inp, max_pat;//кол-во нейронов и выборок

inp = binar.GetBinarizeText(out outp, out max_pat, out max_inp);

test = binar.GetBinarizeWord(sLetter);

NeuroNetwork neuro = new NeuroNetwork(inp, outp, max_inp, N_HID, max_pat, beta, m, Epoch, sFileName, flag);//нейросеть

if (flag == false)

{

neuro.random_weights();

neuro.train_the_network();

}

string[] m_resultat = neuro.test_the_network(test);

string res1 = "", res2 = "";

switch (sFileName)

{

case "-ой":

res1 = "существительное";

res2 = "прилагательное";

break;

case "-им":

res1 = "глагол";

res2 = "прилагательное";

break;

case "-ем":

res1 = "глагол";

res2 = "существительное";

break;

case "-ом":

res1 = "существительное";

res2 = "прилагательное";

break;

case "-ие":

res1 = "прилагательное";

res2 = "существительное";

break;

case "-ми":

res1 = "прилагательное";

res2 = "существительное";

break;

}

if (double.Parse(m_resultat[0]) < 0.5 && double.Parse(m_resultat[1]) < 0.5 && double.Parse(m_resultat[2]) < 0.5)

{

return res1;

}

if (double.Parse(m_resultat[0]) < 0.5 && double.Parse(m_resultat[1]) < 0.5 && double.Parse(m_resultat[2]) > 0.5)

{

return res2;

}

return "неизвестно";

}

private string Scaning(string sLetter, int N_HID, double beta, double m, int Epoch, bool flag)

{

Hash hash = new Hash();

string result = "существительное";//результат

string[] znaks = { "с", "п", "г" };

for (int i = 0; i < znaks.Length; i++)

{

if (hash.CheckHash(sLetter + znaks[i].ToString(), "iskl") == true)

{

switch (znaks[i])

{

case "с": result = "существительное";

return result;

case "п": result = "прилагательное";

return result;

case "г": result = "глагол";

return result;

}

}

}

if (hash.CheckHash(sLetter, "predlog") == true)

{

result = "предлог";

return result;

}

if (hash.CheckHash(sLetter, "mest") == true)

{

result = "местоимение";

return result;

}

if (hash.CheckHash(sLetter, "narechie") == true)

{

result = "наречие";

return result;

}

if (hash.CheckHash(sLetter, "deepr") == true)

{

result = "деепричастие";

return result;

}

if (hash.CheckHash(sLetter, "soyuz") == true)

{

result = "союз";

return result;

}

if (String.Compare(sLetter, "не") == 0 || String.Compare(sLetter, "бы") == 0)

{

result = "частица";

return result;

}

if (sLetter.Length < 2)

{ return "предлог"; }

//--------------------------------------------------------------------

string[] pril = { "ий", "ый", "ая", "яя", "го", "ую", "ое", "их", "ых", "ым" };

string[] glagol = { "ит", "ат", "ят", "ут", "ют", "ул", "ял", "ал", "ли", "ла", "ег", "ел", "сь", "ыл", "ил" };

string[] prich = { "вший", "шими", "вшая", "вшем", "вшие", "ящий", "ящая", "ящие", "щими", "ющий", "ющая", "ющие", "ущий", "ущая", "ущие", "ащий", "ащая", "ащие", "шего", "щего" };

string okonchanie = (sLetter[sLetter.Length - 2].ToString() + sLetter[sLetter.Length - 1].ToString());

if (Array.IndexOf(pril, okonchanie)!= -1)

{

string ok_i_suff = sLetter[sLetter.Length - 4].ToString() + sLetter[sLetter.Length - 3].ToString() + okonchanie;

if (Array.IndexOf(prich, ok_i_suff)!= -1)

{

return "причастие";

}

return "прилагательное";

}

else

if (Array.IndexOf(glagol, okonchanie)!= -1)

{

return "глагол";

}

else

if (Array.IndexOf(glagol, okonchanie)!= -1)

{

return "глагол";

}

else

if (String.Compare(okonchanie, "ся") == 0)

{

string ok_i_suff = sLetter[sLetter.Length - 4].ToString() + sLetter[sLetter.Length - 3].ToString();

if (Array.IndexOf(pril, ok_i_suff)!= -1)

{

return "причастие";

}

else

{

return "глагол";

}

}

else

if (String.Compare(okonchanie, "ть") == 0)

{

char ok_i_suff = sLetter[sLetter.Length - 3];

if (ok_i_suff == 'а' || ok_i_suff == 'я' || ok_i_suff == 'ю' || ok_i_suff == 'у' || ok_i_suff == 'е' || ok_i_suff == 'и')

{

return "глагол";

}

else

{

return "существительное";

}

}

else

if (String.Compare(okonchanie, "ом") == 0)

{

string res = GetNeuroResult(sLetter, "-ом", N_HID, beta, m, Epoch, flag_om);

flag_om = true;

return res;

}

else

if (String.Compare(okonchanie, "ем") == 0)

{

string ok_i_suff = sLetter[sLetter.Length - 4].ToString() + sLetter[sLetter.Length - 3].ToString() + okonchanie;

if (Array.IndexOf(prich, ok_i_suff)!= -1)

{

return "причастие";

}

string res = GetNeuroResult(sLetter, "-ем", N_HID, beta, m, Epoch, flag_em);

flag_em = true;

return res;

}

else

if (String.Compare(okonchanie, "им") == 0)

{

string res = GetNeuroResult(sLetter, "-им", N_HID, beta, m, Epoch, flag_im);

flag_im = true;

return res;

}

else

if (String.Compare(okonchanie, "ой") == 0)

{

string res = GetNeuroResult(sLetter, "-ой", N_HID, beta, m, Epoch, flag_oy);

flag_oy = true;

return res;

}

else

if (String.Compare(okonchanie, "ие") == 0)

{

string ok_i_suff = sLetter[sLetter.Length - 4].ToString() + sLetter[sLetter.Length - 3].ToString() + okonchanie;

if (Array.IndexOf(prich, ok_i_suff)!= -1)

{

return "причастие";

}

string res = GetNeuroResult(sLetter, "-ие", N_HID, beta, m, Epoch, flag_ie);

flag_ie = true;

return res;

}

else

if (String.Compare(okonchanie, "ми") == 0)

{

string ok_i_suff = sLetter[sLetter.Length - 4].ToString() + sLetter[sLetter.Length - 3].ToString() + okonchanie;

if (Array.IndexOf(prich, ok_i_suff)!= -1)

{

return "причастие";

}

string res = GetNeuroResult(sLetter, "-ми", N_HID, beta, m, Epoch, flag_mi);

flag_mi = true;

return res;

}

else

{

return "существительное";

}

}

}

Приложение В. Листинг класса Binaryzation

class Binarization

{

string[] sLetter;

int iLengthPattern;

public Binarization(string[] sLetter1)

{

sLetter = sLetter1;

}

private string DecToBin(string value)

{

value.Trim(); // очищаем строку от пробелов

char[] array = null; /* массив для хранения двоичных чисел ввиде символов */

int degree = Convert.ToInt32(value) / 255; /* получаем степень возведения для отображения количества 0 в массиве */

if (degree <= 255 && Convert.ToInt32(value) <= 255) /* если степень входит в стандартный диапазон 8 цифр */

array = new char[8];

else /* иначе вычисляем наш диапазон цифр */

{

if (degree == 1) /* если оставить 1, то получится первое условие, а нам надо чтобы выполнилось второе */

degree++;

array = new char[8 * degree];

}

int position = array.Length - 1; /* двоичные цифры считаются с конца в начало, соответственно писать мы их будем, тоже с конца в начало */

int nextValue = Convert.ToInt32(value); /* здесь будет хранится наше значение, которое мы будем делить на 2 и проверять есть ли остаток от деления */

for (int i = 0; i < array.Length; i++) /* в этом цикле мы будем заполнять наш массив значениями */

{

if ((Convert.ToInt32(nextValue) % 2)!= 0) /* проверяем есть ли остаток от деления */

{

nextValue /= 2; /* в любом случае записываем результат, для дальнейших расчетов */

array[position] = '1'; /* устанавливаем 1 если остаток есть */

}

else

{

nextValue /= 2; /* в любом случае записываем результат, для дальнейших расчетов */

array[position] = '0'; /* устанавливаем 0 если остатка нет */

}

position--; /* уменьшаем итератор */

}

string ret = ""; // пустая строка для хранения результата

for (int i = 0; i < array.Length; i++) /* в этом цикле уже записываем в нашу строку, наше двоичное число, с начала и до конца */

ret += array[i].ToString();

return ret;

}

public double[] GetBinarizeWord(string sWord)

{

int iSum = 0; string sBuf = ""; int k = 0;

for (int j = 0; j < sWord.Length; j++)

{

iSum = iSum + (j + 5) * Char.ConvertToUtf32(sWord[j].ToString(), 0);

}

sBuf = DecToBin(iSum.ToString());

k = 0;

while (sBuf[k]!= '1')

{

k++;

}

sBuf = sBuf.Substring(k, sBuf.Length - 1 - k);

double[] test = new double[iLengthPattern];

for (int j = 0; j < iLengthPattern; j++)

{

if (sBuf.Length <= j)

{

test[j] = 0;

}

else

if (sBuf[j] == '1')

{

test[j] = 1;

}

}

return test;

}

public double[,] GetBinarizeText(out double[,] OUT_PATTERNS, out int max_pat, out int iLengthPattern1)

{

max_pat = sLetter.Length;

OUT_PATTERNS = new double[sLetter.Length, 3];

int iSum = 0; string sBuf; int k = 0; iLengthPattern1 = 0; string[] sBigBuf = new string[sLetter.Length];

for (int i = 0; i < sLetter.Length; i++)

{

iSum = 0;

for (int j = 0; j < sLetter[i].Length - 1; j++)

{

iSum = iSum + (j + 5) * Char.ConvertToUtf32(sLetter[i][j].ToString(), 0);

}

switch (sLetter[i][sLetter[i].Length - 1])

{

case '@': OUT_PATTERNS[i, 0] = 0; OUT_PATTERNS[i, 1] = 0;

OUT_PATTERNS[i, 2] = 0;

break;

case '#': OUT_PATTERNS[i, 0] = 0; OUT_PATTERNS[i, 1] = 0;

OUT_PATTERNS[i, 2] = 1;

break;

case '*': OUT_PATTERNS[i, 0] = 0; OUT_PATTERNS[i, 1] = 1;

OUT_PATTERNS[i, 2] = 0;

break;

case '(': OUT_PATTERNS[i, 0] = 0; OUT_PATTERNS[i, 1] = 1;

OUT_PATTERNS[i, 2] = 1;

break;

case '-': OUT_PATTERNS[i, 0] = 1; OUT_PATTERNS[i, 1] = 0;

OUT_PATTERNS[i, 2] = 0;

break;

case '/': OUT_PATTERNS[i, 0] = 1; OUT_PATTERNS[i, 1] = 0;

OUT_PATTERNS[i, 2] = 1;

break;

case '+': OUT_PATTERNS[i, 0] = 1; OUT_PATTERNS[i, 1] = 1;

OUT_PATTERNS[i, 2] = 0;

break;

}

sBuf = DecToBin(iSum.ToString());

k = 0;

while (sBuf[k]!= '1')

{

k++;

}

sBuf = sBuf.Substring(k, sBuf.Length - 1 - k);

if (sBuf.Length > iLengthPattern1)

{

iLengthPattern1 = sBuf.Length;

}

sBigBuf[i] = sBuf;

}

double[,] inp = new double[sLetter.Length, iLengthPattern1];

for (int i = 0; i < sLetter.Length; i++)

{

for (int j = 0; j < iLengthPattern1; j++)

{

if (sBigBuf[i].Length <= j)

{

inp[i, j] = 0;

}

else

if (sBigBuf[i][j] == '1')

{

inp[i, j] = 1;

}

}

}

iLengthPattern = iLengthPattern1;

return inp;

}

}

Страницы: 1, 2, 3, 4, 5, 6, 7



© 2003-2013
Рефераты бесплатно, курсовые, рефераты биология, большая бибилиотека рефератов, дипломы, научные работы, рефераты право, рефераты, рефераты скачать, рефераты литература, курсовые работы, реферат, доклады, рефераты медицина, рефераты на тему, сочинения, реферат бесплатно, рефераты авиация, рефераты психология, рефераты математика, рефераты кулинария, рефераты логистика, рефераты анатомия, рефераты маркетинг, рефераты релиния, рефераты социология, рефераты менеджемент.