想理解神经算术逻辑单元吗？

文 / Akil Hylton

DeepMind 最近发布了一篇新的论文---《神经算术逻辑单元（NALU）》（https://arxiv.org/abs/1808.00508），这是一篇很有趣的论文，它解决了深度学习中的一个重要问题，即教导神经网络计算。 令人惊讶的是，尽管神经网络已经能够在许多任务，如肺癌分类中获得卓绝表现，却往往在一些简单任务，像计算数字上苦苦挣扎。

在一个展示网络如何努力从新数据中插入特征的实验中，我们的研究发现，他们能够用 -5 到 5 之间的数字将训练数据分类，准确度近乎完美，但对于训练数据之外的数字，网络几乎无法归纳概括。

论文提供了一个解决方案，分成两个部分。以下我将简单介绍一下 NAC 的工作原理，以及它如何处理加法和减法等操作。之后，我会介绍 NALU，它可以处理更复杂的操作，如乘法和除法。 我提供了可以尝试演示这些代码的代码，您可以阅读上述的论文了解更多详情。

第一神经网络（NAC）

神经累加器（简称 NAC）是其输入的一种线性变换。什么意思呢？ 它是一个转换矩阵，是 tanh（W_hat）和 sigmoid（M_hat）的元素乘积。 最后，转换矩阵 W 乘以输入（x）。

Python 中的 NAC

1    import tensorflow as tf 

2

3    # NAC

4    W_hat = tf.Variable(tf.truncated_normal(shape, stddev=0.02))  

5    M_hat = tf.Variable(tf.truncated_normal(shape, stddev=0.02))

6

7    W = tf.tanh(W_hat) * tf.sigmoid(M_hat)

8    # Forward propogation

9    a = tf.matmul(in_dim, W) 

NAC

第二神经网络 (NALU)

神经算术逻辑单元，或者我们简称之为 NALU，是由两个 NAC 单元组成。 第一个 NAC g 等于 sigmoid（Gx）。 第二个 NAC 在一个等于 exp 的日志空间 m 中运行 (W(log(|x| + epsilon)))

Python 中的 NALU

1    import tensorflow as tf

2

3    # NALU

4    G = tf.Variable(tf.truncated_normal(shape, stddev=0.02))

5

6    m = tf.exp(tf.matmul(tf.log(tf.abs(in_dim) + epsilon), W))

7

8    g = tf.sigmoid(tf.matmul(in_dim, G))

9

10    y = g * a + (1 - g) * m

NALU

通过学习添加来测试 NAC 

现在让我们进行测试，首先将 NAC 转换为函数。

1    # Neural Accumulator

2    def NAC(in_dim, out_dim):

3

4        in_features = in_dim.shape[1]

5

6        # define W_hat and M_hat

7        W_hat = tf.get_variable(name = 'W_hat', initializer=tf.initializers.random_uniform(minval=-2, maxval=2),shape=[in_features, out_dim],  trainable=True)

8        M_hat = tf.get_variable(name = 'M_hat', initializer=tf.initializers.random_uniform(minval=-2, maxval=2), shape=[in_features, out_dim], trainable=True)

9

10        W = tf.nn.tanh(W_hat) * tf.nn.sigmoid(M_hat)

11

12        a = tf.matmul(in_dim, W)

13

14        return a, W 

NAC function in Python

Python 中的 NAC 功能

接下来，让我们创建一些玩具数据，用于训练和测试数据。 NumPy 有一个名为 numpy.arrange 的优秀 API，我们将利用它来创建数据集。

1    # Generate a series of input number X1 and X2 for training

2    x1 = np.arange(0,10000,5, dtype=np.float32)

3    x2 = np.arange(5,10005,5, dtype=np.float32)

4

5

6    y_train = x1 + x2

7

8    x_train = np.column_stack((x1,x2))

9

10    print(x_train.shape)

11    print(y_train.shape)

12

13    # Generate a series of input number X1 and X2 for testing

14    x1 = np.arange(1000,2000,8, dtype=np.float32)

15    x2 = np.arange(1000,1500,4, dtype= np.float32)

16

17    x_test = np.column_stack((x1,x2))

18    y_test = x1 + x2

19

20    print()

21    print(x_test.shape)

22    print(y_test.shape)

添加玩具数据

现在，我们可以定义样板代码来训练模型。 我们首先定义占位符 X 和 Y，用以在运行时提供数据。 接下来我们定义的是 NAC 网络（y_pred，W = NAC（in_dim = X，out_dim = 1））。 对于损失，我们使用 tf.reduce_sum()。 我们将有两个超参数，alpha，即学习率和我们想要训练网络的时期数。在运行训练循环之前，我们需要定义一个优化器，这样我们就可以使用 tf.train.AdamOptimizer() 来减少损失。

1    # Define the placeholder to feed the value at run time

2    X = tf.placeholder(dtype=tf.float32, shape =[None , 2])    # Number of samples x Number of features (number of inputs to be added)

3    Y = tf.placeholder(dtype=tf.float32, shape=[None,])

4    

5    # define the network

6    # Here the network contains only one NAC cell (for testing)

7    y_pred, W = NAC(in_dim=X, out_dim=1)

8    y_pred = tf.squeeze(y_pred)            # Remove extra dimensions if any

9

10    # Mean Square Error (MSE)

11    loss = tf.reduce_mean( (y_pred - Y) **2)

12

13

14    # training parameters

15    alpha = 0.05    # learning rate

16    epochs = 22000

17

18    optimize = tf.train.AdamOptimizer(learning_rate=alpha).minimize(loss)

19

20    with tf.Session() as sess:

21

22        #init = tf.global_variables_initializer()

23        cost_history = []

24

25        sess.run(tf.global_variables_initializer())

26

27        # pre training evaluate

28        print("Pre training MSE: ", sess.run (loss, feed_dict={X: x_test, Y:y_test}))

29        print()

30        for i in range(epochs):

31            _, cost = sess.run([optimize, loss ], feed_dict={X:x_train, Y: y_train})

32            print("epoch: {}, MSE: {}".format( i,cost) )

33            cost_history.append(cost)

34

35        # plot the MSE over each iteration

36        plt.plot(np.arange(epochs),np.log(cost_history))  # Plot MSE on log scale

37        plt.xlabel("Epoch")

38        plt.ylabel("MSE")

39        plt.show()

40

41        print()

42        print(W.eval())

43        print()

44        # post training loss

45        print("Post training MSE: ", sess.run(loss, feed_dict={X: x_test, Y: y_test}))

46

47        print("Actual sum: ", y_test[0:10])

48        print()

49        print("Predicted sum: ", sess.run(y_pred[0:10], feed_dict={X: x_test, Y: y_test})) 

训练之后，成本图的样子：

NAC 训练之后的成本

Actual sum:  [2000. 2012. 2024. 2036. 2048. 2060. 2072. 2084. 2096. 2108.]

Predicted sum:  [1999.9021 2011.9015 2023.9009 2035.9004 2047.8997 2059.8992 2071.8984
2083.898  2095.8975 2107.8967]

虽然 NAC 可以处理诸如加法和减法之类的操作，但是它无法处理乘法和除法。 于是，就有了 NALU 的用武之地。它能够处理更复杂的操作，例如乘法和除法。

通过学习乘法来测试 NALU 

为此，我们将添加片段以使 NAC 成为 NALU。

神经累加器（NAC）是其输入的线性变换。神经算术逻辑单元（NALU）使用两个带有绑定的权重的 NACs 来启用加法或者减法（较小的紫色单元）和乘法/除法（较大的紫色单元），由一个门（橙色单元）来控制。

1    # The Neural Arithmetic Logic Unit

2    def NALU(in_dim, out_dim):

3

4        shape = (int(in_dim.shape[-1]), out_dim)

5        epsilon = 1e-7

6

7        # NAC

8        W_hat = tf.Variable(tf.truncated_normal(shape, stddev=0.02))

9        M_hat = tf.Variable(tf.truncated_normal(shape, stddev=0.02))

10        G = tf.Variable(tf.truncated_normal(shape, stddev=0.02))

11

12        W = tf.tanh(W_hat) * tf.sigmoid(M_hat)

13        # Forward propogation

14        a = tf.matmul(in_dim, W)

15

16        # NALU

17        m = tf.exp(tf.matmul(tf.log(tf.abs(in_dim) + epsilon), W))

18        g = tf.sigmoid(tf.matmul(in_dim, G))

19        y = g * a + (1 - g) * m

20

21        return y

Python 中的 NALU 函数

现在，再次创建一些玩具数据，这次我们将进行两行更改。

1    # Test the Network by learning the multiplication

2

3    # Generate a series of input number X1 and X2 for training

4    x1 = np.arange(0,10000,5, dtype=np.float32)

5    x2 = np.arange(5,10005,5, dtype=np.float32)

6

7

8    y_train = x1 * x2

9

10    x_train = np.column_stack((x1,x2))

11

12    print(x_train.shape)

13    print(y_train.shape)

14

15    # Generate a series of input number X1 and X2 for testing

16    x1 = np.arange(1000,2000,8, dtype=np.float32)

17    x2 = np.arange(1000,1500,4, dtype= np.float32)

18

19    x_test = np.column_stack((x1,x2))

20    y_test = x1 * x2

21

22    print()

23    print(x_test.shape)

24    print(y_test.shape)

用于乘法的玩具数据

第 8 行和第 20 行是进行更改的地方，将加法运算符切换为乘法。

现在我们可以训练的是 NALU 网络。 我们唯一需要更改的地方是定义 NAC 网络改成 NALU（y_pred = NALU（in_dim = X，out_dim = 1））。

1    # Define the placeholder to feed the value at run time

2    X = tf.placeholder(dtype=tf.float32, shape =[None , 2])    # Number of samples x Number of features (number of inputs to be added)

3    Y = tf.placeholder(dtype=tf.float32, shape=[None,])

4

5    # Define the network

6    # Here the network contains only one NAC cell (for testing)

7    y_pred = NALU(in_dim=X, out_dim=1)

8    y_pred = tf.squeeze(y_pred)      # Remove extra dimensions if any

9

10    # Mean Square Error (MSE)

11    loss = tf.reduce_mean( (y_pred - Y) **2)

12    

13    

14    # training parameters

15    alpha = 0.05    # learning rate

16    epochs = 22000

17    

18    optimize = tf.train.AdamOptimizer(learning_rate=alpha).minimize(loss)

19

20    with tf.Session() as sess: 

21

22        #init = tf.global_variables_initializer()

23        cost_history = []

24

25        sess.run(tf.global_variables_initializer())

26

27        # pre training evaluate    

28        print("Pre training MSE: ", sess.run (loss, feed_dict={X: x_test, Y: y_test}))    

29        print()    

30        for i in range(epochs):    

31            _, cost = sess.run([optimize, loss ], feed_dict={X: x_train, Y: y_train})    

32        print("epoch: {}, MSE: {}".format( i,cost) )

33        cost_history.append(cost) 

34

35        # Plot the loss over each iteration

36        plt.plot(np.arange(epochs),np.log(cost_history))  # Plot MSE on log scale

37        plt.xlabel("Epoch") 

38        plt.ylabel("MSE")    

39        plt.show() 

40

41

42        # post training loss    

43        print("Post training MSE: ", sess.run(loss, feed_dict={X: x_test, Y: y_test})) 

44

45        print("Actual product: ", y_test[0:10])    

46        print()    

47        print("Predicted product: ", sess.run(y_pred[0:10], feed_dict={X: x_test, Y: y_test})) 

NALU 训练后的成本

Actual product:  [1000000. 1012032. 1024128. 1036288. 1048512. 1060800. 1073152. 1085568.
1098048. 1110592.]

Predicted product:  [1000000.2  1012032.   1024127.56 1036288.6  1048512.06 1060800.8
1073151.6  1085567.6  1098047.6  1110592.8 ]

在 TensorFlow 中全面实现

注：链接地址

https://github.com/ahylton19/simpleNALU-tf

更多 AI 相关阅读：