bpn3.cpp

一个实现3层BP人工神经网络的类

// BPN3.cpp：三层BP网络类的实现文件
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "BPN3.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)

//析构函数
TBPN3::~TBPN3()
{
    for(int i=0;i<3;i++) m_nNodes[i]=0;
}

//缺省构造函数
TBPN3::TBPN3()
{
    for(int i=0;i<3;i++) m_nNodes[i]=0;
}

//构造函数：以矩阵初始化网络
TBPN3::TBPN3(TMatrix *pU,TMatrix *pO,TMatrix *pWeights)
{
    for(int i=0;i<3;i++)  
    {   
    	m_nNodes[i]=pU[i].GetRows();	
    	m_U[i]=pU[i];
    	m_O[i]=pO[i];
    }
    m_Weights[0]=pWeights[0];
    m_Weights[1]=pWeights[1];    
}  

//拷贝构造函数
TBPN3::TBPN3(TBPN3& OneNN)
{
    for(int i=0;i<3;i++)  
    {   
    	m_nNodes[i]=OneNN.m_nNodes[i];	
    	m_U[i]=OneNN.m_U[i];
    	m_O[i]=OneNN.m_O[i];
    }
    m_Weights[0]=OneNN.m_Weights[0];
    m_Weights[1]=OneNN.m_Weights[1];    
}
   
//初始化函数：以矩阵初始化网络
void TBPN3::InitByMatrix(TMatrix *pU,TMatrix *pO,TMatrix *pWeights)
{
    for(int i=0;i<3;i++)  
    {
    	m_nNodes[i]=pU[i].GetRows();	
    	m_U[i].InitByMatrix(pU[i]);
    	m_O[i].InitByMatrix(pO[i]);
    }
    m_Weights[0].InitByMatrix(pWeights[0]);
    m_Weights[1].InitByMatrix(pWeights[1]);    
}

//初始化函数：以某网络初始化网络
void TBPN3::InitByBPN(TBPN3& OneNN)
{
   for(int i=0;i<3;i++)  
    {   
    	m_nNodes[i]=OneNN.m_nNodes[i];	
    	m_U[i].InitByMatrix(OneNN.m_U[i]);
    	m_O[i].InitByMatrix(OneNN.m_O[i]);
    }
    m_Weights[0].InitByMatrix(OneNN.m_Weights[0]);
    m_Weights[1].InitByMatrix(OneNN.m_Weights[1]);     
}

//功能：获取某层节点数；
//参数：int nLayer--指明层数，其值只能为0、1、2。
int TBPN3::GetNodes(int nLayer) const  
{
    if(nLayer>=0 && nLayer<=2) return m_nNodes[nLayer];
    else                       return -1;
}

//功能：获取某层u阵；
//参数：int nLayer--指明层数，其值只能为0、1、2。
TMatrix TBPN3::GetU(int nLayer)
{
    TMatrix Temp;
    if(nLayer>=0 && nLayer<=2) Temp=m_U[nLayer];
    return Temp;
}	

//功能：获取某层o阵；
//参数：int nLayer--指明层数，其值只能为0、1、2。
TMatrix TBPN3::GetO(int nLayer)
{
    TMatrix Temp;
    if(nLayer>=0 && nLayer<=2) Temp=m_O[nLayer];
    return Temp;
}

//功能：获取权值矩阵                 
//参数：int nPart；0-- 获取输入-隐层权阵；1-- 获取隐-输出层权阵。
TMatrix TBPN3::GetWeights(int nPart)
{
     TMatrix Temp;
     if(nPart==0 || nPart==1) Temp=m_Weights[nPart];
     return Temp;
}

void TBPN3::SetU(int nLayer,TMatrix& NewU)
{
    if(nLayer>=0 && nLayer<=2) m_U[nLayer]=NewU;
}
 	
void TBPN3::SetO(int nLayer,TMatrix& NewO)
{
    if(nLayer>=0 && nLayer<=2) m_O[nLayer]=NewO;
}

void TBPN3::SetWeights(int nPart,TMatrix& NewW)
{
    if(nPart==0 || nPart==1) m_Weights[nPart]=NewW;
}

/*函  数：GetFstOutputs()。
  参  数：TMatrix& OneMatrix---线性化后的输入。
  功  能：计算网络的输入层输出，其输入为线性化后的输出。
  返回值：TMatrix类，[输入节点数][OneMatrix.m_nCols]。    */
TMatrix TBPN3::GetFstOutputs(TMatrix& OneMatrix)
{
   TMatrix Temp;
   Temp=TanH(OneMatrix,m_U[0],m_O[0]);
   return Temp;
}

/*函  数：GetHiddenOutputs()。
  参  数：TMatrix& OneMatrix---隐层的输入。
  功  能：计算网络的隐层输出，其输入为输入层的输出。
  返回值：TMatrix类，[隐节点数][OneMatrix.m_nCols]。    */
TMatrix TBPN3::GetHiddenOutputs(TMatrix& OneMatrix)         
{
   TMatrix Temp;
   Temp=TanH(m_Weights[0]*OneMatrix,m_U[1],m_O[1]);
   return Temp;
}

/*函  数：GetLastOutputs()。
  参  数：TMatrix& OneMatrix---输出层的输入。
  功  能：计算网络的输出，其输入为隐层的输出。
  返回值：TMatrix类，[输出节点数][OneMatrix.m_nCols]。    */
TMatrix TBPN3::GetLastOutputs(TMatrix& OneMatrix)         
{
   TMatrix Temp;
   Temp=TanH(m_Weights[1]*OneMatrix,m_U[2],m_O[2]);
   return Temp;
}

/*函  数：GetOutputs()。
  参  数：TMatrix& Input---线性化后的网络输入。
  功  能：计算网络的输出，其输入为线性化后的网络输入。
  返回值：TMatrix类，[输出节点数][Input.m_nCols]。    */
TMatrix TBPN3::GetOutputs(TMatrix& Input)         
{
   TMatrix Temp[3];
   Temp[0]=TanH(Input,m_U[0],m_O[0]);
   Temp[1]=TanH(m_Weights[0]*Temp[0],m_U[1],m_O[1]);
   Temp[2]=TanH(m_Weights[1]*Temp[1],m_U[2],m_O[2]);
   return Temp[2];
}

/*函  数：Compute()。
  参  数：TMatrix ActualIn  ---实际应用中的网络输入。
          TMatrix InLineInfo---输入线性化所需斜率、截距，[输入节点数][2]。
          TMatrix OutLinInfo----输出线性化所需斜率、截距，[输出节点数][2]。
  功  能：实际使用时计算神经网络的输出。
  返回值：TMatrix类，[输出节点数][ActualIn.m_nCols]。                   */
TMatrix TBPN3::Compute(TMatrix ActualIn,TMatrix InLineInfo,TMatrix OutLineInfo)
{
   TMatrix Temp[3],ActualOut;
   
   Temp[0]=ActualIn.Linear(InLineInfo);
   Temp[0]=TanH(Temp[0],m_U[0],m_O[0]);
   Temp[1]=TanH(m_Weights[0]*Temp[0],m_U[1],m_O[1]);
   Temp[2]=TanH(m_Weights[0]*Temp[1],m_U[2],m_O[2]);
   ActualOut=Temp[2].DeLinear(OutLineInfo);
   return ActualOut;
}