深度学习之感知机

感知机是由美国学者 Frank Rosenblatt 于 1957 年发明的, 它是神经网络和深度学习的起源算法。

什么是感知机？

我们考虑输入信号 $x = (x_1, \cdots, x_n)^T$ , 输出信号 $y$ , 权重 $w = (w_1, \cdots, w_n)^T$ , 其中 $x, w \in \mathbb{R}^{n\times 1}, y \in \{0, 1\}$ , 则感知机的定义为

$y = \begin{cases} 0 & (w^Tx \leq \theta)\\ 1 & (w^Tx > \theta) \end{cases}$

其中 $\theta$ 被称为阈值，用来控制“神经元是否被激活”（ $1$ 表示激活）。感知机接收多个信号，输出一个信号。这里的“信号”可以当作电流等具有“流动性”的东西。 $x_i$ 与 $y$ 被称为节点, 箭头的指向表示信号流动的方向。权重 $w_i$ 可以看作“电流”对应的“”电阻。下面画出了二节点输入的感知机结构图：

二元输入的感知机

下面我们看看逻辑运算的定义：

输入 $x_1$	输入 $x_2$	OR	AND	NAND
0	0	0	0	1
0	1	1	0	1
1	0	1	0	1
1	1	1	1	0

下面我们将使用 Python 来实现感知机型的逻辑运算。为了和后面的深度学习模型一致，我们可以将上面的感知机模型改写为

$y = \begin{cases} 0 & (w^Tx + b \leq 0)\\ 1 & (w^Tx + b> 0) \end{cases}$

下面我们使用 Numpy 来手动设计逻辑运算：

import numpy as np

class Gate:
    '''
    逻辑运算的输入 x1, x2 只能是 0 或 1
    '''
    @staticmethod
    def AND(x1, x2):
        '''
        与门
        '''
        x = np.array([x1, x2])
        w = np.array([.5, .5])
        b = -.7
        tmp = np.dot(x.T, w) + b
        if tmp <= 0:
            return 0
        else:
            return 1

    @staticmethod
    def NAND(x1, x2):
        '''
        与非门
        '''
        x = np.array([x1, x2])
        w = np.array([-.5, -.5])
        b = .7
        tmp = np.dot(x.T, w) + b
        if tmp <= 0:
            return 0
        else:
            return 1

    @staticmethod
    def OR(x1, x2):
        '''
        或门
        '''
        x = np.array([x1, x2])
        w = np.array([.5, .5])
        b = -.2
        tmp = np.dot(x.T, w) + b
        if tmp <= 0:
            return 0
        else:
            return 1

gate = Gate()

将逻辑运算的不同状态看作四个不同的样本：

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
X

array([[0, 0],
       [0, 1],
       [1, 0],
       [1, 1]])

for x1, x2 in X:
    y = gate.AND(x1, x2)
    print(x1, 'and', x2, '-->', y)
    y1 = gate.OR(x1, x2)
    print(x1, 'or', x2, '-->', y1)
    y2 = gate.NAND(x1, x2)
    print(x1, 'not and', x2, '-->', y2)
    print('^'*18)

0 and 0 --> 0
0 or 0 --> 0
0 not and 0 --> 1
^^^^^^^^^^^^^^^^^^
0 and 1 --> 0
0 or 1 --> 1
0 not and 1 --> 1
^^^^^^^^^^^^^^^^^^
1 and 0 --> 0
1 or 0 --> 1
1 not and 0 --> 1
^^^^^^^^^^^^^^^^^^
1 and 1 --> 1
1 or 1 --> 1
1 not and 1 --> 0
^^^^^^^^^^^^^^^^^^

从上面的结果我们可以看出：感知机可以实现与门、与非门、或门运算。

感知机的局限性

单层感知机无法实现异或运算，下面我们利用 Matplotlib 来说明单层感知机的局限性：

import numpy as np
import matplotlib.pyplot as plt

x, y = X.T
fig = plt.figure()
ax1 = fig.add_axes([0.6, 0, .5, .5])
ax1.scatter(x, y, s=75, c=[1, 1, 0, 1], alpha=0.5)
ax1.plot(x, x-.2)
plt.title('NAND')
plt.xticks([])
plt.yticks([])

ax2 = fig.add_axes([0, 0, .5, .5])
ax2.scatter(x, y, s=75, c=[0, 0, 1, 0], alpha=0.5)
ax2.plot(x, x-.5)
plt.title('AND')
plt.xticks([])
plt.yticks([])

ax3 = fig.add_axes([0, 0.6, .5, .5])
ax3.scatter(x, y, s=75, c=[0, 1, 1, 1], alpha=0.5)
ax3.plot(x, - x + .7)
plt.title('OR')
plt.xticks([])
plt.yticks([])

ax4 = fig.add_axes([.6, 0.6, .5, .5])
ax4.scatter(x, y, s=75, c=[1, 0, 0, 1], alpha=0.5)
ax4.plot(x, x-.5)
plt.title('XOR')
plt.xticks([])
plt.yticks([])
plt.show()

逻辑运算.png

图中黄色的点代表“正例”，紫色的点代表“负例”。从上图可以看出 XOR 无法使用一条直线将“正例”与“负例”分隔开。在机器学习中，一般称可以使用一条“直线”将“正例”与“负例”分隔开的数据集为线性可分的，否则称为线性不可分的。

从上面的分析，我们发现单层感知机的局限性：无法解决异或问题（线性不可分的问题）。

多层感知机

虽然单层感知机无法解决异或问题，但是多层感知机便可以解决异或问题。

def XOR(x1, x2):
    s1 = gate.NAND(x1, x2)
    s2 = gate.OR(x1, x2)
    y = gate.AND(s1, s2)
    return y

for x1, x2 in X:
    y = XOR(x1, x2)
    print(x1, 'xor', x2, '-->', y)

0 xor 0 --> 0
0 xor 1 --> 1
1 xor 0 --> 1
1 xor 1 --> 0

上面的 XOR 求解过程可以使用如下的图像来表示。

捕获.PNG

小结

我们已经完成了感知机的学习，感知机是十分简单的算法，已经有理论证明，2 层（使用了非线性激活函数的）感知机可以表示任意函数。但是，使用 2 层感知机的构造，需要我们手工设定权重，这是令人十分绝望的，而神经网络的自动设定参数机制为此带来了福音。