backpropagation.cpp

以类库的形式实现了BP神经网络算法。可从该类基础上派生新类

/* 
* Copyright (c) 2006
* All rights reserved.
*
* 文件名称：BackPropagation.cpp
* 文件标识：
* 摘 要   ：多层前馈神经网络BP算法类实现
* 
* 当前版本：1.0
* 作 者   ：
* 完成日期：
*/

#include "StdAfx.h"
#include "BackPropagation.h"
#include <math.h>
#include <stdlib.h>
/* 
* 函数名称：CBackPropagation()
* 函数介绍： 默认构造函数
* 输入参数：
* 输出参数： 
* 返回值  ：
*/
CBackPropagation::CBackPropagation(void)
{
	m_InNodesNum = 0;			
	m_OutNodesNum = 0;			
	m_HidLayersNum = 0;
	m_ExamplesNum = 0;
	
	m_XExamples = NULL;
	m_YExamples = NULL;
	m_HideNodesNum = NULL;
	m_Weight = NULL;
	
	m_XYMaxMin[0] = NULL;
	m_XYMaxMin[1] = NULL;
	m_XYMaxMin[2] = NULL;
	m_XYMaxMin[3] = NULL;	
	
	m_YUnitary = NULL;
	m_XUnitary = NULL;
	m_YOutPut = NULL;
	
	m_BPNodes = NULL;
	
	m_Ajust = NULL;	
}

/* 
* 函数名称：CBackPropagation()
* 函数介绍：构造函数
* 输入参数：
inNodesNum		-输入层节点数目
outNodesNum		-输出层节点数目

* 输出参数： 
* 返回值  ：
*/
CBackPropagation::CBackPropagation(int inNodesNum,int outNodesNum)
{
	m_InNodesNum=inNodesNum;			
	m_OutNodesNum=outNodesNum;
	m_HidLayersNum = 0;
	m_ExamplesNum = 0;	
	
	m_XExamples = NULL;
	m_YExamples = NULL;
	m_HideNodesNum = NULL;
	m_Weight = NULL;
	
	m_XYMaxMin[0] = NULL;
	m_XYMaxMin[1] = NULL;
	m_XYMaxMin[2] = NULL;
	m_XYMaxMin[3] = NULL;	
	
	m_YUnitary = NULL;
	m_XUnitary = NULL;
	m_YOutPut = NULL;
	
	m_BPNodes = NULL;
	
	m_Ajust = NULL;	
}

/* 
* 函数名称：GetInputNum()
* 函数介绍：获得输入层节点数目
* 输入参数：
* 输出参数： 
* 返回值  ：输入层节点数目
*/
int CBackPropagation::GetInputNum(void)
{
	return m_InNodesNum;
}
/* 
* 函数名称：SetInputNum()
* 函数介绍：设置输入层节点数目
* 输入参数：num			－输入层节点数目
* 输出参数： 
* 返回值  ：true		－成功
*/
bool CBackPropagation::SetInputNum(int num)
{
	if (num < 1)
	{
		return false;
	}
	
	m_InNodesNum = num;
	return true;
}

/* 
* 函数名称：GetOutputNum()
* 函数介绍：获得输出层节点数目
* 输入参数：
* 输出参数： 
* 返回值  ：输出层节点数目
*/
int CBackPropagation::GetOutputNum(void)
{
	return m_OutNodesNum;
}

/* 
* 函数名称：SetOutputNum()
* 函数介绍：设置输出层节点数目
* 输入参数：num			－输出层节点数目
* 输出参数： 
* 返回值  ：true		－成功
*/
bool CBackPropagation::SetOutputNum(int num)
{
    if (num < 1)
	{
		return false;
	}
	
	m_OutNodesNum = num;
	return true;
}

/* 
* 函数名称：GetHideLayersNum()
* 函数介绍：获得隐含层层数
* 输入参数：
* 输出参数： 
* 返回值  ：隐含层层数
*/
int CBackPropagation::GetHideLayersNum(void)
{
	return m_HidLayersNum;
}

/* 
* 函数名称：SetHideLayersNum()
* 函数介绍：设置隐含层层数
* 输入参数：num			－隐含层层数
* 输出参数： 
* 返回值  ：true		－成功
*/
bool CBackPropagation::SetHideLayersNum(int num)
{
    if (num<1)
	{
		return false;
	}
	
	FreeHideMem();
	
	m_HidLayersNum = num;
	int nI=0;
	m_HideNodesNum = new int[m_HidLayersNum + 2];
	for (nI=0; nI<(m_HidLayersNum+2); nI++)
	{
		m_HideNodesNum[nI] = 0;
	}
	return true;
}

/* 
* 函数名称：GetHideNodesNum()
* 函数介绍：获得指定隐含层节点数目
* 输入参数：layerIndex		－指定的隐含层
* 输出参数： 
* 返回值  ：指定隐含层节点数目
*/
int CBackPropagation::GetHideNodesNum(int layerIndex)
{
	if (!m_HideNodesNum)
	{
		return -1;
	}
	if (layerIndex<1 || layerIndex>m_HidLayersNum)
	{
		return -1;
	}
	
	return m_HideNodesNum[layerIndex];
}

/* 
* 函数名称：GetHideNodesNum()
* 函数介绍：获得指定隐含层节点数目
* 输入参数：layerIndex		－指定的隐含层
* 输出参数： 
* 返回值  ：true			－成功
*/
bool CBackPropagation::SetHideNodesNum(int layerIndex, int num)
{
	
	if (layerIndex<1 || layerIndex>m_HidLayersNum || num<1)
	{
		return false;
	}	
	
	m_HideNodesNum[layerIndex] = num;	
	
	return true;
}

/* 
* 函数名称：InitNetwork()
* 函数介绍：初始化网络结构
* 输入参数：
* 输出参数： 
* 返回值  ：true		－成功
*/
bool CBackPropagation::InitNetwork()
{
	if (m_InNodesNum<1 || m_OutNodesNum<1 || m_HidLayersNum<1)
	{
		return false;
	}
    if (!m_HideNodesNum)
	{
		return false;
	}
	
	int nI=0;
	int nJ=0;
	int nK=0;
	for (nI=1; nI<=m_HidLayersNum; nI++)
	{
		//检查隐含层节点数目
		if (m_HideNodesNum[nI]<1)
		{
			return false;
		}
	}
	//释放原来权重存储区
	FreeWeigMem();
	
	m_HideNodesNum[0] = m_InNodesNum;
	m_HideNodesNum[m_HidLayersNum+1] = m_OutNodesNum;
	
	m_Weight = new double** [m_HidLayersNum+1];
	
	for (nI=0; nI<(m_HidLayersNum+1); nI++)
	{
		m_Weight[nI] = new double* [m_HideNodesNum[nI]];
		for (nJ=0; nJ<m_HideNodesNum[nI]; nJ++)
		{
			m_Weight[nI][nJ] = new double [m_HideNodesNum[nI+1]];
		}
        
	}
	
	//初始化权重
	for (nI=0; nI<(m_HidLayersNum+1); nI++)
	{
		for (nJ=0; nJ<m_HideNodesNum[nI]; nJ++)
		{
			for (nK=0; nK<m_HideNodesNum[nI+1]; nK++)
			{
				//产生0－1.0之间随机权重
				m_Weight[nI][nJ][nK] = (double)(rand()/(double)RAND_MAX);
			}
		}
	}
	
	//释放内存
	FreeNodesMem();
	//分配节点信息内存
	m_BPNodes = new BPNode* [m_HidLayersNum+2];
    m_BPNodes[0] = new BPNode[m_InNodesNum];
	for (nI=0; nI<m_HidLayersNum; nI++)
	{
		m_BPNodes[nI+1] = new BPNode[m_HideNodesNum[nI+1]];
	}
	m_BPNodes[m_HidLayersNum+1] = new BPNode[m_OutNodesNum];
	
	for (nI=0; nI<(m_HidLayersNum+2); nI++)
	{
		for(nJ=0; nJ<m_HideNodesNum[nI]; nJ++)
		{
			m_BPNodes[nI][nJ].err = 0.0;
			m_BPNodes[nI][nJ].net = 0.0;
			m_BPNodes[nI][nJ].val = 0.0;
		}
	}
	
	//释放样本最值内存
	FreeMaxMinMem();
	
	//输入样本最大值
	m_XYMaxMin[0] = new double[m_InNodesNum]; 
	//输入样本最小值
	m_XYMaxMin[1] = new double[m_InNodesNum]; 
	
	//输出样本最大值
	m_XYMaxMin[2] = new double[m_OutNodesNum]; 
	//输出样本最小值
	m_XYMaxMin[3] = new double[m_OutNodesNum]; 
	
	for (nI=0; nI<m_InNodesNum; nI++)
	{
        m_XYMaxMin[0][nI] = 0.0;	
		m_XYMaxMin[1][nI] = 0.0;		
	}
	for (nI=0; nI<m_OutNodesNum; nI++)
	{
        m_XYMaxMin[2][nI] = 0.0;	
		m_XYMaxMin[3][nI] = 0.0;		
	}
	
	return true;
}

/* 
* 函数名称：GetWeight()
* 函数介绍：获得指定的权重
* 输入参数：layerIndex		－网络层
preNodeIndex	－前层节点序号
curNodeIndex	－当前节点序号
* 输出参数： 
* 返回值  ：权重
*/
double CBackPropagation::GetWeight(int layerIndex, int preNodeIndex, int curNodeIndex)
{
    if (!m_Weight)
	{
		return -1.0;
	}
	
	if (layerIndex<1 || preNodeIndex<1 || curNodeIndex<1)
	{
        return -1.0;
	}
	
	if (layerIndex>(m_HidLayersNum+1) || preNodeIndex>m_HideNodesNum[layerIndex-1] 
		|| curNodeIndex>m_HideNodesNum[layerIndex])
	{
        return -1.0;
	}
	
	return m_Weight[layerIndex-1][preNodeIndex-1][curNodeIndex-1];
	
	
}

/* 
* 函数名称：SetWeight()
* 函数介绍：设置指定的权重
* 输入参数：layerIndex		－网络层
preNodeIndex	－前层节点序号
curNodeIndex	－当前节点序号
weight			－权重
* 输出参数： 
* 返回值  ：true			－成功
*/
bool CBackPropagation::SetWeight(int layerIndex, int preNodeIndex, int curNodeIndex, double weight)
{
    if (!m_Weight)
	{
		return false;
	}
	
	if (layerIndex<1 || preNodeIndex<1 || curNodeIndex<1)
	{
        return false;
	}
	
	if (layerIndex>(m_HidLayersNum+1) || preNodeIndex>m_HideNodesNum[layerIndex-1] 
		|| curNodeIndex>m_HideNodesNum[layerIndex])
	{
        return false;
	}
	
	m_Weight[layerIndex-1][preNodeIndex-1][curNodeIndex-1] = weight;
	return true;
}

/* 
* 函数名称：GetExamNum()
* 函数介绍：获得样本数目
* 输入参数：
* 输出参数： 
* 返回值  ：样本数目
*/
int CBackPropagation::GetExamNum(void)
{
	return m_ExamplesNum;
}

/* 
* 函数名称：SetExamNum()
* 函数介绍：设置样本数目
* 输入参数：num			－样本数目
* 输出参数： 
* 返回值  ：true		－成功
*/
bool CBackPropagation::SetExamNum(int num)
{
    if (num<1)
	{
		return false;
	}
	
	if (m_InNodesNum<1 || m_OutNodesNum<1)
	{
		//没有设置输入层和输出层节点数目
		return false;
	}
	
	//释放样本存储区
	FreeExamMem();
	
	FreeUnitMem();
	
	m_ExamplesNum = num;
	
	//分配输入样本
	int nLoop=0;
	m_XExamples = new double* [m_ExamplesNum];
	for (nLoop=0; nLoop<m_ExamplesNum; nLoop++)
	{
		m_XExamples[nLoop] = new double[m_InNodesNum];
	}
	
	//分配输出样本
	m_YExamples = new double* [m_ExamplesNum];
	for (nLoop=0; nLoop<m_ExamplesNum; nLoop++)
	{
		m_YExamples[nLoop] = new double[m_OutNodesNum];
	}
	
	//初始化存储区
	int nI=0;
	int nJ=0;
	for (nI=0; nI<m_ExamplesNum; nI++)
	{
		for (nJ=0; nJ<m_InNodesNum; nJ++)
		{
			m_XExamples[nI][nJ]=0.0;
		}
		for (nJ=0; nJ<m_OutNodesNum; nJ++)
		{
			m_YExamples[nI][nJ]=1.0;
		}
	}
	
	
	//分配输入样本
	m_XUnitary = new double* [m_ExamplesNum];
	for (nLoop=0; nLoop<m_ExamplesNum; nLoop++)
	{
		m_XUnitary[nLoop] = new double[m_InNodesNum];
	}
	
	//分配输出样本
	m_YUnitary = new double* [m_ExamplesNum];
	for (nLoop=0; nLoop<m_ExamplesNum; nLoop++)
	{
		m_YUnitary[nLoop] = new double[m_OutNodesNum];
	}
	
	//网络输出
	m_YOutPut = new double* [m_ExamplesNum];
	for (nLoop=0; nLoop<m_ExamplesNum; nLoop++)
	{
		m_YOutPut[nLoop] = new double[m_OutNodesNum];
	}
	return true;
}

/* 
* 函数名称：GetExamValue()
* 函数介绍：获得指定样本值
* 输入参数：examIndex		－第几个样本
index			－第几个输入或者输出
isX				－1：输入样本  0：输出样本 
* 输出参数： 
* 返回值  ：指定样本值
*/
double CBackPropagation::GetExamValue(int examIndex, int index, int isX)
{
	if (examIndex<1 || examIndex>m_ExamplesNum)
	{
		return -1.0;
	}
	
	if (isX)
	{
		//输入样本	
		if (!m_XExamples)
		{
			return -1.0;
		}
		if (index<1 || index>m_InNodesNum)
		{
			return -1.0;
		}
		return m_XExamples[examIndex-1][index-1];        	
	}
	else
	{
		//输出样本
		if (!m_YExamples)
		{
			return -1.0;
		}
		if (index<1 || index>m_OutNodesNum)
		{
			return -1.0;
		}
		return m_YExamples[examIndex-1][index-1];
	}
	
}

/* 
* 函数名称：GetExamValue()
* 函数介绍：获得指定样本值
* 输入参数：examIndex	－第几个样本
index		－第几个输入或者输出
examValue	－样本值
isX			－1：输入样本  0：输出样本 
* 输出参数： 
* 返回值  ：true		－成功
*/
bool CBackPropagation::SetExamValue(int examIndex, int index, double examValue, int isX)
{
	if (examIndex<1 || examIndex>m_ExamplesNum)
	{
		return false;
	}
	
	if (isX)
	{
		//输入样本	
		if (!m_XExamples)
		{
			return false;
		}
		if (index<1 || index>m_InNodesNum)
		{
			return false;
		}
		
		m_XExamples[examIndex-1][index-1] = examValue;
		return true; 
	}
	else
	{
		//输出样本
		if (!m_YExamples)
		{
			return false;
		}
		if (index<1 || index>m_OutNodesNum)
		{
			return false;
		}
		
		m_YExamples[examIndex-1][index-1] = examValue;
		return true;
	}	
}

/* 
* 函数名称：CacMaxMin()
* 函数介绍：查找样本最值
* 输入参数：
* 输出参数： 
* 返回值  ：true		－成功
*/
bool CBackPropagation::CacMaxMin(void)
{
	if (!m_XExamples || !m_YExamples)
	{
		return false;
	}
	
	//查找输入样本最值
	int nI=0;
	int nJ=0;
    for(nI=0; nI<m_InNodesNum; nI++)
	{
        m_XYMaxMin[0][nI] = m_XExamples[0][nI];
		m_XYMaxMin[1][nI] = m_XExamples[0][nI];
	}	
	for (nI=1; nI<m_ExamplesNum; nI++)
	{
        for (nJ=0; nJ<m_InNodesNum; nJ++)
		{
			if (m_XExamples[nI][nJ]>m_XYMaxMin[0][nJ])
			{
				m_XYMaxMin[0][nJ] = m_XExamples[nI][nJ];
			}
			
			if (m_XExamples[nI][nJ]<m_XYMaxMin[1][nJ])
			{
				m_XYMaxMin[1][nJ] = m_XExamples[nI][nJ];
			}
			
		}
	}
	
	//查找输出样本最值
    for(nI=0; nI<m_OutNodesNum; nI++)
	{
        m_XYMaxMin[2][nI] = m_YExamples[0][nI];
		m_XYMaxMin[3][nI] = m_YExamples[0][nI];
	}	
	for (nI=1; nI<m_ExamplesNum; nI++)
	{
        for (nJ=0; nJ<m_OutNodesNum; nJ++)
		{
			if (m_YExamples[nI][nJ]>m_XYMaxMin[2][nJ])
			{
				m_XYMaxMin[2][nJ] = m_YExamples[nI][nJ];
			}
			
			if (m_YExamples[nI][nJ]<m_XYMaxMin[3][nJ])
			{
				m_XYMaxMin[3][nJ] = m_YExamples[nI][nJ];
			}
			
		}
	}
	
	for (nI=0; nI<m_InNodesNum; nI++)
	{
		if(m_XYMaxMin[0][nI] == m_XYMaxMin[1][nI])
		{
            m_XYMaxMin[0][nI] += m_XYMaxMin[0][nI]/10000;
		}
	}
	
	for (nI=0; nI<m_OutNodesNum; nI++)
	{
		if(m_XYMaxMin[2][nI] == m_XYMaxMin[3][nI])
		{
            m_XYMaxMin[2][nI] += m_XYMaxMin[2][nI]/10000;
		}
	}
	
	return true;
}

/* 
* 函数名称：GetExamMax()
* 函数介绍：获得样本最大值
* 输入参数：varIndex	-参数序号
isX			-是否输入参数
* 输出参数： 
* 返回值  ：最大值
*/
double CBackPropagation::GetExamMax(int varIndex, int isX)
{
	if (!m_XYMaxMin[0] || !m_XYMaxMin[2])
	{
		return -1.0;
	}
	if (isX)
	{
		if (varIndex<1 || varIndex>m_InNodesNum)
		{
			return -1.0;
		}
		return m_XYMaxMin[0][varIndex-1];
	}
	else
	{
		if (varIndex<1 || varIndex>m_OutNodesNum)
		{