感知器训练算法----离散单输出

最新推荐文章于 2024-07-07 00:33:57 发布

转载最新推荐文章于 2024-07-07 00:33:57 发布 · 3k 阅读

神经网络NN 专栏收录该内容

9 篇文章

订阅专栏

本文介绍感知器模型及其学习算法，包括离散单输出感知器的训练过程和权值修正规则。通过实例展示了感知器如何通过有监督学习调整连接权重以实现分类任务。

感知器是一种早期的神经网络模型，由美国学者F.Rosenblatt于1957年提出。由于在感知器中第一次引入了学习的概念，使人脑所具备的学习功能在基于符号处理的数学模型中得到了一定程度的模拟，所以引起了广泛的关注。

简单感知器模型实际上仍然是M－P模型的结构，但是它通过采用有监督学习来逐步增强模式划分的能力，达到学习的目的

感知器处理单元对n个输入进行加权和操作，即：

感知器在形式上与M－P模型差不多，它们之间的区别在于神经元间连接权的变化。感知器的连接权定义为可变的，这样感知器就被赋予了学习的特性。

离散单输出感知器训练算法:
1.初始化权向量W；
2.重复下列过程，直到训练完成：
对样本集中的每一个样本X
    (1)输入X；
    (2)计算O＝F(XW)；
    (3)如果输出不正确，则
        当O＝0时，取W＝W+X
   当O＝1时，取W＝W-X
(

如果第i个神经元的输出是正确的，即有：ai＝ti，那么与第i个神经元联接的权值wij和偏差值bi保持不变；
如果第i个神经元的输出是0，但期望输出为1，即有ai＝0，而ti＝1，此时权值修正算法为：新的权值wij为旧的权值wij加上输人矢量pj；类似的，新的偏差bi为旧偏差bi加上它的输入1；
如果第i个神经元的输出为1，但期望输出为0，即有ai＝1，而ti＝0，此时权值修正算法为：新的权值wij等于旧的权值wij减去输入矢量pj；类似的，新的偏差bi为旧偏差bi减去1。
感知器学习规则的实质为：权值的变化量等于正负输入矢量。

只对输出不正确的进行修正，正确的不作修正

)
上述算法中，当O＝0时，按W+X修改权向量W。这是因为，理想输出本来应该是1，但现在却是0，所以相应的权应该增加，而且是增加对该样本的实际输出真正方贡献的权。当O＝1时恰好相反。

例如：

对于两类分类来计算权值：

第一类：wkTx＞0

第二类：wkTx＜0

1.错误分类修正wk
           如w(k)T*x≤0并且x∈ω1   (第一类)     wk+1= wk＋ρkx
               如wkTx≥0并且x∈ω2 （第二类） wk+1= wk-ρkx
2.正确分类，wk不修正
           如wkTx＞0并且x∈ω1
           如wkTx＜0并且x∈ω2
           wk+1= wk

ρk选择准则

①     固定增量原则 ρk固定非负数

②     绝对修正规则 ρk>

③    部分修正规则 ρk=λ        0＜λ≤2

算法例子：

使用感知器，W-H固定增量法求判别函数

class MyPerceptron{

protected:
   vector<Point2Type> pointsAtype;
   //vector<int> classes;//放置类标记
public:
   MyPerceptron(vector<POINT>* pointsT,vector<int> classesT){
       for (int i=0;i<pointsT->size();i++)
       {
           MyPoint mp={pointsT->at(i).x,pointsT->at(i).y,1};
           Point2Type m2t={mp,classesT.at(i)};
           pointsAtype.push_back(m2t);
       }
   }
protected:
   int getProduct(Weight W,MyPoint X){
       int result=W.w1*X.x1+W.w2*X.x2+W.w3*X.IncreX;
       return result;
   }
   Weight fixedResultAdd(Weight W,MyPoint X,double ro)
   {
       W.w1+=ro*X.x1;
       W.w2+=ro*X.x2;
       W.w3+=ro*X.IncreX;
       return W;
   }

   Weight fixedResultSub(Weight W,MyPoint X,double ro)
   {
       W.w1-=ro*X.x1;
       W.w2-=ro*X.x2;
       W.w3-=ro*X.IncreX;
       return W;
   }
   Weight getResultW(Weight W,int maxTimes,double ro){
       if (maxTimes>=100)//迭代的最大次数
       {
           return W;
       }
       int flag=0;//判断权值是否发生改变
       int product=0;
       for (int i=0;i<pointsAtype.size();i++)
       {
           //cout<<mypointsT.at(i).type;
           product=getProduct(W,pointsAtype.at(i).mypoint);
           if (product<=0 && pointsAtype.at(i).type==1 )
           {
               flag=1;
               W=fixedResultAdd(W,pointsAtype.at(i).mypoint,ro);
           }
           if (product>=0 && pointsAtype.at(i).type==2 )
           {
               flag=1;
               W=fixedResultSub(W,pointsAtype.at(i).mypoint,ro);
           }
       }
       if (flag == 1)
       {
           maxTimes=maxTimes+1;
           return getResultW(W,maxTimes,ro);
       }
       return W;

   }
public:
   Weight getFinalW(){
       Weight W={1,1,1};
       Weight WRe;
       WRe=getResultW(W,1,1);
       return WRe;
   }
};

struct MyPoint{
   int x1;
   int x2;
   int IncreX;//=1，增值模式,即为常数
};
struct Point2Type{
   MyPoint mypoint;
   int type;//type分为1,2，分别表示是属于第一类(>0)还是第二类(<0)
};

struct Weight{
   int w1;//对应x1的权值
   int w2;//对应x2的权值
   int w3;//对应x3的权值，常数系数
};