终于把 word2vec 的原理搞清楚了！

word2vec 是一种广泛用于自然语言处理的技术，主要目的是将单词转换为词向量（将单词表示为数字向量）。这些词向量能够反映不同词语的相似性，使得语义上或语法上相近的词语在向量空间中也相互接近。

word2vec 是自然语言处理领域的一种基础技术，广泛应用于文本分析、机器翻译、情感分析等多种场景。

word2vec 的工作原理

如下图所示，其中 N 为 2，对于单词 word，它的上下文词为 machine、learning、 a 和 method。

• CBOW（连续词袋模型），一种根据上下文词预测当前词的模型。

• Skip-Gram，一种根据当前单词预测上下文单词的模型。

‍

下面，我们来看一下具体的模型架构。

• 输入层

  模型的输入为单词对应的 one-hot 编码。

  其中 CBOW 模型的输入是某个目标词周围的上下文单词的 one-hot 编码。而 Skip-gram 模型的输入是目标词的 one-hot 编码。

• 隐藏层

  输入层直接连接到隐藏层（通过权重矩阵），没有非线性激活函数。隐藏层的输出是当前单词的词向量表示。

• 输出层

  接下来是具有 Softmax 激活的线性层。

CBOW 和 Skip-Gram 模型的区别在于输入词的数量。CBOW 模型采用多个词，每个词经过相同的嵌入层，然后对词嵌入向量进行平均，然后进入线性层。而 Skip-Gram 模型则采用单个词。

Skip-Gram 模型的前向传播过程详解

对中心词和外部词进行编码

此中心词和相应外部词将用于训练模型。

1. import re
   import numpy as np
   
   WINDOW_SIZE = 2
   
   def  create_vocabulary ( training_data ): 
       """ 通过标记训练数据返回排序后的单词列表。"""
       all_words = ' ' .join(training_data).lower() 
       all_words = all_words.replace( '.' , '' ) 
       all_words = all_words.split( ' ' ) 
       vocab = list ( set (all_words)) 
       vocab.sort() 
       return vocab 
   
   
   def one_hot(word, vocab, vocab_size ): 
       """ 返回单词的独热编码向量。"""
       one_hot = [0]*vocab_size 
       pos = vocab.index(word) 
       one_hot[pos] = 1
       one_hot = np.array(one_hot) 
       return one_hot 
   
   
   def  create_vector_word_map (vocab, vocab_size ): 
        """ 返回一个词典映射，将独热向量转换回单词。"""
        vec_to_word = { str (one_hot(word, vocab, vocab_size)): word for word in vocab} 
        return vec_to_word
   
   def encode_training_data(training_data, vocab_size, window_size):
       """ Encode the center and outside words as one-hot vectors."""
   
       encoded_training_data = []
   
       for sentence in training_data:
   
           # Tokenize the sentence
           tokens = re.sub(r'[^\w\s]', '', sentence).lower().split(' ')
   
           # Encode each center word and its surrounding context words
           for word_pos, word in enumerate(tokens):
               center_word = one_hot(word, vocab, vocab_size)
               for outside_pos in range(word_pos-window_size, 
                                        word_pos+window_size+1):
                   if (outside_pos >= 0) and (outside_pos < len(tokens)) \
                   and (outside_pos != word_pos):
                       outside_word=one_hot(tokens[outside_pos],
                                                    vocab,
                                                    vocab_size)
                       encoded_training_data.append([center_word, outside_word])
       return encoded_training_data
   
   
   def print_training_encodings(encoded_training_data, vocab, vec_to_word):
       """ Print the encodings for each (center word - outside words) set."""
       
       max_len = len(max(vocab, key=len))
   
       for num, (cw_vector, ow_vectors) in enumerate(encoded_training_data):
   
           cw = vec_to_word[str(cw_vector)]
           ow = vec_to_word[str(ow_vectors)]
   
           print(f'Center Word #{num}: {cw} {cw_vector}')
           print(f'Outside Words: {ow} {ow_vectors}')
   
   
   # Create training data
   training_data = ['The dog chased the cat around the garden.']
   
   # Encode training data
   vocab = create_vocabulary(training_data)
   vocab_size = len(vocab)
   vec_to_word = create_vector_word_map(vocab, vocab_size)
   encoded_training_data = encode_training_data(training_data,
                                                vocab_size,
                                                window_size=WINDOW_SIZE)
   # # Print out results
   print_training_encodings(encoded_training_data, vocab, vec_to_word)

   

计算隐藏层向量
一旦对中心词及其各自的外部词进行编码，就可以将中心词逐个输入网络以完成其前向传递。‍



EMBEDDING_DIM = 3
# Calculate the hidden layer vector
x = encoded_training_data[0][0]
w_center = np.random.rand(vocab_size, EMBEDDING_DIM)
h = np.dot(x, w_center)

# Print the results
print(f'Center word, w(t): {vec_to_word[str(x)]}\n')
print(f'Input vector, x:   {x}\n')
print(f'W_center: \n\n{w_center}\n')
print(f'Hidden layer, h:   {h}\n')

计算网络输出
前向传递的下一阶段是计算隐藏层向量 h 和外部词权重矩阵 W_outside 的点积。这将产生原始网络输出 u，即 V 维的 logits 向量。下一阶段，softmax 函数会将这些输出转换为“概率”值。



# Calculate the raw network outputs
w_outside = np.random.rand(EMBEDDING_DIM, vocab_size)
u = np.dot(h, w_outside)


# Print the results
print(f'Hidden layer, h:   {h}\n')
print(f'W_outside: \n\n{w_outside}\n')
print(f'Raw network outputs (logits), u:   {u}\n')

每个元素的值对应于一个单词属于给定中心词 x 的集合外部单词的“概率” 。

1. def softmax(u):
       """ Return the softmax values for a vector u."""
       values = np.exp(u)/np.sum(np.exp(u))
       return values
   
   
   def find_outside_words(y_pred, vocab):
       # Get a sorted list of softmax scores
       sorted_y_pred = y_pred.copy()
       sorted_y_pred = sorted_y_pred[::-1]
       top_score = sorted_y_pred[:1]
       index = np.where(y_pred == top_score)[0][0]
       print(index)
       word = vocab[index]
       return word
   
   # Calculate the softmax outputs
   y_pred = softmax(u)
   outside_word = find_outside_words(y_pred, vocab)
   # Print the results
   print(f'Raw network outputs (logits), u:   {u}\n')
   print(f'Softmax outputs, y_pred:           {y_pred}\n')
   print(f'Outside words:                     {outside_word}')
   

适用场景

性能

资源消耗