2021-01-17 22:42:47

new/dl-pt-workshop/3.md

@@ -564,7 +564,7 @@ batch_size = 100
     训练过程可能需要几分钟，具体取决于您的资源。 如果您希望查看训练过程的进度，则添加打印语句是一种很好的做法。
 
 9.  绘制两组损失。
-10.  绘制两组数据的准确率。
+0.  绘制两组数据的准确率。
 
 最终图将如下所示：
 
@@ -928,11 +928,11 @@ prediction = traced_script(input)
 
 8.  使用 JIT 模块转换模型。
 9.  通过从“步骤 7”中输入张量到模型的跟踪脚本中来执行预测。
-10.  打开一个新的 Jupyter Notebook，然后导入使用 Flask 创建 API 所需的库以及加载已保存模型的库。
-11.  初始化 Flask 应用。
-12.  定义一个函数来加载保存的模型并实例化该模型。
-13.  定义 API 的路由，使其为`/prediction`，并定义方法为`POST`。 然后，定义将接收`POST`数据并将其馈送到模型以执行预测的函数。
-14.  运行 Flask 应用。
+0.  打开一个新的 Jupyter Notebook，然后导入使用 Flask 创建 API 所需的库以及加载已保存模型的库。
+1.  初始化 Flask 应用。
+2.  定义一个函数来加载保存的模型并实例化该模型。
+3.  定义 API 的路由，使其为`/prediction`，并定义方法为`POST`。 然后，定义将接收`POST`数据并将其馈送到模型以执行预测的函数。
+4.  运行 Flask 应用。
 
 运行后，该应用程序将如下所示：
 

new/dl-pt-workshop/4.md

@@ -570,7 +570,7 @@ test_loader = torch.utils.data.DataLoader(test_data, \
 7.  定义训练模型所需的所有参数。 将纪元数设置为 50。
 8.  训练您的网络，并确保保存训练和验证集的损失和准确率值。
 9.  绘制两组的损失和准确率。
-10.  在测试集上检查模型的准确度--它应该在 72%左右。
+0.  在测试集上检查模型的准确度--它应该在 72%左右。
 
     注意
 

new/dl-pt-workshop/5.md

@@ -642,7 +642,7 @@ style_features = features_extractor(style_img, model, \
 7.  创建一个字典，将相关层（键）的索引映射到名称（值）。 然后，创建一个函数以提取相关层的特征图。 使用它们提取两个输入图像的特征。
 8.  计算样式特征的克矩阵。 另外，创建初始目标图像。
 9.  设置不同样式层的权重以及内容和样式损失的权重。
-10.  运行模型 500 次迭代。在开始训练模型之前，定义 Adam 优化算法，以 0.001 作为学习率。
+0.  运行模型 500 次迭代。在开始训练模型之前，定义 Adam 优化算法，以 0.001 作为学习率。
 
     注意
 
@@ -650,7 +650,7 @@ style_features = features_extractor(style_img, model, \
 
     本章中显示的结果是通过运行大约 5,000 次迭代而获得的，如果不使用 GPU，则将花费很长时间（在本书的 GitHub 存储库中也找到了使用 GPU 的活动的解决方案）。 但是，仅看到一些小的更改，就可以按照本活动的建议运行它几百次迭代就足够了（500）。
 
-11.  绘制内容、风格、目标图片，比较结果。
+1.  绘制内容、风格、目标图片，比较结果。
 
     5,000 次迭代后的输出应如下所示：
 

new/dl-pt-workshop/6.md

@@ -272,7 +272,7 @@ for i in range(1, epochs+1):
 7.  定义损失函数，优化算法和训练网络的时期数。 为此，请使用均方误差损失函数，Adam 优化器和 10,000 个纪元。
 8.  使用`for`循环通过遍历所有时期来执行训练过程。 在每个时期，都必须进行预测，以及随后的损失函数计算和网络参数优化。 然后，保存每个时期的损失。
 9.  绘制所有时期的损失。
-10.  使用散点图，显示在训练过程的最后一个纪元中获得的预测值与地面真实值（即上周的销售交易）的对比。
+0.  使用散点图，显示在训练过程的最后一个纪元中获得的预测值与地面真实值（即上周的销售交易）的对比。
 
     注意
 
@@ -694,14 +694,14 @@ while starter[-1] != "." and counter < 50:
 
     根据您的资源，训练过程将花费很长时间，这就是为什么建议仅运行 20 个纪元的原因。 但是，本书的 GitHub 存储库中提供了可以在 GPU 上运行的代码的等效版本。 这将使您运行更多的时代并获得出色的性能。
 
-10.  在每一个时代，数据必须被划分为 50 个序列长度的批次。这意味着每个时代将有 100 个序列，每个序列的长度为 50。
+0.  在每一个时代，数据必须被划分为 50 个序列长度的批次。这意味着每个时代将有 100 个序列，每个序列的长度为 50。
 
     注意
 
     为输入和目标创建了批量 ，其中后者是前者的副本，但领先一步。
 
-11.  绘制随时间推移的损失进度。
-12.  将下面的句子启动器输入到训练好的模型中，并完成这个句子：`"So she was considering in her own mind "`。
+1.  绘制随时间推移的损失进度。
+2.  将下面的句子启动器输入到训练好的模型中，并完成这个句子：`"So she was considering in her own mind "`。
 
     注意
 
@@ -837,7 +837,7 @@ class LSTM(nn.Module):
 7.  使用 3 个 LSTM 层的 64 个嵌入尺寸和 128 个神经元实例化模型。
 8.  定义损失函数，优化算法以及要训练的时期数。 例如，您可以将二进制交叉熵损失用作损失函数，Adam 优化器，并训练 10 个历元。
 9.  创建一个`for`循环，该循环将经历不同的时期并分别经历每个审核。 对于每次审核，都要进行预测，计算损失函数并更新网络参数。 此外，根据该训练数据计算网络的准确率。
-10.  随时间绘制损失的进度和准确率。
+0.  随时间绘制损失的进度和准确率。
 
 最终的精度图将如下所示：
 

new/handson-1shot-learn-py/2.md

@@ -497,7 +497,7 @@ Epoch: 98       Loss: 0.003155
 Epoch: 99       Loss: 0.003937
 ```
 
-10.  现在，让我们创建所有用于绘制嵌入的函数和一个损失函数：
+0.  现在，让我们创建所有用于绘制嵌入的函数和一个损失函数：
 
 ```py
 def plot_loss(train_loss,name="train_loss.png"):
@@ -517,7 +517,7 @@ def plot_mnist(numpy_all, numpy_labels,name="./embeddings_plot.png"):
         plt.savefig(name)
 ```
 
-11.  使用以下代码绘制`loss`功能：
+1.  使用以下代码绘制`loss`功能：
 
 ```py
 plot_loss(train_loss)
@@ -527,7 +527,7 @@ plot_loss(train_loss)
 
 ![](img/aba64cc3-f3b4-4d14-a3bf-8d0ae4a62c36.png)
 
-12.  然后，我们将定义`test_model`和`testing_plots`来绘制`MNIST`数据集的测试集嵌入：
+2.  然后，我们将定义`test_model`和`testing_plots`来绘制`MNIST`数据集的测试集嵌入：
 
 ```py
 def test_model(model):
@@ -553,7 +553,7 @@ def testing_plots(model):
         plot_mnist(numpy_all, numpy_labels)
 ```
 
-13.  然后，绘制`testing_plots`：
+3.  然后，绘制`testing_plots`：
 
 ```py
 testing_plots(model)
@@ -1031,7 +1031,7 @@ Epoch 1: train_loss:2.97 train_accuracy:0.20 valid_loss:2.97 valid_accuracy:0.28
 Epoch 2: train_loss:2.95 train_accuracy:0.31 valid_loss:2.94 valid_accuracy:0.37
 ```
 
-10.  现在，通过运行以下代码块来获得测试的准确率：
+0.  现在，通过运行以下代码块来获得测试的准确率：
 
 ```py
 total_test_c_loss, total_test_accuracy = run_epoch(total_test_batches,'test')
@@ -1044,7 +1044,7 @@ print("test_accuracy:{}%".format(total_test_accuracy*100))
 test_accuracy:86.0%
 ```
 
-11.  让我们可视化我们的结果：
+1.  让我们可视化我们的结果：
 
 ```py
 def plot_loss(train,val,name1="train_loss",name2="val_loss"):

new/handson-1shot-learn-py/3.md

@@ -487,7 +487,7 @@ sequence_length, token_size, training_samples = 2, 10, 99
 min_grad, max_grad = -10, 10
 ```
 
-10.  然后，初始化火车模型：
+0.  然后，初始化火车模型：
 
 ```py
 # Initialize the dataset
@@ -534,7 +534,7 @@ iteration: 40, Loss:0.7050653696060181
 iteration: 50, Loss:0.7188648581504822
 ```
 
-11.  定义一个`plot_signal`函数并绘制训练损失`losses`：
+1.  定义一个`plot_signal`函数并绘制训练损失`losses`：
 
 ```py
 def plot_signal(grid_image, fig_size=(500,100)):
@@ -545,7 +545,7 @@ plt.plot(losses)
 plt.show()
 ```
 
-12.  测试 NTM 模型的复制任务：
+2.  测试 NTM 模型的复制任务：
 
 ```py
 X, Y = dataset._generate_seq()

new/handson-nlp-pt-1x/3.md

@@ -279,7 +279,7 @@ X = ["is", "a", "learning", "framework"]; y = "deep"
 
     图 3.11 –张量值
 
-10.  现在，我们训练我们的网络。我们循环通过 100 个周期，对于每一个通道，我们循环通过我们所有的上下文词，也就是目标词对。对于这些对，我们使用`make_sentence_vector()`加载上下文句子，并使用我们当前的模型状态来获得预测。我们根据我们的实际目标评估这些预测，以获得我们的损失。我们反推计算梯度，并通过我们的优化器来更新权重。最后，我们将该时代的所有损失相加并打印出来。在这里，我们可以看到，我们的损失正在减少，这表明我们的模型正在学习。
+0.  现在，我们训练我们的网络。我们循环通过 100 个周期，对于每一个通道，我们循环通过我们所有的上下文词，也就是目标词对。对于这些对，我们使用`make_sentence_vector()`加载上下文句子，并使用我们当前的模型状态来获得预测。我们根据我们的实际目标评估这些预测，以获得我们的损失。我们反推计算梯度，并通过我们的优化器来更新权重。最后，我们将该时代的所有损失相加并打印出来。在这里，我们可以看到，我们的损失正在减少，这表明我们的模型正在学习。
 
     ```py
     for epoch in range(100):
@@ -304,7 +304,7 @@ X = ["is", "a", "learning", "framework"]; y = "deep"
 
     现在我们的模型已经训练完毕，我们可以进行预测了。 我们定义了几个函数来允许我们这样做。 `get_predicted_result()`从预测数组中返回预测的单词，而我们的`predicted_sentence()`函数则根据上下文单词进行预测。
 
-11.  我们将我们的句子分割成单个单词，并将它们转化为一个输入向量。然后我们将其输入到模型中，创建我们的预测数组，并使用`get_predicted_result()`函数获得最终的预测词。我们也会打印出预测目标词前后的两个词作为上下文。我们可以运行几个预测来验证我们的模型是否正常工作。
+1.  我们将我们的句子分割成单个单词，并将它们转化为一个输入向量。然后我们将其输入到模型中，创建我们的预测数组，并使用`get_predicted_result()`函数获得最终的预测词。我们也会打印出预测目标词前后的两个词作为上下文。我们可以运行几个预测来验证我们的模型是否正常工作。
 
     ```py
     def get_predicted_result(input, inverse_word_dict):
@@ -326,7 +326,7 @@ X = ["is", "a", "learning", "framework"]; y = "deep"
 
     图 3.13 –预测值
 
-12.  现在我们已经有了一个训练好的模型，我们能够使用`get_word_embedding()`函数，以便返回我们语料库中任何单词的 20 维单词嵌入。如果我们在另一个 NLP 任务中需要我们的嵌入，我们实际上可以从整个嵌入层中提取权重，并将其用于我们的新模型中。
+2.  现在我们已经有了一个训练好的模型，我们能够使用`get_word_embedding()`函数，以便返回我们语料库中任何单词的 20 维单词嵌入。如果我们在另一个 NLP 任务中需要我们的嵌入，我们实际上可以从整个嵌入层中提取权重，并将其用于我们的新模型中。
 
     ```py
     print(model.get_word_emdedding('leap'))

new/handson-nlp-pt-1x/7.md

@@ -485,7 +485,7 @@ def forward(self, input, h, cell):
     output = model(src, trg, 0)
     ```
 
-10.  最后，我们需要创建一个训练循环，在这个循环中调用`train()`和`evaluate()`函数。我们首先定义了我们希望训练的次数和最大梯度（用于梯度剪接）。我们还将最低验证损失设置为无穷大。这将在后面用来选择我们表现最好的模型。
+0.  最后，我们需要创建一个训练循环，在这个循环中调用`train()`和`evaluate()`函数。我们首先定义了我们希望训练的次数和最大梯度（用于梯度剪接）。我们还将最低验证损失设置为无穷大。这将在后面用来选择我们表现最好的模型。
 
     ```py
     epochs = 10
@@ -493,7 +493,7 @@ def forward(self, input, h, cell):
     lowest_validation_loss = float('inf')
     ```
 
-11.  然后，我们循环浏览我们的每个时代，并在每个时代内，使用我们的`train()`和·evaluate()函数计算我们的训练和验证损失。我们还通过在训练过程前后调用`time.time()`来计算时间。
+1.  然后，我们循环浏览我们的每个时代，并在每个时代内，使用我们的`train()`和·evaluate()函数计算我们的训练和验证损失。我们还通过在训练过程前后调用`time.time()`来计算时间。
 
     ```py
     for epoch in range(epochs):
@@ -506,7 +506,7 @@ def forward(self, input, h, cell):
         end_time = time.time()
     ```
 
-12.  接下来，对于每个时代，我们确定我们刚刚训练的模型是否是我们迄今为止看到的表现最好的模型。如果我们的模型在我们的验证数据上表现最好（如果验证损失是我们迄今为止看到的最低的），我们就保存我们的模型。
+2.  接下来，对于每个时代，我们确定我们刚刚训练的模型是否是我们迄今为止看到的表现最好的模型。如果我们的模型在我们的验证数据上表现最好（如果验证损失是我们迄今为止看到的最低的），我们就保存我们的模型。
 
     ```py
     if valid_loss < lowest_validation_loss:
@@ -514,7 +514,7 @@ def forward(self, input, h, cell):
         torch.save(model.state_dict(), ‘seq2seq.pt’)
     ```
 
-13.  最后，我们只需打印我们的输出。
+3.  最后，我们只需打印我们的输出。
 
     ```py
     print(f'Epoch: {epoch+1:02} | Time: {np.round(end_time-start_time,0)}s')

new/handson-nlp-pt-1x/8.md

@@ -717,7 +717,7 @@ for line in lines[:3]:
                             range(n_iteration)]
     ```
 
-10.  然后，我们创建一些变量，使我们能够计算迭代次数，并跟踪每个时代的总损失。
+0.  然后，我们创建一些变量，使我们能够计算迭代次数，并跟踪每个时代的总损失。
 
     ```py
     print('Starting ...')
@@ -727,7 +727,7 @@ for line in lines[:3]:
         start_iteration = checkpoint['iteration'] + 1
     ```
 
-11.  接下来，我们定义我们的训练循环。对于每次迭代，我们从我们的批次列表中得到一个训练批次。然后，我们从我们的批次中提取相关字段，并使用这些参数运行一次训练迭代。最后，我们将这个批次的损失加入到我们的总体损失中。
+1.  接下来，我们定义我们的训练循环。对于每次迭代，我们从我们的批次列表中得到一个训练批次。然后，我们从我们的批次中提取相关字段，并使用这些参数运行一次训练迭代。最后，我们将这个批次的损失加入到我们的总体损失中。
 
     ```py
     print("Beginning Training...")
@@ -743,7 +743,7 @@ for line in lines[:3]:
         print_loss += loss
     ```
 
-12.  在每一次迭代中，我们还确保打印出迄今为止的进度，跟踪我们已经完成了多少次迭代，以及每个纪元的损失是多少。
+2.  在每一次迭代中，我们还确保打印出迄今为止的进度，跟踪我们已经完成了多少次迭代，以及每个纪元的损失是多少。
 
     ```py
     if iteration % print_every == 0:
@@ -755,7 +755,7 @@ for line in lines[:3]:
         print_loss = 0
     ```
 
-13.  为了完成，我们还需要在每隔几个纪元后保存我们的模型状态。这让我们可以重新审视我们已经训练过的任何历史模型；例如，如果我们的模型开始过拟合，我们可以恢复到早期的迭代。
+3.  为了完成，我们还需要在每隔几个纪元后保存我们的模型状态。这让我们可以重新审视我们已经训练过的任何历史模型；例如，如果我们的模型开始过拟合，我们可以恢复到早期的迭代。
 
     ```py
     if (iteration % save_every == 0):
@@ -1015,7 +1015,7 @@ print('Response:', ' '.join(output_words))
                 state[k] = v.cuda()
     ```
 
-10.  最后，我们准备好训练我们的模型。这可以通过简单地调用`trainIters`函数来完成，其中包含所有所需参数。
+0.  最后，我们准备好训练我们的模型。这可以通过简单地调用`trainIters`函数来完成，其中包含所有所需参数。
 
     ```py
     print("Starting Training!")

new/pt-ai-fund/3.md

@@ -524,56 +524,56 @@ pip install torchvision==0.x.x
 >>import numpy as np
 ```
 
-10.  然后，我们将获得训练数据的大小：
+0.  然后，我们将获得训练数据的大小：
 
 ```py
 >>training_size = len(train_data)
 ```
 
-11.  接下来，我们创建一个索引列表：
+1.  接下来，我们创建一个索引列表：
 
 ```py
 >>indices = list(range(training_size))
 ```
 
-12.  然后，我们将重新整理索引列表：
+2.  然后，我们将重新整理索引列表：
 
 ```py
 >>np.random.shuffle(indices)
 ```
 
-13.  之后，我们将获得索引以拆分验证和训练数据集：
+3.  之后，我们将获得索引以拆分验证和训练数据集：
 
 ```py
 >>index_split = int(np.floor(training_size * validation_size))
 ```
 
-14.  然后，我们将获得训练和验证集索引：
+4.  然后，我们将获得训练和验证集索引：
 
 ```py
 >>validation_indices, training_indices = indices[:index_split], indices[index_split:]
 ```
 
-15.  现在，我们将使用来自割炬的子集随机采样器：
+5.  现在，我们将使用来自割炬的子集随机采样器：
 
 ```py
 >>training_sample = SubsetRandomSampler(training_indices)
 >>validation_sample = SubsetRandomSampler(validation_indices)
 ```
 
-16.  接下来，我们将数据集分成多个批量。 我们将批量大小设置为 16：
+6.  接下来，我们将数据集分成多个批量。 我们将批量大小设置为 16：
 
 ```py
 >>batch_size = 16
 ```
 
-17.  然后，我们将在 PyTorch 中使用`dataloader`模块将数据批量加载：
+7.  然后，我们将在 PyTorch 中使用`dataloader`模块将数据批量加载：
 
 ```py
 >>from torch.utils.data.dataloader import DataLoader
 ```
 
-18.  然后，我们将创建训练，验证和测试数据集批量：
+8.  然后，我们将创建训练，验证和测试数据集批量：
 
 ```py
 >>train_loader = DataLoader(train_data, batch_size=batch_size, sampler=training_sample)

new/pt-ai-fund/4.md

@@ -433,19 +433,19 @@ x = self.embedding(x)
 output, (hidden, cell) = self.rnn(x)
 ```
 
-10.  然后，我们应用`dropout`：
+0.  然后，我们应用`dropout`：
 
 ```py
 hidden = self.dropout(hidden)
 ```
 
-11.  最后，我们将输出传递给线性层：
+1.  最后，我们将输出传递给线性层：
 
 ```py
 return self.fc(hidden)
 ```
 
-12.  我们将定义超参数如下：
+2.  我们将定义超参数如下：
 
 ```py
 >>EMBEDDING_DIM = 100
@@ -454,7 +454,7 @@ return self.fc(hidden)
 >>DROPOUT = 0.5
 ```
 
-13.  最后，我们创建一个`model`对象：
+3.  最后，我们创建一个`model`对象：
 
 ```py
 >>model = LSTMClassifier(EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM, DROPOUT)

new/pt-ai-fund/6.md

@@ -343,63 +343,63 @@ Estimated Total Size (MB): 0.58
 >>num_epochs = 50
 ```
 
-10.  现在，我们开始训练循环：
+0.  现在，我们开始训练循环：
 
 ```py
 >>for epoch in range(num_epochs):
 ```
 
-11.  然后我们遍历数据：
+1.  然后我们遍历数据：
 
 ```py
 print(f'Epoch : | {epoch+1:03} / {num_epochs:03} |')
 for i, data in enumerate(train_loader):
 ```
 
-12.  然后，我们通过清除梯度来开始训练判别器：
+2.  然后，我们通过清除梯度来开始训练判别器：
 
 ```py
 discriminator.zero_grad()
 ```
 
-13.  然后我们获取图像：
+3.  然后我们获取图像：
 
 ```py
 real_images = data[0].to(device)
 size = real_images.size(0)
 ```
 
-14.  然后，我们为这些图像创建标签：
+4.  然后，我们为这些图像创建标签：
 
 ```py
 label = torch.full((size,), real_label, device=device)
 ```
 
-15.  接下来，我们得到判别器输出：
+5.  接下来，我们得到判别器输出：
 
 ```py
 d_output = discriminator(real_images).view(-1)
 ```
 
-16.  然后我们计算判别器误差：
+6.  然后我们计算判别器误差：
 
 ```py
 derror_real = criterion(d_output, label)
 ```
 
-17.  接下来，我们计算梯度：
+7.  接下来，我们计算梯度：
 
 ```py
 derror_real.backward()
 ```
 
-18.  现在我们将创建一个噪声向量：
+8.  现在我们将创建一个噪声向量：
 
 ```py
 noise = torch.randn(size, z_dim, device=device)
 ```
 
-19.  接下来，我们将噪声向量传递给生成器：
+9.  接下来，我们将噪声向量传递给生成器：
 
 ```py
 fake_images = generator(noise)

new/pt-ai-fund/7.md

@@ -279,7 +279,7 @@ self.explore_limit = False
         batch = random.sample(self.memory, BATCH_SIZE)
 ```
 
-10.  现在，让我们使用批量更新 q 值：
+0.  现在，让我们使用批量更新 q 值：
 
 ```py
 for state, action, reward, next_state, terminal in batch:
@@ -291,7 +291,7 @@ for state, action, reward, next_state, terminal in batch:
     q_values[0][action] = q_update
 ```
 
-11.  接下来，我们计算损失并更新权重：
+1.  接下来，我们计算损失并更新权重：
 
 ```py
 loss = self.criterion(self.policy_net(state), q_values)
@@ -300,7 +300,7 @@ loss.backward()
 self.optimizer.step()
 ```
 
-12.  我们还将更新探查率：
+2.  我们还将更新探查率：
 
 ```py
 if not self.explore_limit:
@@ -437,7 +437,7 @@ if steps%UPDATE_FREQ == 0:
 .
 ```
 
-10.  现在，我们将定义一个函数，该函数将可视化 cart 的性能：
+0.  现在，我们将定义一个函数，该函数将可视化 cart 的性能：
 
 ```py
 >>def play_agent(dqn, env):

new/pt-ai-fund/8.md

@@ -105,13 +105,13 @@ pip install flask
 >>model = create_model()
 ```
 
-10.  现在，让我们创建路线：
+0.  现在，让我们创建路线：
 
 ```py
 >>@app.route('/predict', methods=['POST'])
 ```
 
-11.  接下来，我们将编写一个将在此路由上调用的函数：
+1.  接下来，我们将编写一个将在此路由上调用的函数：
 
 ```py
 >>@app.route('/predict', methods=['POST'])
@@ -125,14 +125,14 @@ pip install flask
       return jsonify({'object_name' : object_name})
 ```
 
-12.  最后，如果运行`imageapp.py`，我们将启动 Flask 应用程序：
+2.  最后，如果运行`imageapp.py`，我们将启动 Flask 应用程序：
 
 ```py
 >>if __name__ == '__main__':
     app.run(debug=True)
 ```
 
-13.  接下来，您需要使用以下命令运行 Flask 应用程序：
+3.  接下来，您需要使用以下命令运行 Flask 应用程序：
 
 ```py
 python imageapp.py
@@ -140,7 +140,7 @@ python imageapp.py
 
 通过运行此命令，Flask 服务器将启动并运行。 您应该可以通过`http://127.0.0.1:5000/`访问应用程序的 URL 并发送`POST`请求。
 
-14.  使用邮差工具，您可以检查 API。 这是图像的示例响应：
+4.  使用邮差工具，您可以检查 API。 这是图像的示例响应：
 
 ![](img/0cc7beb5-f92e-4caf-bb41-15799b308364.jpeg)
 
@@ -547,21 +547,21 @@ CNN(
 >>ort_session = onnxruntime.InferenceSession("cifar.onnx")
 ```
 
-10.  现在，定义`to_numpy()`函数：
+0.  现在，定义`to_numpy()`函数：
 
 ```py
 >>def to_numpy(tensor):
     return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()
 ```
 
-11.  在这里，我们将把输入变量`x`传递到 ONNX 运行时：
+1.  在这里，我们将把输入变量`x`传递到 ONNX 运行时：
 
 ```py
 >>ort_inputs = {ort_session.get_inputs()[0].name: to_numpy(x)}
 >>ort_outs = ort_session.run(None, ort_inputs)
 ```
 
-12.  最后，我们将检查模型和`onnx`模型的输出是否相等：
+2.  最后，我们将检查模型和`onnx`模型的输出是否相等：
 
 ```py
 >>np.testing.assert_allclose(to_numpy(model_out), ort_outs[0], rtol=1e-03, atol=1e-05)