Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
大唐爆破僧
apachecn-dl-zh
提交
77295c9d
A
apachecn-dl-zh
项目概览
大唐爆破僧
/
apachecn-dl-zh
与 Fork 源项目一致
Fork自
OpenDocCN / apachecn-dl-zh
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
A
apachecn-dl-zh
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
77295c9d
编写于
1月 17, 2021
作者:
W
wizardforcel
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
2021-01-17 22:26:16
上级
3fba2354
变更
1
隐藏空白更改
内联
并排
Showing
1 changed file
with
268 addition
and
467 deletion
+268
-467
new/dl-pt-workshop/7.md
new/dl-pt-workshop/7.md
+268
-467
未找到文件。
new/dl-pt-workshop/7.md
浏览文件 @
77295c9d
...
@@ -802,93 +802,70 @@
...
@@ -802,93 +802,70 @@
1.
导入所需的库。
1.
导入所需的库。
将 numpy 导入为 np
```py
import numpy as np
进口火炬
import torch
from torch import nn, optim
从火炬进口 nn,乐观
import torch.nn.functional as F
from torchvision import datasets
导入功能为 F 的 torch.nn。
import torchvision.transforms as transforms
from torch.utils.data.sampler import SubsetRandomSampler
从 torchvision 导入数据集中
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
导入 torchvision.transforms 作为转换
```
从 torch.utils.data.sampler 导入 SubsetRandomSampler
从 sklearn.metrics 导入 precision_score
导入 matplotlib.pyplot 作为 plt
2.
设置要对数据进行的变换,将数据转换为张量并对像素值进行归一化。
2.
设置要对数据进行的变换,将数据转换为张量并对像素值进行归一化。
变换= \
```py
transform = \
transforms.Compose([[transforms.ToTensor(),\
transforms.Compose([transforms.ToTensor(), \
transforms.Normalize((0.5, 0.5, 0.5),\
transforms.Normalize((0.5,0.5,0.5),\
(0.5, 0.5, 0.5))])
```
(0.5, 0.5, 0.5))])
3.
设置批量大小为 100 张图像,并从
**CIFAR10**
数据集下载训练和测试数据。
3.
设置批量大小为 100 张图像,并从
**CIFAR10**
数据集下载训练和测试数据。
```py
batch_size = 100
batch_size = 100
train_data = datasets.CIFAR10('data', train=True, \
train_data =数据集.CIFAR10('data',train = True,\
download=True, \
transform=transform)
download = True,\
test_data = datasets.CIFAR10('data', train=False, \
download=True, \
转换=转换)
transform=transform)
```
test_data =数据集.CIFAR10('data',train = False,\
download = True,\
转换=转换)
前面的代码将下载可通过 PyTorch 的`Torchvision`软件包获得的训练和测试数据集。 根据上一步中定义的转换对数据集进行转换。
前面的代码将下载可通过 PyTorch 的`Torchvision`软件包获得的训练和测试数据集。 根据上一步中定义的转换对数据集进行转换。
4.
使用 20% 的验证大小,定义训练和验证采样器,用于将数据集划分为这两组。
4.
使用 20% 的验证大小,定义训练和验证采样器,用于将数据集划分为这两组。
```py
dev_size = 0.2
dev_size = 0.2
idx = list(range(len(train_data)))
idx =列表(范围(len(train_data)))
np.random.shuffle(idx)
split_size = int(np.floor(dev_size * len(train_data)))
np.random.shuffle(idx)
train_idx, dev_idx = idx[split_size:], idx[:split_size]
train_sampler = SubsetRandomSampler(train_idx)
split_size = int(np.floor(dev_size * len(train_data)))
dev_sampler = SubsetRandomSampler(dev_idx)
```
train_idx,dev_idx = idx [split_size:],idx [:split_size]
train_sampler = SubsetRandomSampler(train_idx)
dev_sampler = SubsetRandomSampler(dev_idx)
为了将训练集分为两组(训练和验证),为每个组定义了一个索引列表,然后可以使用`SubsetRandomSampler`函数对其进行随机采样。
为了将训练集分为两组(训练和验证),为每个组定义了一个索引列表,然后可以使用`SubsetRandomSampler`函数对其进行随机采样。
5.
使用
`DataLoader()`
函数来定义要使用的每一组数据的批次。
5.
使用
`DataLoader()`
函数来定义要使用的每一组数据的批次。
```py
train_loader = \
train_loader = \
torch.utils.data.DataLoader(train_data, \
torch.utils.data.DataLoader(train_data,\
batch_size=batch_size, \
sampler=train_sampler)
batch_size =批量大小,\
sampler = train_sampler)
dev_loader = \
dev_loader = \
torch.utils.data.DataLoader(train_data, \
torch.utils.data.DataLoader(train_data,\
batch_size=batch_size, \
sampler=dev_sampler)
batch_size =批量大小,\
sampler = dev_sampler)
test_loader = \
test_loader = \
torch.utils.data.DataLoader(test_data, \
torch.utils.data.DataLoader(test_data,\
batch_size=batch_size)
```
batch_size =批量大小)
PyTorch 的`DataLoader`函数用于创建批量,这些批量将在开发过程的训练,验证和测试阶段馈送到模型中。
PyTorch 的`DataLoader`函数用于创建批量,这些批量将在开发过程的训练,验证和测试阶段馈送到模型中。
...
@@ -910,319 +887,188 @@
...
@@ -910,319 +887,188 @@
Linear2:一个全连接层,可生成 10 个输出,每个类标签一个。 将`log_softmax`激活函数用于输出层:
Linear2:一个全连接层,可生成 10 个输出,每个类标签一个。 将`log_softmax`激活函数用于输出层:
CNN(nn.Module)类:
```py
class CNN(nn.Module):
def __init __():
def __init__(self):
super(CNN, self).__init__()
超级(CNN,自我).__ init __()
self.conv1 = nn.Conv2d(3, 10, 3, 1, 1)
self.conv2 = nn.Conv2d(10, 20, 3, 1, 1)
self.conv1 = nn.Conv2d(3,10,3,1,1)
self.conv3 = nn.Conv2d(20, 40, 3, 1, 1)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(10,20,3,1,1)
self.linear1 = nn.Linear(40 * 4 * 4, 100)
self.linear2 = nn.Linear(100, 10)
self.conv3 = nn.Conv2d(20,40,3,1,1)
self.dropout = nn.Dropout(0.2)
def forward(self, x):
self.pool = nn.MaxPool2d(2,2)
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
self.linear1 = nn.Linear(40 * 4 * 4,100)
x = self.pool(F.relu(self.conv3(x)))
x = x.view(-1, 40 * 4 * 4)
self.linear2 = nn.Linear(100,10)
x = self.dropout(x)
x = F.relu(self.linear1(x))
self.dropout = nn.Dropout(0.2)
x = self.dropout(x)
x = F.log_softmax(self.linear2(x), dim=1)
def forward(self,x):
return x
```
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = self.pool(F.relu(self.conv3(x)))
x = x.view(-1,40 * 4 * 4)
x = self.dropout(x)
x = F.relu(self.linear1(x))
x = self.dropout(x)
x = F.log_softmax(self.linear2(x),dim = 1)
返回 x
前面的代码段包含一个定义了网络架构的类(`__init__`方法),以及在信息正向传递过程中所遵循的步骤(`forward`方法)。
前面的代码段包含一个定义了网络架构的类(`__init__`方法),以及在信息正向传递过程中所遵循的步骤(`forward`方法)。
7.
定义训练模型所需的所有参数。设置周期数为
`50`
。
7.
定义训练模型所需的所有参数。设置周期数为
`50`
。
型号= CNN()
```py
model = CNN()
loss_function = nn.NLLLoss()
loss_function = nn.NLLLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
优化程序= optim.Adam(model.parameters(),lr = 0.001)
epochs = 50
```
时代= 50
我们为此练习选择的优化器是 Adam。 同样,负对数似然率用作损失函数,如本书前一章所述。
我们为此练习选择的优化器是 Adam。 同样,负对数似然率用作损失函数,如本书前一章所述。
如果您的计算机具有可用的 GPU,则应按以下步骤完成模型的实例化:
如果您的计算机具有可用的 GPU,则应按以下步骤完成模型的实例化:
型号= CNN()。to(“ cuda”)
```py
model = CNN().to("cuda")
```
8.
训练你的网络,并确保保存训练集和验证集的损失和准确性的值。
8.
训练你的网络,并确保保存训练集和验证集的损失和准确性的值。
train_losses,dev_losses,train_acc,dev_acc = [],[],[],[]
```py
train_losses, dev_losses, train_acc, dev_acc= [], [], [], []
x_axis = []
x_axis = []
# For loop through the epochs
#循环遍历
for e in range(1, epochs+1):
losses = 0
对于范围(1,历元+1)中的 e:
acc = 0
iterations = 0
损失= 0
model.train()
"""
acc = 0
For loop through the batches (created using
the train loader)
迭代次数= 0
"""
for data, target in train_loader:
model.train()
iterations += 1
# Forward and backward pass of the training data
"""
pred = model(data)
loss = loss_function(pred, target)
For 遍历批量(使用创建
optimizer.zero_grad()
loss.backward()
火车装载者)
optimizer.step()
losses += loss.item()
"""
p = torch.exp(pred)
top_p, top_class = p.topk(1, dim=1)
对于数据,在 train_loader 中定位:
acc += accuracy_score(target, top_class)
dev_losss = 0
迭代次数== 1
dev_accs = 0
iter_2 = 0
#训练数据的前后传递
# Validation of model for given epoch
if e%5 == 0 or e == 1:
pred =模型(数据)
x_axis.append(e)
with torch.no_grad():
损失= loss_function(pred,目标)
model.eval()
"""
Optimizer.zero_grad()
For loop through the batches of
the validation set
loss.backward()
"""
for data_dev, target_dev in dev_loader:
Optimizer.step()
iter_2 += 1
dev_pred = model(data_dev)
损失+ = loss.item()
dev_loss = loss_function(dev_pred, target_dev)
dev_losss += dev_loss.item()
p = torch.exp(pred)
dev_p = torch.exp(dev_pred)
top_p, dev_top_class = dev_p.topk(1, dim=1)
top_p,top_class = p.topk(1,暗= 1)
dev_accs += accuracy_score(target_dev, \
dev_top_class)
acc + = precision_score(target,top_class)
# Losses and accuracy are appended to be printed
train_losses.append(losses/iterations)
dev_losss = 0
dev_losses.append(dev_losss/iter_2)
train_acc.append(acc/iterations)
dev_accs = 0
dev_acc.append(dev_accs/iter_2)
print("Epoch: {}/{}.. ".format(e, epochs), \
iter_2 = 0
"Training Loss: {:.3f}.. "\
.format(losses/iterations), \
#验证给定时期的模型
"Validation Loss: {:.3f}.. "\
.format(dev_losss/iter_2), \
如果 e% 5 == 0 或 e == 1:
"Training Accuracy: {:.3f}.. "\
.format(acc/iterations), \
x_axis.append(e)
"Validation Accuracy: {:.3f}"\
.format(dev_accs/iter_2))
使用 torch.no_grad():
```
model.eval()
"""
用于循环遍历
验证集
"""
对于 dev_loader 中的 data_dev,target_dev:
iter_2 + = 1
dev_pred =模型(data_dev)
dev_loss = loss_function(dev_pred,target_dev)
dev_losss + = dev_loss.item()
dev_p = torch.exp(dev_pred)
top_p,dev_top_class = dev_p.topk(1,暗= 1)
dev_accs + = precision_score(target_dev,\
dev_top_class)
#损失和准确率将附加打印
train_losses.append(损失/迭代)
dev_losses.append(dev_losss / iter_2)
train_acc.append(acc /迭代)
dev_acc.append(dev_accs / iter_2)
print(“ Epoch:{} / {} ..”“ .format(e,epochs),\
“训练损失:{:. 3f} ..” \
.format(损失/迭代),\
“验证损失:{:. 3f} ..” \
.format(dev_losss / iter_2),\
“训练准确率:{:. 3f} ..” \
.format(acc / iterations),\
“验证准确率:{:. 3f}” \
.format(dev_accs / iter_2))
如果您的计算机具有可用的 GPU,则对前面的代码进行一些修改,如下所示:
如果您的计算机具有可用的 GPU,则对前面的代码进行一些修改,如下所示:
train_losses,dev_losses,train_acc,dev_acc = [],[],[],[]
```py
train_losses, dev_losses, train_acc, dev_acc= [], [], [], []
x_axis = []
x_axis = []
# For loop through the epochs
#循环遍历
for e in range(1, epochs+1):
losses = 0
对于范围(1,历元+1)中的 e:
acc = 0
iterations = 0
损失= 0
model.train()
acc = 0
"""
For loop through the batches
迭代次数= 0
(created using the train loader)
"""
model.train()
for data, target in train_loader:
iterations += 1
"""
# Forward and backward pass of the training data
pred = model(data.to("cuda"))
循环遍历批量
loss = loss_function(pred, target.to("cuda"))
optimizer.zero_grad()
(使用火车装载程序创建)
loss.backward()
optimizer.step()
"""
losses += loss.item()
p = torch.exp(pred)
对于数据,在 train_loader 中定位:
top_p, top_class = p.topk(1, dim=1)
acc += accuracy_score(target.to("cpu"), \
迭代次数== 1
top_class.to("cpu"))
dev_losss = 0
#训练数据的前后传递
dev_accs = 0
iter_2 = 0
pred =模型(data.to(“ cuda”))
# Validation of model for given epoch
if e%5 == 0 or e == 1:
损失= loss_function(pred,target.to(“ cuda”))
x_axis.append(e)
with torch.no_grad():
Optimizer.zero_grad()
model.eval()
"""
loss.backward()
For loop through the batches of
the validation set
Optimizer.step()
"""
for data_dev, target_dev in dev_loader:
损失+ = loss.item()
iter_2 += 1
dev_pred = model(data_dev.to("cuda"))
p = torch.exp(pred)
dev_loss = loss_function(dev_pred, \
target_dev.to("cuda"))
top_p,top_class = p.topk(1,暗= 1)
dev_losss += dev_loss.item()
dev_p = torch.exp(dev_pred)
acc + = precision_score(target.to(“ cpu”),\
top_p, dev_top_class = dev_p.topk(1, dim=1)
dev_accs += \
top_class.to(“ cpu”))
accuracy_score(target_dev.to("cpu"), \
dev_top_class.to("cpu"))
dev_losss = 0
# Losses and accuracy are appended to be printed
train_losses.append(losses/iterations)
dev_accs = 0
dev_losses.append(dev_losss/iter_2)
train_acc.append(acc/iterations)
iter_2 = 0
dev_acc.append(dev_accs/iter_2)
print("Epoch: {}/{}.. ".format(e, epochs), \
#验证给定时期的模型
"Training Loss: {:.3f}.. "\
.format(losses/iterations), \
如果 e% 5 == 0 或 e == 1:
"Validation Loss: {:.3f}.. "\
.format(dev_losss/iter_2), \
x_axis.append(e)
"Training Accuracy: {:.3f}.. "\
.format(acc/iterations), \
使用 torch.no_grad():
"Validation Accuracy: {:.3f}"\
.format(dev_accs/iter_2))
model.eval()
```
"""
用于循环遍历
验证集
"""
对于 dev_loader 中的 data_dev,target_dev:
iter_2 + = 1
dev_pred =模型(data_dev.to(“奇迹”))
dev_loss = loss_function(dev_pred,\
target_dev.to(“ cuda”))
dev_losss + = dev_loss.item()
dev_p = torch.exp(dev_pred)
top_p,dev_top_class = dev_p.topk(1,暗= 1)
dev_accs + = \
precision_score(target_dev.to(“ cpu”),\
dev_top_class.to(“ cpu”))
#损失和准确率将附加打印
train_losses.append(损失/迭代)
dev_losses.append(dev_losss / iter_2)
train_acc.append(acc /迭代)
dev_acc.append(dev_accs / iter_2)
print(“ Epoch:{} / {} ..”“ .format(e,epochs),\
“训练损失:{:. 3f} ..” \
.format(损失/迭代),\
“验证损失:{:. 3f} ..” \
.format(dev_losss / iter_2),\
“训练准确率:{:. 3f} ..” \
.format(acc / iterations),\
“验证准确率:{:. 3f}” \
.format(dev_accs / iter_2))
9.
绘制这两组数据的损失和精度。要绘制损失,请使用以下代码。
9.
绘制这两组数据的损失和精度。要绘制损失,请使用以下代码。
plt.plot(x_axis,train_losses,label ='训练损失')
```py
plt.plot(x_axis,train_losses, label='Training loss')
plt.plot(x_axis,dev_losses,label ='验证损失')
plt.plot(x_axis, dev_losses, label='Validation loss')
plt.legend(frameon=False)
plt.legend(frameon = False)
plt.show()
plt.show()
```
结果图应类似于以下内容:
结果图应类似于以下内容:
...
@@ -1232,13 +1078,12 @@
...
@@ -1232,13 +1078,12 @@
要绘制精度,请使用以下代码:
要绘制精度,请使用以下代码:
plt.plot(x_axis,train_acc,label =“训练精度”)
```py
plt.plot(x_axis, train_acc, label="Training accuracy")
plt.plot(x_axis,dev_acc,label =“验证准确率”)
plt.plot(x_axis, dev_acc, label="Validation accuracy")
plt.legend(frameon=False)
plt.legend(frameon = False)
plt.show()
plt.show()
```
该图应类似于以下内容:
该图应类似于以下内容:
...
@@ -1250,51 +1095,36 @@
...
@@ -1250,51 +1095,36 @@
10.
在测试集上检查模型的准确性。
10.
在测试集上检查模型的准确性。
model.eval()
```py
model.eval()
iter_3 = 0
iter_3 = 0
acc_test = 0
acc_test = 0
for data_test, target_test in test_loader:
对于 test_loader 中的 data_test 和 target_test:
iter_3 += 1
test_pred = model(data_test)
iter_3 + = 1
test_pred = torch.exp(test_pred)
top_p, top_class_test = test_pred.topk(1, dim=1)
test_pred =模型(data_test)
acc_test += accuracy_score(target_test, top_class_test)
print(acc_test/iter_3)
test_pred = torch.exp(test_pred)
```
top_p,top_class_test = test_pred.topk(1,暗= 1)
acc_test + =准确度得分(target_test,top_class_test)
打印(acc_test / iter_3)
使用我们之前创建的数据加载器,可以对测试集数据进行图像分类,以估计模型在看不见数据上的准确率。
使用我们之前创建的数据加载器,可以对测试集数据进行图像分类,以估计模型在看不见数据上的准确率。
如果您的计算机具有可用的 GPU,则对前面的代码进行一些修改,如下所示:
如果您的计算机具有可用的 GPU,则对前面的代码进行一些修改,如下所示:
model.eval()
```py
model.eval()
iter_3 = 0
iter_3 = 0
acc_test = 0
acc_test = 0
for data_test, target_test in test_loader:
对于 test_loader 中的 data_test 和 target_test:
iter_3 += 1
test_pred = model(data_test.to("cuda"))
iter_3 + = 1
test_pred = torch.exp(test_pred)
top_p, top_class_test = test_pred.topk(1, dim=1)
test_pred =模型(data_test.to(“ cuda”))
acc_test += accuracy_score(target_test .to("cpu"), \
top_class_test .to("cpu"))
test_pred = torch.exp(test_pred)
print(acc_test/iter_3)
```
top_p,top_class_test = test_pred.topk(1,暗= 1)
acc_test + = precision_score(target_test .to(“ cpu”),\
top_class_test .to(“ cpu”))
打印(acc_test / iter_3)
测试集的准确率与其他两组所达到的准确率非常相似,这意味着该模型能够对看不见的数据表现出同样出色的性能。 它应该在 72% 左右。
测试集的准确率与其他两组所达到的准确率非常相似,这意味着该模型能够对看不见的数据表现出同样出色的性能。 它应该在 72% 左右。
...
@@ -1320,27 +1150,19 @@
...
@@ -1320,27 +1150,19 @@
对于测试集,请勿添加任何其他转换:
对于测试集,请勿添加任何其他转换:
变换= \
```py
transform = \
{“火车”:transforms.Compose([\
{"train": transforms.Compose([\
transforms.RandomHorizontalFlip(0.5), \
transforms.RandomHorizontalFlip(0.5),\
transforms.RandomGrayscale(0.1),\
transforms.ToTensor(),\
transforms.RandomGrayscale(0.1),\
transforms.Normalize((0.5, 0.5, 0.5), \
(0.5, 0.5, 0.5))]),\
transforms.ToTensor(),\
"test": transforms.Compose([\
transforms.ToTensor(),\
transforms.Normalize((0.5,0.5,0.5),\
transforms.Normalize((0.5, 0.5, 0.5), \
(0.5, 0.5, 0.5))])}
(0.5, 0.5, 0.5))]),\
```
“ test”:transforms.Compose([\
transforms.ToTensor(),\
transforms.Normalize((0.5,0.5,0.5),\
(0.5, 0.5, 0.5))])}
3.
训练模型 100 个纪元。
3.
训练模型 100 个纪元。
...
@@ -1382,53 +1204,32 @@
...
@@ -1382,53 +1204,32 @@
网络的最终架构应如下:
网络的最终架构应如下:
CNN(nn.Module)类:
```py
class CNN(nn.Module):
def __init __():
def __init__(self):
super(Net, self).__init__()
超级(净,自我).__ init __()
self.conv1 = nn.Conv2d(3, 10, 3, 1, 1)
self.norm1 = nn.BatchNorm2d(10)
self.conv1 = nn.Conv2d(3,10,3,1,1)
self.conv2 = nn.Conv2d(10, 20, 3, 1, 1)
self.norm2 = nn.BatchNorm2d(20)
self.norm1 = nn.BatchNorm2d(10)
self.conv3 = nn.Conv2d(20, 40, 3, 1, 1)
self.norm3 = nn.BatchNorm2d(40)
self.conv2 = nn.Conv2d(10,20,3,1,1)
self.pool = nn.MaxPool2d(2, 2)
self.linear1 = nn.Linear(40 * 4 * 4, 100)
self.norm2 = nn.BatchNorm2d(20)
self.norm4 = nn.BatchNorm1d(100)
self.linear2 = nn.Linear(100, 10)
self.conv3 = nn.Conv2d(20,40,3,1,1)
self.dropout = nn.Dropout(0.2)
def forward(self, x):
self.norm3 = nn.BatchNorm2d(40)
x = self.pool(self.norm1(F.relu(self.conv1(x))))
x = self.pool(self.norm2(F.relu(self.conv2(x))))
self.pool = nn.MaxPool2d(2,2)
x = self.pool(self.norm3(F.relu(self.conv3(x))))
x = x.view(-1, 40 * 4 * 4)
self.linear1 = nn.Linear(40 * 4 * 4,100)
x = self.dropout(x)
x = self.norm4(F.relu(self.linear1(x)))
self.norm4 = nn.BatchNorm1d(100)
x = self.dropout(x)
x = F.log_softmax(self.linear2(x), dim=1)
self.linear2 = nn.Linear(100,10)
return x
```
self.dropout = nn.Dropout(0.2)
def forward(self,x):
x = self.pool(self.norm1(F.relu(self.conv1(x))))
x = self.pool(self.norm2(F.relu(self.conv2(x))))
x = self.pool(self.norm3(F.relu(self.conv3(x))))
x = x.view(-1,40 * 4 * 4)
x = self.dropout(x)
x = self.norm4(F.relu(self.linear1(x)))
x = self.dropout(x)
x = F.log_softmax(self.linear2(x),dim = 1)
返回 x
3.
训练模型 100 个纪元。
3.
训练模型 100 个纪元。
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录