之前以為直接使用contrib.text.embedding就可以完成學習，後面發現和paper的意思不匹配，這一層是需要單獨獲取的。
先附上可以參考的鏈接:

1. LSTM裏Embedding Layer的作用是什麽
2. http://www.cnblogs.com/iloveai/p/word2vec.html
3. 原文

可以了解到，Embedding是要產生一個矩陣，通過行引索輸出連續空間變量，並且空間的維數可以人為設定。關鍵處是要使詞之間的上下文關系程度由歐氏距離指示。
但對於如何得到這樣的矩陣，找到的描述確實語焉不詳（比如鏈接2看起來條條有理，但卻使人無處著力，尤其是那幾張圖配合著文段描述真是使人不著頭腦） ，另外看到一篇貼上自己分析google的cpp的註釋。自動求導大行其道的當下，很難說不通過這種方式實現的方法有什麽實用價值。 還是給我找到了在MXNet中的實現過程:
https://github.com/apache/incubator-mxnet/tree/master/example/nce-loss

所有需要學習的參數只有一個矩陣，並沒有鏈接1說的抽取中間數據的思想。實際也可想見，對於實現目標，只需要想辦法通過損失函數，使出於同一上下文中的詞向量(稠密表示後的)接近就好了；如果從加快收斂角度考慮，進行negative 采樣，每次對不在同一上下文中的向量進行懲罰。

 # 優化的框架，需要有叠代器(DataIterWords@text8_data.py )的支持才有註釋中的效果
 # wordvec_net.py
 # 對中心詞作為預測目標進行優化
def get_word_net(vocab_size, num_input):
    data = mx.sym.Variable(‘data‘
 
)
    label = mx.sym.Variable(‘label‘)
    label_weight = mx.sym.Variable(‘label_weight‘) # 在叠代器的輸出中，首個元素是中心詞，其余是負樣本
    embed_weight = mx.sym.Variable(‘embed_weight‘) # 首個元素是1，其余是0，logistic回歸作為損失函數
    data_embed = mx.sym.Embedding(data=data, input_dim=vocab_size,
                                  weight=
 
embed_weight,
                                  output_dim=100, name=‘data_embed‘)
    datavec = mx.sym.SliceChannel(data=data_embed,
                                  num_outputs=num_input,
                                  squeeze_axis=1, name=‘data_slice‘)
    pred = datavec[0]
    for i in range(1, num_input):
        pred = pred + datavec[i]        # 對上下文進行求和， 按照原文的意思
    return nce_loss(data=pred,
                    label=label,
                    label_weight=label_weight,
                    embed_weight=embed_weight,
                    vocab_size=vocab_size,
                    num_hidden=100)
 # nce.py
def nce_loss(data, label, label_weight, embed_weight, vocab_size, num_hidden):
    label_embed = mx.sym.Embedding(data=label, input_dim=vocab_size,
                                   weight=embed_weight,
                                   output_dim=num_hidden, name=‘label_embed‘) # 對 label引索
    data = mx.sym.Reshape(data=data, shape=(-1, 1, num_hidden))
    pred = mx.sym.broadcast_mul(data, label_embed)  # 求點積
    pred = mx.sym.sum(data=pred, axis=2)
    return mx.sym.LogisticRegressionOutput(data=pred,
                                           label=label_weight)  # 向中心詞靠近，遠離上下文以外的詞

叠代器設計巧妙，把用到的程序放在這:

# text8_data.py
def _load_data(name):
    buf = open(name).read()
    tks = buf.split(‘ ‘)
    vocab = {}
    freq = [0]
    data = []
    for tk in tks:
        if len(tk) == 0:
            continue
        if tk not in vocab:
            vocab[tk] = len(vocab) + 1
            freq.append(0)
        wid = vocab[tk]
        data.append(wid)
        freq[wid] += 1
    negative = []
    for i, v in enumerate(freq):
        if i == 0 or v < 5:
            continue
        v = int(math.pow(v * 1.0, 0.75))
        negative += [i for _ in range(v)] # 詞的頻數高，連接的負樣本數量應該更多，見下文討論
    return data, negative, vocab, freq
class DataIterWords(mx.io.DataIter):
    def __init__(self, name, batch_size, num_label):
        super(DataIterWords, self).__init__()
        self.batch_size = batch_size
        self.data, self.negative, self.vocab, self.freq = _load_data(name)
        self.vocab_size = 1 + len(self.vocab)
        print("Vocabulary Size: {}".format(self.vocab_size))
        self.num_label = num_label
        self.provide_data = [(‘data‘, (batch_size, num_label - 1))]
        self.provide_label = [(‘label‘, (self.batch_size, num_label)),
                              (‘label_weight‘, (self.batch_size, num_label))]
    def sample_ne(self):
        return self.negative[random.randint(0, len(self.negative) - 1)]
    def __iter__(self):
        batch_data = []
        batch_label = []
        batch_label_weight = []
        start = random.randint(0, self.num_label - 1)
        for i in range(start, len(self.data) - self.num_label - start, self.num_label):
            context = self.data[i: i + self.num_label // 2] \
                      + self.data[i + 1 + self.num_label // 2: i + self.num_label]  # 以中心詞作為預測目標
            target_word = self.data[i + self.num_label // 2]
            if self.freq[target_word] < 5:
                continue
            target = [target_word] + [self.sample_ne() for _ in range(self.num_label - 1)]
            target_weight = [1.0] + [0.0 for _ in range(self.num_label - 1)]  # 負樣本優化目標為0
            batch_data.append(context)
            batch_label.append(target)
            batch_label_weight.append(target_weight)
            if len(batch_data) == self.batch_size:
                data_all = [mx.nd.array(batch_data)]
                label_all = [mx.nd.array(batch_label), mx.nd.array(batch_label_weight)]
                data_names = [‘data‘]
                label_names = [‘label‘, ‘label_weight‘]
                batch_data = []
                batch_label = []
                batch_label_weight = []
                yield SimpleBatch(data_names, data_all, label_names, label_all)

這裏想說的是，負樣本的生成與頻數關聯的原因。雖然每一個batch中，負樣本的數量是一定的(都是batch_size x (label_num-1) )，但由於是均勻采樣（見sample_ne），高頻詞對應的負樣本將有更大概率被抽到。
對一個高頻詞而言，其在優化中出現的次數會比較多，如果沒有匹配數量的負樣本，按照神經網絡優化的弊端，結果模型會偏向比重大的，可能的結果就是把這個詞放在了帶有權重的中心位置。或者說，結果模型會有更大部分只是在反應輸入樣本的統計關系，而不是上下文關系。

Word Embedding的生成