单层感知器神经网络

/***********************************************************************/  
/*  文件：MC_Neuron.h                                                  */
/*  版权: 转载请注明来自mni2005的博客[http://blog.csdn.net/mni2005]    */
/*  作者: 莫问                                                         */ 
/*  日期: 2014-06-04                                                   */
/*  描述:单层感知器神经网络头文件                                      */
/***********************************************************************/  

#ifndef _AFX_MC_NEURON_INCLUDE_H_
#define _AFX_MC_NEURON_INCLUDE_H_
 
class Neuron
{
	
public:
	Neuron();

public:
	bool  Train(float expect, float mX1, float mX2);
	float Compute(float mX1, float mX2);
	void  GetWeight(float &mX1, float &mX2);
	
private:	
	float ActivateFunc(float fSum);

private:
	float m_Weight[2];  //权值向量
	float m_Bias;       //偏差
	float m_alpha;      //学习速率
 
};

#endif //_AFX_MC_NEURON_INCLUDE_H_ 

/***********************************************************************/  
/*  文件：MC_Neuron.cpp                                                */
/*  版权: 转载请注明来自mni2005的博客[http://blog.csdn.net/mni2005]    */
/*  作者: 莫问                                                         */ 
/*  日期: 2014-06-04                                                   */
/*  描述: 单层感知器神经网络实现                                       */
/***********************************************************************/   

#include "MC_Neuron.h"

Neuron::Neuron()
{
	m_Weight[0] = 0.01f;
	m_Weight[1] = 0.01f;	

	m_Bias = 0.01f;
	m_alpha  = 0.01f;
}

//激活函数
float Neuron::ActivateFunc(float Yn)
{	
	if(Yn >=0.0f) 
	{ 
		return 1.0f;  
	}else{
		return 0.0f;
	}
}


float Neuron::Compute(float mX0, float mX1)
{
	float Yn = m_Bias*1.0f + m_Weight[0]*mX0 + m_Weight[1]* mX1;

	return ActivateFunc(Yn);	
}

void  Neuron::GetWeight(float &mX1, float &mX2)
{
	mX1 = m_Weight[0];
	mX2 = m_Weight[1];
}

bool Neuron::Train(float expect, float mX0, float mX1)
{
	float  Yn = Compute(mX0, mX1);

	//调整权值感知器向量
	if( Yn != expect )
	{
		m_Weight[0] += ( m_alpha * (expect - Yn) * mX0 );
		m_Weight[1] += ( m_alpha * (expect - Yn) * mX1 ); 
		m_Bias      += ( m_alpha * (expect - Yn) * 1.0f ); 

		return false;
	}	
	return true;
}

/***********************************************************************/  
/*  文件：NeuronTest.cpp                                               */
/*  版权: 转载请注明来自mni2005的博客[http://blog.csdn.net/mni2005]    */
/*  作者: 莫问                                                         */ 
/*  日期: 2014-06-04                                                   */
/*  描述: 用逻辑与或运算，完成单层感知器神经网络测试                   */
/***********************************************************************/    
 

#include <stdio.h>
#include <stdlib.h>
#include "MC_Neuron.h"


int main(int argc, char* argv[])
{ 
	/*
	//逻辑与 训练样本 
	float slps[][3] = { 
		{1.0, 1.0, 1.0}, 		
		{0.0, 1.0, 0.0},  
		{1.0, 0.0, 0.0}, 
		{0.0, 0.0, 0.0}, 		
	}; 
*/
	//逻辑或 训练样本 
	float slps[][3] = { 
		{1.0, 1.0, 1.0}, 		
		{0.0, 1.0, 1.0},  
		{1.0, 0.0, 1.0}, 
		{0.0, 0.0, 0.0}, 		
	}; 

	Neuron neuron;
	bool   bOK;

	//开始训练
	do{	
		bOK = true;
		for (int i=0; i<4; i++)
		{	  
		   float* pSlp = slps[i];		
		   if(!neuron.Train(pSlp[2], pSlp[0], pSlp[1]))
		   {
			   bOK = false;
		   }
		}
	}while(!bOK);

	//训练结束，输出权值
	float weight1, weight2;
	neuron.GetWeight(weight1, weight2);
	printf("weight1=%f, weight2=%f\n", weight1, weight2);

	//验证感知器训练结果
	for (int i=0; i<4; i++)
	{	  
		float* pSlp = slps[i];		
		float  fvalue = neuron.Compute(pSlp[0], pSlp[1]);
		printf("value=%f, expect=%f\n", fvalue, pSlp[2]);
	}

	system("pause");

	return 0;
}