感知机学习算法的原始形式

对于训练集：T={(x1,y1),(x2,y2),...,(xN,yN)}T=\left \{ \left ( x_{1},y_{1} \right ),\left ( x_{2},y_{2} \right ),...,\left ( x_{N},y_{N} \right ) \right.\left. \right \} 其中，xiϵRn,yiϵ{−1,1},i=1,2,...Nx_{i}\epsilon R^{n},y_{i}\epsilon \left \{ -1,1 \right.\left. \right \},i=1,2,...N,求参数w，b，使其是一下损失函数极小化问题的解

minw,bL(w,b)=−∑xiϵMyi(w∗xi+b)\underset{w,b}{min}L(w,b)=-\sum_{x_{i}\epsilon M}{y_{i}(w*x_{i}+b)}





需要注意的是，这种感知机学习算法得到的模型参数不是唯一的，它会由于采用不同的参数初始值或选取不同的误分类点，而导致解不同。

而对于线性可分的数据集，算法一定是收敛的，即经过有限次迭代，一定可以得到一个将数据集完全正确划分的分类超平面及感知机模型。

根据上面算法流程，和书上例子的Java程序如下：

class Al21{
//感知机学习算法的元素形式 算法2.1

double caculate(double[] w,int k,double[][] x){
double res=0.0;
for(int i=0;i<w.length;i++){
res+=w[i]*x[k][i];
}
return res;
}

void solve1(double[][] x,int[] y,double[] w,double b,double n){
for(int i=0;i<y.length;i++){
double caculateMult=caculate(w,i,x)+b;

if(caculateMult*y[i]<=0){
for(int k=0;k<w.length;k++){
w[k] += n * y[i] * x[i][k];//更新 w b
}
b += n * y[i];
System.out.println(i+1+" "+w[0]+" "+w[1]+" "+b);
i=-1;
}

}
System.out.println(w[0]+" "+w[1]+" "+b);
}
}

public class Test {

/**
* @param args
*/
public static void main(String[] args) {

double[][] x={{3,3},
{4,3},
{1,1}};
int[] y={1,1,-1};
double[] w={0.0,0.0};
double b=0.0;
double n=1;
new Al21().solve1(x,y,w,b,n);

}

}

结果：

1   3.0 3.0 1.0
3   2.0 2.0 0.0
3   1.0 1.0 -1.0
3   0.0 0.0 -2.0
1   3.0 3.0 -1.0
3   2.0 2.0 -2.0
3   1.0 1.0 -3.0

1.0 1.0 -3.0

每列依次是：误分类点，w[0],w[1],b

这里的选取的误分类是每当更新w，b后，从第一个x开始，从新遍历的，当这个顺序不一样的时候结果可能不同的。

为什么不同？

最直观的解释是，把点分成两类的线有多种。如下图：