天池学习赛-NLP新闻文本分类（5/6）-Word2Vec+TextCNN模型

这是一份还没完成的作品。后面再补上~

Word2Vec

两个算法：

Skip-grams (SG)：预测上下文

Continuous Bag of Words (CBOW)：预测目标单词

两种稍微高效一些的训练方法：

Hierarchical softmax

Negative sampling
ps:时间已经来不及了，[详细介绍]及[代码讲解]以后补上。
这次主要来讲一下TextCNN。

TextCNN[先上一波理论]

然后是[代码部分]，小白的我表示看不懂，只能一行一行的去看，补充了注释和相关知识，在时间限时内表示没看完，就先放上看完的部分的理解了。

1.把数据划分为10折，每一折的类别分布与原数据分布相同

# split data to 10 fold
fold_num = 10
data_file = r'E:\jupyter_lab\TianChi\News_classifier\data\train\train_set.csv'
import pandas as pd


def all_data2fold(fold_num, num=10000):
fold_data = []
f = pd.read_csv(data_file, sep='\t', encoding='UTF-8')
texts = f['text'].tolist()[:num] #只取前10000条数据 原来是的shape（200000,2）
labels = f['label'].tolist()[:num] #texts，lables都变成了list，里面有10000个元素

total = len(labels) #总的数据量 与num相等

index = list(range(total))
np.random.shuffle(index) #打乱这个包含索引的list

all_texts = []
all_labels = []
for i in index: #在这个索引list里 
all_texts.append(texts[i])
all_labels.append(labels[i]) #用这些打乱的索引，去取原来的texts 和 labels 里的值，此时他们也相应变成了all_texts ,all_labels

label2id = {} #给这个label—id建立一个字典 ，key是label，value是一个列表，元素是label在 all_labels中的位置索引
for i in range(total):
label = str(all_labels[i])
if label not in label2id:
label2id[label] = [i]
else:
label2id[label].append(i) #同一个label会出现多条，所以他在all_labels中有多个索引位置

all_index = [[] for _ in range(fold_num)]#根据fold_num，建立相等长度的列表，目前列表里的元素为空。即all_index是一个长度为fold_num的list，元素目前为空。
for label, data in label2id.items(): #在label-id这个字典里，data存的是label在all_labels中的位置索引，然后，每一个label每一个label的去循环
# print(label, len(data)) 
batch_size = int(len(data) / fold_num) #len(data)某个label出现的次数。将每个label出现的总次数 分成fold_num份，每一份batch_size个数据
other = len(data) - batch_size * fold_num # 不能整除的剩下的数据，此处的other一定小于fold_num
for i in range(fold_num): #某一折中，我们记为i
cur_batch_size = batch_size + 1 if i < other else batch_size #如果i小于剩下的数据个数，batch_size就增加1，把剩下的数据依次加进每一份里
# print(cur_batch_size) #每个label 分成fold_num份后，每一份目前的数据量
batch_data = [data[i * batch_size + b] for b in range(cur_batch_size)]
#取出当前的数据，data里是label的索引位置。 i * batch_size用来跳过以前的batch_size，跳到现在这一折的位置
all_index[i].extend(batch_data)#添加到all_index的相应位置中 
#all_index数据形式：[[],[],...[]]-->[[label_1_1折 expand label_2_1折 expand label_3_1折...expand label_19_1折 ],[label_1_2折 expand label_2_1折...],...[label_1_n折 expand ...]]

#这样在每一折中都保证了，label的分布同原始数据一致

batch_size = int(total / fold_num) #总的数据量分成fold_num份，每一份大小为batch_size
other_texts = []
other_labels = []
other_num = 0
start = 0
for fold in range(fold_num):
num = len(all_index[fold]) #num每一折的数据量
texts = [all_texts[i] for i in all_index[fold]] #all_texts是打乱后的text数据， all_index[fold]代表第fold折的数据
labels = [all_labels[i] for i in all_index[fold]] 
'''
以fold=0为例， all_index[0]=[label_1_1折 expand label_2_1折 expand label_3_1折...expand label_19_1折 ]
其中，label_1_1折 代表label——1划分到1折中的数据，数据的内容是label-1在原始数据中的索引位置 data[i * batch_size + b]
所以，all_index[0] 代表是是，各个label划分到1折中的数据，数据内容是每个label在原始数据中的索引位置

然后，利用这些索引位置，在all_texts和all_labels中取到真正的数据

'''
if num > batch_size: #如果这一折的数量>batch_size
fold_texts = texts[:batch_size] #取前batch_size个数据
other_texts.extend(texts[batch_size:]) #之后的数据放到 other_texts中
fold_labels = labels[:batch_size]
other_labels.extend(labels[batch_size:]) #label也这样操作
other_num += num - batch_size #统计每一折中在batch_size中放不开的数据总量
elif num < batch_size:#如果这一折的数量<batch_size
end = start + batch_size - num # batch_size比num多的数据量
fold_texts = texts + other_texts[start: end] # 从others_texts里补上
fold_labels = labels + other_labels[start: end]
start = end #移动在others_texts中的start位置
else:
fold_texts = texts
fold_labels = labels

assert batch_size == len(fold_labels) #assert函数主要是用来声明某个函数是真的，当assert()语句失败的时候，就会引发assertError
#这里 将batch_size的大小与每一折的大小弄成一样的 数据存到fold_texts和fold_labels里

# shuffle
index = list(range(batch_size))
np.random.shuffle(index) #打乱batch_size

shuffle_fold_texts = []
shuffle_fold_labels = []
for i in index:
shuffle_fold_texts.append(fold_texts[i])
shuffle_fold_labels.append(fold_labels[i]) #打乱索引再去取值 fold_texts和fold_labels 变成了 shuffle_fold_texts和shuffle_fold_labels

data = {'label': shuffle_fold_labels, 'text': shuffle_fold_texts} #一折中的数据
fold_data.append(data) #每一折的数据现在变成了上面的data字典，然后加入到fold_data列表中。

logging.info("Fold lens %s", str([len(data['label']) for data in fold_data])) #打印每一折数据的大小

return fold_data

fold_data = all_data2fold(10)

2.利用返回的fold_data数据，划分训练集、验证集、测试集

# build train, dev, test data
fold_id = 9

# dev
dev_data = fold_data[fold_id] # 验证集dev_data取第10折

# train
train_texts = []
train_labels = []
for i in range(0, fold_id):
data = fold_data[i]
train_texts.extend(data['text'])
train_labels.extend(data['label']) #train取前9折数据

train_data = {'label': train_labels, 'text': train_texts}

# test
test_data_file = '../data/test_a.csv'
f = pd.read_csv(test_data_file, sep='\t', encoding='UTF-8')
texts = f['text'].tolist()
test_data = {'label': [0] * len(texts), 'text': texts}

 

补充知识：Counter的用法

from collections import Counter
C = Counter() #{word:count}
data = '1 2 3 4 5 1 2 3 4 1 2 3 1 2 1'
for text in data:
words = text.split()
for word in words:
C[word] += 1
C
#Counter{[('1', 5), ('2', 4), ('3', 3), ('4', 2), ('5', 1)]}

C.most_common()
#[('1', 5), ('2', 4), ('3', 3), ('4', 2), ('5', 1)]
len(C)
#5
C['1']
#5

3.构建vocab类

它有几个方法：

（1）def build_vocab(self, data)

   构建了：

       self._id2word 这个list，元素是word ，具体来讲是data['text']中词频大于min_count的词

　　　 self._id2label 这个list，元素是label，具体来讲是data['label']中label的集合，所谓集合即去重了，len（_id2label）=19
　　　 self.target_names 这个list，元素是label的名字

（2）def load_pretrained_embs(self, embfile)

        return embeddings #返回预训练的词向量矩阵

（3）def word2id(self, xs):

 

      return self._word2id.get(xs, self.unk) #word2id得到的是 xs这个list里的词的编号

（4）def extword2id(self, xs):

　　return self._extword2id.get(xs, self.unk) #extword2id得到的是 xs这个list里的元素的编号

（5）def label2id(self, xs):

return self._label2id.get(xs, self.unk) #label2id得到label的编号

它还有几个属性
word_size，extword_size，label_size

# build vocab
from collections import Counter
from transformers import BasicTokenizer

basic_tokenizer = BasicTokenizer()#目前没用到


class Vocab():
def __init__(self, train_data):
self.min_count = 5
self.pad = 0
self.unk = 1
self._id2word = ['[PAD]', '[UNK]']
self._id2extword = ['[PAD]', '[UNK]']

self._id2label = []
self.target_names = []

self.build_vocab(train_data)

reverse = lambda x: dict(zip(x, range(len(x)))) #给x编号，0-(len(x)-1)
self._word2id = reverse(self._id2word)
self._label2id = reverse(self._id2label)

logging.info("Build vocab: words %d, labels %d." % (self.word_size, self.label_size))

def build_vocab(self, data):
self.word_counter = Counter() #{word:count}

for text in data['text']:
words = text.split()
for word in words:
self.word_counter[word] += 1 #统计每个词出现的频数

for word, count in self.word_counter.most_common(): # most_common()返回的是统计的列表，元素是元组，（‘词’：频数）
if count >= self.min_count: #频数大于阈值
self._id2word.append(word) # 将word添加到这个 list 中 self._id2word = ['[PAD]', '[UNK]']

label2name = {0: '科技', 1: '股票', 2: '体育', 3: '娱乐', 4: '时政', 5: '社会', 6: '教育', 7: '财经',
8: '家居', 9: '游戏', 10: '房产', 11: '时尚', 12: '彩票', 13: '星座'}

self.label_counter = Counter(data['label']) #每个label出现的次数

for label in range(len(self.label_counter)): # label的个数 19个，此处有个点就是：label正好也是0-18的赋值，与range(19)相同
count = self.label_counter[label] #各个label的频数 
self._id2label.append(label) # 将label加到这个list 中 self._id2label = [] 
self.target_names.append(label2name[label]) # self.target_names = []，label2name是上面的这个label字典，通过label能知道name。 

''' 
build_vocab方法
构建了： self._id2word 这个list，元素是word ，具体来讲是data['text']中词频大于min_count的词
　　　　 self._id2label 这个list，元素是label，具体来讲是data['label']中label的集合，所谓集合即去重了，len（_id2label）=19
　　　　 self.target_names 这个list，元素是label的名字

'''

def load_pretrained_embs(self, embfile): #加载预训练的词向量
with open(embfile, encoding='utf-8') as f:
lines = f.readlines()#readlines()方法读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素，但读取大文件会比较占内存。
items = lines[0].split() #embfile的第一行，lines[0]=[item[0],item[1]]， item[0]word_count(总的词数) item[1]词向量维度
word_count, embedding_dim = int(items[0]), int(items[1])

index = len(self._id2extword)# self._id2extword = ['[PAD]', '[UNK]'] 
'''现在还不知道干啥的， index是它的长度'''
embeddings = np.zeros((word_count + index, embedding_dim)) #创建一个空的矩阵，（预训练的总词量+_id2extword的词量，词向量的维度
for line in lines[1:]: #词向量文件里从第二行起 循环到最后
values = line.split() #values=[word_id,word_vector]
self._id2extword.append(values[0])
'''我猜测value[0]是word_id'''
vector = np.array(values[1:], dtype='float64') #value[1]是word_vector

embeddings[self.unk] += vector #self.unk = 1
'''embeddings[1]=embeddings[1]+values[1:] 把所有词的词向量都加起来？ 这是要干什么？'''
embeddings[index] = vector #embeddings[index] index是len(_id2extword),在embeddings矩阵的这个位置开始放预训练里的所有词的词向量
index += 1 #索引向前移动

embeddings[self.unk] = embeddings[self.unk] / word_count
'''把所有词的词向量都加起来除以总词数，看起来像求了个均值？'''
embeddings = embeddings / np.std(embeddings) 
'''这个embedding矩阵除以了它的标准差 这又是在干什么'''

reverse = lambda x: dict(zip(x, range(len(x)))) #erverse这个函数是给x赋个索引值，返回字典，key是x，value是x是索引或者说是编号，编号从0开始
self._extword2id = reverse(self._id2extword) #把_id2extword里面的东西编个号，
#_extword2id是一个字典，key是_id2extword里的值，value是他们的编号

assert len(set(self._id2extword)) == len(self._id2extword) #确定他们的长度相等，即_id2extword里的值不重复，每个值唯一

return embeddings #返回词向量矩阵
'''
embeddings[self.unk] = embeddings[self.unk] / word_count
'''把所有词的词向量都加起来除以总词数，看起来像求了个均值？'''
embeddings = embeddings / np.std(embeddings) 
'''这个embedding矩阵除以了它的标准差 这又是在干什么'''

embdding目前是这个形式

'''

def word2id(self, xs):
if isinstance(xs, list): #xs要是一个list
return [self._word2id.get(x, self.unk) for x in xs] #self._word2id = reverse(self._id2word)
#_word2id是一个字典，key是_id2word这里面的元素，value是它们的编号。
#在这个字典里找x，找知道x就返回x是value 也就是x的编号，找不到就返回self.unk=1 
return self._word2id.get(xs, self.unk)
#word2id得到的是 xs这个list里的词的编号

def extword2id(self, xs): 
if isinstance(xs, list): #xs要是一个list
return [self._extword2id.get(x, self.unk) for x in xs] #self._extword2id = reverse(self._id2extword)
# _extword2id是一个字典，key是_id2extword里的值，value是他们的编号
'''self._id2extword这个是干啥的？？'''
return self._extword2id.get(xs, self.unk)
#extword2id得到的是 xs这个list里的元素的编号

def label2id(self, xs):
if isinstance(xs, list):
return [self._label2id.get(x, self.unk) for x in xs] #self._label2id = reverse(self._id2label)
return self._label2id.get(xs, self.unk)
#label2id得到label的编号

@property
def word_size(self):
return len(self._id2word) #data['text']中词频大于min_count的总词数

@property
def extword_size(self):
return len(self._id2extword) #不知道干啥的

@property
def label_size(self):
return len(self._id2label) #类别数


vocab = Vocab(train_data)

补充知识

- [pytorch自定义层]
- [类的继承]
- [参数初始化1]，[参数初始化2]
- [outputs.masked_fill]
- [mm,bmm]
- [squeeze],[示例]
- [nn.Embedding]
- [requires_grad]
- [nn.Modulelist]
- [nn.Conv2d]，[资料2]

 

# build module
import torch.nn as nn
import torch.nn.functional as F


class Attention(nn.Module):
"""自己定义网络的层,要继承nn.Module"""

def __init__(self, hidden_size):
super().__init__() #继承nn.Module中的__init__()

'''声明一些Parameter类的实例（在__init__函数中）'''
self.weight = nn.Parameter(torch.Tensor(hidden_size, hidden_size)) #权重矩阵参数weight(hidden_size, hidden_size)
self.weight.data.normal_(mean=0.0, std=0.05)
#self.weight.data表示需要初始化的权重

self.bias = nn.Parameter(torch.Tensor(hidden_size)) #bias参数
b = np.zeros(hidden_size, dtype=np.float32) #b （hidden_size，）
self.bias.data.copy_(torch.from_numpy(b)) #跟b形状相同

self.query = nn.Parameter(torch.Tensor(hidden_size)) #query参数
self.query.data.normal_(mean=0.0, std=0.05)
def forward(self, batch_hidden, batch_masks):
# batch_hidden: b x len x hidden_size (2 * hidden_size of lstm)
# batch_masks: b x len

# linear
key = torch.matmul(batch_hidden, self.weight) + self.bias # key的维度：b x len x hidden

# compute attention
outputs = torch.matmul(key, self.query) #outputs的维度： b x len

masked_outputs = outputs.masked_fill((1 - batch_masks).bool(), float(-1e32))
#masked_fill_(mask, value) 用value填充tensor中与mask中值为1位置相对应的元素。
'''batch_masks=0,(1 - batch_masks)=1 .bool()为真，然后去填float(-1e32)???'''

attn_scores = F.softmax(masked_outputs, dim=1) #attn_scores的维度： b x len

# 对于全零向量，-1e32的结果为 1/len, -inf为nan, 额外补0
'''???上面这句什么意思？'''
masked_attn_scores = attn_scores.masked_fill((1 - batch_masks).bool(), 0.0) #b x len

# sum weighted sources
batch_outputs = torch.bmm(masked_attn_scores.unsqueeze(1), key).squeeze(1) # b x hidden
#顾名思义, 就是两个batch矩阵乘法.
'''
a.unsqueeze(N)：在a中指定位置N加上一个维数为1的维度。 
masked_attn_scores:b x 1 x len ; key:b x len x hidden = b x 1 x hidden
.squeeze(1),去掉维数为1的维度，

返回值：
batch_outputs：b x hidden
attn_scores ：b x len

'''

return batch_outputs, attn_scores


# build word encoder
word2vec_path = '../emb/word2vec.txt'
dropout = 0.15


class WordCNNEncoder(nn.Module):
def __init__(self, vocab):
super().__init__()
self.dropout = nn.Dropout(dropout)
self.word_dims = 100

self.word_embed = nn.Embedding(vocab.word_size, self.word_dims, padding_idx=0)
#word_embed embedding层

extword_embed = vocab.load_pretrained_embs(word2vec_path) #vocab是上面定义的类
'''extword_embed 是加载的预训练的词向量'''
extword_size, word_dims = extword_embed.shape
logging.info("Load extword embed: words %d, dims %d." % (extword_size, word_dims))

self.extword_embed = nn.Embedding(extword_size, word_dims, padding_idx=0)
#self.extword_embed embedding层
self.extword_embed.weight.data.copy_(torch.from_numpy(extword_embed))
#self.extword_embed 加载了预训练词向量的embedding层
self.extword_embed.weight.requires_grad = False #不训练

input_size = self.word_dims

self.filter_sizes = [2, 3, 4] # n-gram window
self.out_channel = 100
self.convs = nn.ModuleList([nn.Conv2d(1, self.out_channel, (filter_size, input_size), bias=True)
for filter_size in self.filter_sizes])
#创建3个卷积层，
'''
self.filter_sizes = [2, 3, 4] # n-gram window self.out_channel = 100

nn.Conv2d(1, self.out_channel, (filter_size, input_size), bias=True) 1个卷积核，输出100，卷积核大小（2,1），
nn.Conv2d(1, self.out_channel, (filter_size, input_size), bias=True) 1个卷积核，输出100，卷积核大小（3,1），
nn.Conv2d(1, self.out_channel, (filter_size, input_size), bias=True) 1个卷积核，输出100，卷积核大小（4,1），
'''
def forward(self, word_ids, extword_ids):
# word_ids: sen_num x sent_len
# extword_ids: sen_num x sent_len
# batch_masks: sen_num x sent_len
sen_num, sent_len = word_ids.shape

word_embed = self.word_embed(word_ids) # sen_num x sent_len x 100
#word_embed nn.Embedding 传入数据
extword_embed = self.extword_embed(extword_ids)
#extword_embed 加载了预训练词向量的embedding层
batch_embed = word_embed + extword_embed # sen_num x sent_len x 100

if self.training:
batch_embed = self.dropout(batch_embed)

batch_embed.unsqueeze_(1) # sen_num x 1 x sent_len x 100

pooled_outputs = []
for i in range(len(self.filter_sizes)):
filter_height = sent_len - self.filter_sizes[i] + 1
conv = self.convs[i](batch_embed)
hidden = F.relu(conv) # sen_num x out_channel x filter_height x 1

mp = nn.MaxPool2d((filter_height, 1)) # (filter_height, filter_width)
pooled = mp(hidden).reshape(sen_num,
self.out_channel) # sen_num x out_channel x 1 x 1 -> sen_num x out_channel

pooled_outputs.append(pooled)

reps = torch.cat(pooled_outputs, dim=1) # sen_num x total_out_channel

if self.training:
reps = self.dropout(reps)

return reps


# build sent encoder
sent_hidden_size = 256
sent_num_layers = 2


class SentEncoder(nn.Module):
def __init__(self, sent_rep_size):
super(SentEncoder, self).__init__()
self.dropout = nn.Dropout(dropout)

self.sent_lstm = nn.LSTM(
input_size=sent_rep_size,
hidden_size=sent_hidden_size,
num_layers=sent_num_layers,
batch_first=True,
bidirectional=True
)

def forward(self, sent_reps, sent_masks):
# sent_reps: b x doc_len x sent_rep_size
# sent_masks: b x doc_len

sent_hiddens, _ = self.sent_lstm(sent_reps) # b x doc_len x hidden*2
sent_hiddens = sent_hiddens * sent_masks.unsqueeze(2)

if self.training:
sent_hiddens = self.dropout(sent_hiddens)

return sent_hiddens

 

这部分还没看完只看完了attention层，但是里面的mask和quary也不是很懂原理。WordCNNEncoder和SentEncoder就更不懂是干啥的了，先写到这，后面再来补上。