Paragraph Vector学习文章特征及其在Gensim和Tensorflow上的编写以及应用

原文

Paragraph2vec 是一种非监督学习方式，输入为文本，输出则是文本对应的向量表示。

连续分布式向量表示。文本可以是可变的长度（对应于 sentence 及 documents）。
向量表示可以用来预测文章中的 word。可以连接 paragraph vector和 word vector，预测给定的 context 下将要出现的 word。 word 向量和 para 向量都是通过 GD 和 BP 计算出来的。para 向量唯一对应于相应的文章，而 word 向量则是全局共享的。在 predict 时，固定 word 向量，并训练新的 para 向量直到收敛获得 para 向量的预测。

word 向量一般是通过对 context 下得 word 向量进行连接或者平均获得。结果向量用来预测在这个 context 下的其他 word。例如在NNLM（Bengio 06）中，使用前面出现的 word 向量的连接作为神经网络的输入，目的是预测下面的 word。在 model 训练完成，word 向量被映射到一个向量空间，使得语义相似的 word 拥有相似的向量表示。（如“strong” 靠近 “powerful”）

在此基础上，出现了 phrase 和 sentence 层的表示。使用文档中出现的 word 的平均权重来表示一个 document。更复杂的是使用 sentence 的分析树，使用矩阵向量操作。这两种方式都有弱点，因为他们都忽略了 word 在 document 中出现的顺序。第二种由于依赖于分析（parsing）则只能处理 sentence。

para 向量可以用来构造可变长度的输入序列的表示。不同于前面的一些方法，para 向量是通用的并可以用在任意长度的文本上。例如，在情感分析人物中，我们获得新的结果，比那些复杂的方法还要好。在文本分类的工作中，我们的方法相较于bag-of-words方法有超过30%的提升。

算法

学习 word 的向量表示

每个 word 都被映射到一个唯一的向量，也就对应于矩阵 M 中得一个列。列则是有词在词汇表中的位置索引。那么这些 word 向量的连接和求和就可以作为这个句子中下一个 word 预测的前提。

给定

Paste_Image.png

word 向量模型的目标就是优化下面的平均 log 概率

Paste_Image.png

这个预测的任务使用了多类分类器完成，例如 softmax。我们有：

Paste_Image.png

每个 y_i 是对应于每个输出 word i 的一个未正规化的 log 概率，计算公式如下：

Paste_Image.png

其中 U，b 是 softmax 参数。h由 word 向量的连接或者平均获得。

Paste_Image.png

层次化 softmax 通过一个二叉 Huffman 树完成，短的编码对应于出现频繁的 word。这样常用词可以很快的查到。

基于 word 向量的神经网络通常使用 SGD 训练，其中gradient 通过 BP 获得。这是比较常见的 NNLM。

paragraph 向量：分布式记忆模型

每篇文档映射在一个唯一的向量上，由矩阵D中的一列表示，每个 word 则类似地被映射到向量上，这个向量由矩阵 M 的列表示。同样是使用连接或者平均的方式获得新 word 的预测。在实验中，使用的连接的方式进行。

Paste_Image.png

也就是说，唯一与 word2vec 不同的地方就是公式（1）：h 由 W 和 D 共同构造。

算法本身两个关键步骤：

1. 训练获得word向量 W，softmax权值 U，b 和在已经见过的para 向量 D上；
2. 推断步骤：获得新 paragraph 的 para 向量 D 和在固定W，U，b 时的 D 上的下降的 gradient。我们使用 D 并借助通常的分类器做出预测特定的标签。

para 向量的优点：从未标记数据学得，因此可以应用在没有太多标签得数据上。还有 para 向量解决了 bag-of-words 的没有 word 顺序的问题。并且极大地降低了表示的维度。

转载自：http://www.jianshu.com/p/d34d61188ab5

****************************************************************************************************************************************************目前，Mikolov以及Bengio的最新论文Ensemble of Generative and Discriminative Techniques for Sentiment Analysis of Movie Reviews里就引入了该模型作为用户对影视作品的评论分析方法。与此同时，网络上很多地方也指出该模型效果并没有其前期模型Word2Vec的效果好。这里，我们先不讨论其效果是好是坏，单就如何搭建该模型来展开讨论。首先，我将介绍该模型的Gensim编写方法，之后，在Gensim模型的思维下，我们将尝试运用Tensorflow来编写这个模型。在我们开始码代码前，对于这个模型，还是有必要做一点稍许介绍的。

模型背景：

该模型起始于Word2Vec中的CBOW以及Skip-Gram模型。从模型的框架来看，其结构基本等同于CBOW或者Skip-Gram模型，但最大区别在于加入了一个新的于单词维度相等的维度作为句子维度，段落维度或者文章维度。 维度的意义为需要运用该模型的人他们所需要代表的意义，即句子分类，段落分类还是文章分类。这个新的维度存在于不同于单词维度的空间，所以大家注意不要混淆单词维度和这个新维度的概念。模型的训练方式等同于Word2Vec。模型的目的在于为单词加入一些更长的序列意义外同时为句子，段落或者文章的非监督分类得到类似于Word2Vec的效果。详细的说明大家可以阅读如下链接（即上文）。

模型代码：

1. Gensim代码：

首先，让我们来看看Gensim代码是如何表达的：

from  gensim.models  import  doc2vec
from  collections  import  namedtuple
import  csv
import  re
import  string
# 选择wikipedia作为输入，录入一部分wikipedia的csv文档
reader  =  csv.reader( open ( "wikipedia.csv" ))
count  =  0
data  =  ''
for  row  in  reader:
    count  =  count  +  1
    if  count >  301 :
       break
    else :
        data  + =  row[ 1 ]
# 分句。我们以句号，问号以及感叹号作为分句依据。
# 值得注意的是，该依据并非十分严谨，例如英文中的
# Mr.Wang就会被划分为两句，但是由于该代码是作为
# 示范，我们对严谨的分句并不感兴趣，大家有空可以
# 做更好的处理
sentenceEnders  =  re. compile ( '[.?!]' )
data_list  =  sentenceEnders.split(data)
# 建设一个namedtuple框架来装载输入
LabelDoc  =  namedtuple( 'LabelDoc' ,  'words tags' )
exclude  =  set (string.punctuation)
all_docs  =  []
count  =  0
for  sen  in  data_list:
    word_list  =  sen.split()
    # 当一句话小于三个词儿时，我们认为其意义并不
    # 完整，所以去除该类话以净化我们的输入。
    if  len (word_list) <  3 :
        continue
    tag  =  [ 'SEN_'  +  str (count)]
    count  + =  1
    sen  =  ''.join(ch  for  ch  in  sen  if  ch  not  in  exclude)
    all_docs.append(LabelDoc(sen.split(), tag))
# 打印例子来看看all_docs的形状
print  all_docs[ 0 : 10 ]
# 在Gensim的官方文件中，作者指出最好的效果要么来自于随意排列输入句子，要么
# 来自于在训练迭代的过程中减少learning rate alpha，故这里我们运用了后者。
model  =  doc2vec.Doc2Vec(alpha = 0.025 , min_alpha = 0.025 )   # use fixed learning rate
model.build_vocab(all_docs)
for  epoch  in  range ( 10 ):
    model.train(all_docs)
    model.alpha  - =  0.002   # decrease the learning rate
    model.min_alpha  =  model.alpha   # fix the learning rate, no decay
# 保存该模型
model.save( 'my_model.doc2vec' )

 不难看出，在整理好输入后，除了需要设计减少learning rate alpha外，其余的训练方法非常浅显易懂。在测试该模型的效果时，运行以下代码即可：

import  random
import  numpy as np
import  string

# 选取一个任意的句子id
doc_id  =  np.random.randint(model.docvecs.count)
print  doc_id

# 通过docvecs.most_similar函数计算相近的句子id，并依次打印出前8个
sims  =  model.docvecs.most_similar(doc_id, topn = model.docvecs.count)
print ( 'TARGET'  , all_docs[doc_id].words)
count  =  0
for  i  in  sims:
    if  count >  8 :
        break
    pid  =  int (string.replace(i[ 0 ],  "SEN_" , ""))
    print (i[ 0 ], ": " , all_docs[pid].words)
    count  + =  1

 运行结果如下：

显而易见，当我们的目标句子是关于Maldonado时，我们的最接近句子也是关于他的。同时，我们的句子是关羽notable victories(明显的胜利)时，第二接近的句子也是关于这个主题。由此可见，系统的确学习到了一些关联性。但是我们终究只是运用了一个黑盒子，这个黑盒子到底是怎么工作的呢？下面我们将试图用Tensorflow还原这个逻辑。

2. Tensorflow代码：

在我5月19日的博客上已经介绍了关于Word2Vec里CBOW模型在Tensorflow上的编写，详细信息请点击链接查询。基于这个模型，我们将来推演如何更改以获得PV-DM模型，即Paragraph Vector版本的CBOW模型。

首先，我们需要整理输入。方法相同于之前Gensim的代码，这里将不予重复。但是值得注意的是，原来的wikipedia.csv文档被我们预处理为一个装有单词list以及其对应句子id的一个namedtuple struct。那么，在接受这个struct的同时，我们需要更改build_data函数来正确的组建dictionary以及我们需要的data输入。这里，我们的目标是保持原来的count, dictionary以及reverse dictionary, 但是对于输入data，我们希望直接更改我们的输入，把namedtuple中，单词list里的单词换成他们在dictionary中的index。如下代码将做到这个功能：

def  build_dataset(input_data, min_cut_freq):
  # 这里将input_data重新收集为CBOW模型中的words list以方便
  # counter函数的使用。
  words  =  []
  for  i  in  input_data:
        for  j  in  i.words:
            words.append(j)
  count_org  =  [[ 'UNK' ,  - 1 ]]
  count_org.extend(collections.Counter(words).most_common())
  count  =  [[ 'UNK' ,  - 1 ]]
  for  word, c  in  count_org:
    word_tuple  =  [word, c]
    if  word  = =  'UNK' :
        count[ 0 ][ 1 ]  =  c
        continue
    if  c > min_cut_freq:
        count.append(word_tuple)
  dictionary  =  dict ()
  for  word, _  in  count:
    dictionary[word]  =  len (dictionary)
  data  =  []
  unk_count  =  0
  for  tup  in  input_data:
    word_data  =  []
    for  word  in  tup.words:
      if  word  in  dictionary:
        index  =  dictionary[word]
      else :
        index  =  0
        unk_count  + =  1
      word_data.append(index)
    data.append(LabelDoc(word_data, tup.tags))
  count[ 0 ][ 1 ]  =  unk_count
  reverse_dictionary  =  dict ( zip (dictionary.values(), dictionary.keys()))
  return  data, count, dictionary, reverse_dictionary

由以上代码，我们将会得到我们需要的输入。那么，如何建立我们的模型呢？在建立模型前，我们需要跟改generate_batch函数以求保持原来的batch和label输出外，增加一个对应每个label的一个paragraph label。

def  generate_DM_batch(batch_size, num_skips, skip_window):
    global  word_index
    global  sentence_index
    assert  batch_size  %  num_skips  = =  0
    assert  num_skips < =  2  *  skip_window
    batch  =  np.ndarray(shape = (batch_size, num_skips), dtype = np.int32)
    labels  =  np.ndarray(shape = (batch_size,  1 ), dtype = np.int32)
    para_labels  =  np.ndarray(shape = (batch_size,  1 ), dtype = np.int32)  # Paragraph Labels
    span  =  2  *  skip_window  +  1  # [ skip_window target skip_window ]
    buffer  =  collections.deque(maxlen = span)
    for  _  in  range (span):
        buffer .append(data[sentence_index].words[word_index])
        sen_len  =  len (data[sentence_index].words)
        if  sen_len  -  1  = =  word_index:  # reaching the end of a sentence
            word_index  =  0
            sentence_index  =  (sentence_index  +  1 )  %  len (data)
        else :  # increase the word_index by 1
            word_index  + =  1
    for  i  in  range (batch_size):
        target  =  skip_window   # target label at the center of the buffer
        targets_to_avoid  =  [ skip_window ]
        batch_temp  =  np.ndarray(shape = (num_skips), dtype = np.int32)
        for  j  in  range (num_skips):
            while  target  in  targets_to_avoid:
                target  =  random.randint( 0 , span  -  1 )
            targets_to_avoid.append(target)
            batch_temp[j]  =  buffer [target]
        batch[i]  =  batch_temp
        labels[i, 0 ]  =  buffer [skip_window]
        para_labels[i,  0 ]  =  sentence_index
        buffer .append(data[sentence_index].words[word_index])
        sen_len  =  len (data[sentence_index].words)
        if  sen_len  -  1  = =  word_index:  # reaching the end of a sentence
            word_index  =  0
            sentence_index  =  (sentence_index  +  1 )  %  len (data)
        else :  # increase the word_index by 1
            word_index  + =  1
    return  batch, labels, para_labels

 这里，我们保持了两个global的变量，即word_index和sentence_index。前者标记了在一句中前一个batch读到了哪个单词，后者标记了前一个batch读到了哪个句子。他们的初始值都是0。如果我们发现目前所读入的单词在句子中是最后一个词，即sen_len - 1 == word_index, 我们将会重置word_index,并移动sentence_index去向下一句。这样，我们保持了原有的batch和labels外针对每一个input window定义了它自身所应对的一个para_label。 好了，材料齐备了，那么我们如何运用这些材料构建paragraph vector呢？

with graph.as_default():

  # Input data.
  train_inputs  =  tf.placeholder(tf.int32,shape = [batch_size, skip_window  *  2 ])
  train_labels  =  tf.placeholder(tf.int32, shape = [batch_size,  1 ])
  #paragraph vector place holder
  train_para_labels  =  tf.placeholder(tf.int32,shape = [batch_size,  1 ])

  # Ops and variables pinned to the CPU because of missing GPU implementation
  with tf.device( '/cpu:0' ):
    # Look up embeddings for inputs.
    embeddings  =  tf.Variable(tf.random_uniform([vocabulary_size, embedding_size],  - 1.0 ,  1.0 ))
    embed_word  =  tf.nn.embedding_lookup(embeddings, train_inputs)
    # Look up embeddings for paragraph inputs
    para_embeddings  =  tf.Variable(tf.random_uniform([paragraph_size, embedding_size],  - 1.0 ,  1.0 ))
    embed_para  =  tf.nn.embedding_lookup(para_embeddings, train_para_labels)
    # Concat them and average them
    embed  =  tf.concat( 1 , [embed_word, embed_para])
    reduced_embed  =  tf.div(tf.reduce_sum(embed,  1 ), skip_window * 2  +  1 )

    # Construct the variables for the NCE loss
    nce_weights  =  tf.Variable(tf.truncated_normal([vocabulary_size, embedding_size],
                            stddev = 1.0  /  math.sqrt(embedding_size)))
    nce_biases  =  tf.Variable(tf.zeros([vocabulary_size]))
    # Compute the average NCE loss for the batch.
    # tf.nce_loss automatically draws a new sample of the negative labels each
    # time we evaluate the loss.
    loss  =  tf.reduce_mean( tf.nn.nce_loss(nce_weights, nce_biases, reduced_embed, train_labels,
                     num_sampled, vocabulary_size))

这里，我们首先保留了原来的word embedding的graph，在此基础上，我们加入了paragraph_labels的placeholder，并且定义了paragraph vector的embedding。在把他们合并并且加权平均了后，我们通过nce loss的方式训练该模型。最后

with tf.Session(graph = graph) as session:
  # We must initialize all variables before we use them.
  init.run()
  print ( "Initialized" )

  average_loss  =  0
  for  step  in  xrange (num_steps):
    batch_inputs, batch_labels, batch_para_labels  =  generate_DM_batch(
        batch_size, num_skips, skip_window)
    feed_dict  =  {train_inputs : batch_inputs, train_labels : batch_labels, train_para_labels: batch_para_labels}

 在session里，我们呼叫我们的generatge_DM_batch函数并将batch, label和paragraph_label喂给我们的模型。该模型在运行的过程中效果并不很好，由于时间紧张，我没有对模型进行优化。之后我将会gensim里关于shuffle输入语句或者减少learning rate alpha的提议进行尝试。如果你发现我的代码有误，请务必指出，感谢你的热情参与！谢谢！代码可以在这里找到.

转载自：http://www.cnblogs.com/edwardbi/p/5540898.html