精通 TensorFlow 1.x：6~10（3）-阿里云开发者社区

精通 TensorFlow 1.x：6~10（2）https://developer.aliyun.com/article/1426820

一旦模型被训练，我们用 2 个不同的字符串作为生成更多字符的种子来测试它：

random5：随机选择 5 个单词生成的字符串。
first5：从文本的前 5 个单词生成的字符串。

random5 = np.random.choice(n_x * 50, n_x, replace=False)
print('Random 5 words: ',id2string(random5))
first5 = text8.part['train'][0:n_x].copy()
print('First 5 words: ',id2string(first5))

我们看到种子串是：

Random 5 words:  free bolshevik be n another
First 5 words:  anarchism originated as a term

对于您的执行，随机种子字符串可能不同。

现在让我们首先在 TensorFlow 中创建 LSTM 模型。

TensorFlow 中的 LSTM 和文本生成

您可以在 Jupyter 笔记本ch-08b_RNN_Text_TensorFlow中按照本节的代码进行操作。

我们使用以下步骤在 TensorFlow 中实现文本生成 LSTM：

让我们为x和y定义参数和占位符：

batch_size = 128
n_x = 5 # number of input words
n_y = 1 # number of output words
n_x_vars = 1 # in case of our text, there is only 1 variable at each timestep
n_y_vars = text8.vocab_len
state_size = 128
learning_rate = 0.001
x_p = tf.placeholder(tf.float32, [None, n_x, n_x_vars], name='x_p') 
y_p = tf.placeholder(tf.float32, [None, n_y_vars], name='y_p')

对于输入，我们使用单词的整数表示，因此n_x_vars是 1。对于输出，我们使用单热编码值，因此输出的数量等于词汇长度。

接下来，创建一个长度为n_x的张量列表：

x_in = tf.unstack(x_p,axis=1,name='x_in')

接下来，从输入和单元创建 LSTM 单元和静态 RNN 网络：

cell = tf.nn.rnn_cell.LSTMCell(state_size)
rnn_outputs, final_states = tf.nn.static_rnn(cell, x_in,dtype=tf.float32)

接下来，我们定义最终层的权重，偏差和公式。最后一层只需要为第六个单词选择输出，因此我们应用以下公式来仅获取最后一个输出：

# output node parameters
w = tf.get_variable('w', [state_size, n_y_vars], initializer= tf.random_normal_initializer)
b = tf.get_variable('b', [n_y_vars], initializer=tf.constant_initializer(0.0))
y_out = tf.matmul(rnn_outputs[-1], w) + b

接下来，创建一个损失函数和优化器：

loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
        logits=y_out, labels=y_p))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
            .minimize(loss)

创建我们可以在会话块中运行的准确率函数，以检查训练模式的准确率：

n_correct_pred = tf.equal(tf.argmax(y_out,1), tf.argmax(y_p,1))
accuracy = tf.reduce_mean(tf.cast(n_correct_pred, tf.float32))

最后，我们训练模型 1000 个周期，并每 100 个周期打印结果。此外，每 100 个周期，我们从上面描述的种子字符串打印生成的文本。

LSTM 和 RNN 网络需要对大量数据集进行大量周期的训练，以获得更好的结果。请尝试加载完整的数据集并在计算机上运行 50,000 或 80,000 个周期，并使用其他超参数来改善结果。

n_epochs = 1000
learning_rate = 0.001
text8.reset_index_in_epoch()
n_batches = text8.n_batches_seq(batch_size=batch_size,n_tx=n_x,n_ty=n_y)
n_epochs_display = 100
with tf.Session() as tfs:
    tf.global_variables_initializer().run()
    for epoch in range(n_epochs):
        epoch_loss = 0
        epoch_accuracy = 0
        for step in range(n_batches):
            x_batch, y_batch = text8.next_batch_seq(batch_size=batch_size,
                                n_tx=n_x,n_ty=n_y)
            y_batch = dsu.to2d(y_batch,unit_axis=1)
            y_onehot = np.zeros(shape=[batch_size,text8.vocab_len],
                        dtype=np.float32)
            for i in range(batch_size):
                y_onehot[i,y_batch[i]]=1
            feed_dict = {x_p: x_batch.reshape(-1, n_x, n_x_vars), 
                         y_p: y_onehot}
            _, batch_accuracy, batch_loss = tfs.run([optimizer,accuracy,
                                            loss],feed_dict=feed_dict)
            epoch_loss += batch_loss
            epoch_accuracy += batch_accuracy
        if (epoch+1) % (n_epochs_display) == 0:
            epoch_loss = epoch_loss / n_batches
            epoch_accuracy = epoch_accuracy / n_batches
            print('\nEpoch {0:}, Average loss:{1:}, Average accuracy:{2:}'.
                    format(epoch,epoch_loss,epoch_accuracy ))
            y_pred_r5 = np.empty([10])
            y_pred_f5 = np.empty([10])
            x_test_r5 = random5.copy()
            x_test_f5 = first5.copy()
            # let us generate text of 10 words after feeding 5 words
            for i in range(10):
                for x,y in zip([x_test_r5,x_test_f5],
                               [y_pred_r5,y_pred_f5]):
                    x_input = x.copy()
                    feed_dict = {x_p: x_input.reshape(-1, n_x, n_x_vars)}
                    y_pred = tfs.run(y_out, feed_dict=feed_dict)
                    y_pred_id = int(tf.argmax(y_pred, 1).eval())
                    y[i]=y_pred_id
                    x[:-1] = x[1:]
                    x[-1] = y_pred_id
            print(' Random 5 prediction:',id2string(y_pred_r5))
            print(' First 5 prediction:',id2string(y_pred_f5))

结果如下：

Epoch 99, Average loss:1.3972469369570415, Average accuracy:0.8489583333333334
  Random 5 prediction: labor warren together strongly profits strongly supported supported co without
  First 5 prediction: market own self free together strongly profits strongly supported supported
Epoch 199, Average loss:0.7894854595263799, Average accuracy:0.9186197916666666
  Random 5 prediction: syndicalists spanish class movements also also anarcho anarcho anarchist was
  First 5 prediction: five civil association class movements also anarcho anarcho anarcho anarcho
Epoch 299, Average loss:1.360412875811259, Average accuracy:0.865234375
  Random 5 prediction: anarchistic beginnings influenced true tolstoy tolstoy tolstoy tolstoy tolstoy tolstoy
  First 5 prediction: early civil movement be for was two most most most
Epoch 399, Average loss:1.1692512730757396, Average accuracy:0.8645833333333334
  Random 5 prediction: including war than than revolutionary than than war than than
  First 5 prediction: left including including including other other other other other other
Epoch 499, Average loss:0.5921860883633295, Average accuracy:0.923828125
  Random 5 prediction: ever edited interested interested variety variety variety variety variety variety
  First 5 prediction: english market herbert strongly price interested variety variety variety variety
Epoch 599, Average loss:0.8356450994809469, Average accuracy:0.8958333333333334
  Random 5 prediction: management allow trabajo trabajo national national mag mag ricardo ricardo
  First 5 prediction: spain prior am working n war war war self self
Epoch 699, Average loss:0.7057955612738928, Average accuracy:0.8971354166666666
  Random 5 prediction: teachings can directive tend resist obey christianity author christianity christianity
  First 5 prediction: early early called social called social social social social social
Epoch 799, Average loss:0.772875706354777, Average accuracy:0.90234375
  Random 5 prediction: associated war than revolutionary revolutionary revolutionary than than revolutionary revolutionary
  First 5 prediction: political been hierarchy war than see anti anti anti anti
Epoch 899, Average loss:0.43675946692625683, Average accuracy:0.9375
  Random 5 prediction: individualist which which individualist warren warren tucker benjamin how tucker
  First 5 prediction: four at warren individualist warren published considered considered considered considered
Epoch 999, Average loss:0.23202441136042276, Average accuracy:0.9602864583333334
  Random 5 prediction: allow allow trabajo you you you you you you you
  First 5 prediction: labour spanish they they they movement movement anarcho anarcho two

生成的文本中的重复单词是常见的，并且应该更好地训练模型。虽然模型的准确率提高到 96%，但仍然不足以生成清晰的文本。尝试增加 LSTM 单元/隐藏层的数量，同时在较大的数据集上运行模型以获取大量周期。

现在让我们在 Keras 建立相同的模型：

Keras 中的 LSTM 和文本生成

您可以在 Jupyter 笔记本ch-08b_RNN_Text_Keras中按照本节的代码进行操作。

我们在 Keras 实现文本生成 LSTM，步骤如下：

首先，我们将所有数据转换为两个张量，张量x有五列，因为我们一次输入五个字，张量y只有一列输出。我们将y或标签张量转换为单热编码表示。

请记住，在大型数据集的实践中，您将使用 word2vec 嵌入而不是单热表示。

# get the data
x_train, y_train = text8.seq_to_xy(seq=text8.part['train'],n_tx=n_x,n_ty=n_y)
# reshape input to be [samples, time steps, features]
x_train = x_train.reshape(x_train.shape[0], x_train.shape[1],1)
y_onehot = np.zeros(shape=[y_train.shape[0],text8.vocab_len],dtype=np.float32)
for i in range(y_train.shape[0]):
    y_onehot[i,y_train[i]]=1

接下来，仅使用一个隐藏的 LSTM 层定义 LSTM 模型。由于我们的输出不是序列，我们还将return_sequences设置为False：

n_epochs = 1000
batch_size=128
state_size=128
n_epochs_display=100
# create and fit the LSTM model
model = Sequential()
model.add(LSTM(units=state_size,
                input_shape=(x_train.shape[1], x_train.shape[2]),
                return_sequences=False
                )
          )
model.add(Dense(text8.vocab_len))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam')
model.summary()

该模型如下所示：

Layer (type)                 Output Shape              Param #   
=================================================================
lstm_1 (LSTM)                (None, 128)               66560     
_________________________________________________________________
dense_1 (Dense)              (None, 1457)              187953    
_________________________________________________________________
activation_1 (Activation)    (None, 1457)              0         
=================================================================
Total params: 254,513
Trainable params: 254,513
Non-trainable params: 0
_________________________________________________________________

对于 Keras，我们运行一个循环来运行 10 次，在每次迭代中训练 100 个周期的模型并打印文本生成的结果。以下是训练模型和生成文本的完整代码：

for j in range(n_epochs // n_epochs_display):
     model.fit(x_train, y_onehot, epochs=n_epochs_display,
                         batch_size=batch_size,verbose=0)
     # generate text
     y_pred_r5 = np.empty([10])
     y_pred_f5 = np.empty([10])
     x_test_r5 = random5.copy()
     x_test_f5 = first5.copy()
     # let us generate text of 10 words after feeding 5 words
     for i in range(10):
         for x,y in zip([x_test_r5,x_test_f5],
                        [y_pred_r5,y_pred_f5]):
             x_input = x.copy()
             x_input = x_input.reshape(-1, n_x, n_x_vars)
             y_pred = model.predict(x_input)[0]
             y_pred_id = np.argmax(y_pred)
             y[i]=y_pred_id
             x[:-1] = x[1:]
             x[-1] = y_pred_id
     print('Epoch: ',((j+1) * n_epochs_display)-1)
     print(' Random5 prediction:',id2string(y_pred_r5))
     print(' First5 prediction:',id2string(y_pred_f5))

输出并不奇怪，从重复单词开始，模型有所改进，但是可以通过更多 LSTM 层，更多数据，更多训练迭代和其他超参数调整来进一步提高。

Random 5 words: free bolshevik be n another 
First 5 words: anarchism originated as a term

预测的输出如下：

Epoch: 99 
    Random5 prediction: anarchistic anarchistic wrote wrote wrote wrote wrote wrote wrote wrote 
    First5 prediction: right philosophy than than than than than than than than 
Epoch: 199 
    Random5 prediction: anarchistic anarchistic wrote wrote wrote wrote wrote wrote wrote wrote 
    First5 prediction: term i revolutionary than war war french french french french 
Epoch: 299 
    Random5 prediction: anarchistic anarchistic wrote wrote wrote wrote wrote wrote wrote wrote 
    First5 prediction: term i revolutionary revolutionary revolutionary revolutionary revolutionary revolutionary revolutionary revolutionary 
Epoch: 399 
    Random5 prediction: anarchistic anarchistic wrote wrote wrote wrote wrote wrote wrote wrote 
    First5 prediction: term i revolutionary labor had had french french french french 
Epoch: 499 
    Random5 prediction: anarchistic anarchistic amongst wrote wrote wrote wrote wrote wrote wrote 
    First5 prediction: term i revolutionary labor individualist had had french french french 
Epoch: 599 
    Random5 prediction: tolstoy wrote tolstoy wrote wrote wrote wrote wrote wrote wrote     First5 prediction: term i revolutionary labor individualist had had had had had 
Epoch: 699 
    Random5 prediction: tolstoy wrote tolstoy wrote wrote wrote wrote wrote wrote wrote     First5 prediction: term i revolutionary labor individualist had had had had had 
Epoch: 799 
    Random5 prediction: tolstoy wrote tolstoy tolstoy tolstoy tolstoy tolstoy tolstoy tolstoy tolstoy 
    First5 prediction: term i revolutionary labor individualist had had had had had 
Epoch: 899 
    Random5 prediction: tolstoy wrote tolstoy tolstoy tolstoy tolstoy tolstoy tolstoy tolstoy tolstoy 
    First5 prediction: term i revolutionary labor should warren warren warren warren warren 
Epoch: 999 
    Random5 prediction: tolstoy wrote tolstoy tolstoy tolstoy tolstoy tolstoy tolstoy tolstoy tolstoy 
    First5 prediction: term i individualist labor should warren warren warren warren warren

如果您注意到我们在 LSTM 模型的输出中有重复的单词用于文本生成。虽然超参数和网络调整可以消除一些重复，但还有其他方法可以解决这个问题。我们得到重复单词的原因是模型总是从单词的概率分布中选择具有最高概率的单词。这可以改变以选择诸如在连续单词之间引入更大可变性的单词。

总结

在本章中，我们学习了单词嵌入的方法，以找到更好的文本数据元素表示。随着神经网络和深度学习摄取大量文本数据，单热表示和其他单词表示方法变得低效。我们还学习了如何使用 t-SNE 图来可视化文字嵌入。我们使用简单的 LSTM 模型在 TensorFlow 和 Keras 中生成文本。类似的概念可以应用于各种其他任务，例如情感分析，问答和神经机器翻译。

在我们深入研究先进的 TensorFlow 功能（如迁移学习，强化学习，生成网络和分布式 TensorFlow）之前，我们将在下一章中看到如何将 TensorFlow 模型投入生产。

九、TensorFlow 和 Keras 中的 CNN

卷积神经网络（CNN）是一种特殊的前馈神经网络，在其架构中包含卷积和汇聚层。也称为 ConvNets，CNN 架构的一般模式是按以下顺序包含这些层：

完全连接的输入层
卷积，池化和全连接层的多种组合
完全连接的输出层，具有 softmax 激活函数

CNN 架构已被证明在解决涉及图像学习的问题（例如图像识别和对象识别）方面非常成功。

在本章中，我们将学习与卷积网络相关的以下主题：

理解卷积
理解池化
CNN 架构模式 - LeNet
用于 MNIST 数据集的 LeNet

使用 TensorFlow 和 MNIST 的 LeNet
使用 Keras 和 MNIST 的 LeNet

用于 CIFAR 数据集的 LeNet

使用 TensorFlow 和 CIFAR10 的 LeNet CNN
使用 Keras 和 CIFAR10 的 LeNet CNN

让我们从学习卷积网络背后的核心概念开始。

理解卷积

卷积是 CNN 架构背后的核心概念。简单来说，卷积是一种数学运算，它结合了两个来源的信息来产生一组新的信息。具体来说，它将一个称为内核的特殊矩阵应用于输入张量，以产生一组称为特征图的矩阵。可以使用任何流行的算法将内核应用于输入张量。

生成卷积矩阵的最常用算法如下：

N_STRIDES = [1,1]
1\. Overlap the kernel with the top-left cells of the image matrix.
2\. Repeat while the kernel overlaps the image matrix:
    2.1 c_col = 0
    2.2 Repeat while the kernel overlaps the image matrix:
        2.1.1 set c_row = 0        2.1.2 convolved_scalar = scalar_prod(kernel, overlapped cells)
        2.1.3 convolved_matrix(c_row,c_col) = convolved_scalar
        2.1.4 Slide the kernel down by N_STRIDES[0] rows.
        2.1.5 c_row = c_row  + 1
    2.3 Slide the kernel to (topmost row, N_STRIDES[1] columns right)
    2.4 c_col = c_col + 1

例如，我们假设核矩阵是2 x 2矩阵，输入图像是3 x 3矩阵。下图逐步显示了上述算法：


[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QpWK3vWN-1681566456881)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/mastering-tf-1x-zh/img/12748d18-c1b3-49c4-8376-208a077c6116.png)]	[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FGhtdwSV-1681566456881)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/mastering-tf-1x-zh/img/27bc51c5-60bc-4cd0-b030-7253ca8072f6.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jAMVVCNt-1681566456881)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/mastering-tf-1x-zh/img/1f39630a-7dcf-4fd2-8f38-e5cc1123125c.png)]	[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BEgeoOWZ-1681566456882)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/mastering-tf-1x-zh/img/d613bdcd-7ecd-425d-9941-003500a98adf.png)]

在卷积操作结束时，我们得到以下特征图：


-6	-8
-12	-14

在上面的示例中，与卷积的原始输入相比，生成的特征映射的大小更小。通常，特征图的大小减小（内核大小减 1）。因此，特征图的大小为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JQwhxlhv-1681566456882)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/mastering-tf-1x-zh/img/0bc241d0-3c55-481f-8687-fb8da66ffa09.png)]

三维张量

对于具有额外深度尺寸的三维张量，您可以将前面的算法视为应用于深度维度中的每个层。将卷积应用于 3D 张量的输出也是 2D 张量，因为卷积运算添加了三个通道。

步幅

数组N_STRIDES中的步长是您想要将内核滑过的行或列的数字。在我们的例子中，我们使用了 1 的步幅。如果我们使用更多的步幅，那么特征图的大小将根据以下等式进一步减小：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NIAh3g4P-1681566456882)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/mastering-tf-1x-zh/img/6db06a54-de55-4fc3-a0c5-485fcf4b35b2.png)]

填充

如果我们不希望减小特征映射的大小，那么我们可以在输入的所有边上使用填充，使得特征的大小增加填充大小的两倍。使用填充，可以按如下方式计算特征图的大小：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j9smkKYX-1681566456883)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/mastering-tf-1x-zh/img/f3a81e63-5d7a-4e84-9c0b-bf2eb6e1f284.png)]

TensorFlow 允许两种填充：SAME或VALID。 SAME填充意味着添加填充，使输出特征图与输入特征具有相同的大小。 VALID填充意味着没有填充。

应用前面提到的卷积算法的结果是特征图，是原始张量的滤波版本。例如，特征图可能只有从原始图像中过滤出的轮廓。因此，内核也称为过滤器。对于每个内核，您将获得单独的 2D 特征图。

根据您希望网络学习的特征，您必须应用适当的过滤器来强调所需的特征。但是，使用 CNN，模型可以自动了解哪些内核在卷积层中最有效。

TensorFlow 中的卷积运算

TensorFlow 提供实现卷积算法的卷积层。例如，具有以下签名的tf.nn.conv2d()操作：

tf.nn.conv2d(
  input,
  filter,
  strides,
  padding,
  use_cudnn_on_gpu=None,
  data_format=None,
  name=None
)

input和filter表示形状[batch_size, input_height, input_width, input_depth]的数据张量和形状[filter_height, filter_width, input_depth, output_depth]的核张量。内核张量中的output_depth表示应该应用于输入的内核数量。strides张量表示每个维度中要滑动的单元数。如上所述，padding是有效的或相同的。

您可以在此链接中找到有关 TensorFlow 中可用卷积操作的更多信息

您可以在此链接中找到有关 Keras 中可用卷积层的更多信息

此链接提供了卷积的详细数学解释：

http://colah.github.io/posts/2014-07-Understanding-Convolutions/

http://ufldl.stanford.edu/tutorial/supervised/FeatureExtractionUsingConvolution/

http://colah.github.io/posts/2014-07-Understanding-Convolutions/

卷积层或操作将输入值或神经元连接到下一个隐藏层神经元。每个隐藏层神经元连接到与内核中元素数量相同数量的输入神经元。所以在前面的例子中，内核有 4 个元素，因此隐藏层神经元连接到输入层的 4 个神经元（3×3 个神经元中）。在我们的例子中，输入层的 4 个神经元的这个区域被称为 CNN 理论中的感受域。

卷积层具有每个内核的单独权重和偏差参数。权重参数的数量等于内核中元素的数量，并且只有一个偏差参数。内核的所有连接共享相同的权重和偏差参数。因此在我们的例子中，将有 4 个权重参数和 1 个偏差参数，但如果我们在卷积层中使用 5 个内核，则总共将有5 x 4个权重参数和5 x 1个偏差参数（每个特征图 4 个权重，1 个偏差）。

理解池化

通常，在卷积操作中，应用几个不同的内核，这导致生成若干特征映射。因此，卷积运算导致生成大尺寸数据集。

例如，将形状为3 x 3 x 1的内核应用于具有28 x 28 x 1像素形状的图像的 MNIST 数据集，可生成形状为26 x 26 x 1的特征映射。如果我们在其中应用 32 个这样的滤波器卷积层，则输出的形状为32 x 26 x 26 x 1，即形状为26 x 26 x 1的 32 个特征图。

与形状为28 x 28 x 1的原始数据集相比，这是一个庞大的数据集。因此，为了简化下一层的学习，我们应用池化的概念。

聚合是指计算卷积特征空间区域的聚合统计量。两个最受欢迎的聚合统计数据是最大值和平均值。应用最大池化的输出是所选区域的最大值，而应用平均池的输出是区域中数字的平均值。

例如，假设特征图的形状为3 x 3，池化区域形状为2 x 2。以下图像显示了使用[1, 1]的步幅应用的最大池操作：


[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hTXGCIMk-1681566456883)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/mastering-tf-1x-zh/img/c4bea549-7ee7-491c-9ad7-37ccb55dbf2e.png)]	[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gaA4GOmx-1681566456883)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/mastering-tf-1x-zh/img/4cea41c9-7a13-4e8d-bbec-d7d36ecf69b5.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-agOQ9oob-1681566456883)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/mastering-tf-1x-zh/img/efdcb6bb-da73-40ea-ab75-88008b176d48.png)]	[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mkB9yDTv-1681566456884)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/mastering-tf-1x-zh/img/4c1f8231-e6d4-4bde-9cdf-2332accbb66d.png)]

在最大池操作结束时，我们得到以下矩阵：


5	6
8	9

通常，池化操作应用非重叠区域，因此步幅张量和区域张量被设置为相同的值。

例如，TensorFlow 具有以下签名的max_pooling操作：

max_pool(
  value,
  ksize,
  strides,
  padding,
  data_format='NHWC',
  name=None
)

value表示形状[batch_size, input_height, input_width, input_depth]的输入张量。对矩形形状区域ksize执行合并操作。这些区域被形状strides抵消。

您可以在此链接中找到有关 TensorFlow 中可用的池化操作的更多信息

有关 Keras 中可用池化的更多信息，请访问此链接

此链接提供了池化的详细数学说明

CNN 架构模式 - LeNet

LeNet 是实现 CNN 的流行架构模式。在本章中，我们将学习如何通过按以下顺序创建层来构建基于 LeNet 模式的 CNN 模型：

输入层
卷积层 1，它产生一组特征映射，具有 ReLU 激活
池化层 1 产生一组统计聚合的特征映射
卷积层 2，其产生一组特征映射，具有 ReLU 激活
池化层 2 产生一组统计聚合的特征映射
完全连接的层，通过 ReLU 激活来展平特征图
通过应用简单线性激活产生输出的输出层

LeNet 系列模型由 Yann LeCun 及其研究员介绍。有关 LeNet 系列模型的更多详细信息，请访问此链接。

Yann LeCun 通过此链接维护 LeNet 系列模型列表。

用于 MNIST 数据的 LeNet

您可以按照 Jupyter 笔记本中的代码ch-09a_CNN_MNIST_TF_and_Keras。

准备 MNIST 数据到测试和训练集：

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets(os.path.join('.','mnist'), one_hot=True)
X_train = mnist.train.images
X_test = mnist.test.images
Y_train = mnist.train.labels
Y_test = mnist.test.labels

TensorFlow 中的用于 MNIST 的 LeNet CNN

在 TensorFlow 中，应用以下步骤为 MNIST 数据构建基于 LeNet 的 CNN 模型：

定义超参数，以及 x 和 y 的占位符（输入图像和输出标签）：

n_classes = 10 # 0-9 digits
n_width = 28
n_height = 28
n_depth = 1
n_inputs = n_height * n_width * n_depth # total pixels
learning_rate = 0.001
n_epochs = 10
batch_size = 100
n_batches = int(mnist.train.num_examples/batch_size)
# input images shape: (n_samples,n_pixels)
x = tf.placeholder(dtype=tf.float32, name="x", shape=[None, n_inputs]) 
# output labels
y = tf.placeholder(dtype=tf.float32, name="y", shape=[None, n_classes])

将输入 x 重塑为形状(n_samples, n_width, n_height, n_depth)：

x_ = tf.reshape(x, shape=[-1, n_width, n_height, n_depth])

使用形状为4 x 4的 32 个内核定义第一个卷积层，从而生成 32 个特征图。

首先，定义第一个卷积层的权重和偏差。我们使用正态分布填充参数：

layer1_w = tf.Variable(tf.random_normal(shape=[4,4,n_depth,32],
            stddev=0.1),name='l1_w')
layer1_b = tf.Variable(tf.random_normal([32]),name='l1_b')

接下来，用tf.nn.conv2d函数定义卷积层。函数参数stride定义了内核张量在每个维度中应该滑动的元素。维度顺序由data_format确定，可以是'NHWC'或'NCHW'（默认为'NHWC'）。
通常，stride中的第一个和最后一个元素设置为 1。函数参数padding可以是SAME或VALID。SAMEpadding表示输入将用零填充，以便在卷积后输出与输入的形状相同。使用tf.nn.relu()函数添加relu激活：

layer1_conv = tf.nn.relu(tf.nn.conv2d(x_,layer1_w,
                                      strides=[1,1,1,1],
                                      padding='SAME'
                                     ) + 
                         layer1_b 
                        )

使用tf.nn.max_pool()函数定义第一个池化层。参数ksize表示使用2×2×1个区域的合并操作，参数stride表示将区域滑动2×2×1个像素。因此，区域彼此不重叠。由于我们使用max_pool，池化操作选择2 x 2 x 1区域中的最大值：

layer1_pool = tf.nn.max_pool(layer1_conv,ksize=[1,2,2,1],
                 strides=[1,2,2,1],padding='SAME')

第一个卷积层产生 32 个大小为28 x 28 x 1的特征图，然后池化成32 x 14 x 14 x 1的数据。

定义第二个卷积层，它将此数据作为输入并生成 64 个特征图。

首先，定义第二个卷积层的权重和偏差。我们用正态分布填充参数：

layer2_w = tf.Variable(tf.random_normal(shape=[4,4,32,64],
           stddev=0.1),name='l2_w')
layer2_b = tf.Variable(tf.random_normal([64]),name='l2_b')

接下来，用tf.nn.conv2d函数定义卷积层：

layer2_conv = tf.nn.relu(tf.nn.conv2d(layer1_pool,
                                      layer2_w,
                                      strides=[1,1,1,1],
                                      padding='SAME'
                                     ) + 
                          layer2_b
                        )

用tf.nn.max_pool函数定义第二个池化层：

layer2_pool = tf.nn.max_pool(layer2_conv,
                             ksize=[1,2,2,1],
                             strides=[1,2,2,1],
                             padding='SAME'
                            )

第二卷积层的输出形状为64×14×14×1，然后池化成64×7×7×1的形状的输出。

在输入 1024 个神经元的完全连接层之前重新整形此输出，以产生大小为 1024 的扁平输出：

layer3_w = tf.Variable(tf.random_normal(shape=[64*7*7*1,1024],
                       stddev=0.1),name='l3_w')
layer3_b = tf.Variable(tf.random_normal([1024]),name='l3_b')
layer3_fc = tf.nn.relu(tf.matmul(tf.reshape(layer2_pool,
            [-1, 64*7*7*1]),layer3_w) + layer3_b)

完全连接层的输出馈入具有 10 个输出的线性输出层。我们在这一层没有使用 softmax，因为我们的损失函数自动将 softmax 应用于输出：

layer4_w = tf.Variable(tf.random_normal(shape=[1024, n_classes],
                                        stddev=0.1),name='l)
layer4_b = tf.Variable(tf.random_normal([n_classes]),name='l4_b')
layer4_out = tf.matmul(layer3_fc,layer4_w)+layer4_b

这创建了我们保存在变量model中的第一个 CNN 模型：

model = layer4_out

鼓励读者探索具有不同超参数值的 TensorFlow 中可用的不同卷积和池操作符。

为了定义损失，我们使用tf.nn.softmax_cross_entropy_with_logits函数，对于优化器，我们使用AdamOptimizer函数。您应该尝试探索 TensorFlow 中可用的不同优化器函数。

entropy = tf.nn.softmax_cross_entropy_with_logits(logits=model, labels=y)
loss = tf.reduce_mean(entropy)
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss)

最后，我们通过迭代n_epochs来训练模型，并且在n_batches上的每个周期列中，每批batch_size的大小：

with tf.Session() as tfs:
    tf.global_variables_initializer().run()
    for epoch in range(n_epochs):
        total_loss = 0.0
        for batch in range(n_batches):
            batch_x,batch_y = mnist.train.next_batch(batch_size)
            feed_dict={x:batch_x, y: batch_y}
            batch_loss,_ = tfs.run([loss, optimizer],
                                   feed_dict=feed_dict)
            total_loss += batch_loss 
        average_loss = total_loss / n_batches
        print("Epoch: {0:04d} loss = {1:0.6f}".format(epoch,average_loss))
    print("Model Trained.")
    predictions_check = tf.equal(tf.argmax(model,1),tf.argmax(y,1))
    accuracy = tf.reduce_mean(tf.cast(predictions_check, tf.float32))
    feed_dict = {x:mnist.test.images, y:mnist.test.labels}
    print("Accuracy:", accuracy.eval(feed_dict=feed_dict))

我们得到以下输出：

Epoch: 0000   loss = 1.418295
Epoch: 0001   loss = 0.088259
Epoch: 0002   loss = 0.055410
Epoch: 0003   loss = 0.042798
Epoch: 0004   loss = 0.030471
Epoch: 0005   loss = 0.023837
Epoch: 0006   loss = 0.019800
Epoch: 0007   loss = 0.015900
Epoch: 0008   loss = 0.012918
Epoch: 0009   loss = 0.010322
Model Trained.
Accuracy: 0.9884

现在，与我们在前几章中看到的方法相比，这是一个非常好的准确率。从图像数据中学习 CNN 模型是不是很神奇？

Keras 中的用于 MNIST 的 LeNet CNN

让我们重新审视具有相同数据集的相同 LeNet 架构，以在 Keras 中构建和训练 CNN 模型：

导入所需的 Keras 模块：

import keras
from keras.models import Sequential
from keras.layers import Conv2D,MaxPooling2D, Dense, Flatten, Reshape
from keras.optimizers import SGD

定义每个层的过滤器数量：

n_filters=[32,64]

定义其他超参数：

learning_rate = 0.01
n_epochs = 10
batch_size = 100

定义顺序模型并添加层以将输入数据重新整形为形状(n_width,n_height,n_depth)：

model = Sequential()
model.add(Reshape(target_shape=(n_width,n_height,n_depth), 
                  input_shape=(n_inputs,))
         )

使用4 x 4内核过滤器，SAME填充和relu激活添加第一个卷积层：

model.add(Conv2D(filters=n_filters[0],kernel_size=4, 
                 padding='SAME',activation='relu') 
         )

添加区域大小为2 x 2且步长为2 x 2的池化层：

model.add(MaxPooling2D(pool_size=(2,2),strides=(2,2)))

以与添加第一层相同的方式添加第二个卷积和池化层：

model.add(Conv2D(filters=n_filters[1],kernel_size=4, 
                 padding='SAME',activation='relu') 
         )
model.add(MaxPooling2D(pool_size=(2,2),strides=(2,2)))

添加层以展平第二个层的输出和 1024 个神经元的完全连接层，以处理展平的输出：

model.add(Flatten())
model.add(Dense(units=1024, activation='relu'))

使用softmax激活添加最终输出层：

model.add(Dense(units=n_outputs, activation='softmax'))

使用以下代码查看模型摘要：

model.summary()

该模型描述如下：

Layer (type)                 Output Shape              Param #   
=================================================================
reshape_1 (Reshape)          (None, 28, 28, 1)         0         
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 28, 28, 32)        544       
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 14, 14, 32)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 14, 14, 64)        32832     
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 7, 7, 64)          0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 3136)              0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              3212288   
_________________________________________________________________
dense_2 (Dense)              (None, 10)                10250     
=================================================================
Total params: 3,255,914
Trainable params: 3,255,914
Non-trainable params: 0
_________________________________________________________________

编译，训练和评估模型：

model.compile(loss='categorical_crossentropy',
              optimizer=SGD(lr=learning_rate),
              metrics=['accuracy'])
model.fit(X_train, Y_train,batch_size=batch_size,
          epochs=n_epochs)
score = model.evaluate(X_test, Y_test)
print('\nTest loss:', score[0])
print('Test accuracy:', score[1])

我们得到以下输出：

Epoch 1/10
55000/55000 [===================] - 267s - loss: 0.8854 - acc: 0.7631   
Epoch 2/10
55000/55000 [===================] - 272s - loss: 0.2406 - acc: 0.9272   
Epoch 3/10
55000/55000 [===================] - 267s - loss: 0.1712 - acc: 0.9488   
Epoch 4/10
55000/55000 [===================] - 295s - loss: 0.1339 - acc: 0.9604   
Epoch 5/10
55000/55000 [===================] - 278s - loss: 0.1112 - acc: 0.9667   
Epoch 6/10
55000/55000 [===================] - 279s - loss: 0.0957 - acc: 0.9714   
Epoch 7/10
55000/55000 [===================] - 316s - loss: 0.0842 - acc: 0.9744   
Epoch 8/10
55000/55000 [===================] - 317s - loss: 0.0758 - acc: 0.9773   
Epoch 9/10
55000/55000 [===================] - 285s - loss: 0.0693 - acc: 0.9790   
Epoch 10/10
55000/55000 [===================] - 217s - loss: 0.0630 - acc: 0.9804
Test loss: 0.0628845927377
Test accuracy: 0.9785

准确率的差异可归因于我们在这里使用 SGD 优化器这一事实，它没有实现我们用于 TensorFlow 模型的AdamOptimizer提供的一些高级功能。

用于 CIFAR10 数据的 LeNet

现在我们已经学会了使用 TensorFlow 和 Keras 的 MNIST 数据集构建和训练 CNN 模型，让我们用 CIFAR10 数据集重复练习。

CIFAR-10 数据集包含 60,000 个32x32像素形状的 RGB 彩色图像。图像被平均分为 10 个不同的类别或类别：飞机，汽车，鸟，猫，鹿，狗，青蛙，马，船和卡车。 CIFAR-10 和 CIFAR-100 是包含 8000 万个图像的大图像数据集的子集。 CIFAR 数据集由 Alex Krizhevsky，Vinod Nair 和 Geoffrey Hinton 收集和标记。数字 10 和 100 表示图像类别的数量。

有关 CIFAR 数据集的更多详细信息，请访问此链接：

http://www.cs.toronto.edu/~kriz/cifar.html

和

http://www.cs.toronto.edu/~kriz/learning-features-2009-TR.pdf

我们选择了 CIFAR 10，因为它有 3 个通道，即图像的深度为 3，而 MNIST 数据集只有一个通道。为了简洁起见，我们将详细信息留给下载并将数据拆分为训练和测试集，并在本书代码包中的datasetslib包中提供代码。

您可以按照 Jupyter 笔记本中的代码ch-09b_CNN_CIFAR10_TF_and_Keras。

我们使用以下代码加载和预处理 CIFAR10 数据：

from datasetslib.cifar import cifar10
from datasetslib import imutil
dataset = cifar10()
dataset.x_layout=imutil.LAYOUT_NHWC
dataset.load_data()
dataset.scaleX()

加载数据使得图像采用'NHWC'格式，使数据变形（number_of_samples, image_height, image_width, image_channels）。我们将图像通道称为图像深度。图像中的每个像素是 0 到 255 之间的数字。使用 MinMax 缩放来缩放数据集，以通过将所有像素值除以 255 来标准化图像。

加载和预处理的数据在数据集对象变量中可用作dataset.X_train，dataset.Y_train，dataset.X_test和dataset.Y_test。

TensorFlow 中的用于 CIFAR10 的卷积网络

我们保持层，滤波器及其大小与之前的 MNIST 示例中的相同，增加了一个正则化层。由于此数据集与 MNIST 相比较复杂，因此我们为正则化目的添加了额外的丢弃层：

tf.nn.dropout(layer1_pool, keep_prob)

在预测和评估期间，占位符keep_prob设置为 1。这样我们就可以重复使用相同的模型进行训练以及预测和评估。

有关 CIFAR10 数据的 LeNet 模型的完整代码在笔记本ch-09b_CNN_CIFAR10_TF_and_Keras中提供。

在运行模型时，我们得到以下输出：

Epoch: 0000   loss = 2.115784
Epoch: 0001   loss = 1.620117
Epoch: 0002   loss = 1.417657
Epoch: 0003   loss = 1.284346
Epoch: 0004   loss = 1.164068
Epoch: 0005   loss = 1.058837
Epoch: 0006   loss = 0.953583
Epoch: 0007   loss = 0.853759
Epoch: 0008   loss = 0.758431
Epoch: 0009   loss = 0.663844
Epoch: 0010   loss = 0.574547
Epoch: 0011   loss = 0.489902
Epoch: 0012   loss = 0.410211
Epoch: 0013   loss = 0.342640
Epoch: 0014   loss = 0.280877
Epoch: 0015   loss = 0.234057
Epoch: 0016   loss = 0.195667
Epoch: 0017   loss = 0.161439
Epoch: 0018   loss = 0.140618
Epoch: 0019   loss = 0.126363
Model Trained.
Accuracy: 0.6361

与我们在 MNIST 数据上获得的准确率相比，我们没有获得良好的准确率。通过调整不同的超参数并改变卷积和池化层的组合，可以实现更好的准确率。我们将其作为挑战，让读者探索并尝试不同的 LeNet 架构和超参数变体，以实现更高的准确率。

Keras 中的用于 CIFAR10 的卷积网络

让我们在 Keras 重复 LeNet CNN 模型构建和 CIFAR10 数据训练。我们保持架构与前面的示例相同，以便轻松解释概念。在 Keras 中，丢弃层添加如下：

model.add(Dropout(0.2))

用于 CIFAR10 CNN 模型的 Keras 中的完整代码在笔记本ch-09b_CNN_CIFAR10_TF_and_Keras中提供。

在运行模型时，我们得到以下模型描述：

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_1 (Conv2D)            (None, 32, 32, 32)        1568      
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 16, 16, 32)        0         
_________________________________________________________________
dropout_1 (Dropout)          (None, 16, 16, 32)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 16, 16, 64)        32832     
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 8, 8, 64)          0         
_________________________________________________________________
dropout_2 (Dropout)          (None, 8, 8, 64)          0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 4096)              0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              4195328   
_________________________________________________________________
dropout_3 (Dropout)          (None, 1024)              0         
_________________________________________________________________
dense_2 (Dense)              (None, 10)                10250     
=================================================================
Total params: 4,239,978
Trainable params: 4,239,978
Non-trainable params: 0
_________________________________________________________________

我们得到以下训练和评估结果：

Epoch 1/10
50000/50000 [====================] - 191s - loss: 1.5847 - acc: 0.4364   
Epoch 2/10
50000/50000 [====================] - 202s - loss: 1.1491 - acc: 0.5973   
Epoch 3/10
50000/50000 [====================] - 223s - loss: 0.9838 - acc: 0.6582   
Epoch 4/10
50000/50000 [====================] - 223s - loss: 0.8612 - acc: 0.7009   
Epoch 5/10
50000/50000 [====================] - 224s - loss: 0.7564 - acc: 0.7394   
Epoch 6/10
50000/50000 [====================] - 217s - loss: 0.6690 - acc: 0.7710   
Epoch 7/10
50000/50000 [====================] - 222s - loss: 0.5925 - acc: 0.7945   
Epoch 8/10
50000/50000 [====================] - 221s - loss: 0.5263 - acc: 0.8191   
Epoch 9/10
50000/50000 [====================] - 237s - loss: 0.4692 - acc: 0.8387   
Epoch 10/10
50000/50000 [====================] - 230s - loss: 0.4320 - acc: 0.8528   
Test loss: 0.849927025414
Test accuracy: 0.7414

再次，我们将其作为挑战，让读者探索并尝试不同的 LeNet 架构和超参数变体，以实现更高的准确率。

总结

在本章中，我们学习了如何使用 TensorFlow 和 Keras 创建卷积神经网络。我们学习了卷积和池化的核心概念，这是 CNN 的基础。我们学习了 LeNet 系列架构，并为 MNIST 和 CIFAR 数据集创建，训练和评估了 LeNet 族模型。 TensorFlow 和 Keras 提供了许多卷积和池化层和操作。鼓励读者探索本章未涉及的层和操作。

在下一章中，我们将继续学习如何使用自编码器架构将 TensorFlow 应用于图像数据。

十、TensorFlow 和 Keras 中的自编码器

自编码器是一种神经网络架构，通常与无监督学习，降维和数据压缩相关联。自编码器通过使用隐藏层中较少数量的神经元来学习产生与输入层相同的输出。这允许隐藏层以较少数量的参数学习输入的特征。使用较少数量的神经元来学习输入数据的特征的这个过程反过来减少了输入数据集的维度。

自编码器架构有两个阶段：编码器和解码器。在编码器阶段，模型学习表示具有较小维度的压缩向量的输入，并且在解码器阶段，模型学习将压缩向量表示为输出向量。损失计算为输出和输入之间的熵距离，因此通过最小化损失，我们学习将输入编码成能够产生输入的表示的参数，以及另一组学习参数。

在本章中，您将学习如何使用 TensorFlow 和 Keras 在以下主题中创建自编码器架构：

自编码器类型
TensorFlow 和 Keras 中的栈式自编码器
在 TensorFlow 和 Keras 中对自编码器进行去噪
TensorFlow 和 Keras 中的变分自编码器

自编码器类型

自编码器架构可以在各种配置中找到，例如简单自编码器，稀疏自编码器，去噪自编码器和卷积自编码器。

简单自编码器：在简单的自编码器中，与输入相比，隐藏层具有较少数量的节点或神经元。例如，在 MNIST 数据集中，784 个特征的输入可以连接到 512 个节点的隐藏层或 256 个节点，其连接到 784 特征输出层。因此，在训练期间，仅由 256 个节点学习 784 个特征。简单自编码器也称为欠完整自编码器。
简单的自编码器可以是单层或多层。通常，单层自编码器在生产中表现不佳。多层自编码器具有多个隐藏层，分为编码器和解码器分组。编码器层将大量特征编码为较少数量的神经元，然后解码器层将学习的压缩特征解码回原始特征或减少数量的特征。多层自编码器被称为栈式自编码器 。
稀疏自编码器：在稀疏自编码器中，添加正则化项作为惩罚，因此，与简单自编码器相比，表示变得更稀疏。
去噪自编码器（DAE）：在 DAE 架构中，输入带有随机噪声。 DAE 重新创建输入并尝试消除噪音。 DAE 中的损失函数将去噪重建输出与原始未损坏输入进行比较。
卷积自编码器（CAE）：前面讨论过的自编码器使用全连接层，这种模式类似于多层感知机模型。我们也可以使用卷积层而不是完全连接或密集层。当我们使用卷积层来创建自编码器时，它被称为卷积自编码器。作为一个例子，我们可以为 CAE 提供以下层：
输入 -> 卷积 -> 池化 -> 卷积 -> 池化 -> 输出
第一组卷积和池化层充当编码器，将高维输入特征空间减少到低维特征空间。第二组卷积和池化层充当解码器，将其转换回高维特征空间。
变分自编码器（VAE）：变分自编码器架构是自编码器领域的最新发展。 VAE 是一种生成模型，即它产生概率分布的参数，从中可以生成原始数据或与原始数据非常相似的数据。
在 VAE 中，编码器将输入样本转换为潜在空间中的参数，使用该参数对潜在点进行采样。然后解码器使用潜点重新生成原始输入数据。因此，在 VAE 中学习的重点转移到最大化输入数据的概率，而不是试图从输入重建输出。

现在让我们在以下部分中在 TensorFlow 和 Keras 中构建自编码器。我们将使用 MNIST 数据集来构建自编码器。自编码器将学习表示具有较少数量的神经元或特征的 MNIST 数据集的手写数字。

您可以按照 Jupyter 笔记本中的代码ch-10_AutoEncoders_TF_and_Keras。

像往常一样，我们首先使用以下代码读取 MNIST 数据集：

from tensorflow.examples.tutorials.mnist.input_data import input_data
dataset_home = os.path.join(datasetslib.datasets_root,'mnist') 
mnist = input_data.read_data_sets(dataset_home,one_hot=False)
X_train = mnist.train.images
X_test = mnist.test.images
Y_train = mnist.train.labels
Y_test = mnist.test.labels
pixel_size = 28

我们从训练和测试数据集中提取四个不同的图像及其各自的标签：

while True:
     train_images,train_labels = mnist.train.next_batch(4)
     if len(set(train_labels))==4:
        break
while True:
     test_images,test_labels = mnist.test.next_batch(4)
     if len(set(test_labels))==4:
        break

现在让我们看看使用 MNIST 数据集构建自编码器的代码。

您可以按照 Jupyter 笔记本中的代码ch-10_AutoEncoders_TF_and_Keras。

TensorFlow 中的栈式自编码器

在 TensorFlow 中构建栈式自编码器模型的步骤如下：

首先，定义超参数如下：

learning_rate = 0.001
n_epochs = 20
batch_size = 100
n_batches = int(mnist.train.num_examples/batch_size)

定义输入（即特征）和输出（即目标）的数量。输出数量与输入数量相同：

# number of pixels in the MNIST image as number of inputs
n_inputs = 784
n_outputs = n_inputs

定义输入和输出图像的占位符：

x = tf.placeholder(dtype=tf.float32, name="x", shape=[None, n_inputs])
y = tf.placeholder(dtype=tf.float32, name="y", shape=[None, n_outputs])

添加编码器和解码器层的神经元数量为[512,256,256,512]：

# number of hidden layers
n_layers = 2
# neurons in each hidden layer
n_neurons = [512,256]
# add number of decoder layers:
n_neurons.extend(list(reversed(n_neurons)))
n_layers = n_layers * 2

定义w和b参数：

w=[]
b=[]
for i in range(n_layers):
    w.append(tf.Variable(tf.random_normal([n_inputs \
                  if i==0 else n_neurons[i-1],n_neurons[i]]),
                         name="w_{0:04d}".format(i) 
                        )
            ) 
    b.append(tf.Variable(tf.zeros([n_neurons[i]]),
                         name="b_{0:04d}".format(i) 
                        )
            ) 
w.append(tf.Variable(tf.random_normal([n_neurons[n_layers-1] \
                    if n_layers > 0 else n_inputs,n_outputs]),
                     name="w_out"
                    )
        )
b.append(tf.Variable(tf.zeros([n_outputs]),name="b_out"))

精通 TensorFlow 1.x：6~10（4）https://developer.aliyun.com/article/1426822

精通 TensorFlow 1.x：6~10（3）

TensorFlow 中的 LSTM 和文本生成

Keras 中的 LSTM 和文本生成

总结

九、TensorFlow 和 Keras 中的 CNN

理解卷积

理解池化

CNN 架构模式 - LeNet

用于 MNIST 数据的 LeNet

TensorFlow 中的用于 MNIST 的 LeNet CNN

Keras 中的用于 MNIST 的 LeNet CNN

用于 CIFAR10 数据的 LeNet

TensorFlow 中的用于 CIFAR10 的卷积网络

Keras 中的用于 CIFAR10 的卷积网络

总结

十、TensorFlow 和 Keras 中的自编码器

自编码器类型

TensorFlow 中的栈式自编码器

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

精通 TensorFlow 1.x：6~10（3）

TensorFlow 中的 LSTM 和文本生成

Keras 中的 LSTM 和文本生成

总结

九、TensorFlow 和 Keras 中的 CNN

理解卷积

理解池化

CNN 架构模式 - LeNet

用于 MNIST 数据的 LeNet

TensorFlow 中的用于 MNIST 的 LeNet CNN

Keras 中的用于 MNIST 的 LeNet CNN

用于 CIFAR10 数据的 LeNet

TensorFlow 中的用于 CIFAR10 的卷积网络

Keras 中的用于 CIFAR10 的卷积网络

总结

十、TensorFlow 和 Keras 中的自编码器

自编码器类型

TensorFlow 中的栈式自编码器

热门文章

最新文章

相关课程

相关电子书