devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

单层纯RNN＋全连接实现AG_NEWS数据集的分类

作者：小小林熬夜学编程 | 2024-05-07 00:26:34

赞

踩

单层纯RNN＋全连接实现AG_NEWS数据集的分类

基于RNN的文本分类任务实现

环境配置

python为3.9.19

  1. import os
  2. import matplotlib.pyplot as plt
  3. import numpy as np
  4. import torch
  5. import torch.nn as nn
  6. import torch.optim
  7. from torch.utils.data import DataLoader
  8. from torchtext.data.utils import get_tokenizer
  9. from torchtext.datasets import AG_NEWS
  10. from torchtext.vocab import build_vocab_from_iterator
  11. from tqdm import tqdm
  12. from model_set import RNNnet

数据集

使用torchtext自带的数据集AG_NEWS

  1. def loaddata(config):
  2.     # Step1 加载数据集
  3.     #######################################################################
  4.     print("Step1: Loading DateSet")
  5.     #######################################################################
  6.     # 【数据集介绍】AG_NEWS, 新闻语料库，仅仅使用了标题和描述字段，
  7.     # 包含4个大类新闻:World、Sports、Business、Sci/Tec。
  8.     # 【样本数据】 120000条训练样本集（train.csv)， 7600测试样本数据集(test.csv);
  9.     # 每个类别分别拥有 30,000 个训练样本及 1900 个测试样本。
  10.     os.makedirs(config.datapath, exist_ok=True)
  11.     train_dataset_o, test_dataset_o = AG_NEWS(root=config.datapath, split=('train', 'test'))
  12.     classes = ['World', 'Sports', 'Business', 'Sci/Tech']
  13.     return train_dataset_o, test_dataset_o, classes

文本分词

tokenizer = get_tokenizer('basic_english')  # 基本的英文分词器，tokenizer会把句子进行分割，类似jieba

构建词汇表

  1. def bulvocab(traindata):
  2.     # Step2 分词，构建词汇表
  3.     #######################################################################
  4.     #
  5.     print("Step2: Building VocabSet")
  6.     #######################################################################
  7.     tokenizer = get_tokenizer('basic_english')  # 基本的英文分词器，tokenizer会把句子进行分割，类似jieba
  8. ​
  9.     def yield_tokens(data_iter):  # 分词生成器
  10.         for _, text in data_iter:
  11.             yield tokenizer(text)  # yield会构建一个类似列表可迭代的东西，但比起直接使用列表要少占用很多内存
  12. ​
  13.     # 根据训练数据构建词汇表
  14.     vocab = build_vocab_from_iterator(yield_tokens(traindata), specials=["<PAD>"])  # <unk>代指低频词或未在词表中的词
  15.     # 词汇表会将token映射到词汇表中的索引上，注意词汇表的构建不需要用测试集
  16.     vocab.set_default_index(vocab["<PAD>"])  # 设置默认索引，当某个单词不在词汇表vocab时（OOV)，返回该单词索引
  17.     print(f"len vocab:{len(vocab)}")
  18.     len_vocab = len(vocab)
  19. ​
  20.     return vocab, len_vocab

文本映射索引

映射在下面dataload里，这里就用图片展示一下过程

构建数据dataloader

构建成batch时需要每个句子一样长度

  1.  # 指定句子长度统一的标准
  2.         if config.seq_mode == "min":
  3.             seq_len = min(len(item) for item in text_list)
  4.         elif config.seq_mode == "max":
  5.             seq_len = max(len(item) for item in text_list)
  6.         elif config.seq_mode == "avg":
  7.             seq_len = sum(len(item) for item in text_list)/len(text_list)
  8.         elif isinstance(config.seq_mode, int):
  9.             seq_len = config.seq_mode
  10.         else:
  11.             seq_len = min(len(item) for item in text_list)
  12.         seq_len = int(seq_len)
  13.         # 每一个batch里统一长度
  14.         batch_seq = torch.stack(tensor_padding(text_list, seq_len))
  1. def tensor_padding(tensor_list, seq_len):
  2.     # 填充前两个张量
  3.     padded_tensors = []
  4.     for tensor in tensor_list:
  5.         padding = (0, seq_len - len(tensor))  # 在末尾填充0
  6.         padded_tensor = torch.nn.functional.pad(tensor, padding, mode='constant', value=0)
  7.         padded_tensors.append(padded_tensor)
  8.     return padded_tensors
  9. def dateset2loader(config, vocab, traindata, testdata):
  10.     tokenizer = get_tokenizer('basic_english')  # 基本的英文分词器，tokenizer会把句子进行分割，类似jieba
  11.     # Step3 构建数据加载器 dataloader
  12.     ##########################################################################
  13.  
  14.     print("Step3: DateSet -> Dataloader")
  15.     ##########################################################################
  16.     # text_pipeline将一个文本字符串转换为整数List, List中每项对应词汇表voca中的单词的索引号
  17.     text_pipeline = lambda x: vocab(tokenizer(x))
  18.  
  19.     # label_pipeline将label转换为整数
  20.     label_pipeline = lambda x: int(x) - 1
  21.  
  22.     # 加载数据集合，转换为张量
  23.     def collate_batch(batch):
  24.         """
  25.         (3, "Wall") -> (2, "467")
  26.         :param batch:
  27.         :return:
  28.         """
  29.         label_list, text_list = [], []
  30.         for (_label, _text) in batch:
  31.             label_list.append(label_pipeline(_label))
  32.             processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64)
  33.             text_list.append(processed_text)
  34.  
  35.         # 指定句子长度统一的标准
  36.         if config.seq_mode == "min":
  37.             seq_len = min(len(item) for item in text_list)
  38.         elif config.seq_mode == "max":
  39.             seq_len = max(len(item) for item in text_list)
  40.         elif config.seq_mode == "avg":
  41.             seq_len = sum(len(item) for item in text_list)/len(text_list)
  42.         elif isinstance(config.seq_mode, int):
  43.             seq_len = config.seq_mode
  44.         else:
  45.             seq_len = min(len(item) for item in text_list)
  46.         seq_len = int(seq_len)
  47.         # 每一个batch里统一长度
  48.         batch_seq = torch.stack(tensor_padding(text_list, seq_len))
  49.  
  50.         label_list = torch.tensor(label_list, dtype=torch.int64)
  51.         return label_list, batch_seq
  52.  
  53.     train_dataloader = DataLoader(traindata, batch_size=config.batchsize, shuffle=True, collate_fn=collate_batch)
  54.     test_dataloader = DataLoader(testdata, batch_size=config.batchsize, shuffle=True, collate_fn=collate_batch)
  55.  
  56.     return train_dataloader, test_dataloader

文本词嵌入

  1. self.embedding = nn.Embedding(len_vocab, embedding_size)
  2. #len_vocab是上面构建的词汇表的长度
  3. #embedding_size就是向量化后，每个词变成的维度大小

网络搭建

batch_first=True默认是为False的，如果不设置为True，那么你的索引文本的尺寸就得是[句子长度，batch_size]

  1. class RNNnet(nn.Module):
  2.     def __init__(self, len_vocab, embedding_size, hidden_size, num_class, num_layers):
  3.         super(RNNnet, self).__init__()
  4.         self.hidden = hidden_size
  5.         self.num_layers = num_layers
  6.         self.embedding = nn.Embedding(len_vocab, embedding_size)
  7.         self.rnn = nn.RNN(embedding_size, hidden_size, num_layers=num_layers, batch_first=True)
  8.         self.fc = nn.Linear(hidden_size, num_class)
  9. ​
  10.     def forward(self, text):
  11.         """
  12.         :param text: [batch_size, sentence_len]
  13.         :return:
  14.         """
  15.         # embedded:[batch_size,sentence_len , embedding_size]
  16.         embedded = self.embedding(text)
  17.         # output:[batch_size, sentence_len, hidden_size]
  18.         # hidden:[1, batch_size, hidden_size]
  19.         output, hidden = self.rnn(embedded)
  20.         return self.fc(hidden[-1])

模型训练

  1. def model_train(config, len_vocab, classes, train_dataloader, test_dataloader):
  2.     # 构建模型
  3.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  4.     rnn_model = RNNnet(
  5.         len_vocab=len_vocab,
  6.         embedding_size=config.embedding_size,
  7.         hidden_size=config.hidden_size,
  8.         num_class=len(classes),
  9.         num_layers=config.num_layers
  10.     )
  11. ​
  12.     optimizer = torch.optim.Adam(rnn_model.parameters(), lr=config.l_r)
  13.     loss_fn = nn.CrossEntropyLoss()
  14.     rnn_model.train()
  15.     rnn_model.to(device)
  16.     # 训练模型
  17.     LOSS = []
  18.     ACC = []
  19.     os.makedirs(config.savepath, exist_ok=True)
  20.     for epoch in range(config.epochs):
  21.         loop = tqdm(train_dataloader, desc='Train')
  22.         total_loss, total_acc, count, i = 0, 0, 0, 0
  23.         for idx, (label, text) in enumerate(loop):
  24.             text = text.to(device)
  25.             label = label.to(device)
  26.             optimizer.zero_grad()
  27.             output = rnn_model(text)  # 预测
  28.             loss = loss_fn(output, label)
  29.             loss.backward()
  30.             optimizer.step()
  31. ​
  32.             predict = torch.argmax(output, dim=1)  # 判断与原标签是否一样
  33.             acc = (predict == label).sum()
  34.             total_loss += loss.item()
  35.             total_acc += acc.item()
  36.             count += len(label)
  37.             i += 1
  38.             # 打印过程
  39.             loop.set_description(f'Epoch [{epoch + 1}/{config.epochs}]')
  40.             loop.set_postfix(loss=round(loss.item(), 4), acc=(round(acc.item() / len(label), 4) * 100))
  41.         print(
  42.             f"epoch_loss:{round(total_loss / i, 4)}\nepoch_acc:{round(total_acc / count, 4) * 100}%")
  43.         # 保存模型参数
  44.         torch.save(rnn_model.state_dict(), f"{config.savepath}/{config.modelpath}")
  45.         LOSS.append(round(total_loss / i, 4))
  46.         ACC.append(round((total_acc / count) * 100, 4))
  47. ​
  48.         modeltest(config, len_vocab, classes, test_dataloader)
  49.     print(f"LOSS_array:{LOSS}")
  50.     print(f"ACC_array:{ACC}")
  51.     with open(config.logpath, 'w') as f:
  52.         f.write(f"LOSS_array:{LOSS}\nACC_array:{ACC}")

损失值和准确度曲线图

  1. def plot_result(logpath, mode):
  2.     mode_set = ["loss", 'accuracy']
  3.     if mode not in mode_set:
  4.         return "wrong mode"
  5.     color = ['blue', 'red']
  6.     with open(logpath, "r") as f:
  7.         line = f.readlines()[mode_set.index(mode)]
  8.         y = eval(line[line.index(':') + 1:])
  9.         x = [i for i in range(len(y))]
  10. ​
  11.         plt.figure()
  12. ​
  13.         # 去除顶部和右边框框
  14.         ax = plt.axes()
  15.         ax.spines['top'].set_visible(False)
  16.         ax.spines['right'].set_visible(False)
  17. ​
  18.         plt.xlabel('epoch')
  19.         plt.ylabel(f'{mode}')
  20. ​
  21.         plt.plot(x, y, color=color[mode_set.index(mode)], linestyle="solid", label=f"train {mode}")
  22.         plt.legend()
  23. ​
  24.         plt.title(f'train {mode} curve')
  25.         # plt.show()
  26.         plt.savefig(f"{mode}.png")

模型测试

  1. def modeltest(config, len_vocab, classes, test_dataloader):
  2.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  3.     # 测试模型
  4.     rnn_model_test = RNNnet(
  5.         len_vocab=len_vocab,
  6.         embedding_size=config.embedding_size,
  7.         hidden_size=config.hidden_size,
  8.         num_class=len(classes),
  9.         num_layers=config.num_layers
  10.     )
  11.     rnn_model_test.load_state_dict(torch.load(f"{config.savepath}/{config.modelpath}"))
  12.     rnn_model_test.eval()
  13.     rnn_model_test.to(device)
  14.     test_loop = tqdm(test_dataloader)
  15.     total_acc, count = 0, 0
  16.     for idx, (label, text) in enumerate(test_loop):
  17.         text = text.to(device)
  18.         label = label.to(device)
  19.         output = rnn_model_test(text)
  20.         predict = torch.argmax(output, dim=1)  # 判断与原标签是否一样
  21.         acc = (predict == label).sum()
  22.         total_acc += acc.item()
  23.         count += len(label)
  24.     print(f"测试集精度：{round((total_acc / count) * 100, 2)}%")

测试集精度：86.53%

测试自己输入的样本

  1. #Fears for T N pension after talksUnions representing workers at Turner   Newall say they are 'disappointed' after talks with stricken parent firm Federal Mogul.
  2.  
  3. #The Race is On: Second Private Team Sets Launch Date for Human SPACE.com - TORONTO, Canada -- A second\team of rocketeers competing for the  #36;10 million Ansari X Prize, a contest for\privately funded suborbital space flight, has officially announced the first\launch date for its manned rocket.
  4.  
  5. #Dutch Retailer Beats Apple to Local Download Market AMSTERDAM (Reuters) - Free Record Shop, a Dutch music  retail chain, beat Apple Computer Inc. to market on Tuesday  with the launch of a new download service in Europe's latest  battleground for digital song services.
  6.  
  7. #U.S. Urges China to Push for More N.Korea Talks BEIJING (Reuters) - Secretary of State Colin Powell urged  China on Monday to exert its influence over North Korea to  resume stalled talks on scrapping its nuclear weapons programs  and pressed Beijing to accept a Taiwan offer of talks.
  8.  
  9. #这四个样本的原标签分别为：3，4，4，1
  1. def simple(vocab, text_one):
  2.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  3.     # 测试模型
  4.     rnn_model_test = RNNnet(
  5.         len_vocab=len_vocab,
  6.         embedding_size=config.embedding_size,
  7.         hidden_size=config.hidden_size,
  8.         num_class=len(classes),
  9.         num_layers=config.num_layers
  10.     )
  11.     rnn_model_test.load_state_dict(torch.load(f"{config.savepath}/{config.modelpath}"))
  12.     rnn_model_test.eval()
  13.     rnn_model_test.to(device)
  14.  
  15.     text_pipeline = lambda x: vocab(tokenizer(x))
  16.     tokenizer = get_tokenizer('basic_english')  # 基本的英文分词器，tokenizer会把句子进行分割，类似jieba
  17.  
  18.     for text in text_one:
  19.         text_one_tensor = torch.tensor(text_pipeline(text), dtype=torch.int64)
  20.         text_one_tensor = text_one_tensor.to(device)
  21.         print(f"预测标签为：{torch.argmax(rnn_model_test(text_one_tensor)).item()+1}")

预测结果：

完整代码

model_set.py

  1. import os
  2.  
  3. import matplotlib.pyplot as plt
  4. import torch
  5. import torch.nn as nn
  6. import torch.optim
  7. from torch.utils.data import DataLoader
  8. from torchtext.data.utils import get_tokenizer
  9. from torchtext.datasets import AG_NEWS
  10. from torchtext.vocab import build_vocab_from_iterator
  11. from tqdm import tqdm
  12.  
  13. from model_set import RNNnet
  14.  
  15.  
  16. def loaddata(config):
  17.     # Step1 加载数据集
  18.     #######################################################################
  19.  
  20.     print("Step1: Loading DateSet")
  21.     #######################################################################
  22.     # 【数据集介绍】AG_NEWS, 新闻语料库，仅仅使用了标题和描述字段，
  23.     # 包含4个大类新闻:World、Sports、Business、Sci/Tec。
  24.     # 【样本数据】 120000条训练样本集（train.csv)， 7600测试样本数据集(test.csv);
  25.     # 每个类别分别拥有 30,000 个训练样本及 1900 个测试样本。
  26.     os.makedirs(config.datapath, exist_ok=True)
  27.     train_dataset_o, test_dataset_o = AG_NEWS(root=config.datapath, split=('train', 'test'))
  28.     classes = ['World', 'Sports', 'Business', 'Sci/Tech']
  29.  
  30.     # for t in test_dataset_o:
  31.     #     print(t)
  32.     #     break
  33.  
  34.     return train_dataset_o, test_dataset_o, classes
  35.  
  36.  
  37. def bulvocab(traindata):
  38.     # Step2 分词，构建词汇表
  39.     #######################################################################
  40.     #
  41.     print("Step2: Building VocabSet")
  42.     #######################################################################
  43.     tokenizer = get_tokenizer('basic_english')  # 基本的英文分词器，tokenizer会把句子进行分割，类似jieba
  44.  
  45.     def yield_tokens(data_iter):  # 分词生成器
  46.         for _, text in data_iter:
  47.             yield tokenizer(text)  # yield会构建一个类似列表可迭代的东西，但比起直接使用列表要少占用很多内存
  48.  
  49.     # 根据训练数据构建词汇表
  50.     vocab = build_vocab_from_iterator(yield_tokens(traindata), specials=["<PAD>"])  # <unk>代指低频词或未在词表中的词
  51.     # 词汇表会将token映射到词汇表中的索引上，注意词汇表的构建不需要用测试集
  52.     vocab.set_default_index(vocab["<PAD>"])  # 设置默认索引，当某个单词不在词汇表vocab时（OOV)，返回该单词索引
  53.     print(f"len vocab:{len(vocab)}")
  54.     len_vocab = len(vocab)
  55.  
  56.     return vocab, len_vocab
  57.  
  58.  
  59. def tensor_padding(tensor_list, seq_len):
  60.     # 填充前两个张量
  61.     padded_tensors = []
  62.     for tensor in tensor_list:
  63.         padding = (0, seq_len - len(tensor))  # 在末尾填充0
  64.         padded_tensor = torch.nn.functional.pad(tensor, padding, mode='constant', value=0)
  65.         padded_tensors.append(padded_tensor)
  66.     return padded_tensors
  67.  
  68.  
  69. def dateset2loader(config, vocab, traindata, testdata):
  70.     tokenizer = get_tokenizer('basic_english')  # 基本的英文分词器，tokenizer会把句子进行分割，类似jieba
  71.     # Step3 构建数据加载器 dataloader
  72.     ##########################################################################
  73.  
  74.     print("Step3: DateSet -> Dataloader")
  75.     ##########################################################################
  76.     # text_pipeline将一个文本字符串转换为整数List, List中每项对应词汇表voca中的单词的索引号
  77.     text_pipeline = lambda x: vocab(tokenizer(x))
  78.  
  79.     # label_pipeline将label转换为整数
  80.     label_pipeline = lambda x: int(x) - 1
  81.  
  82.     # 加载数据集合，转换为张量
  83.     def collate_batch(batch):
  84.         """
  85.         (3, "Wall") -> (2, "467")
  86.         :param batch:
  87.         :return:
  88.         """
  89.         label_list, text_list = [], []
  90.         for (_label, _text) in batch:
  91.             label_list.append(label_pipeline(_label))
  92.             processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64)
  93.             text_list.append(processed_text)
  94.  
  95.         # 指定句子长度统一的标准
  96.         if config.seq_mode == "min":
  97.             seq_len = min(len(item) for item in text_list)
  98.         elif config.seq_mode == "max":
  99.             seq_len = max(len(item) for item in text_list)
  100.         elif config.seq_mode == "avg":
  101.             seq_len = sum(len(item) for item in text_list) / len(text_list)
  102.         elif isinstance(config.seq_mode, int):
  103.             seq_len = config.seq_mode
  104.         else:
  105.             seq_len = min(len(item) for item in text_list)
  106.         seq_len = int(seq_len)
  107.         # 每一个batch里统一长度
  108.         batch_seq = torch.stack(tensor_padding(text_list, seq_len))
  109.  
  110.         label_list = torch.tensor(label_list, dtype=torch.int64)
  111.         return label_list, batch_seq
  112.  
  113.     train_dataloader = DataLoader(traindata, batch_size=config.batchsize, shuffle=True, collate_fn=collate_batch)
  114.     test_dataloader = DataLoader(testdata, batch_size=config.batchsize, shuffle=True, collate_fn=collate_batch)
  115.  
  116.     return train_dataloader, test_dataloader
  117.  
  118.  
  119. def model_train(config, len_vocab, classes, train_dataloader, test_dataloader):
  120.     # 构建模型
  121.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  122.     rnn_model = RNNnet(
  123.         len_vocab=len_vocab,
  124.         embedding_size=config.embedding_size,
  125.         hidden_size=config.hidden_size,
  126.         num_class=len(classes),
  127.         num_layers=config.num_layers
  128.     )
  129.  
  130.     optimizer = torch.optim.Adam(rnn_model.parameters(), lr=config.l_r)
  131.     loss_fn = nn.CrossEntropyLoss()
  132.     rnn_model.train()
  133.     rnn_model.to(device)
  134.     # 训练模型
  135.     LOSS = []
  136.     ACC = []
  137.     os.makedirs(config.savepath, exist_ok=True)
  138.     best_acc = 0
  139.     for epoch in range(config.epochs):
  140.         loop = tqdm(train_dataloader, desc='Train')
  141.         total_loss, total_acc, count, i = 0, 0, 0, 0
  142.         rnn_model.train()
  143.         for idx, (label, text) in enumerate(loop):
  144.             text = text.to(device)
  145.             label = label.to(device)
  146.             optimizer.zero_grad()
  147.             output = rnn_model(text)  # 预测
  148.             loss = loss_fn(output, label)
  149.             loss.backward()
  150.             optimizer.step()
  151.  
  152.             predict = torch.argmax(output, dim=1)  # 判断与原标签是否一样
  153.             acc = (predict == label).sum()
  154.             total_loss += loss.item()
  155.             total_acc += acc.item()
  156.             count += len(label)
  157.             i += 1
  158.             # 打印过程
  159.             loop.set_description(f'Epoch [{epoch + 1}/{config.epochs}]')
  160.             loop.set_postfix(loss=round(loss.item(), 4), acc=(round(acc.item() / len(label), 4) * 100))
  161.         print(
  162.             f"epoch_loss:{round(total_loss / i, 4)}\nepoch_acc:{round(total_acc / count, 4) * 100}%")
  163.         # 保存模型参数
  164.  
  165.         LOSS.append(round(total_loss / i, 4))
  166.         ACC.append(round((total_acc / count) * 100, 4))
  167.  
  168.         rnn_model.eval()
  169.         test_loop = tqdm(test_dataloader)
  170.         total_acc, count = 0, 0
  171.         for idx, (label, text) in enumerate(test_loop):
  172.             text = text.to(device)
  173.             label = label.to(device)
  174.             output = rnn_model(text)
  175.             predict = torch.argmax(output, dim=1)  # 判断与原标签是否一样
  176.             acc = (predict == label).sum()
  177.             total_acc += acc.item()
  178.             count += len(label)
  179.         print(f"测试集精度：{round((total_acc / count) * 100, 2)}%")
  180.         temp_acc = round((total_acc / count) * 100, 2)
  181.         if temp_acc>best_acc:
  182.             best_acc = temp_acc
  183.             torch.save(rnn_model.state_dict(), f"{config.savepath}/{config.modelpath}")
  184.  
  185.     print(f"LOSS_array:{LOSS}")
  186.     print(f"ACC_array:{ACC}")
  187.     with open(config.logpath, 'w') as f:
  188.         f.write(f"LOSS_array:{LOSS}\nACC_array:{ACC}")
  189.  
  190.  
  191. def modeltest(config, len_vocab, classes, test_dataloader):
  192.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  193.     # 测试模型
  194.     rnn_model_test = RNNnet(
  195.         len_vocab=len_vocab,
  196.         embedding_size=config.embedding_size,
  197.         hidden_size=config.hidden_size,
  198.         num_class=len(classes),
  199.         num_layers=config.num_layers
  200.     )
  201.     rnn_model_test.load_state_dict(torch.load(f"{config.savepath}/{config.modelpath}"))
  202.     rnn_model_test.eval()
  203.     rnn_model_test.to(device)
  204.     test_loop = tqdm(test_dataloader)
  205.     total_acc, count = 0, 0
  206.     for idx, (label, text) in enumerate(test_loop):
  207.         text = text.to(device)
  208.         label = label.to(device)
  209.         output = rnn_model_test(text)
  210.         predict = torch.argmax(output, dim=1)  # 判断与原标签是否一样
  211.         acc = (predict == label).sum()
  212.         total_acc += acc.item()
  213.         count += len(label)
  214.     print(f"测试集精度：{round((total_acc / count) * 100, 2)}%")
  215.  
  216. def plot_result(logpath, mode):
  217.     mode_set = ["loss", 'accuracy']
  218.     if mode not in mode_set:
  219.         return "wrong mode"
  220.     color = ['blue', 'red']
  221.     with open(logpath, "r") as f:
  222.         line = f.readlines()[mode_set.index(mode)]
  223.         y = eval(line[line.index(':') + 1:])
  224.         x = [i for i in range(len(y))]
  225.  
  226.         plt.figure()
  227.  
  228.         # 去除顶部和右边框框
  229.         ax = plt.axes()
  230.         ax.spines['top'].set_visible(False)
  231.         ax.spines['right'].set_visible(False)
  232.  
  233.         plt.xlabel('epoch')
  234.         plt.ylabel(f'{mode}')
  235.  
  236.         plt.plot(x, y, color=color[mode_set.index(mode)], linestyle="solid", label=f"train {mode}")
  237.         plt.legend()
  238.  
  239.         plt.title(f'train {mode} curve')
  240.         # plt.show()
  241.         plt.savefig(f"{mode}.png")
  242.  
  243.  
  244. class Config:
  245.     def __init__(self):
  246.         #######################################
  247.         # 数据集使用的是AG_NEWS，实现文本分类任务
  248.         #######################################
  249.         self.datapath = './data'
  250.         self.savepath = './save_model'
  251.         self.modelpath = 'rnn_model.pt'
  252.         self.logpath = 'log_best.txt'
  253.         self.embedding_size = 128
  254.         self.hidden_size = 256
  255.         self.num_layers = 1  # rnn的层数
  256.         self.l_r = 1e-3
  257.         self.epochs = 50
  258.         self.batchsize = 1024
  259.         self.plotloss = False
  260.         self.plotacc = False
  261.         self.train = True
  262.         self.test = False
  263.         self.seq_mode = "avg"  # seq_mode:min、max、avg、也可输入一个数字自定义长度
  264.         self.test_one = False
  265.         self.test_self = "./test_self.txt"
  266.  
  267.     def parm(self):
  268.         print(
  269.             f"datapath={self.datapath}\n"
  270.             f"savepath={self.savepath}\n"
  271.             f"modelpath={self.modelpath}\n"
  272.             f"logpath={self.logpath}\n"
  273.             f"embedding_size={self.embedding_size}\n"
  274.             f"hidden_size={self.hidden_size}\n"
  275.             f"num_layers={self.num_layers}\n"
  276.             f"l_r={self.l_r}\n"
  277.             f"epochs={self.epochs}\n"
  278.             f"batchsize={self.batchsize}\n"
  279.             f"plotloss={self.plotloss}\n"
  280.             f"plotacc={self.plotacc}\n"
  281.             f"train={self.train}\n"
  282.             f"test={self.test}\n"
  283.             f"seq_mode={self.seq_mode}\n"
  284.             f"test_one={self.test_one}\n"
  285.             f"test_self={self.test_self}\n"
  286.         )
  287.  
  288.  
  289. def simple(vocab, text_one):
  290.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  291.     # 测试模型
  292.     rnn_model_test = RNNnet(
  293.         len_vocab=len_vocab,
  294.         embedding_size=config.embedding_size,
  295.         hidden_size=config.hidden_size,
  296.         num_class=len(classes),
  297.         num_layers=config.num_layers
  298.     )
  299.     rnn_model_test.load_state_dict(torch.load(f"{config.savepath}/{config.modelpath}"))
  300.     rnn_model_test.eval()
  301.     rnn_model_test.to(device)
  302.  
  303.     text_pipeline = lambda x: vocab(tokenizer(x))
  304.     tokenizer = get_tokenizer('basic_english')  # 基本的英文分词器，tokenizer会把句子进行分割，类似jieba
  305.  
  306.     for text in text_one:
  307.         text_one_tensor = torch.tensor(text_pipeline(text), dtype=torch.int64)
  308.         text_one_tensor = text_one_tensor.to(device)
  309.         print(f"预测标签为：{torch.argmax(rnn_model_test(text_one_tensor)).item()+1}")
  310.  
  311.  
  312. if __name__ == "__main__":
  313.     config = Config()
  314.     config.parm()
  315.     if config.train:
  316.         train_dataset_o, test_dataset_o, classes = loaddata(config)
  317.         vocab, len_vocab = bulvocab(train_dataset_o)
  318.         train_dataloader, test_dataloader = dateset2loader(config, vocab, train_dataset_o, test_dataset_o)
  319.         model_train(config, len_vocab, classes, train_dataloader, test_dataloader)
  320.     elif config.test:
  321.         train_dataset_o, test_dataset_o, classes = loaddata(config)
  322.         vocab, len_vocab = bulvocab(train_dataset_o)
  323.         train_dataloader, test_dataloader = dateset2loader(config, vocab, train_dataset_o, test_dataset_o)
  324.         modeltest(config, len_vocab, classes, test_dataloader)
  325.     elif config.plotloss:
  326.         plot_result(config.logpath, 'loss')
  327.     elif config.plotacc:
  328.         plot_result(config.logpath, 'accuracy')
  329.     elif config.test_one:
  330.         train_dataset_o, test_dataset_o, classes = loaddata(config)
  331.         vocab, len_vocab = bulvocab(train_dataset_o)
  332.         with open(config.test_self, "r") as f:
  333.             simple(vocab, f.readlines())

  1. import os
  2.  
  3. import matplotlib.pyplot as plt
  4. import torch
  5. import torch.nn as nn
  6. import torch.optim
  7. from torch.utils.data import DataLoader
  8. from torchtext.data.utils import get_tokenizer
  9. from torchtext.datasets import AG_NEWS
  10. from torchtext.vocab import build_vocab_from_iterator
  11. from tqdm import tqdm
  12.  
  13. from model_set import RNNnet
  14.  
  15.  
  16. def loaddata(config):
  17.     # Step1 加载数据集
  18.     #######################################################################
  19.  
  20.     print("Step1: Loading DateSet")
  21.     #######################################################################
  22.     # 【数据集介绍】AG_NEWS, 新闻语料库，仅仅使用了标题和描述字段，
  23.     # 包含4个大类新闻:World、Sports、Business、Sci/Tec。
  24.     # 【样本数据】 120000条训练样本集（train.csv)， 7600测试样本数据集(test.csv);
  25.     # 每个类别分别拥有 30,000 个训练样本及 1900 个测试样本。
  26.     os.makedirs(config.datapath, exist_ok=True)
  27.     train_dataset_o, test_dataset_o = AG_NEWS(root=config.datapath, split=('train', 'test'))
  28.     classes = ['World', 'Sports', 'Business', 'Sci/Tech']
  29.  
  30.     # for t in test_dataset_o:
  31.     #     print(t)
  32.     #     break
  33.  
  34.     return train_dataset_o, test_dataset_o, classes
  35.  
  36.  
  37. def bulvocab(traindata):
  38.     # Step2 分词，构建词汇表
  39.     #######################################################################
  40.     #
  41.     print("Step2: Building VocabSet")
  42.     #######################################################################
  43.     tokenizer = get_tokenizer('basic_english')  # 基本的英文分词器，tokenizer会把句子进行分割，类似jieba
  44.  
  45.     def yield_tokens(data_iter):  # 分词生成器
  46.         for _, text in data_iter:
  47.             yield tokenizer(text)  # yield会构建一个类似列表可迭代的东西，但比起直接使用列表要少占用很多内存
  48.  
  49.     # 根据训练数据构建词汇表
  50.     vocab = build_vocab_from_iterator(yield_tokens(traindata), specials=["<PAD>"])  # <unk>代指低频词或未在词表中的词
  51.     # 词汇表会将token映射到词汇表中的索引上，注意词汇表的构建不需要用测试集
  52.     vocab.set_default_index(vocab["<PAD>"])  # 设置默认索引，当某个单词不在词汇表vocab时（OOV)，返回该单词索引
  53.     print(f"len vocab:{len(vocab)}")
  54.     len_vocab = len(vocab)
  55.  
  56.     return vocab, len_vocab
  57.  
  58.  
  59. def tensor_padding(tensor_list, seq_len):
  60.     # 填充前两个张量
  61.     padded_tensors = []
  62.     for tensor in tensor_list:
  63.         padding = (0, seq_len - len(tensor))  # 在末尾填充0
  64.         padded_tensor = torch.nn.functional.pad(tensor, padding, mode='constant', value=0)
  65.         padded_tensors.append(padded_tensor)
  66.     return padded_tensors
  67.  
  68.  
  69. def dateset2loader(config, vocab, traindata, testdata):
  70.     tokenizer = get_tokenizer('basic_english')  # 基本的英文分词器，tokenizer会把句子进行分割，类似jieba
  71.     # Step3 构建数据加载器 dataloader
  72.     ##########################################################################
  73.  
  74.     print("Step3: DateSet -> Dataloader")
  75.     ##########################################################################
  76.     # text_pipeline将一个文本字符串转换为整数List, List中每项对应词汇表voca中的单词的索引号
  77.     text_pipeline = lambda x: vocab(tokenizer(x))
  78.  
  79.     # label_pipeline将label转换为整数
  80.     label_pipeline = lambda x: int(x) - 1
  81.  
  82.     # 加载数据集合，转换为张量
  83.     def collate_batch(batch):
  84.         """
  85.         (3, "Wall") -> (2, "467")
  86.         :param batch:
  87.         :return:
  88.         """
  89.         label_list, text_list = [], []
  90.         for (_label, _text) in batch:
  91.             label_list.append(label_pipeline(_label))
  92.             processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64)
  93.             text_list.append(processed_text)
  94.  
  95.         # 指定句子长度统一的标准
  96.         if config.seq_mode == "min":
  97.             seq_len = min(len(item) for item in text_list)
  98.         elif config.seq_mode == "max":
  99.             seq_len = max(len(item) for item in text_list)
  100.         elif config.seq_mode == "avg":
  101.             seq_len = sum(len(item) for item in text_list) / len(text_list)
  102.         elif isinstance(config.seq_mode, int):
  103.             seq_len = config.seq_mode
  104.         else:
  105.             seq_len = min(len(item) for item in text_list)
  106.         seq_len = int(seq_len)
  107.         # 每一个batch里统一长度
  108.         batch_seq = torch.stack(tensor_padding(text_list, seq_len))
  109.  
  110.         label_list = torch.tensor(label_list, dtype=torch.int64)
  111.         return label_list, batch_seq
  112.  
  113.     train_dataloader = DataLoader(traindata, batch_size=config.batchsize, shuffle=True, collate_fn=collate_batch)
  114.     test_dataloader = DataLoader(testdata, batch_size=config.batchsize, shuffle=True, collate_fn=collate_batch)
  115.  
  116.     return train_dataloader, test_dataloader
  117.  
  118.  
  119. def model_train(config, len_vocab, classes, train_dataloader, test_dataloader):
  120.     # 构建模型
  121.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  122.     rnn_model = RNNnet(
  123.         len_vocab=len_vocab,
  124.         embedding_size=config.embedding_size,
  125.         hidden_size=config.hidden_size,
  126.         num_class=len(classes),
  127.         num_layers=config.num_layers
  128.     )
  129.  
  130.     optimizer = torch.optim.Adam(rnn_model.parameters(), lr=config.l_r)
  131.     loss_fn = nn.CrossEntropyLoss()
  132.     rnn_model.train()
  133.     rnn_model.to(device)
  134.     # 训练模型
  135.     LOSS = []
  136.     ACC = []
  137.     os.makedirs(config.savepath, exist_ok=True)
  138.     for epoch in range(config.epochs):
  139.         loop = tqdm(train_dataloader, desc='Train')
  140.         total_loss, total_acc, count, i = 0, 0, 0, 0
  141.         for idx, (label, text) in enumerate(loop):
  142.             text = text.to(device)
  143.             label = label.to(device)
  144.             optimizer.zero_grad()
  145.             output = rnn_model(text)  # 预测
  146.             loss = loss_fn(output, label)
  147.             loss.backward()
  148.             optimizer.step()
  149.  
  150.             predict = torch.argmax(output, dim=1)  # 判断与原标签是否一样
  151.             acc = (predict == label).sum()
  152.             total_loss += loss.item()
  153.             total_acc += acc.item()
  154.             count += len(label)
  155.             i += 1
  156.             # 打印过程
  157.             loop.set_description(f'Epoch [{epoch + 1}/{config.epochs}]')
  158.             loop.set_postfix(loss=round(loss.item(), 4), acc=(round(acc.item() / len(label), 4) * 100))
  159.         print(
  160.             f"epoch_loss:{round(total_loss / i, 4)}\nepoch_acc:{round(total_acc / count, 4) * 100}%")
  161.         # 保存模型参数
  162.         torch.save(rnn_model.state_dict(), f"{config.savepath}/{config.modelpath}")
  163.         LOSS.append(round(total_loss / i, 4))
  164.         ACC.append(round((total_acc / count) * 100, 4))
  165.  
  166.         modeltest(config, len_vocab, classes, test_dataloader)
  167.     print(f"LOSS_array:{LOSS}")
  168.     print(f"ACC_array:{ACC}")
  169.     with open(config.logpath, 'w') as f:
  170.         f.write(f"LOSS_array:{LOSS}\nACC_array:{ACC}")
  171.  
  172.  
  173. def modeltest(config, len_vocab, classes, test_dataloader):
  174.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  175.     # 测试模型
  176.     rnn_model_test = RNNnet(
  177.         len_vocab=len_vocab,
  178.         embedding_size=config.embedding_size,
  179.         hidden_size=config.hidden_size,
  180.         num_class=len(classes),
  181.         num_layers=config.num_layers
  182.     )
  183.     rnn_model_test.load_state_dict(torch.load(f"{config.savepath}/{config.modelpath}"))
  184.     rnn_model_test.eval()
  185.     rnn_model_test.to(device)
  186.     test_loop = tqdm(test_dataloader)
  187.     total_acc, count = 0, 0
  188.     for idx, (label, text) in enumerate(test_loop):
  189.         text = text.to(device)
  190.         label = label.to(device)
  191.         output = rnn_model_test(text)
  192.         predict = torch.argmax(output, dim=1)  # 判断与原标签是否一样
  193.         acc = (predict == label).sum()
  194.         total_acc += acc.item()
  195.         count += len(label)
  196.     print(f"测试集精度：{round((total_acc / count) * 100, 2)}%")
  197.  
  198.  
  199. def plot_result(logpath, mode):
  200.     mode_set = ["loss", 'accuracy']
  201.     if mode not in mode_set:
  202.         return "wrong mode"
  203.     color = ['blue', 'red']
  204.     with open(logpath, "r") as f:
  205.         line = f.readlines()[mode_set.index(mode)]
  206.         y = eval(line[line.index(':') + 1:])
  207.         x = [i for i in range(len(y))]
  208.  
  209.         plt.figure()
  210.  
  211.         # 去除顶部和右边框框
  212.         ax = plt.axes()
  213.         ax.spines['top'].set_visible(False)
  214.         ax.spines['right'].set_visible(False)
  215.  
  216.         plt.xlabel('epoch')
  217.         plt.ylabel(f'{mode}')
  218.  
  219.         plt.plot(x, y, color=color[mode_set.index(mode)], linestyle="solid", label=f"train {mode}")
  220.         plt.legend()
  221.  
  222.         plt.title(f'train {mode} curve')
  223.         # plt.show()
  224.         plt.savefig(f"{mode}.png")
  225.  
  226.  
  227. class Config:
  228.     def __init__(self):
  229.         #######################################
  230.         # 数据集使用的是AG_NEWS，实现文本分类任务
  231.         #######################################
  232.         self.datapath = './data'
  233.         self.savepath = './save_model'
  234.         self.modelpath = 'rnn_model_best.pt'
  235.         self.logpath = 'log_best.txt'
  236.         self.embedding_size = 128
  237.         self.hidden_size = 256
  238.         self.num_layers = 1  # rnn的层数
  239.         self.l_r = 1e-3
  240.         self.epochs = 50
  241.         self.batchsize = 1024
  242.         self.plotloss = False
  243.         self.plotacc = False
  244.         self.train = False
  245.         self.test = False
  246.         self.seq_mode = "min"  # seq_mode:min、max、avg、也可输入一个数字自定义长度
  247.         self.test_one = True
  248.         self.test_self = "./test_self.txt"
  249.  
  250.     def parm(self):
  251.         print(
  252.             f"datapath={self.datapath}\n"
  253.             f"savepath={self.savepath}\n"
  254.             f"modelpath={self.modelpath}\n"
  255.             f"logpath={self.logpath}\n"
  256.             f"embedding_size={self.embedding_size}\n"
  257.             f"hidden_size={self.hidden_size}\n"
  258.             f"num_layers={self.num_layers}\n"
  259.             f"l_r={self.l_r}\n"
  260.             f"epochs={self.epochs}\n"
  261.             f"batchsize={self.batchsize}\n"
  262.             f"plotloss={self.plotloss}\n"
  263.             f"plotacc={self.plotacc}\n"
  264.             f"train={self.train}\n"
  265.             f"test={self.test}\n"
  266.             f"seq_mode={self.seq_mode}\n"
  267.             f"test_one={self.test_one}\n"
  268.             f"test_self={self.test_self}\n"
  269.         )
  270.  
  271.  
  272. def simple(vocab, text_one):
  273.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  274.     # 测试模型
  275.     rnn_model_test = RNNnet(
  276.         len_vocab=len_vocab,
  277.         embedding_size=config.embedding_size,
  278.         hidden_size=config.hidden_size,
  279.         num_class=len(classes),
  280.         num_layers=config.num_layers
  281.     )
  282.     rnn_model_test.load_state_dict(torch.load(f"{config.savepath}/{config.modelpath}"))
  283.     rnn_model_test.eval()
  284.     rnn_model_test.to(device)
  285.  
  286.     text_pipeline = lambda x: vocab(tokenizer(x))
  287.     tokenizer = get_tokenizer('basic_english')  # 基本的英文分词器，tokenizer会把句子进行分割，类似jieba
  288.  
  289.     for text in text_one:
  290.         text_one_tensor = torch.tensor(text_pipeline(text), dtype=torch.int64)
  291.         text_one_tensor = text_one_tensor.to(device)
  292.         print(f"预测标签为：{torch.argmax(rnn_model_test(text_one_tensor)).item()+1}")
  293.  
  294.  
  295. if __name__ == "__main__":
  296.     config = Config()
  297.     config.parm()
  298.     if config.train:
  299.         train_dataset_o, test_dataset_o, classes = loaddata(config)
  300.         vocab, len_vocab = bulvocab(train_dataset_o)
  301.         train_dataloader, test_dataloader = dateset2loader(config, vocab, train_dataset_o, test_dataset_o)
  302.         model_train(config, len_vocab, classes, train_dataloader, test_dataloader)
  303.     elif config.test:
  304.         train_dataset_o, test_dataset_o, classes = loaddata(config)
  305.         vocab, len_vocab = bulvocab(train_dataset_o)
  306.         train_dataloader, test_dataloader = dateset2loader(config, vocab, train_dataset_o, test_dataset_o)
  307.         modeltest(config, len_vocab, classes, test_dataloader)
  308.     elif config.plotloss:
  309.         plot_result(config.logpath, 'loss')
  310.     elif config.plotacc:
  311.         plot_result(config.logpath, 'accuracy')
  312.     elif config.test_one:
  313.         train_dataset_o, test_dataset_o, classes = loaddata(config)
  314.         vocab, len_vocab = bulvocab(train_dataset_o)
  315.         with open(config.test_self, "r") as f:
  316.             simple(vocab, f.readlines())

细节补充：

重点在于构建batch时，对局部batch内进行长度统一化，在dateset2loader函数里有细节，而且batch尽量大，但不能过大，类似我这1024，训练时间短，效果也不错，学习率1e-3即可，大概在epoch20多轮便有很好结果出现了

 

 


                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/546566
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号