Python代码实现单层感知器神经网络，进行AND,OR,XOR数据分类

上期文章，我们介绍了人工智能，机器学习，深度学习的关系以及深度学习的发展，那里我们介绍了如下图中的XOR数据，使用一条直线无法分开XOR类似的数据，也因为此问题的提出，影响了神经网络近10年的发展。

由Rosenblatt 于 1958 年首次推出的感知器：大脑中信息存储和组织的概率模型可以说是最古老、最简单的 ANN 算法。在此出版之后，基于感知器的技术在神经网络社区中风靡一时。

一条直线把XOR数据给分开

但随后，在 1969 年，机器学习社区迎来了“AI 寒冬”，几乎永远冻结了神经网络。Minsky 和 Papert 出版了Perceptrons: an Introduction to compute geometry，这本书有效地使神经网络的研究停滞了近十年——关于这本书有很多争议，但作者确实成功地证明了单层感知器无法实现分离非线性数据点。就如上图所示，我们不能使用一条直线把XOR数据给分开。

鉴于大多数现实世界的数据集是自然非线性可分的，这似乎感知器以及其他神经网络研究可能会停滞不前。

在 Minsky 和 Papert 的出版物和神经网络彻底改变行业之前，人们对神经网络的兴趣大幅下降。直到我们开始探索更深层次的网络（有时称为多层感知器）以及反向传播算法，1970 年代的“AI 寒冬”才结束，神经网络研究又开始升温.

尽管如此，感知器仍然是一个非常重要的算法，因为它为更高级的多层网络奠定了基础。我们将首先回顾感知器架构并解释用于训练感知器的训练过程。我们还将查看网络的终止标准（即，感知器何时应该停止训练）。最后，我们将在纯 Python 中实现感知器算法，并使用它来研究和检查网络如何无法学习非线性可分数据集。

AND、OR 和 XOR 数据集

在我们研究感知器本身之前，让我们先讨论一下“按位运算”，包括 AND、OR 和 XOR（异或）。这在计算机编程里面，我们都或多或少地使用过类似的位算方法，我们在计算机视觉中也使用到了此方法来对图片进行位操作，详细可以参考如下

按位运算符和相关的按位数据集接受两个输入位，并在应用运算后产生一个最终输出位。给定两个输入位，每个位可能取值为0 或者 1，这两个位有四种可能的组合——表 1提供了 AND、OR 和 XOR 的可能输入和输出值：

AND，OR，和XOR

左：按位 AND 数据集。给定两个输入，如果两个输入都为 1，则输出仅为 1。中间：按位 OR 数据集。给定两个输入，输出为1，如果任一的两个输入端为1。右侧：异或（E（X）clusive OR）数据集。给定两个输入，输出为 1 而且仅当其中一个输入为 1，但不是两者都为 1 。

正如我们在左边看到的，当且仅当两个输入值都是1. 如果任一输入值是0, AND 返回 0. 因此，当 AND 的输出为真时，只有一种组合，x 0 = 1 和x 1 = 1。

在中间，我们有 OR 运算，当至少一个输入值是1. 因此，两个位x 0和x 1 的三种可能组合会产生y = 1的值。

最后，右侧显示 XOR 运算，当且仅当输入为 1 为真1 但不是两者兼而有之。虽然 OR 有y = 1 的三种可能情况，但 XOR 只有两种情况。

我们经常使用这些简单的“按位数据集”来测试和调试机器学习算法。如果我们绘制和可视化的AND，OR，和XOR值便如下图

AND，OR，和XOR

AND 和 OR 按位数据集都是线性可分的，这意味着我们可以画一条线（绿色）将这两个类分开。然而，对于异或，不可能画一条线来分隔这两个类——因此这是一个非线性可分的数据集。

AND 和 OR 都是线性可分的——我们可以清楚地画一条线来分隔 0 和 1类——XOR 并非如此。但是不可能在 XOR 问题中画一条线将两个类完全分开。因此，XOR 是非线性可分数据集的一个例子。

理想情况下，我们希望我们的机器学习算法能够分离非线性类，因为现实世界中遇到的大多数数据集都是非线性的。因此，在构建、调试和评估给定的机器学习算法时，我们可能会使用按位值x 0和x 1作为我们的设计矩阵，然后尝试预测相应的y值。

与我们将数据拆分为训练和测试拆分的标准程序不同，当使用按位数据集时，我们只需在同一组数据上训练和评估我们的网络。我们的目标只是确定我们的学习算法是否有可能学习数据中的模式。正如我们介绍的，感知器算法可以正确地对 AND 和 OR 函数进行分类，但无法对 XOR 数据进行分类。

感知器架构

Rosenblatt (1958)将感知器定义为使用特征向量（或原始像素强度）的标记示例（即监督学习）进行学习的系统，将这些输入映射到它们相应的输出类标签。

在最简单的形式中，感知器包含N 个输入节点，设计矩阵的输入行中的每个条目一个，然后是网络中有一层，该层中只有一个节点。

从输入x i到网络中的单个输出节点，存在连接及其相应的权重w 1 , w 2 , ..., w i。该节点采用输入的加权总和并应用阶跃函数来确定输出类别标签。感知器输出一个0 或 1 — 0 对于第 1 类和 1对于第 2 类；因此，在其原始形式中，感知器只是一个二元的、二分类的分类器。

感知器网络的架构

1.用小的随机值初始化我们的权重向量w

2. 直到感知器收敛：

(a) 循环遍历我们训练集D 中的每个特征向量x j和真实类别标签d i
(b) 取x并将其通过网络，计算输出值：y j = f ( w ( t ) · x j )
(c) 更新权重w : w i ( t +1) = w i ( t ) + α( d j −y j ) x j,i对于所有特征 0 < = i < = n 感知器训练程序和 Delta 规则

训练感知器是一个相当简单的操作。我们的目标是获得一组权重w ，可以准确地对训练集中的每个实例进行分类。为了训练我们的感知器，我们多次使用我们的训练数据迭代的馈送网络。每次网络看到完整的训练数据集时，我们就说一个训练已经过去。通常需要很多 epoch，直到可以学习到一个权重向量w 来线性地分离我们的两类数据。

感知器训练终止

允许感知器训练过程继续进行，直到所有训练样本都被正确分类或达到预设的时期数。如果α足够小并且训练数据是线性可分的，则确保终止。

那么，如果我们的数据不是线性可分的，或者我们的α设置不合理，会发生什么？训练会无限持续吗？在这种情况下，我们通常在达到一定数量的 epoch 后或者如果错误分类的数量在大量 epoch 中没有改变（表明数据不是线性可分的）就停止。

Python代码中实现单层感知器

首先我们建立一个perceptron.py脚本，在脚本中插入如下代码

import numpy as np
class Perceptron:
def __init__(self, N, alpha=0.1):
self.W = np.random.randn(N + 1) / np.sqrt(N)
self.alpha = alpha
def step(self, x):
return 1 if x > 0 else 0
def fit(self, X, y, epochs=10):
X = np.c_[X, np.ones((X.shape[0]))]
for epoch in np.arange(0, epochs):
for (x, target) in zip(X, y):
p = self.step(np.dot(x, self.W))
if p != target:
error = p - target
self.W += -self.alpha * error * x

代码截图

首先我们建立一个Perceptron类，在此Perceptron类中初始化函数，此函数主要接受2个参数

N：输入特征向量中的列数。在我们的按位数据集的上下文中，我们将设置N 等于二，因为有两个输入。 α：我们对感知器算法的学习率。我们将这个值设置为0. 1默认。

我们的权重矩阵W从具有零均值和单位方差的“正态”（高斯）分布中采样的随机值。权重矩阵将有N +1 个条目，每个条目N特征向量中的输入，加上一个偏差。然后除以输入数量的平方根，这是一种用于缩放权重矩阵的常用技术，从而加快收敛速度。

然后定义一个step函数，此函数定义若输入的为0，则输出0 ，输入为1，则为1

为了训练神经网络，我们定义一个fit函数，此函数用来训练神经网络

def fit(self, X, y, epochs=10):
X = np.c_[X, np.ones((X.shape[0]))]
for epoch in np.arange(0, epochs):
for (x, target) in zip(X, y):
p = self.step(np.dot(x, self.W))
if p != target:
error = p - target
self.W += -self.alpha * error * x

代码截图

X值是我们实际的训练数据。y是我们的目标输出类标签（即我们的网络应该预测什么）。最后是训练步数，我们的感知器将训练到此步数后进行停止。

第 11 行通过在训练数据中插入一列 1 来应用偏差技巧，这允许我们将偏差视为直接在权重矩阵内的可训练参数。

在第 12 行，我们开始循环训练周期，我们还遍历每个单独的数据点X 和输出目标类标签（第 13 行）。

第 14行取输入特征之间的点积X 和权重矩阵W，然后将输出通过 step 函数来获得感知器的预测。

应用上面介绍的训练程序过程，我们仅在我们的预测与目标不匹配时才执行权重更新（第 15行）。

更新权重矩阵在第 17 行处理，我们的目的是缩小偏差α. 在一系列训练过程中，我们的感知器能够学习基础数据中的模式并改变权重矩阵的值，以便我们正确地对输入样本进行分类.

然后我们定义最后一个函数是precidt，顾名思义，它用于预测给定输入数据集的类标签

def predict(self, X, addBias=True):
X = np.atleast_2d(X)
if addBias:
X = np.c_[X, np.ones((X.shape[0]))]
return self.step(np.dot(X, self.W))

代码截图

我们的 预测 方法需要一组输入数据 X。

获取输出预测 X 与训练过程相同—只需取输入特征之间的点积 (X 和我们的权重矩阵w)，然后通过我们的 step 函数传递值。

现在我们已经实现了我们的 感知器 类，让我们尝试将它应用到我们的按位数据集，看看神经网络是如何执行的。

我们定义一个predict.py脚本，在脚本中输入如下代码：

from perceptron import Perceptron
import numpy as np
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [1]])
print("[INFO] training perceptron...")
p = Perceptron(X.shape[1], alpha=0.1)
p.fit(X, y, epochs=20)
print("[INFO] testing perceptron...")
for (x, target) in zip(X, y):
pred = p.predict(x)
print("[INFO] data={}, ground-truth={}, pred={}".format(x, target[0], pred))

代码截图

首先我们插入我们建立的Perceptron感知器类函数，并定义一个OR函数数据，我们把OR数据添加到神经网络中进行训练，然后使用predict函数对训练集进行预测

[INFO] training perceptron...
[INFO] testing perceptron...
[INFO] data=[0 0], ground-truth=0, pred=0
[INFO] data=[0 1], ground-truth=1, pred=1
[INFO] data=[1 0], ground-truth=1, pred=1
[INFO] data=[1 1], ground-truth=1, pred=1

从结果来看，神经网络成功预测出了我们的数据

我们看看AND 数据集，我们修改一下上面的代码

from perceptron import Perceptron
import numpy as np
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [0], [0], [1]])
print("[INFO] training perceptron...")
p = Perceptron(X.shape[1], alpha=0.1)
p.fit(X, y, epochs=20)
print("[INFO] testing perceptron...")
for (x, target) in zip(X, y):
pred = p.predict(x)
print("[INFO] data={}, ground-truth={}, pred={}".format(x, target[0], pred))

代码截图

[INFO] training perceptron...
[INFO] testing perceptron...
[INFO] data=[0 0], ground-truth=0, pred=0
[INFO] data=[0 1], ground-truth=0, pred=0
[INFO] data=[1 0], ground-truth=0, pred=0
[INFO] data=[1 1], ground-truth=1, pred=1

从训练结果来看，神经网络也成功预测出了数据，接下来我们看看XOR数据是否也能成功预测

from perceptron import Perceptron
import numpy as np
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])
print("[INFO] training perceptron...")
p = Perceptron(X.shape[1], alpha=0.1)
p.fit(X, y, epochs=20)
print("[INFO] testing perceptron...")
for (x, target) in zip(X, y):
pred = p.predict(x)
print("[INFO] data={}, ground-truth={}, pred={}".format(x, target[0], pred))

代码截图

[INFO] training perceptron...
[INFO] testing perceptron...
[INFO] data=[0 0], ground-truth=0, pred=1
[INFO] data=[0 1], ground-truth=1, pred=1
[INFO] data=[1 0], ground-truth=1, pred=0
[INFO] data=[1 1], ground-truth=0, pred=0

从训练结果来看，神经网络并没有完全识别出来需要的数据，无论我们设计什么样的学习效率或者训练多少次，我们的单层感知器不能完全预测出我们想要的数据，因此我们便需要非线性的多次感知器，这个便是深度学习研究的对象了，以上知识只是简单的介绍单层感知层的概念，后期我们将分享更多的关于神经网络与深度学习的相关知识。