准备数据

imdb数据集的目标是根据电影评论的文本内容预测评论的情感标签。
训练集有20000条电影评论文本，测试集有5000条电影评论文本，其中正面评论和负面评论都各占一半。
image.png
文本数据预处理较为繁琐，包括中文切词（本示例不涉及），构建词典，编码转换，序列填充，构建数据管道等等。
在torch中预处理文本数据一般使用torchtext或者自定义Dataset，torchtext功能非常强大，可以构建文本分类，序列标注，问答模型，机器翻译等NLP任务的数据集。

torchtext常见API一览：

  • torchtext.data.Example : 用来表示一个样本，数据和标签
  • torchtext.vocab.Vocab: 词汇表，可以导入一些预训练词向量
  • torchtext.data.Datasets: 数据集类，getitem返回 Example实例, torchtext.data.TabularDataset是其子类。
  • torchtext.data.Field : 用来定义字段的处理方法（文本字段，标签字段）创建 Example时的 预处理，batch 时的一些处理操作。
  • torchtext.data.Iterator: 迭代器，用来生成 batch
  • torchtext.datasets: 包含了常见的数据集
  1. import numpy as np 
  2. import pandas as pd 
  3. from collections import OrderedDict
  4. import re,string
  5. MAX_WORDS = 10000  # 仅考虑最高频的10000个词
  6. MAX_LEN = 200  # 每个样本保留200个词的长度
  7. BATCH_SIZE = 20 
  8. train_data_path = '../data/imdb/train.tsv'
  9. test_data_path = '../data/imdb/test.tsv'
  10. train_token_path = '../data/imdb/train_token.tsv'
  11. test_token_path =  '../data/imdb/test_token.tsv'
  12. train_samples_path = '../data/imdb/train_samples/'
  13. test_samples_path =  '../data/imdb/test_samples/'

首先我们构建词典，并保留最高频的MAX_WORDS个词。

  1. ##构建词典
  3. word_count_dict = {}
  5. #清洗文本
  6. def clean_text(text):
  7.     lowercase = text.lower().replace("\n"," ")
  8.     stripped_html = re.sub('<br />', ' ',lowercase)
  9.     cleaned_punctuation = re.sub('[%s]'%re.escape(string.punctuation),'',stripped_html)
  10.     return cleaned_punctuation
  12. with open(train_data_path,"r",encoding = 'utf-8') as f:
  13.     for line in f:
  14.         label,text = line.split("\t")
  15.         cleaned_text = clean_text(text)
  16.         for word in cleaned_text.split(" "):
  17.             word_count_dict[word] = word_count_dict.get(word,0)+1 
  19. df_word_dict = pd.DataFrame(pd.Series(word_count_dict,name = "count"))
  20. df_word_dict = df_word_dict.sort_values(by = "count",ascending =False)
  22. df_word_dict = df_word_dict[0:MAX_WORDS-2] #  
  23. df_word_dict["word_id"] = range(2,MAX_WORDS) #编号0和1分别留给未知词<unkown>和填充<padding>
  25. word_id_dict = df_word_dict["word_id"].to_dict()
  27. df_word_dict.head(10)

image.png

然后我们利用构建好的词典，将文本转换成token序号。

  1. #转换token
  3. # 填充文本
  4. def pad(data_list,pad_length):
  5.     padded_list = data_list.copy()
  6.     if len(data_list)> pad_length:
  7.          padded_list = data_list[-pad_length:]
  8.     if len(data_list)< pad_length:
  9.          padded_list = [1]*(pad_length-len(data_list))+data_list
  10.     return padded_list
  12. def text_to_token(text_file,token_file):
  13.     with open(text_file,"r",encoding = 'utf-8') as fin,\
  14.       open(token_file,"w",encoding = 'utf-8') as fout:
  15.         for line in fin:
  16.             label,text = line.split("\t")
  17.             cleaned_text = clean_text(text)
  18.             word_token_list = [word_id_dict.get(word, 0) for word in cleaned_text.split(" ")]
  19.             pad_list = pad(word_token_list,MAX_LEN)
  20.             out_line = label+"\t"+" ".join([str(x) for x in pad_list])
  21.             fout.write(out_line+"\n")
  23. text_to_token(train_data_path,train_token_path)
  24. text_to_token(test_data_path,test_token_path)

接着将token文本按照样本分割，每个文件存放一个样本的数据。

  1. # 分割样本
  2. import os
  4. if not os.path.exists(train_samples_path):
  5.     os.mkdir(train_samples_path)
  7. if not os.path.exists(test_samples_path):
  8.     os.mkdir(test_samples_path)
  11. def split_samples(token_path,samples_dir):
  12.     with open(token_path,"r",encoding = 'utf-8') as fin:
  13.         i = 0
  14.         for line in fin:
  15.             with open(samples_dir+"%d.txt"%i,"w",encoding = "utf-8") as fout:
  16.                 fout.write(line)
  17.             i = i+1
  19. split_samples(train_token_path,train_samples_path)
  20. split_samples(test_token_path,test_samples_path)
  1. print(os.listdir(train_samples_path)[0:100])

image.png

一切准备就绪，我们可以创建数据集Dataset, 从文件名称列表中读取文件内容了。

  1. import os
  2. from torch.utils.data import Dataset,DataLoader 
  3. class imdbDataset(Dataset):
  4.     def __init__(self,samples_dir):
  5.         self.samples_dir = samples_dir
  6.         self.samples_paths = os.listdir(samples_dir)
  8.     def __len__(self):
  9.         return len(self.samples_paths)
  11.     def __getitem__(self,index):
  12.         path = self.samples_dir + self.samples_paths[index]
  13.         with open(path,"r",encoding = "utf-8") as f:
  14.             line = f.readline()
  15.             label,tokens = line.split("\t")
  16.             label = torch.tensor([float(label)],dtype = torch.float)
  17.             feature = torch.tensor([int(x) for x in tokens.split(" ")],dtype = torch.long)
  18.             return  (feature,label)
  1. ds_train = imdbDataset(train_samples_path)
  2. ds_test = imdbDataset(test_samples_path)
  4. print(len(ds_train))
  5. print(len(ds_test))
  7. dl_train = DataLoader(ds_train,batch_size = BATCH_SIZE,shuffle = True,num_workers=0)
  8. dl_test = DataLoader(ds_test,batch_size = BATCH_SIZE,num_workers=0)
  10. for features,labels in dl_train:
  11.     print(features)
  12.     print(labels)
  13.     break

image.png

定义模型

使用Pytorch通常有三种方式构建模型：

  1. 使用nn.Sequential按层顺序构建模型；
  2. 继承nn.Module基类构建自定义模型；
  3. 继承nn.Module基类构建模型并辅助应用模型容器(nn.Sequential,nn.ModuleList,nn.ModuleDict)进行封装。

此处选择使用第三种方式进行构建。由于接下来使用类形式的训练循环，我们将模型封装成torchkeras.Model类来获得类似Keras中高阶模型接口的功能。Model类实际上继承自nn.Module类。
MacBook torchkeras包没导入成功，后边没实现。
把torchkears.py文件放到/Users/huang/miniforge3/lib/python3.9/site-packages是可以正常导入了，但后边训练部分还是报错。
torchkeras.py

  1. import torch
  2. from torch import nn 
  3. import torchkeras
  1. torch.random.seed()
  2. import torch
  3. from torch import nn 
  5. class Net(torchkeras.Model):
  7.     def __init__(self):
  8.         super(Net, self).__init__()
  10.         #设置padding_idx参数后将在训练过程中将填充的token始终赋值为0向量
  11.         self.embedding = nn.Embedding(num_embeddings = MAX_WORDS,embedding_dim = 3,padding_idx = 1)
  12.         self.conv = nn.Sequential()
  13.         self.conv.add_module("conv_1",nn.Conv1d(in_channels = 3,out_channels = 16,kernel_size = 5))
  14.         self.conv.add_module("pool_1",nn.MaxPool1d(kernel_size = 2))
  15.         self.conv.add_module("relu_1",nn.ReLU())
  16.         self.conv.add_module("conv_2",nn.Conv1d(in_channels = 16,out_channels = 128,kernel_size = 2))
  17.         self.conv.add_module("pool_2",nn.MaxPool1d(kernel_size = 2))
  18.         self.conv.add_module("relu_2",nn.ReLU())
  20.         self.dense = nn.Sequential()
  21.         self.dense.add_module("flatten",nn.Flatten())
  22.         self.dense.add_module("linear",nn.Linear(6144,1))
  23.         self.dense.add_module("sigmoid",nn.Sigmoid())
  25.     def forward(self,x):
  26.         x = self.embedding(x).transpose(1,2)
  27.         x = self.conv(x)
  28.         y = self.dense(x)
  29.         return y
  32. model = Net()
  33. print(model)
  35. model.summary(input_shape = (200,),input_dtype = torch.LongTensor)

image.png

训练模型

训练Pytorch通常需要用户编写自定义训练循环，训练循环的代码风格因人而异。
有3类典型的训练循环代码风格：

  1. 脚本形式训练循环；
  2. 函数形式训练循环；
  3. 类形式训练循环。

此处介绍一种类形式的训练循环。
我们仿照Keras定义了一个高阶的模型接口Model,实现 fit, validate，predict, summary 方法，相当于用户自定义高阶API。

  1. # 准确率
  2. def accuracy(y_pred,y_true):
  3.     y_pred = torch.where(y_pred>0.5,torch.ones_like(y_pred,dtype = torch.float32),
  4.                       torch.zeros_like(y_pred,dtype = torch.float32))
  5.     acc = torch.mean(1-torch.abs(y_true-y_pred))
  6.     return acc
  8. model.compile(loss_func = nn.BCELoss(),optimizer= torch.optim.Adagrad(model.parameters(),lr = 0.02),
  9.              metrics_dict={"accuracy":accuracy})
  1. # 有时候模型训练过程中不收敛，需要多试几次
  2. dfhistory = model.fit(20,dl_train,dl_val=dl_test,log_step_freq= 200)

image.png

评估模型

  1. %matplotlib inline
  2. %config InlineBackend.figure_format = 'svg'
  4. import matplotlib.pyplot as plt
  6. def plot_metric(dfhistory, metric):
  7.     train_metrics = dfhistory[metric]
  8.     val_metrics = dfhistory['val_'+metric]
  9.     epochs = range(1, len(train_metrics) + 1)
  10.     plt.plot(epochs, train_metrics, 'bo--')
  11.     plt.plot(epochs, val_metrics, 'ro-')
  12.     plt.title('Training and validation '+ metric)
  13.     plt.xlabel("Epochs")
  14.     plt.ylabel(metric)
  15.     plt.legend(["train_"+metric, 'val_'+metric])
  16.     plt.show()
  18. plot_metric(dfhistory,"loss")

image.png

  1. plot_metric(dfhistory,"accuracy")

image.png

  1. # 评估
  2. model.evaluate(dl_test)

image.png

使用模型

  1. model.predict(dl_test)

image.png

保存模型

推荐使用保存参数方式保存Pytorch模型。

  1. print(model.state_dict().keys())

image.png

  1. # 保存模型参数
  3. torch.save(model.state_dict(), "./data/model_parameter.pkl")
  5. model_clone = Net()
  6. model_clone.load_state_dict(torch.load("./data/model_parameter.pkl"))
  8. model_clone.compile(loss_func = nn.BCELoss(),optimizer= torch.optim.Adagrad(model.parameters(),lr = 0.02),
  9.              metrics_dict={"accuracy":accuracy})
  11. # 评估模型
  12. model_clone.evaluate(dl_test)

image.png