1 赛题理解

2 数据分析

3 词向量+机器学习模型

4 Fasttext

5 Word2Vec+TextCNN模型

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

Word2Vec

两个算法：

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

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

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

Hierarchical softmax

Negative sampling

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

TextCNN

先上一波理论

image.png image.png

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

# 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)

# 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

image.png

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

# 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就更不懂是干啥的了，先写到这，后面再来补上。
下一节预告：bert