word2vec

one-hot:

文本：在nlp任务中，首先需要考虑词如何在计算机中表示

将句子划分为以下词语：

词库 在 nlp 任务 中 首先 需要 考虑 词 如何 在 计算机 表示

用one-hot表示：

 one-hot的维度由词库的大小决定

在词库中，在出现该词的地方标记为1，其它地方标记为0，这样，每一个词就唯一表示为一个向量，但是这种表示方式受限于词库的大小，当词库过于庞大时，每一个one-hot向量的维度也会很大，对于计算机的存储和计算来说是灾难性的。而且这种表示无法度量词语之间的相似性。

用词向量表示词语

词向量表示就是用一串数字表示词语

 词向量的每个维度由一个实数表示，因此有限的维度可以表示无数的词语

12维的one-hot可以表示12个词语，12维的词向量可以表示无数的词语。

词向量如何获取

先讲一下word2vec的一个重要假设

文本中离得越近的词语相似度越高

例如一篇文章中，一句话里面出现的词语相比在两个段落之间出现的词语，前者的相似度更高。

计算词向量矩阵的两种方法：CBOW、skip-gram

CBOW

CBOW是用上下文词预测中心词，相反skip-gram是用中心词预测上下文词。现在用的比较多的是skip-gram

那一个中心词周围哪些词语可以作为中心词呢？因此我们需要定义一个界定范围，然后最大化这些词语和中心词共同出现的概率，这样就可以得到词向量。

当界定范围为2时，中心词和上下文词如图所示：

绿色部分为非上下文词，按照之前定义的获取词向量时，只需考虑上下文词，但是优化时，我们不仅要考虑上下文词，而且还要考虑非上下文词，但是当语料库非常大的时候，非上下文词太多了，会导致计算灾难，因此只采样部分负样本，负样本即非上下文词。在具体代码实战时，需要设置窗口大小（界定范围）、负采样两个参数。

评估词向量：

方法一：输出与特定词语的相关度比较高的词语

方法二：可视化

方法三：类比实验，例如：国王-王后=男人-女人

词向量的用途

1、主题聚类

2、情感分析

3、信息检索

......

word2vec的缺点：

我们人类理解语言是从理解词语开始的，然后经过词语重组，得到句子的意思。计算机是不理解人类的语言的，若想计算机理解人类的语言，就需要先理解词语

那计算机如何理解词语呢

我们知道，计算机只能理解数字，因此我们需要将词语转化为数字，计算机对词语的理解就是计算机对空间和位置的理解

CBOW(Continuous Bag of Words Model)

skip-gram ( Skip-Gram Model)

获取词向量的代码

import numpy as np
from collections import defaultdict
 
 
class word2vec():
 
    def __init__(self):
        self.n = settings['n']
        self.lr = settings['learning_rate']
        self.epochs = settings['epochs']
        self.window = settings['window_size']
 
    def generate_training_data(self, settings, corpus):
        """
        得到训练数据
        """
 
        #defaultdict(int)  一个字典，当所访问的键不存在时，用int类型实例化一个默认值
        word_counts = defaultdict(int)
 
        #遍历语料库corpus
        for row in corpus:
            for word in row:
                #统计每个单词出现的次数
                word_counts[word] += 1
 
        # 词汇表的长度
        self.v_count = len(word_counts.keys())
        # 在词汇表中的单词组成的列表
        self.words_list = list(word_counts.keys())
        # 以词汇表中单词为key，索引为value的字典数据
        self.word_index = dict((word, i) for i, word in enumerate(self.words_list))
        #以索引为key，以词汇表中单词为value的字典数据
        self.index_word = dict((i, word) for i, word in enumerate(self.words_list))
 
        training_data = []
 
        for sentence in corpus:
            sent_len = len(sentence)
 
            for i, word in enumerate(sentence):
 
                w_target = self.word2onehot(sentence[i])
 
                w_context = []
 
                for j in range(i - self.window, i + self.window):
                    if j != i and j <= sent_len - 1 and j >= 0:
                        w_context.append(self.word2onehot(sentence[j]))
 
                training_data.append([w_target, w_context])
 
        return np.array(training_data)
 
    def word2onehot(self, word):
 
        #将词用onehot编码
 
        word_vec = [0 for i in range(0, self.v_count)]
 
        word_index = self.word_index[word]
 
        word_vec[word_index] = 1
 
        return word_vec
 
    def train(self, training_data):
 
 
        #随机化参数w1,w2
        self.w1 = np.random.uniform(-1, 1, (self.v_count, self.n))
 
        self.w2 = np.random.uniform(-1, 1, (self.n, self.v_count))
 
        for i in range(self.epochs):
 
            self.loss = 0
 
            # w_t 是表示目标词的one-hot向量
            #w_t -> w_target,w_c ->w_context
            for w_t, w_c in training_data:
 
                #前向传播
                y_pred, h, u = self.forward(w_t)
 
                #计算误差
                EI = np.sum([np.subtract(y_pred, word) for word in w_c], axis=0)
 
                #反向传播，更新参数
                self.backprop(EI, h, w_t)
 
                #计算总损失
                self.loss += -np.sum([u[word.index(1)] for word in w_c]) + len(w_c) * np.log(np.sum(np.exp(u)))
 
            print('Epoch:', i, "Loss:", self.loss)
 
    def forward(self, x):
        """
        前向传播
        """
 
        h = np.dot(self.w1.T, x)
 
        u = np.dot(self.w2.T, h)
 
        y_c = self.softmax(u)
 
        return y_c, h, u
 
 
    def softmax(self, x):
        """
        """
        e_x = np.exp(x - np.max(x))
 
        return e_x / np.sum(e_x)
 
 
    def backprop(self, e, h, x):
 
        d1_dw2 = np.outer(h, e)
        d1_dw1 = np.outer(x, np.dot(self.w2, e.T))
 
        self.w1 = self.w1 - (self.lr * d1_dw1)
        self.w2 = self.w2 - (self.lr * d1_dw2)
 
    def word_vec(self, word):
 
        """
        获取词向量
        通过获取词的索引直接在权重向量中找
        """
 
        w_index = self.word_index[word]
        v_w = self.w1[w_index]
 
        return v_w
 
    def vec_sim(self, word, top_n):
        """
        找相似的词
        """
 
        v_w1 = self.word_vec(word)
        word_sim = {}
 
        for i in range(self.v_count):
            v_w2 = self.w1[i]
            theta_sum = np.dot(v_w1, v_w2)
 
            #np.linalg.norm(v_w1) 求范数 默认为2范数，即平方和的二次开方
            theta_den = np.linalg.norm(v_w1) * np.linalg.norm(v_w2)
            theta = theta_sum / theta_den
 
            word = self.index_word[i]
            word_sim[word] = theta
 
        words_sorted = sorted(word_sim.items(), key=lambda kv: kv[1], reverse=True)
 
        for word, sim in words_sorted[:top_n]:
            print(word, sim)
 
    def get_w(self):
        w1 = self.w1
        return  w1
#超参数
settings = {
    'window_size': 2,   #窗口尺寸 m
    #单词嵌入(word embedding)的维度,维度也是隐藏层的大小。
    'n': 10,
    'epochs': 50,         #表示遍历整个样本的次数。在每个epoch中，我们循环通过一遍训练集的样本。
    'learning_rate':0.01 #学习率
}
 
#数据准备
text = "natural language processing and machine learning is fun and exciting"
#按照单词间的空格对我们的语料库进行分词
corpus = [[word.lower() for word in text.split()]]
print(corpus)
 
#初始化一个word2vec对象
w2v = word2vec()
 
training_data = w2v.generate_training_data(settings,corpus)
 
#训练
w2v.train(training_data)
 
# 获取词的向量
word = "machine"
vec = w2v.word_vec(word)
print(word, vec)
 
# 找相似的词
w2v.vec_sim("machine", 3)