介绍

人类有能力理解单词并轻松地从中获取含义。然而，在当今世界，大多数任务都是由计算机执行的。例如，如果您想知道今天是晴天还是下雨天，则必须在 Google 中输入文本查询。现在的问题是，机器将如何频繁地理解和处理文本中呈现的如此大量的信息？答案是词嵌入。

Word Embeddings 基本上是向量（文本转换为数字），用于捕获单词的含义、各种上下文和语义关系。嵌入本质上是使用预定义字典将单词映射到其对应向量。

例如，

句子： It will rain heavily today.

字典：{“it”：[1,0,0,0,0]，“will”：[0,1,0,0,0]，“rain”：[0,0,1,0,0] , “ heavily ”: [0,0,0,1,0], “today”: [0,0,0,0,1]}

在这里，每个单词都被分配了一个唯一的向量（例如），以便区分所有单词。

Let the corpus comprise three sentences.

S1 = In monsoon, it will rain.

S2 = rain rain come again.

S3 = sun is visible in summer. In the monsoon, the sun is hidden by clouds.

Let N be the list of unique words = [‘monsoon’, ‘rain’, ‘come’, ‘again’, ‘sun’, ‘visible’, ‘summer’, ‘hidden’, ‘clouds’]

计数矩阵的维度将是 3X9，因为语料库中有 3 个文档和 9 个唯一词。
计数矩阵如下所示：

优点：由于只考虑单词的频率，因此计算成本较低。

缺点：由于计算只是基于计数并且没有考虑单词的上下文，因此该方法证明不太有用。
代码：

#Importing libraries
from sklearn.feature_extraction.text import CountVectorizer
import nltk 
from nltk.corpus import stopwords 
from nltk.tokenize import word_tokenize 

#Downloading stopwords and punkt packages
nltk.download('stopwords') 
nltk.download('punkt') 

#Initialising stopwords for english
set(stopwords.words('english')) 

#sample sentences
text = ["In monsoon, it will rain", "rain rain come again", "sun is visible in summer. In the monsoon, the sun is hidden by clouds"]

#set of stop words
stop_words = set(stopwords.words('english')) 
all_sentences = []

#Logic for removing stop words and obtaining filtered sentences from the list 

for i in range(len(text)):
  word_tokens[i] = word_tokenize(text[i]) 
  tokenized_sentence = []

  for j in word_tokens[i]: 
      if j not in stop_words: 
          tokenized_sentence.append(j) 
  all_sentences.append(" ".join(tokenized_sentence))

#Initialising the CountVectorizer
countvectorizer = CountVectorizer()

#Applying CountVectorizer to the list of sentences
X = countvectorizer.fit_transform(all_sentences)

#Converting output to array
result = X.toarray()

print("Sentences after removing stop words", all_sentences)
print("Count Vector:", result)

2.TF-IDF：

TF-IDF 代表词频-逆文档频率。 该方法是对 Count Vector 方法的即兴创作，因为特定单词的频率被考虑在整个语料库中，而不仅仅是单个文档。 主要思想是对某些文档非常具体的词给予更多的权重，而对更普遍且在大多数文档中出现的词给予较少的权重。

例如，诸如“is”、“the”、“and”之类的通用词会经常出现，而诸如“Donald Trump”或“Indira Gandhi”之类的词将特定于特定文档。

数学上，

词频 (TF) = 词条在文档中出现的次数 / 文档中词条的总数

逆文档频率 (IDF) = log(N/n) 其中 N 是文档总数，n 是一个术语出现的文档数。

考虑以下示例。
给出了两个文档——D1 和 D2。

TF(Today, Document 1) = 1/8

TF(Today, Document 2) = 1/8

TF(sunny, Document 1) = 4/8

IDF(Today) = log(2/2) = log(1) = 0

IDF(sunny) = log(2/1) = log(2) = 0.301

Therefore,

TF-IDF(Today, Document 1) = 1/8 * 0 = 0

TF-IDF(Today, Document 2) = 1/8 * 0 = 0

TF-IDF(sunny, Document 1) = 4/8 * 0.301 = 0.1505

从上面的计算可以看出，与文档 1 的上下文中的重要词“sunny”相比，常用词“Today”的权重较低。

优点：

它在计算上很容易。
文档中最重要的单词是通过基本计算提取的，不需要太多努力。

缺点：

它无法捕捉单词的语义，只能像词汇级别的特征一样工作。
代码：

from sklearn.feature_extraction.text import TfidfVectorizer 
import pandas as pd

#Declaring the list of sentences
documents = ['Today is sunny day', 'Today is rainy day']

#Initialising Tfidf Vectorizer
vectorizer = TfidfVectorizer()

#Fitting the Vectorizer to the list
X = vectorizer.fit_transform(documents)
print(X)

#Printing the feature names
print(vectorizer.get_feature_names()) 

matrix = X.todense()
tfidf_list = matrix.tolist()
tfidf_df = pd.DataFrame(tfidf_list, columns = vectorizer.get_feature_names())

print(tfidf_df)

3.Word2Vec：

Word2Vec 是一种基于预测的词嵌入方法。 与确定性方法不同，它是一个浅层的两层神经网络，能够预测单词之间的语义和相似性。 Word2Vec 是两种不同模型的组合——（i）CBOW（连续词袋）和（ii）Skip-gram。

模型概述 – CBOW（连续词袋）和 Skip-gram。

3.1 CBOW（连续词袋）：

该模型是一个浅层神经网络，可以在给定上下文的情况下预测单词的概率。 这里，上下文是指围绕要预测的单词的单词的输入。
CBOW模型的架构：

作为第一步，输入是通过为给定文本形成一个词袋来创建的。
例如，

Sentence 1 = All work and no play make Jack a dull boy.

Sentence 2 = Jack and Jill went up the hill.

Bag of Words: {“All”:1, “work”:1, “no”:1, “play”:1, “makes”:1, “Jack”:2, “dull”:1, “boy”:1, “Jill”:1, “went”:1, “up”:1, “hill”:1} (after removing the stop words)

这个由单词及其出现频率组成的输入作为向量发送到输入层。对于 X 个单词，输入将是 X[1XV] 个向量，其中 V 是向量的最大长度。

接下来，输入隐藏层矩阵由维数 VXN 组成，其中 N 是表示单词的维数。输出隐藏层矩阵由维数 NXV 组成。在这里，这些值是通过将输入乘以隐藏输入权重来计算的。

在输出层，通过将隐藏输入乘以隐藏输出权重来计算输出。在隐藏层和输出层之间计算的权重给出了单词的表示。作为一个连续的中间步骤，通过对输出和目标值之间计算的误差使用反向传播来调整权重。
优点：

与确定性方法相比，概率性方法给出了更好的结果。
由于不需要计算巨大的矩阵，因此内存需求较少。
缺点：

优化非常重要，否则培训将需要很长时间才能完成。

3.2 Skip-gram ：

Skip-gram 模型预测给定单词的上下文，与 CBOW 所做的正好相反。 Skip-gram 模型的架构：

输入层大小：[1XV]，输入隐藏权重矩阵大小：[VXN]，输出隐藏权重矩阵：[NXV]，输出层大小：C[1XV]

模型的输入和直到隐藏层的进一步步骤将类似于 CBOW。 输出目标变量的数量取决于上下文窗口的大小。 例如，如果上下文窗口的大小为 2，那么将有四个目标变量，两个词在给定词之前，两个词在给定词之后。

将针对四个目标变量计算四个单独的误差，并通过执行元素相加获得最终向量。 然后反向传播这个最终向量以更新权重。 对于训练，输入和隐藏层之间的权重用于单词表示。

优点：

Skip-gram 模型可以捕获单词的不同上下文信息，因为每个上下文都有不同的向量表示。
对于不常用的术语更准确，并且适用于更大的数据库。
缺点：

它需要更多的 内存 进行处理。
代码：

要使用 genism 库中预训练的 Word2Vec 模型：

import gensim 
import gensim.downloader as api
from gensim.models.keyedvectors import KeyedVectors

#loading pretrained model
nlp_w2v = api.load("word2vec-google-news-300") 

#save the Word2Vec model
nlp_w2v.wv.save_word2vec_format('model.bin', binary=True)

#load the Word2Vec model 
model = KeyedVectors.load_word2vec_format('model.bin', binary=True)

#Printing the most similar words to New York from vocabulary of pretrained model
model.most_similar('New_York')

从头开始训练 Word2Vec 模型：

import gensim 
'''
Data for training Word2Vec
train: A data frame comprising of text samples
'''

#training data
corpus = train

#creates a list for a list of words for every training sample
w2v_corpus = []
for document in corpus:
   w2v_words = document.split()
   w2v_grams = [" ".join(w2v_words[i:i+1]) 
               for i in range(0, len(w2v_words), 1)]
   w2v_corpus.append(w2v_grams)

#initialising and training the custom Word2Vec model 
'''
size: dimensions of word embeddings 
window: context window for words 
min_count: words which appear less number of times than this count will be ignored 
sg: To choose skip-gram model 
iter: Number of epochs for training
'''

word2vec_model = gensim.models.word2vec.Word2Vec(w2v_corpus, size=300,   
            window=8, min_count=1, sg=1, iter=30)

#vector size of the model
print(word2vec_model.vector_size)

#vocabulary contained by the model
print(len(word2vec_model.wv.vocab))

4.GloVE:

GloVe 代表词表示的全局向量。 该算法是对 Word2Vec 方法的改进，因为它考虑全局统计而不是局部统计。 在这里，全局统计数据意味着从整个语料库中考虑的单词。 GloVe 基本上试图解释特定单词对在文档中出现的频率。 为此，构建了一个共现矩阵，该矩阵将表示特定单词相对于另一个单词的存在。

例如，

Corpus – It is rainy today, tomorrow it will be sunny and the day after will be windy.

上面的矩阵表示一个共现矩阵，其值表示在给定示例语料库中一起出现的每对单词的计数。

在计算给定“today”、p(rainy/today) 和给定“tomorrow”、p(rainy/tomorrow) 的单词“rainy”的出现概率后，结果是与“rainy”最相关的单词 与“明天”相比，“今天”是“今天”。

代码：

#Import statements
from numpy import array
from numpy import asarray
from numpy import zeros
from keras.preprocessing.text import Tokenizer 

#Download the pretrained GloVe data files
!wget http://nlp.stanford.edu/data/glove.6B.zip

#Unzipping the zipped folder
!unzip glove*.zip

#Initialising a tokenizer and fitting it on the training dataset
'''
train: a dataframe comprising of rows containing text data
'''
tokenizer = Tokenizer(num_words=5000)
tokenizer.fit_on_texts(train)

#Creating a dictionary to store the embeddings
embeddings_dictionary = dict()

#Opening GloVe file
glove_file = open('glove.6B.50d.txt', encoding="utf8")

#Filling the dictionary of embeddings by reading data from the GloVe file
for line in glove_file:
    records = line.split()
    word = records[0]
    vector_dimensions = asarray(records[1:], dtype='float32')
    embeddings_dictionary[word] = vector_dimensions
glove_file.close()

#Parsing through all the words in the input dataset and fetching their corresponding vectors from the dictionary and storing them in a matrix 
embedding_matrix = zeros((vocab_size, 50))
for word, index in tokenizer.word_index.items():
    embedding_vector = embeddings_dictionary.get(word)
    if embedding_vector is not None:
        embedding_matrix[index] = embedding_vector

#Displaying embedding matrix 
print(embedding_matrix) 

结论：

在这篇博客中，我们回顾了一些方法——Count Vector、TF-IDF、Word2Vec 和 GloVe，用于从原始文本数据创建词嵌入。 预处理文本然后发送预处理数据以创建词嵌入总是一个好习惯。 作为进一步的步骤，这些词嵌入可以发送到机器学习或深度学习模型，用于各种任务，例如文本分类或机器翻译。