hftest.cpp

Hopfield 离散网络源程序 是人工神经网络的一个网络构建的基本代码

///////////////////////////////////////////////////////////////////////////////////////
#include <iostream> 
#include <time.h>
#include <stdlib.h>
#include <math.h>
//系统头文件
////////////////////////////////////////////////////////////////////////////////////////
// 矩阵类头文件
#include "matrix.h" 

using namespace std;
using namespace math;
////////////////////////////////////////////////////////////////////////////////////////
int main()
{
	typedef matrix<double> Matrix;

    // V0 hf网络状态矩阵； Q H 系统性能指标方程给定系数矩阵；X0系统输入列向量 Y域值列向量;

	Matrix V0(10,1), Q(2,2), H(2,2), X0(2,1), Y(10,1);
	// 定义矩阵数组A,B;
	Matrix A[5],B[5];
    // 二维的矩阵数组 P；
	Matrix P[5][5];
    //  W=W1+W2+W3;   W为连接权矩阵；
	Matrix W1(10,10), W2(10,10), W3(10,10),W(10,10);
	// 差分hopfield 网络的学习率;
	double f=0.001;

    // 列向量  V0随机初始化
    int i,j,k;

    cout<<"本网络的学习率设置为: "<< f <<endl;
	srand( (unsigned)time( NULL ) );
	for (i=0; i < 10; i++)
		for (j=0; j < 1; j++)
			V0(i,j) = rand()%10+0.0;
	cout<<"\n 初始V0为： "<<endl;
	cout<< V0 <<endl;
	// H 矩阵初始化
	 for(i=0;i<2;i++)
		for(j=0;j<2;j++)
	    {
		   if(i==j)
			H(i,j)=1;
		   else
			H(i,j)=0;
	     }
	// Q 矩阵初始化
	 Q=H;
    

	// 列向量  X0初始化
    X0(0,0)=1;
	X0(1,0)=1;
	// A ,B初始化
	for(i=0;i<5;i++)
	{
		A[i].SetSize(2,2);
		A[i](0,0)=0.8+0.02*(float)sin((double)i);
		A[i](0,1)=0.5;
		A[i](1,0)=0.6;
		A[i](1,1)=1-0.01*(float)cos((double)i);
     }
	for(i=0;i<5;i++)
	{
		B[i].SetSize(2,2);
		B[i](0,0)=1+0.1*exp((float)(-i/10));
		B[i](0,1)=0.5;
		B[i](1,0)=0.4;
		B[i](1,1)=0.7+0.1*exp((float)(-i/15));

	}
  
	// 数组 P 的初始化
	for(i=1;i<=5;i++)
		for(k=1;k<=5;k++)
		{
			if(i<k)
			{
				int l=k;
                Matrix C(2,2);
				C(0,0)=1;
				C(0,1)=0;
				C(1,0)=0;
				C(1,1)=1;
				while(l-->0)
				{
					
					C=C*A[l];
                  
				}
				C=C*A[i]*B[i-1];
				P[i-1][k-1].SetSize(2,2);
			    P[i-1][k-1]=C;
			}
			else if(i==k)
			{
				P[i-1][k-1]=B[i-1];
			}
			else
			{ 
				for(int m=0;m<2;m++)
					for(int n=0;n<2;n++)
					{
						 P[i-1][k-1].SetSize(2,2);
				         P[i-1][k-1](m,n)=0;
					}
			}
		}


	//-W1 初试化
	for (i=0;i<10;i++)
		for(j=0;j<10;j++)
		{
			if(i==j)
				W1(i,j)=1;
			else
				W1(i,j)=0;
		}
	// -W2 初始化
	Matrix C(10,2);
    int t=0;
    for(int k=0;k<5;k++)
	{ 
		
		for(i=0;i<2;i++)
		  for(j=0;j<2;j++)
			{
			    C(t+i,j)=P[k][4](i,j);
				
			}
		t+=2;
	}
	W2=C*H*(~C);
	//cout<<W2<<endl;
	
	// -W3 初始化
	
	Matrix R[4]; //  矩阵数组 R
	for(int l=0;l<4;l++)
	{
		int t=0;
		R[l].SetSize(10,2);
		for(int k=0;k<5;k++)
		{
			for(i=0;i<2;i++)	
			  for(j=0;j<2;j++)
			  {				 
				  R[l](t+i,j)=P[k][l](i,j);
			  }
			t+=2;
		}
	}
			
   for(i=0;i<10;i++)
	 for(j=0;j<10;j++)
		 W3(i,j)=0;

   for(int k=0;k<4;k++)
		 W3+=R[k]*Q*(~R[k]);

        //W的构造输出

       
		W=W1+W2+W3;
		Matrix M(10,10),N(10,10);
		cout<<"\n由给出的线形时变系统可得到如下数据: "<<endl;
		cout<<"\n负的连接权矩阵W如下: "<<endl;
		cout<< W <<endl;
		for(i=0;i<10;i++)
			for(j=0;j<10;j++)
			{
				N(i,j)=W(i,j)*(1.0/2);
				W(i,j)=W(i,j)*(-1.0);
			}

		for(i=0;i<10;i++)
			for(j=0;j<10;j++)
				M(i,j)=f*W(i,j);

		// 阀值列向量 Y 初始化

		Matrix D(10,2),F(2,2),G[5];
		for(i=0;i<5;i++)
		{
			F=H;
			G[i].SetSize(2,2);
			for(j=0;j<=i;j++)
			{
				F*=A[j];
				G[i]=F;
			}
		}
        D=C*H*G[4];
		for(i=0;i<4;i++)
			D+=R[i]*Q*G[i];
		Y=D*X0;
		cout<<"阀值列向量为: "<<endl;
		cout<< Y <<endl;
		Matrix S(10,1);
			for(i=0;i<10;i++)
				S(i,0)=f*Y(i,0);

		// 差分网络迭代的过程
		Matrix V1(10,1);
		do{
			V1=M*V0+V0-S;
			V0=V1;
		}while(V1!=V0);
		Matrix E(1,1);
		E=~(V1)*N*V0+~V0*Y;
		cout<< E <<endl;
		cout<<" Hopfield 网络的稳定状态如下: "<<endl;
		cout<< V1 <<endl;
		cout<<"\n V1即为线形时变系统所要找的最优2维列向量序列U!"<<endl;
		system("pause");
	return 0;
}