Нейросеть / Отчёт

МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РФ

Бийский технологический институт (филиал)

федерального государственного бюджетного образовательного

учреждения высшего образования

«Алтайский государственный технический университет

им. И.И. Ползунова»

Технологический факультет

Кафедра М Методов и средств измерения и автоматизации и

Отчет защищен с оценкой

_________________________________

А.Н. Павлов

(подпись преподавателя) (инициалы, фамилия)

«____» ___________ 2018 г.

Отчет

по лабораторной работе № 2 .

Искусственные нейронные сети

(название лабораторной работы)

по дисциплине «Интеллектуальные системы и технологии»

(наименование дисциплины)

ЛР 09.03.02.01.000 ОТ Т

(обозначение документа)

Студент группы ИСТ-

подпись (инициалы, фамилия)

Преподаватель доц. каф. МСИА, к.т.н. А.Н. Павлов

(должность, ученое звание) подпись (инициалы, фамилия)

БИЙСК 2018

Цель работы: закрепление, углубление и расширение знаний студентов в области искусственных нейронных сетей в процессе выполнения конкретной практической задачи по распознаванию графических объектов.

Задания:

• реализовать модель искусственной нейронной сети со следующей конфигурацией: первый слой — 30; второй слой — 25; третий слой —4. Сеть должна распознавать графические объекты в виде матрицы 5x6 – графические примитивы и цифры;

• обучить сеть, созданную в предыдущем задание, используя алгоритм обратного распространения;

• исследовать помехоустойчивость и надежность обученной искусственной нейронной сети.

Ход работы

В ходе лабораторной работы была создана нейронная сеть, которая распознает графические объекты, представленные на рисунке 1.

А) Б) В) Г) Д) Е) Ж) З) И) К)

Рисунок 1 – Входные изображения обучающего множества

Вычисление в нейросети представляет собой преобразование входного вектора 𝑜𝑢𝑡𝑠[0][0 . . .𝑁н.max] в выходной вектор 𝑜𝑢𝑡𝑠[𝑁сл][0 . . .𝑁н.min] в соответствии со следующим алгоритмом. Слой за слоем, начиная с ближайшего к входу, выполняется «проход вперед», вычисляя величины 𝑛𝑒𝑡 и 𝑜𝑢𝑡𝑠 для каждого нейрона. Величина 𝑛𝑒𝑡 каждого нейрона вычисляется как взвешенная сумма его входов:

Затем 𝑛𝑒𝑡 «сжимается» активационной функцией и получается величина 𝑜𝑢𝑡𝑠:

Так же нейронная сеть была обучена алгоритмом обратного распространения.

Обучение сети обратного распространения требует выполнения

следующих операций.

1. Выбрать обучающую пару и подать входной вектор на вход сети.

2. Вычислить выход сети проходом вперед.

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

4. Повторить шаги с 1 по 3 для каждого вектора обучающего множества до тех пор, пока ошибка на всем множестве не достигнет приемлемого уровня 𝐸п.

При выполнении обратного прохода для каждого слоя, начиная с выходного, выполняются следующие операции.

1. Для каждого нейрона текущего слоя вычисляется сигнал ошибки 𝜀:

Далее ошибка 𝜀 умножается на производную сжимающей функции и вычисляется величина 𝛿𝑘,𝑖:

2. Корректируются веса, связанные с текущим слоем. Для чего величина 𝛿𝑘,𝑖 умножается на величину 𝑜𝑢𝑡𝑠 нейрона 𝑗 из слоя [𝑘 −1], из которого выходит рассматриваемый вес. Это произведение в свою очередь умножается на коэффициент скорости обучения 𝜂, и результат прибавляется к весу:

Обратный проход можно реализовать в виде процедуры goBack. Ошибка обучения определяется на всем обучающем множестве, т.е. необходимо для каждого шаблона вычислить выход сети и оценить ошибку в соответствии с целевым вектором. Например, можно использовать выражение для среднеквадратического отклонения:

Результат выполнения программы приведен на рисунке 2.

Рисунок 2 – Обученная нейронная сеть.

Нейронная сеть была исследована на помехоустойчивость и надежность.

Алгоритм исследования нейросети на помехоустойчивость.

Провести серию исследований для каждого из шаблонов, выполняя следующие действия:

1) скопировать в файл «input.txt» исходный шаблон 𝑚;

2) «зашумить» входное изображение, изменив произвольным образом один случайно выбранный пиксель изображения (поменять 0 на 1 или наоборот — 1 на 0);

3) вычислить выход сети, выбрав пункт меню «Calc input», и зафиксировать полученную ошибку для исследуемого шаблона 𝜎𝑖,𝑚;

4) повторить шаги 2 и 3, пока количество «зашумленных» пикселей 𝑖 не достигнет 5.

Средняя ошибка определяется в соответствии с выражением:

После заполнения таблицы оценить, на сколько процентов можно «зашумить» входное изображение, чтобы средняя ошибка не превышала «рабочего» порогового значения 𝐸п.раб = 0,2.

Изменяя количество нейронов во внутренних слоях (по умолчанию 𝑠𝑡𝑟𝑢𝑐[1] = 30 и 𝑠𝑡𝑟𝑢𝑐[2] = 25), можно смоделировать выход из строя определенного количества нейронов. Далее необходимо определить ошибку по всему множеству, изменяя количество отказавших нейронов от 1 до 5 в различных комбинациях для внутренних слоев. Оценить, сколько процентов нейронов может быть повреждено без превышения ошибки «рабочего» порогового значения 𝐸п.раб =0,1.

На рисунке 3 представлена таблица с результатом исследования нейронной сети на помехоустойчивость.

Рисунок 3 – Результаты исследования.

На рисунке 4 представлена таблица с результатом исследования таблицы на надежность.

Рисунок 4 – Результаты исследования

Код программы представлен на листинге

#include <iostream>

#include <fstream>

#include <cstdlib>

#include <ctime>

using namespace std;

const int NSL = 3;

const int NMAX = 30;

const int NMIN = 4;

const int NSH = 10;

const int N = 1;

const float EPS = 0.01;

const int NU = 10000;

int struc[NSL + 1] = { NMAX,30,25,NMIN };

int i, j, k, m, c;

float net;

float outs[NSL + 1][NMAX];

float w[NSL + 1][NMAX][NMAX];

float pattern[NSH][NMAX];

float target[NSH][NMIN];

float b[NSL + 1][NMAX];

float e;

ifstream f;

void NeuroCalc() {

for (k = 1; k <= NSL; k++)

for (i = 0; i < struc[k]; i++) {

net = 0;

for (j = 0; j < struc[k - 1]; j++)

net += outs[k - 1][j] * w[k][j][i];

outs[k][i] = 1 / (1 + exp(-net));

}

}

float calcErr(int m) {

float sum = 0;

for (i = 0; i < NMIN; i++)

sum += pow(target[m][i] - outs[NSL][i], 2);

return sqrt(sum / NMIN);

}

void loadPatterns() {

f.open("patterns.txt");

if (!f) cout << "Can't open file!";

else {

while (!f.eof()) {

f >> m;

cout << m << ' ';

for (i = 0; i<NMAX; i++)

f >> pattern[m][i];

for (i = 0; i<NMIN; i++)

f >> target[m][i];

}

f.close();

}

}

void printNeuroNet() {

cout << "Input:" << endl;

for (i = 0; i < NMAX; i++) {

if (outs[0][i] == 1)

cout << char(219);

else cout << char(176);

if ((i + 1) % 5 == 0)

cout << '\n';

}

cout << '\n';

cout << "Output:" << endl;

for (i = 0; i<NMIN; i++) {

cout << outs[NSL][i] << ' ';

}

cout << '\n';

cout << "Target: " << endl;

for (i = 0; i<NMIN; i++) {

cout << target[m][i] << ' ';

}

cout << '\n';

}

double calcSumErr() {

double sum = 0;

for (c = 0; c < NSH; c++) {

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

outs[0][i] = pattern[c][i];

NeuroCalc();

sum = sum + pow(calcErr(c), 2);

}

return (sqrt(sum / NSH));

}

void goBack() {

for (int k = NSL; k >= 1; k--) {

for (int i = 0; i < struc[k]; i++) {

if (k == NSL)

e = target[m][i] - outs[k][i];

else {

e = 0;

for (int c = 0; c < struc[k + 1]; c++)

e = e + b[k + 1][c] * w[k + 1][i][c];

}

b[k][i] = outs[k][i] * (1 - outs[k][i])*e;

for (int j = 0; j < struc[k - 1]; j++)

w[k][j][i] = w[k][j][i] + N * b[k][i] * outs[k - 1][j];

}

}

}

void educate() {

int count = 0;

m = 0;

do {

for (int i = 0; i<NMAX; i++) outs[0][i] = pattern[m][i];

NeuroCalc();

goBack();

if (m == NSH - 1) m = 0;

else m++;

count++;

} while (calcSumErr() > EPS && count < NU);

cout << count << endl;

cout << " Sum error: " << calcSumErr() << endl;

}

void calcPattern() {

cout << "Type pattern number:" << endl;

cin >> m;

for (i = 0; i<NMAX; i++) outs[0][i] = pattern[m][i];

NeuroCalc();

printNeuroNet();

cout << "Error: " << calcErr(m) << endl;

}

void calcInput() {

f.open("input.txt");

if (!f) cout << "Can't open file!";

else {

while (!f.eof()) {

f >> m;

cout << m << ' ';

for (i = 0; i < NMAX; i++) f >> outs[0][i];

}

f.close();

}

NeuroCalc();

printNeuroNet();

cout << "Error: " << calcErr(m) << endl;

}

void SetStructure() {

cout << "Enter n1(30) and n2(25)" << endl;

cin >> struc[1] >> struc[2];

cout << "SumError = " << calcSumErr() << endl;

}

void init() {

srand(time(NULL));

for (k = 1; k <= NSL; k++)

for (j = 0; j<NMAX; j++)

for (i = 0; i<NMAX; i++)

w[k][j][i] = -1 + 2 * (float)rand() / RAND_MAX;

}

int main()

{

init();

char ch;

do {

cout << "\nMenu:" << endl;

cout << "1: Load patterns" << endl;

cout << "2: Calc pattern" << endl;

cout << "3: Calc input" << endl;

cout << "4: Educate" << endl;

cout << "5: Set Structure" << endl;

cout << "6: Exit" << endl;

cout << "\n Select menu item: ";

cin >> ch;

switch (ch) {

case '1':

loadPatterns();

break;

case '2':

calcPattern();

break;

case '3':

calcInput();

break;

case '4':

educate();

break;

case '5':

SetStructure();

break;

default:

cout << "Wrong item!" << endl;

break;

}

} while (ch != '6');

}

Вывод: В ходе лабораторной работы была создана нейронная сеть. Так же в результате проведенных исследований были оценены помехоустойчивость и надежность искусственной нейросети. Результаты показали, что можно зашумить 6% входного изображения, чтобы средняя ошибка не превышала 20% и 1,65% нейронов может быть повреждено без превышения порогового значения ошибки 10%.