2020-12-16 21:54:32

new/ai-py/19.md

@@ -268,9 +268,9 @@ for item in data_test:
 
 ![](img/B15441_19_06.png)
 
-图 6：训练纪元
+图 6：训练周期
 
-正如我们在“图 5”中看到的那样，错误迅速开始减少，这表明我们的训练有效地创造了越来越好的预测。 在这种情况下，错误不会降为零。 但是如果我们让模型再运行几个纪元，我们预计误差将继续减少。 如果将这些测试数据点定位在 2D 图形上，则可以直观地验证预测输出的正确性。
+正如我们在“图 5”中看到的那样，错误迅速开始减少，这表明我们的训练有效地创造了越来越好的预测。 在这种情况下，错误不会降为零。 但是如果我们让模型再运行几个周期，我们预计误差将继续减少。 如果将这些测试数据点定位在 2D 图形上，则可以直观地验证预测输出的正确性。
 
 # 构建多层神经网络
 
@@ -394,7 +394,7 @@ plt.show()
 
 ![](img/B15441_19_10.png)
 
-图 10：训练纪元
+图 10：训练周期
 
 在前面的部分中，我们学习了如何构建基本的神经网络以及对基础知识的牢固掌握和理解。 在下一节中，我们将继续学习如何构建神经网络。 现在，我们将学习如何使用向量量化器构建神经网络。
 
@@ -511,7 +511,7 @@ plt.show()
 
 ![](img/B15441_19_12.png)
 
-图 12：训练纪元
+图 12：训练周期
 
 在上一节中，我们学习了如何使用向量量化器构建神经网络。 在下一节中，我们将继续学习神经网络。 接下来，我们将学习如何使用递归神经网络（RNN）分析序列数据。
 
@@ -652,7 +652,7 @@ if __name__=='__main__':
 
 ![](img/B15441_19_15.png)
 
-图 15：训练纪元
+图 15：训练周期
 
 如您所见，错误持续减小，直到达到训练次数的最大值。 到此结束了本节，我们展示了如何使用 RNN 来分析时间序列数据。 在下一部分中，我们将通过研究光学字符识别来演示神经网络的实际应用。
 
@@ -897,13 +897,13 @@ for i in range(num_test):
 
 ![](img/B15441_19_18.png)
 
-图 18：训练纪元
+图 18：训练周期
 
-它将持续进行直到 10,000 个纪元。 完成后，您应该看到以下输出：
+它将持续进行直到 10,000 个周期。 完成后，您应该看到以下输出：
 
 ![](img/B15441_19_19.png)
 
-图 19：训练纪元
+图 19：训练周期
 
 正如我们在前面的屏幕截图中看到的，我们的模型正确地选择了其中的三个。 如果使用更大的数据集并训练更长的时间，则应该获得更高的准确性。 我们让您看看它们是否可以通过更长的网络训练和调整模型的配置来获得更高的准确性和更好的结果。
 

new/ai-py/20.md

@@ -298,13 +298,13 @@ for step in range(num_iterations):
 
 ![](img/B15441_20_10.png)
 
-图 10：历元的初始输出
+图 10：周期的初始输出
 
 完成训练后，您将看到以下内容：
 
 ![](img/B15441_20_11.png)
 
-图 11：历元的最终输出
+图 11：周期的最终输出
 
 我们可以看到`w`和`b`的值是如何不断调整的，我们还可以看到损失如何持续减小直到损失很小的程度，以至于我们不再看到它减小。 有趣的是，我们能够很快取得良好的结果，但是我们为我们的网络解决了一个相当简单的问题。 让我们开始吧。
 

new/ai-py/21.md

@@ -269,7 +269,7 @@ def sigmoid(x):
 
 现在，我们已经准备就绪，可以开始训练模型了。 我们将迭代`25`时代。 您将在结果中清楚地看到模型和实际数据开始收敛的点。 确保收敛后停止训练。 否则，我们将过拟合数据，并且我们的模型将使用训练数据生成良好的数字，但对于尚未看到的数据将不会表现良好。
 
-运行该程序几次。 一旦看到数据开始收敛，就可以调整“历元数”的值。
+运行该程序几次。 一旦看到数据开始收敛，就可以调整“周期数”的值。
 
 这是训练期间将执行的步骤的概述：
 
@@ -409,7 +409,7 @@ for epoch in range(number_of_epochs):
 
 ![](img/B15441_21_11.png)
 
-图 9：5 个历元的 RNN 训练输出
+图 9：5 个周期的 RNN 训练输出
 
 如您所见，损失和验证损失在每个时期都在不断减少。 我们可能会再运行几个模型，并确保结果收敛。
 
@@ -417,9 +417,9 @@ for epoch in range(number_of_epochs):
 
 ![](img/B15441_21_12.png)
 
-图 10：10 个历元的 RNN 训练输出
+图 10：10 个周期的 RNN 训练输出
 
-如您所见，在第 6 个阶段之后，结果已经收敛。 找出最佳时期数是一个*试错*过程。 从这些结果可以看出，大约 6 个纪元是正确的纪元数。
+如您所见，在第 6 个阶段之后，结果已经收敛。 找出最佳时期数是一个*试错*过程。 从这些结果可以看出，大约 6 个周期是正确的周期数。
 
 在这个例子中，我们几乎已经走到了尽头。 让我们根据预测值绘制初始输入数据集，然后看看如何得出。 以下是相关代码：
 

new/gan-proj/1.md

@@ -13,7 +13,7 @@
 *   什么是 GAN？
 *   GAN 的架构
 *   与 GAN 相关的重要概念
-*   GAN 的不同品种
+*   GAN 的不同种类
 *   GAN 的优缺点
 *   GAN 的实际应用
 

new/gan-proj/2.md

@@ -144,7 +144,7 @@
 2.  使用生成器模型生成伪图像。
 3.  在真实图像（从真实数据中采样）和生成器网络生成的伪图像上训练生成器网络。
 4.  使用对抗模型训练生成器模型。 不要训练判别器模型。
-5.  对指定的时期数重复这些步骤。
+5.  对指定的周期数重复这些步骤。
 
 我们将在后面的部分中详细探讨这些步骤。 让我们继续建立一个项目。
 
@@ -622,7 +622,7 @@ tensorboard.set_model(generator)
 tensorboard.set_model(discriminator)
 ```
 
-6.  添加一个循环，该循环将运行指定的时期数：
+6.  添加一个循环，该循环将运行指定的周期数：
 
 ```py
 for epoch in range(epochs):
@@ -694,7 +694,7 @@ z = np.random.normal(0, 0.33, size=[batch_size, 1, 1, 1, z_size]).astype(np.floa
         dis_losses.append(d_loss)
 ```
 
-12.  每隔一个纪元生成并保存 3D 图像：
+12.  每隔一个周期生成并保存 3D 图像：
 
 ```py
  if index % 10 == 0:
@@ -714,7 +714,7 @@ z = np.random.normal(0, 0.33, size=[batch_size, 1, 1, 1, z_size]).astype(np.floa
 write_log(tensorboard, 'd_loss', np.mean(dis_losses), epoch)
 ```
 
-我的建议是将其训练 100 个纪元，以查找代码中的问题。 解决了这些问题后，您就可以在 100,000 个时期内训练网络。
+我的建议是将其训练 100 个周期，以查找代码中的问题。 解决了这些问题后，您就可以在 100,000 个时期内训练网络。
 
 
 

new/gan-proj/3.md

@@ -991,7 +991,7 @@ for epoch in range(epochs):
     print("Number of batches:", number_of_batches)
 ```
 
-10.  接下来，在纪元循环内创建另一个循环，并使它运行 `num_batches` 指定的次数，如下所示：
+10.  接下来，在周期循环内创建另一个循环，并使它运行 `num_batches` 指定的次数，如下所示：
 
 ```py
  for index in range(number_of_batches):
@@ -1169,7 +1169,7 @@ y = to_categorical(y, num_classes=num_classes)
 
 您可以随意采样。 在我们的例子中，我们正在采样 1,000 个值。
 
-5.  接下来，添加一个纪元循环和一个批量步骤循环，如下所示：
+5.  接下来，添加一个周期循环和一个批量步骤循环，如下所示：
 
 ```py
 for epoch in range(epochs):

new/gan-proj/4.md

@@ -914,7 +914,7 @@ dis_model.save("directory/for/the/discriminator/model.h5")
 
 ![](img/82a9152b-d3fb-467b-837f-96af60995452.png)
 
-要生成非常好的图像，请将网络训练 10,000 个纪元。
+要生成非常好的图像，请将网络训练 10,000 个周期。
 
 
 
@@ -960,7 +960,7 @@ Tensorboard 的`GRAPHS`部分包含两个网络的图形。 如果网络性能
 
 *   学习率
 *   批量大小
-*   纪元数
+*   周期数
 *   生成器优化器
 *   判别器优化器
 *   层数

new/gan-proj/5.md

@@ -1136,19 +1136,19 @@ dis_model.save("directory/for/the/discriminator/model.h5")
 
 ![](img/f099cb7a-a2b7-476b-9476-f7e47eb947b4.png)
 
-*   10,000 个纪元后，图像显示如下：
+*   10,000 个周期后，图像显示如下：
 
 ![](img/96ef5573-9de4-4bf6-a6ec-848e6f3c622c.png)
 
-*   15,000 个纪元后，图像显示如下：
+*   15,000 个周期后，图像显示如下：
 
 ![](img/fd0ed18a-8cd7-4200-a3e9-81c6f771302a.png)
 
-*   经过 20,000 个纪元后，图像显示如下：
+*   经过 20,000 个周期后，图像显示如下：
 
 ![](img/d58519f5-35a1-4b3b-831f-163b995eeabd.png)
 
-要生成非常好的图像，请将网络训练 30,000-50,000 个纪元。
+要生成非常好的图像，请将网络训练 30,000-50,000 个周期。
 
 
 

new/gan-proj/6.md

@@ -1834,7 +1834,7 @@ for epoch in range(epochs):
     dis_losses = []
 ```
 
-4.  在纪元循环内创建另一个循环，该循环将运行指定的批量数量：
+4.  在周期循环内创建另一个循环，该循环将运行指定的批量数量：
 
 ```py
  print("Number of batches:{}".format(number_of_batches))
@@ -1942,7 +1942,7 @@ stage2_dis.save_weights("stage2_dis.h5")
 
 由 StackGAN 网络的第一阶段和第二阶段生成的图像
 
-我建议您将网络训练 1000 个纪元。 如果一切顺利，则在 1000 个时期之后，生成器网络将开始生成逼真的图像。
+我建议您将网络训练 1000 个周期。 如果一切顺利，则在 1000 个时期之后，生成器网络将开始生成逼真的图像。
 
 
 

new/gan-proj/7.md

@@ -1040,7 +1040,7 @@ discriminatorB.save("directory/for/the/discriminatorB/model.h5")
 
 ![](img/34d03920-182c-4630-bba6-25d7f728c1f6.png)
 
-我建议您将网络训练 1000 个纪元。 如果一切顺利，则在 1000 个时期之后，生成器网络将开始生成逼真的图像。
+我建议您将网络训练 1000 个周期。 如果一切顺利，则在 1000 个时期之后，生成器网络将开始生成逼真的图像。
 
 
 

new/gan-proj/8.md

@@ -1357,7 +1357,7 @@ patchgan_discriminator.save_weights("discriminator.h5")
 
 ![](img/277d3877-16f5-4ce5-b5f0-2703bc2d3075.png)
 
-每个块均包含垂直堆叠的外观标签，生成的照片和实际图像。 我建议您将网络训练 1000 个纪元。 如果一切顺利，则在 1000 个时期之后，生成器网络将开始生成逼真的图像。
+每个块均包含垂直堆叠的外观标签，生成的照片和实际图像。 我建议您将网络训练 1000 个周期。 如果一切顺利，则在 1000 个时期之后，生成器网络将开始生成逼真的图像。
 
 
 

new/handson-unsup-learn-py/08.md

@@ -99,7 +99,7 @@ faces = fetch_olivetti_faces(shuffle=True, random_state=1000)
 X_train = faces['images']
 ```
 
-样本是 400 个`64×64`灰度图像，我们将其调整为`32×32`，以加快计算速度并避免出现内存问题（此操作会导致视觉精度略有下降，如果您有足够的计算资源，您可以删除它）。 现在，我们可以定义主要常量（历元数（`nb_epochs`，`batch_size`和`code_length`））和`graph`：
+样本是 400 个`64×64`灰度图像，我们将其调整为`32×32`，以加快计算速度并避免出现内存问题（此操作会导致视觉精度略有下降，如果您有足够的计算资源，您可以删除它）。 现在，我们可以定义主要常量（周期数（`nb_epochs`，`batch_size`和`code_length`））和`graph`：
 
 ```py
 import tensorflow as tf
@@ -399,7 +399,7 @@ for e in range(nb_epochs):
 
 ![](img/ec6a414d-389c-457f-9944-ba198988bf14.png)
 
-`α`常数确定将要达到的稀疏程度。 当然，由于`C[s]`的最佳值与原始值不对应，因此，为了达到相同的精度，通常需要更多的历元和更长的代码层。 由 Andrew Ng（斯坦福大学的 CS294A “稀疏自编码器”）提出的另一种方法是基于稍微不同的方法。 代码层被认为是一组独立的伯努利随机变量。 因此，给定另一组均值较小的伯努利变量（例如`p[r] ~ B(0.05)`），就有可能尝试找到使代码最小化的最佳代码`z[i]`与此类参考分布之间的 Kullback-Leibler 散度：
+`α`常数确定将要达到的稀疏程度。 当然，由于`C[s]`的最佳值与原始值不对应，因此，为了达到相同的精度，通常需要更多的周期和更长的代码层。 由 Andrew Ng（斯坦福大学的 CS294A “稀疏自编码器”）提出的另一种方法是基于稍微不同的方法。 代码层被认为是一组独立的伯努利随机变量。 因此，给定另一组均值较小的伯努利变量（例如`p[r] ~ B(0.05)`），就有可能尝试找到使代码最小化的最佳代码`z[i]`与此类参考分布之间的 Kullback-Leibler 散度：
 
 ![](img/04ada51f-118c-4cd8-8c62-f1ca4ec0b792.png)
 
@@ -632,7 +632,7 @@ with graph.as_default():
 1.  基于交叉熵的重构损失
 2.  代码分布与参考正态分布之间的 Kullback-Leibler 散度
 
-在这一点上，像往常一样，我们可以初始化会话和所有变量，并开始每批 800 个纪元和 100 个样本的训练过程：
+在这一点上，像往常一样，我们可以初始化会话和所有变量，并开始每批 800 个周期和 100 个样本的训练过程：
 
 ```py
 import tensorflow as tf

new/intel-mobi-proj-tf/08.md

@@ -223,7 +223,7 @@ with tf.Session() as sess:
 (500, 'loss:', 91.966286)
 ```
 
-您可以在第 4 步中用`BasicLSTMCell`替换`BasicRNNCell`并运行训练代码，但是使用`BasicLSTMCell`进行训练要慢得多，并且在 500 个纪元之后损耗值仍然很大。 在本节中，我们将不再对`BasicLSTMCell`进行实验，但是为了进行比较，在使用 Keras 的下一部分中，您将看到堆叠 LSTM 层，丢弃法和双向 RNN 的详细用法。
+您可以在第 4 步中用`BasicLSTMCell`替换`BasicRNNCell`并运行训练代码，但是使用`BasicLSTMCell`进行训练要慢得多，并且在 500 个周期之后损耗值仍然很大。 在本节中，我们将不再对`BasicLSTMCell`进行实验，但是为了进行比较，在使用 Keras 的下一部分中，您将看到堆叠 LSTM 层，丢弃法和双向 RNN 的详细用法。
 
 
 
@@ -231,7 +231,7 @@ with tf.Session() as sess:
 
 
 
-要查看 500 个纪元后的损失值是否足够好，让我们使用测试数据集添加以下代码，以计算总测试示例中正确预测的数量（正确的意思是，预测价格在目标价格的同一个方向上上下波动，相对于前一天的价格）：
+要查看 500 个周期后的损失值是否足够好，让我们使用测试数据集添加以下代码，以计算总测试示例中正确预测的数量（正确的意思是，预测价格在目标价格的同一个方向上上下波动，相对于前一天的价格）：
 
 ```py
     correct = 0