Искуственный интелект. Анализатор цвета. С++BUILDER 6.0

Тема: Использование нейронных сетей в инфокоммуникациях

Цель работы: При передаче мультимедийного трафика в системах связи возможны его частичные искажения. При передаче в сети графических изображений, помехи могут влиять на качество изображений.Поэтому предполагается на приемной стороне(в приемнике) возможность применить алгоритмы искусственного интеллекта, которые позволят попиксельно относить оттенки цвета к основному набору цветов и восстановить изображение.

Структура:1)Постановка задачи2)Искусственный интеллект3)Искусственные нейронные сети4)Функция активации нейрона5)Методы обучения нейронной сети6)Программная реализация7)Выводы.

Содержание приложения:1)Исходники программы;

2)Презентация для выступа на конференции *.ppt;

3)Доклад по выступу на конференции *.doc.

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

Исходный код:(отрывок)

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

#include <vcl.h>
#pragma hdrstop
#include <math.h>
#include "Unit1.h"
//---------------------------------------------------------------------------
#define INCOUNT	3
#define NEUROCOUNT 8
#define E 2.7182818284590452354
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
TCanvas *t,*t2;
//---------------------------------------------------------------------------
void color()
{int r=255-Form1->TrackBar1->Position,
     g=255-Form1->TrackBar2->Position,
     b=255-Form1->TrackBar3->Position;
t->Brush->Color=RGB(r, g, b);
t->Rectangle(0,0,Form1->Image1->Width,Form1->Image1->Height);
}
//---------------------------------------------------------------------------

struct Neuron
{
	double x[INCOUNT];// входные сигналы
	double w[INCOUNT];// весовые коэфициенты
	double w0;// доп вес
	double sum;// сумма
	double y;// выход аксон
	double h; // множитель задающий скорость движения
};
//---------------------------------------------------------------------------
class CNeuroNet
{
public:
	CNeuroNet(void);
	~CNeuroNet(void);
	float ActiveSigm(float x);
	float ActiveSigmPro(float x);
	void ProcNeuro(Neuron& n);
	int Process();
	int Teach(int Num);
        void AutoTeach();
        void ProcNet();
        void Draw();


	int m_NeuroCount;
	Neuron m_Neuro[NEUROCOUNT];

        int m_TechColor;
        int m_Red;
        int m_Green;
        int m_Blue;
        int m_ProcRes;

};

CNeuroNet m_NeuroNet;
//---------------------------------------------------------------------------
CNeuroNet::CNeuroNet(void)
{
 m_NeuroCount=NEUROCOUNT;
  for(int i=0;i<m_NeuroCount;i++)
   {
    for(int j=0;j<INCOUNT;j++)
     {
      m_Neuro[i].x[j]=0;
      m_Neuro[i].w[j]=1;      //((rand()&0xFF)-127)/127.
     }
    m_Neuro[i].y=0;
    m_Neuro[i].sum=0;
    m_Neuro[i].h=1;
    m_Neuro[i].w0=1;
   }
}
//---------------------------------------------------------------------------
CNeuroNet::~CNeuroNet(void)
{
}
//---------------------------------------------------------------------------
float CNeuroNet::ActiveSigm(float x)  //сигмоидальная функция активации
{
 float e=(float)E;
 float y=1./(1+pow(e,-x))-0.5;
 return y;
}
//---------------------------------------------------------------------------
float CNeuroNet::ActiveSigmPro(float x)//производная сигмоид. ф.активации
{                                      //используется для обучения нейронной сети
 float e=(float)E;                     //методом обратного распространения
 float y=pow(e,-x)/pow((1+pow(e,-x)),2);
 return y;
}
//---------------------------------------------------------------------------
void CNeuroNet::ProcNeuro(Neuron& n)
{
 float Net=0;//NET — взвешенная сумма входных сигналов,
 for(int i=0;i<INCOUNT;i++)
  {
   Net+=n.x[i]*n.w[i];
  }
 Net+=n.w0;
 n.sum=Net;
 n.y=ActiveSigm(Net);
}
//---------------------------------------------------------------------------
int CNeuroNet::Process()
{
 double Max=0;
 int Num=0;
 for(int i=0;i<m_NeuroCount;i++)
  {
   ProcNeuro(m_Neuro[i]);
   if(m_Neuro[i].y>Max)
    {
     Max=m_Neuro[i].y;
     Num=i;
    }
  }
 return Num;
}
//---------------------------------------------------------------------------
int CNeuroNet::Teach(int Num)
{
 Process();
 for(int i=0;i<m_NeuroCount;i++)
  {
   float t=0;
   if(Num==i)// t=1
    t=1;
   float deltaRes = m_Neuro[i].y - t;// res - t
   float delta = ActiveSigmPro(m_Neuro[i].sum)*deltaRes;
   for(int j=0;j<INCOUNT;j++)
    {
     m_Neuro[i].w[j]=m_Neuro[i].w[j]-m_Neuro[i].h*delta*m_Neuro[i].x[j];
    }
   m_Neuro[i].w0 = m_Neuro[i].w0 - m_Neuro[i].h*delta;
   float a=m_Neuro[i].w0;
  }
 return 0;
}
//---------------------------------------------------------------------------

void CNeuroNet::AutoTeach()
{
 double Red=(((double)(rand()&0xFF)))/255.;
 double Green=(((double)(rand()&0xFF)))/255.;
 double Blue=(((double)(rand()&0xFF)))/255.;
 for(int i=0;i<m_NeuroNet.m_NeuroCount;i++)
  {
   m_NeuroNet.m_Neuro[i].x[0]=Red;
   m_NeuroNet.m_Neuro[i].x[1]=Green;
   m_NeuroNet.m_Neuro[i].x[2]=Blue;
  } 
  
 double Level=Red;
 if(Green>Level)
  Level=Green;
 if(Blue>Level)
  Level=Blue;
 Level=Level*0.7;

 m_TechColor=0;
 if(Red>Level)
  m_TechColor|=1; //побитовое ИЛИ (001или010=011)
 if(Green>Level)
  m_TechColor|=2;
 if(Blue>Level)
  m_TechColor|=4;
 m_NeuroNet.Teach(m_TechColor);
}