9行Python代码搭建神经网络

9行Python代码搭建神经网络

Kaiser谈笑风生

4月前发表至趣味项目，5995次访问

---

原文：How to build a simple neural network in 9 lines of Python code

作者：Milo Spencer-Harper

翻译：Kaiser（王司图）

---

前言

在上一篇文章中，Milo给自己定下了两个小目标：

1. 学习层次隐式马尔可夫模型

2. 用Python搭建神经网络

本文讲的就是他如何实现第二个目标。当然，这里的“用Python”指的就是不用那些现成的神经网络库比如Keras、Tensorflow等，否则连9行都不用了。

---

正文

Python 2 重置 复制

9行代码的神经网络

1

from numpy import exp, array, random, dot

2

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

3

training_set_outputs = array([[0, 1, 1, 0]]).T

4

random.seed(1)

5

synaptic_weights = 2 * random.random((3, 1)) - 1

6

for iteration in xrange(10000):

7

    output = 1 / (1 + exp(-(dot(training_set_inputs, synaptic_weights))))

8

    synaptic_weights += dot(training_set_inputs.T, (training_set_outputs - output) * output * (1 - output))

9

print 1 / (1 + exp(-(dot(array([1, 0, 0]), synaptic_weights))))

运行

本文我会解释这个神经网络是怎样炼成的，所以你也可以搭建你自己的神经网络。也会提供一个加长版、但是也更漂亮的源代码。

不过首先，什么是神经网络？人脑总共有超过千亿个神经元细胞，通过神经突触相互连接。如果一个神经元被足够强的输入所激活，那么它也会激活其他神经元，这个过程就叫“思考”。

我们可以在计算机上创建神经网络，来对这个过程进行建模，且并不需要模拟分子级的生物复杂性，只要观其大略即可。为了简化起见，我们只模拟一个神经元，含有三个输入和一个输出。

我们将训练这个神经元来解决下面这个问题，前四个样本叫作“训练集”，你能求解出模式吗？?处应该是0还是1呢？

或许已经发现了，输出总是与第一列的输入相等，所以?应该是1。

训练过程

问题虽然很简单，但是如何教会神经元来正确的回答这个问题呢？我们要给每个输入赋予一个权重，权重可能为正也可能为负。权重的绝对值，代表了输入对输出的决定权。在开始之前，我们先把权重设为随机数，再开始训练过程：

1. 从训练集样本读取输入，根据权重进行调整，再代入某个特殊的方程计算神经元的输出。

2. 计算误差，也就是神经元的实际输出和训练样本的期望输出之差。

3. 根据误差的方向，微调权重。

4. 重复10000次。

最终神经元的权重会达到训练集的最优值。如果我们让神经元去思考一个新的形势，遵循相同过程，应该会得到一个不错的预测。

计算神经元输出的方程

你可能会好奇，计算神经元输出的人“特殊方程”是什么？首先我们取神经元输入的加权总和：

∑weighti⋅inputi=weight1⋅input1+weight2⋅input2+weight3⋅input3 ∑ w e i g h t i ⋅ i n p u t i = w e i g h t 1 ⋅ i n p u t 1 + w e i g h t 2 ⋅ i n p u t 2 + w e i g h t 3 ⋅ i n p u t 3

接下来我们进行正规化，将结果限制在0和1之间。这里用到一个很方便的函数，叫Sigmoid函数：

11+e−x 1 1 + e − x

如果绘出图像，Sigmoid函数是S形的曲线：

将第一个公式代入第二个，即得最终的神经元输出方程：

Outputofneuron=11+e−(∑weighti⋅inputi) O u t p u t o f n e u r o n = 1 1 + e − ( ∑ w e i g h t i ⋅ i n p u t i )

调整权重的方程

在训练进程中，我们需要调整权重，但是具体如何调整呢？就要用到“误差加权导数”方程：

Adjustweightsby=error⋅input⋅SigmoidCurveGradient(output) A d j u s t w e i g h t s b y = e r r o r ⋅ i n p u t ⋅ S i g m o i d C u r v e G r a d i e n t ( o u t p u t )

为什么是这个方程？首先我们希望调整量与误差量成正比，然后再乘以输入(0-1)。如果输入为0，那么权重就不会被调整。最后乘以Sigmoid曲线的梯度，为便于理解，请考虑：

1. 我们使用Sigmoid曲线计算神经元输出。

2. 如果输出绝对值很大，这就表示该神经元是很确定的（有正反两种可能）。

3. Sigmoid曲线在绝对值较大处的梯度较小。

4. 如果神经元确信当前权重值是正确的，那么就不需要太大调整。乘以Sigmoid曲线的梯度可以实现。

Sigmoid曲线的梯度可由导数获得：

SigmoidCurveGradient(output)=output⋅(1−output) S i g m o i d C u r v e G r a d i e n t ( o u t p u t ) = o u t p u t ⋅ ( 1 − o u t p u t )

代入公式可得最终的权重调整方程：

Adjustweightsby=error⋅input⋅output⋅(1−output) A d j u s t w e i g h t s b y = e r r o r ⋅ i n p u t ⋅ o u t p u t ⋅ ( 1 − o u t p u t )

实际上也有其他让神经元学习更快的方程，这里主要是取其相对简单的优势。

构建Python代码

尽管我们不直接用神经网络库，但还是要从Python数学库Numpy中导入4种方法：

• exp： 自然对常数

• array： 创建矩阵

• dot：矩阵乘法

• random： 随机数

比如我们用array()方法代表训练集：

1

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

2

training_set_outputs = array([[0, 1, 1, 0]]).T

.T函数就是矩阵转置。我想现在可以来看看美化版的源代码了，最后我还会提出自己的终极思考。源代码中已经添加了注释逐行解释。注意每次迭代我们都一并处理了整个训练集，以下为完整的Python示例：

Python 2 重置 复制

完整版神经网络

1

from numpy import exp, array, random, dot

2

​

3

class NeuralNetwork():

4

    def __init__(self):

5

        # 随机数发生器种子，以保证每次获得相同结果

6

        random.seed(1)

7

​

8

        # 对单个神经元建模，含有3个输入连接和一个输出连接

9

        # 对一个3 x 1的矩阵赋予随机权重值。范围-1～1，平均值为0

10

        self.synaptic_weights = 2 * random.random((3, 1)) - 1

11

​

12

    # Sigmoid函数，S形曲线

13

    # 用这个函数对输入的加权总和做正规化，使其范围在0～1

14

    def __sigmoid(self, x):

15

        return 1 / (1 + exp(-x))

16

​

17

    # Sigmoid函数的导数

18

    # Sigmoid曲线的梯度

19

    # 表示我们对当前权重的置信程度

20

    def __sigmoid_derivative(self, x):

21

        return x * (1 - x)

22

​

23

    # 通过试错过程训练神经网络

24

    # 每次都调整突触权重

25

    def train(self, training_set_inputs, training_set_outputs, number_of_training_iterations):

26

        for iteration in xrange(number_of_training_iterations):

27

            # 将训练集导入神经网络

28

            output = self.think(training_set_inputs)

29

​

30

            # 计算误差（实际值与期望值之差）

31

            error = training_set_outputs - output

32

​

33

            # 将误差、输入和S曲线梯度相乘

34

            # 对于置信程度低的权重，调整程度也大

35

            # 为0的输入值不会影响权重

36

            adjustment = dot(training_set_inputs.T, error * self.__sigmoid_derivative(output))

37

​

38

            # 调整权重

39

            self.synaptic_weights += adjustment

40

​

41

    # 神经网络一思考

42

    def think(self, inputs):

43

        # 把输入传递给神经网络

44

        return self.__sigmoid(dot(inputs, self.synaptic_weights))

45

​

46

​

47

if __name__ == "__main__":

48

​

49

    # 初始化神经网络

50

    neural_network = NeuralNetwork()

51

​

52

    print "随机的初始突触权重："

53

    print neural_network.synaptic_weights

54

​

55

    # 训练集。四个样本，每个有3个输入和1个输出

56

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

57

    training_set_outputs = array([[0, 1, 1, 0]]).T

58

​

59

    # 用训练集训练神经网络

60

    # 重复一万次，每次做微小的调整

61

    neural_network.train(training_set_inputs, training_set_outputs, 10000)

62

​

63

    print "训练后的突触权重："

64

    print neural_network.synaptic_weights

65

​

66

    # 用新数据测试神经网络

67

    print "考虑新的形势 [1, 0, 0] -> ?: "

68

    print neural_network.think(array([1, 0, 0]))

运行

终极思考

（Kaiser：原文讲的是将代码写入本地main.py文件，再在终端中运行python main.py，这里只需点击运行即可。）

我们用Python打造了一个简单的神经网络。

首先神经网络给自己赋予随机的权重值，然后用训练集训练自己，最后去思考新的形势[1 0 0]并预测了0.99993704，这与正确答案非常接近。

传统的计算机程序无法学习，神经网络的最大魅力就在于学习能力，可以自主适应新形势，就像人的心智一样。当然，仅仅一个神经元只能完成特别简单的任务，但如果我们把上百万个如此的神经元连接起来呢？能否有朝一日制造出具有自我意识的东西？