通过前两次对前馈神经网络的探究实验，基础掌握了前馈神经网络的基本概念、网络结构及代码实现，利用前馈神经网络完成一个分类任务，并通过两个简单的实验，观察前馈神经网络的梯度消失问题和死亡ReLU问题，以及对应的优化策略。接下来便落实实例，完成基于前馈神经网络完成鸾尾花分类。
目录
深入研究鸾尾花数据集
在本实践中，我们继续使用第三章中的鸢尾花分类任务，将Softmax分类器替换为本章介绍的前馈神经网络。
- 损失函数：交叉熵损失；
- 优化器：随机梯度下降法；
- 评价指标：准确率。
小批量梯度下降法
在梯度下降法中，目标函数是整个训练集上的风险函数，这种方式称为批量梯度下降法。 批量梯度下降法在每次迭代时需要计算每个样本上损失函数的梯度并求和。当训练集中的样本数量 N 很大时，空间复杂度比较高，每次迭代的计算开销也很大。
为了减少每次迭代的计算复杂度，我们可以在每次迭代时只采集一小部分样本，计算在这组样本上损失函数的梯度并更新参数，这种优化方式称为小批量梯度下降法。
第 t 次迭代时，随机选取一个包含 K 个样本的子集，计算这个子集上每个样本损失函数的梯度并进行平均，然后再进行参数更新。
其中 K 为批量大小。K 通常不会设置很大，一般在1∼100之间。在实际应用中为了提高计算效率，通常设置为。
在实际应用中，小批量随机梯度下降法有收敛快、计算开销小的优点，因此逐渐成为大规模的机器学习中的主要优化算法,此外，随机梯度下降相当于在批量梯度下降的梯度上引入了随机噪声。在非凸优化问题中，随机梯度下降更容易逃离局部最优点。
小批量随机梯度下降法的训练过程如下：
数据分组
为了小批量梯度下降法，我们需要对数据进行随机分组。目前，机器学习中通常做法是构建一个数据迭代器，每个迭代过程中从全部数据集中获取一批指定数量的数据。
数据迭代器的实现原理如下图所示：
- 首先，将数据集封装为Dataset类，传入一组索引值，根据索引从数据集合中获取数据；
- 其次，构建DataLoader类，需要指定数据批量的大小和是否需要对数据进行乱序，通过该类即可批量获取数据。
数据处理
对鸾尾花数据集进行处理，构造IrisDataset类进行数据读取并进行继承和封装。
代码实现：
# 导入需要使用的所有包
import copy
import torch
import numpy as np
from torch import nn
import torch.optim as opt
import matplotlib.pyplot as plt
import torch.nn.functional as F
from sklearn.datasets import load_iris
import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"class IrisDataset(torch.utils.data.Dataset):
def __init__(self, mode='train', num_train=120, num_dev=15):
super(IrisDataset, self).__init__()
# 调用第三章中的数据读取函数，其中不需要将标签转成one-hot类型
X, y = load_data(shuffle=True)
if mode == 'train':
self.X, self.y = X[:num_train], y[:num_train]
elif mode == 'dev':
self.X, self.y = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev]
else:
self.X, self.y = X[num_train + num_dev:], y[num_train + num_dev:]
def __getitem__(self, idx):
return self.X[idx], self.y[idx]
def __len__(self):
return len(self.y)train_dataset = IrisDataset(mode='train')
dev_dataset = IrisDataset(mode='dev')
test_dataset = IrisDataset(mode='test')
# 打印数据集长度
print("length of train set: ", len(train_dataset))
print("length of dev set: ", len(dev_dataset))
print("length of test set: ", len(test_dataset))输出结果：
length of train set: 120
length of dev set: 15
length of test set: 15用DataLoader进行封装
# 批量大小
batch_size = 16
# 加载数据
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True,num_workers=0)
dev_loader = torch.utils.data.DataLoader(dev_dataset, batch_size=batch_size)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size)模型构建
构建一个简单的前馈神经网络进行鸢尾花分类实验。其中输入层神经元个数为4，输出层神经元个数为3，隐含层神经元个数为6。
基于前馈神经网络的鸾尾花分类
代码实现如下：
# 定义前馈神经网络
class Model_MLP_L2_V3(nn.Module):
def __init__(self, input_size, output_size, hidden_size):
super(Model_MLP_L2_V3, self).__init__()
# 构建第一个全连接层
self.fc1 = nn.Linear(input_size,hidden_size)
nn.init.normal_(tensor=self.fc1.weight,mean=0.0, std=0.01)
nn.init.constant_(tensor=self.fc1.bias,val=1.0)
# 构建第二全连接层
self.fc2 = nn.Linear(hidden_size,output_size)
nn.init.normal_(tensor=self.fc2.weight,mean=0.0, std=0.01)
nn.init.constant_(tensor=self.fc2.bias,val=1.0)
# 定义网络使用的激活函数
self.act = nn.Sigmoid()
def forward(self, inputs):
outputs = self.fc1(inputs)
outputs = self.act(outputs)
outputs = self.fc2(outputs)
return outputs
fnn_model = Model_MLP_L2_V3(input_size=4, output_size=3, hidden_size=6)完善Runner类
基于RunnerV2类进行完善实现了RunnerV3类。其中训练过程使用自动梯度计算，使用Dataloader加载批量数据，使用随机梯度下降法进行参数优化；模型保存时，使用state_dict方法获取模型参数；模型加载时，使用set_state_dict方法加载此参数。
由于这里使用随机梯度下降法对参数优化，所以数据以批次的形式输入到模型中进行训练，那么评价指标计算也是分别在每个批次进行的，要想获得每个epoch整体的评价结果，需要对历史评价结果进行累积。这里定义Accuracy类实现该功能。
class Accuracy():
def __init__(self, is_logist=True):
"""
输入：
- is_logist: outputs是logist还是激活后的值
"""
# 用于统计正确的样本个数
self.num_correct = 0
# 用于统计样本的总数
self.num_count = 0
self.is_logist = is_logist
def update(self, outputs, labels):
"""
输入：
- outputs: 预测值, shape=[N,class_num]
- labels: 标签值, shape=[N,1]
"""
# 判断是二分类任务还是多分类任务，shape[1]=1时为二分类任务，shape[1]>1时为多分类任务
if outputs.shape[1] == 1: # 二分类
outputs = torch.squeeze(outputs, dim=-1)
if self.is_logist:
# logist判断是否大于0
preds = torch.tensor((outputs >= 0), dtype=torch.float32)
else:
# 如果不是logist，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0
preds = torch.tensor((outputs >= 0.5), dtype=torch.float32)
else:
# 多分类时，使用'paddle.argmax'计算最大元素索引作为类别
preds = torch.argmax(outputs, dim=1)
# 获取本批数据中预测正确的样本个数
labels = torch.squeeze(labels, dim=-1)
batch_correct = torch.sum(torch.tensor(preds == labels, dtype=torch.float32)).numpy()
batch_count = len(labels)
# 更新num_correct 和 num_count
self.num_correct += batch_correct
self.num_count += batch_count
def accumulate(self):
# 使用累计的数据，计算总的指标
if self.num_count == 0:
return 0
return self.num_correct / self.num_count
def reset(self):
# 重置正确的数目和总数
self.num_correct = 0
self.num_count = 0
def name(self):
return "Accuracy"RunnerV3类的代码实现如下：
class RunnerV3(object):
def __init__(self, model, optimizer, loss_fn, metric, **kwargs):
self.model = model
self.optimizer = optimizer
self.loss_fn = loss_fn
self.metric = metric # 只用于计算评价指标
# 记录训练过程中的评价指标变化情况
self.dev_scores = []
# 记录训练过程中的损失函数变化情况
self.train_epoch_losses = [] # 一个epoch记录一次loss
self.train_step_losses = [] # 一个step记录一次loss
self.dev_losses = []
# 记录全局最优指标
self.best_score = 0
def train(self, train_loader, dev_loader=None, **kwargs):
# 将模型切换为训练模式
self.model.train()
# 传入训练轮数，如果没有传入值则默认为0
num_epochs = kwargs.get("num_epochs", 0)
# 传入log打印频率，如果没有传入值则默认为100
log_steps = kwargs.get("log_steps", 100)
# 评价频率
eval_steps = kwargs.get("eval_steps", 0)
# 传入模型保存路径，如果没有传入值则默认为"best_model.pdparams"
save_path = kwargs.get("save_path", "best_model.pdparams")
custom_print_log = kwargs.get("custom_print_log", None)
# 训练总的步数
num_training_steps = num_epochs * len(train_loader)
if eval_steps:
if self.metric is None:
raise RuntimeError('Error: Metric can not be None!')
if dev_loader is None:
raise RuntimeError('Error: dev_loader can not be None!')
# 运行的step数目
global_step = 0
# 进行num_epochs轮训练
for epoch in range(num_epochs):
# 用于统计训练集的损失
total_loss = 0
for step, data in enumerate(train_loader):
X, y = data
# 获取模型预测
logits = self.model(X)
loss = self.loss_fn(logits, y) # 默认求mean
total_loss += loss
# 训练过程中，每个step的loss进行保存
self.train_step_losses.append((global_step, loss.item()))
if log_steps and global_step % log_steps == 0:
print(
f"[Train] epoch: {epoch}/{num_epochs}, step: {global_step}/{num_training_steps}, loss: {loss.item():.5f}")
# 梯度反向传播，计算每个参数的梯度值
loss.backward()
if custom_print_log:
custom_print_log(self)
# 小批量梯度下降进行参数更新
self.optimizer.step()
# 梯度归零
self.optimizer.zero_grad()
# 判断是否需要评价
if eval_steps > 0 and global_step > 0 and \
(global_step % eval_steps == 0 or global_step == (num_training_steps - 1)):
dev_score, dev_loss = self.evaluate(dev_loader, global_step=global_step)
print(f"[Evaluate] dev score: {dev_score:.5f}, dev loss: {dev_loss:.5f}")
# 将模型切换为训练模式
self.model.train()
# 如果当前指标为最优指标，保存该模型
if dev_score > self.best_score:
self.save_model(save_path)
print(
f"[Evaluate] best accuracy performence has been updated: {self.best_score:.5f} --> {dev_score:.5f}")
self.best_score = dev_score
global_step += 1
# 当前epoch 训练loss累计值
trn_loss = (total_loss / len(train_loader)).item()
# epoch粒度的训练loss保存
self.train_epoch_losses.append(trn_loss)
print("[Train] Training done!")
# 模型评估阶段，使用'paddle.no_grad()'控制不计算和存储梯度
@torch.no_grad()
def evaluate(self, dev_loader, **kwargs):
assert self.metric is not None
# 将模型设置为评估模式
self.model.eval()
global_step = kwargs.get("global_step", -1)
# 用于统计训练集的损失
total_loss = 0
# 重置评价
self.metric.reset()
# 遍历验证集每个批次
for batch_id, data in enumerate(dev_loader):
X, y = data
# 计算模型输出
logits = self.model(X)
# 计算损失函数
loss = self.loss_fn(logits, y).item()
# 累积损失
total_loss += loss
# 累积评价
self.metric.update(logits, y)
dev_loss = (total_loss / len(dev_loader))
dev_score = self.metric.accumulate()
# 记录验证集loss
if global_step != -1:
self.dev_losses.append((global_step, dev_loss))
self.dev_scores.append(dev_score)
return dev_score, dev_loss
# 模型评估阶段，使用'paddle.no_grad()'控制不计算和存储梯度
@torch.no_grad()
def predict(self, x, **kwargs):
# 将模型设置为评估模式
self.model.eval()
# 运行模型前向计算，得到预测值
logits = self.model(x)
return logits
def save_model(self, save_path):
torch.save(self.model.state_dict(), save_path)
def load_model(self, model_path):
model_state_dict = torch.load(model_path)
self.model.set_state_dict(model_state_dict)模型训练
实例化RunnerV3类，并传入训练配置，代码实现如下：
lr = 0.2
# 定义网络
model = fnn_model
# 定义优化器
optimizer = opt.SGD(lr=lr, params=model.parameters())
# 定义损失函数。softmax+交叉熵
loss_fn = F.cross_entropy
# 定义评价指标
metric = Accuracy(is_logist=True)
runner = RunnerV3(model, optimizer, loss_fn, metric)使用训练集和验证集进行模型训练，共训练150个epoch。在实验中，保存准确率最高的模型作为最佳模型。代码实现如下：
# 启动训练
log_steps = 100
eval_steps = 50
runner.train(train_loader, dev_loader,
num_epochs=150, log_steps=log_steps, eval_steps = eval_steps,
save_path="best_model.pdparams")训练结果为：
[Train] epoch: 0/150, step: 0/1200, loss: 1.10467
[Evaluate] dev score: 0.26667, dev loss: 1.22231
[Evaluate] best accuracy performence has been updated: 0.00000 --> 0.26667
[Train] epoch: 12/150, step: 100/1200, loss: 1.11286
[Evaluate] dev score: 0.26667, dev loss: 1.11308
[Evaluate] dev score: 0.26667, dev loss: 1.13753
[Train] epoch: 25/150, step: 200/1200, loss: 1.11455
[Evaluate] dev score: 0.26667, dev loss: 1.12687
[Evaluate] dev score: 0.26667, dev loss: 1.11112
[Train] epoch: 37/150, step: 300/1200, loss: 1.07319
[Evaluate] dev score: 0.26667, dev loss: 1.09228
[Evaluate] dev score: 0.26667, dev loss: 1.07941
[Train] epoch: 50/150, step: 400/1200, loss: 0.96820
[Evaluate] dev score: 0.53333, dev loss: 1.02344
[Evaluate] best accuracy performence has been updated: 0.26667 --> 0.53333
[Evaluate] dev score: 0.53333, dev loss: 0.93751
[Train] epoch: 62/150, step: 500/1200, loss: 0.72586
[Evaluate] dev score: 0.60000, dev loss: 0.77080
[Evaluate] best accuracy performence has been updated: 0.53333 --> 0.60000
[Evaluate] dev score: 0.66667, dev loss: 0.67423
[Evaluate] best accuracy performence has been updated: 0.60000 --> 0.66667
[Train] epoch: 75/150, step: 600/1200, loss: 0.53801
[Evaluate] dev score: 0.86667, dev loss: 0.57472
[Evaluate] best accuracy performence has been updated: 0.66667 --> 0.86667
[Evaluate] dev score: 0.80000, dev loss: 0.56176
[Train] epoch: 87/150, step: 700/1200, loss: 0.38122
[Evaluate] dev score: 0.86667, dev loss: 0.50781
[Evaluate] dev score: 0.93333, dev loss: 0.46224
[Evaluate] best accuracy performence has been updated: 0.86667 --> 0.93333
[Train] epoch: 100/150, step: 800/1200, loss: 0.43660
[Evaluate] dev score: 0.93333, dev loss: 0.43534
[Evaluate] dev score: 1.00000, dev loss: 0.40225
[Evaluate] best accuracy performence has been updated: 0.93333 --> 1.00000
[Train] epoch: 112/150, step: 900/1200, loss: 0.33995
[Evaluate] dev score: 0.93333, dev loss: 0.38908
[Evaluate] dev score: 0.93333, dev loss: 0.36191
[Train] epoch: 125/150, step: 1000/1200, loss: 0.28941
[Evaluate] dev score: 1.00000, dev loss: 0.33070
[Evaluate] dev score: 1.00000, dev loss: 0.31569
[Train] epoch: 137/150, step: 1100/1200, loss: 0.27491
[Evaluate] dev score: 1.00000, dev loss: 0.30810
[Evaluate] dev score: 1.00000, dev loss: 0.28763
[Evaluate] dev score: 1.00000, dev loss: 0.26681
[Train] Training done!可视化观察训练集损失和训练集loss变化情况。
# 绘制训练集和验证集的损失变化以及验证集上的准确率变化曲线
def plot_training_loss_acc(runner, fig_name,
fig_size=(16, 6),
sample_step=20,
loss_legend_loc="upper right",
acc_legend_loc="lower right",
train_color="#8E004D",
dev_color='#E20079',
fontsize='x-large',
train_linestyle="-",
dev_linestyle='--'):
plt.figure(figsize=fig_size)
plt.subplot(1, 2, 1)
train_items = runner.train_step_losses[::sample_step]
train_steps = [x[0] for x in train_items]
train_losses = [x[1] for x in train_items]
plt.plot(train_steps, train_losses, color=train_color, linestyle=train_linestyle, label="Train loss")
if len(runner.dev_losses) > 0:
dev_steps = [x[0] for x in runner.dev_losses]
dev_losses = [x[1] for x in runner.dev_losses]
plt.plot(dev_steps, dev_losses, color=dev_color, linestyle=dev_linestyle, label="Dev loss")
# 绘制坐标轴和图例
plt.ylabel("loss", fontsize=fontsize)
plt.xlabel("step", fontsize=fontsize)
plt.legend(loc=loss_legend_loc, fontsize=fontsize)
# 绘制评价准确率变化曲线
if len(runner.dev_scores) > 0:
plt.subplot(1, 2, 2)
plt.plot(dev_steps, runner.dev_scores,
color=dev_color, linestyle=dev_linestyle, label="Dev accuracy")
# 绘制坐标轴和图例
plt.ylabel("score", fontsize=fontsize)
plt.xlabel("step", fontsize=fontsize)
plt.legend(loc=acc_legend_loc, fontsize=fontsize)
plt.savefig(fig_name)
plt.show()
plot_training_loss_acc(runner, 'fw-loss.pdf')所绘制图像为
从输出结果可以看出准确率随着迭代次数增加逐渐上升，损失函数下降，最终准确率回达到趋近于1的程度。
模型评价
使用测试数据对在训练过程中保存的最佳模型进行评价，观察模型在测试集上的准确率以及Loss情况。代码实现如下：
score, loss = runner.evaluate(test_loader)
print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))输出结果：
[Test] accuracy/loss: 1.0000/0.1564模型预测
同样地，也可以使用保存好的模型，对测试集中的某一个数据进行模型预测，观察模型效果。代码实现如下：
test_loader = iter(test_loader)
# 获取测试集中第一条数据
(X, label) = next(test_loader)
logits = runner.predict(X)
pred_class = torch.argmax(logits[0]).numpy()
label = label.numpy()[0]
# 输出真实类别与预测类别
print("The true category is {} and the predicted category is {}".format(label, pred_class))输出为：
The true category is 2 and the predicted category is 2思考题
对比Softmax分类和前馈神经网络分类
首先是Softmax对实现对鸾尾花数据集的分类：
data_x, data_y = load_data()
iris_first = []
iris_second = []
iris_third = []
for i in range(0,len(data_y)):
if(data_y[i]==0):
iris_first.append(data_x[i, :].numpy())
elif(data_y[i]==2):
iris_second.append(data_x[i, :].numpy())
else:
iris_third.append(data_x[i,:].numpy())
iris_first = torch.tensor(iris_first)
iris_second = torch.tensor(iris_second)
iris_third = torch.tensor(iris_third)
plt.scatter(iris_first[:, 0], iris_first[:, 1], c='b')
plt.scatter(iris_second[:, 0], iris_second[:, 1], c='y')
plt.scatter(iris_third[:, 0], iris_third[:, 1], c='g')
plt.legend(['iris versicolor', 'iris setosa', 'iris vlrglnica'])
plt.show()tensor([4.3000, 2.0000, 1.0000, 0.1000])
此输出为鸾尾花数据集数据可视化表现。
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.linear_model import LogisticRegression
iris = datasets.load_iris() # 加载数据
list(iris.keys()) # ['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename', 'data_module']
X = iris["data"][:, 3:] # 花瓣长度
y = (iris["target"] == 2).astype(np.int32) # 标签，是维吉尼亚鸢尾花y就是1，否则为0
log_reg = LogisticRegression(solver="lbfgs", random_state=42)
log_reg.fit(X, y) # 训练模型
# 绘制预测图像
X_new = np.linspace(0, 3, 1000).reshape(-1, 1)
y_proba = log_reg.predict_proba(X_new)
plt.plot(X_new, y_proba[:, 1], "g-", linewidth=2, label="Iris virginica")
plt.plot(X_new, y_proba[:, 0], "b--", linewidth=2, label="Not Iris virginica")
plt.xlabel("Petal width", fontsize=12)
plt.ylabel("Probability", fontsize=13)
plt.legend(loc="center left", fontsize=11)
plt.show()
log_reg.predict([[1.7], [1.5]]) # 输出：array([1, 0], dtype=int32)from sklearn.linear_model import LogisticRegression
X = iris["data"][:, (2, 3)] # 花瓣长度和宽度两个特征
y = (iris["target"] == 2).astype(np.int32)
log_reg = LogisticRegression(solver="lbfgs", C=10 ** 10, random_state=42)
log_reg.fit(X, y) # 训练模型
x0, x1 = np.meshgrid(
np.linspace(2.9, 7, 500).reshape(-1, 1),
np.linspace(0.8, 2.7, 200).reshape(-1, 1),
)
X_new = np.c_[x0.ravel(), x1.ravel()]
y_proba = log_reg.predict_proba(X_new)
plt.figure(figsize=(10, 4))
plt.plot(X[y == 0, 0], X[y == 0, 1], "bs")
plt.plot(X[y == 1, 0], X[y == 1, 1], "g^")
zz = y_proba[:, 1].reshape(x0.shape)
contour = plt.contour(x0, x1, zz, cmap=plt.cm.brg)
# 模型的决策边界。这是点x的集合，使得θ0+θ1x1+θ2x2=0，它定义了一条直线。
left_right = np.array([2.9, 7])
boundary = -(log_reg.coef_[0][0] * left_right + log_reg.intercept_[0]) / log_reg.coef_[0][1]
plt.clabel(contour, inline=1, fontsize=12)
plt.plot(left_right, boundary, "k--", linewidth=3)
plt.text(3.5, 1.5, "Not Iris virginica", fontsize=14, color="r", ha="center")
plt.text(6.5, 2.3, "Iris virginica", fontsize=14, color="b", ha="center")
plt.xlabel("Petal length", fontsize=12)
plt.ylabel("Petal width", fontsize=12)
plt.axis([2.9, 7, 0.8, 2.7])
plt.show()
X = iris["data"][:, (2, 3)] # 花瓣长度, 花瓣宽度
y = iris["target"]
# 设置超参数multi_class为"multinomial"，指定一个支持Softmax回归的求解器，默认使用l2正则化，可以通过超参数C进行控制
softmax_reg = LogisticRegression(multi_class="multinomial", solver="lbfgs", C=5, random_state=42)
softmax_reg.fit(X, y)
softmax_reg.predict([[5, 2]]) # 输出：array([2])
softmax_reg.predict_proba([[5, 2]])
x0, x1 = np.meshgrid(
np.linspace(0, 8, 500).reshape(-1, 1),
np.linspace(0, 3.5, 200).reshape(-1, 1),
)
X_new = np.c_[x0.ravel(), x1.ravel()]
y_proba = softmax_reg.predict_proba(X_new)
y_predict = softmax_reg.predict(X_new)
zz1 = y_proba[:, 1].reshape(x0.shape)
zz = y_predict.reshape(x0.shape)
plt.figure(figsize=(8, 3))
plt.plot(X[y == 2, 0], X[y == 2, 1], "g^", label="Iris virginica")
plt.plot(X[y == 1, 0], X[y == 1, 1], "bs", label="Iris versicolor")
plt.plot(X[y == 0, 0], X[y == 0, 1], "yo", label="Iris setosa")
from matplotlib.colors import ListedColormap
custom_cmap = ListedColormap(['#fafab0', '#9898ff', '#a0faa0'])
plt.contourf(x0, x1, zz, cmap=custom_cmap)
plt.clabel(contour, inline=1, fontsize=10)
plt.xlabel("Petal length", fontsize=13)
plt.ylabel("Petal width", fontsize=13)
plt.legend(loc="center left", fontsize=13)
plt.axis([0, 7, 0, 3.5])
plt.title('C=5')
plt.show()通过不断改变C的值以控制他的分类结果，当C=1时：
当C=5时：
当C=50时：
当C=500时：
总结
（ 如有纰漏或错误敬请指出）
做完本次实验就意味着前馈神经网络的知识学完了，即将要学习卷积神经网络，从这次的实验看来，其中许多地方我还尚有不足，例如许多命令语句并不知道如何去使用等等还有许多，但是也是有收获的，从开始的迷茫到后来知道了实现模型训练的每个过程，学会了paddle与pytorch的相互转换，paddle中一些代码语句的作用等，但是仍有较多不足，而且对课程的进度感到有些压力，所以后面会投入更多的时间去将不会的部分给补上。
参考
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
