Распознавание слов естественного языка с использованием нейросетей
Анализ нейронных сетей и выбор их разновидностей. Модель многослойного персептрона с обучением по методу обратного распространения ошибки. Проектирование библиотеки классов для реализации нейросети и тестовой программы, описание тестирующей программы.
| Рубрика | Программирование, компьютеры и кибернетика |
| Вид | курсовая работа |
| Язык | русский |
| Дата добавления | 19.06.2010 |
| Размер файла | 515,4 K |
Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
{
for (int i = 0; i < MAX_HID; i++) //{Подстройка}
{
ol[j].change[i] = BETA * ol[j].E * hl[i].a + M * ol[j].change[i];
ol[j].w[i] = ol[j].w[i] + ol[j].change[i];
}
// {Подстройка значения порога}
ol[j].t_change = BETA * ol[j].E * 1 + M * ol[j].t_change;
//--------------------
ol[j].threshold = ol[j].threshold + ol[j].t_change;
//----------------------------
}
// {Модифицируем веса между входным слоем и скрытым слоем}
// {i -нейрон входного слоя, j -скрытого}
for (int j = 0; j < MAX_HID; j++)
{
for (int i = 0; i < MAX_INP; i++)
{
hl[j].change[i] = BETA * hl[j].E * ipl[i].a + M * hl[j].change[i];
hl[j].w[i] = hl[j].w[i] + hl[j].change[i];
}
hl[j].t_change = BETA * hl[j].E * 1 + M * hl[j].t_change;
//-------------------------------------
hl[j].threshold = hl[j].threshold + hl[j].t_change;
}
// {Модифицируем веса между входами и входным слоем }
// {i -входной образ, j - нейроны входного слоя}
for (int j = 0; j < MAX_INP; j++)
{
for (int i = 0; i < MAX_INP; i++)
{
ipl[j].change[i] = BETA * ipl[j].E * test_pat[i] + M * ipl[j].change[i];
ipl[j].w[i] = ipl[j].w[i] + ipl[j].change[i];
}
ipl[j].t_change = BETA * ipl[j].E * 1 + M * ipl[j].t_change;
ipl[j].threshold = ipl[j].threshold + ipl[j].t_change;
}
}
//{Выполнение алгоритма back propagation }
private void back_propagate()
{
calculate_output_layer_errors();
calculate_hidden_layer_errors();
calculate_input_layer_errors();
weight_change();
}
//{Инициализация весовых коэффициентов и порогов}
public void random_weights()
{
Random rnd = new Random();
for (int i = 0; i < MAX_INP; i++)
{
ipl[i].w = new double[MAX_INP]; // {весовые коэффициенты}
ipl[i].change = new double[MAX_INP];
}
for (int i = 0; i < MAX_HID; i++)
{
hl[i].w = new double[MAX_INP]; // {весовые коэффициенты}
hl[i].change = new double[MAX_INP];
}
for (int i = 0; i < MAX_OUT; i++)
{
ol[i].w = new double[MAX_HID]; // {весовые коэффициенты}
ol[i].change = new double[MAX_HID];
}
for (int i = 0; i < MAX_INP; i++)
{
for (int j = 0; j < MAX_INP; j++)
{ ipl[i].w[j] = (double)rnd.Next(1000) / 1000; }
ipl[i].threshold = (double)rnd.Next(1000) / 1000;
}
for (int i = 0; i < MAX_HID; i++)
{
for (int j = 0; j < MAX_INP; j++)
{ hl[i].w[j] = (double)rnd.Next(1000) / 1000; }
hl[i].threshold = (double)rnd.Next(1000) / 1000;
}
for (int i = 0; i < MAX_OUT; i++)
{
for (int j = 0; j < MAX_HID; j++)
{ ol[i].w[j] = (double)rnd.Next(1000) / 1000; }
ol[i].threshold = (double)rnd.Next(1000) / 1000;
}
}
private void ExtractWeights()
{
for (int i = 0; i < MAX_INP; i++)
{
ipl[i].w = new double[MAX_INP]; // {весовые коэффициенты}
ipl[i].change = new double[MAX_INP];
}
for (int i = 0; i < MAX_HID; i++)
{
hl[i].w = new double[MAX_INP]; // {весовые коэффициенты}
hl[i].change = new double[MAX_INP];
}
for (int i = 0; i < MAX_OUT; i++)
{
ol[i].w = new double[MAX_HID]; // {весовые коэффициенты}
ol[i].change = new double[MAX_HID];
}
if (File.Exists(filename + "ip.txt") == true && File.Exists(filename + "ol.txt") == true && File.Exists(filename + "hl.txt") == true)
{
StreamReader streamreader = new StreamReader(filename + "ip.txt");
for (int i = 0; i < ipl.Length; i++)
{
ipl[i].a = double.Parse(streamreader.ReadLine());
ipl[i].threshold = double.Parse(streamreader.ReadLine());
for (int j = 0; j < ipl[i].w.Length; j++)
{
ipl[i].w[j] = double.Parse(streamreader.ReadLine());
}
}
streamreader.Close();
streamreader = new StreamReader(filename + "ol.txt");
for (int i = 0; i < ol.Length; i++)
{
ol[i].a = double.Parse(streamreader.ReadLine());
ol[i].threshold = double.Parse(streamreader.ReadLine());
for (int j = 0; j < ol[i].w.Length; j++)
{
ol[i].w[j] = double.Parse(streamreader.ReadLine());
}
}
streamreader.Close();
streamreader = new StreamReader(filename + "hl.txt");
for (int i = 0; i < hl.Length; i++)
{
hl[i].a = double.Parse(streamreader.ReadLine());
hl[i].threshold = double.Parse(streamreader.ReadLine());
for (int j = 0; j < hl[i].w.Length; j++)
{
hl[i].w[j] = double.Parse(streamreader.ReadLine());
}
}
streamreader.Close();
}
else
{
File.Create(filename + "ip.txt");
File.Create(filename + "ol.txt");
File.Create(filename + "hl.txt");
}
}
//-------------------------------------------------------------
private void AddWeightsToFile()
{
StreamWriter streamwriter = new StreamWriter(filename + "ip.txt");
for (int i = 0; i < ipl.Length; i++)
{
streamwriter.WriteLine(ipl[i].a.ToString());
streamwriter.WriteLine(ipl[i].threshold.ToString());
for (int j = 0; j < ipl[i].w.Length; j++)
{
streamwriter.WriteLine(ipl[i].w[j].ToString());
streamwriter.Flush();
}
streamwriter.Flush();
}
streamwriter.Close();
streamwriter = new StreamWriter(filename + "hl.txt");
for (int i = 0; i < hl.Length; i++)
{
streamwriter.WriteLine(hl[i].a.ToString());
streamwriter.WriteLine(hl[i].threshold.ToString());
for (int j = 0; j < hl[i].w.Length; j++)
{
streamwriter.WriteLine(hl[i].w[j].ToString());
streamwriter.Flush();
}
streamwriter.Flush();
}
streamwriter.Close();
streamwriter = new StreamWriter(filename + "ol.txt");
for (int i = 0; i < ol.Length; i++)
{
streamwriter.WriteLine(ol[i].a.ToString());
streamwriter.WriteLine(ol[i].threshold.ToString());
for (int j = 0; j < ol[i].w.Length; j++)
{
streamwriter.WriteLine(ol[i].w[j].ToString());
streamwriter.Flush();
}
streamwriter.Flush();
}
streamwriter.Close();
}
private void blank_changes()
{
for (int j = 0; j < MAX_INP; j++)
{
for (int i = 0; i < MAX_INP; i++)
{ ipl[j].change[i] = 0; }
ipl[j].t_change = 0;
}
for (int j = 0; j < MAX_HID; j++)
{
for (int i = 0; i < MAX_INP; i++)
{ hl[j].change[i] = 0; }
hl[j].t_change = 0;
}
for (int j = 0; j < MAX_OUT; j++)
{
for (int i = 0; i < MAX_HID; i++)
{ ol[j].change[i] = 0; }
ol[j].t_change = 0;
}
}
public void train_the_network()
{
blank_changes(); // {Очистка предыдущих значений changes}
for (int loop = 0; loop < num_cycles; loop++)
{
for (int pat = 0; pat < MAX_PAT; pat++)
{
for (int i = 0; i < MAX_INP; i++) //{Копирование входного образа}
{ test_pat[i] = INP_PATTERNS[pat, i]; } //{в массив 'test_pat' }
for (int i = 0; i < MAX_OUT; i++) //{Копирование выходного образа}
{ desired[i] = OUT_PATTERNS[pat, i]; } //{ в массив'desired' }
run_the_network(); //{Определение выходов сети}
back_propagate();
}
}
AddWeightsToFile();
}
}
Приложение Б. Листинг класса Analization
public class Analization
{
List<Results> results = new List<Results>();
public static void AddToFile(string sLetter, string sFile)
{
FileStream filestream = File.Open(sFile + ".txt", FileMode.Append, FileAccess.Write);
StreamWriter streamwriter = new StreamWriter(filestream);
streamwriter.WriteLine(sLetter);
streamwriter.Close();
filestream.Close();
}
private void AddEtalonLetter()
{
string[] im = { "смотрим@", "носим@", "ходим@", "бродим@", "катим@", "синим#", "большим#", "тугим#", "крайним#" };
if (File.Exists("-им.txt") == false)
{
FileStream filestream = File.Open("-им.txt", FileMode.CreateNew, FileAccess.Write);
StreamWriter streamwriter = new StreamWriter(filestream);
for (int i = 0; i < im.Length; i++)
{
streamwriter.WriteLine(im[i]);
}
streamwriter.Close();
filestream.Close();
}
string[] om = { "столом@", "стулом@", "ковром@", "городом@", "селом@", "красном#", "туманном#", "тяжелом#", "легком#" };
if (File.Exists("-ом.txt") == false)
{
FileStream filestream = File.Open("-ом.txt", FileMode.CreateNew, FileAccess.Write);
StreamWriter streamwriter = new StreamWriter(filestream);
for (int i = 0; i < om.Length; i++)
{
streamwriter.WriteLine(om[i]);
}
streamwriter.Close();
filestream.Close();
}
string[] oy = { "ручкой@", "краской@", "бумагой@", "оградой@", "каймой@", "большой#", "небольшой#", "тугой#", "малой#" };
if (File.Exists("-ой.txt") == false)
{
FileStream filestream = File.Open("-ой.txt", FileMode.CreateNew, FileAccess.Write);
StreamWriter streamwriter = new StreamWriter(filestream);
for (int i = 0; i < oy.Length; i++)
{
streamwriter.WriteLine(oy[i]);
}
streamwriter.Close();
filestream.Close();
}
string[] em = { "кидаем@", "бросаем@", "стережем@", "бережем@", "блюдем@", "гребнем#", "камнем#", "ставнем#", "гравием#" };
if (File.Exists("-ем.txt") == false)
{
FileStream filestream = File.Open("-ем.txt", FileMode.CreateNew, FileAccess.Write);
StreamWriter streamwriter = new StreamWriter(filestream);
for (int i = 0; i < em.Length; i++)
{
streamwriter.WriteLine(em[i]);
}
streamwriter.Close();
filestream.Close();
}
string[] ie = { "большие@", "синие@", "маленькие@", "хорошие@", "плохие@", "хождение#", "мероприятие#", "становление#", "украшение#" };
if (File.Exists("-ие.txt") == false)
{
FileStream filestream = File.Open("-ие.txt", FileMode.CreateNew, FileAccess.Write);
StreamWriter streamwriter = new StreamWriter(filestream);
for (int i = 0; i < ie.Length; i++)
{
streamwriter.WriteLine(ie[i]);
}
streamwriter.Close();
filestream.Close();
}
string[] mi = { "красными@", "зелеными@", "хорошими@", "плохими@", "трудными@", "стульями#", "столами#", "ставнями#", "карандашами#" };
if (File.Exists("-ми.txt") == false)
{
FileStream filestream = File.Open("-ми.txt", FileMode.CreateNew, FileAccess.Write);
StreamWriter streamwriter = new StreamWriter(filestream);
for (int i = 0; i < mi.Length; i++)
{
streamwriter.WriteLine(mi[i]);
}
streamwriter.Close();
filestream.Close();
}
}
public string BigToSmall(string letter)
{
switch (letter)
{
case "А": return "а";
case "Б": return "б";
case "В": return "в";
case "Г": return "г";
case "Д": return "д";
case "Е": return "е";
case "Ё": return "ё";
case "Ж": return "ж";
case "З": return "з";
case "И": return "и";
case "Й": return "й";
case "К": return "к";
case "Л": return "л";
case "М": return "м";
case "Н": return "н";
case "О": return "о";
case "П": return "п";
case "Р": return "р";
case "С": return "с";
case "Т": return "т";
case "У": return "у";
case "Ф": return "ф";
case "Х": return "х";
case "Ц": return "ц";
case "Ч": return "ч";
case "Ш": return "ш";
case "Щ": return "щ";
case "Ъ": return "ъ";
case "Ы": return "ы";
case "Ь": return "ь";
case "Э": return "э";
case "Ю": return "ю";
case "Я": return "я";
}
return "ё";
}
public Analization(string sText, int N_HID, double beta, double m, int Epoch, bool flag)
{
AddEtalonLetter();
Results res;
string sLetter = "";
for (int i = 0; i < sText.Length; i++)
{
if (sText[i] == ' ' || sText[i] == '.' || sText[i] == ',' || sText[i] == '!' || sText[i] == '?' || sText[i] == '-' || sText[i] == ':' || sText[i] == ';')
{
if (sLetter == "")
{
goto k;
}
if ((Char.ConvertToUtf32(sLetter, 0) >= 1040 && Char.ConvertToUtf32(sLetter, 0) <= 1071))
{
if (i - sLetter.Length + 1 == 1)
{
string ch = BigToSmall(sLetter[0].ToString());
sLetter = ch + sLetter.Substring(1, sLetter.Length - 1);
goto m;
}
else
if (sText[i - sLetter.Length - 1] == ' ' && sText[i - sLetter.Length - 2] == '.')
{
string ch = BigToSmall(sLetter[0].ToString());
sLetter = ch + sLetter.Substring(1, sLetter.Length - 1);
goto m;
}
res.Class = "существительное";
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;
}
}
Подобные документы
Рассмотрение способов применения и основных понятий нейронных сетей. Проектирование функциональной структуры автоматизированной системы построения нейросети обратного распространения ошибки, ее классов и интерфейсов. Описание периода "бета тестирования".
дипломная работа [3,0 M], добавлен 02.03.2010Диагностический анализ изучения алгоритмов обучения нейронных сетей "с учителем". Сбор входных и выходных переменных для наблюдений и понятие пре/пост процессирования. Подготовка и обобщение многослойного персептрона, модель обратного распространения.
курсовая работа [249,3 K], добавлен 22.06.2011Общие сведения о принципах построения нейронных сетей. Искусственные нейронные системы. Математическая модель нейрона. Классификация нейронных сетей. Правила обучения Хэбба, Розенблатта и Видроу-Хоффа. Алгоритм обратного распространения ошибки.
дипломная работа [814,6 K], добавлен 29.09.2014Обучение нейронных сетей как мощного метода моделирования, позволяющего воспроизводить сложные зависимости. Реализация алгоритма обратного распространения ошибки на примере аппроксимации функции. Анализ алгоритма обратного распространения ошибки.
реферат [654,2 K], добавлен 09.06.2014Разработка систем автоматического управления. Свойства нейронных сетей. Сравнительные оценки традиционных ЭВМ и нейрокомпьютеров. Формальная модель искусственного нейрона. Обучение нейроконтроллера при помощи алгоритма обратного распространения ошибки.
реферат [1,4 M], добавлен 05.12.2010Основные отличия нейросетей от других методов. Неформализуемые и трудно формализуемые задачи. Моделирование интеллектуальной деятельности человека. Оценка стоимости квартир в Перми с использованием нейронных сетей. Проектирование и обучение нейросети.
презентация [139,4 K], добавлен 14.08.2013Принцип работы нейросетей и модели синтеза. Ключевые моменты проблемы распознавания речи. Система распознавания речи как самообучающаяся система. Описание системы: ввод звука, наложение первичных признаков на вход нейросети, модель и обучение нейросети.
курсовая работа [215,2 K], добавлен 19.10.2010Обучение простейшей и многослойной искусственной нейронной сети. Метод обучения перцептрона по принципу градиентного спуска по поверхности ошибки. Реализация в программном продукте NeuroPro 0.25. Использование алгоритма обратного распространения ошибки.
курсовая работа [1019,5 K], добавлен 05.05.2015Требования к тестовому контролю. Разработка электронной контролирующей программы по спецдисциплинам, направленной на упрощение проведения проверочных работ. Инструкция пользователю и программисту. Определение затрат на создание тестирующей программы.
курсовая работа [4,9 M], добавлен 15.10.2013Обзор и анализ распространенных искусственных нейронных сетей. Функциональное назначение слоев сети, алгоритмы обучения. Описание функциональных возможностей разработанной программной системы. Анализ исследовательской эксплуатации и возможных применений.
дипломная работа [1,3 M], добавлен 19.05.2011
