标签：指南实战卷积模型 train tf TensorFlow 我们

原文：Hands-on Deep Learning with TensorFlow

协议：CC BY-NC-SA 4.0

译者：飞龙

本文来自【ApacheCN 深度学习译文集】，采用译后编辑（MTPE）流程来尽可能提升效率。

不要担心自己的形象，只关心如何实现目标。——《原则》，生活原则 2.3.c

一、入门

TensorFlow 是 Google 最近发布的新的机器学习和图计算库。其 Python 接口可确保通用模型的优雅设计，而其编译后的后端可确保速度。

让我们看一下应用 TensorFlow 时要学习的技术和要构建的模型。

安装 TensorFlow

在本节中，您将学习什么是 TensorFlow，如何安装 TensorFlow 以及如何构建简单模型和进行简单计算。此外，您将学习如何建立用于分类的逻辑回归模型，并介绍机器学习问题以帮助我们学习 TensorFlow。

我们将学习 TensorFlow 是什么类型的库，并将其安装在我们自己的 Linux 机器上；如果您无法访问 Linux 机器，则将其安装在 CoCalc 的免费实例中。

TensorFlow 主页

首先，什么是 TensorFlow？ TensorFlow 是 Google 推出的新的机器学习库。它被设计为非常易于使用且非常快。如果您访问 TensorFlow 网站，则可以访问有关 TensorFlow 是什么以及如何使用的大量信息。我们将经常提到这一点，特别是文档。

TensorFlow 安装页面

在我们开始使用 TensorFlow 之前，请注意，您需要先安装它，因为它可能尚未预先安装在您的操作系统上。因此，如果转到 TensorFlow 网页上的“安装”选项卡，单击在 Ubuntu 上安装 TensorFlow，然后单击“本机 PIP”，您将学习如何安装 TensorFlow。

TensorFlow – the installation page

即使对于经验丰富的系统管理员来说，安装 TensorFlow 也是非常困难的。因此，我强烈建议您使用类似pip的安装方式。或者，如果您熟悉 Docker，请使用 Docker 安装。您可以从源代码安装 TensorFlow，但这可能非常困难。我们将使用称为 wheel 文件的预编译二进制文件安装 TensorFlow。您可以使用 Python 的pip模块安装程序来安装此文件。

通过`pip`安装

对于pip安装，您可以选择使用 Python2 或 Python3 版本。另外，您可以在 CPU 和 GPU 版本之间进行选择。如果您的计算机具有功能强大的显卡，则可能适合您使用 GPU 版本。

Installing via pip

但是，您需要检查显卡是否与 TensorFlow 兼容。如果不是，那很好。本系列中的所有内容都可以仅使用 CPU 版本来完成。

注意

我们可以使用pip install tensorflow命令（基于您的 CPU 或 GPU 支持以及pip版本）安装 TensorFlow，如前面的屏幕截图所示。

因此，如果您为 TensorFlow 复制以下行，则也可以安装它：

# Python 3.4 installation
sudo pip3 install --upgrade \
https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.2.1-cp34-cp34m-linux_x86_64.whl

如果您没有 Python 3.4，请按照 wheel 文件的要求进行操作，那就可以了。您可能仍然可以使用相同的 wheel 文件。让我们看一下如何在 Python 3.5 上执行此操作。首先，只需将以下 URL 放在浏览器中，或使用命令行程序（例如wget）直接下载 wheel 文件，就像我们在这里所做的那样：

wget  https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.2.1-cp34-cp34m-linux_x86_64.whl

如果下载此文件，它将很快被您的计算机抓住。

现在，您需要做的就是将文件名从cp34（代表 Python 3.4）更改为您使用的任何版本的 Python3。在这种情况下，我们将其更改为使用 Python 3.5 的版本，因此我们将4更改为5：

mv tensorflow-1.2.1-cp34-cp34m-linux_x86_64.whl tensorflow-1.2.1-cp35-cp35m-linux_x86_64.whl

现在您可以通过简单地将安装行更改为pip3 install并将新 wheel 文件的名称更改为 3.5 后，来为 Python 3.5 安装 TensorFlow：

sudo pip3 install ./tensorflow-1.2.1-cp35-cp35m-linux_x86_64.whl

我们可以看到这很好。现在，您已经安装了 TensorFlow。

Installing via pip

如果您的安装以后因某种原因损坏了，您可以随时跳回到该部分，以提醒自己有关安装所涉及的步骤。

通过 CoCalc 安装

如果您没有计算机的管理或安装权限，但仍然想尝试 TensorFlow，则可以尝试在 CoCalc 实例中通过 Web 运行 TensorFlow。如果转到 cocalc.com 并创建一个新帐户，则可以创建一个新项目。这将为您提供一种可以玩耍的虚拟机。方便的是，TensorFlow 已经安装在 Anaconda 3 内核中。

Installing via CoCalc

让我们创建一个名为TensorFlow的新项目。单击+创建新项目...，为您的项目输入标题，然后单击创建项目。现在，我们可以通过单击标题进入我们的项目。加载将需要几秒钟。

Installing via CoCalc

单击+新建以创建一个新文件。在这里，我们将创建一个 Jupyter 笔记本：

Installing via CoCalc

Jupyter 是与 IPython 进行交互的便捷方法，也是使用 CoCalc 进行这些计算的主要手段。加载可能需要几秒钟。

进入下面的屏幕快照中所示的界面时，您需要做的第一件事是通过转到“内核 | 更改内核… | Python3（Anaconda）”将内核更改为 Anaconda Python3：

Installing via CoCalc

这将为您提供适当的依赖关系以使用 TensorFlow。更改内核可能需要几秒钟。连接到新内核后，可以在单元格中键入import tensorflow，然后转到“单元格 | 运行单元格”以检查其是否有效：

Installing via CoCalc

如果 Jupyter 笔记本需要很长时间才能加载，则可以使用以下屏幕截图中所示的按钮在 CoCalc 中创建终端：

Installing via CoCalc

到那里后，键入anaconda3切换环境，然后键入ipython3启动交互式 Python 会话，如以下屏幕截图所示：

Installing via CoCalc

尽管您无法可视化输出，但是您可以在这里轻松地工作。在终端中输入import tensorflow，然后离开。

到目前为止，您已经了解了 TensorFlow 是什么以及如何在本地或 Web 上的虚拟机上安装 TensorFlow。现在我们准备在 TensorFlow 中探索简单的计算。

简单的计算

首先，我们将看一下张量对象类型。然后，我们将理解定义计算的 TensorFlow 图。最后，我们将使用会话运行图，显示如何替换中间值。

定义标量和张量

您需要做的第一件事是下载本书的源代码包并打开simple.py文件。您可以使用此文件将行复制并粘贴到 TensorFlow 或 CoCalc 中，也可以直接键入它们。首先，让我们将tensorflow导入为tf。这是在 Python 中引用它的便捷方法。您需要在tf.constant通话中保留常数。例如，做a = tf.constant(1)和b = tf.constant(2)：

import tensorflow as tf
# You can create constants in TF to hold specific values
a = tf.constant(1)
b = tf.constant(2)

当然，您可以将它们相加并相乘以获得其他值，即c和d：

# Of course you can add, multiply, and compute on these as you like
c = a + b
d = a * b

TensorFlow 数字以张量存储，这是多维数组的一个花哨术语。如果您将 Python 列表传递给 TensorFlow，它将做正确的事并将其转换为适当尺寸的张量。您可以在以下代码中看到这一点：

# TF numbers are stored in "tensors", a fancy term for multidimensional arrays. If you pass TF a Python list, it can convert it
V1 = tf.constant([1., 2.])   # Vector, 1-dimensional
V2 = tf.constant([3., 4.])   # Vector, 1-dimensional
M = tf.constant([[1., 2.]])             # Matrix, 2d
N = tf.constant([[1., 2.],[3.,4.]])     # Matrix, 2d
K = tf.constant([[[1., 2.],[3.,4.]]])   # Tensor, 3d+

V1向量（一维张量）作为[1\. , 2.]的 Python 列表传递。这里的点只是强制 Python 将数字存储为十进制值而不是整数。 V2向量是[3\. , 4\. ]的另一个 Python 列表。 M变量是由 Python 中的列表列表构成的二维矩阵，在 TensorFlow 中创建了二维张量。 N变量也是二维矩阵。请注意，这一行实际上有多行。最后，K是一个真实的张量，包含三个维度。请注意，最终维度仅包含一个条目，即一个2 x 2框。

如果该项有点混乱，请不要担心。每当您看到一个奇怪的新变量时，都可以跳回到这一点以了解它可能是什么。

张量计算

您还可以做一些简单的事情，例如将张量相加：

V3 = V1 + V2

或者，您可以将它们逐个元素相乘，以便将每个公共位置相乘在一起：

# Operations are element-wise by default
M2 = M * M

但是，对于真正的矩阵乘法，您需要使用tf.matmul，传入两个张量作为参数：

NN = tf.matmul(N,N)

执行计算

到目前为止，所有内容都已指定 TensorFlow 图；我们还没有计算任何东西。为此，我们需要启动一个进行计算的会话。以下代码创建一个新的会话：

sess = tf.Session()

打开会话后，请执行以下操作：sess.run(NN)将计算给定的表达式并返回一个数组。通过执行以下操作，我们可以轻松地将其发送到变量：

output = sess.run(NN)
print("NN is:")
print(output)

如果现在运行此单元格，则应该在屏幕上看到NN输出的正确张量数组：

Doing computation

使用完会话后，最好将其关闭，就像关闭文件句柄一样：

# Remember to close your session when you're done using it
sess.close()

对于交互式工作，我们可以像这样使用tf.InteractiveSession()：

sess = tf.InteractiveSession()

然后，您可以轻松计算任何节点的值。例如，输入以下代码并运行单元格将输出M2的值：

# Now we can compute any node
print("M2 is:")
print(M2.eval())

可变张量

当然，并非我们所有的数字都是恒定的。例如，要更新神经网络中的权重，我们需要使用tf.Variable创建适当的对象：

W = tf.Variable(0, name="weight")

请注意，TensorFlow 中的变量不会自动初始化。为此，我们需要使用一个特殊的调用，即tf.global_variables_initializer()，然后使用sess.run()运行该调用：

init_op = tf.global_variables_initializer()
sess.run(init_op)

这是在该变量中放置一个值。在这种情况下，它将把0值填充到W变量中。让我们验证一下W是否具有该值：

print("W is:")
print(W.eval())

您应该在单元格中看到0的W的输出值：

Variable tensors

让我们看看向其中添加a会发生什么：

W += a
print("W after adding a:")
print(W.eval())

回想一下a是1，因此您在这里得到1的期望值：

Variable tensors

让我们再次添加a，以确保我们可以递增并且它确实是一个变量：

W += a
print("W after adding a:")
print(W.eval())

现在您应该看到W持有2，因为我们已经使用a对其进行了两次递增：

Variable tensors

查看和替换中间值

在执行 TensorFlow 计算时，您可以返回或提供任意节点。让我们定义一个新节点，但同时在fetch调用中返回另一个节点。首先，让我们定义新节点E，如下所示：

E = d + b # 1*2 + 2 = 4

让我们看看E的开头是：

print("E as defined:")
print(E.eval())

如您所料，您应该看到E等于4。现在让我们看一下如何传递E和d多个节点，以从sess.run调用中返回多个值：

# Let's see what d was at the same time
print("E and d:")
print(sess.run([E,d]))

您应该看到输出中返回了多个值，即4和2：

Viewing and substituting intermediate values

现在假设我们要使用其他中间值，例如出于调试目的。返回值时，我们可以使用feed_dict将自定义值提供给计算中任何位置的节点。让我们现在用d等于4而不是2来做：

# Use a custom d by specifying a dictionary
print("E with custom d=4:")
print(sess.run(E, feed_dict = {d:4.}))

请记住，E 等于 d + b，d和b的值都是2。尽管我们为d插入了4的新值，但是您应该看到E的值现在将输出为6：

Viewing and substituting intermediate values

您现在已经了解了如何使用 TensorFlow 张量进行核心计算。现在是时候通过建立逻辑回归模型来迈出下一步。

逻辑回归模型构建

好的，让我们开始构建一个真正的机器学习模型。首先，我们将看到提出的机器学习问题：字体分类。然后，我们将回顾一个简单的分类算法，称为逻辑回归。最后，我们将在 TensorFlow 中实现逻辑回归。

字体分类数据集简介

在开始之前，让我们加载所有必需的模块：

import tensorflow as tf
import numpy as np

如果要复制并粘贴到 IPython，请确保将autoindent属性设置为OFF：

%autoindent

tqdm模块是可选的；它只是显示了不错的进度条：

try:
    from tqdm import tqdm
except ImportError:
    def tqdm(x, *args, **kwargs):
        return x

接下来，我们将设置0的种子，以使每次运行之间的数据分割保持一致：

# Set random seed
np.random.seed(0)

在本书中，我们提供了使用五种字体的字符图像数据集。为方便起见，这些文件存储在压缩的 NumPy 文件（data_with_labels.npz）中，该文件可在本书的下载包中找到。您可以使用numpy.load轻松将它们加载到 Python 中：

# Load data
data = np.load('data_with_labels.npz')
train = data['arr_0']/255.
labels = data['arr_1']

这里的train变量保存从 0 到 1 缩放的实际像素值，labels保留原来的字体类型。因此，它将是 0、1、2、3 或 4，因为总共有五种字体。您可以打印这些值，因此可以使用以下代码查看它们：

# Look at some data
print(train[0])
print(labels[0])

但是，这不是很有启发性，因为大多数值都是零，并且仅屏幕的中央部分包含图像数据：

Introducing the font classification dataset

如果您已安装 Matplotlib，则现在是导入它的好地方。在需要时，我们将使用plt.ion()自动调出数字：

# If you have matplotlib installed
import matplotlib.pyplot as plt
plt.ion()

这是每种字体的一些字符示例图：

Introducing the font classification dataset

是的，他们很浮华。在数据集中，每个图像都表示为像素暗度值的36 x 36二维矩阵。 0 值表示白色像素，而 255 表示黑色像素。两者之间的一切都是灰色阴影。这是在您自己的计算机上显示这些字体的代码：

# Let's look at a subplot of one of A in each font
f, plts = plt.subplots(5, sharex=True)
c = 91
for i in range(5):
    plts[i].pcolor(train[c + i * 558],
                   cmap=plt.cm.gray_r)

如果您的图看起来确实很宽，则可以使用鼠标轻松调整窗口大小。如果您只是以交互方式进行绘图，则在 Python 中提前调整其大小通常需要做很多工作。鉴于我们还有许多其他标记的字体图像，我们的目标是确定图像属于哪种字体。为了扩展数据集并避免过拟合，我们还在36 x 36区域内抖动了每个字符，为我们提供了 9 倍的数据点。

在使用较新的模型后重新回到这一点可能会有所帮助。无论最终模型有多高级，记住原始数据都非常重要。

逻辑回归

如果您熟悉线性回归，那么您将了解逻辑回归。基本上，我们将为图像中的每个像素分配一个权重，然后对这些像素进行加权求和（权重为beta，像素为X）。这将为我们提供该图像是特定字体的分数。每种字体都有自己的权重集，因为它们对像素的重视程度不同。要将这些分数转换为适当的概率（由Y表示），我们将使用softmax函数将其总和强制在 0 到 1 之间，如下所示。对于特定图像而言，无论最大概率是多少，我们都将其分类为关联的类别。

您可以在大多数统计建模教科书中阅读有关逻辑回归理论的更多信息。这是它的公式：

Logistic regression

William H. Greene 的《计量经济学分析》（Pearson）于 2012 年出版，这是一本针对应用的很好的参考。

准备数据

在 TensorFlow 中实现逻辑回归非常容易，并将作为更复杂的机器学习算法的基础。首先，我们需要将整数标签转换为单格式。这意味着，不是将字体类标记为 2，而是将标签转换为[0, 0, 1, 0, 0]。也就是说，我们将1放在第二个位置（注意，向上计数在计算机科学中很常见），而0则放在其他位置。这是我们的to_onehot函数的代码：

def to_onehot(labels,nclasses = 5):
    '''
    Convert labels to "one-hot" format.
    >>> a = [0,1,2,3]
    >>> to_onehot(a,5)
    array([[ 1.,  0.,  0.,  0.,  0.],
           [ 0.,  1.,  0.,  0.,  0.],
           [ 0.,  0.,  1.,  0.,  0.],
           [ 0.,  0.,  0.,  1.,  0.]])
    '''
    outlabels = np.zeros((len(labels),nclasses))
    for i,l in enumerate(labels):
        outlabels[i,l] = 1
    return outlabels

完成此操作后，我们可以继续调用该函数：

onehot = to_onehot(labels)

对于像素，在这种情况下，我们实际上并不需要矩阵，因此我们将36 x 36的数字展平为长度为 1,296 的一维向量，但这会在以后出现。另外，回想一下，我们已经重新调整了 0-255 的像素值，使其介于 0 和 1 之间。

好的，我们的最后准备是将数据集分为训练和验证集。这将有助于我们稍后解决过拟合问题。训练集将帮助我们确定逻辑回归模型中的权重，而验证集将仅用于确认这些权重在新数据上是否合理：

# Split data into training and validation
indices = np.random.permutation(train.shape[0])
valid_cnt = int(train.shape[0] * 0.1)
test_idx, training_idx = indices[:valid_cnt],\
                         indices[valid_cnt:]
test, train = train[test_idx,:],\
              train[training_idx,:]
onehot_test, onehot_train = onehot[test_idx,:],\
                        onehot[training_idx,:]

建立 TensorFlow 模型

好的，让我们通过创建一个交互式会话来开始 TensorFlow 代码：

sess = tf.InteractiveSession()

这样，我们就在 TensorFlow 中开始了我们的第一个模型。

我们将为x使用占位符变量，该变量代表我们的输入图像。这只是告诉 TensorFlow 我们稍后将通过feed_dict为该节点提供值：

# These will be inputs
## Input pixels, flattened
x = tf.placeholder("float", [None, 1296])

另外，请注意，我们可以指定此张量的形状，在这里我们将None用作大小之一。 None的大小允许我们立即将任意数量的数据点发送到算法中以进行批量。同样，我们将使用变量y_来保存我们已知的标签，以便稍后进行训练：

## Known labels
y_ = tf.placeholder("float", [None,5])

要执行逻辑回归，我们需要一组权重（W）。实际上，五个字体类别中的每一个都需要 1,296 的权重，这将为我们提供形状。请注意，我们还希望为每个类别添加一个额外的权重作为偏差（b）。这与添加始终为1值的额外输入变量相同：

# Variables
W = tf.Variable(tf.zeros([1296,5]))
b = tf.Variable(tf.zeros([5]))

随着所有这些 TensorFlow 变量浮动，我们需要确保对其进行初始化。现在给他们打电话：

# Just initialize
sess.run(tf.global_variables_initializer())

做得好！您已经准备好一切。现在，您可以实现softmax公式来计算概率。由于我们非常仔细地设置权重和输入，因此 TensorFlow 只需调用tf.matmul和tf.nn.softmax就可以轻松完成此任务：

# Define model
y = tf.nn.softmax(tf.matmul(x,W) + b)

而已！您已经在 TensorFlow 中实现了整个机器学习分类器。辛苦了。但是，我们从哪里获得权重的值？让我们看一下使用 TensorFlow 训练模型。

逻辑回归训练

首先，您将了解我们的机器学习分类器的损失函数，并在 TensorFlow 中实现它。然后，我们将通过求值正确的 TensorFlow 节点来快速训练模型。最后，我们将验证我们的模型是否合理准确，权重是否合理。

定义损失函数

优化我们的模型实际上意味着最大程度地减少我们的误差。使用我们的标签，可以很容易地将它们与模型预测的类概率进行比较。类别cross_entropy函数是测量此函数的正式方法。尽管确切的统计信息超出了本课程的范围，但是您可以将其视为对模型的惩罚，以期获得更不准确的预测。为了进行计算，我们将单热的实数标签与预测概率的自然对数相乘，然后将这些值相加并取反。为方便起见，TensorFlow 已经包含此函数为tf.nn.softmax_cross_entropy_with_logits()，我们可以这样称呼它：

# Climb on cross-entropy
cross_entropy = tf.reduce_mean(
        tf.nn.softmax_cross_entropy_with_logits(
        logits = y + 1e-50, labels = y_))

请注意，我们在此处添加了一个较小的1e-50误差值，以避免数值不稳定问题。

训练模型

TensorFlow 的便利之处在于它提供了内置的优化器，以利用我们刚刚编写的损失函数。梯度下降是一种常见的选择，它将使我们的权重逐渐趋于更好。这是将更新我们权重的节点：

# How we train
train_step = tf.train.GradientDescentOptimizer(
                0.02).minimize(cross_entropy)

在我们实际开始训练之前，我们应该指定一些其他节点来评估模型的表现：

# Define accuracy
correct_prediction = tf.equal(tf.argmax(y,1),
                     tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(
           correct_prediction, "float"))

如果我们的模型将最高概率分配给正确的类别，则correct_prediction节点为1，否则为0。 accuracy变量对可用数据的这些预测取平均值，从而使我们对模型的执行情况有一个整体认识。

在进行机器学习训练时，我们经常希望多次使用同一数据点，以挤出所有信息。每次遍历整个训练数据都称为一个周期。在这里，我们将每 10 个时间段同时保存训练和验证准确率：

# Actually train
epochs = 1000
train_acc = np.zeros(epochs//10)
test_acc = np.zeros(epochs//10)
for i in tqdm(range(epochs)):
    # Record summary data, and the accuracy
    if i % 10 == 0:
        # Check accuracy on train set
        A = accuracy.eval(feed_dict={
            x: train.reshape([-1,1296]),
            y_: onehot_train})
        train_acc[i//10] = A
        # And now the validation set
        A = accuracy.eval(feed_dict={
            x: test.reshape([-1,1296]),
            y_: onehot_test})
        test_acc[i//10] = A
    train_step.run(feed_dict={
        x: train.reshape([-1,1296]),
        y_: onehot_train})

请注意，我们使用feed_dict传递不同类型的数据以获得不同的输出值。最后，train_step.run每次迭代都会更新模型。在典型的计算机上，这只需几分钟，如果使用 GPU，则要少得多，而在功率不足的计算机上则要花更多时间。

您刚刚使用 TensorFlow 训练了模型; 真棒！

评估模型准确率

在 1,000 个周期之后，让我们看一下模型。如果您安装了 Matplotlib，则可以在绘图中查看精度；如果没有，您仍然可以查看电话号码。对于最终结果，请使用以下代码：

# Notice that accuracy flattens out
print(train_acc[-1])
print(test_acc[-1])

如果您确实安装了 Matplotlib，则可以使用以下代码显示图：

# Plot the accuracy curves
plt.figure(figsize=(6,6))
plt.plot(train_acc,'bo')
plt.plot(test_acc,'rx')

您应该看到类似下面的图（请注意，我们使用了一些随机初始化，因此可能并不完全相同）：

Evaluating the model accuracy

验证精度似乎在经过约 400-500 次迭代后趋于平稳；除此之外，我们的模型可能过拟合或没有学到更多。同样，即使最终精度大约是 40%，看起来也很差，但请记住，对于五个类别，完全随机的猜测将仅具有 20% 的精度。有了这个有限的数据集，简单的模型就可以做到。

查看计算出的权重通常也很有帮助。这些可以为您提供有关模型认为重要的线索。让我们按给定类的像素位置绘制它们：

# Look at a subplot of the weights for each font
f, plts = plt.subplots(5, sharex=True)
for i in range(5):
    plts[i].pcolor(W.eval()[:,i].reshape([36,36]))

这应该给您类似于以下的结果（同样，如果图显示得很宽，则可以挤压窗口大小以使其平方）：

Evaluating the model accuracy

我们可以看到，在某些模型中，靠近内部的权重很重要，而外部的权重基本上为零。这是有道理的，因为没有字体字符到达图像的角落。

同样，请注意，由于随机初始化的影响，最终结果可能看起来有些不同。随时可以尝试并更改模型的参数；这就是您学习新事物的方式。

总结

在本章中，我们在可以使用的机器上安装了 TensorFlow。经过一些基本计算的小步骤，我们跳入了机器学习问题，仅通过逻辑回归和几行 TensorFlow 代码就成功构建了一个体面的模型。

在下一章中，我们将看到 TensorFlow 在深度神经网络方面的优势。

二、深度神经网络

在上一章中，我们研究了简单的 TensorFlow 操作以及如何在字体分类问题上使用逻辑回归。在本章中，我们将深入探讨一种最流行和成功的机器学习方法-神经网络。使用 TensorFlow，我们将构建简单和深度的神经网络，以改善字体分类问题的模型。在这里，我们将实践神经网络的基础。我们还将使用 TensorFlow 构建和训练我们的第一个神经网络。然后，我们将进入具有神经元隐藏层的神经网络，并完全理解它。完成后，您将更好地掌握以下主题：

基本神经网络
单隐藏层模型
单隐藏层说明
多隐藏层模型
多隐藏层的结果

在第一部分中，我们将回顾神经网络的基础。您将学习转换输入数据的常见方法，了解神经网络如何将这些转换联系在一起，最后，如何在 TensorFlow 中实现单个神经元。

基本神经网络

我们的逻辑回归模型运作良好，但本质上是线性的。将像素的强度加倍会使像素对得分的贡献增加一倍，但我们可能只真正关心像素是否在某个阈值之上或将较小的权重放在较小的值上。线性可能无法捕获问题的所有细微差别。解决此问题的一种方法是使用非线性函数转换输入。让我们看一下 TensorFlow 中的一个简单示例。

首先，请确保加载所需的模块（tensorflow，numpy和math）并启动交互式会话：

import tensorflow as tf
import numpy as np
import math

sess = tf.InteractiveSession()

在下面的示例中，我们创建了三个五长向量的正常随机数，这些向量被截断以防止它们过于极端，中心不同：

x1 = tf.Variable(tf.truncated_normal([5],
                 mean=3, stddev=1./math.sqrt(5)))
x2 = tf.Variable(tf.truncated_normal([5],
                 mean=-1, stddev=1./math.sqrt(5)))
x3 = tf.Variable(tf.truncated_normal([5],
                 mean=0, stddev=1./math.sqrt(5)))

sess.run(tf.global_variables_initializer())

注意

请注意，由于这是随机的，因此您的值可能会有所不同，但这很好。

常见的转换是对输入求平方。这样做会使更大的值变得更加极端，当然也使所有事情都变得积极起来：

sqx2 = x2 * x2
print(x2.eval())
print(sqx2.eval())

您可以在以下屏幕截图中看到结果：

Basic neural networks

对数函数

相反，如果您需要在较小的值中有更多细微差别，则可以尝试采用输入的自然对数或任何基本对数：

logx1 = tf.log(x1)
print(x1.eval())
print(logx1.eval())

请参考以下屏幕截图，请注意，较大的值往往会挤在一起，而较小的值则散布得多：

Log function

但是，对数不能处理负输入，并且您越接近零，小输入就变得越负。因此，请注意对数。最后，是 Sigmoid 变换。

sigmoid 函数

不必担心公式，只需知道正负两个极值分别被压缩为加一或零，而接近零的输入就接近二分之一：

sigx3 = tf.sigmoid(x3)
print(x3.eval())
print(sigx3.eval())

在这里，您将看到一个接近一半的示例。它从四分之一开始，到现在将近一半：

Sigmoid function

在机器学习中，我们通常将这些转换称为激活函数。我们通常将输入的加权总和组合到其中。当您考虑输入，权重和激活函数时，就将其称为神经元，因为它是受生物神经元启发的。

真正的神经元如何在物理大脑中工作的细节不在本书的讨论范围之内。如果您对此感兴趣，则神经生物学文章可能包含更多内容，或者您可以参考 Gordon M. Shepherd 的《神经元学说》作为近期参考。让我们看一下 TensorFlow 中的一个简单示例：

w1 = tf.constant(0.1)
w2 = tf.constant(0.2)
sess.run(tf.global_variables_initializer())

首先，只需创建一些常量w1和w2即可。我们将x1乘以w1，将x2乘以w2，然后将这些中间值相加，最后将结果通过tf.sigmoid的sigmoid激活函数进行处理。查看以下屏幕快照中显示的结果：

Sigmoid function

同样，现在不必担心确切的公式，您可以拥有各种不同的激活函数。请注意，这是您迈向自己的神经网络的第一步。

那么，我们如何从单个神经元到整个网络？简单！一个神经元的输入仅成为网络下一层中另一神经元的输入。

Sigmoid function

在上图中，我们有一个简单的网络，其中有两个输入X0和X1，两个输出Y0和Y1，中间有三个神经元。 X0中的值被发送到每个N神经元，但是权重不同，该权重乘以与每个相关的X0。 X1也发送到每个神经元，并具有自己的一组权重。对于每个神经元，我们计算输入的加权总和，将其通过激活函数，然后产生中间输出。现在，我们做同样的事情，但是将神经元的输出视为Y的输入。注意，通过对输入加权和进行非线性激活，我们实际上只是为最终模型计算了一组新的特征。

现在您已经了解了 TensorFlow 中非线性转换的基础以及什么是神经网络。好吧，它们可能不会让您读懂思想，它们对于深度学习至关重要。在下一节中，我们将使用简单的神经网络来改进分类算法。

单隐藏层模型

在这里，我们将实践神经网络的基础知识。我们将逻辑回归 TenserFlow 代码改编为神经元的单个隐藏层。然后，您将学习反向传播背后的思想以计算权重，即训练网络。最后，您将在 TensorFlow 中训练您的第一个真正的神经网络。

本部分的 TensorFlow 代码应该看起来很熟悉。它只是逻辑回归代码的略微演变版本。让我们看看如何添加神经元的隐藏层，以计算输入像素的非线性组合。

您应该从全新的 Python 会话开始，执行代码以读入，并按照逻辑模型中的步骤设置数据。相同的代码，只是复制到新文件中：

import tensorflow as tf
import numpy as np
import math
from tqdm import tqdm
%autoindent
try:
    from tqdm import tqdm
except ImportError:
    def tqdm(x, *args, **kwargs):
        return x

您总是可以回到前面的部分，并提醒自己该代码的作用；直到num_hidden变量的所有内容都可以使您快速入门。

探索单隐藏层模型

现在，让我们逐步介绍单个隐藏层模型：

首先，让我们指定num_hidden = 128想要多少个神经元；最终，这实际上是将多少个非线性组合传递给逻辑对数。

为了适应这一点，我们还需要更新W1和b1权重张量的形状。他们现在正在馈送我们隐藏的神经元，因此需要匹配形状：

W1 = tf.Variable(tf.truncated_normal([1296, num_hidden],
                                   stddev=1./math.sqrt(1296)))
b1 = tf.Variable(tf.constant(0.1,shape=[num_hidden]))

我们计算加权和的激活函数的方法是使用单行h1。这是将我们的输入像素乘以每个神经元各自的权重：
```
h1 = tf.sigmoid(tf.matmul(x,W1) + b1)
```
添加神经元偏差项，最后通过sigmoid激活函数进行设置；此时，我们有 128 个中间值：
现在，这只是对您友好的逻辑回归；您已经知道该怎么办。这些新计算的 128 个特征需要它们自己的权重和偏置集来计算输出类的分数，分别为W2和b2。注意形状如何与神经元的形状 128 匹配，并且输出类的数量为 5：
```
W2 = tf.Variable(tf.truncated_normal([num_hidden, 5],
                                      stddev=1./math.sqrt(5)))
b2 = tf.Variable(tf.constant(0.1,shape=[5]))
sess.run(tf.global_variables_initializer())
```
在所有这些权重中，我们使用此奇怪的截断普通调用对其进行初始化。借助神经网络，我们希望获得良好的初始值分布，以便我们的权重可以攀升至有意义的值，而不是仅仅归零。
截断正态具有给定标准偏差的正态分布中的随机值，该研究标准按输入数量进行缩放，但抛出的值太极端，因此被截断了。定义好权重和神经元后，我们将像以前一样设置最终的softmax模型，除了需要注意使用 128 个神经元作为输入h1以及相关的权重和偏差W2和b2：
```
y = tf.nn.softmax(tf.matmul(h1,W2) + b2)
```

反向传播

训练神经网络和许多其他机器学习模型权重的关键称为反向传播。

Backpropagation

完整的推导超出了本书的范围，但是让我们直观地进行研究。当您在空中训练逻辑回归之类的模型并且训练集直接来自选择不当的权重时，您可以看到应该调整哪些权重以及应该调整多少权重并相应地更改它们。

从形式上讲，TensorFlow 通过计算空气相对于权重的导数并将权重调整为该数值的一小部分来实现此目的。反向传播实际上是同一过程的扩展。

您从最底层的输出或成本函数层开始，计算导数，然后使用它们来计算与上一层神经元相关的导数。通过将从成本到权重的路径上的导数乘积相加，我们可以计算相对于要调整的权重的成本的适当偏导数。上图中显示的公式仅说明了红色箭头显示的内容。如果这看起来很复杂，请不要担心。

TensorFlow 使用优化器在后台为您处理。由于我们使用 TensorFlow 精心指定了模型来训练模型，因此几乎与之前完全相同，因此我们将在此处使用相同的代码：

epochs = 5000
train_acc = np.zeros(epochs//10)
test_acc = np.zeros(epochs//10)
for i in tqdm(range(epochs), ascii=True):
    if i % 10 == 0: # Record summary data, and the accuracy
        # Check accuracy on train set
        A = accuracy.eval(feed_dict={x: train.reshape([-1,1296]), y_: onehot_train})
        train_acc[i//10] = A

        # And now the validation set
        A = accuracy.eval(feed_dict={x: test.reshape([-1,1296]), y_: onehot_test})
        test_acc[i//10] = A
    train_step.run(feed_dict={x: train.reshape([-1,1296]), y_: onehot_train})

需要注意的一件事是，因为我们有这些隐藏的神经元，所以有更多的权重可以拟合模型。这意味着我们的模型将需要更长的运行时间，并且必须花费更多的迭代时间才能进行训练。这次我们通过5000历时运行它：

Backpropagation

该模型可能比以前的模型花费更长的时间，可能是前一个模型的四倍。因此，您可能需要几分钟到 10 分钟的时间，具体取决于您的计算机。现在，通过模型训练，我们将在稍后查看验证准确率。

单隐藏层的说明

在本节中，我们将仔细研究构建的模型。首先，我们将验证模型的整体准确率，然后查看模型出了哪些问题。最后，我们将可视化与多个神经元相关的权重，以查看它们在寻找什么：

plt.figure(figsize=(6, 6))
plt.plot(train_acc,'bo')
plt.plot(test_acc,'rx')

确保您已经按照上一节中的步骤训练了模型，如果没有，您可能要在这里停下来并首先进行操作。由于我们每隔 10 个训练周期就评估模型的准确率并保存结果，因此现在很容易探索模型的演变方式。

使用 Matplotlib，我们可以在同一张图上绘制训练精度（蓝色点）和测试精度（红色点）：

Single hidden layer explained

同样，如果您没有 Matplotlib，那就没关系。您可以只查看数组值本身。请注意，训练精度（蓝色）通常比测试精度（红色）好一点。这并不奇怪，因为测试图像对于模型来说是全新的，并且可能包含以前看不见的特征。另外，观察精度通常会攀升到更多的周期，然后逐渐上升，然后逐渐上升。我们的模型在这里达到约 60% 的准确率；并非完美，但对简单逻辑回归进行了改进。

要查看我们的模型在哪里混淆，创建混淆矩阵会很有帮助。也就是说，我们将寻找一个可以说的实际绘图类别。该模型将其分类为什么？形式上是5x5矩阵。对于每个测试图像，如果图像实际上是类别i和模型预测类别j，则我们增加值和位置i j。请注意，当模型正确时，则为i = j。

一个好的模型在对角线上将具有很大的值，而在其他地方则没有很多。通过这种类型的分析，很容易看出两个类是否经常彼此混淆，或者模型很少选择某些类。

在以下示例中，我们通过求值y（类概率）来创建预测类：

pred = np.argmax(y.eval(feed_dict={x: 
     test.reshape([-1,1296]), y_: onehot_test}), axis = 1)
conf = np.zeros([5,5])
for p,t in zip(pred,np.argmax(onehot_test,axis=1)):
    conf[t,p] += 1

plt.matshow(conf)
plt.colorbar()

np.argmax函数提取概率最大的位置。同样，为了确定实际的类别，我们使用np.argmax撤消一次热编码。创建混乱矩阵始于全零数组，然后逐步遍历所有填充的测试数据。Matplotlib 让我们看一下彩色图像，但打印与会者的效果几乎相同：

Single hidden layer explained

在前面的输出中，我们看到模型通常做得不错，只是它很少预测类2。由于初始的随机性，您的确切结果可能看起来有些不同。

了解模型的权重

正如我们查看逻辑回归模型的权重一样，我们可以监视此模型的权重：

plt.figure(figsize=(6, 6))
f, plts = plt.subplots(4,8, sharex=True)
for i in range(32):
    plts[i//8, i%8].pcolormesh(W1.eval()[:,i].reshape([36,36]))

但是，现在我们有 128 个神经元，每个神经元的权重都来自输入像素，权重为36x36。让我们看看其中的一些，以了解他们的发现。同样，如果您没有 Matplotlib，则可以简单地打印出数组以查看相同的行为。在这里，我们将研究 128 个神经元中的 32 个。因此，让我们将子图的格式设置为四行八列。现在，我们逐步求值每个神经元的权重，并将其重塑为图像大小。双斜杠（//）使用整数除法将图像放入适当的行，而百分号（%）使用余数（实际上是模块化算术）来选择列。

Understanding weights of the model

视觉上，在前面的输出中，您可以看到一些形状突出。与它们的权重模式相比，某些神经元或多或少具有圆形形状。其他人看起来很随意，但可能会选择我们不容易理解的特征。我们也可以尝试可视化输出层的权重，但是这些不再直观。我们称其为神经网络。现在，输出逻辑回归是 128 个输入值，以及用于计算 5 个分数的权重。不再有图像结构，因为每个像素都进入了隐藏层的每个神经元。现在您知道了如何评估和解释神经网络结果。做得好！

多隐藏层模型

在本节中，我们将向您展示如何使用其他隐藏层构建更复杂的模型。我们将单层隐藏模型改编为称为深度神经网络的多层模型。然后，我们将讨论选择要使用的神经元和层数。最后，我们将耐心地训练模型本身，因为这可能需要一段时间才能计算出来。

还记得我们向逻辑回归模型添加神经元的隐藏层吗？好了，我们可以再做一次，在我们的单个隐藏层模型中添加另一层。一旦您拥有一层以上的神经元，我们就将其称为深度神经网络。但是，您以前所学的一切都可以立即应用。与本章前面的部分一样，您应该进行一个全新的 Python 会话并执行本部分代码文件中直到num_hidden1的代码。然后，乐趣开始了。

The multiple hidden layer model

探索多隐藏层模型

首先，将旧的num_hidden更改为num_hidden1，以指示第一个隐藏层上的神经元数量：

# Hidden layer 1
num_hidden1 = 128

确保更改变量，同时定义权重和偏差变量。现在，我们将插入第二个隐藏层：

W1 = tf.Variable(tf.truncated_normal([1296,num_hidden1],
                               stddev=1./math.sqrt(1296)))
b1 = tf.Variable(tf.constant(0.1,shape=[num_hidden1]))
h1 = tf.sigmoid(tf.matmul(x,W1) + b1)

这次使用带有32神经元的神经元。请注意，权重的形状必须如何解释来自上一层的 128 个中间输出中的每一个进入当前层的 32 个输入或神经元，但是我们初始化权重和偏差的方式基本上相同：

# Hidden Layer 2
num_hidden2 = 32
W2 = tf.Variable(tf.truncated_normal([num_hidden1,
            num_hidden2],stddev=2./math.sqrt(num_hidden1)))
b2 = tf.Variable(tf.constant(0.2,shape=[num_hidden2]))
h2 = tf.sigmoid(tf.matmul(h1,W2) + b2)

如您在前面的代码中所见，我们像以前一样使用sigmoid函数创建h2输出，并使用矩阵乘法，加法和函数调用。

对于输出逻辑回归层，我们只需要更新变量名称：

# Output Layer
W3 = tf.Variable(tf.truncated_normal([num_hidden2, 5],
                                   stddev=1./math.sqrt(5)))
b3 = tf.Variable(tf.constant(0.1,shape=[5]))

现在这是第三组权重，当然，此形状必须与前面的隐藏层的输出匹配，因此32 x 5：

Exploring the multiple hidden layer model

不要忘记使用h2，W3和b3变量更新y模型函数。您不想只使用旧模型就更新所有代码。

您可能想知道我们如何决定第一层的 128 个神经元和第二层的 32 个神经元。事实是，为网络确定合适的尺寸和形状可能是一个具有挑战性的问题。尽管计算可能会很昂贵，但是反复试验是开发模型的一种方法。通常，您可能会从旧模型开始并从那里开始工作。在这里，我们从 128 个神经元的单个隐藏层开始，然后尝试在其下添加一个新层。我们要计算一些特征以区分五类，因此在选择神经元数量时应牢记这一点。

通常，最好从小处着手，逐步发展到解释数据的最小模型。如果在顶层具有 128 个神经元而在下一层具有 8 个神经元的模型的效果较差，则可能表明我们需要为最后一层提供更多特征，并应添加更多而不是更少的神经元。

尝试将最后一层中的神经元数量加倍，当然，最好回到较早的层并调整那里的神经元数量。同样，您可以更改优化器的学习率，从而改变每一步调整权重的程度，甚至更改用于优化的函数。

注意

设置所有这些值称为超参数优化，这是机器学习研究中的热门话题。

请注意，我们实际上是从最简单的模型，逻辑回归开始，然后慢慢添加新的功能和结构。如果一个简单的模型运行良好，那么甚至没有必要花时间在更高级的东西上。

现在已经指定了我们的模型，让我们实际进行训练：

# Climb on cross-entropy
cross_entropy = tf.reduce_mean(
     tf.nn.softmax_cross_entropy_with_logits(logits= y + 1e-50, labels= y_))

# How we train
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

# Define accuracy
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))
accuracy=tf.reduce_mean(tf.cast(correct_prediction, "float"))

同样，我们需要在 TensorFlow 图中重新定义我们的训练节点，但是这些与以前完全相同。请注意，由于我们的第一个隐藏层现在挂接到神经元的另一层，因此我们需要计算更多的权重。以下是实际的训练代码：

epochs = 25000
train_acc = np.zeros(epochs//10)
test_acc = np.zeros(epochs//10)
for i in tqdm(range(epochs)):
    # Record summary data, and the accuracy
    if i % 10 == 0:
        # Check accuracy on train set
        A = accuracy.eval(feed_dict={
            x: train.reshape([-1,1296]),
            y_: onehot_train})
        train_acc[i//10] = A
        # And now the validation set
        A = accuracy.eval(feed_dict={
            x: test.reshape([-1,1296]),
            y_: onehot_test})
        test_acc[i//10] = A
    train_step.run(feed_dict={
        x: train.reshape([-1,1296]),
        y_: onehot_train})

以前，我们有 128 乘以 5 的权重，但是现在我们有 128 乘以 32 的权重-这是该层的六倍，这是从像素到神经元第一层的初始权重之上。深度神经网络的一个缺点是它们可能需要一段时间才能训练。在这里，我们将运行25000个周期，以确保权重收敛：

Exploring the multiple hidden layer model

这可能需要一个小时或更长时间，具体取决于您的计算机和 GPU。尽管这看起来似乎过多，但专业的机器学习研究人员通常会训练模型长达两个星期。您可能会学得很快，但是计算机需要一些时间。

在本节中，我们使用 TensorFlow 构建并训练了一个真正的深度神经网络。许多专业的机器学习模型没有您已经编写的复杂。

多隐藏层的结果

现在，我们将研究深度神经网络内部的情况。首先，我们将验证模型的准确率。然后，我们将可视化并研究像素权重。最后，我们还将查看输出权重。

训练完您的深度神经网络后，让我们看一下模型的准确率。我们将以与单隐藏层模型相同的方式进行操作。这次的唯一区别是，从更多的周期开始，我们保存了更多的训练和测试准确率样本。

和往常一样，如果您没有 Matplotlib，请不要担心。打印数组的一部分很好。

了解多隐藏层的图

执行以下代码以查看结果：

# Plot the accuracy curves
plt.figure(figsize=(6,6))
plt.plot(train_acc,'bo')
plt.plot(test_acc,'rx')

Understanding the multiple hidden layers graph

从前面的输出图中，我们可以达到约 68% 的训练精度，也许还有 63% 的验证精度。这还不错，但是确实留出了一些改进的空间。

让我们花点时间看一下准确率在许多周期如何增长。当然，它起步非常糟糕，并且存在一些最初的麻烦，但是权重是随机的，并且在那个时候仍在学习，并且在最初的数千个周期中它很快得到了改善。虽然可能会暂时卡在局部最大值中，但通常会爬出并最终减慢其重音。请注意，它仍然可以很好地进入训练阶段。只是到了尽头，模型才可能达到其最大容量。根据随机初始化，您的曲线可能看起来有些不同，但这没关系；这是您的模型，非常好。

要查看我们的模型在哪里出现问题，让我们看一下混淆矩阵：

pred = np.argmax(y.eval(feed_dict={x:
    test.reshape([-1,1296]), y_: onehot_test}), axis = 1)
conf = np.zeros([5,5])
for p,t in zip(pred,np.argmax(onehot_test,axis=1)):
    conf[t,p] += 1

plt.matshow(conf)
plt.colorbar()

同样，这与我们用于单个隐藏层模型的过程完全相同，只是在更高级的方面：

Understanding the multiple hidden layers graph

对此进行绘图，就像在前面的输出中一样，我们看到该模型总体上运行良好，但是仍然难以识别其中一个类，这次是1。我们正在逐步取得进展。验证准确率之后，让我们检查一下我们的第一层神经元，即 128 个人，发现了什么样的现象：

# Let's look at a subplot of some weights
f, plts = plt.subplots(4,8, sharex=True)
for i in range(32):
    plts[i//8, i%8].matshow(W1.eval()[:,i].reshape([36,36]))

为了简单起见，我们仅查看前 32 个此类神经元。使用与先前模型相同的代码，可以轻松地使用 Matplotlib 进行绘制或打印出来：

Understanding the multiple hidden layers graph

毫不奇怪，我们看到了许多与先前模型相同的函数。尽管在这里，由于随机初始化，即使它们看起来像是同一类型的特征，它们也会位于不同的位置。同样，您有一些环形神经元，具有非常条纹状特征的神经元，以及具有宽条纹状特征的另一个神经元。就我们的神经网络而言，圆形和条纹形状是确定字体类别的良好成分。

尽管我们其他隐藏层中的权重不再具有图像的结构，但查看输出的权重可能会很有帮助。这将告诉我们每个最终神经元对每个类别的贡献。我们可以将其绘制为热力图，或使用W3.eval任意方式打印单个数组：

# Examine the output weights
plt.matshow(W3.eval())
plt.colorbar()

因为我们仔细指定了W3，所以每一行将代表一个神经元，每一列将代表一个类：

Understanding the multiple hidden layers graph

从前面的输出图中我们可以看到，不同的神经元对某些类别的贡献要大于其他类别，这表明神经元正在计算的某些总体非线性特征与该特定字体类别有关。也就是说，虽然这些神经元产生的值用于计算每种字体的分数，但非常重要且权重较大的一种字体的神经元可能与另一种字体几乎无关。例如，对于2类，N1神经元的权重非常大，而对于所有其他类别，N1神经元的权重几乎为零。该神经元具有什么计算特征，对于2类而言非常重要，但对于其他类别而言则没有那么重要。

总结

在本章中，我们使用 TensorFlow 进行了深度学习。尽管我们从一个神经元隐藏层的简单模型开始，但是并不需要花很长时间就可以开发和训练用于字体分类问题的深度神经网络。

您了解了单层和多层隐藏层模型，并对其进行了详细了解。您还将了解神经网络的不同类型，并使用 TensorFlow 构建和训练了我们的第一个神经网络。

在下一章中，我们将使用卷积神经网络（一种用于图像分类的强大工具）来证明我们的模型。

三、卷积神经网络

在上一章中，我们探讨了深度神经网络，该神经网络需要更多的参数才能拟合。本章将指导您完成深度学习中最强大的开发之一，并让我们使用有关问题空间的一些知识来改进模型。首先，我们将解释一个神经网络中的卷积层，然后是一个 TensorFlow 示例。然后，我们将对池化层执行相同的操作。最后，我们将字体分类模型改编为卷积神经网络（CNN），然后看看它是如何工作的。

在本章中，我们将介绍卷积神经网络的背景。我们还将在 TensorFlow 中实现卷积层。我们将学习最大池化层并将其付诸实践，并以单个池化层为例。

在本章的最后，您将对以下概念有很好的控制：

卷积层动机
卷积层应用
池化层动机
池化层应用
深度 CNN
更深的 CNN
深层 CNN 总结

现在让我们进入卷积层。

卷积层动机

在本节中，我们将逐步使用示例图像上的卷积层。我们将以图形方式看到卷积只是一个滑动窗口。此外，我们将学习如何从窗口中提取多个特征以及如何接受到窗口的多层输入。

在给定神经元的神经网络的经典密集层中，每个输入特征都具有自己的权重。