Word2Vec詳解
這幾天集中學習了Word2Vec，實現并不復雜，但是真正對一些細節有些了解還查閱了一些資料，今天在這里統一自己整理總結一下。

簡介
首先說為什么會有Word2Vec，之前對文字的編碼通常使用的是one-hot，也就是一個詞對應一個編號，或者是一個向量，這樣一篇文章就是一個稀疏矩陣。這種方式存在兩個問題：1.不同于視頻音頻的稠密矩陣，稀疏矩陣儲存和訓練就很低效；2.編碼的隨機性導致詞語之間沒有任何關聯性。?
Word2Vec出現解決上面兩個問題。通過embedding將詞語編碼映射到一個新的多維空間，在這個新的空間中，詞義相近的詞會有相近的位置，并且最終形成地是稠密矩陣。?
Word2Vec有兩種預測模型：CBOW主要用來從原始語句推測目標詞匯，skip-gram用來從目標詞匯推測原始語境。網上資料很多，不多做介紹。

模型思想
下面是兩種模型的示意圖?
?
Word2Vec的思想和自編碼器很相似。具體來說，我們用機器學習的方法訓練神經網絡，但是最終我們關心的不是使用這個神經網絡計算輸出結果，我們想要得到的是神經網絡隱藏岑層的參數，這個權重矩陣就是我們需要的詞向量Word vector。換句話說，建模并不是我們的根本目的。

訓練樣本構建和訓練
上面說過，兩種模型分別是從原始語境和目標詞匯兩者之一推另外一個。所以訓練之前我們需要對文本進行構建，形成目標詞匯和對應的原始語境。

假如我們有一個句子“The dog barked at the mailman”。?
首先我們選句子中間的一個詞作為我們的輸入詞，也就是目標詞匯，例如我們選取“dog”作為input word；

有了input word以后，我們再定義一個叫做skip_window的參數，它代表著我們從當前input word的一側（左邊或右邊）選取詞的數量。如果我們設置skip_window=2，那么我們最終獲得窗口中的詞（包括inputword在內）就是[‘The’, ‘dog’，’barked’, ‘at’]。skip_window=2代表著選取左input word左側2個詞和右側2個詞進入我們的窗口，所以整個窗口大小span=2x2=4。另一個參數叫num_skips，它代表著我們從整個窗口中選取多少個不同的詞作為我們的outputword，當skip_window=2，num_skips=2時，我們將會得到兩組 (input word, output word) 形式的訓練數據，即 (‘dog’, ‘barked’)，(‘dog’, ‘the’)，也就是目標詞匯dog對應的原始語境。

神經網絡基于這些訓練數據將會輸出一個概率分布，這個概率代表著我們的詞典中的每個詞是output word的可能性。這句話有點繞，我們來看個栗子。第二步中我們在設置skip_window和num_skips=2的情況下獲得了兩組訓練數據。假如我們先拿一組數據 (‘dog’, ‘barked’) 來訓練神經網絡，那么模型通過學習這個訓練樣本，會告訴我們詞匯表中每個單詞是“barked”的概率大小。

模型的輸出概率代表著到我們詞典中每個詞有多大可能性跟input word同時出現。舉個栗子，如果我們向神經網絡模型中輸入一個單詞“Soviet“，那么最終模型的輸出概率中，像“Union”，”Russia“這種相關詞的概率將遠高于像”watermelon“，”kangaroo“非相關詞的概率。因為”Union“，”Russia“在文本中更大可能在”Soviet“的窗口中出現。我們將通過給神經網絡輸入文本中成對的單詞來訓練它完成上面所說的概率計算。下面的圖中給出了一些我們的訓練樣本的例子。我們選定句子“The quick brown fox jumps over lazy dog”，設定我們的窗口大小為2（window_size=2），也就是說我們僅選輸入詞前后各兩個詞和輸入詞進行組合。?
我們的模型將會從每對單詞出現的次數中習得統計結果。例如，我們的神經網絡可能會得到更多類似（“Soviet“，”Union“）這樣的訓練樣本對，而對于（”Soviet“，”Sasquatch“）這樣的組合卻看到的很少。因此，當我們的模型完成訓練后，給定一個單詞”Soviet“作為輸入，輸出的結果中”Union“或者”Russia“要比”Sasquatch“被賦予更高的概率。

模型的訓練
前面說過，Word2Vec之前詞語的編碼是one-hot，這樣我們訓練時把成千上萬個詞語對應的one-hot編碼輸入到神經網絡與隱層權重矩陣相乘，這種操作會消耗大量的計算資源并且不高效。想象一下，我們每個詞匯是1*10000的向量（10000個數中只有一個是1，其他為0），權重矩陣10000*128，需要計算10000*128次乘法和9999*128次加法，但實際上one-hot只是取了權重矩陣中的一行。可以結合下圖理解。?
?
為了解決這個問題，TensorFlow封裝了一個embedding_lookup函數

embed = tf.nn.embedding_lookup(embeddings, train_inputs)
1
函數返回以train_inputs為下標的權重矩陣embeddings中的行，這些行組成新的矩陣embed。例如上圖中，train_inputs就是3，返回的是[10, 12, 19]?
而實際上，我們要訓練的也即是這個embeddings

對于模型的訓練過程，我們參照下圖進行說明：?

假設我們有一個訓練樣本（fox, jumps），input word是fox（編碼是13），output word是jumps。權重矩陣也是embeddings是50000*128。訓練開始，使用均勻分布初始化embeddings，再使用embedding_lookup查找embeddings中行號為13的128維向量，這個向量表示fox。那么我們怎么優化這個向量使得其成為想要的word vector呢？Word2Vec使用了一種叫做負采樣（negative sampleing）的方法，具體來說，模型會隨機選取k個噪聲詞，這個例子中比如car，pen等與fox沒有關戲的詞，這樣，在輸出層，fox與噪聲次和jumps做softmax時，我們自然會想到應該將jumps對應的概率值提高，而噪聲詞低，TensorFlow封裝了NCE loss的函數，對其進行優化。不斷迭代，我們會得到fox 對應的128維的word vector。

附上一些參考資料：?
一文詳解 Word2vec 之 Skip-Gram 模型（結構篇）?
一文詳解 Word2vec 之 Skip-Gram 模型（訓練篇）?
一文詳解 Word2vec 之 Skip-Gram 模型（實現篇）?
word2vec 中的數學原理詳解

下面附上skip-gram模式的代碼：

import collections
import math
import os
import random
import zipfile
import numpy as np
import urllib
import tensorflow as tf

from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

url = 'http://mattmahoney.net/dc/'

def maybe_download(filename, expected_bytes):
? ? if not os.path.exists(filename):
? ? ? ? filename, _ = urllib.request.urlretrieve(url + filename, filename)
? ? statinfo = os.stat(filename)
? ? if statinfo.st_size == expected_bytes:
? ? ? ? print('found and verified', filename)
? ? else:
? ? ? ? print(statinfo.st_size)
? ? ? ? raise Exception('failed to verified ' + filename + '. can you get to it with a browser?')
? ? return filename

filename = maybe_download('text8.zip', 31344016)

def read_data(filename):
? ? with zipfile.ZipFile(filename) as f:
? ? ? ? data = tf.compat.as_str(f.read(f.namelist()[0])).split()
? ? # print(data)
? ? return data

words = read_data(filename)
print('Data size', len(words))

vocabulary_size = 50000

def build_dataset(words):
? ? count = [['UNK', -1]] ? ?#存儲單詞及對應出現的次數
? ? count.extend(collections.Counter(words).most_common(vocabulary_size - 1))
? ? dictionary = dict() ? ? ?#存儲單詞及對應的編號
? ? for word, _ in count:
? ? ? ? dictionary[word] = len(dictionary) ?#詞頻高的單詞編號小
? ? data = list() ? ?#將文章存儲為編號的形式
? ? 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()))
? ? return data, count, dictionary, reverse_dictionary

data, count, dictionary, reverse_dictionary = build_dataset(words)

del words

data_index = 0
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)
? ? labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)
? ? span = 2 * skip_window + 1
? ? buffer = collections.deque(maxlen=span)
? ? for _ in range(span):
? ? ? ? buffer.append(data[data_index])
? ? ? ? data_index = (data_index + 1) % len(data)
? ? for i in range(batch_size // num_skips):
? ? ? ? target = skip_window
? ? ? ? target_to_avoid = [ skip_window ]
? ? ? ? for j in range(num_skips):
? ? ? ? ? ? while target in target_to_avoid:
? ? ? ? ? ? ? ? target = random.randint(0, span - 1)
? ? ? ? ? ? target_to_avoid.append(target)
? ? ? ? ? ? batch[i * num_skips + j] = buffer[skip_window]
? ? ? ? ? ? labels[i * num_skips + j, 0] = buffer[target]
? ? ? ? buffer.append(data[data_index])
? ? ? ? data_index = (data_index + 1) % len(data)
? ? return batch, labels

# batch, labels = generate_batch(batch_size=8, num_skips=2, skip_window=1)
# for i in range(8):
# ? ? print('batch', batch[i], reverse_dictionary[batch[i]])
# ? ? print('couple', batch[i], reverse_dictionary[batch[i]], '->', labels[i, 0], reverse_dictionary[labels[i, 0]])

batch_size = 128
embedding_size = 128
skip_window = 1
num_skip = 2
valid_size = 16
valid_window = 100
valid_examples = np.random.choice(valid_window, valid_size, replace=False)
num_sample = 64 #噪聲詞數量

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)

? ? with tf.device('/cpu:0'):
? ? ? ? embeddings = tf.Variable(tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0))
? ? ? ? embed = tf.nn.embedding_lookup(embeddings, train_inputs) #函數作用上文解釋

? ? ? ? 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]))

? ? loss = tf.reduce_mean(tf.nn.nce_loss(weights=nce_weights,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?biases=nce_biases,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?labels=train_labels,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?inputs=embed,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?num_sampled=num_sample,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?num_classes=vocabulary_size))

? ? optimizer = tf.train.GradientDescentOptimizer(1.0).minimize(loss)

? ? #驗證相似度
? ? norm = tf.sqrt(tf.reduce_mean(tf.square(embeddings), 1, keep_dims=True))
? ? normalized_embeddings = embeddings / norm
? ? valid_embeddings = tf.nn.embedding_lookup(normalized_embeddings, valid_dataset)
? ? similarity = tf.matmul(valid_embeddings, normalized_embeddings, transpose_b=True)

? ? init = tf.global_variables_initializer()

num_steps = 100001

with tf.Session(graph=graph) as session:
? ? init.run()
? ? print('initialized')

? ? average_loss = 0
? ? for step in range(num_steps):
? ? ? ? batch_inputs, batch_labels = generate_batch(batch_size, num_skip, skip_window)
? ? ? ? feed_dict = {train_inputs: batch_inputs, train_labels: batch_labels}

? ? ? ? _, loss_val = session.run([optimizer, loss], feed_dict=feed_dict)
? ? ? ? average_loss += loss_val

? ? ? ? if step % 2000 == 0:
? ? ? ? ? ? if step > 0:
? ? ? ? ? ? ? ? average_loss /= 2000
? ? ? ? ? ? print('Average loss at step', step, ':', average_loss)
? ? ? ? ? ? average_loss = 0

? ? ? ? if step % 10000 == 0:
? ? ? ? ? ? sim = similarity.eval()
? ? ? ? ? ? for i in range(valid_size):
? ? ? ? ? ? ? ? valid_word = reverse_dictionary[valid_examples[i]]
? ? ? ? ? ? ? ? top_k = 8
? ? ? ? ? ? ? ? nearst = (-sim[i, :]).argsort()[1: top_k+1]
? ? ? ? ? ? ? ? log_str = "Nearst to %s:" % valid_word
? ? ? ? ? ? for k in range(top_k):
? ? ? ? ? ? ? ? close_word = reverse_dictionary[nearst[k]]
? ? ? ? ? ? ? ? log_str = "%s %s," % (log_str, close_word)
? ? ? ? ? ? print(log_str)
? ? final_embeddings = normalized_embeddings.eval()

def plot_with_labels(low_dim_embs, labels, filename='tsne.png'):
? ? assert low_dim_embs.shape[0] >= len(labels), "More labels than embeddings"
? ? 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 = TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000) #TSNE降維函數
plot_only = 100
low_dim_embs = tsne.fit_transform(final_embeddings[:plot_only, :])
labels = [reverse_dictionary[i] for i in range(plot_only)]
plot_with_labels(low_dim_embs, labels)
---------------------?
作者：hoohaa_?
來源：CSDN?
原文：https://blog.csdn.net/pnnngchg/article/details/79925462?
版權聲明：本文為博主原創文章，轉載請附上博文鏈接！

總結

以上是生活随笔為你收集整理的Word2Vec详解的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。