- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍖 原作者：K同学啊 | 接辅导、项目定制
目录
本文为TR6学习打卡，为了保证记录顺序我这里写为N11
总结：
之前有学习过文本预处理的环节，对文本处理的主要方式有以下三种：
1：词袋模型（one-hot编码）
2：TF-IDF
3：Word2Vec(词向量(Word Embedding) 以及Word2vec(Word Embedding 的方法之一))
详细介绍及中英文分词详见pytorch文本分类（一）：文本预处理
N1期介绍了one-hot编码
N2期主要介绍Embedding,及EmbeddingBag 使用示例（对词索引向量转化为词嵌入向量）
N3期主要介绍：应用三种模型的英文分类
N4期将主要介绍中文基本分类（熟悉流程）、拓展：textCNN分类（通用模型）、拓展：Bert分类（模型进阶）
N5期主要介绍Word2Vec，和nn.Embedding(), nn.EmbeddingBag()相比都是嵌入技术，用于将离散的词语或符号映射到连续的向量空间。
nn.Embedding 和 nn.EmbeddingBag 是深度学习框架（如 PyTorch）中的层，直接用于神经网络模型中，而 Word2Vec 是一种独立的词嵌入算法。
使用来说，如果需要在神经网络中处理变长序列的嵌入，可以选择 nn.EmbeddingBag；如果需要预训练词嵌入用于不同任务，可以选择 Word2Vec。
N6期主要介绍使用Word2Vec实现文本分类：
与N4文本分类的异同点总结
- 共同点
数据加载：都使用了PyTorch的DataLoader来批量加载数据。
模型训练：训练过程大同小异，都是前向传播、计算损失、反向传播和梯度更新。 - 不同点
分词处理：
BERT模型：使用专门的BERT分词器。
传统嵌入方法：通常使用jieba等工具进行分词。
Word2Vec模型：假设数据已经分词。
词向量表示：
BERT模型：使用BERT生成的上下文相关的词向量。
传统嵌入方法：使用静态预训练词向量。
Word2Vec模型：训练一个Word2Vec模型生成词向量。
模型结构：
BERT模型：使用预训练的BERT模型作为编码器。
传统嵌入方法：一般使用嵌入层+卷积/循环神经网络。
Word2Vec模型：使用Word2Vec词向量和一个简单的线性分类器。 - 值得学习的点
词向量的使用：了解如何使用Word2Vec生成词向量并将其用于下游任务。
数据预处理：不同方法的数据预处理方式，尤其是分词和词向量化的处理。
模型训练：标准的模型训练和评估流程，尤其是损失计算、反向传播和梯度更新等步骤。
超参数选择：注意学习率、批量大小和训练轮数等超参数的选择。
通过这些比较和分析，可以更好地理解不同文本分类方法的优缺点以及适用场景。
N7期，需要理解RNN 及 seq2seq代码，并在此基础上成功运行代码，理解代码流程
N8期，在上一期的基础上加入了注意力机制
N9期，transformer的代码复现，注释里加入了一些理解，但是对transformer的网络结构的理解还需加强
在之前的任务中我们学习了Seq2Seq，知晓了Attention为RNN带来的优点。那么有没有一种神经网络结构直接基于attention构造，并且不再依赖RNN、LSTM或者CNN网络结构了呢？答案便是：Transformer。Seq2Seq和Transformer都是用于处理序列数据的深度学习模型，但它们是两种不同的架构。
1，Seq2Seq：
- 定义： Seq2Seq是一种用于序列到序列任务的模型架构，最初用于机器翻译。这意味着它可以处理输入序列，并生成相应的输出序列。
- 结构： Seq2Seq模型通常由两个主要部分组成：编码器和解码器。编码器负责将输入序列编码为固定大小的向量，而解码器则使用此向量生成输出序列。
- 问题： 传统的Seq2Seq模型在处理长序列时可能会遇到梯度消失/爆炸等问题，而Transformer模型的提出正是为了解决这些问题。
2，Transformer：
- 定义： Transformer是一种更现代的深度学习模型，专为处理序列数据而设计，最初用于自然语言处理任务。它不依赖于RNN或CNN等传统结构，而是引入了注意力机制。
- 结构： Transformer模型主要由编码器和解码器组成，它们由自注意力层和全连接前馈网络组成。它使用注意力机制来捕捉输入序列中不同位置之间的依赖关系，同时通过多头注意力来提高模型的表达能力。
- 优势： Transformer的设计使其能够更好地处理长距离依赖关系，同时具有更好的并行性。
在某种程度上，可以将Transformer看作是Seq2Seq的一种演变，Transformer可以执行Seq2Seq任务，并且相对于传统的Seq2Seq模型具有更好的性能和可扩展性。
N10期,Transformer实战：文本分类 , 使用pytorch实现的transformer完成中文文本分类，实际上在N4期我已做过bert的文本分类。
N11期，在上一期的基础上加入了embedding
准备工作
1. 环境配置
import torch,torchvision
print(torch.__version__) #注意是双下划线
print(torchvision.__version__)
2.2.0+cu118
0.17.0+cu118
import math,os,PIL,pathlib,warnings
import torch.nn as nn
import numpy as np
from torchvision import transforms, datasets
warnings.filterwarnings("ignore") #忽略警告信息
# 设置GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device
device(type='cuda')
2. 数据加载
import pandas as pd
# 加载自定义中文数据
train_data = pd.read_csv('./data/TR5-train.csv', sep='\t', header=None)
train_data.head()
| 0 | 1 | |
|---|---|---|
| 0 | 还有双鸭山到淮阴的汽车票吗13号的 | Travel-Query |
| 1 | 从这里怎么回家 | Travel-Query |
| 2 | 随便播放一首专辑阁楼里的佛里的歌 | Music-Play |
| 3 | 给看一下墓王之王嘛 | FilmTele-Play |
| 4 | 我想看挑战两把s686打突变团竞的游戏视频 | Video-Play |
label_name = list(set(train_data[1].values[:]))
print(label_name)
['Music-Play', 'Audio-Play', 'Alarm-Update', 'HomeAppliance-Control', 'Other', 'Weather-Query', 'Travel-Query', 'Calendar-Query', 'TVProgram-Play', 'Video-Play', 'FilmTele-Play', 'Radio-Listen']
数据预处理
3. 构建词典
from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator
import jieba
# 中文分词方法
tokenizer = jieba.lcut
def yield_tokens(data_iter):
for text in data_iter:
yield tokenizer(text)
vocab = build_vocab_from_iterator(yield_tokens(train_data[0].values[:]), specials=["<unk>"])
vocab.set_default_index(vocab["<unk>"]) # 设置默认索引，如果找不到单词，则会选择默认索引
Building prefix dict from the default dictionary ...
Loading model from cache C:\Users\Cheng\AppData\Local\Temp\jieba.cache
Loading model cost 0.876 seconds.
Prefix dict has been built successfully.
text_pipeline = lambda x: torch.tensor(vocab(tokenizer(x)))
label_pipeline = lambda x: torch.tensor(label_name.index(x))
print(text_pipeline('我想看和平精英上战神必备技巧的游戏视频'))
print(label_pipeline('Video-Play'))
tensor([ 2, 10, 13, 973, 1079, 146, 7724, 7574, 7793, 1, 186, 28])
tensor(9)
4. 进行one-hot编码
from functools import partial
X = [text_pipeline(i) for i in train_data[0].values[:]]
y = [label_pipeline(i) for i in train_data[1].values[:]]
# 对便签 y 进行 one-hot 编码
numbers_array = np.array(y) # 转换为 NumPy 数组
num_classes = np.max(numbers_array)+1 # 计算类别数量
y = np.eye(num_classes)[numbers_array] # 进行 one-hot 编码
5. 自定义数据集类
from torch.utils.data import DataLoader, Dataset
class TextDataset(Dataset):
def __init__(self, texts, labels):
self.texts = texts
self.labels = labels
def __len__(self):
return len(self.labels)
def __getitem__(self, idx):
return self.texts[idx], self.labels[idx]
6. 定义填充函数
import torch.nn.functional as F
max_len = max(len(i) for i in X)
def collate_batch(batch, max_len):
texts, labels = zip(*batch)
padded_texts = [F.pad(text, (0, max_len - len(text)), value=0) for text in texts]
padded_texts = torch.stack(padded_texts)
labels = torch.tensor(labels, dtype=torch.float)#.unsqueeze(1)
return padded_texts.to(device), labels.to(device)
# 使用 partial 函数创建 collate_fn，传入参数
collate_fn = partial(collate_batch, max_len=max_len)
7. 构建数据集
from torch.utils.data.dataset import random_split
# 示例词典大小和嵌入维度
vocab_size = 10
embed_dim = 6
# 创建数据集和数据加载器
dataset = TextDataset(X, y)
train_dataset, valid_dataset = random_split(dataset,
[int(len(dataset)*0.8),
int(len(dataset)*0.2)])
train_dataloader = DataLoader(train_dataset, batch_size=128,
shuffle=True, collate_fn=collate_fn)
valid_dataloader = DataLoader(valid_dataset, batch_size=128,
shuffle=True, collate_fn=collate_fn)
模型构建
8. 定义位置编码函数
class PositionalEncoding(nn.Module):
def __init__(self, embed_dim, max_len=100):
super(PositionalEncoding, self).__init__()
# 创建一个大小为 [max_len, embed_dim] 的零张量
pe = torch.zeros(max_len, embed_dim)
# 创建一个形状为 [max_len, 1] 的位置索引张量
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
div_term = torch.exp(torch.arange(0, embed_dim, 2).float() * (-math.log(100.0) / embed_dim))
pe[:, 0::2] = torch.sin(position * div_term) # 计算 PE(pos, 2i)
pe[:, 1::2] = torch.cos(position * div_term) # 计算 PE(pos, 2i+1)
pe = pe.unsqueeze(0)
# 将位置编码张量注册为模型的缓冲区,参数不参与梯度下降，保存model的时候会将其保存下来
self.register_buffer('pe', pe)
def forward(self, x):
# x 的形状为[batch_size, seq_len, embedding_dim]
# 将位置编码添加到输入张量中，注意位置编码的形状
# print(x.shape, self.pe.shape, self.pe[:,:x.size(1), :].shape)
x = x + self.pe[:,:x.size(1)]
# print(x.shape)
return x
9. 定义Transformer模型
from tempfile import TemporaryDirectory
from typing import Tuple
from torch import Tensor
from torch.nn import TransformerEncoder, TransformerEncoderLayer
from torch.utils.data import dataset
class TransformerModel(nn.Module):
def __init__(self, vocab_size, embed_dim, max_len, num_class,
nhead=8, d_hid=256, nlayers=12, dropout=0.1):
super().__init__()
self.embedding = nn.Embedding(vocab_size, # 词典大小
embed_dim) # 嵌入的维度
self.pos_encoder = PositionalEncoding(embed_dim)
# 定义编码器层
encoder_layers = TransformerEncoderLayer(embed_dim, nhead, d_hid, dropout)
self.transformer_encoder = TransformerEncoder(encoder_layers, nlayers)
self.embed_dim = embed_dim
self.linear = nn.Linear(embed_dim*max_len, num_class)
def forward(self, src, src_mask=None):
src = self.embedding(src)
src = self.pos_encoder(src)
output = self.transformer_encoder(src, src_mask)
output = output.view(output.size(0), -1)
output = self.linear(output)
return output
10. 定义训练函数
# 训练循环
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset) # 训练集的大小
num_batches = len(dataloader) # 批次数目, (size/batch_size，向上取整)
train_loss, train_acc = 0, 0 # 初始化训练损失和正确率
for X, y in dataloader: # 获取图片及其标签
X, y = X.to(device), y.to(device)
# 计算预测误差
pred = model(X) # 网络输出
loss = loss_fn(pred, y) # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
# 反向传播
optimizer.zero_grad() # grad属性归零
loss.backward() # 反向传播
optimizer.step() # 每一步自动更新
# 记录acc与loss
train_acc += (pred.argmax(1) == y.argmax(1)).type(torch.float).sum().item()
train_loss += loss.item()
train_acc /= size
train_loss /= num_batches
return train_acc, train_loss
11. 测试函数
def test(dataloader, model, loss_fn):
size = len(dataloader.dataset) # 测试集的大小
num_batches = len(dataloader) # 批次数目, (size/batch_size，向上取整)
test_loss, test_acc = 0, 0
# 当不进行训练时，停止梯度更新，节省计算内存消耗
with torch.no_grad():
for imgs, target in dataloader:
imgs, target = imgs.to(device), target.to(device)
# 计算loss
target_pred = model(imgs)
loss = loss_fn(target_pred, target)
test_loss += loss.item()
test_acc += (target_pred.argmax(1) == target.argmax(1)).type(torch.float).sum().item()
test_acc /= size
test_loss /= num_batches
return test_acc, test_loss
vocab_size = len(vocab) # 词汇表的大小
embed_dim = 64 # 嵌入维度
num_class = len(label_name)
# 创建 Transformer 模型，并将其移动到设备上
model = TransformerModel(vocab_size,
embed_dim,
max_len,
num_class).to(device)
12. 模型训练
import torch.optim as optim
# 超参数
EPOCHS = 50
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)
for epoch in range(1, EPOCHS + 1):
model.train() # 切换为训练模式
train_acc, train_loss = train(train_dataloader, model, criterion, optimizer)
model.eval() # 切换为测试模式
test_acc, test_loss = test(valid_dataloader, model, criterion)
# 获取当前的学习率
lr = optimizer.state_dict()['param_groups'][0]['lr']
print('| epoch {:1d} | train_acc {:4.4f} train_loss {:4.4f} | lr {:4.4f}'.format(epoch,
train_acc,
train_loss,
lr))
print('| epoch {:1d} | test_acc {:4.4f} test_loss {:4.4f} | lr {:4.4f}'.format(epoch,
test_acc,
test_loss,
lr))
print('-' * 69)
| epoch 1 | train_acc 0.1102 train_loss 2.6465 | lr 0.0100
| epoch 1 | test_acc 0.1074 test_loss 2.4828 | lr 0.0100
---------------------------------------------------------------------
| epoch 2 | train_acc 0.1231 train_loss 2.5342 | lr 0.0100
| epoch 2 | test_acc 0.1124 test_loss 2.4640 | lr 0.0100
---------------------------------------------------------------------
| epoch 3 | train_acc 0.1597 train_loss 2.4479 | lr 0.0100
| epoch 3 | test_acc 0.1880 test_loss 2.4078 | lr 0.0100
---------------------------------------------------------------------
| epoch 4 | train_acc 0.1861 train_loss 2.3449 | lr 0.0100
| epoch 4 | test_acc 0.1888 test_loss 2.3159 | lr 0.0100
---------------------------------------------------------------------
| epoch 5 | train_acc 0.2403 train_loss 2.1903 | lr 0.0100
| epoch 5 | test_acc 0.2285 test_loss 2.4278 | lr 0.0100
---------------------------------------------------------------------
| epoch 6 | train_acc 0.2699 train_loss 2.1178 | lr 0.0100
| epoch 6 | test_acc 0.3132 test_loss 2.0727 | lr 0.0100
---------------------------------------------------------------------
| epoch 7 | train_acc 0.3233 train_loss 2.0103 | lr 0.0100
| epoch 7 | test_acc 0.3463 test_loss 1.9704 | lr 0.0100
---------------------------------------------------------------------
| epoch 8 | train_acc 0.3424 train_loss 1.9519 | lr 0.0100
| epoch 8 | test_acc 0.3678 test_loss 1.9031 | lr 0.0100
---------------------------------------------------------------------
| epoch 9 | train_acc 0.4028 train_loss 1.8084 | lr 0.0100
| epoch 9 | test_acc 0.3653 test_loss 1.8819 | lr 0.0100
---------------------------------------------------------------------
| epoch 10 | train_acc 0.4429 train_loss 1.6957 | lr 0.0100
| epoch 10 | test_acc 0.4831 test_loss 1.6156 | lr 0.0100
---------------------------------------------------------------------
| epoch 11 | train_acc 0.4902 train_loss 1.5934 | lr 0.0100
| epoch 11 | test_acc 0.4537 test_loss 1.6163 | lr 0.0100
---------------------------------------------------------------------
| epoch 12 | train_acc 0.5246 train_loss 1.5029 | lr 0.0100
| epoch 12 | test_acc 0.5103 test_loss 1.4861 | lr 0.0100
---------------------------------------------------------------------
| epoch 13 | train_acc 0.5510 train_loss 1.4041 | lr 0.0100
| epoch 13 | test_acc 0.5463 test_loss 1.4384 | lr 0.0100
---------------------------------------------------------------------
| epoch 14 | train_acc 0.5722 train_loss 1.3334 | lr 0.0100
| epoch 14 | test_acc 0.5438 test_loss 1.3855 | lr 0.0100
---------------------------------------------------------------------
| epoch 15 | train_acc 0.5994 train_loss 1.2739 | lr 0.0100
| epoch 15 | test_acc 0.5773 test_loss 1.3223 | lr 0.0100
---------------------------------------------------------------------
| epoch 16 | train_acc 0.6271 train_loss 1.1936 | lr 0.0100
| epoch 16 | test_acc 0.5988 test_loss 1.2436 | lr 0.0100
---------------------------------------------------------------------
| epoch 17 | train_acc 0.6423 train_loss 1.1522 | lr 0.0100
| epoch 17 | test_acc 0.6248 test_loss 1.1862 | lr 0.0100
---------------------------------------------------------------------
| epoch 18 | train_acc 0.6556 train_loss 1.0953 | lr 0.0100
| epoch 18 | test_acc 0.6260 test_loss 1.1813 | lr 0.0100
---------------------------------------------------------------------
| epoch 19 | train_acc 0.6693 train_loss 1.0437 | lr 0.0100
| epoch 19 | test_acc 0.6583 test_loss 1.0975 | lr 0.0100
---------------------------------------------------------------------
| epoch 20 | train_acc 0.6852 train_loss 1.0123 | lr 0.0100
| epoch 20 | test_acc 0.6384 test_loss 1.1165 | lr 0.0100
---------------------------------------------------------------------
| epoch 21 | train_acc 0.6915 train_loss 0.9936 | lr 0.0100
| epoch 21 | test_acc 0.6566 test_loss 1.1023 | lr 0.0100
---------------------------------------------------------------------
| epoch 22 | train_acc 0.7022 train_loss 0.9463 | lr 0.0100
| epoch 22 | test_acc 0.6607 test_loss 1.0707 | lr 0.0100
---------------------------------------------------------------------
| epoch 23 | train_acc 0.7132 train_loss 0.9247 | lr 0.0100
| epoch 23 | test_acc 0.6851 test_loss 1.0147 | lr 0.0100
---------------------------------------------------------------------
| epoch 24 | train_acc 0.7240 train_loss 0.8895 | lr 0.0100
| epoch 24 | test_acc 0.6983 test_loss 0.9727 | lr 0.0100
---------------------------------------------------------------------
| epoch 25 | train_acc 0.7331 train_loss 0.8567 | lr 0.0100
| epoch 25 | test_acc 0.6967 test_loss 0.9620 | lr 0.0100
---------------------------------------------------------------------
| epoch 26 | train_acc 0.7436 train_loss 0.8319 | lr 0.0100
| epoch 26 | test_acc 0.7157 test_loss 0.9248 | lr 0.0100
---------------------------------------------------------------------
| epoch 27 | train_acc 0.7500 train_loss 0.8146 | lr 0.0100
| epoch 27 | test_acc 0.7041 test_loss 0.9173 | lr 0.0100
---------------------------------------------------------------------
| epoch 28 | train_acc 0.7530 train_loss 0.7884 | lr 0.0100
| epoch 28 | test_acc 0.7198 test_loss 0.9029 | lr 0.0100
---------------------------------------------------------------------
| epoch 29 | train_acc 0.7601 train_loss 0.7727 | lr 0.0100
| epoch 29 | test_acc 0.7277 test_loss 0.8738 | lr 0.0100
---------------------------------------------------------------------
| epoch 30 | train_acc 0.7645 train_loss 0.7479 | lr 0.0100
| epoch 30 | test_acc 0.7335 test_loss 0.8604 | lr 0.0100
---------------------------------------------------------------------
| epoch 31 | train_acc 0.7759 train_loss 0.7223 | lr 0.0100
| epoch 31 | test_acc 0.7376 test_loss 0.8529 | lr 0.0100
---------------------------------------------------------------------
| epoch 32 | train_acc 0.7756 train_loss 0.7158 | lr 0.0100
| epoch 32 | test_acc 0.7120 test_loss 0.9181 | lr 0.0100
---------------------------------------------------------------------
| epoch 33 | train_acc 0.7867 train_loss 0.7004 | lr 0.0100
| epoch 33 | test_acc 0.7314 test_loss 0.8660 | lr 0.0100
---------------------------------------------------------------------
| epoch 34 | train_acc 0.7916 train_loss 0.6831 | lr 0.0100
| epoch 34 | test_acc 0.7500 test_loss 0.8123 | lr 0.0100
---------------------------------------------------------------------
| epoch 35 | train_acc 0.7965 train_loss 0.6623 | lr 0.0100
| epoch 35 | test_acc 0.7525 test_loss 0.8098 | lr 0.0100
---------------------------------------------------------------------
| epoch 36 | train_acc 0.7982 train_loss 0.6481 | lr 0.0100
| epoch 36 | test_acc 0.7467 test_loss 0.8016 | lr 0.0100
---------------------------------------------------------------------
| epoch 37 | train_acc 0.8079 train_loss 0.6310 | lr 0.0100
| epoch 37 | test_acc 0.7587 test_loss 0.7923 | lr 0.0100
---------------------------------------------------------------------
| epoch 38 | train_acc 0.8123 train_loss 0.6184 | lr 0.0100
| epoch 38 | test_acc 0.7529 test_loss 0.8095 | lr 0.0100
---------------------------------------------------------------------
| epoch 39 | train_acc 0.8152 train_loss 0.6091 | lr 0.0100
| epoch 39 | test_acc 0.7690 test_loss 0.7694 | lr 0.0100
---------------------------------------------------------------------
| epoch 40 | train_acc 0.8135 train_loss 0.5977 | lr 0.0100
| epoch 40 | test_acc 0.7628 test_loss 0.7691 | lr 0.0100
---------------------------------------------------------------------
| epoch 41 | train_acc 0.8200 train_loss 0.5839 | lr 0.0100
| epoch 41 | test_acc 0.7550 test_loss 0.7975 | lr 0.0100
---------------------------------------------------------------------
| epoch 42 | train_acc 0.8223 train_loss 0.5755 | lr 0.0100
| epoch 42 | test_acc 0.7731 test_loss 0.7510 | lr 0.0100
---------------------------------------------------------------------
| epoch 43 | train_acc 0.8253 train_loss 0.5674 | lr 0.0100
| epoch 43 | test_acc 0.7632 test_loss 0.7529 | lr 0.0100
---------------------------------------------------------------------
| epoch 44 | train_acc 0.8311 train_loss 0.5494 | lr 0.0100
| epoch 44 | test_acc 0.7661 test_loss 0.7570 | lr 0.0100
---------------------------------------------------------------------
| epoch 45 | train_acc 0.8350 train_loss 0.5391 | lr 0.0100
| epoch 45 | test_acc 0.7550 test_loss 0.7676 | lr 0.0100
---------------------------------------------------------------------
| epoch 46 | train_acc 0.8341 train_loss 0.5408 | lr 0.0100
| epoch 46 | test_acc 0.7653 test_loss 0.7646 | lr 0.0100
---------------------------------------------------------------------
| epoch 47 | train_acc 0.8399 train_loss 0.5195 | lr 0.0100
| epoch 47 | test_acc 0.7798 test_loss 0.7356 | lr 0.0100
---------------------------------------------------------------------
| epoch 48 | train_acc 0.8437 train_loss 0.5126 | lr 0.0100
| epoch 48 | test_acc 0.7657 test_loss 0.7450 | lr 0.0100
---------------------------------------------------------------------
| epoch 49 | train_acc 0.8451 train_loss 0.4968 | lr 0.0100
| epoch 49 | test_acc 0.7855 test_loss 0.7126 | lr 0.0100
---------------------------------------------------------------------
| epoch 50 | train_acc 0.8466 train_loss 0.4938 | lr 0.0100
| epoch 50 | test_acc 0.7785 test_loss 0.7203 | lr 0.0100
---------------------------------------------------------------------
13. 模型评估
model.eval() # 切换为测试模式
test_acc, test_loss = test(valid_dataloader, model, criterion)
print('模型准确率为：{:5.4f}'.format(test_acc))
模型准确率为：0.7793
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
