Perceptron：一个简单的二分类器

分类感知机学习算法的实现。

from mlxtend.classifier import Perceptron

概览

这个“阈值”感知机背后的想法是模仿大脑中单个神经元的工作方式：它要么“激发”，要么不激发。感知机接收多个输入信号，如果输入信号的总和超过某个阈值，它要么返回一个信号，要么保持“沉默”。使这成为一个“机器学习”算法的是 Frank Rosenblatt 的感知机学习规则思想：感知机算法是关于学习输入信号的权重，以便绘制一个线性决策边界，从而使我们能够区分两个线性可分的类别 +1 和 -1。

基本符号

在深入探讨学习感知机分类器权重算法之前，我们先简要了解一下基本符号。在以下部分中，我们将二分类设置中的正类别和负类别分别标记为“1”和“-1”。接下来，我们定义一个激活函数$g(\mathbf{z})$它接收输入值$\mathbf{x}$和权重$\mathbf{w}$的线性组合作为输入 ($\mathbf{z} = w_1x_{1} + \dots + w_mx_{m}$)，并且如果$g(\mathbf{z})$大于一个定义的阈值$\theta$我们预测为 1，否则为 -1；在这种情况下，这个激活函数$g$是一个简单的“单位阶跃函数”，有时也称为“Heaviside 阶跃函数”。

$$ g(z) = $$\begin{cases} 1 & \text{if $z \ge \theta$}\\ -1 & \text{otherwise}. \end{cases}$$ $$

其中

$$z = w_1x_{1} + \dots + w_mx_{m} = \sum_{j=1}^{m} x_{j}w_{j} \\ = \mathbf{w}^T\mathbf{x}$$

$\mathbf{w}$是特征向量，并且$\mathbf{x}$是一个$m$-维的训练数据集中的样本

$$\mathbf{w} = \begin{bmatrix} w_{1} \\ \vdots \\ w_{m} \end{bmatrix} \quad \mathbf{x} = \begin{bmatrix} x_{1} \\ \vdots \\ x_{m} \end{bmatrix}$$

为了简化符号，我们将$\theta$移到等式左边，并定义$w_0 = -\theta \text{ and } x_0=1$

从而有

$$ g({z}) = $$\begin{cases} 1 & \text{if $z \ge 0$}\\ -1 & \text{otherwise}. \end{cases}$$ $$

和

$$z = w_0x_{0} + w_1x_{1} + \dots + w_mx_{m} = \sum_{j=0}^{m} x_{j}w_{j} \\ = \mathbf{w}^T\mathbf{x}.$$

感知机规则

Rosenblatt 的原始感知机规则相当简单，可以概括为以下步骤：

1. 将权重初始化为 0 或小的随机数。
2. 对于每个训练样本$\mathbf{x^{(i)}}$:
   1. 计算输出值。
   2. 更新权重。

输出值是我们之前定义的单位阶跃函数预测的类别标签（输出$=g(\mathbf{z})$），并且权重的更新可以更正式地写成$w_j := w_j + \Delta w_j$.

每次增量更新权重的数值通过学习规则计算

$\Delta w_j = \eta \; (\text{target}^{(i)} - \text{output}^{(i)})\;x^{(i)}_{j}$

其中$\eta$是学习率（一个介于 0.0 和 1.0 之间的常数），“target”是真实类别标签，“output”是预测类别标签。

重要的是要注意，权重向量中的所有权重都会同时更新。具体来说，对于一个二维数据集，我们将更新写为

$\Delta w_0 = \eta(\text{target}^{(i)} - \text{output}^{(i)})$
$\Delta w_1 = \eta(\text{target}^{(i)} - \text{output}^{(i)})\;x^{(i)}_{1}$
$\Delta w_2 = \eta(\text{target}^{(i)} - \text{output}^{(i)})\;x^{(i)}_{2}$

在我们用 Python 实现感知机规则之前，让我们做一个简单的思想实验，以说明这个学习规则的美妙之处。在感知机正确预测类别标签的两种情况下，权重保持不变

• $\Delta w_j = \eta(-1^{(i)} - -1^{(i)})\;x^{(i)}_{j} = 0$
• $\Delta w_j = \eta(1^{(i)} - 1^{(i)})\;x^{(i)}_{j} = 0$

然而，如果预测错误，权重会分别被“推向”正或负目标类别的方向

• $\Delta w_j = \eta(1^{(i)} - -1^{(i)})\;x^{(i)}_{j} = \eta(2)\;x^{(i)}_{j}$
• $\Delta w_j = \eta(-1^{(i)} - 1^{(i)})\;x^{(i)}_{j} = \eta(-2)\;x^{(i)}_{j}$

重要的是要注意，感知机的收敛只有在两个类别线性可分时才能保证。如果两个类别不能通过线性决策边界分开，我们可以设置训练数据集上的最大遍历次数（“epochs”）和/或可容忍的错误分类次数的阈值。

参考文献

• F. Rosenblatt. 感知机，一种感知和识别自动机，项目 Para. 康奈尔航空实验室，1957。

示例 1 - 鸢尾花分类

from mlxtend.data import iris_data
from mlxtend.plotting import plot_decision_regions
from mlxtend.classifier import Perceptron
import matplotlib.pyplot as plt

# Loading Data

X, y = iris_data()
X = X[:, [0, 3]] # sepal length and petal width
X = X[0:100] # class 0 and class 1
y = y[0:100] # class 0 and class 1

# standardize
X[:,0] = (X[:,0] - X[:,0].mean()) / X[:,0].std()
X[:,1] = (X[:,1] - X[:,1].mean()) / X[:,1].std()


# Rosenblatt Perceptron

ppn = Perceptron(epochs=5, 
                 eta=0.05, 
                 random_seed=0,
                 print_progress=3)
ppn.fit(X, y)

plot_decision_regions(X, y, clf=ppn)
plt.title('Perceptron - Rosenblatt Perceptron Rule')
plt.show()

print('Bias & Weights: %s' % ppn.w_)

plt.plot(range(len(ppn.cost_)), ppn.cost_)
plt.xlabel('Iterations')
plt.ylabel('Missclassifications')
plt.show()

Iteration: 5/5 | Elapsed: 00:00:00 | ETA: 00:00:00

Bias & Weights: [[-0.04500809]
 [ 0.11048855]]

API

Perceptron(eta=0.1, epochs=50, random_seed=None, print_progress=0)

感知机分类器。

注意，这个感知机实现期望的二元类别标签是 {0, 1}。

参数

• eta : float (默认值: 0.1)

  学习率 (介于 0.0 和 1.0 之间)

• epochs : int (默认值: 50)

  训练数据集的遍历次数。在每个 epoch 之前，数据集会被打乱以防止周期。

• random_seed : int

  用于初始化随机权重和打乱的随机状态。

• print_progress : int (默认值: 0)

  将拟合过程打印到标准错误输出。 0: 无输出 1: 已完成的 epoch 和成本 2: 1 加已耗时间 3: 2 加估计完成时间

属性

• w_ : 二维数组, 形状={n_features, 1}

  拟合后的模型权重。

• b_ : 一维数组, 形状={1,}

  拟合后的偏置单元。

• cost_ : 列表

  每个 epoch 中的错误分类数。

示例

有关使用示例，请参阅 https://mlxtend.cn/mlxtend/user_guide/classifier/Perceptron/

方法

---

fit(X, y, init_params=True)

从训练数据中学习模型。

参数

• X : {类数组对象, 稀疏矩阵}, 形状 = [n_samples, n_features]

  训练向量，其中 n_samples 是样本数，n_features 是特征数。

• y : 类数组对象, 形状 = [n_samples]

  目标值。

• init_params : bool (默认值: True)

  在拟合前重新初始化模型参数。设置为 False 可继续使用之前模型拟合的权重进行训练。

返回值

• self : 对象

---

predict(X)

从 X 中预测目标。

参数

• X : {类数组对象, 稀疏矩阵}, 形状 = [n_samples, n_features]

  训练向量，其中 n_samples 是样本数，n_features 是特征数。

返回值

• target_values : 类数组对象, 形状 = [n_samples]

  预测的目标值。

---

score(X, y)

计算预测准确率

参数

• X : {类数组对象, 稀疏矩阵}, 形状 = [n_samples, n_features]

  训练向量，其中 n_samples 是样本数，n_features 是特征数。

• y : 类数组对象, 形状 = [n_samples]

  目标值（真实类别标签）。

返回值

• acc : float

  预测准确率，一个介于 0.0 和 1.0 之间的浮点数（完美分数为 1.0）。

Python