一个简单的深度学习模型来添加两个数字

2019-04-11 08:00:00 · 飞浪

通过使用数据张量来获取正确形状的数据并使用 Keras 开发神经网络，我们可以看到深度学习世界中如何处理传统的计算问题。

介绍

人工神经网络或深度学习模型是机器学习提供的最强大的预测工具之一。它们非常适合感知问题，与传统的计算机任务相比，这类问题更容易被人类理解、领悟和解决。例如，计算机可以在几微秒内轻松计算 3453454345 和 94834368345 的乘法，而区分图片中的猫和狗却是一个不小的问题，直到最近，这对计算世界来说还是一个巨大的挑战。

随着深度学习的出现，这类感知问题取得了巨大的成功。在本指南中，为了简单易懂，我们将尝试将简单的算术加法改为感知问题，然后尝试通过这个训练模型来预测值。

在本指南中，我们将使用作为 Tensorflow 库的一部分提供的 Keras 库。

数据张量

让数据保持正确的形状可能是任何机器学习模型中最重要的方面，在这里也是如此。下面的程序 (data_creation.py) 为加法问题创建训练集和测试集。

      import numpy as np 
train_data = np.array([[1.0,1.0]])
train_targets = np.array([2.0])
print(train_data)
for i in range(3,10000,2):
    train_data= np.append(train_data,[[i,i]],axis=0)
    train_targets= np.append(train_targets,[i+i])
test_data = np.array([[2.0,2.0]])
test_targets = np.array([4.0])
for i in range(4,8000,4):
    test_data = np.append(test_data,[[i,i]],axis=0)
    test_targets = np.append(test_targets,[i+i])
    

我们来分析一下上面的程序：

      import numpy as np 
train_data = np.array([[1.0,1.0]])
train_targets = np.array([2.0])
    

在以上三行中，我们导入了 Numpy 库并创建了 train_data 和 train_target 数据集。train_data 是用于保存要相加的两个数字的数组，而 train_targets 是用于保存两个数字相加值的向量。train_data 被初始化为包含两个数字，如 1.0 和 1.0。这是一个非常简单的程序，因此您将看到相同的数字重复出现 (1.0)，并且这种模式在整个训练和测试数据集中重复出现，即相同的数字 (i) 用于将自身相加。

      for i in range(3,10000,2):
    train_data= np.append(train_data,[[i,i]],axis=0)
    train_targets= np.append(train_targets,[i+i])
    

上面的代码通过循环计数器 (i) 附加 train_data 数组和 train_target 向量，计数器 (i) 从 3 开始，以 2 为步长增加到 10000。train_data 如下所示：

输出

      [1.000e+00 1.000e+00]
 [3.000e+00 3.000e+00]
 [5.000e+00 5.000e+00]
 ...
 [9.995e+03 9.995e+03]
 [9.997e+03 9.997e+03]
 [9.999e+03 9.999e+03]
    

训练目标：

输出

      2.0000e+00 6.0000e+00 1.0000e+01 ... 1.9990e+04 1.9994e+04 1.9998e+04

test_data 和 test_targets 也以类似的方式创建，但有一点不同：它以 4 为步长一直到 8000。

      test_data = np.array([[2.0,2.0]])
test_targets = np.array([4.0])
for i in range(4,8000,4):
    test_data = np.append(test_data,[[i,i]],axis=0)
    test_targets = np.append(test_targets,[i+i])
    

测试数据：

输出

      [2.000e+00 2.000e+00]
 [4.000e+00 4.000e+00]
 [8.000e+00 8.000e+00]
 ...
 [7.988e+03 7.988e+03]
 [7.992e+03 7.992e+03]
 [7.996e+03 7.996e+03]
    

测试目标：

输出

      4.0000e+00 8.0000e+00 1.6000e+01 ... 1.5976e+04 1.5984e+04 1.5992e+04

使用 Keras 开发加法神经网络

Keras 是一种 API 规范，可用于运行各种深度学习库，例如 Tensorflow、Theano 等。需要注意的是，Keras 没有实现，它是一个在其他深度学习库之上运行的高级 API。我们试图解决的问题是一个回归问题，其中输出可以是连续的值，而不是采用指定的一组值。下面，该程序创建一个深度学习模型，使用我们在 data_creation.py 程序中创建的训练集对其进行训练，然后使用同样在同一程序中创建的测试集对其进行测试。最后，训练后的模型用于预测值。

      import tensorflow as tf
from tensorflow import keras
import numpy as np
import data_creation as dc 

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(2,)),
    keras.layers.Dense(20, activation=tf.nn.relu),
	keras.layers.Dense(20, activation=tf.nn.relu),
    keras.layers.Dense(1)
])

model.compile(optimizer='adam', 
              loss='mse',
              metrics=['mae'])

model.fit(dc.train_data, dc.train_targets, epochs=10, batch_size=1)

test_loss, test_acc = model.evaluate(dc.test_data, dc.test_targets)
print('Test accuracy:', test_acc)
a= np.array([[2000,3000],[4,5]])
print(model.predict(a))
    

让我们将上面的程序分成几个小块来分析一下：

      import tensorflow as tf
from tensorflow import keras
import numpy as np
import data_creation as dc
    

上述代码在程序中导入了 Tensorflow、Keras 和 Numpy 库。此外，我们之前创建的 data_creation.py 程序也被导入，并被赋予一个命名变量 dc。现在，我们创建的所有经过训练的测试数据集都可以使用 dc 进行引用。例如，如果用户需要使用 train_data 的内容，那么她只需使用 dc.train_data 即可访问它。

      model = keras.Sequential([
    keras.layers.Flatten(input_shape=(2,)),
    keras.layers.Dense(20, activation=tf.nn.relu),
	keras.layers.Dense(20, activation=tf.nn.relu),
    keras.layers.Dense(1)
])
    

上述代码创建了实际的深度学习模型。上述模型将模型初始化为层的堆栈（Keras.Sequential），然后将输入数组展平为向量（keras.layers.Flatten(input_shape=(2,)）。展平部分也恰好是神经网络的第一层。网络的第二层和第三层各由 20 个节点组成，我们使用的激活函数是relu（整流线性单元）。也可以使用其他激活函数，例如softmax。最后一层，即第四层，是输出层。由于我们只期望一个输出值（因为这是一个回归模型，所以是一个预测值），因此该模型中只有一个输出节点（keras.layers.Dense(1)）。

模型的架构在很大程度上取决于我们要解决的问题。我们上面创建的模型对于分类问题（例如图像分类）效果不佳。

      model.compile(optimizer='adam', 
              loss='mse',
              metrics=['mae'])
    

上述代码将用于编译网络。我们使用的优化函数是adam，它是一种基于动量的优化器，可防止模型陷入局部最小值。我们使用的损失函数是mse（均方误差）。它考虑预测值与实际值之间的平方差。此外，我们还在监控另一个指标mae（平均绝对误差）。

      model.fit(dc.train_data, dc.train_targets, epochs=10, batch_size=1)

这是网络实际训练发生的地方。训练集将被输入到网络 10 次（epoch）以进行训练。需要仔细选择 epoch，因为较少的 epoch 数可能导致网络训练不足，而过多的 epoch 数可能导致过度拟合，其中网络在训练数据上运行良好，但在测试数据集上运行不佳。

      test_loss, test_acc = model.evaluate(dc.test_data, dc.test_targets)
print('Test accuracy:', test_acc)
    

上述代码在测试数据集上评估训练后的模型，随后打印测试准确率值。

      a= np.array([[2000,3000],[4,5]])
print(model.predict(a))
    

一旦模型经过训练和测试，我们就可以通过提供真实世界的值来使用它来预测值。在本例中，我们提供 2 组值 (2000,30000) 和 (4,5)，然后打印模型的输出。

输出

      Epoch 1/10
5000/5000 [==============================] - 5s 997us/sample - loss: 1896071.4827 - mean_absolute_error: 219.0276

Epoch 2/10
5000/5000 [==============================] - 5s 956us/sample - loss: 492.9092 - mean_absolute_error: 3.8202

Epoch 3/10
5000/5000 [==============================] - 5s 1ms/sample - loss: 999.7580 - mean_absolute_error: 7.1740

Epoch 4/10
5000/5000 [==============================] - 5s 1ms/sample - loss: 731.0374 - mean_absolute_error: 6.0325

Epoch 5/10
5000/5000 [==============================] - 5s 935us/sample - loss: 648.6434 - mean_absolute_error: 7.5037

Epoch 6/10
5000/5000 [==============================] - 5s 942us/sample - loss: 603.1096 - mean_absolute_error: 7.7574

Epoch 7/10
5000/5000 [==============================] - 5s 1ms/sample - loss: 596.2445 - mean_absolute_error: 5.1727

Epoch 8/10
5000/5000 [==============================] - 5s 924us/sample - loss: 685.5327 - mean_absolute_error: 4.9312

Epoch 9/10
5000/5000 [==============================] - 5s 931us/sample - loss: 1895.0845 - mean_absolute_error: 5.7679

Epoch 10/10
5000/5000 [==============================] - 5s 996us/sample - loss: 365.9733 - mean_absolute_error: 2.7120
2000/2000 [==============================] - 0s 42us/sample - loss: 5.8080 - mean_absolute_error: 2.0810
Test accuracy: 2.0810156
[[5095.9385  ]
 [   9.108022]]
    

可以看出，输入集 (2000,3000) 的预测值为 5095.9385，输入集 (4,5) 的预测值为 9.108022。这可以通过更改 epoch 或增加层数或增加层中的节点数来优化。

结论

需要注意的是，我们使用的示例（即两个数字相加）仅用于说明目的，并不是神经网络的最佳用途。但是，很容易理解并直观地了解神经网络以及如何在深度学习世界中处理传统的计算问题（例如加法）。深度学习是一种基于黑箱的问题解决模型，因此结果会随着不同参数而变化。用户需要熟悉不同的参数以及如何使用它们来直观地了解哪些参数适用于手头的问题。用户越多地练习深度学习并处理不同的问题，她就会发展出越深入的理解。

_{免责声明：本内容来源于第三方作者授权、网友推荐或互联网整理，旨在为广大用户提供学习与参考之用。所有文本和图片版权归原创网站或作者本人所有，其观点并不代表本站立场。如有任何版权侵犯或转载不当之情况，请与我们取得联系，我们将尽快进行相关处理与修改。感谢您的理解与支持！}

_查看原文

python

技术指南

阅读全文

一个简单的深度学习模型来添加两个数字

杭州电子商务研究院

5年前 · 面向社会、服务行业、政产学研结合、整合资源、和谐发展

import numpy as np train_data = np.array([[1.0,1.0]]) train_targets = np.array([2.0]) print(train_data) for i in range(3,10000,2): train_data= np.append(train_data,[[i,i]],axis=0) train_targets= np.append(train_targets,[i+i]) test_data = np.array([[2.0,2.0]]) test_targets = np.array([4.0]) for i in range(4,8000,4): test_data = np.append(test_data,[[i,i]],axis=0) test_targets = np.append(test_targets,[i+i])

test_data = np.array([[2.0,2.0]]) test_targets = np.array([4.0]) for i in range(4,8000,4): test_data = np.append(test_data,[[i,i]],axis=0) test_targets = np.append(test_targets,[i+i])

import tensorflow as tf from tensorflow import keras import numpy as np import data_creation as dc model = keras.Sequential([ keras.layers.Flatten(input_shape=(2,)), keras.layers.Dense(20, activation=tf.nn.relu), keras.layers.Dense(20, activation=tf.nn.relu), keras.layers.Dense(1) ]) model.compile(optimizer='adam', loss='mse', metrics=['mae']) model.fit(dc.train_data, dc.train_targets, epochs=10, batch_size=1) test_loss, test_acc = model.evaluate(dc.test_data, dc.test_targets) print('Test accuracy:', test_acc) a= np.array([[2000,3000],[4,5]]) print(model.predict(a))

model = keras.Sequential([ keras.layers.Flatten(input_shape=(2,)), keras.layers.Dense(20, activation=tf.nn.relu), keras.layers.Dense(20, activation=tf.nn.relu), keras.layers.Dense(1) ])

Epoch 1/10 5000/5000 [==============================] - 5s 997us/sample - loss: 1896071.4827 - mean_absolute_error: 219.0276 Epoch 2/10 5000/5000 [==============================] - 5s 956us/sample - loss: 492.9092 - mean_absolute_error: 3.8202 Epoch 3/10 5000/5000 [==============================] - 5s 1ms/sample - loss: 999.7580 - mean_absolute_error: 7.1740 Epoch 4/10 5000/5000 [==============================] - 5s 1ms/sample - loss: 731.0374 - mean_absolute_error: 6.0325 Epoch 5/10 5000/5000 [==============================] - 5s 935us/sample - loss: 648.6434 - mean_absolute_error: 7.5037 Epoch 6/10 5000/5000 [==============================] - 5s 942us/sample - loss: 603.1096 - mean_absolute_error: 7.7574 Epoch 7/10 5000/5000 [==============================] - 5s 1ms/sample - loss: 596.2445 - mean_absolute_error: 5.1727 Epoch 8/10 5000/5000 [==============================] - 5s 924us/sample - loss: 685.5327 - mean_absolute_error: 4.9312 Epoch 9/10 5000/5000 [==============================] - 5s 931us/sample - loss: 1895.0845 - mean_absolute_error: 5.7679 Epoch 10/10 5000/5000 [==============================] - 5s 996us/sample - loss: 365.9733 - mean_absolute_error: 2.7120 2000/2000 [==============================] - 0s 42us/sample - loss: 5.8080 - mean_absolute_error: 2.0810 Test accuracy: 2.0810156 [[5095.9385 ] [ 9.108022]]