【深度学习】用Keras实现word2vec的CBOW模型

前言

  尽管gensim里的word2vec已经非常好用，但用别人的模型始终难以直接解决自己的问题，于是去搜有没有直接能用的Keras版，找到了两版，分别为：

• 版本1：keras训练word2vec代码
• 版本2：【不可思议的Word2Vec】6. Keras版的Word2Vec

  两位写的都很好，版本1代码上可以直接上手，版本2框架更清晰，但两位大佬的数据集都是基于多篇文章的，版本1是从微信接口里拿的，但我连接不上服务器；版本二的数据集未给，然后面向对象的写法本人不是很熟就不好改。于是就在学习版本框架理论的同时，在版本1上进行更改。
  最终形成在单个文本内进行词向量训练。

数据

  随便一个utf-8的中文文档就行，我这里为了求快，节选了《天龙八部》的第一章，记得改下编码utf-8。

停用词

  也是网上扒的停用词，据说非常全，最全中文停用词表整理（1893个）。

def stopwordslist(): #设置停用词
    stopwords = []
    if not os.path.exists('./stopwords.txt'):
        print('未发现停用词表！')
    else:
        stopwords = [line.strip() for line in open('stopwords.txt',encoding='UTF-8').readlines()]
    return stopwords

分词

   输入一个文档，输出全部原始句子和分好词的句子。

def getdata(fname):
    f = open(fname,'r',encoding='UTF-8')
    lines = f.readlines()
    sentences = []
    data = []
    stopwords = stopwordslist()
    for line in lines:
        data.append(line.strip()) #原始句子
        sts = list(jieba.cut(line.strip(), cut_all=False)) #分词后
        splits = [] #去停用词后
        for w in sts:
            if w not in stopwords:
                splits.append(w) 
        sentences.append(splits)
    f.close()
    return data,sentences

建字典

  需要非常多的映射关系，这里还有一个降采样表，后面有对其功能的解释。

def bulid_dic(sentences): #建立各种字典
    words = {} #词频表
    nb_sentence = 0 #总句子数
    total = 0. #总词频
    
    for d in sentences:
        nb_sentence += 1
        for w in d:
            if w not in words:
                words[w] = 0
            words[w] += 1
            total += 1
        if nb_sentence % 100 == 0:
            print (u'已经找到%s个句子'%nb_sentence)
    
    words = {i:j for i,j in words.items() if j >= min_count} #截断词频
    id2word = {i+1:j for i,j in enumerate(words)} #id到词语的映射，0表示UNK
    word2id = {j:i for i,j in id2word.items()} #词语到id的映射
    nb_word = len(words)+1 #总词数（算上填充符号0）
    
    subsamples = {i:j/total for i,j in words.items() if j/total > subsample_t}
    subsamples = {i:subsample_t/j+(subsample_t/j)**0.5 for i,j in subsamples.items()} #这个降采样公式，是按照word2vec的源码来的
    subsamples = {word2id[i]:j for i,j in subsamples.items() if j < 1.} #降采样表
    return nb_sentence,id2word,word2id,nb_word,subsamples

构造训练数据

  结合后文的框架图进行分析。

def data_generator(word2id,subsamples,data): #训练数据生成器
    x,y = [],[]
    _ = 0
    for d in data:
        d = [0]*window + [word2id[w] for w in d if w in word2id] + [0]*window
        r = np.random.random(len(d))
        for i in range(window, len(d)-window):
            if d[i] in subsamples and r[i] > subsamples[d[i]]: #满足降采样条件的直接跳过
                continue
            x.append(d[i-window:i]+d[i+1:i+1+window])
            y.append([d[i]])
        _ += 1
        if _ == nb_sentence_per_batch:
            x,y = np.array(x),np.array(y)
            z = np.zeros((len(x), 1))
            return [x,y],z

word2vec

  好了，终于到这步了。尽管这个东西出来挺久了，理论解释的人也一大把，但我在未完全自己跑一遍之前，仍是一知半解，似懂非懂，直到我遇到版本2的这一张图。

  原谅我孤陋寡闻，原来Keras模型结构还能可视化出来(点个赞，顺便一起实现了)。
  众所周知，CBOW是用某一个词的上下文(前面几个和后面几个)去预测它本身，但实现起来，word2vec绝不止这一点，其精华还在负(降)采样和层级softmax，两者都是为了加速而做的优化，我们来顺着这个图理解一下。
  先看下参数，我们的window设置为5，那么就是用前5个词和后5个词去预测当前词，所以模型的输入是上下文，也就是10个词，这就是右边的第一个input层。右边的Embedding层也好理解，词向量维度为128，那就成了10*128的张量。再看第一个lambda层，其做的是加法，将10个128维的词向量同一维度直接加在一起形成了一个128维的张量，至此右边完成。

   fname = 'corpus.txt' #数据集(语料库) 一个文档
   word_size = 128 #词向量维度
   window = 5 #窗口大小
   nb_negative = 15 #随机负采样的样本数
   min_count = 5 #频数少于min_count的词将会被抛弃
   nb_worker = 4 #读取数据的并发数
   nb_epoch = 2 #迭代次数，由于使用了adam，迭代次数1～2次效果就相当不错
   subsample_t = 1e-5 #词频大于subsample_t的词语，会被降采样，这是提高速度和词向量质量的有效方案
   nb_sentence_per_batch = 20
   #目前是以句子为单位作为batch，多少个句子作为一个batch（这样才容易估计训练过程中的steps参数，另外注意，样本数是正比于字数的。）

  再看左边，第二个输入层输入的就是当前词，也就是1个词。第二个lambda层做的是抽样，随机构造15个跟当前词不一样的词作为负样本，通过第三个lambda层拼接到一起。嵌入2次，分别得到W和b,也就是权重和偏置在第四个lambda层完成Dense（Wx+b）和Softmax的操作。
  最后一步也就是整个模型的输出就是softmax的值，其有16维实际上是模型预测当前词是正例(1个)和负例(抽样的15个)的概率值，这就做到了通过输入上下文来识别当前词，且识别范围(解空间)由原先的所有词，限制到了负采样个数+1内，这就大大地加快了训练速度。而我们所需要的词向量就是右边的Embeding层，也就是第一个嵌入层的权重。

   再对比下model搭建的代码，其实主要就是看每个Lambda层的作用。

def build_w2vm(word_size,window,nb_negative):
    K.clear_session() #清除之前的模型，省得压满内存
    #CBOW输入
    input_words = Input(shape=(window*2,), dtype='int32')
    input_vecs = Embedding(nb_word, word_size, name='word2vec')(input_words)
    input_vecs_sum = Lambda(lambda x: K.sum(x, axis=1))(input_vecs) #CBOW模型，直接将上下文词向量求和
    
    #构造随机负样本，与目标组成抽样
    target_word = Input(shape=(1,), dtype='int32')
    negatives = Lambda(lambda x: K.random_uniform((K.shape(x)[0], nb_negative), 0, nb_word, 'int32'))(target_word)
    samples = Lambda(lambda x: K.concatenate(x))([target_word,negatives]) #构造抽样，负样本随机抽。负样本也可能抽到正样本，但概率小。
    
    #只在抽样内做Dense和softmax
    softmax_weights = Embedding(nb_word, word_size, name='W')(samples)
    softmax_biases = Embedding(nb_word, 1, name='b')(samples)
    softmax = Lambda(lambda x: 
                        K.softmax((K.batch_dot(x[0], K.expand_dims(x[1],2))+x[2])[:,:,0])
                    )([softmax_weights,input_vecs_sum,softmax_biases]) #用Embedding层存参数，用K后端实现矩阵乘法，以此复现Dense层的功能
    
    #留意到，我们构造抽样时，把目标放在了第一位，也就是说，softmax的目标id总是0，这可以从data_generator中的z变量的写法可以看出
    
    model = Model(inputs=[input_words,target_word], outputs=softmax)
    model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    #请留意用的是sparse_categorical_crossentropy而不是categorical_crossentropy
    model.summary()
    return model

检验(计算TopK个相似度高的单词)

   载入模型，取词向量，再求余弦相似度（先归一化再点积）。

def most_similar(word2id,w,k=10): #找相似性Topk个词
    #通过词语相似度，检查我们的词向量是不是靠谱的
    model = load_model('./word2vec.h5') #载入模型 在数据集较大的时候用空间换时间
    # weights = model.get_weights()#可以顺便看看每层的权重
    # for wei in weights:
    #     print(wei.shape)
    embeddings = model.get_weights()[0]
    normalized_embeddings = embeddings / (embeddings**2).sum(axis=1).reshape((-1,1))**0.5 #词向量归一化，即将模定为1
    v = normalized_embeddings[word2id[w]]
    sims = np.dot(normalized_embeddings, v)
    sort = sims.argsort()[::-1]
    sort = sort[sort > 0]
    return [(id2word[i],sims[i]) for i in sort[:k]]

效果

  由于求快，数据集非常小，词不多，精度不算准，但能用，以下为输入“天龙八部”后结果。

完整代码

  需要一个数据文件(txt)，一个停用词表(txt)，还有一个代码文件(py)。

#! -*- coding:utf-8 -*-
#Keras版的Word2Vec，作者：苏剑林，http://kexue.fm
#Keras 2.0.6 ＋ Tensorflow 测试通过

import numpy as np
from keras.layers import Input,Embedding,Lambda
from keras.models import Model,load_model
from keras.utils import plot_model
import keras.backend as K
import jieba
import pandas as pd
import os


def stopwordslist(): #设置停用词
    stopwords = []
    if not os.path.exists('./stopwords.txt'):
        print('未发现停用词表！')
    else:
        stopwords = [line.strip() for line in open('stopwords.txt',encoding='UTF-8').readlines()]
    return stopwords

def getdata(fname):
    f = open(fname,'r',encoding='UTF-8')
    lines = f.readlines()
    sentences = []
    data = []
    stopwords = stopwordslist()
    for line in lines:
        data.append(line.strip()) #原始句子
        sts = list(jieba.cut(line.strip(), cut_all=False)) #分词后
        splits = [] #去停用词后
        for w in sts:
            if w not in stopwords:
                splits.append(w) 
        sentences.append(splits)
    f.close()
    return data,sentences

def bulid_dic(sentences): #建立各种字典
    words = {} #词频表
    nb_sentence = 0 #总句子数
    total = 0. #总词频
    
    for d in sentences:
        nb_sentence += 1
        for w in d:
            if w not in words:
                words[w] = 0
            words[w] += 1
            total += 1
        if nb_sentence % 100 == 0:
            print (u'已经找到%s个句子'%nb_sentence)
    
    words = {i:j for i,j in words.items() if j >= min_count} #截断词频
    id2word = {i+1:j for i,j in enumerate(words)} #id到词语的映射，0表示UNK
    word2id = {j:i for i,j in id2word.items()} #词语到id的映射
    nb_word = len(words)+1 #总词数（算上填充符号0）
    
    subsamples = {i:j/total for i,j in words.items() if j/total > subsample_t}
    subsamples = {i:subsample_t/j+(subsample_t/j)**0.5 for i,j in subsamples.items()} #这个降采样公式，是按照word2vec的源码来的
    subsamples = {word2id[i]:j for i,j in subsamples.items() if j < 1.} #降采样表
    return nb_sentence,id2word,word2id,nb_word,subsamples

def data_generator(word2id,subsamples,data): #训练数据生成器
    x,y = [],[]
    _ = 0
    for d in data:
        d = [0]*window + [word2id[w] for w in d if w in word2id] + [0]*window
        r = np.random.random(len(d))
        for i in range(window, len(d)-window):
            if d[i] in subsamples and r[i] > subsamples[d[i]]: #满足降采样条件的直接跳过
                continue
            x.append(d[i-window:i]+d[i+1:i+1+window])
            y.append([d[i]])
        _ += 1
        if _ == nb_sentence_per_batch:
            x,y = np.array(x),np.array(y)
            z = np.zeros((len(x), 1))
            return [x,y],z

def build_w2vm(word_size,window,nb_negative):
    K.clear_session() #清除之前的模型，省得压满内存
    #CBOW输入
    input_words = Input(shape=(window*2,), dtype='int32')
    input_vecs = Embedding(nb_word, word_size, name='word2vec')(input_words)
    input_vecs_sum = Lambda(lambda x: K.sum(x, axis=1))(input_vecs) #CBOW模型，直接将上下文词向量求和
    
    #构造随机负样本，与目标组成抽样
    target_word = Input(shape=(1,), dtype='int32')
    negatives = Lambda(lambda x: K.random_uniform((K.shape(x)[0], nb_negative), 0, nb_word, 'int32'))(target_word)
    samples = Lambda(lambda x: K.concatenate(x))([target_word,negatives]) #构造抽样，负样本随机抽。负样本也可能抽到正样本，但概率小。
    
    #只在抽样内做Dense和softmax
    softmax_weights = Embedding(nb_word, word_size, name='W')(samples)
    softmax_biases = Embedding(nb_word, 1, name='b')(samples)
    softmax = Lambda(lambda x: 
                        K.softmax((K.batch_dot(x[0], K.expand_dims(x[1],2))+x[2])[:,:,0])
                    )([softmax_weights,input_vecs_sum,softmax_biases]) #用Embedding层存参数，用K后端实现矩阵乘法，以此复现Dense层的功能
    
    #留意到，我们构造抽样时，把目标放在了第一位，也就是说，softmax的目标id总是0，这可以从data_generator中的z变量的写法可以看出
    
    model = Model(inputs=[input_words,target_word], outputs=softmax)
    model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    #请留意用的是sparse_categorical_crossentropy而不是categorical_crossentropy
    model.summary()
    return model

def most_similar(word2id,w,k=10): #找相似性Topk个词
    #通过词语相似度，检查我们的词向量是不是靠谱的
    model = load_model('./word2vec.h5') #载入模型 在数据集较大的时候用空间换时间
    # weights = model.get_weights()#可以顺便看看每层的权重
    # for wei in weights:
    #     print(wei.shape)
    embeddings = model.get_weights()[0]
    normalized_embeddings = embeddings / (embeddings**2).sum(axis=1).reshape((-1,1))**0.5 #词向量归一化，即将模定为1
    v = normalized_embeddings[word2id[w]]
    sims = np.dot(normalized_embeddings, v)
    sort = sims.argsort()[::-1]
    sort = sort[sort > 0]
    return [(id2word[i],sims[i]) for i in sort[:k]]

if __name__ == '__main__': 
    fname = 'seq.txt' #数据集(语料库) 一个文档
    word_size = 60 #词向量维度
    window = 5 #窗口大小
    nb_negative = 15 #随机负采样的样本数
    min_count = 0 #频数少于min_count的词将会被抛弃
    nb_worker = 4 #读取数据的并发数
    nb_epoch = 2 #迭代次数，由于使用了adam，迭代次数1～2次效果就相当不错
    subsample_t = 1e-5 #词频大于subsample_t的词语，会被降采样，这是提高速度和词向量质量的有效方案
    nb_sentence_per_batch = 20
    #目前是以句子为单位作为batch，多少个句子作为一个batch（这样才容易估计训练过程中的steps参数，另外注意，样本数是正比于字数的。）
    
    data,sentences = getdata(fname) #读原始数据
    nb_sentence,id2word,word2id,nb_word,subsamples = bulid_dic(sentences) #建字典
    ipt,opt = data_generator(word2id,subsamples,data) #构造训练数据
    model = build_w2vm(word_size,window,nb_word,nb_negative) #搭模型
    model.fit(  ipt,opt, 
                steps_per_epoch= int(nb_sentence/nb_sentence_per_batch), 
                epochs=nb_epoch,
                workers=nb_worker,
                use_multiprocessing=True
              )
    model.save('word2vec.h5')
    plot_model(model, to_file='./word2vec.png',show_shapes=True,dpi=300) #输出框架图
    print(pd.Series(most_similar(word2id,'天龙八部')))

来源：CSDN

作者：lechuan_dafo

链接：https://blog.csdn.net/qq_34862636/article/details/103834058