感知机

1 感知机模型

感知机，是机器学习中二分类问题中的一个非常简单的模型，是最找的监督式训练算法，是神经网络构建的基础。

  定义：假设输入空间（特征空间）是$\chi \subseteq R^n$，输出空间是 Y = { + 1 , − 1 } Y=\{+1, -1\} Y={+1,−1}。输入$x\in \chi$表示实例的特征向量，对应于输入空间的点，即感知模型也是线性分类器模型；输出$y\in Y$表示实例的列别。由输入空间到输出空间的如下函数$$f(x)=sign(w\cdot x+b)$$
称为感知机。
  $w和b$是感知机模型参数
  $w\in R^n$是权值或权值向量
  $b\in R$是偏置
  $w\cdot x$bi表示w和x的内积
  $sign$是符号函数即$sign(x)=\{\begin{array}{ll}+1,& x\ge 0\\ -1,& x\le 0\end{array}$

  感知机的线性解释： 线性方程$w\cdot x+b=0$对应特征空间$R^n$中的一个超平面S，其中w是超平面的法向量，b是超平面的截距。超平面会将空间划分为两个部分，位于两部分的点分为正负两类。

---

2 学习策略

  线性可分定义：能够将数据集的正实例和负实例完全划分到超平面的两侧，则数据线性可分。
  确定感知机学习策略即定义损失函数并将损失函数最小化。
可选策略：

• 误差分类点的总数，但是这样损失函数 $w,b$不是连续可导函数，不易优化
• 误分类点到超平面的总距离，损失函数定义为$L(w,b)=-\frac{1}{||w||}{\sum }_{x_i\in M}{y}_i(w\cdot x_i+b)$，不考虑$\frac{1}{||w||}$，就得到告知及学习的损失函数。
  感知机$sign(w\cdot x+b)$学习的损失函数定义为：$$L(w,b)=-\sum _{x_i\in M}yi(w\cdot x_i+b)$$，M为误分类点的集合。

---

3 感知机学习算法

目标是将损失函数$L(w,b)$最小化
  随机梯度下降：任意选取一个超平面$w_0,b_0$，然后用梯度下降不断地极小化$L(w,b)$，损失函数地梯度由：
$${\nabla }_{w}L(w,b)=-\sum _{x_i\in M}{y}_i{x}_i$$
$${\nabla }_{b}L(w,b)=-\sum _{x_i\in M}{y}_i$$
给出。
  随机选取一个误分类点$(x_i,y_i)$，对w，b进行更新：
$$w\leftarrow w+\eta y_i{x}_i$$
$$b\leftarrow b+\eta y_i$$
其中$\eta$是步长，又称学习率。

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

输出：$w,b；感知机模型f(x)=sign(w\cdot x+b).$
（1）选取初值$w_0,b_0$
（2）在训练集中选取数据$(x_i,y_i)$
（3）如果$y_i(w\cdot x_i+b)\le 0$
$$w\leftarrow w+\eta y_i{x}_i$$
$$b\leftarrow b+\eta y_i$$
（4）转至（2），直到没有误分类点

$\hat{w}=(w^T,b{)}^T$
$\hat{x}=(x^T,1{)}^T$
定理： 设训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x n , y n ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_n,y_n)\} T={(x1​,y1​),(x2​,y2​),...,(xn​,yn​)}是线性可分的，其中 x i ∈ χ = R n , y i ∈ Y = { − 1 , + 1 } x_i\in\chi=R^n,y_i\in Y=\{-1,+1\} xi​∈χ=Rn,yi​∈Y={−1,+1}则：
 &wmsp;（1）存在满足条件$||{\hat{w}}_{opt}||=1$的超平面${\hat{w}}_{opt}\cdot {\hat{x}}_i=w_{opt}\cdot x+b_{opt}=0$将训练数据集完全正确分开；且存在$\gamma >0$，$y_i({\hat{w}}_{opt}\cdot {\hat{x}}_i)=y_i(w_{opt}\cdot x+b_{opt})\ge \gamma$
  （2）令$R=ma{x}_{i\ge N\ge N}||{\hat{x}}_i||$，则感知机算法2.1在训练数据集上的误分类次数k满足不等式$k\le (\frac{R}{\gamma }{)}^2$

from __future__ import division     #表示精确除法
import random
import numpy as np
import matplotlib.pyplot as plt

# 返回sign函数的结果
def sign(v):
    if v >= 0:
        return 1
    else:
        return -1

# 训练函数
def train(train_num, train_datas, lr):  #lr表示学习率
    w = [0, 0]
    b = 0
    for i in range(train_num):  #设定训练次数
        x = random.choice(train_datas)  #从训练集中随机选择一条数据
        x1, x2, y = x
        if (y * sign((w[0] * x1 + w[1] * x2 + b)) <= 0):
            w[0] += lr * y * x1
            w[1] += lr * y * x2
            b += lr * y
    return w, b

def plot_points(train_datas, w, b):
    plt.figure()
    x1 = np.linspace(0, 8, 100)
    x2 = (-b - w[0] * x1)/w[1]
    plt.plot(x1, x2, color='r', label='y1 data')
    datas_len = len(train_datas)
    for i in range(datas_len):
        if train_datas[i][-1] == 1:
            plt.scatter(train_datas[i][0], train_datas[i][1], s=50)
        else:
            plt.scatter(train_datas[i][0], train_datas[i][1], marker='x', s=50)
    plt.show()

train_data1 = [[1, 3, 1], [2, 2, 1], [3, 8, 1], [2, 6, 1]]  # 正样本
train_data2 = [[2, 1, -1], [4, 1, -1], [6, 2, -1], [7, 3, -1]]  # 负样本
train_datas = train_data1 + train_data2  # 样本集
w, b = train(train_num=50, train_datas=train_datas, lr=0.01)
plot_points(train_datas, w, b)

感知机学习算法的对偶形式：

对于$w和b$的更新公式为：
$$w\leftarrow w+\eta y_i{x}_i$$
$$b\leftarrow b+\eta y_i$$
若将$w和b$初始化为0，则最后学习到的$w和b$可以分别表示为($\alpha =n_i\eta$)：
$$w=\sum _{i=1}^N{\alpha }_i{y}_i{x}_i$$
$$b=\sum _{i=1}^N{\alpha }_i{y}_i$$
$当\eta =1时{\alpha }_i$表示第i个实例由于误分类而进行的更新的次数，更新次数越多意味着它距离分离超平面越近，也就越难正确分类。
算法过程：
感知机模型更新为$f(x)=sign({\sum }_{i=1}^N{\alpha }_i{y}_i{x}_i\cdot x+{\sum }_{i=1}^N{\alpha }_i{y}_i)$其中$\alpha =({\alpha }_1,{\alpha }_2,...,{\alpha }_N{)}^T$.
(1)$\alpha \leftarrow 0$，$b\leftarrow 0$
(2)在训练集中选取数据(x_i,y_i)
(3)如果$y_i({\sum }_{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x_i+b)\le 0$
$${\alpha }_i\leftarrow {\alpha }_i+\eta$$
$$b\leftarrow b+\eta y_i$$
(4)转至(2)直到没有误差分类数据。
  对于迭代的过程中，需要多次计算$x_j\cdot x_i$，因此使用Gram矩阵来减少重复计算$Gram=[x_i\cdot x_j{]}_{N\times N}$

# Gram矩阵
gram = np.matmul(x, x.T)

感知机的对偶形式就是把对$w,b的学习变成了\alpha ,b$的学习，原始形式中，$w$在每一轮迭代错时都需更新，而采用对偶形式时，对某一点分类错误时，只需要 更新对应的${\alpha }_i$即可，最后一次计算出$w$.

def train(train_num, train_datas, lr):  #lr为学习率
    w = [0, 0]
    b = 0
    datas_len = len(train_datas)
    alpha = [0 for i in range(datas_len)]
    train_array = np.array(train_datas)
    gram = np.matmul(train_array[:, 0:-1], train_array[:, 0:-1].T)
    print(train_array)
    for idx in range(train_num):
        tmp = 0
        i = random.randint(0, datas_len-1)
        yi = train_array[i, -1]
        for j in range(datas_len):
            tmp += alpha[j] * train_array[j, -1] * gram[i, j]
        tmp += b
        if yi * tmp <= 0:
            alpha[i] = alpha[i] + lr
            b = b + lr * yi
    for i in range(datas_len):
        w += alpha[i] * train_array[i, 0: -1] * train_array[i, -1]
    return w, b, alpha, gram

---

代码参考：

https://blog.youkuaiyun.com/winter_evening/article/details/70196040