Системные требования:

- Для корректной работы приложения необходимо наличие на компьютере программы Microsoft.NET Framework 2.0

- Операционные системы: Windows 2000 Service Pack 3; Windows 98; Windows 98 Second Edition; Windows ME; Windows Server 2003; Windows XP Service Pack 2

- Требуемое программное обеспечение: установщик Windows 3.0 (кроме ОС Windows 98/ME, для которых требуется Установщик Windows 2.0 или более поздней версии). Рекомендуется Установщик Windows 3.1 или более поздней версии. Обозреватель IE 5.01 или более поздней версии: Для установки.NET Framework требуется обозреватель Microsoft Internet Explorer 5.01 или более поздней версии.

Заключение

В данном курсовом проекте была разработана программа-анализатор слов естественного языка с использованием нейросети.

В ходе выполнения данного курсового проекта была разработана библиотека, содержащая классы для лексического анализа слов естественного языка с использованием нейросети (для решения поставленной задачи была выбрана нейросеть обратного распространения ошибки), была написана тестирующая программа, подготовлены тесты. При тестировании, после соответствующей настройки, программа не допустила ни одной ошибки.

Данный программный продукт может быть использован специалистами в области филолигии.

Список используемой литературы

Комарцова Л.Г., Максимов А.В.. Нейрокомпьютеры Учебное пособие для вузов. - М.: Изд-во МГТУ им. Н.Э.Баумана,2002.

Осовский С. Нейронные сети для обработки информации.-М.:Финансы и статистика, 2004.

Уоссермен Ф. Нейрокомпьютерная техника: теория и практика. -- М.: Мир, 1992.

Ключко В.И., Ермоленко В.В. Нейрокомпьютерные системы. Базы знаний. Учеб. пособие Изд-во КубГТУ,1999.-100с.

Приложение А. Листинг класса NeuroNetwork

class NeuroNetwork

{

struct neuron_type

{

public double[] w;//=new double[MAX_INP]; // {весовые коэффициенты}

public double[] change;//=new double[MAX_INP];//{модификация весовых коэффициентов используется в процессе обучения}

public double threshold, a; // {а-сигнал на выходе нейрона,threshold-значение порога}

public double t_change; // {модификация порога используется в процессе обучения}

public double E; // {значение ошибки}

}

double[,] INP_PATTERNS;

double[,] OUT_PATTERNS;

int MAX_INP; //{Количество нейронов в входном слое}

int MAX_HID; //{Количество нейронов в скрытом слое}

int MAX_OUT; // {Количество нейронов в выходном слое

int MAX_PAT; // {Количество образов для обучения}

double[] test_pat;

double[] desired;

neuron_type[] ipl; // {Входной слой }

neuron_type[] hl; // {Скрытый слой }

neuron_type[] ol; // {Выходной слой }

double BETA = 0.8; // {Коэффициент обучения}

double M = 0.8; //{момент}

int num_cycles = 1000;

string filename;

public NeuroNetwork(double[,] INP_PATTERNS1/*выборка*/, double[,] OUT_PATTERNS1/*желаемый выход*/, int Max_inp/*кол-во символов в слове*/, int N_HID, int Max_pat/*максмальное кол-во выборок, double beta, double m, int Epoch, string name, bool indicate)

{

filename = name;

num_cycles = Epoch;

// elemKolvo = elemKol;

BETA = beta; M = m;

MAX_INP = Max_inp; //{Количество нейронов в входном слое}

MAX_HID = N_HID; //{Количество нейронов в скрытом слое}

MAX_OUT = 3; //int IPi;

MAX_PAT = Max_pat;

INP_PATTERNS = INP_PATTERNS1;

OUT_PATTERNS = OUT_PATTERNS1;

test_pat = new double[MAX_INP];

desired = new double[MAX_OUT];

ipl = new neuron_type[MAX_INP]; // {Входной слой }

hl = new neuron_type[MAX_HID]; // {Скрытый слой }

ol = new neuron_type[MAX_OUT];

if (indicate == true)

{

try { ExtractWeights(); }

catch { }

}

}

private double sigmoid(double x) // {функция активации}

{

if (Math.Abs(x) < 38) // {проверка условия нахождения функции в интервале -39..38}

{ return 1 / (1 + Math.Exp(-x)); }

else

{

if (x >= 38)

{ return 1; }

else { return 0; }

}

}

//{Вычисление суммы взвешенных сигналов для входного набора данных}

private void run_input_layer()

{

double sum = 0;

for (int i = 0; i < MAX_INP; i++)

{

sum = 0;

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

{ sum = sum + ipl[i].w[j] * test_pat[j]; }

ipl[i].a = sigmoid(sum - ipl[i].threshold);

}

}

//{Вычисление суммы взвешенных сигналов для скрытого слоя}

private void run_hidden_layer()

{

double sum;

for (int i = 0; i < MAX_HID; i++)

{

sum = 0;

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

{ sum = sum + hl[i].w[j] * ipl[j].a; }

hl[i].a = sigmoid(sum - hl[i].threshold);

}

}

//{Вычисление суммы взвешенных сигналов для выходного слоя}

private void run_output_layer()

{

double sum;

for (int i = 0; i < MAX_OUT; i++)

{

sum = 0;

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

{ sum = sum + ol[i].w[j] * hl[j].a; }

ol[i].a = sigmoid(sum - ol[i].threshold);

}

}

private void run_the_network()

{

run_input_layer();

run_hidden_layer();

run_output_layer();

}

//{Процедура выводит на экран результаты теста}

private void display_the_results(out string[] outp)

{

outp = new string[ol.Length];

for (int i = 0; i < MAX_OUT; i++)

{ outp[i] = ol[i].a.ToString() + " "; }

}

// {Процедуры для тестирования сети до и после обучения}

public void get_test_pattern(double[] tests)

{

test_pat = tests;

}

public string[] test_the_network(double[] test)

{

test_pat = test;

Console.WriteLine();

Console.WriteLine("Процедура тестирования сети");

Console.WriteLine();

string[] str;

run_the_network();

display_the_results(out str);

return str;

}

// {Процедуры обучения сети}

private void calculate_output_layer_errors()

{

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

{ ol[j].E = (desired[j] - ol[j].a) * ol[j].a * (1 - ol[j].a); }

}

private void calculate_hidden_layer_errors()

{

double sum;

for (int i = 0; i < MAX_HID; i++)

{

sum = 0; // {Сумма ошибок выходного слоя}

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

{ sum = sum + ol[j].E * ol[j].w[i]; }

hl[i].E = hl[i].a * (1 - hl[i].a) * sum;

}

}

private void calculate_input_layer_errors()

{

double sum;

for (int i = 0; i < MAX_INP; i++)

{

sum = 0; // {Сумма ошибок скрытого слоя}

for (int j = 1; j < MAX_HID; j++)

{ sum = sum + hl[j].E * hl[j].w[i]; }

ipl[i].E = ipl[i].a * (1 - ipl[i].a) * sum;

}

}

private void weight_change()

{

for (int j = 0; j < MAX_OUT; j++) //{выходной слой}

{

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++)

{