«Нелинейные искусственные нейронные сети в задачах прогнозирования»

Министерство образования Республики Беларусь
Учреждение образования
«Брестский государственный технический университет»
Кафедра ИИТ

Лабораторная работа №4
По ИМОД

Тема: «Нелинейные искусственные нейронные сети
в задачах прогнозирования»

Выполнил:
студент 4-го курса
группы АС-56
Ровенский Д.В.


Проверил:
Савицкий Ю. В.
Брест 2022
Цель работы: Изучить обучение и функционирование нелинейной искусственной нейронной сети (ИНС) при решении задач прогнозирования.
Вариант 4

№ варианта	a	b	с	d	Кол-во входов ИНС	Кол-во НЭ в скрытом слое
4	0.4	0.4	0.08	0.4	6	2

1. Изучить теоретические сведения
2. Написать на любом языке высокого уровня программу моделирования прогнозирующей линейной ИНС. Для тестирования использовать функцию . Варианты заданий приведены в таблице 1.
Результаты представить в виде отчета содержащего:

1. 
   Титульный лист.
   
2. 
   Цель работы.
   
3. 
   Задание.
   
4. 
   График прогнозируемой функции на участке обучения
   
5. 
   Результаты обучения: таблицу со столбцами: эталонное значение, полученное значение, отклонение; график изменения ошибки в зависимости от итерации
   
6. 
   Результаты прогнозирования: таблицу со столбцами: эталонное значение, полученное значение, отклонение
   
7. 
   Выводы по лабораторной работе
   

Исходный код
#pragma once
class Network
{
public:
Network();
Network(const int& _inputINS, const int& _hideNS);
~Network();

void setPrecision(long double& _prec);

void setLearnSpeed(float& _lSpeed);

void learnNetwork(const long double* _etalon);

long double sigmoid(const long double& _S);

long double proizvod(const long double& _y);
long double sumNeuron12(const int& _indxNeur);
long double sumNeuron23(const long double* _Ymass);
long double gamma12();
long double summHideGamma(const long double& Y2, const long double& Etalon, const long double* arrY1);
long double summInputHamma(const long double* arrY1, const int& indx);
void checkNetwork(const long double* _etalon);
long double networkAnt();

private:
int inputINS;

int hideNS;

long double** arrW_Ins;

long double* arrW_Hide;
long double** arrT_Ins;
long double* arrT_Hide;
long double* inputValues;
long double T;
long double* hideGamma;
long double* inputGamma;

long double precision;

float learnSpeed;

};

#include
#include
#include
#include

Network::Network()

{
inputINS = 2;
hideNS = 2;
precision = 1e-5;

learnSpeed = 0.1;

arrW_Ins = new long double*[hideNS];

for (int i = 0; i < hideNS; i++) arrW_Ins[i] = new long double[inputINS];
arrW_Hide = new long double[hideNS];
arrT_Ins = new long double*[hideNS];
for (int i = 0; i < hideNS; i++) arrT_Ins[i] = new long double[inputINS];
arrT_Hide = new long double[hideNS];

double randValue = ((double) rand() / (RAND_MAX)) + 1;

for (int i = 0; i < hideNS; i++)
{
for (int j = 0; j < inputINS; j++)
{
arrW_Ins[i][j] = randValue;
arrT_Ins[i][j] = randValue;
}
}
for (int i = 0; i < hideNS; i++)
{
arrW_Hide[i] = randValue;
arrT_Hide[i] = randValue;
}

inputValues = new long double[inputINS];

T = randValue;

}

Network::Network(const int& _inputINS, const int & _hideNS)

{
inputINS = _inputINS;
hideNS = _hideNS;

precision = 1e-5;

learnSpeed = 0.1;

arrW_Ins = new long double* [hideNS];

for (int i = 0; i < hideNS; i++) arrW_Ins[i] = new long double[inputINS];
arrW_Hide = new long double[hideNS];
arrT_Ins = new long double* [hideNS];
for (int i = 0; i < hideNS; i++) arrT_Ins[i] = new long double[inputINS];
arrT_Hide = new long double[hideNS];

double randValue = ((double)rand() / (RAND_MAX)) + 1;

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

{
for (int j = 0; j < inputINS; j++)
{
arrW_Ins[i][j] = randValue;
arrT_Ins[i][j] = randValue;
}
}

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

{
arrW_Hide[i] = randValue;
arrT_Hide[i] = randValue;
}

inputValues = new long double[inputINS];

T = randValue;

}

Network::~Network()

{
for (int i = 0; i < hideNS; i++) delete arrW_Ins[i];
delete[]arrW_Ins;
delete[]arrW_Hide;
for (int i = 0; i < hideNS; i++) delete arrT_Ins[i];
delete[]arrT_Ins;
delete[]arrT_Hide;
delete[]inputValues;
}

void Network::setPrecision(long double& _prec)

{
precision = _prec;
}

void Network::setLearnSpeed(float& _lSpeed)

{
learnSpeed = _lSpeed;
}

void Network::learnNetwork(const long double* _etalon)

{
int countIter = 0;
int countEpoch = 0;

long double precissionInNeur = 0.0;

std::vector vect;
do
{
for (int countIteration = 0; countIteration < 30; countIteration++)
{
long double Etalon = 0;
for (int i = 0; i < inputINS; i++)
{
inputValues[i] = _etalon[i + countIteration];
}
Etalon = _etalon[inputINS + countIteration];

long double* arrY1 = new long double[hideNS];

long double* arrY1Sum = new long double[hideNS];
for (int i = 0; i < hideNS; i++)
{
arrY1[i] = sigmoid(sumNeuron12(i) - arrT_Hide[i]);
arrY1Sum[i] = sumNeuron12(i) - arrT_Hide[i];
}
long double Y2 = sumNeuron23(arrY1) - T;

precissionInNeur += ((Y2 - Etalon) * (Y2 - Etalon)) / static_cast(2);

long double gamma = (Y2 - Etalon);

hideGamma = new long double[hideNS];

inputGamma = new long double[inputINS];

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

{
hideGamma[i] = arrW_Hide[i] * gamma * proizvod(Y2);
}
T += learnSpeed * gamma;

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

{
arrW_Hide[i] -= learnSpeed * gamma * arrY1[i];
}

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

{
for (int j = 0; j < inputINS; j++)
{
arrW_Ins[i][j] -= learnSpeed * hideGamma[i] * proizvod(arrY1[i]) * inputValues[j];
}
}
for (int i = 0; i < hideNS; i++)
{
arrT_Hide[i] += learnSpeed * hideGamma[i] * proizvod(arrY1[i]);
}

delete[]arrY1;

delete[]arrY1Sum;
delete[]hideGamma;
delete[]inputGamma;
}
precissionInNeur /= static_cast(30);
countEpoch++;
if (countEpoch % 5000 == 0)
{
vect.push_back(precissionInNeur);
}
} while (precision < precissionInNeur);
std::cout << "[";
for (auto it : vect) std::cout << it << ", ";
std::cout << "]"<std::cout<<"Ready! Epoch: " << countEpoch <}

long double Network::sigmoid(const long double& _S)

{
return static_cast(1)/(static_cast(1) + powl(2.718281828459045, -_S));
}

long double Network::proizvod(const long double& _y)

{
return _y*(static_cast(1) - _y);
}

long double Network::sumNeuron12(const int& _indxNeur)

{
long double retRez = 0;
for (int i=0; i < inputINS; i++)
{
retRez += arrW_Ins[_indxNeur][i]*inputValues[i];
}
return retRez;
}

long double Network::sumNeuron23(const long double * _Ymass)

{
long double retRez = 0;
for (int i=0; i < hideNS; i++)
{
retRez += arrW_Hide[i] * _Ymass[i];
}
return retRez;
}

long double Network::gamma12()

{
return 0;
}

long double Network::summHideGamma(const long double& Y2, const long double& Etalon, const long double *arrY1)

{
long double returnRez = 0;
for (int i = 0; i < hideNS; i++)
{
returnRez += static_cast(Y2 - Etalon) * proizvod(Y2)*arrW_Hide[i];
}
return returnRez;
}

long double Network::summInputHamma(const long double* arrY1, const int & indx)

{
long double returnRez = 0;
for (int i = 0; i < hideNS; i++)
{
returnRez += static_cast(hideGamma[i]) * proizvod(arrY1[i]) * arrW_Ins[i][indx];
}
return returnRez;
}

void Network::checkNetwork(const long double* _array)

{

std::cout << std::setw(10) << "Вывод:" << std::setw(10) << "Эталон:" << std::setw(12) << "Разность:" << std::endl;

for (int counter = 0; counter < 15; counter++)
{
for (int i = 0; i < inputINS; i++)
{
inputValues[i] = _array[i + counter];
}

long double Etalon = _array[inputINS + counter];

long double Ant = networkAnt();
std::cout << std::setw(10) << std::setprecision(5) << Ant << " " << std::setw(10) << std::setprecision(5) << Etalon << " " << std::setw(10) << std::setprecision(5) << (Etalon - Ant) << std::endl;
}
}

long double Network::networkAnt()

{
long double *arrY = new long double[hideNS];
long double Y = 0;
for (int i = 0; i < hideNS; i++)
{
arrY[i] = sigmoid(sumNeuron12(i) - arrT_Hide[i]);
}
Y = sumNeuron23(arrY) - T;
delete[]arrY;
return Y;
}

#include

#include
#define ETALON_COUNT 50

long double* makeEtalon(const float &_a, const float &_b, const float &_c, const float &_d, const float &_x)

{
long double *arrEtalon = new long double[ETALON_COUNT];
float incrementValue = 0;

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

{
arrEtalon[i] = _a * cosf(_b * incrementValue) + _c * sinf(_d * incrementValue);
incrementValue += _x;
}

return arrEtalon;

}

int main()

{
setlocale(LC_ALL,"RU");

long double *arrEtalon = makeEtalon(0.2, 0.4, 0.09, 0.4, 0.1);

int temp1 = 6, temp2 = 2;
Network neuronka(6,2);
long double E = 1e-5;
neuronka.setPrecision(E);
neuronka.learnNetwork(arrEtalon);
neuronka.checkNetwork(arrEtalon);
delete []arrEtalon;
}
Результат выполнения:




Вывод: с помощью нелинейной искусственной нейронной (ИНС) сети изучили процессы обучения и функционирования этой сети при решении задач прогнозирования нелинейных задач прогнозирования.