应用 - gensim如何得到word2vec词向量

妖狐艹你老母 2022-12-26 10:27 123阅读 0赞

## 从三个方面去说明 ##

1.  word2vec词向量中文语料处理(python gensim word2vec总结）
2.  python训练work2vec词向量系列函数（python gensim）
3.  python训练work2vec词向量实例（python gensim）

## 一、word2vec词向量中文语料处理(python gensim word2vec总结） ##

**目录**

[中文语料处理][Link 1]

[法一：语料处理为列表][Link 2]

[法二：语料是文件（处理为迭代器）][Link 3]

[对一个目录下的所有文件生效（法1）][1]

[ 对一个目录下的所有文件生效（法2）][_2]

[对于单个文件语料，使用LineSentence][LineSentence]

[语料库获取语料][Link 4]

[word2vec中文语料处理及模型训练实践][word2vec]

--------------------

python gensim训练 word2vec的中文语料格式是什么样的呢？很多经验贴或是忽略了这个地方，或是没有详细说明，此博文详细说明及实践语料的处理方式，并汇总数种语料加载方式。

从文章[word2vec词向量训练使用（python gensim）][word2vec_python gensim]对word2vec的介绍，我们了解到Word2Vec第一个参数sentences要求是是预处理后的训练语料库，需要输入一个可迭代的列表，但是对于较大的语料库，可以考虑直接从磁盘/网络传输句子的迭代。

## 中文语料处理 ##

如果是句子，需要进行分词

如果是文件，需要将文件处理为每一行对应一个句子（已经分词，以空格隔开），实例处理过程见文末。

## 法一：语料处理为列表 ##

from gensim.models import Word2Vec
    sentences = [["Python", "深度学习", "机器学习"], ["NLP", "深度学习", "机器学习"]]
    model = Word2Vec(sentences, min_count=1)

把Python内置列表当作输入很方便，但当输入量很大的时候，大会占用大量内存。

## 法二：语料是文件（处理为迭代器） ##

Gensim需要输入一个可迭代的列表，可以是迭代器，没有必要把一切东西都保存在内存中，提供一个语句，加载处理它，忘记它，加载另一个语句。

一般我们的语料是在文件中存放的，首先，需要保证语料文件内部每一行对应一个句子（已经分词，以空格隔开），方法见上。

### 对一个目录下的所有文件生效（法1） ###

这些文件已经被分词好了，如果还需要进一步预处理文件中的单词，如移除数字，提取命名实体… 所有的这些都可以在MySentences 迭代器内进行，保证给work2vec的是处理好的迭代器。

class MySentences(object):
        def __init__(self, dirname):
            self.dirname = dirname
     
        def __iter__(self):
            for fname in os.listdir(self.dirname):
                for line in open(os.path.join(self.dirname, fname)):
                    yield line.split()
     
    sentences = MySentences('/some/directory') # a memory-friendly iterator
    model = gensim.models.Word2Vec(sentences)

### 对一个目录下的所有文件生效（法2） ###

### class : gensim.models.word2vec.PathLineSentences ###

gensim.models.word2vec.PathLineSentences(source, max_sentence_length=10000, limit=None)
    Bases: object
    作用同下一个类，对一个目录下的所有文件生效，对子目录无效
    Works like word2vec.LineSentence, but will process all files in a directory in alphabetical order by filename. 
    该路径下的文件 只有后缀为bz2，gz和text的文件可以被读取，其他的文件都会被认为是text文件
    The directory can only contain files that can be read by LineSentence: .bz2, .gz, and text files. Any file not ending with .bz2 or .gz is assumed to be a text file. Does not work with subdirectories.
    一个句子即一行，单词需要预先使用空格分隔
    The format of files (either text, or compressed text files) in the path is one sentence = one line, with words already preprocessed and separated by whitespace.
    源处填写的必须是一个目录，务必保证该目录下的文件都能被该类读取。如果设置了读取限制，那么只读取限定的行数。
    Example:
    sentences = PathLineSentences(path)
    目录下的文件应该是如此种种。
    The files in the directory should be either text files, .bz2 files, or .gz files.

### 对于单个文件语料，使用LineSentence ###

class: gensim.models.word2vec.LineSentence

每一行对应一个句子（已经分词，以空格隔开），我们可以直接用LineSentence把txt文件转为所需要的格式。

LineSentence功能解释：Iterate over a file that contains sentences: one line = one sentence. Words must be already preprocessed and separated by whitespace(对包含句子的文件进行迭代:一行=一句话。单词必须经过预处理，并由空格分隔)

from gensim import Word2Vec
    from gensim.Word2Vec import LineSentence
    from gensim.test.utils import common_texts, get_tmpfile
     
    # inp为输入语料
    inp = 'wiki.zh.text.jian.seg.txt'
    sentences = LineSentences(inp)
    path = get_tmpfile("word2vec.model") #创建临时文件
    model = Word2Vec(sentences, size=100, window=5, min_count=1)
    model.save("word2vec.model")

gensim.models.word2vec.LineSentence(source, max\_sentence\_length=10000, limit=None)  
预处理类，限制句子最大长度，文档最大行数  
拿到了分词后的文件，在一般的NLP处理中，会需要去停用词。由于word2vec的算法依赖于上下文，而上下文有可能就是停词。因此对于word2vec，我们可以不用去停词。

### 语料库获取语料 ###

class gensim.models.word2vec.Text8Corpus

class gensim.models.word2vec.Text8Corpus(fname, max_sentence_length=10000)
    Bases: object
    从一个叫‘text8’的语料库中获取数据，该语料来源于以下网址，参数max_sentence_length限定了获取的语料长度
    Iterate over sentences from the “text8” corpus, unzipped from http://mattmahoney.net/dc/text8.zip .

## word2vec中文语料处理及模型训练实践（[实践部分代码改编自链接][Link 5]） ##

import jieba
    import jieba.analyse
    from gensim.test.utils import common_texts, get_tmpfile
    from gensim.models import Word2Vec
    #文件位置需要改为自己的存放路径
    #将文本分词
    with open('C:\\Users\Administrator\Desktop\\in_the_name_of_people\in_the_name_of_people.txt',encoding='utf-8') as f:
        document = f.read()
        document_cut = jieba.cut(document)
        result = ' '.join(document_cut)
        with open('./in_the_name_of_people_segment.txt', 'w',encoding="utf-8") as f2:
            f2.write(result)
    #加载语料
    sentences = word2vec.LineSentence('./in_the_name_of_people_segment.txt')
    #训练语料
    path = get_tmpfile("word2vec.model") #创建临时文件
    model = word2vec.Word2Vec(sentences, hs=1,min_count=1,window=10,size=100)
    # model.save("word2vec.model")
    # model = Word2Vec.load("word2vec.model")
    #输入与“贪污”相近的100个词
    for key in model.wv.similar_by_word('贪污', topn =100):
        print(key)
    #输出了100个，示例前几个
    ('地皮', 0.9542419910430908)
    ('高昂', 0.934522807598114)
    ('证', 0.9154356122016907)
    ('上强', 0.9113685488700867)
    ('一抹', 0.9097814559936523)
    ('得罪', 0.9082552790641785)
    ('屁股', 0.9072068929672241)
    ('能伸能屈', 0.9049990177154541)
    ('二十五万', 0.9045952558517456)

# 二、python训练work2vec词向量（python gensim） #

看了很多文章，对与word2vec语料的处理没有那么清晰，现在写下自己处理流程，方便入手的小伙伴，望大家使用的过程中，少走弯路。

**目录**

[模型训练][Link 6]

[1.安装gensim][1._gensim]

[2.模型训练][2.]

[3.模型保存][3.]

[3.1模型训练保存与加载1（模型可继续训练）][3.1_1]

[3.1.1模型继续训练][3.1.1]

[3.2模型训练保存与加载2（模型不可继续训练）][3.2_2]

[模型使用汇总（词语相似度、集合相似度、词向量计算等）][Link 7]

[1.获取每个词的词向量][1.]

[2支持词语的加减运算。（实际中可能只有少数例子比较符合）][2]

[3计算两个词之间的余弦距离][3]

[4计算余弦距离最接近“word”的10个词，或topn个词][4_word_10_topn]

[5计算两个集合之间的余弦似度][5]

[6.选出集合中不同类的词语][6.]

### 看了很多文章，对与word2vec语料的处理没有那么清晰，现在写下自己处理流程，方便入手的小伙伴，望大家使用的过程中，少走弯路。 ###

本博客主要是针对word2vec的使用，做一下介绍，理论部分不过多解释。

# 模型训练 #

## 1.安装gensim ##

pip install gensim

gensim中封装了包括了word2vec, doc2vec等模型，word2vec采用了CBOW(Continuous Bag-Of-Words，连续词袋模型)和Skip-Gram两种模型。

## 2.模型训练 ##

from gensim.models import Word2Vec
    model = Word2Vec(sentences, sg=1, size=100,  window=5,  min_count=5,  negative=3, sample=0.001, hs=1, workers=4)

gensim参数解释

*  sentences 第一个参数是预处理后的训练语料库。是可迭代列表，但是对于较大的语料库，可以考虑直接从磁盘/网络传输句子的迭代。
 *  sg=1是skip-gram算法，对低频词敏感；默认sg=0为CBOW算法。
 *  size(int) 是输出词向量的维数，默认值是100。这个维度的取值与我们的语料的大小相关，比如小于100M的文本语料，则使用默认值一般就可以了。如果是超大的语料，建议增大维度。值太小会导致词映射因为冲突而影响结果，值太大则会耗内存并使算法计算变慢，一般值取为100到200之间，不过见的比较多的也有300维的。
 *  window（int）是一个句子中当前单词和预测单词之间的最大距离，window越大，则和某一词较远的词也会产生上下文关系。默认值为5。windows越大所需要枚举的预测此越多，计算的时间越长。
 *  min\_count 忽略所有频率低于此值的单词。默认值为5。
 *  workers表示训练词向量时使用的线程数,默认是当前运行机器的处理器核数。
 *  还有关采样和学习率的，一般不常设置  
    negative和sample可根据训练结果进行微调，sample表示更高频率的词被随机下采样到所设置的阈值，默认值为1e-3。  
    hs=1表示层级softmax将会被使用，默认hs=0且negative不为0，则负采样将会被选择使用。

from gensim.models import Word2Vec
    sentences = [["cat", "say", "meow"], ["dog", "say", "woof"]]
    #数据也可以时分好词的文档，按行读取
    #sentences=word2vec.Text8Corpus("分词后文件.txt")
    model = Word2Vec(sentences, min_count=1)

详细请参考[gensim的word2vec的官方说明][gensim_word2vec]，里面讲的很详细，不过常用到的参数就是上面介绍的。

## 3.模型保存 ##

模型保存两种方式：

### model = Word2Vec(common\_texts, size=100, window=5, min\_count=1, workers=4)   model.save(path) 或者 ###

### model.wv.save(path) ###

两种的区别见3.1及3.2。

ps:model.save\_word2vec\_format("w2v\_vector.bin", binary=False)这种方式是二进制保存，已经弃用改为 model.wv.save

### 3.1模型训练保存与加载1（模型可继续训练） ###

model.save(path)

Word2Vec.load(path)

使用以下命令初始化模型
    from gensim.test.utils import common_texts, get_tmpfile
    from gensim.models import Word2Vec
     
    path = get_tmpfile("word2vec.model") #创建临时文件
     
    model = Word2Vec(sentences, size=100, window=5, min_count=1, workers=4)
    model.save("word2vec.model")
     
    #加载模型
    model = Word2Vec.load("word2vec.model")

### 3.1.1模型继续训练 ###

训练是流式的，这意味着句子可以是一个生成器，动态地从磁盘读取输入数据，而无需将整个语料库加载到RAM中。这也意味着您可以在以后继续培训模型:

#训练模型
    使用以下命令初始化模型
    from gensim.test.utils import common_texts, get_tmpfile
    from gensim.models import Word2Vec
     
    path = get_tmpfile("word2vec.model") #创建临时文件
     
    model = Word2Vec(sentences, size=100, window=5, min_count=1, workers=4)
    model.save("word2vec.model")
     
    #加载模型
    model = Word2Vec.load("word2vec.model")
     
    #继续训练
    model.train([["hello", "world"]], total_examples=1, epochs=1)
    #(0, 2)
    #调用模型
    vector = model['computer']  # numpy vector of a word
     
    # 如果已经完成了模型的培训(即不再更新，只进行查询)，可以切换到KeyedVectors实例
    word_vectors = model.wv
    del model

### 3.2模型训练保存与加载2（模型不可继续训练） ###

from gensim.models import KeyedVectors

model.wv.save(path)

wv = KeyedVectors.load("model.wv", mmap='r')

要继续进行培训，需要save()存储的完整Word2Vec对象状态，而不仅仅是keyedvector。如果不需要继续训练模型，在加载时设置参数 model.wv.save(path) 以及 KeyedVectors.load("model.wv", mmap='r')分离训练向量到KeyedVectors，得到更小、更快的模型对象。

from gensim.models import KeyedVectors
     
    path = get_tmpfile("model.wv")
    model = Word2Vec(common_texts, size=100, window=5, min_count=1, workers=4)
    model.wv.save(path)
    wv = KeyedVectors.load("model.wv", mmap='r')
    vector = wv['computer']  # numpy vector of a word

如果从文件加载训练好的模型（人民日报词向量）：

from gensim.models import KeyedVectors
    from gensim.test.utils import datapath
    model= KeyedVectors.load_word2vec_format(datapath('E:\Mypython3\wenshu_my\data_my\sgns.renmin.bigram-char'), binary=False)
    for key in model.similar_by_word('人民',topn=10):
        print(key)
     
    ('各族人民', 0.6978535652160645)
    ('人民大众', 0.6294125318527222)
    ('亿万人民', 0.6256287097930908)
    ('群众', 0.5972658395767212)
    ('民众', 0.567489504814148)
    ('城乡人民', 0.5603191256523132)
    ('广大群众', 0.5412135124206543)
    ('新疆各族人民', 0.5377484560012817)
    ('百姓', 0.5321395993232727)
    ('劳苦大众', 0.530288577079773)

[gensim官网例子][gensim]训练一个完整的模型，然后访问它的模型。wv属性，它包含独立键控向量。例如，使用Word2Vec算法来训练向量

>>> from gensim.test.utils import common_texts
    >>> from gensim.models import Word2Vec
    >>>
    >>> model = Word2Vec(common_texts, size=100, window=5, min_count=1, workers=4)
    >>> word_vectors = model.wv

将单词vector保存到磁盘

>>> from gensim.test.utils import get_tmpfile
    >>> from gensim.models import KeyedVectors
    >>>
    >>> fname = get_tmpfile("vectors.kv")
    >>> word_vectors.save(fname)
    >>> word_vectors = KeyedVectors.load(fname, mmap='r')

这些向量还可以从磁盘上的现有文件实例化，以原始谷歌的word2vec C格式作为KeyedVectors实例

>>> from gensim.test.utils import datapath
    >>>
    >>> wv_from_text = KeyedVectors.load_word2vec_format(datapath('word2vec_pre_kv_c'), binary=False)  # C text format
    >>> wv_from_bin = KeyedVectors.load_word2vec_format(datapath("euclidean_vectors.bin"), binary=True)  # C binary format

# work2vec词向量使用汇总（词语相似度、集合相似度、词向量计算等） #

在已经获取模型的前提下可以进行：

*  ### 1.获取每个词的词向量 ###

model\['computer'\] \# raw numpy vector of a word

*  ### 2.支持词语的加减运算。（实际中可能只有少数例子比较符合） ###

model.most\_similar(positive=\['woman', 'king'\], negative=\['man'\])

*  ### 3.计算两个词之间的余弦距离 ###

model.similarity("好", "还行")

*  ### 4.计算余弦距离最接近“word”的10个词，或topn个词 ###

model.most\_similar("word")

model.similar\_by\_word('贪污', topn =100) 最接近的100个词

*  ### 5.计算两个集合之间的余弦似度 ###

当出现某个词语不在这个训练集合中的时候，会报错  
list\_sim1 = model.n\_similarity(list1, list2)

*  ### 6.选出集合中不同类的词语 ###

model.doesnt\_match("breakfast cereal dinner lunch".split())

#使用以下命令初始化模型
    from gensim.test.utils import common_texts, get_tmpfile
    from gensim.models import Word2Vec
     
    path = get_tmpfile("word2vec.model") #创建临时文件
     
    model = Word2Vec(common_texts, size=100, window=5, min_count=1, workers=4)
    model.save("word2vec.model")
    #加载模型
    model = Word2Vec.load("word2vec.model")
    --------------------- 
    #获取每个词的词向量
    model['computer']  # raw numpy vector of a word
    #输出array([-0.00449447, -0.00310097,  0.02421786, ...], dtype=float32)
    --------------------- 
    # 支持词语的加减运算。（实际中可能只有少数例子比较符合）
    model.most_similar(positive=['woman', 'king'], negative=['man'])
    #输出[('queen', 0.50882536), ...]
    --------------------- 
    #计算两个词之间的余弦距离
    model.similarity("好", "还行")
    model.most_similar("人民")#计算余弦距离最接近“滋润”的10个词
    for i in model.most_similar("人民"):
        print i[0],i[1]
    --------------------- 
    #model.similar_by_word('人民',topn=100) 输出与“人民”相似的前100个词
    for key in model.similar_by_word('人民',topn=10):
            print(key)
    for key in model.wv.similar_by_word('人民', topn =10):
        print(key)
    ---------------------
    #计算两个集合之间的余弦似度,当出现某个词语不在这个训练集合中的时候，会报错
    list1 = [u'今天', u'我', u'很', u'开心']
    list2 = [u'空气',u'清新', u'善良', u'开心']
    list3 = [u'国家电网', u'再次', u'宣告', u'破产', u'重新']
    list_sim1 =  model.n_similarity(list1, list2)
    print (list_sim1)
    list_sim2 = model.n_similarity(list1, list3)
    print( list_sim2) 
    0.541874230659
    0.13056320154
    --------------------- 
    #选出集合中不同类的词语
    model.doesnt_match("breakfast cereal dinner lunch".split())
    #输出'cereal'
    list = ['纽约', '北京', '上海', '西安']
    print( model.doesnt_match(list))
    list = ['纽约', '北京', '上海', '西瓜']
    print(model.doesnt_match(list))
    纽约
    西瓜
    --------------------- 
    此四个应用结果来源：https://blog.csdn.net/jerr__y/article/details/52967351 、https://blog.csdn.net/lk7688535/article/details/52798735

# 三、python训练work2vec词向量实例（gensim） #

### 前期工作可参阅： ###

1.python work2vec词向量训练可参考 https://blog.csdn.net/shuihupo/article/details/85156544词向量训练

2.word2vec词向量中文语料处理(python gensim word2vec总结） 可参考 https://mp.csdn.net/postedit/85162237汇总数种语料加载方式。  
之前的博客讲的比较详细，这篇博客则直接上例子了，有疑问的翻看之前的语料处理和词向量训练。

### python训练work2vec词向量实例 ###

## word2vec中文语料处理及模型训练实践 ##

（[实践部分代码改编自链接][Link 5]）原始小说语料下载[《人民的名义》][Link 8]

将代码中路径改为小说文本存放路径

#!/Mypython python3.5
    # -*- coding: utf-8 -*-
    # @Time    : 2018/12/21 16:49
    # @Author  : LinYimeng
    # @Site   : 
    # @File   : word2vec_test.py
    # @Software: PyCharm
    import multiprocessing
    import jieba
    import jieba.analyse
    from gensim.test.utils import common_texts, get_tmpfile
    from gensim.models import Word2Vec
    from gensim.models import KeyedVectors
    # import logging
    import os
     
    #处理语料
    with open('C:\\Users\Administrator\Desktop\\in_the_name_of_people\in_the_name_of_people.txt',encoding='utf-8') as f:
        document = f.read()
        document_cut = jieba.cut(document)
        result = ' '.join(document_cut)
        print("type",type(result))
        with open('./in_the_name_of_people_segment.txt', 'w',encoding="utf-8") as f2:
            f2.write(result)
     
    # logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
    sentences = word2vec.LineSentence('./in_the_name_of_people_segment.txt')
    path = get_tmpfile("w2v_model.bin") #创建临时文件
    model = Word2Vec(sentences, size=200, window=5, min_count=1,workers=multiprocessing.cpu_count())
    #模型储存与加载1
    model.save(path)
    model=Word2Vec.load("w2v_model.bin")
    for key in model.similar_by_word('人民',topn=10):
            print(key)
    #模型储存与加载2
    path1 = get_tmpfile("w2v_vector.bin") #创建临时文件
    model.wv.save(path1)
    wv = KeyedVectors.load("w2v_vector.bin", mmap='r')
    for key in wv.similar_by_word('人民', topn =10):
        print(key)
     
    ('钱', 0.9998364448547363)
    ('但', 0.9998363256454468)
    ('倒', 0.9998291730880737)
    ('以后', 0.99982750415802)
    ('回来', 0.9998223185539246)
    ('工作', 0.999817967414856)
    ('赵家', 0.9998155236244202)
    ('赵瑞龙', 0.9998130798339844)
    ('打', 0.9998125433921814)
    ('一次', 0.9998101592063904)

将单词vector保存到磁盘 ，这些向量还可以从磁盘上的现有文件实例化，如果从文件加载训练好的模型（人民日报词向量）：

[Link 1]: https://blog.csdn.net/shuihupo/article/details/85162237#%E4%B8%AD%E6%96%87%E8%AF%AD%E6%96%99%E5%A4%84%E7%90%86
[Link 2]: https://blog.csdn.net/shuihupo/article/details/85162237#%E6%B3%95%E4%B8%80%EF%BC%9A%E8%AF%AD%E6%96%99%E5%A4%84%E7%90%86%E4%B8%BA%E5%88%97%E8%A1%A8
[Link 3]: https://blog.csdn.net/shuihupo/article/details/85162237#%E6%B3%95%E4%BA%8C%EF%BC%9A%E8%AF%AD%E6%96%99%E6%98%AF%E6%96%87%E4%BB%B6%EF%BC%88%E5%A4%84%E7%90%86%E4%B8%BA%E8%BF%AD%E4%BB%A3%E5%99%A8%EF%BC%89
[1]: https://blog.csdn.net/shuihupo/article/details/85162237#%E5%AF%B9%E4%B8%80%E4%B8%AA%E7%9B%AE%E5%BD%95%E4%B8%8B%E7%9A%84%E6%89%80%E6%9C%89%E6%96%87%E4%BB%B6%E7%94%9F%E6%95%88%EF%BC%88%E6%B3%951%EF%BC%89
[_2]: https://blog.csdn.net/shuihupo/article/details/85162237#%C2%A0%E5%AF%B9%E4%B8%80%E4%B8%AA%E7%9B%AE%E5%BD%95%E4%B8%8B%E7%9A%84%E6%89%80%E6%9C%89%E6%96%87%E4%BB%B6%E7%94%9F%E6%95%88%EF%BC%88%E6%B3%952%EF%BC%89
[LineSentence]: https://blog.csdn.net/shuihupo/article/details/85162237#%E5%AF%B9%E4%BA%8E%E5%8D%95%E4%B8%AA%E6%96%87%E4%BB%B6%E8%AF%AD%E6%96%99%EF%BC%8C%E4%BD%BF%E7%94%A8LineSentence
[Link 4]: https://blog.csdn.net/shuihupo/article/details/85162237#%E8%AF%AD%E6%96%99%E5%BA%93%E8%8E%B7%E5%8F%96%E8%AF%AD%E6%96%99
[word2vec]: https://blog.csdn.net/shuihupo/article/details/85162237#%E5%AE%9E%E8%B7%B5
[word2vec_python gensim]: https://blog.csdn.net/shuihupo/article/details/85156544
[Link 5]: https://www.cnblogs.com/pinard/p/7278324.html
[Link 6]: https://blog.csdn.net/shuihupo/article/details/85156544#%E6%A8%A1%E5%9E%8B%E8%AE%AD%E7%BB%83
[1._gensim]: https://blog.csdn.net/shuihupo/article/details/85156544#1.%E5%AE%89%E8%A3%85gensim
[2.]: https://blog.csdn.net/shuihupo/article/details/85156544#2.%E6%A8%A1%E5%9E%8B%E8%AE%AD%E7%BB%83
[3.]: https://blog.csdn.net/shuihupo/article/details/85156544#3.%E6%A8%A1%E5%9E%8B%E4%BF%9D%E5%AD%98
[3.1_1]: https://blog.csdn.net/shuihupo/article/details/85156544#3.%E6%A8%A1%E5%9E%8B%E8%AE%AD%E7%BB%83%E4%BF%9D%E5%AD%98%E4%B8%8E%E5%8A%A0%E8%BD%BD1%EF%BC%88%E6%A8%A1%E5%9E%8B%E5%8F%AF%E7%BB%A7%E7%BB%AD%E8%AE%AD%E7%BB%83%EF%BC%89
[3.1.1]: https://blog.csdn.net/shuihupo/article/details/85156544#4.%E6%A8%A1%E5%9E%8B%E7%BB%A7%E7%BB%AD%E8%AE%AD%E7%BB%83
[3.2_2]: https://blog.csdn.net/shuihupo/article/details/85156544#5.%E6%A8%A1%E5%9E%8B%E8%AE%AD%E7%BB%83%E4%BF%9D%E5%AD%98%E4%B8%8E%E5%8A%A0%E8%BD%BD2%EF%BC%88%E6%A8%A1%E5%9E%8B%E4%B8%8D%E5%8F%AF%E7%BB%A7%E7%BB%AD%E8%AE%AD%E7%BB%83%EF%BC%89
[Link 7]: https://blog.csdn.net/shuihupo/article/details/85156544#%E6%A8%A1%E5%9E%8B%E4%BD%BF%E7%94%A8%E6%B1%87%E6%80%BB%EF%BC%88%E8%AF%8D%E8%AF%AD%E7%9B%B8%E4%BC%BC%E5%BA%A6%E3%80%81%E9%9B%86%E5%90%88%E7%9B%B8%E4%BC%BC%E5%BA%A6%E3%80%81%E8%AF%8D%E5%90%91%E9%87%8F%E8%AE%A1%E7%AE%97%E7%AD%89%EF%BC%89
[1.]: https://blog.csdn.net/shuihupo/article/details/85156544#1.%E8%8E%B7%E5%8F%96%E6%AF%8F%E4%B8%AA%E8%AF%8D%E7%9A%84%E8%AF%8D%E5%90%91%E9%87%8F
[2]: https://blog.csdn.net/shuihupo/article/details/85156544#2%E6%94%AF%E6%8C%81%E8%AF%8D%E8%AF%AD%E7%9A%84%E5%8A%A0%E5%87%8F%E8%BF%90%E7%AE%97%E3%80%82%EF%BC%88%E5%AE%9E%E9%99%85%E4%B8%AD%E5%8F%AF%E8%83%BD%E5%8F%AA%E6%9C%89%E5%B0%91%E6%95%B0%E4%BE%8B%E5%AD%90%E6%AF%94%E8%BE%83%E7%AC%A6%E5%90%88%EF%BC%89
[3]: https://blog.csdn.net/shuihupo/article/details/85156544#3%E8%AE%A1%E7%AE%97%E4%B8%A4%E4%B8%AA%E8%AF%8D%E4%B9%8B%E9%97%B4%E7%9A%84%E4%BD%99%E5%BC%A6%E8%B7%9D%E7%A6%BB
[4_word_10_topn]: https://blog.csdn.net/shuihupo/article/details/85156544#4%E8%AE%A1%E7%AE%97%E4%BD%99%E5%BC%A6%E8%B7%9D%E7%A6%BB%E6%9C%80%E6%8E%A5%E8%BF%91%E2%80%9Cword%E2%80%9D%E7%9A%8410%E4%B8%AA%E8%AF%8D
[5]: https://blog.csdn.net/shuihupo/article/details/85156544#5%E8%AE%A1%E7%AE%97%E4%B8%A4%E4%B8%AA%E9%9B%86%E5%90%88%E4%B9%8B%E9%97%B4%E7%9A%84%E4%BD%99%E5%BC%A6%E4%BC%BC%E5%BA%A6
[6.]: https://blog.csdn.net/shuihupo/article/details/85156544#6.%E9%80%89%E5%87%BA%E9%9B%86%E5%90%88%E4%B8%AD%E4%B8%8D%E5%90%8C%E7%B1%BB%E7%9A%84%E8%AF%8D%E8%AF%AD
[gensim_word2vec]: https://radimrehurek.com/gensim/models/word2vec.html
[gensim]: https://radimrehurek.com/gensim/models/keyedvectors.html
[Link 8]: http://files.cnblogs.com/files/pinard/in_the_name_of_people.zip