（笔记+代码+习题）统计学习方法第二章 感知机

一、机器学习的老祖宗——感知机

感知机1957年由Rosenblatt提出，是神经网络与支持向量机的基础。是二类分类的线性分类模型，属于判别模型，旨在求出将训练数据进行线性划分的分离超平面，为此，导入基于误分类的损失函数，利用梯度下降法对损失函数进行极小化，求得感知机模型。

• 训练数据集：线性可分（必存在超平面将训练集正负实例分开）
• 学习目标：找到一个将训练集正、负实例点完全正确分开的超平面
• 具体学习对象：$w、b$
• **学习策略：**误分类点到超平面S的总距离最小
• **算法形式：**原始形式+对偶形式

二、从机器学习的三要素角度来详细认识感知机

1、模型

• 输入空间（特征空间）是 $\chi \subseteq R^n$，输入 $x\in \chi$ 表示实例的特征向量

• 输出空间是 $Y=\{+1,-1\}$，输出 $y\in Y$表示实例的类别。

• 输入空间 —> 输出空间：

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

其中，$\ast \ast w$和$b$为感知机模型参数，也就是我们机器学习最终要学习的参数**。

sign是符号函数，

$$sign(x)=\{\begin{array}{c}+1,x>0\\ -1,x<0\end{array}$$

2、策略

确定学习策略就是定义**(经验)损失函数并将损失函数最小化。（注意这里提到了经验**，所以学习是base在训练数据集上的操作）

关于损失函数的选择问题？

我们对损失函数的要求就是参数$w，b$的连续可导函数，这样才易优化（后面随机梯度来优化，不可导何谈梯度）。为此，感知机的损失函数选择了：误分类点到超平面$S$的总距离，而不是误分类点的总数。

数学形式：

$$L(w,b)=-\sum _{x_i\in M}{y}_i(w\cdot x_i+b)$$

其中$M$是误分类点的集合，给定训练数据集$T$，损失函数$L(w,b)$是$w$和$b$的连续可导函数

3、算法——原始形式

• 输入

  $$\begin{gathered} T=(x_1,y_1),(x_2,y_2),\dots ,(x_N,y_N) \\ {x}_i\in \chi =R^n,y_i\in Y=-1,+1,i=1,2,...，N；0<\eta ⩽1 \end{gathered}$$

• 输出

  $$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)⩽0$

     $$\begin{gathered} w\leftarrow w+\eta y_i{x}_i \\ b\leftarrow b+\eta y_i \end{gathered}$$

  4. 转至(2)，直至训练集中没有误分类点

• 步骤解释：

  • 步骤1：

    初始超平面一般选$w_0=0,b_0=0$，不同的初始值会学习出不同满足条件的模型，多解问题。

  • 步骤2：

    每次选一个数据点判断是不是误判，不是的话不修正参数，直接下一轮。

  • 步骤3：

    • 极小化过程中不是一次使所有误分类点的梯度下降，而是每次随机选取一个误分类点使其梯度下降（随机梯度法），如3中的$(x_i,y_i)$这一误分类点
    • 如果$(x_i,y_i)$是误分类点，说明$y_i、f(x_i)$异号，则如3中满足$y_i(w\cdot x_i+b)⩽0$
    • 梯度可以由上面损失函数的数学形式看出

  • 步骤4：

    步骤4可能是算法中最不好理解的地方，我学到这里的疑问是：

    用上面的步骤为什么能实现”直至训练集中没有误分类点“？

    这里其实涉及到一个普遍且重要的问题——算法的收敛性，换句话说，我们的算法有效的话，那么经过有限次修正之后一定能找到符合终止条件的模型。

    证明请见：Novikoff定理证明

4、算法——对偶形式

对偶形式的基本思想是将$w$和$b$表示为实例$x_i$和标记$y_i$的线性组合的形式，通过求解其系数而求得$w$和$b$。

原始形式中对误分类点$(x_i,y_i)$通过：

$$\begin{gathered} w\leftarrow w+\eta y_i{x}_i \\ b\leftarrow b+\eta y_i \end{gathered}$$

来修正。假设对于某误分类点$(x_i,y_i)$，一共修正了$n_i$次，那么：

$$\begin{gathered} w\leftarrow w+n_i\eta y_i{x}_i \\ b\leftarrow b+n_i\eta y_i \end{gathered}$$

那么，对于所有数据点$w,b$的变化就是：

$$\begin{gathered} w\leftarrow w+\sum _{i=1}^N{n}_i\eta y_i{x}_i \\ b\leftarrow b+\sum _{i=1}^N{n}_i\eta y_i \end{gathered}$$

如果令初始$w_0=0,b_0=0,{\alpha }_i=n_i\eta$，则有：

$$\begin{gathered} w=\sum _{i=1}^N{\alpha }_i{y}_i{x}_i \\ b=\sum _{i=1}^N{\alpha }_i{y}_i \end{gathered}$$

在原始形式中，我们是要学习$w,b$，现在可以转化为$\alpha 、b$

对偶形式：

• 输入：

  $$\begin{gathered} T=\{(x_1,y_1),(x_2,y_2),\dots ,(x_N,y_N)\} \\ {x}_i\in X={\mathbf{R}}^{\mathbf{n}},{\mathbf{y}}_{\mathbf{i}}\in \mathbf{Y}=\{-1,+1\},\mathbf{i}=1,2,\dots ,\mathbf{N};0<\eta ⩽1 \end{gathered}$$

• 输出：

  $$\begin{gathered} \alpha ,b;f(x)=sign(\sum _{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x+b) \\ \alpha =({\alpha }_1,{\alpha }_2,...{\alpha }_N{)}^T \end{gathered}$$

• 步骤：

  1. $\alpha \leftarrow 0,b\leftarrow 0$

  2. 训练集中选取数据$(x_i,y_i)$

  3. 如果$y_i\left({\sum }_{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x+b\right)⩽0$

     $$\begin{gathered} {\alpha }_i\leftarrow {\alpha }_i+\eta \\ b\leftarrow b+\eta y_i \end{gathered}$$

  4. 转至(2)，直至训练集中没有误分类点

• 步骤解释：

  • 步骤1：和前面一样，初始值取0

  • 步骤2：每次也是选取一个数据

  • 步骤3：

    • 如果数据点是误判点的话，开始修正
    • 这里关注一下梯度的计算：对于每一个数据$(x_i,y_i)$每一次修正来说，${\alpha }_i$的变化量是：$\eta$，$b$还是$\eta y_i$不变

  • 步骤4：与原始形式一样，感知机学习算法的对偶形式迭代是收敛的，存在多个解

Gram matrix

对偶形式中，训练实例仅以内积的形式出现。

为了方便可预先将训练集中的实例间的内积计算出来并以矩阵的形式存储，这个矩阵就是所谓的Gram矩阵

$$G=[x_i\cdot x_j{]}_{N\times N}$$

三、代码实现

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

#加载数据
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target

df.columns = [
    'sepal length', 'sepal width', 'petal length', 'petal width', 'label'
]
print(df.label.value_counts())

#画出原始数据离散图
plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('original data')
plt.legend()
plt.show()

data = np.array(df.iloc[:100, [0, 1, -1]])
X, y = data[:,:-1], data[:,-1]
print("X: ",X)
print("y: ",y)
y = np.array([1 if i == 1 else -1 for i in y])

#感知机模型
# 数据线性可分，二分类数据
# 此处为一元一次线性方程
class Model:
    def __init__(self):
        self.w = np.ones(len(data[0]) - 1, dtype=np.float32)
        self.b = 0
        self.l_rate = 0.1
        # self.data = data

    def sign(self, x, w, b):
        y = np.dot(x, w) + b
        return y

    # 随机梯度下降法
    def fit(self, X_train, y_train):
        is_wrong = False
        while not is_wrong:
            wrong_count = 0
            for d in range(len(X_train)):
                X = X_train[d]
                y = y_train[d]
                if y * self.sign(X, self.w, self.b) <= 0:
                    self.w = self.w + self.l_rate * np.dot(y, X)
                    self.b = self.b + self.l_rate * y
                    wrong_count += 1
            if wrong_count == 0:
                is_wrong = True
        return 'Perceptron Model!'

    def score(self):
        pass

perceptron = Model()
perceptron.fit(X, y)

#画出训练结果
x_points = np.linspace(4, 7, 10)
y_ = -(perceptron.w[0] * x_points + perceptron.b) / perceptron.w[1]
plt.plot(x_points, y_)
plt.plot(data[:50, 0], data[:50, 1], 'bo', color='blue', label='0')
plt.plot(data[50:100, 0], data[50:100, 1], 'bo', color='orange', label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('result')
plt.legend()
plt.show()

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hS62NC6Z-1636977901727)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/d3b23003-63be-495a-bbb9-ba3b3a16a9ec/Untitled.png)]

习题解答：https://github.com/datawhalechina/statistical-learning-method-solutions-manual## 一、机器学习的老祖宗——感知机

感知机1957年由Rosenblatt提出，是神经网络与支持向量机的基础。是二类分类的线性分类模型，属于判别模型，旨在求出将训练数据进行线性划分的分离超平面，为此，导入基于误分类的损失函数，利用梯度下降法对损失函数进行极小化，求得感知机模型。

• 训练数据集：线性可分（必存在超平面将训练集正负实例分开）
• 学习目标：找到一个将训练集正、负实例点完全正确分开的超平面
• 具体学习对象：$w、b$
• **学习策略：**误分类点到超平面S的总距离最小
• **算法形式：**原始形式+对偶形式

二、从机器学习的三要素角度来详细认识感知机

1、模型

• 输入空间（特征空间）是 $\chi \subseteq R^n$，输入 $x\in \chi$ 表示实例的特征向量

• 输出空间是 $Y=\{+1,-1\}$，输出 $y\in Y$表示实例的类别。

• 输入空间 —> 输出空间：

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

其中，$\ast \ast w$和$b$为感知机模型参数，也就是我们机器学习最终要学习的参数**。

sign是符号函数，

$$sign(x)=\{\begin{array}{c}+1,x>0\\ -1,x<0\end{array}$$

2、策略

确定学习策略就是定义**(经验)损失函数并将损失函数最小化。（注意这里提到了经验**，所以学习是base在训练数据集上的操作）

关于损失函数的选择问题？

我们对损失函数的要求就是参数$w，b$的连续可导函数，这样才易优化（后面随机梯度来优化，不可导何谈梯度）。为此，感知机的损失函数选择了：误分类点到超平面$S$的总距离，而不是误分类点的总数。

数学形式：

$$L(w,b)=-\sum _{x_i\in M}{y}_i(w\cdot x_i+b)$$

其中$M$是误分类点的集合，给定训练数据集$T$，损失函数$L(w,b)$是$w$和$b$的连续可导函数

3、算法——原始形式

• 输入

  $$\begin{gathered} T=(x_1,y_1),(x_2,y_2),\dots ,(x_N,y_N) \\ {x}_i\in \chi =R^n,y_i\in Y=-1,+1,i=1,2,...，N；0<\eta ⩽1 \end{gathered}$$

• 输出

  $$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)⩽0$

     $$\begin{gathered} w\leftarrow w+\eta y_i{x}_i \\ b\leftarrow b+\eta y_i \end{gathered}$$

  4. 转至(2)，直至训练集中没有误分类点

• 步骤解释：

  • 步骤1：

    初始超平面一般选$w_0=0,b_0=0$，不同的初始值会学习出不同满足条件的模型，多解问题。

  • 步骤2：

    每次选一个数据点判断是不是误判，不是的话不修正参数，直接下一轮。

  • 步骤3：

    • 极小化过程中不是一次使所有误分类点的梯度下降，而是每次随机选取一个误分类点使其梯度下降（随机梯度法），如3中的$(x_i,y_i)$这一误分类点
    • 如果$(x_i,y_i)$是误分类点，说明$y_i、f(x_i)$异号，则如3中满足$y_i(w\cdot x_i+b)⩽0$
    • 梯度可以由上面损失函数的数学形式看出

  • 步骤4：

    步骤4可能是算法中最不好理解的地方，我学到这里的疑问是：

    用上面的步骤为什么能实现”直至训练集中没有误分类点“？

    这里其实涉及到一个普遍且重要的问题——算法的收敛性，换句话说，我们的算法有效的话，那么经过有限次修正之后一定能找到符合终止条件的模型。

    证明请见：Novikoff定理证明

4、算法——对偶形式

对偶形式的基本思想是将$w$和$b$表示为实例$x_i$和标记$y_i$的线性组合的形式，通过求解其系数而求得$w$和$b$。

原始形式中对误分类点$(x_i,y_i)$通过：

$$\begin{gathered} w\leftarrow w+\eta y_i{x}_i \\ b\leftarrow b+\eta y_i \end{gathered}$$

来修正。假设对于某误分类点$(x_i,y_i)$，一共修正了$n_i$次，那么：

$$\begin{gathered} w\leftarrow w+n_i\eta y_i{x}_i \\ b\leftarrow b+n_i\eta y_i \end{gathered}$$

那么，对于所有数据点$w,b$的变化就是：

$$\begin{gathered} w\leftarrow w+\sum _{i=1}^N{n}_i\eta y_i{x}_i \\ b\leftarrow b+\sum _{i=1}^N{n}_i\eta y_i \end{gathered}$$

如果令初始$w_0=0,b_0=0,{\alpha }_i=n_i\eta$，则有：

$$\begin{gathered} w=\sum _{i=1}^N{\alpha }_i{y}_i{x}_i \\ b=\sum _{i=1}^N{\alpha }_i{y}_i \end{gathered}$$

在原始形式中，我们是要学习$w,b$，现在可以转化为$\alpha 、b$

对偶形式：

• 输入：

  $$\begin{gathered} T=\{(x_1,y_1),(x_2,y_2),\dots ,(x_N,y_N)\} \\ {x}_i\in X={\mathbf{R}}^{\mathbf{n}},{\mathbf{y}}_{\mathbf{i}}\in \mathbf{Y}=\{-1,+1\},\mathbf{i}=1,2,\dots ,\mathbf{N};0<\eta ⩽1 \end{gathered}$$

• 输出：

  $$\begin{gathered} \alpha ,b;f(x)=sign(\sum _{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x+b) \\ \alpha =({\alpha }_1,{\alpha }_2,...{\alpha }_N{)}^T \end{gathered}$$

• 步骤：

  1. $\alpha \leftarrow 0,b\leftarrow 0$

  2. 训练集中选取数据$(x_i,y_i)$

  3. 如果$y_i\left({\sum }_{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x+b\right)⩽0$

     $$\begin{gathered} {\alpha }_i\leftarrow {\alpha }_i+\eta \\ b\leftarrow b+\eta y_i \end{gathered}$$

  4. 转至(2)，直至训练集中没有误分类点

• 步骤解释：

  • 步骤1：和前面一样，初始值取0

  • 步骤2：每次也是选取一个数据

  • 步骤3：

    • 如果数据点是误判点的话，开始修正
    • 这里关注一下梯度的计算：对于每一个数据$(x_i,y_i)$每一次修正来说，${\alpha }_i$的变化量是：$\eta$，$b$还是$\eta y_i$不变

  • 步骤4：与原始形式一样，感知机学习算法的对偶形式迭代是收敛的，存在多个解

Gram matrix

对偶形式中，训练实例仅以内积的形式出现。

为了方便可预先将训练集中的实例间的内积计算出来并以矩阵的形式存储，这个矩阵就是所谓的Gram矩阵

$$G=[x_i\cdot x_j{]}_{N\times N}$$

三、代码实现

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

#加载数据
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target

df.columns = [
    'sepal length', 'sepal width', 'petal length', 'petal width', 'label'
]
print(df.label.value_counts())

#画出原始数据离散图
plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('original data')
plt.legend()
plt.show()

data = np.array(df.iloc[:100, [0, 1, -1]])
X, y = data[:,:-1], data[:,-1]
print("X: ",X)
print("y: ",y)
y = np.array([1 if i == 1 else -1 for i in y])

#感知机模型
# 数据线性可分，二分类数据
# 此处为一元一次线性方程
class Model:
    def __init__(self):
        self.w = np.ones(len(data[0]) - 1, dtype=np.float32)
        self.b = 0
        self.l_rate = 0.1
        # self.data = data

    def sign(self, x, w, b):
        y = np.dot(x, w) + b
        return y

    # 随机梯度下降法
    def fit(self, X_train, y_train):
        is_wrong = False
        while not is_wrong:
            wrong_count = 0
            for d in range(len(X_train)):
                X = X_train[d]
                y = y_train[d]
                if y * self.sign(X, self.w, self.b) <= 0:
                    self.w = self.w + self.l_rate * np.dot(y, X)
                    self.b = self.b + self.l_rate * y
                    wrong_count += 1
            if wrong_count == 0:
                is_wrong = True
        return 'Perceptron Model!'

    def score(self):
        pass

perceptron = Model()
perceptron.fit(X, y)

#画出训练结果
x_points = np.linspace(4, 7, 10)
y_ = -(perceptron.w[0] * x_points + perceptron.b) / perceptron.w[1]
plt.plot(x_points, y_)
plt.plot(data[:50, 0], data[:50, 1], 'bo', color='blue', label='0')
plt.plot(data[50:100, 0], data[50:100, 1], 'bo', color='orange', label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('result')
plt.legend()
plt.show()

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-01X1BWFf-1636977902626)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/d3b23003-63be-495a-bbb9-ba3b3a16a9ec/Untitled.png)]

习题解答：https://github.com/datawhalechina/statistical-learning-method-solutions-manual## 一、机器学习的老祖宗——感知机

感知机1957年由Rosenblatt提出，是神经网络与支持向量机的基础。是二类分类的线性分类模型，属于判别模型，旨在求出将训练数据进行线性划分的分离超平面，为此，导入基于误分类的损失函数，利用梯度下降法对损失函数进行极小化，求得感知机模型。

• 训练数据集：线性可分（必存在超平面将训练集正负实例分开）
• 学习目标：找到一个将训练集正、负实例点完全正确分开的超平面
• 具体学习对象：$w、b$
• **学习策略：**误分类点到超平面S的总距离最小
• **算法形式：**原始形式+对偶形式

二、从机器学习的三要素角度来详细认识感知机

1、模型

• 输入空间（特征空间）是 $\chi \subseteq R^n$，输入 $x\in \chi$ 表示实例的特征向量

• 输出空间是 $Y=\{+1,-1\}$，输出 $y\in Y$表示实例的类别。

• 输入空间 —> 输出空间：

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

其中，$\ast \ast w$和$b$为感知机模型参数，也就是我们机器学习最终要学习的参数**。

sign是符号函数，

$$sign(x)=\{\begin{array}{c}+1,x>0\\ -1,x<0\end{array}$$

2、策略

确定学习策略就是定义**(经验)损失函数并将损失函数最小化。（注意这里提到了经验**，所以学习是base在训练数据集上的操作）

关于损失函数的选择问题？

我们对损失函数的要求就是参数$w，b$的连续可导函数，这样才易优化（后面随机梯度来优化，不可导何谈梯度）。为此，感知机的损失函数选择了：误分类点到超平面$S$的总距离，而不是误分类点的总数。

数学形式：

$$L(w,b)=-\sum _{x_i\in M}{y}_i(w\cdot x_i+b)$$

其中$M$是误分类点的集合，给定训练数据集$T$，损失函数$L(w,b)$是$w$和$b$的连续可导函数

3、算法——原始形式

• 输入

  $$\begin{gathered} T=(x_1,y_1),(x_2,y_2),\dots ,(x_N,y_N) \\ {x}_i\in \chi =R^n,y_i\in Y=-1,+1,i=1,2,...，N；0<\eta ⩽1 \end{gathered}$$

• 输出

  $$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)⩽0$

     $$\begin{gathered} w\leftarrow w+\eta y_i{x}_i \\ b\leftarrow b+\eta y_i \end{gathered}$$

  4. 转至(2)，直至训练集中没有误分类点

• 步骤解释：

  • 步骤1：

    初始超平面一般选$w_0=0,b_0=0$，不同的初始值会学习出不同满足条件的模型，多解问题。

  • 步骤2：

    每次选一个数据点判断是不是误判，不是的话不修正参数，直接下一轮。

  • 步骤3：

    • 极小化过程中不是一次使所有误分类点的梯度下降，而是每次随机选取一个误分类点使其梯度下降（随机梯度法），如3中的$(x_i,y_i)$这一误分类点
    • 如果$(x_i,y_i)$是误分类点，说明$y_i、f(x_i)$异号，则如3中满足$y_i(w\cdot x_i+b)⩽0$
    • 梯度可以由上面损失函数的数学形式看出

  • 步骤4：

    步骤4可能是算法中最不好理解的地方，我学到这里的疑问是：

    用上面的步骤为什么能实现”直至训练集中没有误分类点“？

    这里其实涉及到一个普遍且重要的问题——算法的收敛性，换句话说，我们的算法有效的话，那么经过有限次修正之后一定能找到符合终止条件的模型。

    证明请见：Novikoff定理证明

4、算法——对偶形式

对偶形式的基本思想是将$w$和$b$表示为实例$x_i$和标记$y_i$的线性组合的形式，通过求解其系数而求得$w$和$b$。

原始形式中对误分类点$(x_i,y_i)$通过：

$$\begin{gathered} w\leftarrow w+\eta y_i{x}_i \\ b\leftarrow b+\eta y_i \end{gathered}$$

来修正。假设对于某误分类点$(x_i,y_i)$，一共修正了$n_i$次，那么：

$$\begin{gathered} w\leftarrow w+n_i\eta y_i{x}_i \\ b\leftarrow b+n_i\eta y_i \end{gathered}$$

那么，对于所有数据点$w,b$的变化就是：

$$\begin{gathered} w\leftarrow w+\sum _{i=1}^N{n}_i\eta y_i{x}_i \\ b\leftarrow b+\sum _{i=1}^N{n}_i\eta y_i \end{gathered}$$

如果令初始$w_0=0,b_0=0,{\alpha }_i=n_i\eta$，则有：

$$\begin{gathered} w=\sum _{i=1}^N{\alpha }_i{y}_i{x}_i \\ b=\sum _{i=1}^N{\alpha }_i{y}_i \end{gathered}$$

在原始形式中，我们是要学习$w,b$，现在可以转化为$\alpha 、b$

对偶形式：

• 输入：

  $$\begin{gathered} T=\{(x_1,y_1),(x_2,y_2),\dots ,(x_N,y_N)\} \\ {x}_i\in X={\mathbf{R}}^{\mathbf{n}},{\mathbf{y}}_{\mathbf{i}}\in \mathbf{Y}=\{-1,+1\},\mathbf{i}=1,2,\dots ,\mathbf{N};0<\eta ⩽1 \end{gathered}$$

• 输出：

  $$\begin{gathered} \alpha ,b;f(x)=sign(\sum _{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x+b) \\ \alpha =({\alpha }_1,{\alpha }_2,...{\alpha }_N{)}^T \end{gathered}$$

• 步骤：

  1. $\alpha \leftarrow 0,b\leftarrow 0$

  2. 训练集中选取数据$(x_i,y_i)$

  3. 如果$y_i\left({\sum }_{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x+b\right)⩽0$

     $$\begin{gathered} {\alpha }_i\leftarrow {\alpha }_i+\eta \\ b\leftarrow b+\eta y_i \end{gathered}$$

  4. 转至(2)，直至训练集中没有误分类点

• 步骤解释：

  • 步骤1：和前面一样，初始值取0

  • 步骤2：每次也是选取一个数据

  • 步骤3：

    • 如果数据点是误判点的话，开始修正
    • 这里关注一下梯度的计算：对于每一个数据$(x_i,y_i)$每一次修正来说，${\alpha }_i$的变化量是：$\eta$，$b$还是$\eta y_i$不变

  • 步骤4：与原始形式一样，感知机学习算法的对偶形式迭代是收敛的，存在多个解

Gram matrix

对偶形式中，训练实例仅以内积的形式出现。

为了方便可预先将训练集中的实例间的内积计算出来并以矩阵的形式存储，这个矩阵就是所谓的Gram矩阵

$$G=[x_i\cdot x_j{]}_{N\times N}$$

三、代码实现

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

#加载数据
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target

df.columns = [
    'sepal length', 'sepal width', 'petal length', 'petal width', 'label'
]
print(df.label.value_counts())

#画出原始数据离散图
plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('original data')
plt.legend()
plt.show()

data = np.array(df.iloc[:100, [0, 1, -1]])
X, y = data[:,:-1], data[:,-1]
print("X: ",X)
print("y: ",y)
y = np.array([1 if i == 1 else -1 for i in y])

#感知机模型
# 数据线性可分，二分类数据
# 此处为一元一次线性方程
class Model:
    def __init__(self):
        self.w = np.ones(len(data[0]) - 1, dtype=np.float32)
        self.b = 0
        self.l_rate = 0.1
        # self.data = data

    def sign(self, x, w, b):
        y = np.dot(x, w) + b
        return y

    # 随机梯度下降法
    def fit(self, X_train, y_train):
        is_wrong = False
        while not is_wrong:
            wrong_count = 0
            for d in range(len(X_train)):
                X = X_train[d]
                y = y_train[d]
                if y * self.sign(X, self.w, self.b) <= 0:
                    self.w = self.w + self.l_rate * np.dot(y, X)
                    self.b = self.b + self.l_rate * y
                    wrong_count += 1
            if wrong_count == 0:
                is_wrong = True
        return 'Perceptron Model!'

    def score(self):
        pass

perceptron = Model()
perceptron.fit(X, y)

#画出训练结果
x_points = np.linspace(4, 7, 10)
y_ = -(perceptron.w[0] * x_points + perceptron.b) / perceptron.w[1]
plt.plot(x_points, y_)
plt.plot(data[:50, 0], data[:50, 1], 'bo', color='blue', label='0')
plt.plot(data[50:100, 0], data[50:100, 1], 'bo', color='orange', label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('result')
plt.legend()
plt.show()

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MCZCHEP6-1636977902840)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/d3b23003-63be-495a-bbb9-ba3b3a16a9ec/Untitled.png)]

习题解答：https://github.com/datawhalechina/statistical-learning-method-solutions-manual## 一、机器学习的老祖宗——感知机

感知机1957年由Rosenblatt提出，是神经网络与支持向量机的基础。是二类分类的线性分类模型，属于判别模型，旨在求出将训练数据进行线性划分的分离超平面，为此，导入基于误分类的损失函数，利用梯度下降法对损失函数进行极小化，求得感知机模型。

• 训练数据集：线性可分（必存在超平面将训练集正负实例分开）
• 学习目标：找到一个将训练集正、负实例点完全正确分开的超平面
• 具体学习对象：$w、b$
• **学习策略：**误分类点到超平面S的总距离最小
• **算法形式：**原始形式+对偶形式

二、从机器学习的三要素角度来详细认识感知机

1、模型

• 输入空间（特征空间）是 $\chi \subseteq R^n$，输入 $x\in \chi$ 表示实例的特征向量

• 输出空间是 $Y=\{+1,-1\}$，输出 $y\in Y$表示实例的类别。

• 输入空间 —> 输出空间：

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

其中，$\ast \ast w$和$b$为感知机模型参数，也就是我们机器学习最终要学习的参数**。

sign是符号函数，

$$sign(x)=\{\begin{array}{c}+1,x>0\\ -1,x<0\end{array}$$

2、策略

确定学习策略就是定义**(经验)损失函数并将损失函数最小化。（注意这里提到了经验**，所以学习是base在训练数据集上的操作）

关于损失函数的选择问题？

我们对损失函数的要求就是参数$w，b$的连续可导函数，这样才易优化（后面随机梯度来优化，不可导何谈梯度）。为此，感知机的损失函数选择了：误分类点到超平面$S$的总距离，而不是误分类点的总数。

数学形式：

$$L(w,b)=-\sum _{x_i\in M}{y}_i(w\cdot x_i+b)$$

其中$M$是误分类点的集合，给定训练数据集$T$，损失函数$L(w,b)$是$w$和$b$的连续可导函数

3、算法——原始形式

• 输入

  $$\begin{gathered} T=(x_1,y_1),(x_2,y_2),\dots ,(x_N,y_N) \\ {x}_i\in \chi =R^n,y_i\in Y=-1,+1,i=1,2,...，N；0<\eta ⩽1 \end{gathered}$$

• 输出

  $$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)⩽0$

     $$\begin{gathered} w\leftarrow w+\eta y_i{x}_i \\ b\leftarrow b+\eta y_i \end{gathered}$$

  4. 转至(2)，直至训练集中没有误分类点

• 步骤解释：

  • 步骤1：

    初始超平面一般选$w_0=0,b_0=0$，不同的初始值会学习出不同满足条件的模型，多解问题。

  • 步骤2：

    每次选一个数据点判断是不是误判，不是的话不修正参数，直接下一轮。

  • 步骤3：

    • 极小化过程中不是一次使所有误分类点的梯度下降，而是每次随机选取一个误分类点使其梯度下降（随机梯度法），如3中的$(x_i,y_i)$这一误分类点
    • 如果$(x_i,y_i)$是误分类点，说明$y_i、f(x_i)$异号，则如3中满足$y_i(w\cdot x_i+b)⩽0$
    • 梯度可以由上面损失函数的数学形式看出

  • 步骤4：

    步骤4可能是算法中最不好理解的地方，我学到这里的疑问是：

    用上面的步骤为什么能实现”直至训练集中没有误分类点“？

    这里其实涉及到一个普遍且重要的问题——算法的收敛性，换句话说，我们的算法有效的话，那么经过有限次修正之后一定能找到符合终止条件的模型。

    证明请见：Novikoff定理证明

4、算法——对偶形式

对偶形式的基本思想是将$w$和$b$表示为实例$x_i$和标记$y_i$的线性组合的形式，通过求解其系数而求得$w$和$b$。

原始形式中对误分类点$(x_i,y_i)$通过：

$$\begin{gathered} w\leftarrow w+\eta y_i{x}_i \\ b\leftarrow b+\eta y_i \end{gathered}$$

来修正。假设对于某误分类点$(x_i,y_i)$，一共修正了$n_i$次，那么：

$$\begin{gathered} w\leftarrow w+n_i\eta y_i{x}_i \\ b\leftarrow b+n_i\eta y_i \end{gathered}$$

那么，对于所有数据点$w,b$的变化就是：

$$\begin{gathered} w\leftarrow w+\sum _{i=1}^N{n}_i\eta y_i{x}_i \\ b\leftarrow b+\sum _{i=1}^N{n}_i\eta y_i \end{gathered}$$

如果令初始$w_0=0,b_0=0,{\alpha }_i=n_i\eta$，则有：

$$\begin{gathered} w=\sum _{i=1}^N{\alpha }_i{y}_i{x}_i \\ b=\sum _{i=1}^N{\alpha }_i{y}_i \end{gathered}$$

在原始形式中，我们是要学习$w,b$，现在可以转化为$\alpha 、b$

对偶形式：

• 输入：

  $$\begin{gathered} T=\{(x_1,y_1),(x_2,y_2),\dots ,(x_N,y_N)\} \\ {x}_i\in X={\mathbf{R}}^{\mathbf{n}},{\mathbf{y}}_{\mathbf{i}}\in \mathbf{Y}=\{-1,+1\},\mathbf{i}=1,2,\dots ,\mathbf{N};0<\eta ⩽1 \end{gathered}$$

• 输出：

  $$\begin{gathered} \alpha ,b;f(x)=sign(\sum _{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x+b) \\ \alpha =({\alpha }_1,{\alpha }_2,...{\alpha }_N{)}^T \end{gathered}$$

• 步骤：

  1. $\alpha \leftarrow 0,b\leftarrow 0$

  2. 训练集中选取数据$(x_i,y_i)$

  3. 如果$y_i\left({\sum }_{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x+b\right)⩽0$

     $$\begin{gathered} {\alpha }_i\leftarrow {\alpha }_i+\eta \\ b\leftarrow b+\eta y_i \end{gathered}$$

  4. 转至(2)，直至训练集中没有误分类点

• 步骤解释：

  • 步骤1：和前面一样，初始值取0

  • 步骤2：每次也是选取一个数据

  • 步骤3：

    • 如果数据点是误判点的话，开始修正
    • 这里关注一下梯度的计算：对于每一个数据$(x_i,y_i)$每一次修正来说，${\alpha }_i$的变化量是：$\eta$，$b$还是$\eta y_i$不变

  • 步骤4：与原始形式一样，感知机学习算法的对偶形式迭代是收敛的，存在多个解

Gram matrix

对偶形式中，训练实例仅以内积的形式出现。

为了方便可预先将训练集中的实例间的内积计算出来并以矩阵的形式存储，这个矩阵就是所谓的Gram矩阵

$$G=[x_i\cdot x_j{]}_{N\times N}$$

三、代码实现

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

#加载数据
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target

df.columns = [
    'sepal length', 'sepal width', 'petal length', 'petal width', 'label'
]
print(df.label.value_counts())

#画出原始数据离散图
plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('original data')
plt.legend()
plt.show()

data = np.array(df.iloc[:100, [0, 1, -1]])
X, y = data[:,:-1], data[:,-1]
print("X: ",X)
print("y: ",y)
y = np.array([1 if i == 1 else -1 for i in y])

#感知机模型
# 数据线性可分，二分类数据
# 此处为一元一次线性方程
class Model:
    def __init__(self):
        self.w = np.ones(len(data[0]) - 1, dtype=np.float32)
        self.b = 0
        self.l_rate = 0.1
        # self.data = data

    def sign(self, x, w, b):
        y = np.dot(x, w) + b
        return y

    # 随机梯度下降法
    def fit(self, X_train, y_train):
        is_wrong = False
        while not is_wrong:
            wrong_count = 0
            for d in range(len(X_train)):
                X = X_train[d]
                y = y_train[d]
                if y * self.sign(X, self.w, self.b) <= 0:
                    self.w = self.w + self.l_rate * np.dot(y, X)
                    self.b = self.b + self.l_rate * y
                    wrong_count += 1
            if wrong_count == 0:
                is_wrong = True
        return 'Perceptron Model!'

    def score(self):
        pass

perceptron = Model()
perceptron.fit(X, y)

#画出训练结果
x_points = np.linspace(4, 7, 10)
y_ = -(perceptron.w[0] * x_points + perceptron.b) / perceptron.w[1]
plt.plot(x_points, y_)
plt.plot(data[:50, 0], data[:50, 1], 'bo', color='blue', label='0')
plt.plot(data[50:100, 0], data[50:100, 1], 'bo', color='orange', label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('result')
plt.legend()
plt.show()

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AxFc4sse-1636977903094)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/d3b23003-63be-495a-bbb9-ba3b3a16a9ec/Untitled.png)]

习题解答：https://github.com/datawhalechina/statistical-learning-method-solutions-manual## 一、机器学习的老祖宗——感知机

感知机1957年由Rosenblatt提出，是神经网络与支持向量机的基础。是二类分类的线性分类模型，属于判别模型，旨在求出将训练数据进行线性划分的分离超平面，为此，导入基于误分类的损失函数，利用梯度下降法对损失函数进行极小化，求得感知机模型。

• 训练数据集：线性可分（必存在超平面将训练集正负实例分开）
• 学习目标：找到一个将训练集正、负实例点完全正确分开的超平面
• 具体学习对象：$w、b$
• **学习策略：**误分类点到超平面S的总距离最小
• **算法形式：**原始形式+对偶形式

二、从机器学习的三要素角度来详细认识感知机

1、模型

• 输入空间（特征空间）是 $\chi \subseteq R^n$，输入 $x\in \chi$ 表示实例的特征向量

• 输出空间是 $Y=\{+1,-1\}$，输出 $y\in Y$表示实例的类别。

• 输入空间 —> 输出空间：

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

其中，$\ast \ast w$和$b$为感知机模型参数，也就是我们机器学习最终要学习的参数**。

sign是符号函数，

$$sign(x)=\{\begin{array}{c}+1,x>0\\ -1,x<0\end{array}$$

2、策略

确定学习策略就是定义**(经验)损失函数并将损失函数最小化。（注意这里提到了经验**，所以学习是base在训练数据集上的操作）

关于损失函数的选择问题？

我们对损失函数的要求就是参数$w，b$的连续可导函数，这样才易优化（后面随机梯度来优化，不可导何谈梯度）。为此，感知机的损失函数选择了：误分类点到超平面$S$的总距离，而不是误分类点的总数。

数学形式：

$$L(w,b)=-\sum _{x_i\in M}{y}_i(w\cdot x_i+b)$$

其中$M$是误分类点的集合，给定训练数据集$T$，损失函数$L(w,b)$是$w$和$b$的连续可导函数

3、算法——原始形式

• 输入

  $$\begin{gathered} T=(x_1,y_1),(x_2,y_2),\dots ,(x_N,y_N) \\ {x}_i\in \chi =R^n,y_i\in Y=-1,+1,i=1,2,...，N；0<\eta ⩽1 \end{gathered}$$

• 输出

  $$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)⩽0$

     $$\begin{gathered} w\leftarrow w+\eta y_i{x}_i \\ b\leftarrow b+\eta y_i \end{gathered}$$

  4. 转至(2)，直至训练集中没有误分类点

• 步骤解释：

  • 步骤1：

    初始超平面一般选$w_0=0,b_0=0$，不同的初始值会学习出不同满足条件的模型，多解问题。

  • 步骤2：

    每次选一个数据点判断是不是误判，不是的话不修正参数，直接下一轮。

  • 步骤3：

    • 极小化过程中不是一次使所有误分类点的梯度下降，而是每次随机选取一个误分类点使其梯度下降（随机梯度法），如3中的$(x_i,y_i)$这一误分类点
    • 如果$(x_i,y_i)$是误分类点，说明$y_i、f(x_i)$异号，则如3中满足$y_i(w\cdot x_i+b)⩽0$
    • 梯度可以由上面损失函数的数学形式看出

  • 步骤4：

    步骤4可能是算法中最不好理解的地方，我学到这里的疑问是：

    用上面的步骤为什么能实现”直至训练集中没有误分类点“？

    这里其实涉及到一个普遍且重要的问题——算法的收敛性，换句话说，我们的算法有效的话，那么经过有限次修正之后一定能找到符合终止条件的模型。

    证明请见：Novikoff定理证明

4、算法——对偶形式

对偶形式的基本思想是将$w$和$b$表示为实例$x_i$和标记$y_i$的线性组合的形式，通过求解其系数而求得$w$和$b$。

原始形式中对误分类点$(x_i,y_i)$通过：

$$\begin{gathered} w\leftarrow w+\eta y_i{x}_i \\ b\leftarrow b+\eta y_i \end{gathered}$$

来修正。假设对于某误分类点$(x_i,y_i)$，一共修正了$n_i$次，那么：

$$\begin{gathered} w\leftarrow w+n_i\eta y_i{x}_i \\ b\leftarrow b+n_i\eta y_i \end{gathered}$$

那么，对于所有数据点$w,b$的变化就是：

$$\begin{gathered} w\leftarrow w+\sum _{i=1}^N{n}_i\eta y_i{x}_i \\ b\leftarrow b+\sum _{i=1}^N{n}_i\eta y_i \end{gathered}$$

如果令初始$w_0=0,b_0=0,{\alpha }_i=n_i\eta$，则有：

$$\begin{gathered} w=\sum _{i=1}^N{\alpha }_i{y}_i{x}_i \\ b=\sum _{i=1}^N{\alpha }_i{y}_i \end{gathered}$$

在原始形式中，我们是要学习$w,b$，现在可以转化为$\alpha 、b$

对偶形式：

• 输入：

  $$\begin{gathered} T=\{(x_1,y_1),(x_2,y_2),\dots ,(x_N,y_N)\} \\ {x}_i\in X={\mathbf{R}}^{\mathbf{n}},{\mathbf{y}}_{\mathbf{i}}\in \mathbf{Y}=\{-1,+1\},\mathbf{i}=1,2,\dots ,\mathbf{N};0<\eta ⩽1 \end{gathered}$$

• 输出：

  $$\begin{gathered} \alpha ,b;f(x)=sign(\sum _{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x+b) \\ \alpha =({\alpha }_1,{\alpha }_2,...{\alpha }_N{)}^T \end{gathered}$$

• 步骤：

  1. $\alpha \leftarrow 0,b\leftarrow 0$

  2. 训练集中选取数据$(x_i,y_i)$

  3. 如果$y_i\left({\sum }_{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x+b\right)⩽0$

     $$\begin{gathered} {\alpha }_i\leftarrow {\alpha }_i+\eta \\ b\leftarrow b+\eta y_i \end{gathered}$$

  4. 转至(2)，直至训练集中没有误分类点

• 步骤解释：

  • 步骤1：和前面一样，初始值取0

  • 步骤2：每次也是选取一个数据

  • 步骤3：

    • 如果数据点是误判点的话，开始修正
    • 这里关注一下梯度的计算：对于每一个数据$(x_i,y_i)$每一次修正来说，${\alpha }_i$的变化量是：$\eta$，$b$还是$\eta y_i$不变

  • 步骤4：与原始形式一样，感知机学习算法的对偶形式迭代是收敛的，存在多个解

Gram matrix

对偶形式中，训练实例仅以内积的形式出现。

为了方便可预先将训练集中的实例间的内积计算出来并以矩阵的形式存储，这个矩阵就是所谓的Gram矩阵

$$G=[x_i\cdot x_j{]}_{N\times N}$$

三、代码实现

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

#加载数据
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target

df.columns = [
    'sepal length', 'sepal width', 'petal length', 'petal width', 'label'
]
print(df.label.value_counts())

#画出原始数据离散图
plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('original data')
plt.legend()
plt.show()

data = np.array(df.iloc[:100, [0, 1, -1]])
X, y = data[:,:-1], data[:,-1]
print("X: ",X)
print("y: ",y)
y = np.array([1 if i == 1 else -1 for i in y])

#感知机模型
# 数据线性可分，二分类数据
# 此处为一元一次线性方程
class Model:
    def __init__(self):
        self.w = np.ones(len(data[0]) - 1, dtype=np.float32)
        self.b = 0
        self.l_rate = 0.1
        # self.data = data

    def sign(self, x, w, b):
        y = np.dot(x, w) + b
        return y

    # 随机梯度下降法
    def fit(self, X_train, y_train):
        is_wrong = False
        while not is_wrong:
            wrong_count = 0
            for d in range(len(X_train)):
                X = X_train[d]
                y = y_train[d]
                if y * self.sign(X, self.w, self.b) <= 0:
                    self.w = self.w + self.l_rate * np.dot(y, X)
                    self.b = self.b + self.l_rate * y
                    wrong_count += 1
            if wrong_count == 0:
                is_wrong = True
        return 'Perceptron Model!'

    def score(self):
        pass

perceptron = Model()
perceptron.fit(X, y)

#画出训练结果
x_points = np.linspace(4, 7, 10)
y_ = -(perceptron.w[0] * x_points + perceptron.b) / perceptron.w[1]
plt.plot(x_points, y_)
plt.plot(data[:50, 0], data[:50, 1], 'bo', color='blue', label='0')
plt.plot(data[50:100, 0], data[50:100, 1], 'bo', color='orange', label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('result')
plt.legend()
plt.show()

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SSYuQ3Zn-1636977903383)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/d3b23003-63be-495a-bbb9-ba3b3a16a9ec/Untitled.png)]

习题解答：https://github.com/datawhalechina/statistical-learning-method-solutions-manual