机器学习笔记1——感知机（分类）

1.模型

f (x) = s i g n (\vec{w} \cdot \vec{x} + b)

$f(x)=sign(\vec{w} \cdot \vec{x}+b)$ 其中，

\vec{x}

$\vec{x}$ 为输入向量。

\vec{w}

$\vec{w}$ 和

b

$b$ 为感知机模型的参数，

\vec{w}

$\vec{w}$ 为权值向量，

b

$b$ 为偏置。
感知机就是一个单个的神经元，如下图所示

几何解释：线性方程

\vec{w} \cdot \vec{x} + b = 0

$\vec{w}\cdot \vec{x}+b=0$ 是定义在特征空间

R^{n}

$\boldsymbol{R}^n$ 的一个超平面。其中

\vec{w}

$\vec{w}$ 是超平面的一个法向量，

b

$b$ 是超平面的截距。

2 训练数据集

$(\vec{x}_i,y_i),i=1,2,\cdots,n$ ，其中 $y_i\in \{+1,-1\}$

3 损失函数：误分类点到超平面的总距离

输入空间中任意输入 $\vec{x}_i$ 到超平面的距离为

\frac{1}{| | \vec{w} | |} | \vec{w} \cdot {\vec{x}}_{i} + b |

$\frac{1}{||\vec{w}||}|\vec{w}\cdot \vec{x}_i+b| \\$ 如果

{\vec{x}}_{j}

$\vec{x}_ j$ 为误分类点，那么其到超平面的距离可以写为

- \frac{1}{| | \vec{w} | |} y_{j} (\vec{w} \cdot {\vec{x}}_{j} + b)

$-\frac{1}{||\vec{w}||}y_j(\vec{w}\cdot \vec{x}_j+b)$ 那么感知机学习的损失函数为

L (\vec{w}, b) = - \frac{1}{| | \vec{w} | |} \sum_{x_{j} \in M} y_{j} (\vec{w} \cdot {\vec{x}}_{j} + b)

$L(\vec{w},b)=-\frac{1}{||\vec{w}||}\sum_{x_j\in M} y_j(\vec{w}\cdot \vec{x}_j+b)$ 其中

M

$M$ 为误分类点的集合。

4.学习算法 —— 梯度下降法

极小化过程中不是一次将所有误分类点的梯度下降，而是一次随机算去一个误分类点使其梯度下降

4.1 原始形式

需要注意的是，参数为 $\vec{w}$ 和 $b$ 。将损失函数分别对 $\vec{w}$ 和 $b$ 求偏导

\nabla_{\vec{w}} L (\vec{w}, b) = - \sum_{x_{j} \in M} y_{j} {\vec{x}}_{j}

$\nabla_\vec{w} L(\vec{w},b)=-\sum_{x_j\in M} y_j\vec{x}_j$

\nabla_{b} L (\vec{w}, b) = - \sum_{x_{j} \in M} y_{j}

$\nabla_b L(\vec{w},b)=-\sum_{x_j\in M} y_j$ 每次选取一个点后，按照梯度的负方向更新参数即可，直到被正确分类。其实梯度下降的过程中，超平面在不断向误分类点的一侧移动。

\vec{w} = \vec{w} + η y_{j} {\vec{x}}_{j}

$\vec{w}=\vec{w}+\eta y_j\vec{x}_j$

b = b + η y_{j}

$b=b+\eta y_j$

4.2 对偶形式

在原始形式中，实例点更新次数越多，表明它离超平面越近，分类也就越难。在完成所有的学习之后，得到 $\vec{w}$ 和 $b$ 最终的表达式为

\vec{w} = - \sum_{x_{j} \in M} n_{j} η y_{j} {\vec{x}}_{j}

$\vec{w}=-\sum_{x_j\in M} n_j \eta y_j\vec{x}_j$

b = - \sum_{x_{j} \in M} n_{j} η y_{j}

$b =-\sum_{x_j\in M} n_j \eta y_j$ 其中，

n_{j}

$n_j$ 表示对于实例点

j

$j$ 的学习次数，正确分类点

n_{j} = 0

$n_j=0$ 。在对偶形式中，学习的过程也就变为更新

n_{j}

$n_j$ 的过程。
这样感知机模型就可以表示为

f (x) = s i g n (\sum_{x_{j} \in M} n_{j} η y_{j} {\vec{x}}_{j} \cdot \vec{x} + \sum_{x_{j} \in M} n_{j} η y_{j})

$f(x)=sign(\sum_{x_j\in M} n_j \eta y_j\vec{x}_j\cdot \vec{x}+\sum_{x_j\in M} n_j \eta y_j)$ 学习过程中只需要更新

n_{j}

$n_j$ 的优点还在于，对每次选择的实例点

{\vec{x}}_{i}

$\vec{x}_i$ ，

{\vec{x}}_{j} \cdot {\vec{x}}_{i}

$\vec{x}_j\cdot \vec{x}_i$ 可以提前被离线计算，也就是Gram矩阵。这样可以大大降低运算量。

5 python实现

import numpy as np
import matplotlib.pyplot as plt
#训练数据集
TrainData_x = np.array([[3, 3], [4, 3], [1, 1]])
TrainData_y = np.array([1, 1, -1])
NumData = len(TrainData_x)
#训练数据可视化
plt.figure()
plt.scatter(TrainData_x[0:2,0], TrainData_x[0:2,1], color='r',label='positive')
plt.scatter(TrainData_x[2,0], TrainData_x[2,1], color='k',label='negative')
plt.title('perceptron')
plt.xlabel('x1')
plt.ylabel('x2')
plt.xlim([0,6])
plt.ylim([0,4])
plt.legend()

eta = 1              #步长or学习率
w = np.array([0, 0]) #法向量初始值
delta_w = np.array([[0,0],[0,0],[0,0]]) #法向量更新值
b = 0                #截距初始值
delta_b = np.zeros(NumData)
for index in range(NumData):
    delta_w[index] = eta*TrainData_x[index]*TrainData_y[index]
    delta_b[index] = eta*TrainData_y[index]
###学习过程###
CorrData = 0          #正确分类数据的数目
while 1 :
    for index in range(NumData):
        if  -TrainData_y[index]*(np.dot(w,TrainData_x[index])+b) >= 0 :   #误分类点需要更新法向量和截距                
            w = w + delta_w[index] 
            b = b + delta_b[index]     
        else:         #正确分类点无需操作
            CorrData = CorrData + 1
    if  NumData == CorrData :       #如果分类全部正确，跳出while，学习结束
        break
    else:                           #如果分类有错误，将CorrData置零，重新循环判断数据分类
        CorrData = 0 

print("w = ", w)
print("b = ", b)

line_x = [0, 6]
line_y = [0, 0]

for index in range(len(line_x)):
    line_y[index] = (-w[0] * line_x[index]- b)/w[1]

plt.plot(line_x, line_y)
plt.savefig("perceptron.png")
plt.show()

最终学习结果
w = [1 1]
b = -3.0
这里写图片描述