自然语言处理 - 词向量

Dallas98

词向量

在自然语言处理（NLP）中，词向量将单词按照含义编码成向量，从而更好地进行语言建模和特征学习。词向量经常作为下游 NLP 任务的基本组件，出现在文本分类、翻译、问答、推荐等各种任务模型中；此外，我们也可以通过多种方式，训练自己的词向量。（for more, see here）

通过本次实验，你将进一步体会词向量的特性，以及词向量模型的加载使用。

实验环境

你可以使用任何你自己熟悉的 python 环境来完成实验，我们提供了 conda 环境配置文件 environment.yml，里面给出了一些必要的环境依赖，请确保你安装了这些依赖。如果你需要使用其他 python 扩展包可自行安装。（本次实验二所需的环境依赖在实验一的环境中都有，因此你也可以跳过下面的虚拟环境创建步骤，直接启用实验一的环境进行实验。）

这里我们推荐使用 conda 来创建管理 python 虚拟环境。

  1. 下载安装 conda。你可以选择安装已经预装了许多常用扩展的 Anaconda 或者没有任何预装的 Miniconda。

  2. 打开 Terminal（Windows 可使用 Anaconda Prompt） 并进入当前文件目录，输入以下命令来创建一个名为 nlplab2 的虚拟环境并启用。

conda env create -f environment.yml
conda activate nlplab2
  1. 使用 jupyter-notebook 打开 lab2.ipynb 文件开始下面的实验。
jupyter-notebook lab2.ipynb

实验过程

加载词向量

加载预训练好的词向量。这里我们使用 GLoVe 在中文维基百科语料训练的词向量，词向量维度为 50，词汇量 83W+。为了减少后续的计算时间，我们使用 pickle 模块将词向量模型保存到二进制文件，你可以在 data 目录下看到它。运行下面的代码加载处理后的 50 维词向量。

Notes：

  • 选择 GLoVe 词向量是由于它在词语类比任务上有着更优的特性。
  • GloVe 官网 提供的都是英文的预训练词向量，中文词向量需要自己用语料库训练。具体需要你到维基中文下载网页 zhwiki 下载中文维基百科语料 xml 文件；完成解析抽取、繁体化简、符号停用词过滤、分词等相关处理；下载 GloVe 官方源码 编译预训练。
  • 此处无需你完成整个词向量训练过程，我们已替你训练好，直接加载即可。
import pickle
import numpy as np

with open(\'data/glove.zh.50.pickle\', mode=\'rb\') as f:
    word2vec_map = pickle.load(f)
word2index = dict(zip(word2vec_map.keys(), range(len(word2vec_map))))
index2word = dict(zip(word2index.values(), word2index.keys()))
word_matrix = np.array(list(word2vec_map.values()))
del word2vec_map
print(\'len(word2index):\', len(word2index))
print(\'len(index2word):\', len(index2word))
print(\'word_matrix.shape:\', word_matrix.shape)

len(word2index): 831144
len(index2word): 831144
word_matrix.shape: (831144, 50)

这里我们得到三个变量：

  • word2index：一个字典，以词（str）为 key，以一个 [0, 831144) 间的整数（int）为 value，词语到下标的映射；
  • index2word：一个字典，以 [0, 831144) 间的整数（int）为 key，以对应的词（str）为 value，下标到词语的映射；
  • word_matrix：一个维度为 (831144, 50) 的 numpy.ndarray 矩阵，第 i 行为下标为 i 的词对应的词向量。
    因此，一个词语 word 的词向量可以通过 word_matrix[word2index[word]] 取得，例如：
word_matrix[word2index[\'中科大\']]

array([ 0.476694,  0.012429,  1.334308,  0.833337,  0.422843,  0.404001,
       -0.286563,  0.277617,  0.78868 ,  0.235541,  0.119859,  0.210273,
       -0.294097, -0.157735,  0.008777,  0.902468, -0.244504,  0.116923,
        0.847188, -0.549439,  0.086888, -0.533772, -0.649807, -0.1344  ,
        0.6017  , -0.178695, -0.423312, -0.3307  ,  0.364139, -0.012755,
        0.011284,  0.570228,  0.600845,  0.154449, -0.293372,  0.421692,
        0.274871,  0.700706, -0.160058,  0.345218, -1.173997, -0.345282,
       -0.490619, -0.787566,  0.912973, -0.113094,  0.091646, -0.316972,
        0.962285,  0.372473])

one-hot编码就是保证每个样本中的单个特征只有1位处于状态1，其他的都是0。独热编码即 One-Hot Encoding，又称一位有效编码，其方法是使用N位状态寄存器来对N个状态进行编码，每个状态都由他独立的寄存器位，并且在任意时候，其中只有一位有效。one-hot向量将类别变量转换为机器学习算法易于利用的一种形式的过程，这个向量的表示为一项属性的特征向量，也就是同一时间只有一个激活点（不为0），这个向量只有一个特征是不为0的，其他都是0，特别稀疏。

相比较于词的独热编码向量，fastText，GloVe等词向量包含有更多的信息，也可以更好的表达不同词语间的相似关系。

下面我们来看看如何使用这些词向量来计算两个词语间的相似程度。

余弦相似度（Cosine Similarity）

为了衡量两个词语间的相似程度，我们需要一种合适的计算两个向量间相似程度的方法。给定两个向量 \(\mathbf{u}\) 和 \(\mathbf{v}\)，余弦相似度定义为：

\[\text{CosineSimilarity}(\mathbf{u}, \mathbf{v}) = cos(\theta) = \frac{\mathbf{u} \cdot \mathbf{v}}{\|\mathbf{u}\| \|\mathbf{v}\|} = \frac{\sum_{i=1}^d u_i v_i}{\sqrt{\sum_{i=1}^d u_i^2} \sqrt{\sum_{i=1}^d v_i^2}} \]

其中 \(\mathbf{u} \cdot \mathbf{v}\) 为两个向量 \(\mathbf{u}\) 和 \(\mathbf{v}\) 间的点积，\(\theta\) 为两个向量 \(\mathbf{u}\) 和 \(\mathbf{v}\) 间的夹角，\(\|\mathbf{u}\|\) 是向量 \(\mathbf{u}\) 的 L2 范数，\(d\) 为向量的维数。

余弦相似度的大小取决于两个向量间的夹角的大小，如果 \(\mathbf{u}\) 和 \(\mathbf{v}\) 非常相似余弦相似度的值就非常接近1。

下面请你来实现函数 cosine_similarity 用以计算向量间的余弦相似度。

注意，上面公式给出的是两个向量间余弦相似度的计算过程，也可以认为是一个样本间的计算，即向量 \(\mathbf{u}\) 和向量 \(\mathbf{v}\) 计算得到一个浮点数结果 \(w\)。但为了后续可以进行快速的并行计算，这里要求你的实现可以进行批量处理，即多个不同的向量 \(\mathbf{u}\) 组成的矩阵 \(\mathbf{U} \in \mathbb{R}^{m \times d}\) 和多个不同的向量 \(\mathbf{v}\) 组成的矩阵 \(\mathbf{V} \in \mathbb{R}^{n \times d}\) 计算的到一个结果矩阵 \(\mathbf{W} \in \mathbb{R}^{m \times n}\)，结果矩阵 \(\mathbf{W}\) 的第 \(i\) 行第 \(j\) 列的数值 \(w_{ij}\) 为矩阵 \(\mathbf{U}\) 的第 \(i\) 行向量 \(\mathbf{u}_i\) 和矩阵 \(\mathbf{V}\) 的第 \(j\) 行向量 \(\mathbf{v}_j\) 的余弦相似度值。

Assignment Notes:

  • 仔细阅读下面几个 numpy 函数的说明文档，这些函数可能对你有帮助：

  • 如果你对 numpy 的广播（Broadcasting）机制不了解，可以参阅这些资料：

  • 为了保证你的实现是向量化的批量运算，请不要使用任何 for 循环来逐项计算。合理使用上面参考资料中的方法你可以只用一行代码就完成计算。

def cosine_similarity(u, v):
    \'\'\'
    计算向量间的余弦相似度。

    Args:
        u (numpy.ndarray): 维度为(m, d)的矩阵；
        v (numpy.ndarray): 维度为(n, d)的矩阵。

    Returns:
        (numpy.ndarray): 维度为(m, n)的矩阵，此矩阵第i行第j列的数值为矩阵u的第i行
            和矩阵v的第j行这两个向量依据上面的定义计算出的余弦相似度。
    \'\'\'
    ###### 开始 ######
    
    ### np.dot 求点积
    ### np.linalg.norm 求范数
    
    a = u
    b = v.T
    c = np.dot(a,b)
    d = np.linalg.norm(a,ord=2,axis=1,keepdims=True)
    e = np.linalg.norm(b,ord=2,axis=0,keepdims=True)
    mm = np.dot(d,e)
    return np.divide(c,mm)
    ###### 结束 ######

运行下面的测试，你应该得到如下结果：

mat1.shape: (3, 50)
mat2.shape: (2, 50)
mat3.shape: (3, 2)
array([[0.73747626, 0.3755256 ],
       [0.68657858, 0.40745768],
       [0.13122132, 0.75253873]])

father1 = word_matrix[word2index[\'爸爸\']]
mother1 = word_matrix[word2index[\'妈妈\']]
school1 = word_matrix[word2index[\'学校\']]

father2 = word_matrix[word2index[\'老爸\']]
school2 = word_matrix[word2index[\'校园\']]

mat1 = np.array([father1, mother1, school1])
mat2 = np.array([father2, school2])
print(\'mat1.shape:\', mat1.shape)
print(\'mat2.shape:\', mat2.shape)

mat3 = cosine_similarity(mat1, mat2)
print(\'mat3.shape:\', mat3.shape)
mat3

mat1.shape: (3, 50)
mat2.shape: (2, 50)
mat3.shape: (3, 2)





array([[0.73747626, 0.3755256 ],
       [0.68657858, 0.40745768],
       [0.13122132, 0.75253873]])

可以看到，这个例子中结果矩阵第1行第1列（“爸爸”和“老爸”的相似度）以及第3行第2列（“学校”和“校园”相似度）都有相对较高的余弦相似度数值。

最相似的词语

有了词向量间相似度的度量方法，我们便可以看看与某个词最相似的词语都有哪些。下面请你来实现 top_n_similarity 函数，给定一个词，返回与其最相似的 n 个词及其相似度。任意一个词一定和它自己是最相似的，请将自身排除在外。

Assignment Notes:

  • 想想如何充分利用你上面实现的可进行高效批量运算的 cosine_similarity 函数；
  • 仔细阅读下面的 numpy 函数的说明文档，这些函数可能对你有帮助：
  • 实现合理的话单次调用用时应该在数秒钟，甚至不到1秒钟。
def top_n_similarity(word, n, word2index, index2word, word_matrix):
    \'\'\'
    给定一个词，依据词向量间的余弦相似度找到与其最相似的前n个词并返回。

    Args:
        word (str): 给定的词；
        n (int): 需要返回的最相似词的个数；
        word2index (dict[str, int]): 词语到下标的映射；
        index2word (dict[int, str])：下标到词语的映射；
        word_matrix (numpy.ndarray)：词向量组成的矩阵。

    Returns:
        (dict[str, float]): 找到的n个词及其相似度，一个以词为key，以相似度为
            value的字典。
    \'\'\'
    if word not in word2index:
        raise ValueError(\'Word {} not in the vocabulary.\'.format(word))
    ###### 开始 ######
    
    mydict=dict()
    #取出该单词的词向量，并转换为1维向量
    word1 = word_matrix[word2index[word]]
    mat1 = np.array([word1])
    #mat1 = np.expand_dims(word1,axis=0)
    
    #用该向量与原词组方程求相似度，得到该单词与所有词的相似度向量
    ans=cosine_similarity(mat1,word_matrix)
    
    #对该向量进行排序，得到其下标排序结果
    ans1=np.argsort(-ans)
    
    #将向量降维成数组
    ans=np.squeeze(ans)
    ans1=np.squeeze(ans1)
    
    for i in range(n):
        mydict[index2word[ans1[i+1]]]=ans[ans1[i+1]]
    return mydict
    
    ###### 结束 ######

运行下面的测试，你应该得到如下结果：

{\'维也纳\': 0.8026402573563235,
 \'柏林\': 0.789617648409123,
 \'法国巴黎\': 0.788222576783984,
 \'法国\': 0.783072750843146,
 \'布鲁塞尔\': 0.7728576184665334,
 \'里昂\': 0.7655693234781406,
 \'伦敦\': 0.76422517970406,
 \'斯特拉斯堡\': 0.7464075209702475,
 \'日内瓦\': 0.7349832595389842,
 \'路易\': 0.7206136726368307}

%%time
top_n_similarity(\'巴黎\', 10, word2index, index2word, word_matrix)

Wall time: 651 ms





{\'维也纳\': 0.8026402573563235,
 \'柏林\': 0.7896176484091229,
 \'法国巴黎\': 0.7882225767839838,
 \'法国\': 0.7830727508431462,
 \'布鲁塞尔\': 0.7728576184665333,
 \'里昂\': 0.7655693234781408,
 \'伦敦\': 0.7642251797040602,
 \'斯特拉斯堡\': 0.7464075209702475,
 \'日内瓦\': 0.7349832595389842,
 \'路易\': 0.7206136726368307}

下面请发挥你的想象，任意选取你感兴趣的词语，看看哪些词与它相似，以及返回的结果是否合理。英文请使用小写。

word = \'太阳\'
top_n_similarity(word, 10, word2index, index2word, word_matrix)

{\'地球\': 0.8346179490851815,
 \'金星\': 0.8221919998313647,
 \'星\': 0.8163960486983992,
 \'月亮\': 0.8154737751842294,
 \'天空\': 0.7928664125367684,
 \'行星\': 0.750207872730994,
 \'火星\': 0.7497908278425455,
 \'一颗\': 0.746478634718834,
 \'宇宙\': 0.7345393772157445,
 \'星星\': 0.7298035233569619}

词语类比任务（Word Analogy Task）

在词语类比任务中，我们要完成类似这样一个任务：a 对于 b 相当于 c 对于____。举例来说，我们要完成一句话，巴黎对于法国相当于北京对于____？

巴黎与法国两个词之间是有语义关系的，巴黎是法国的首都，那么根据第三个词北京，我们可以推断出空白处应该填中国。

cDOmfx.jpg

根据上图中的关系我们可以得到：

\[\mathbf{v}_{法国} - \mathbf{v}_{巴黎} \approx \mathbf{v}_{中国} - \mathbf{v}_{北京} \]

即：

\[\mathbf{v}_{法国} - \mathbf{v}_{巴黎} + \mathbf{v}_{北京} \approx \mathbf{v}_{中国} \]

因此，对于我们需要找到，a 对于 b 相当于 c 对于____这样一个任务，我们需要找到最适合的 \(d\) 使 \(\mathbf{v}_b - \mathbf{v}_a + \mathbf{v}_c\) 和 \(\mathbf{v}_d\) 的相似度最高。这里我们同样使用余弦相似度来进行相似性度量。即：

\[d = \underset{w \in \mathbb{V}}{\mathrm{arg\,max}} \, \, \text{CosineSimilarity}(\mathbf{v}_b - \mathbf{v}_a + \mathbf{v}_c, \mathbf{v}_w) \]

其中 \(\mathbb{V}\) 为整个词汇表。

下面需要你来实现 complete_analogy_task 函数并用它来完成词语类比任务。该函数接受词语 a, b, c 为参数，返回相似度最高的 d，同时还有以下要求：

  • 为了方便分析与理解，这里要求函数返回相似度最高的前3个候选词及其相似度。
  • 我们不希望返回的词是 a, b, c 三个词本身，但有时候计算得到的相似度最高的前几个候选词中可能有 a, b, c 三者中的一个或几个，因此请将 a, b, c 三个词本身排除在外。

Assignment Notes:

  • 如果将 \(\mathbf{v}_b - \mathbf{v}_a + \mathbf{v}_c\) 当作一个词语的词向量，这里需要做的和 top_n_similarity 是很相似的。
def complete_analogy_task(
    word_a, word_b, word_c, word2index, index2word, word_matrix
):
    \'\'\'
    完成词语类比任务。给定已知的三个词 a, b, c，找到最适合的3个候选词 d 使得
    (v_b - v_a) 和 (v_d - v_c) 间的余弦相似度最小。

    Args:
        word_a (str): 词语 a；
        word_b (str): 词语 b；
        word_c (str)：词语 c；
        word2index (dict[str, int]): 词语到下标的映射；
        index2word (dict[int, str])：下标到词语的映射；
        word_matrix (numpy.ndarray)：词向量组成的矩阵。

    Returns:
        (dict[str, float]): 最合适的3候选词，以词为key，以相似度为value。
    \'\'\'
    for word in (word_a, word_b, word_c):
        if word not in word2index:
            raise ValueError(
                \'Word {} not in the vocabulary.\'.format(word)
            )
    ###### 开始 ######
    
    mydict= dict()
    wordlist =[]
    #取出该单词的词向量，并转换为1维向量
    word1 = word_matrix[word2index[word_a]]
    word2 = word_matrix[word2index[word_b]]
    word3 = word_matrix[word2index[word_c]]
    wordlist.append(word_a)
    wordlist.append(word_b)
    wordlist.append(word_c)
    mat1 = np.array([word2-word1+word3])
    
    #用该向量与原词组方程求相似度，得到该单词与所有词的相似度向量
    ans=cosine_similarity(mat1,word_matrix)
    
    #对该向量进行排序，得到其下标排序结果
    ans1=np.argsort(-ans)
    
    #将向量将维成数组
    ans=np.squeeze(ans)
    ans1=np.squeeze(ans1)
    
    k=0
    for i in range(6):
        p=index2word[ans1[i]]
        if p not in wordlist:
            mydict[p]=ans[ans1[i]]
            k+=1
            if(k==3):
                break
    return mydict
    
    ###### 结束 ######

运行下面的测试用例，你应该得到：

"巴黎":"法国" = "北京":"中国" 	前3候选: {\'中国\': 0.9035901571740452, \'上海\': 0.7863853529317479, \'中华人民共和国\': 0.7673241689100596}
"法国":"巴黎" = "中国":"北京" 	前3候选: {\'北京\': 0.8777837078974607, \'上海\': 0.7822645566195217, \'杭州\': 0.7708022456031641}
"北京":"中国" = "东京":"日本" 	前3候选: {\'日本\': 0.9126536930088033, \'概要\': 0.8140997356991334, \'条目\': 0.7620412947366628}
"哥哥":"爸爸" = "姐姐":"妈妈" 	前3候选: {\'妈妈\': 0.9105166131659955, \'爱上\': 0.8414034985959645, \'我家\': 0.8085360695344918}
"man":"king" = "woman":"queen" 	前3候选: {\'queen\': 0.7812693110741713, \'princess\': 0.7761106573413572, \'lady\': 0.7394024785261167}
"man":"男人" = "woman":"女人" 	前3候选: {\'女人\': 0.8282728834284955, \'爱上\': 0.7446765414784068, \'漂亮\': 0.7270981887885872}
"夏天":"summer" = "冬天":"winter" 	前3候选: {\'winter\': 0.827960010826369, \'spring\': 0.8133394777339396, \'nights\': 0.7302998615344509}
"猫":"cat" = "狗":"dog" 	前3候选: {\'dog\': 0.673225726288403, \'bell\': 0.6685053095960879, \'avbe\': 0.6440587722819132}

def show_cases(cases):
    for case in cases:
        result = complete_analogy_task(*case, word2index, index2word, word_matrix)
        print(\'"{}":"{}" = "{}":"{}"\'.format(
            case[0], case[1], case[2], list(result.keys())[0]
        ), \'\t前3候选:\', result)

test_cases = [
    (\'巴黎\', \'法国\', \'北京\'),
    (\'法国\', \'巴黎\', \'中国\'),
    (\'北京\', \'中国\', \'东京\'),
    (\'哥哥\', \'爸爸\', \'姐姐\'),
    (\'man\', \'king\', \'woman\'),
    (\'man\', \'男人\', \'woman\'),
    (\'夏天\', \'summer\', \'冬天\'),
    (\'猫\', \'cat\', \'狗\'),
]
show_cases(test_cases)

"巴黎":"法国" = "北京":"中国" 	前3候选: {\'中国\': 0.9035901571740453, \'上海\': 0.7863853529317478, \'中华人民共和国\': 0.7673241689100596}
"法国":"巴黎" = "中国":"北京" 	前3候选: {\'北京\': 0.8777837078974606, \'上海\': 0.7822645566195219, \'杭州\': 0.7708022456031642}
"北京":"中国" = "东京":"日本" 	前3候选: {\'日本\': 0.9126536930088031, \'概要\': 0.8140997356991332, \'条目\': 0.7620412947366628}
"哥哥":"爸爸" = "姐姐":"妈妈" 	前3候选: {\'妈妈\': 0.9105166131659955, \'爱上\': 0.8414034985959644, \'我家\': 0.8085360695344919}
"man":"king" = "woman":"queen" 	前3候选: {\'queen\': 0.7812693110741713, \'princess\': 0.7761106573413571, \'lady\': 0.7394024785261168}
"man":"男人" = "woman":"女人" 	前3候选: {\'女人\': 0.8282728834284955, \'爱上\': 0.7446765414784068, \'漂亮\': 0.7270981887885872}
"夏天":"summer" = "冬天":"winter" 	前3候选: {\'winter\': 0.827960010826369, \'spring\': 0.8133394777339394, \'nights\': 0.7302998615344509}
"猫":"cat" = "狗":"dog" 	前3候选: {\'dog\': 0.673225726288403, \'bell\': 0.668505309596088, \'avbe\': 0.6440587722819131}

下面请发挥你的想象尝试不同的例子，看看你是否可以得到合理的结果。请至少测试10个例子，英文请使用小写。

your_test_cases = [
    (\'苹果\', \'mac\', \'微软\'),
    (\'nba\', \'篮球\', \'nfl\'),
    (\'四川\', \'火锅\', \'北京\'),
    (\'爷爷\', \'奶奶\', \'外公\'),
    (\'爷爷\', \'奶奶\', \'爸爸\'),
    (\'c\', \'编译\', \'python\'),
    (\'英语\', \'english\', \'数学\'),
    (\'王子\', \'公主\', \'男\'),
]
show_cases(your_test_cases)

"苹果":"mac" = "微软":"windows" 	前3候选: {\'windows\': 0.8910806551309494, \'microsoft\': 0.8529114256029701, \'xp\': 0.8379023732611227}
"nba":"篮球" = "nfl":"排球" 	前3候选: {\'排球\': 0.7005484502888687, \'橄榄球\': 0.6665796989079577, \'垒球\': 0.6358227473678834}
"四川":"火锅" = "北京":"双合盛" 	前3候选: {\'双合盛\': 0.5892615817795352, \'李太白\': 0.5601195437064146, \'汉堡\': 0.5514640741701642}
"爷爷":"奶奶" = "外公":"姑姑" 	前3候选: {\'姑姑\': 0.7294645937903153, \'外婆\': 0.7193083976760439, \'洪贞恩\': 0.7190164658997995}
"爷爷":"奶奶" = "爸爸":"妈妈" 	前3候选: {\'妈妈\': 0.8551136273568736, \'爱上\': 0.847611952873073, \'老公\': 0.8176522434879868}
"c":"编译" = "python":"perl" 	前3候选: {\'perl\': 0.7076964643456336, \'zodb\': 0.6825362384237011, \'cweb\': 0.6784671475955981}
"英语":"english" = "数学":"mathematics" 	前3候选: {\'mathematics\': 0.757443123039894, \'mathematical\': 0.6710243658734777, \'高等数学\': 0.6644685799868281}
"王子":"公主" = "男":"女" 	前3候选: {\'女\': 0.8330239176078883, \'女主角\': 0.7256086005422543, \'嫁\': 0.702171130631091}

分类：

技术点：

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode