循环神经网络和自然语言处理介绍
目标
知道token和tokenization知道N-gram的概念和作用知道文本向量化表示的方法1. 文本的tokenization
1.1 概念和工具的介绍
tokenization就是通常所说的分词，分出的每一个词语我们把它称为token。
常见的分词工具很多，比如：
jieba分词：/fxsjy/jieba清华大学的分词工具THULAC：/thunlp/THULAC-Python
1.2 中英文分词的方法
把句子转化为词语 比如：我爱深度学习可以分为[我，爱， 深度学习]把句子转化为单个字 比如：我爱深度学习的token是[我，爱，深，度，学，习]2.N-garm表示方法
前面我们说，句子可以用单个字，词来表示，但是有的时候，我们可以用2个、3个或者多个词来表示。
N-gram一组一组的词语，其中的N表示能够被一起使用的词的数量
例如：
In [59]: text = "深度学习（英语：deep learning）是机器学习的分支，是一种以人工神经网络为架构，对数据进行表征学习的算法。"In [60]: cuted = jieba.lcut(text)In [61]: [cuted[i:i+2] for i in range(len(cuted)-1)] #N-gram 中n=2时Out[61]:[['深度', '学习'],['学习', '（'],['（', '英语'],['英语', '：'],['：', 'deep'],['deep', ' '],[' ', 'learning'],['learning', '）'],['）', '是'],['是', '机器'],['机器', '学习'],['学习', '的'],['的', '分支'],['分支', '，'],['，', '是'],['是', '一种'],['一种', '以'],['以', '人工神经网络'],['人工神经网络', '为'],['为', '架构'],['架构', '，'],['，', '对'],['对', '数据'],['数据', '进行'],['进行', '表征'],['表征', '学习'],['学习', '的'],['的', '算法'],['算法', '。']]
在传统的机器学习中，使用N-gram方法往往能够取得非常好的效果，但是在深度学习比如RNN中会自带N-gram的效果。
3. 向量化
因为文本不能够直接被模型计算，所以需要将其转化为向量
把文本转化为向量有两种方法：
转化为one-hot编码转化为word embedding
3.1 one-hot 编码
在one-hot编码中，每一个token使用一个长度为N的向量表示，N表示词典的数量
即：把待处理的文档进行分词或者是N-gram处理，然后进行去重得到词典，假设我们有一个文档：深度学习，那么进行one-hot处理后的结果如下：
3.2 word embedding
word embedding是深度学习中表示文本常用的一种方法。和one-hot编码不同，word embedding使用了浮点型的稠密矩阵来表示token。根据词典的大小，我们的向量通常使用不同的维度，例如100,256,300等。其中向量中的每一个值是一个参数，其初始值是随机生成的，之后会在训练的过程中进行学习而获得。
如果我们文本中有20000个词语，如果使用one-hot编码，那么我们会有20000*20000的矩阵，其中大多数的位置都为0，但是如果我们使用word embedding来表示的话，只需要20000* 维度，比如20000*300
形象的表示就是：
我们会把所有的文本转化为向量，把句子用向量来表示
但是在这中间，我们会先把token使用数字来表示，再把数字使用向量来表示。
即：token---> num ---->vector
3.3 word embedding API
torch.nn.Embedding(num_embeddings,embedding_dim)
参数介绍：
num_embeddings：词典的大小embedding_dim：embedding的维度
使用方法：
embedding = nn.Embedding(vocab_size,300) #实例化input_embeded = embedding(input) #进行embedding的操作
3.4 数据的形状变化
思考：每个batch中的每个句子有10个词语，经过形状为[20，4]的Word emebedding之后，原来的句子会变成什么形状？
每个词语用长度为4的向量表示，所以，最终句子会变为[batch_size,10,4]的形状。
增加了一个维度，这个维度是embedding的dim
文本情感分类
目标
知道文本处理的基本方法能够使用数据实现情感分类的1. 案例介绍
为了对前面的word embedding这种常用的文本向量化的方法进行巩固，这里我们会完成一个文本情感分类的案例
现在我们有一个经典的数据集IMDB数据集，地址：http://ai.stanford.edu/~amaas/data/sentiment/，这是一份包含了5万条流行电影的评论数据，其中训练集25000条，测试集25000条。数据格式如下：
下图左边为名称，其中名称包含两部分，分别是序号和情感评分，（1-4为neg，5-10为pos），右边为评论内容
根据上述的样本，需要使用pytorch完成模型，实现对评论情感进行预测
2. 思路分析
首先可以把上述问题定义为分类问题，情感评分分为1-10，10个类别（也可以理解为回归问题，这里当做分类问题考虑）。那么根据之前的经验，我们的大致流程如下：
准备数据集构建模型模型训练模型评估
知道思路之后，那么我们一步步来完成上述步骤
3. 准备数据集
准备数据集和之前的方法一样，实例化dataset，准备dataloader，最终我们的数据可以处理成如下格式：
其中有两点需要注意：
如何完成基础打Dataset的构建和Dataloader的准备每个batch中文本的长度不一致的问题如何解决每个batch中的文本如何转化为数字序列
3.1 基础Dataset的准备
import torchfrom torch.utils.data import DataLoader,Datasetimport osimport redata_base_path = r"data\aclImdb"#1. 定义tokenize的方法def tokenize(text):# fileters = '!"#$%&()*+,-./:;<=>?@[\\]^_`{|}~\t\n'fileters = ['!','"','#','$','%','&','\(','\)','\*','\+',',','-','\.','/',':',';','<','=','>','\?','@','\[','\\','\]','^','_','`','\{','\|','\}','~','\t','\n','\x97','\x96','”','“',]text = re.sub("<.*?>"," ",text,flags=re.S)text = re.sub("|".join(fileters)," ",text,flags=re.S)return [i.strip() for i in text.split()]#2. 准备datasetclass ImdbDataset(Dataset):def __init__(self,mode):super(ImdbDataset,self).__init__()if mode=="train":text_path = [os.path.join(data_base_path,i) for i in ["train/neg","train/pos"]]else:text_path = [os.path.join(data_base_path,i) for i in ["test/neg","test/pos"]]self.total_file_path_list = []for i in text_path:self.total_file_path_list.extend([os.path.join(i,j) for j in os.listdir(i)])def __getitem__(self, idx):cur_path = self.total_file_path_list[idx]cur_filename = os.path.basename(cur_path)label = int(cur_filename.split("_")[-1].split(".")[0]) -1 #处理标题，获取label，转化为从[0-9]text = tokenize(open(cur_path).read().strip()) #直接按照空格进行分词return label,textdef __len__(self):return len(self.total_file_path_list)# 2. 实例化，准备dataloaderdataset = ImdbDataset(mode="train")dataloader = DataLoader(dataset=dataset,batch_size=2,shuffle=True)#3. 观察数据输出结果for idx,(label,text) in enumerate(dataloader):print("idx：",idx)print("table:",label)print("text:",text)break
输出如下：
idx： 0table: tensor([3, 1])text: [('I', 'Want'), ('thought', 'a'), ('this', 'great'), ('was', 'recipe'), ('a', 'for'), ('great', 'failure'), ('idea', 'Take'), ('but', 'a'), ('boy', 's'), ('was', 'y'), ('it', 'plot'), ('poorly', 'add'), ('executed', 'in'), ('We', 'some'), ('do', 'weak'), ('get', 'completely'), ('a', 'undeveloped'), ('broad', 'characters'), ('sense', 'and'), ('of', 'than'), ('how', 'throw'), ('complex', 'in'), ('and', 'the'), ('challenging', 'worst'), ('the', 'special'), ('backstage', 'effects'), ('operations', 'a'), ('of', 'horror'), ('a', 'movie'), ('show', 'has'), ('are', 'known'), ('but', 'Let'), ('virtually', 'stew'), ('no', 'for'), ...('show', 'somehow'), ('rather', 'destroy'), ('than', 'every'), ('anything', 'copy'), ('worth', 'of'), ('watching', 'this'), ('for', 'film'), ('its', 'so'), ('own', 'it'), ('merit', 'will')]
明显，其中的text内容出现对应，和想象的不太相似，出现问题的原因在于Dataloader中的参数collate_fn
collate_fn的默认值为torch自定义的default_collate,collate_fn的作用就是对每个batch进行处理，而默认的default_collate处理出错。
解决问题的思路：
手段1：考虑先把数据转化为数字序列，观察其结果是否符合要求，之前使用DataLoader并未出现类似错误
手段2：考虑自定义一个collate_fn，观察结果
这里使用方式2，自定义一个collate_fn,然后观察结果：
def collate_fn(batch):#batch是list，其中是一个一个元组，每个元组是dataset中__getitem__的结果batch = list(zip(*batch))labes = torch.tensor(batch[0],dtype=torch.int32)texts = batch[1]del batchreturn labes,textsdataloader = DataLoader(dataset=dataset,batch_size=2,shuffle=True,collate_fn=collate_fn)#此时输出正常for idx,(label,text) in enumerate(dataloader):print("idx：",idx)print("table:",label)print("text:",text)break
3.2 文本序列化
再介绍word embedding的时候，我们说过，不会直接把文本转化为向量，而是先转化为数字，再把数字转化为向量，那么这个过程该如何实现呢？
这里我们可以考虑把文本中的每个词语和其对应的数字，使用字典保存，同时实现方法把句子通过字典映射为包含数字的列表。
实现文本序列化之前，考虑以下几点:
如何使用字典把词语和数字进行对应不同的词语出现的次数不尽相同，是否需要对高频或者低频词语进行过滤，以及总的词语数量是否需要进行限制得到词典之后，如何把句子转化为数字序列，如何把数字序列转化为句子不同句子长度不相同，每个batch的句子如何构造成相同的长度（可以对短句子进行填充，填充特殊字符）对于新出现的词语在词典中没有出现怎么办（可以使用特殊字符代理）
思路分析：
对所有句子进行分词词语存入字典，根据次数对词语进行过滤，并统计次数实现文本转数字序列的方法实现数字序列转文本方法
import numpy as npclass Word2Sequence():UNK_TAG = "UNK"PAD_TAG = "PAD"UNK = 0PAD = 1def __init__(self):self.dict = {self.UNK_TAG :self.UNK,self.PAD_TAG :self.PAD}self.fited = Falsedef to_index(self,word):"""word -> index"""assert self.fited == True,"必须先进行fit操作"return self.dict.get(word,self.UNK)def to_word(self,index):"""index -> word"""assert self.fited , "必须先进行fit操作"if index in self.inversed_dict:return self.inversed_dict[index]return self.UNK_TAGdef __len__(self):return self(self.dict)def fit(self, sentences, min_count=1, max_count=None, max_feature=None):""":param sentences:[[word1,word2,word3],[word1,word3,wordn..],...]:param min_count: 最小出现的次数:param max_count: 最大出现的次数:param max_feature: 总词语的最大数量:return:"""count = {}for sentence in sentences:for a in sentence:if a not in count:count[a] = 0count[a] += 1# 比最小的数量大和比最大的数量小的需要if min_count is not None:count = {k: v for k, v in count.items() if v >= min_count}if max_count is not None:count = {k: v for k, v in count.items() if v <= max_count}# 限制最大的数量if isinstance(max_feature, int):count = sorted(list(count.items()), key=lambda x: x[1])if max_feature is not None and len(count) > max_feature:count = count[-int(max_feature):]for w, _ in count:self.dict[w] = len(self.dict)else:for w in sorted(count.keys()):self.dict[w] = len(self.dict)self.fited = True# 准备一个index->word的字典self.inversed_dict = dict(zip(self.dict.values(), self.dict.keys()))def transform(self, sentence,max_len=None):"""实现吧句子转化为数组（向量）:param sentence::param max_len::return:"""assert self.fited, "必须先进行fit操作"if max_len is not None:r = [self.PAD]*max_lenelse:r = [self.PAD]*len(sentence)if max_len is not None and len(sentence)>max_len:sentence=sentence[:max_len]for index,word in enumerate(sentence):r[index] = self.to_index(word)return np.array(r,dtype=np.int64)def inverse_transform(self,indices):"""实现从数组 转化为文字:param indices: [1,2,3....]:return:[word1,word2.....]"""sentence = []for i in indices:word = self.to_word(i)sentence.append(word)return sentenceif __name__ == '__main__':w2s = Word2Sequence()w2s.fit([["你", "好", "么"],["你", "好", "哦"]])print(w2s.dict)print(w2s.fited)print(w2s.transform(["你","好","嘛"]))print(w2s.transform(["你好嘛"],max_len=10))
完成了wordsequence之后，接下来就是保存现有样本中的数据字典，方便后续的使用。
实现对IMDB数据的处理和保存
#1. 对IMDB的数据记性fit操作def fit_save_word_sequence():from wordSequence import Word2Sequencews = Word2Sequence()train_path = [os.path.join(data_base_path,i) for i in ["train/neg","train/pos"]]total_file_path_list = []for i in train_path:total_file_path_list.extend([os.path.join(i, j) for j in os.listdir(i)])for cur_path in tqdm(total_file_path_list,ascii=True,desc="fitting"):ws.fit(tokenize(open(cur_path).read().strip()))ws.build_vocab()# 对wordSequesnce进行保存pickle.dump(ws,open("./model/ws.pkl","wb"))#2. 在dataset中使用wordsequencews = pickle.load(open("./model/ws.pkl","rb"))def collate_fn(batch):MAX_LEN = 500 #MAX_LEN = max([len(i) for i in texts]) #取当前batch的最大值作为batch的最大长度batch = list(zip(*batch))labes = torch.tensor(batch[0],dtype=torch.int)texts = batch[1]#获取每个文本的长度lengths = [len(i) if len(i)<MAX_LEN else MAX_LEN for i in texts]texts = torch.tensor([ws.transform(i, MAX_LEN) for i in texts])del batchreturn labes,texts,lengths#3. 获取输出dataset = ImdbDataset(ws,mode="train")dataloader = DataLoader(dataset=dataset,batch_size=20,shuffle=True,collate_fn=collate_fn)for idx,(label,text,length) in enumerate(dataloader):print("idx：",idx)print("table:",label)print("text:",text)print("length:",length)break
输出如下
idx： 0table: tensor([ 7, 4, 3, 8, 1, 10, 7, 10, 7, 2, 1, 8, 1, 2, 2, 4, 7, 10,1, 4], dtype=torch.int32)text: tensor([[ 50983, 77480, 82366, ...,1,1,1],[ 54702, 57262, 102035, ..., 80474, 56457, 63180],[ 26991, 57693, 88450, ...,1,1,1],...,[ 51138, 73263, 80428, ...,1,1,1],[ 7022, 78114, 83498, ...,1,1,1],[ 5353, 101803, 99148, ...,1,1,1]])length: [296, 500, 221, 132, 74, 407, 500, 130, 54, 217, 80, 322, 72, 156, 94, 270, 317, 117, 200, 379]
思考：前面我们自定义了MAX_LEN作为句子的最大长度，如果我们需要把每个batch中的最长的句子长度作为当前batch的最大长度，该如何实现？
4. 构建模型
这里我们只练习使用word embedding，所以模型只有一层，即：
数据经过word embedding数据通过全连接层返回结果，计算log_softmax
import torchimport torch.nn as nnimport torch.nn.functional as Ffrom torch import optimfrom build_dataset import get_dataloader,ws,MAX_LENclass IMDBModel(nn.Module):def __init__(self,max_len):super(IMDBModel,self).__init__()self.embedding = nn.Embedding(len(ws),300,padding_idx=ws.PAD) #[N,300]self.fc = nn.Linear(max_len*300,10) #[max_len*300,10]def forward(self, x):embed = self.embedding(x) #[batch_size,max_len,300]embed = embed.view(x.size(0),-1)out = self.fc(embed)return F.log_softmax(out,dim=-1)
5. 模型的训练和评估
训练流程和之前相同
实例化模型，损失函数，优化器遍历dataset_loader，梯度置为0，进行向前计算计算损失，反向传播优化损失，更新参数
train_batch_size = 128test_batch_size = 1000imdb_model = IMDBModel(MAX_LEN)optimizer = optim.Adam(imdb_model.parameters())criterion = nn.CrossEntropyLoss()def train(epoch):mode = Trueimdb_model.train(mode)train_dataloader =get_dataloader(mode,train_batch_size)for idx,(target,input,input_lenght) in enumerate(train_dataloader):optimizer.zero_grad()output = imdb_model(input)loss = F.nll_loss(output,target) #traget需要是[0,9]，不能是[1-10]loss.backward()optimizer.step()if idx %10 == 0:print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(epoch, idx * len(input), len(train_dataloader.dataset),100. * idx / len(train_dataloader), loss.item()))torch.save(imdb_model.state_dict(), "model/mnist_net.pkl")torch.save(optimizer.state_dict(), 'model/mnist_optimizer.pkl')def test():test_loss = 0correct = 0mode = Falseimdb_model.eval()test_dataloader = get_dataloader(mode, test_batch_size)with torch.no_grad():for target, input, input_lenght in test_dataloader:output = imdb_model(input)test_loss += F.nll_loss(output, target,reduction="sum")pred = torch.max(output,dim=-1,keepdim=False)[-1]correct = pred.eq(target.data).sum()test_loss = test_loss/len(test_dataloader.dataset)print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(test_loss, correct, len(test_dataloader.dataset),100. * correct / len(test_dataloader.dataset)))if __name__ == '__main__':test()for i in range(3):train(i)test()
这里我们仅仅使用了一层全连接层，其分类效果不会很好，这里重点是理解常见的模型流程和word embedding的使用方法
