单层感知器神经网络

/***********************************************************************/
/*  文件：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;
}