devbox
运维做开发
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

HuggingFace学习笔记--利用API实现简单的NLP任务_huggingface api

作者：运维做开发 | 2024-08-03 23:39:03

赞

踩

huggingface api

目录

1--中文分类

1-1--使用预训练模型推理

1-2--基于预训练模型实现下游任务

2--中文填空

3--中文句子关系推断

1--中文分类

1-1--使用预训练模型推理

代码实例：

  1. import torch
  2. from datasets import load_dataset
  3. from transformers import BertTokenizer, BertModel
  4.  
  5. # 定义全局分词工具
  6. tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
  7.  
  8. # 定义数据集
  9. class Dataset(torch.utils.data.Dataset):
  10.     def __init__(self, split):
  11.         self.dataset = load_dataset(path = 'lansinuote/ChnSentiCorp', split = split) # 加载数据集
  12.  
  13.     def __len__(self):
  14.         return len(self.dataset)
  15.  
  16.     def __getitem__(self, i):
  17.         text = self.dataset[i]['text']
  18.         label = self.dataset[i]['label']
  19.         return text, label
  20.  
  21. # 自定义数据的处理(加载)方式
  22. def my_collate_fn(data): # data 的类型与 dataset 的返回值相同，本例中dataset返回一个列表[text, label]
  23.     # 根据dataset的返回结果，取出对应的text和label
  24.     sents = [i[0] for i in data]
  25.     labels = [i[1] for i in data]
  26.  
  27.     # 使用全局的分词工具进行编码
  28.     data = tokenizer.batch_encode_plus(batch_text_or_text_pairs = sents,
  29.                                         truncation = True,
  30.                                         padding = 'max_length',
  31.                                         max_length = 500,
  32.                                         return_tensors = 'pt',
  33.                                         return_length = True)
  34.     input_ids = data['input_ids']
  35.     attention_mask = data['attention_mask']
  36.     token_type_ids = data['token_type_ids']
  37.     labels = torch.LongTensor(labels)
  38.     return input_ids, attention_mask, token_type_ids, labels
  39.  
  40. def main():
  41.     dataset = Dataset('train') # 初始化训练集
  42.     # print(len(dataset), dataset[0])
  43.     
  44.     # 定义dataloader
  45.     loader = torch.utils.data.DataLoader(dataset = dataset,
  46.                                         batch_size = 16,
  47.                                         collate_fn = my_collate_fn,
  48.                                         shuffle = True,
  49.                                         drop_last = True)
  50.     
  51.     # 遍历dataloader加载数据
  52.     for i, (input_ids, attention_mask, token_type_ids, labels) in enumerate(loader):
  53.         break
  54.     print(len(loader))
  55.     print(input_ids.shape, attention_mask.shape, token_type_ids.shape, labels) # 打印一个样本
  56.     
  57.     # 加载预训练模型
  58.     model = BertModel.from_pretrained('bert-base-chinese')
  59.     for param in model.parameters(): # 不进行梯度计算和反向传播
  60.         param.requires_grad_(False)
  61.     # 调用预训练模型推理一个样本    
  62.     output = model(input_ids = input_ids, attention_mask = attention_mask, token_type_ids = token_type_ids)
  63.     print(output.last_hidden_state.shape) # 打印最后一个隐层输出特征的维度
  64.  
  65. if __name__ == "__main__":
  66.     main()
  67.     print("All done!")

输出结果：

  1. # dataloader单个样本：
  2. torch.Size([16, 500]) 
  3. torch.Size([16, 500]) 
  4. torch.Size([16, 500]) 
  5. tensor([1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1])
  6. # 最后一个隐层的输出特征:
  7. torch.Size([16, 500, 768])

1-2--基于预训练模型实现下游任务

        利用预训练 bert 模型最后一个隐层的[cls] token的特征进行中文分类；

代码：

  1. import torch
  2. from datasets import load_dataset
  3. from transformers import BertTokenizer, BertModel, AdamW
  4.  
  5. # 定义全局分词工具
  6. tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
  7.  
  8. # 定义数据集
  9. class Dataset(torch.utils.data.Dataset):
  10.     def __init__(self, split):
  11.         self.dataset = load_dataset(path = 'lansinuote/ChnSentiCorp', split = split) # 加载数据集
  12.  
  13.     def __len__(self):
  14.         return len(self.dataset)
  15.  
  16.     def __getitem__(self, i):
  17.         text = self.dataset[i]['text']
  18.         label = self.dataset[i]['label']
  19.         return text, label
  20.  
  21. # 自定义数据的处理(加载)方式
  22. def my_collate_fn(data): # data 的类型与 dataset 的返回值相同，本例中dataset返回一个列表[text, label]
  23.     # 根据dataset的返回结果，取出对应的text和label
  24.     sents = [i[0] for i in data]
  25.     labels = [i[1] for i in data]
  26.  
  27.     # 使用全局的分词工具进行编码
  28.     data = tokenizer.batch_encode_plus(batch_text_or_text_pairs = sents,
  29.                                         truncation = True,
  30.                                         padding = 'max_length',
  31.                                         max_length = 500,
  32.                                         return_tensors = 'pt',
  33.                                         return_length = True)
  34.     input_ids = data['input_ids']
  35.     attention_mask = data['attention_mask']
  36.     token_type_ids = data['token_type_ids']
  37.     labels = torch.LongTensor(labels)
  38.     return input_ids, attention_mask, token_type_ids, labels
  39.  
  40. # 定义下游任务模型
  41. class Model(torch.nn.Module):
  42.     def __init__(self):
  43.         super().__init__()
  44.         self.pretrained_model = BertModel.from_pretrained('bert-base-chinese') # 加载预训练模型
  45.         self.fc = torch.nn.Linear(768, 2)
  46.         
  47.         # 固定预训练模型
  48.         for param in self.pretrained_model.parameters():
  49.             param.requires_grad = False
  50.  
  51.     def forward(self, input_ids, attention_mask, token_type_ids):
  52.         with torch.no_grad():
  53.             output = self.pretrained_model(input_ids=input_ids,
  54.                        attention_mask=attention_mask,
  55.                        token_type_ids=token_type_ids)
  56.  
  57.         output = self.fc(output.last_hidden_state[:, 0]) # 利用最后一个隐层的[cls]token特征进行分类
  58.  
  59.         output = output.softmax(dim=1)
  60.  
  61.         return output
  62.  
  63. # 定义测试函数
  64. def test(model, dataset):
  65.     model.eval()
  66.     correct = 0
  67.     total = 0
  68.     # 定义加载测试集的dataloader
  69.     loader_test = torch.utils.data.DataLoader(dataset = dataset,
  70.                                               batch_size = 32,
  71.                                               collate_fn = my_collate_fn,
  72.                                               shuffle = True,
  73.                                               drop_last = True)
  74.     for idx, (input_ids, attention_mask, token_type_ids, labels) in enumerate(loader_test):
  75.         if idx == 5: # 测试5个batch
  76.             break
  77.         print(idx)
  78.         with torch.no_grad():
  79.             input_ids = input_ids.cuda()
  80.             attention_mask = attention_mask.cuda()
  81.             token_type_ids = token_type_ids.cuda()
  82.             labels = labels.cuda()
  83.             output = model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
  84.  
  85.         output = output.argmax(dim=1)
  86.         correct += (output == labels).sum().item()
  87.         total += len(labels)
  88.     print("Acc: ", correct / total) # 打印5个batch的总体准确率
  89.  
  90. def main():
  91.     dataset = Dataset('train') # 初始化训练集
  92.     # print(len(dataset), dataset[0])
  93.     
  94.     # 定义dataloader
  95.     loader = torch.utils.data.DataLoader(dataset = dataset,
  96.                                         batch_size = 16,
  97.                                         num_workers = 8,
  98.                                         collate_fn = my_collate_fn,
  99.                                         shuffle = True,
  100.                                         drop_last = True)
  101.     # 初始化模型
  102.     model = Model()
  103.     model = model.cuda() # 使用GPU
  104.  
  105.     # 初始化优化器和损失函数
  106.     optimizer = AdamW(model.parameters(), lr=5e-4)
  107.     criterion = torch.nn.CrossEntropyLoss().cuda()
  108.     
  109.     # 训练模型
  110.     model.train()
  111.     for idx, (input_ids, attention_mask, token_type_ids, labels) in enumerate(loader): # 遍历加载数据
  112.         input_ids = input_ids.cuda()
  113.         attention_mask = attention_mask.cuda()
  114.         token_type_ids = token_type_ids.cuda()
  115.         labels = labels.cuda()
  116.         output = model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
  117.         loss = criterion(output, labels)
  118.         loss.backward()
  119.         optimizer.step()
  120.         optimizer.zero_grad()
  121.  
  122.         if idx % 5 == 0: # 每5个batch打印当前准确率和损失
  123.             output = output.argmax(dim=1)
  124.             accuracy = (output == labels).sum().item() / len(labels)
  125.             print(idx, loss.item(), accuracy)
  126.         if idx == 300: # 使用300个batch进行训练
  127.             break
  128.         
  129.     # 测试模型
  130.     test(model, Dataset('validation'))
  131.  
  132. if __name__ == "__main__":
  133.     main()

部分输出结果：

  1. ...
  2. 260 0.5995925664901733 0.75
  3. 265 0.3791050910949707 1.0
  4. 270 0.42692136764526367 0.9375
  5. 275 0.4765201210975647 0.875
  6. 280 0.4071955382823944 0.9375
  7. 285 0.4194560945034027 0.875
  8. 290 0.449373722076416 0.9375
  9. 295 0.38813596963882446 1.0
  10. 300 0.5164415240287781 0.875
  11. Acc:  0.89375

2--中文填空

        对训练数据的第15个词进行 mask 掉，预测第15个词；

        利用 bert 模型提取特征，对最后一个隐层的第15个token特征进行分类；

        分类用的是一个简单的线性层，其维度为（768, token.vocab_size），其中token.vocab_sized的大小为21128，即预测21128个词的分类分数，再与真实标签进行损失计算；

代码：

  1. import torch
  2. from datasets import load_dataset, load_from_disk
  3. from transformers import BertTokenizer, BertModel, AdamW
  4.  
  5. # 定义全局分词工具
  6. token = BertTokenizer.from_pretrained('bert-base-chinese')
  7.  
  8. # 定义数据集
  9. class Dataset(torch.utils.data.Dataset):
  10.     def __init__(self, split):
  11.         dataset = load_dataset(path = 'lansinuote/ChnSentiCorp', split = split)
  12.         # dataset = load_from_disk('./data/ChnSentiCorp')
  13.         # dataset = dataset[split]
  14.  
  15.         def f(data):
  16.             return len(data['text']) > 30
  17.         self.dataset = dataset.filter(f) # 筛选数据集
  18.  
  19.     def __len__(self):
  20.         return len(self.dataset)
  21.  
  22.     def __getitem__(self, i):
  23.         text = self.dataset[i]['text']
  24.  
  25.         return text
  26.         
  27. def collate_fn(data):
  28.     # batch编码
  29.     data = token.batch_encode_plus(batch_text_or_text_pairs = data,
  30.                                    truncation = True,
  31.                                    padding = 'max_length',
  32.                                    max_length = 30, # padding到30个词
  33.                                    return_tensors = 'pt', # 返回pytorch格式
  34.                                    return_length = True)
  35.  
  36.     input_ids = data['input_ids']
  37.     attention_mask = data['attention_mask']
  38.     token_type_ids = data['token_type_ids']
  39.  
  40.     # 把第15个词固定替换为mask
  41.     labels = input_ids[:, 15].reshape(-1).clone() # 记录真实标签
  42.     input_ids[:, 15] = token.get_vocab()[token.mask_token]
  43.  
  44.     return input_ids, attention_mask, token_type_ids, labels
  45.  
  46. # 定义下游任务模型
  47. class Model(torch.nn.Module):
  48.     def __init__(self):
  49.         super().__init__()
  50.         self.decoder = torch.nn.Linear(768, token.vocab_size, bias=False) # token.vocab_size为21128，预测21128个词的分类分数
  51.         self.bias = torch.nn.Parameter(torch.zeros(token.vocab_size))
  52.         self.decoder.bias = self.bias
  53.         self.pretrained = BertModel.from_pretrained('bert-base-chinese')
  54.         
  55.         # 固定预训练模型
  56.         for param in self.pretrained.parameters():
  57.             param.requires_grad = False
  58.  
  59.     def forward(self, input_ids, attention_mask, token_type_ids):
  60.         # 使用bert模型提取特征
  61.         with torch.no_grad():
  62.             output = self.pretrained(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
  63.  
  64.         output = self.decoder(output.last_hidden_state[:, 15])
  65.         return output
  66.  
  67. # 测试
  68. def test(model):
  69.     model.eval()
  70.     correct = 0
  71.     total = 0
  72.  
  73.     loader_test = torch.utils.data.DataLoader(dataset = Dataset('test'), 
  74.                                               batch_size = 32, 
  75.                                               collate_fn = collate_fn, 
  76.                                               shuffle = True, 
  77.                                               drop_last = True)
  78.  
  79.     for idx, (input_ids, attention_mask, token_type_ids, labels) in enumerate(loader_test):
  80.         input_ids = input_ids.cuda()
  81.         attention_mask = attention_mask.cuda()
  82.         token_type_ids = token_type_ids.cuda()
  83.         labels = labels.cuda()
  84.         
  85.         if idx == 15: # 测试15个batch
  86.             break
  87.         with torch.no_grad():
  88.             output = model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
  89.  
  90.         output = output.argmax(dim=1)
  91.         correct += (output == labels).sum().item()
  92.         total += len(labels)
  93.         print(token.decode(input_ids[0])) # 打印测试数据
  94.         print("真实标签: ", token.decode(labels[0]), "预测标签: ", token.decode(output[0]))
  95.  
  96.     print("Acc: ", correct / total)
  97.  
  98.  
  99. def main():
  100.     # 初始化训练集
  101.     dataset = Dataset('train')
  102.     # 定义dataloader
  103.     loader = torch.utils.data.DataLoader(dataset = dataset,
  104.                                             batch_size = 16,
  105.                                             collate_fn = collate_fn,
  106.                                             shuffle = True,
  107.                                             drop_last = True)
  108.     # 初始化模型
  109.     model = Model().cuda()
  110.     
  111.     # 训练
  112.     optimizer = AdamW(model.parameters(), lr=5e-4)
  113.     criterion = torch.nn.CrossEntropyLoss().cuda()
  114.     model.train()
  115.     
  116.     for epoch in range(5):
  117.         for idx, (input_ids, attention_mask, token_type_ids, labels) in enumerate(loader):
  118.             input_ids = input_ids.cuda()
  119.             attention_mask = attention_mask.cuda()
  120.             token_type_ids = token_type_ids.cuda()
  121.             labels = labels.cuda()
  122.             output = model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
  123.             loss = criterion(output, labels)
  124.             loss.backward()
  125.             optimizer.step()
  126.             optimizer.zero_grad()
  127.  
  128.             if idx % 50 == 0:
  129.                 output = output.argmax(dim=1)
  130.                 accuracy = (output == labels).sum().item() / len(labels)
  131.                 print(epoch, idx, loss.item(), accuracy)
  132.     # 测试模型            
  133.     test(model)
  134.  
  135. if __name__ == "__main__":
  136.     main()

部分输出结果：

  1. 4 200 0.7910566329956055 0.75
  2. 4 250 0.9690109491348267 0.8125
  3. 4 300 0.4056988060474396 0.9375
  4. 4 350 0.31916332244873047 1.0
  5. 4 400 0.8943865895271301 0.6875
  6. 4 450 0.4540601968765259 0.9375
  7. 4 500 0.7437821626663208 0.75
  8. 4 550 0.3669029474258423 0.9375
  9. [CLS] 之 前 看 到 很 多 评 论 ， 说 很 好 兴 冲 [MASK] 买 了 ， 看 了 看 感 觉 非 常 失 望 炒 [SEP]
  10. 真实标签:  冲 预测标签:  冲
  11. [CLS] 刚 看 了 一 章 就 丢 边 上 了 ， 光 盘 也 [MASK] 知 道 放 哪 里 了 ， 很 垃 圾 ， 很 多 [SEP]
  12. 真实标签:  不 预测标签:  不
  13. [CLS] 酒 店 生 意 清 淡 ， 大 堂 里 都 没 几 个 [MASK] 人 。 房 间 倒 是 不 小 ， 但 觉 得 被 [SEP]
  14. 真实标签:  客 预测标签:  客
  15. [CLS] 选 购 的 时 候 ， 还 是 有 货 的 。 最 后 [MASK] 通 知 我 说 ， 没 货 了 。 当 当 的 服 [SEP]
  16. 真实标签:  却 预测标签:  ，
  17. [CLS] 简 单 ， 大 方 ， 在 同 类 尺 寸 的 款 型 [MASK] 笔 记 本 中 不 显 厚 重 ， 轻 薄 感 ！ [SEP]
  18. 真实标签:  的 预测标签:  的
  19. [CLS] 当 时 是 同 事 极 力 推 荐 这 本 书 。 我 [MASK] 到 网 上 的 介 绍 和 那 么 多 的 [UNK] 名 [SEP]
  20. 真实标签:  看 预测标签:  看
  21. [CLS] 酒 店 位 置 离 火 车 站 很 近 ， 走 路 10 [MASK] 钟 不 到 就 能 到 。 。 。 服 务 不 错 [SEP]
  22. 真实标签:  分 预测标签:  分
  23. [CLS] 买 之 前 也 没 见 过 这 本 书, 听 他 们 [MASK] 的 天 花 乱 坠, 翻 了 几 页 就 够 了 [SEP]
  24. 真实标签:  说 预测标签:  写
  25. [CLS] 看 了 百 家 讲 坛 ， 来 了 兴 趣 。 因 为 [MASK] 作 忙 ， 只 看 了 一 点 点 ， 因 此 买 [SEP]
  26. 真实标签:  工 预测标签:  工
  27. [CLS] 第 一 次 买 的 拉 拉 升 职 记 ， 三 天 到 [MASK] （ 我 住 北 京 三 环 边 上 ） ， 还 比 [SEP]
  28. 真实标签:  货 预测标签:  手
  29. [CLS] 房 间 隔 音 效 果 极 差 ， 深 夜 如 果 隔 [MASK] 客 人 大 声 喧 哗 的 话 [UNK] [UNK] 服 务 员 [SEP]
  30. 真实标签:  壁 预测标签:  音
  31. [CLS] 读 过 她 的 《 茶 人 三 部 曲 》 ， 一 口 [MASK] 读 完 的 。 一 直 在 搜 寻 她 的 文 字 [SEP]
  32. 真实标签:  气 预测标签:  气
  33. [CLS] 条 件 、 服 务 、 设 施 都 很 好 ， 房 间 [MASK] 干 净 、 很 舒 适 ， 尤 其 是 前 台 服 [SEP]
  34. 真实标签:  很 预测标签:  很
  35. [CLS] 大 俗 即 大 雅 ！ 这 是 看 郑 振 铎 先 生 [MASK] 部 书 后 最 由 衷 的 感 想 ， 看 过 中 [SEP]
  36. 真实标签:  三 预测标签:  这
  37. [CLS] 觉 得 相 当 没 意 思 的 一 本 书 。 不 伦 [MASK] 类 的 。 看 的 时 候 很 纠 结 ， 看 完 [SEP]
  38. 真实标签:  不 预测标签:  不
  39. Acc:  0.6979166666666666

3--中文句子关系推断

代码：

  1. import torch
  2. import random
  3. from datasets import load_dataset, load_from_disk
  4. from transformers import BertTokenizer, BertModel, AdamW
  5.  
  6. # 定义全局分词工具
  7. token = BertTokenizer.from_pretrained('bert-base-chinese')
  8.  
  9. # 定义数据集
  10. class Dataset(torch.utils.data.Dataset):
  11.     def __init__(self, split):
  12.         # dataset = load_dataset(path='lansinuote/ChnSentiCorp', split=split)
  13.         dataset = load_from_disk('./data/ChnSentiCorp')
  14.         dataset = dataset[split]
  15.  
  16.         def f(data):
  17.             return len(data['text']) > 40
  18.  
  19.         self.dataset = dataset.filter(f)
  20.  
  21.     def __len__(self):
  22.         return len(self.dataset)
  23.  
  24.     def __getitem__(self, i):
  25.         text = self.dataset[i]['text']
  26.  
  27.         # 切分一句话为前半句和后半句
  28.         sentence1 = text[:20]
  29.         sentence2 = text[20:40]
  30.         label = 0 # label为0表示为同一句
  31.  
  32.         # 有一半的概率把后半句替换为一句无关的话
  33.         if random.randint(0, 1) == 0:
  34.             j = random.randint(0, len(self.dataset) - 1)
  35.             sentence2 = self.dataset[j]['text'][20:40]
  36.             label = 1
  37.  
  38.         return sentence1, sentence2, label
  39.  
  40. def collate_fn(data):
  41.     sents = [i[:2] for i in data]
  42.     labels = [i[2] for i in data]
  43.  
  44.     # 编码
  45.     data = token.batch_encode_plus(batch_text_or_text_pairs = sents,
  46.                                    truncation = True,
  47.                                    padding = 'max_length',
  48.                                    max_length = 45,
  49.                                    return_tensors = 'pt',
  50.                                    return_length = True,
  51.                                    add_special_tokens = True)
  52.  
  53.     input_ids = data['input_ids']
  54.     attention_mask = data['attention_mask']
  55.     token_type_ids = data['token_type_ids']
  56.     labels = torch.LongTensor(labels)
  57.  
  58.     return input_ids, attention_mask, token_type_ids, labels
  59.  
  60. # 定义下游任务模型
  61. class Model(torch.nn.Module):
  62.     def __init__(self):
  63.         super().__init__()
  64.         self.fc = torch.nn.Linear(768, 2) # 二分类
  65.         self.pretrained = BertModel.from_pretrained('bert-base-chinese')
  66.         
  67.         # 固定预训练模型
  68.         for param in self.pretrained.parameters():
  69.             param.requires_grad = False
  70.  
  71.     def forward(self, input_ids, attention_mask, token_type_ids):
  72.         with torch.no_grad():
  73.             output = self.pretrained(input_ids = input_ids, attention_mask = attention_mask, token_type_ids = token_type_ids)
  74.  
  75.         output = self.fc(output.last_hidden_state[:, 0])
  76.         output = output.softmax(dim=1)
  77.         return output
  78.  
  79. def main():
  80.     model = Model().cuda()
  81.     optimizer = AdamW(model.parameters(), lr=5e-4)
  82.     criterion = torch.nn.CrossEntropyLoss().cuda() 
  83.     
  84.     # dataloader
  85.     loader = torch.utils.data.DataLoader(dataset = Dataset('train'),
  86.                                         batch_size = 8,
  87.                                         collate_fn = collate_fn,
  88.                                         shuffle = True,
  89.                                         drop_last = True)  
  90.     # 训练
  91.     model.train()
  92.     
  93.     for idx, (input_ids, attention_mask, token_type_ids, labels) in enumerate(loader):
  94.         input_ids = input_ids.cuda()
  95.         attention_mask = attention_mask.cuda()
  96.         token_type_ids = token_type_ids.cuda()
  97.         labels = labels.cuda()
  98.         output = model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
  99.  
  100.         loss = criterion(output, labels)
  101.         loss.backward()
  102.         optimizer.step()
  103.         optimizer.zero_grad()
  104.  
  105.         if idx % 5 == 0: # 每5个batch打印
  106.             output = output.argmax(dim=1)
  107.             accuracy = (output == labels).sum().item() / len(labels)
  108.             print(idx, loss.item(), accuracy)
  109.  
  110.         if idx == 300: # 训练300个batch
  111.             break
  112.     
  113.     # 测试
  114.     test(model)
  115.  
  116. # 定义测试函数
  117. def test(model):
  118.     model.eval()
  119.     correct = 0
  120.     total = 0
  121.     loader_test = torch.utils.data.DataLoader(dataset = Dataset('test'),
  122.                                               batch_size = 32,
  123.                                               collate_fn = collate_fn,
  124.                                               shuffle = True,
  125.                                               drop_last = True)
  126.  
  127.     for idx, (input_ids, attention_mask, token_type_ids, labels) in enumerate(loader_test):
  128.         input_ids = input_ids.cuda()
  129.         attention_mask = attention_mask.cuda()
  130.         token_type_ids = token_type_ids.cuda()
  131.         labels = labels.cuda()
  132.         if idx == 5: # 测试5个batch
  133.             break
  134.         with torch.no_grad():
  135.             output = model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
  136.  
  137.         pred = output.argmax(dim=1)
  138.         correct += (pred == labels).sum().item()
  139.         total += len(labels)
  140.  
  141.     print('acc:', correct / total)
  142.     
  143. if __name__ == "__main__":
  144.     main()

部分运行结果：

  1. 240 0.39283961057662964 0.875
  2. 245 0.7069525122642517 0.5
  3. 250 0.41953372955322266 0.875
  4. 255 0.5032698512077332 0.75
  5. 260 0.6422066688537598 0.75
  6. 265 0.5467717051506042 0.75
  7. 270 0.4452913701534271 0.875
  8. 275 0.5998544096946716 0.625
  9. 280 0.4301206171512604 0.875
  10. 285 0.5177156329154968 0.75
  11. 290 0.3987200856208801 0.875
  12. 295 0.33609679341316223 1.0
  13. 300 0.3723036050796509 0.875
  14. acc: 0.925

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/925390
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号