TensorFlow实现word2vec 详细代码解释

参考1：http://blog.csdn.net/mylove0414/article/details/69789203

参考2：《TensorFlow实战》

参考3：http://www.jianshu.com/p/f682066f0586

代码配合参考3的图形说明，可以更容易理解。本例子，打算实现中文的word2vec,但最后显示都是一群乱码，对应的中文代码，也没有更改。如果有人找到了解决方法，请告知，谢谢。

实验用到了 python3.5，TensorFlow的环境。

试验用到的文本可以去参考一，实验结果如下图。

实验结束的代码画图展示：

由上图，可知道两个单词相似度越高，在压缩的2位空间图中就越近，如上个图的几个画圈的点，日常中使用相似度很高。

实验代码详细解释：

# coding=utf-8

import collections
import sys
import re  
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import jieba
from sklearn.manifold import TSNE
'''
读取源文件,并转为list输出
@param filename:文件名
@return: list of words
'''
# # 读中文的
# def wseg_sentence(input):
#     with open(input, 'r',encoding='utf-8') as fp:
#         ret=[]
#         for line in fp.readlines():
#             word = line.strip()
#             if word !=None and len(word)>0 :
#                 u_ret = jieba.cut(word, cut_all = False) #精准切分模式
#                 ret.append(u_ret)
#                 # print(ret)
#         print(ret)
#         return ret
#读英文的。
def read_file(filename):
    f=open(filename,'r')
    file_read=f.read()
    words_=re.sub("[^a-zA-Z]+", " ",file_read).lower() #正则匹配,只留下单词，且大写改小写
    words=list(words_.split())  #length of words:1121985

    # #将写出的格式，保存在某个文本里
    # m=0
    # for  i in words:
    #     m=m+1
    #     if m<10:
    #         file_object.write(i)
    return words
# words= wseg_sentence('../dataset/hong.txt')
words=read_file('../dataset/heli.txt')
file_object = open('../dataset/1111', 'w')

vocabulary_size=2000  #预定义频繁单词库的长度
count=[['UNK',-1]]    #初始化单词频数统计集合

'''
1.给@param “words”中出现过的单词做频数统计，取top 1999频数的单词放入dictionary中，以便快速查询。
2.给哈利波特这本“单词库”@param“words”编码，出现在top 1999之外的单词，统一令其为“UNK”（未知），编号为0，并统计这些单词的数量。
@return: 哈利波特这本书的编码data，每个单词的频数统计count，词汇表dictionary及其反转形式reverse_dictionary
'''
def build_dataset(words):
    #most_common方法： 去top2000的频数的单词，创建一个dict,放进去。以词频排序
    counter=collections.Counter(words).most_common(vocabulary_size-1) #length of all counter:22159 取top1999频数的单词作为vocabulary，其他的作为unknown
    # print('123  :', type(count))  #list类型
    # print(len(counter)) #1999个
    # print(counter)
    #[('the', 51897), ('and', 27525), ('to', 26996), ('he', 22203), ('of', 21851), ('a', 21043), ('harry', 18165), ('was', 15637), ('you', 14627), ('it', 14489),。 ('member', 49), ('fake', 49)。]
    count.extend(counter)
    #搭建dictionary
    dictionary={}
    for word,_ in count:
        dictionary[word]=len(dictionary)
    # print('234   :',dictionary.get('the'))   输出为1
    data=[]
    #全部单词转为编号
    #先判断这个单词是否出现在dictionary，如果是，就转成编号，如果不是，则转为编号0（代表UNK）
    unk_count=0
    for word in words:
        if word in dictionary:
            index=dictionary[word]
        else:
            index=0
            unk_count+=1
        data.append(index)

    count[0][1]=unk_count
    reverse_dictionary=dict(zip(dictionary.values(),dictionary.keys()))
    # print('aaaaa   ',data)                 #根据文章，将全文每个数，对应的排名标记， 比如 the 出现最多，则对应的数为1，不在前1999的标记为0  【959, 18, 7, 6, 1728, 0, 306, 13, 450, 1175, 32, 180, 265, 3, 9, 205,】
    # print('00000   ',count)               #前1999，个对应的出现的次数，第一个数是 总共多少不在前1999的字数   比如： the:51897
    # print('bbbbb   ',dictionary)          #前1999的数的dict  ['the':1]这种
    # print('1111   :',reverse_dictionary)  #按照dict值来排序，变得有规律起来。{0: 'UNK', 1: 'the', 2: 'and', 3: 'to', 4: 'he', 5: 'of', 6: 'a', 7: 'harry', 8: 'was', 9:}
    return data,count,dictionary,reverse_dictionary

data,count,dictionary,reverse_dictionary=build_dataset(words)   
del words #删除原始单词列表，节约内存



data_index=0


'''
采用Skip-Gram模式,  生成我们需要的 input label 的那种格式。，可以参看第二个小例子。
生成word2vec训练样本
@param batch_size:每个批次训练多少样本
@param num_skips: 为每个单词生成多少样本（本次实验是2个），batch_size必须是num_skips的整数倍,这样可以确保由一个目标词汇生成的样本在同一个批次中。
@param skip_window:单词最远可以联系的距离（本次实验设为1，即目标单词只能和相邻的两个单词生成样本），2*skip_window>=num_skips
'''
def generate_batch(batch_size,num_skips,skip_window):

    global data_index
    assert batch_size%num_skips==0
    assert num_skips<=2*skip_window

    batch=np.ndarray(shape=(batch_size),dtype=np.int32)
    # print(batch)  128个一维数组
    labels=np.ndarray(shape=(batch_size,1),dtype=np.int32)
    # print(labels)  128个二维数组
    span=2*skip_window+1   #入队长度
    # print(span)
    buffer=collections.deque(maxlen=span)
    
    for _ in range(span):  #双向队列填入初始值

        buffer.append(data[data_index])
        data_index=(data_index+1)%len(data)  
    # print('cishu :000', batch_size//num_skips)
    for i in range(batch_size//num_skips):  #第一次循环，i表示第几次入双向队列deque
        for j in range(span):  #内部循环，处理deque
            if j>skip_window:
                batch[i*num_skips+j-1]=buffer[skip_window]
                labels[i*num_skips+j-1,0]=buffer[j]
            elif j==skip_window:
                continue
            else:
                batch[i*num_skips+j]=buffer[skip_window]
                labels[i*num_skips+j,0]=buffer[j]
        buffer.append(data[data_index])  #入队一个单词，出队一个单词
        data_index=(data_index+1)%len(data)
    # print('batch    :',batch)
    # print('label    :',labels)
    return batch,labels    


#开始训练
batch_size=128   
embedding_size=128
skip_window=1
num_skips=2
num_sampled=64  #训练时用来做负样本的噪声单词的数量
#验证数据
valid_size=16 #抽取的验证单词数
valid_window=100 #验证单词只从频数最高的100个单词中抽取
valid_examples=np.random.choice(valid_window,valid_size,replace=False)#不重复在0——10l里取16个


graph=tf.Graph()
with graph.as_default():
    train_inputs=tf.placeholder(tf.int32, shape=[batch_size])
    train_labels=tf.placeholder(tf.int32, shape=[batch_size,1])
    valid_dataset=tf.constant(valid_examples,dtype=tf.int32)
    #单词维度为 2000单词大小，128向量维度
    embeddings=tf.Variable(tf.random_uniform([vocabulary_size,embedding_size], -1, 1))   #初始化embedding vector
    #使用tf.nn.embedding_lookup查找输入train_inputs 对应的向量embed
    embed=tf.nn.embedding_lookup(embeddings, train_inputs) 
    
    #用NCE loss作为优化训练的目标
    #tf.truncated_normal初始化nce loss中的权重参数 nce_weights,并将nce_biases初始化为0
    nce_weights=tf.Variable(tf.truncated_normal([vocabulary_size,embedding_size], stddev=1.0/np.math.sqrt(embedding_size)))
    nce_bias=tf.Variable(tf.zeros([vocabulary_size]))
    #计算学习出的词向量embedding在训练数据上的loss,并使用tf.reduce_mean进行魂汇总
    loss=tf.reduce_mean(tf.nn.nce_loss(nce_weights, nce_bias, embed, train_labels, num_sampled, num_classes=vocabulary_size))
    #学习率为1.0，L2范式标准化后的enormalized_embedding。
    #通过cos方式来测试  两个之间的相似性，与向量的长度没有关系。
    optimizer=tf.train.GradientDescentOptimizer(1.0).minimize(loss)
    norm=tf.sqrt(tf.reduce_sum(tf.square(embeddings), axis=1, keep_dims=True))
    normalized_embeddings=embeddings/norm   #除以其L2范数后得到标准化后的normalized_embeddings
    
    valid_embeddings=tf.nn.embedding_lookup(normalized_embeddings,valid_dataset)    #如果输入的是64，那么对应的embedding是normalized_embeddings第64行的vector
    similarity=tf.matmul(valid_embeddings,normalized_embeddings,transpose_b=True)   #计算验证单词的嵌入向量与词汇表中所有单词的相似性
    print('相似性：',similarity)
    init=tf.global_variables_initializer()
    
num_steps=100001
with tf.Session(graph=graph) as session:
    init.run()
    print("Initialized")
    avg_loss=0
    for step in range(num_steps):
        batch_inputs,batch_labels=generate_batch(batch_size, num_skips, skip_window)  #产生批次训练样本
        feed_dict={train_inputs:batch_inputs,train_labels:batch_labels}   #赋值
        _,loss_val=session.run([optimizer,loss],feed_dict=feed_dict)
        avg_loss+=loss_val
        #每2000次，计算一下平均loss并显示出来。
        if step % 2000 ==0:
            if step>0:
                avg_loss/=2000
            print("Avg loss at step ",step,": ",avg_loss)
            avg_loss=0
            #每10000次，验证单词与全部单词的相似度，并将与每个验证单词最相似的8个找出来。
        if step%10000==0:
            sim=similarity.eval()
            for i in range(valid_size):
                valid_word=reverse_dictionary[valid_examples[i]]  #得到验证单词
                top_k=8  
                nearest=(-sim[i,:]).argsort()[1:top_k+1]     #每一个valid_example相似度最高的top-k个单词
                log_str="Nearest to %s:" % valid_word
                for k in range(top_k):
                    close_word=reverse_dictionary[nearest[k]]
                    log_str="%s %s," %(log_str,close_word)
                print(log_str)
    final_embedding=normalized_embeddings.eval()
'''
可视化Word2Vec散点图并保存
'''
def plot_with_labels(low_dim_embs,labels,filename):
    #low_dim_embs 降维到2维的单词的空间向量
    assert low_dim_embs.shape[0]>=len(labels),"more labels than embedding"
    plt.figure(figsize=(18,18))
    for i,label in enumerate(labels):
        x,y=low_dim_embs[i,:]
        plt.scatter(x, y)
        #展示单词本身
        plt.annotate(label,xy=(x,y),xytext=(5,2),textcoords='offset points',ha='right',va='bottom')
    plt.savefig(filename)

'''
tsne实现降维，将原始的128维的嵌入向量降到2维
'''
print('123213123')
tsne=TSNE(perplexity=30,n_components=2,init='pca',n_iter=5000)
plot_number=100
low_dim_embs=tsne.fit_transform(final_embedding[:plot_number,:])
labels=[reverse_dictionary[i] for i in range(plot_number)]
plot_with_labels(low_dim_embs, labels, './plot.png')
print('1231231')