学习笔记-《统计学习方法》-第二章-感知机

2 感知机

2.1 感知机模型

假设输入空间（特征空间）是$\chi \subseteq R^n$，输出空间是$\gamma = \{+1, -1\}$，输入$x \in \chi$表示实例的特征向量，对应于输入空间的点；输出$y \in \gamma$表示实例的类别，由输入到输出的如下函数

$$f(x) = sign(\omega \cdot x + b)$$

称为感知机。其中$\omega$和$b$为感知机模型参数。

2.2 学习策略

• 线性可分数据集：如果存在超平面$S$

  $$\omega \cdot x + b = 0$$

  能够将数据集的正实例点和负实例点完全正确的划分到超平面的两侧，则称数据集为线性可分数据集(linearly separable data set)

• 由于空间$R^n$中任意一点到超平面S的距离是

  $$\frac{1}{||\omega||}|\omega \cdot x_0 + b|$$

  所有误分类点到超平面的总距离为

  $$\frac{1}{||\omega||} \sum_{x_i \in M}y_i(\omega \cdot x_i + b)$$

2.3 学习算法

2.3.1 原始形式

输入：训练数据集$T={(x_1, y_1), (x_2, y_2), ..., (x_N, y_N)}$，其中$x_i \in X = R^n, y_i \in y = {-1, +1}, i = 1,2,.., N$；学习率$\eta(0<\eta\leq1)$；

输出：$w_i, b_i$感知机模型$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) \leq 0$，

$$w \leftarrow w + \eta y_i x_i \\ b \leftarrow b + \eta y_i$$

(4)转至(2)，直至数据没有误分类点

2.3.2 算法收敛性的证明

首先将偏置$b$也并入权重向量$w$，记做$\hat w = (w^T, b)^T$，同样也将输入向量加以补充，加进常数1，记做$\hat x = (x^T, 1)^T$，这样$\hat x \in R^{n+1}, \hat w \in R ^ {n + 1}$，显然，$\hat w \cdot x = w \cdot x + b$

Novikoff定理
设训练数据$T={(x_1, y_1), (x_2, y_2), ..., (x_N, y_N)}$是线性可分，其中$x_i \in X = R^n, y_i \in y = {-1, +1}, i = 1,2,.., N$，则

（1）存在满足条件$||\hat w _{opt}|| = 1$的超平面$\hat w_{opt} \cdot \hat x = w_{opt} \cdot x + b_{opt} = 0$将训练集数据完全分开；且存在$\gamma > 0$，对所有$i = 1, 2, ..., N$

$$y_i(\hat w_{opt} \cdot x_i) = y_i(w_{opt} \cdot x_i + b_{opt}) \geq \gamma$$

（2）令$R = \underset{1 \leq i \leq N}{max} || \hat x_{i}$，则感知机算法在训练数据集上的误分类次数$k$满足不等式

$$k \leq (\frac{R}{\gamma}) ^ 2$$

证明：

（1）由于数据集是线性可分的，按照定义存在超平面可以将数据集完全正确分开，取超平面为$\hat w_{opt} \cdot \hat x = w_{opt} \cdot x + b_{opt} = 0$，并使$||\hat w _{opt}|| = 1$，因此对于有限的$i$，均有

$$y_i(\hat w_{opt} \cdot x_i) = y_i(w_{opt} \cdot x_i + b_{opt}) > 0$$

所以存在$\gamma$，

$$\gamma = \underset{i} {min} \{y_i(w_{opt} \cdot x_i + b_{opt})\}$$

满足

$$y_i(\hat w_{opt} \cdot x_i) = y_i(w_{opt} \cdot x_i + b_{opt}) \geq \gamma$$

（2）令$\hat w_{k - 1}$是第$k$个误分类实例之前的扩充权重向量，即

$$\hat w_{k-1} = (w_{k-1}^T, b_{k-1})^T$$

第$k$个误分类实例的条件是

$$y_i(\hat w_{k-1} \cdot x_i) = y_i(w_{k-1} \cdot x_i + b_{k-1}) \leq 0$$

若$(x_i, y_i)$是被误分类的数据，则

$$\hat w_k = \hat w_{k-1} + \eta y_i \hat x_i$$

由此，推导两个不等式

$$\hat w_k \cdot \hat w_{opt} \geq k \eta \gamma \tag {2.12}$$

由之前的式子可知

$$\hat w_k \cdot \hat w_{opt} = \hat w_{k-1} \cdot \hat w_{opt} + \eta y_i \hat w_{opt} \cdot \hat x_i \\ \geq \hat w_{k-1} \cdot \hat w_{opt} + \eta \gamma$$

进一步递推得到

$$\hat w_k \cdot \hat w_{opt}\geq \hat w_{k-1} \cdot \hat w_{opt} + \eta \gamma \geq \hat w_{k-2} \cdot \hat w_{opt} + 2\eta \gamma \geq ... \geq k \eta \gamma \\ $$

下一步证明

$$||\hat w_{k}|| \leq k \eta^2 R^2 \tag{2.13}$$

由前面的式子可得

$$||\hat w_k||^2 = ||\hat w_{k-1}||^2 + 2 y_i \hat w_{k-1} \cdot \hat x_i + \eta^2||\hat x_i||^2 \\ \leq ||\hat w_{k-1}||^2 + \eta^2||\hat x_i||^2 \\ \leq ||\hat w_{k-1}||^2 + \eta^2 R^2 \\ \leq ||\hat w_{k-2}||^2 + 2\eta^2 R^2 \leq ... \\ \leq k \eta^2 R^2$$

结合2.12和2.13可得

$$k \eta \gamma \leq \hat w_k \cdot \hat w_{opt} \leq ||\hat w_k||\ || \hat w_{opt}|| = ||\hat w_k|| \leq \sqrt{k}\eta R \\ k^2 \gamma ^2 \leq k R^2$$

所以得到

$$k \leq (\frac{R}{\gamma})^2$$

最终证明误分类次数存在上界，经过有限次搜索可以找到将训练数据完全正确分开的分离超平面。也就是说，当数据线性可分时，感知机算法是收敛的。

习题

2.1

假设二维平面，存在四个点，（1，1）、（1，-1）、（-1，1）、（-1，-1），根据异或的定义，（1，1）和（-1，-1）应被归为一类，但从二维空间看，并不存在这样一个平面，可以将这4个点，依据正负样本分隔开。

2.3

必要性：

样本线性可分->正实例点所构成的凸壳与负实例点所构成的凸壳互不相交

采用反证法

假设样本集线性可分，正实例点所构成的凸壳与负实例点所构成的凸壳相交，即存在某个元素$s$，同时满足$s \in \text{conv}(S_+)$和$s \in \text{conv}(S_-)$。

首先样本线性可分，代表存在一个超平面$w \cdot x + b = 0$，使得正、负实例处于超平面的两边，即对于所有的正实例来说，满足

$$w \cdot x_i + b = \epsilon_i > 0, i = 1,2,...,|S_+|$$

根据凸壳的定义，对于$conv(S_+)$中的元素，存在

$$w \cdot s_+ + b = w \cdot \sum_{i=1}^{|S_+|} \lambda_i x_i +b \\ = \sum_{i=1}^{|S_+|}\lambda_i w \cdot x_i + b \\ = \sum_{i=1}^{|S_+|}\lambda_i (\epsilon_i - b) + b \\ = \sum_{i=1}^{|S_+|}\lambda_i \epsilon_i > 0$$

同理，对于$conv(S_-)$中的元素，均存在

$$w \cdot s_- + b = = \sum_{i=1}^{|S_-|}\lambda_i \epsilon_i < 0$$

那根据推理，不存在$s$同时满足$s \in \text{conv}(S_+)$和$s \in \text{conv}(S_-)$。

充分性有点纠结...没有发现好理解的证明

感知机原始形式代码实现：

# 感知机的原始形式
import numpy as np

X = np.array([[3,3], [4,3], [1,1]]).T
y = np.array([1,1,-1]).T

# 构建模型
def predict(w, b, x):
    f = np.dot(w , x) + b
    return 1 if f > 0 else -1 

# 模型训练
def train(lr=1):
    # 初始化
    w = np.array([0, 0]) 
    b = 0
    lr = lr
    
    false_count = len(X)    
    iter_count = 0
    # 迭代
    while false_count != 0:
        print(f"this is the {iter_count}th iter")
        false_count = X.shape[1]
        for x_p, y_p in zip(X.T, y):
            print(f'the train set is {x_p}, {y_p}')
            pre_y = predict(w, b, x_p)
            # print(pre_y)
            if pre_y * y_p <= 0:
                w = w + lr * y_p * x_p
                b = b + lr * y_p 
                print(w, b)
            else:
                false_count -= 1
                print(f'false_count:{false_count}')
        iter_count += 1

train()

感知机对偶形式代码实现

# 生成gram矩阵
def calculate_gram_matrix(X):
    # 矩阵中不同样本是列向量
    gram_matrix = np.dot(X.T, X)
    return gram_matrix

# 
def duality_predict(alpha, b, x_i, gram_matrix_p):
    n = len(gram_matrix_p) 
    res = 0
    for j, x_j_x_i in enumerate(gram_matrix_p):
        res += alpha[j] * y[j] * x_j_x_i
    
    res += b
    return res

def duality_train():
    # 初始化
    alpha = np.array([0, 0, 0]) 
    b = 0
    
    false_count = len(X)    
    iter_count = 0
   
    gram_matrix = calculate_gram_matrix(X)
    # 迭代
    while false_count != 0:
        print(f"this is the {iter_count}th iter")
        false_count = X.shape[1]
        
        for i, (x_i, y_i) in enumerate(zip(X.T, y)):
            print(f'the train set is {x_i}, {y_i}')
            pre_y = duality_predict(alpha, b, x_i, gram_matrix[i])
            # print(pre_y)
            if pre_y * y_i <= 0:
                alpha[i] += 1
                b += y_i
                print(alpha, b)
            else:
                false_count -= 1
                print(f'false_count:{false_count}')
        iter_count += 1
    
    w = 0
    for i, x_i in enumerate(X):
        w += alpha[i] * y[i] * X[:,i]
     
duality_train()