pnn.cpp

DNA分类

// PNN.cpp: implementation of the CPNN class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "DNAClassification.h"
#include "PNN.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CPNN::CPNN()
{
	m_bIsTraining = FALSE;

	m_cWeight = NULL;
	m_nClass = 0;
	m_pWeight = NULL;
	m_A =NULL;

	m_ParzenWidth = 0.45;

	m_nSample = 0;
}

CPNN::~CPNN()
{
	Clear();
}

/********************************************************/
/*功  能：PNN训练算法
/*参  数：sample:是一个第一维大小为n,第二维大小为c的二维数组,样本已归一化
/*        pClass:n维数组，样本的分类信息,取值是0,1,2,3
/*        n     :第一维大小,即样本个数
/*        c     :第二维大小,即类别数目
/*返回值：训练是否成功
/********************************************************/
BOOL CPNN::Training(double **ppSample,int* pClass,int n,int c)
{
	if(m_bIsTraining)//已经训练过
	{
		//if(c!=m_nClass)//类别数不一致
			return FALSE;
	}
	else //没有训练过
	{		
		if(c<=0)
			return FALSE;

		m_nSample = n;
		m_nClass = c;

		m_cWeight = new double[c];
		m_pWeight = new double*[n];
		m_A = new BOOL*[n];
		for(int i=0;i<n;i++)
		{
			m_pWeight[i] = new double[c];
			m_A[i] = new BOOL[c];
		}
		//初始化
		for(int w = 0;w<n;w++)
		{
			for(int h = 0;h<c;h++)
			{
				m_pWeight[w][h] = 0;
				m_A[w][h] = 0;
			}
		}
		
		//训练
		for(int ii=0;ii<n;ii++)
		{
			for(int jj=0;jj<c;jj++)
			{
				m_pWeight[ii][jj] = ppSample[ii][jj];//w(jk)<-x(jk)
			}
			ASSERT(pClass[ii]<c);
			m_A[ii][pClass[ii]] = TRUE;

			double dRate = (double)((double)ii/(double)n);
			ReportStatus(&dRate);
		}

		m_bIsTraining = TRUE;
	}

	return TRUE;
}

/********************************************************/
/*功  能：PNN分类算法
/*参  数：testsample:是一个第一维大小为n,第二维大小为c的二维数组
/*        pClass:n维数组，样本的分类信息,取值是0,1,2,3，用于输出
/*        n     :第一维大小,即样本个数,必须与训练时所传参数一致
/*        c     :第二维大小,即类别数目,必须与训练时所传参数一致
/*返回值：是否分类成功
/********************************************************/
BOOL CPNN::Classify(double **ppTestSample,int* pClass,int n,int c)
{
	if(m_bIsTraining==FALSE)//还没有训练
		return FALSE;

	double* net = new double[m_nSample];
	double*	g = new double[c];
	memset(g,0,c*sizeof(double));

	for(int nSam = 0;nSam<n;nSam++)
	{
		for(int i=0;i<m_nSample;i++)
		{
			//MatrixMul(m_pWeight,ppTestSample,1,c,1,c,result);
			double result = 0.0;
			for(int r = 0;r<c;r++)
			{
				result += m_pWeight[i][r]*ppTestSample[nSam][r];
			}
			net[i] =result;

			for(int j=0;j<c;j++)
			{
				if(m_A[i][j] ==TRUE)
				{
					g[j]+=exp((net[i]-1)/(m_ParzenWidth*m_ParzenWidth));
				}
			}
		}

		double max =0;
		int nClass = 0;
		for(int jj=0;jj<c;jj++)
		{
			if(g[jj]>max)
			{
				max = g[jj];
				nClass =jj;
			}
		}
		pClass[nSam] = nClass;

		memset(g,0,c*sizeof(double));
	}

	delete[] net;
	delete[] g;
	return TRUE;
}


/********************************************************/
/*功  能：
/*参  数：
/*返回值：
/********************************************************/
void CPNN::Clear()
{
	if(m_cWeight)
	{
		delete[] m_cWeight;
		m_cWeight = NULL;

	}
	if(m_pWeight)
	{
		for(int i=0;i<m_nSample;i++)
		{
			delete[] m_pWeight[i];			
			m_pWeight[i] = NULL;
		}
		delete m_pWeight;
		m_pWeight = NULL;
	}
	if(m_A)
	{		
		for(int i=0;i<m_nSample;i++)
		{
			delete[] m_A[i];
			m_A[i] = NULL;
		}
		delete m_A;
		m_A = NULL;
	}
	
	m_bIsTraining = FALSE;	
	m_nClass = 0;
	m_nSample = 0;
}