词向量作为文本的基本结构——词的模型。良好的词向量可以达到语义相近的词在词向量空间里聚集在一起，这对后续的文本分类，文本聚类等等操作提供了便利，这里简单介绍词向量的训练，主要是记录学习模型和词向量的保存及一些函数用法。

一、搜狐新闻

1. 中文语料库准备

本文采用的是搜狗实验室的搜狗新闻语料库，数据链接 http://www.sogou.com/labs/resource/cs.php

下载下来的文件名为： news_sohusite_xml.full.tar.gz

2. 数据预处理

2.1 数据解压缩并取出内容

（1）cd 到原始文件目录下，执行解压命令：

tar -zvxf news_sohusite_xml.full.tar.gz

（2）取出内容

由于这里的搜狐的材料中每个 对中存储的是文本内容。
所以取出 中的内容,执行如下命令：

cat news_tensite_xml.dat | iconv -f gbk -t utf-8 -c | grep "<content>"  > corpus.txt

得到文件名为corpus.txt的文件，可以通过vim 打开

vim corpus.txt

2.2 使用jieba分词

送给word2vec的文件是需要分词的，分词可以采用jieba分词实现，jieba安装很简单，这里不再讲解。
分词的代码如下：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 11 18:46:22 2018
@author: lilong
"""



"""
由原始文本进行分词后保存到新的文件
"""
import jieba
import numpy as np

filePath='corpus_1.txt'
fileSegWordDonePath ='corpusSegDone_1.txt'

# 打印中文列表
def PrintListChinese(list):
    for i in range(len(list)):
        print (list[i]) 
                
# 读取文件内容到列表
fileTrainRead = []
with open(filePath,'r') as fileTrainRaw:
    for line in fileTrainRaw:  # 按行读取文件
        fileTrainRead.append(line)
    

# jieba分词后保存在列表中
fileTrainSeg=[]
for i in range(len(fileTrainRead)):
    fileTrainSeg.append([' '.join(list(jieba.cut(fileTrainRead[i][9:-11],cut_all=False)))])
    if i % 100 == 0:
        print(i)
        

# 保存分词结果到文件中
with open(fileSegWordDonePath,'w',encoding='utf-8') as fW:
    for i in range(len(fileTrainSeg)):
        fW.write(fileTrainSeg[i][0])
        fW.write('\n')
      
       

"""
gensim word2vec获取词向量
"""

import warnings
import logging
import os.path
import sys
import multiprocessing

import gensim
from gensim.models import Word2Vec
from gensim.models.word2vec import LineSentence
# 忽略警告
warnings.filterwarnings(action='ignore', category=UserWarning, module='gensim')
 
if __name__ == '__main__':
    
    program = os.path.basename(sys.argv[0]) # 读取当前文件的文件名
    logger = logging.getLogger(program)
    logging.basicConfig(format='%(asctime)s: %(levelname)s: %(message)s',level=logging.INFO)
    logger.info("running %s" % ' '.join(sys.argv))
 
    # inp为输入语料, outp1为输出模型, outp2为vector格式的模型
    inp = 'corpusSegDone_1.txt'
    out_model = 'corpusSegDone_1.model'
    out_vector = 'corpusSegDone_1.vector'
 
    # 训练skip-gram模型
    model = Word2Vec(LineSentence(inp), size=50, window=5, min_count=5,
                     workers=multiprocessing.cpu_count())
 
    # 保存模型
    model.save(out_model)
    # 保存词向量
    model.wv.save_word2vec_format(out_vector, binary=False)

分词的结果是：

并且会保存3个文件：
corpusSegDone_1.txt
corpusSegDone_1.model
corpusSegDone_1.vector

由于这里运行需要一段时间，所以没有进行验证测试。

二、维基百科

由于训练需要一定的时间，所以这里只讲下思路。

1. 数据预处理

维基百科数据量不够大，百度百科数据量较全面，内容上面百度百科大陆相关的信息比较全面，港澳台和国外相关信息维基百科的内容比较详细，因此训练时将两个语料一起投入训练，形成互补，另外还加入了1.1万公司行业数据

模型：gensim工具包word2vec模型，安装使用简单，训练速度快
语料：百度百科500万词条+维基百科30万词条+1.1万条领域数据
分词：jieba分词,自定义词典加入行业词,去除停用词
硬件：根据自己的电脑硬件而定

2. 分词

1. 准备一个停用词词典，训练时要去除停用词的干扰
2. 分词工具有中科院分词,哈工大的LTP分词,jieba分词，分词效果中科院的分词效果不错，而这里直接使用jieba进行分词，使用简单方便，分词速度快。
3. 自定义词典：由于百科数据有很多专属名词,很多比较长,如果直接分词,很大情况下会被切开,这不是我们想要的结果，比如:中国人民解放军，可能会被分成：中国 人民 解放军，jieba虽然有新词发现功能，为保证分词准确度，jieba的作者建议我们还是使用自定义词典。
4. 自定义词典抽取：从百度百科抽取了200万的词条，由于自定义词典包含英文单词时会导致jieba对英文单词进行分词，所以需要用正则表达式去除词条中的英文数据，并且去除一些单字词，还有一些词条里面较短词，如"在北京"，这类词会导致分词出现问题，也需要使用正则去除，也有简单粗暴的方法，直接保留3个汉字及以上的中文词条，去除之后得到170万大小的自定义词典。
5. 分词

分词代码：

# 多线程分词
# jieba.enable_parallel()

#加载自定义词典
jieba.load_userdict("F:/baike_spider/dict/baike_word_chinese")

#加载停用词
def getStopwords():
    stopwords = []
    with open("stop_words.txt", "r", encoding='utf8') as f:
        lines = f.readlines()
        for line in lines:
            stopwords.append(line.strip())
    return stopwords

#分词
def segment():
    file_nums = 0
    count = 0
    url = base_url + 'processed_data/demo/'
    fileNames = os.listdir(url)
    for file in fileNames: # 遍历每个文件
        # 日志信息
        logging.info('starting ' + str(file_nums) + 'file word Segmentation')
        segment_file = open(url + file + '_segment', 'a', encoding='utf8')
        # 每个文件单独处理
        with open(url + file, encoding='utf8') as f:
            text = f.readlines()
            for sentence in text:
                sentence = list(jieba.cut(sentence))
                sentence_segment = []
                for word in sentence:
                    if word not in stopwords:
                        sentence_segment.append(word)
                segment_file.write(" ".join(sentence_segment))
            del text
            f.close()
        segment_file.close()
        # 日志信息
        logging.info('finished ' + str(file_nums) + 'file word Segmentation')
        file_nums += 1

• 由于python多线程只能单核多线程，如果是多核的机器并不能有效使用cpu,jieba是使用python写的，所以jieba只支持并行分词，并行分词指的是多进程分词，并且不支持windows。
• 在linux试过jieba自带的并行分词，开启并行分词之后，jieba后台会自动开启多个进程，并且并行分词需要一次性将训练语料读取到内存并传入jieba.cut(file.read())中才会有效果，如果类似我代码中逐行传入，开启多进程是不起作用的，jieba多进程原理是，jieba后台会自动将语料切分分配给指定进程处理，分好词后再合并。
• 8核16g内存Linux虚拟机，发现开启jieba并行分词，1g的语料数据，很快就爆内存了
• 单进程的jieba分词，不需要一次性加载所有语料数据，可逐行读取语料，内存占用不大，运行稳定。因此将语料数据分成8份，手动开启8个进程分别分词，这样每个进程内存占用都很稳定，比jieba自带的并行分词性能好，20g的数据，开启HMM模式，分词大概花了10个小时

3. word2vec训练

使用gensim工具包的word2vec训练，使用简单速度快，效果比Google 的word2vec效果好，用tensorflow来跑word2vec模型，16g的内存根本跑不动
gensim word2vec 训练代码如下，非常简单：

import logging
import multiprocessing
import os.path
import sys
import jieba

from gensim.models import Word2Vec
from gensim.models.word2vec import PathLineSentences

if __name__ == '__main__':
    
    # 日志信息输出
    program = os.path.basename(sys.argv[0])
    logger = logging.getLogger(program)
    logging.basicConfig(format='%(asctime)s: %(levelname)s: %(message)s')
    logging.root.setLevel(level=logging.INFO)
    logger.info("running %s" % ' '.join(sys.argv))
    
    # check and process input arguments
    # if len(sys.argv) < 4:
    #     print(globals()['__doc__'] % locals())
    #     sys.exit(1)
    # input_dir, outp1, outp2 = sys.argv[1:4]
    
    input_dir = 'segment'
    outp1 = 'baike.model'
    outp2 = 'word2vec_format'
    fileNames = os.listdir(input_dir)
    # 训练模型 
    # 输入语料目录:PathLineSentences(input_dir)
    # embedding size:256 共现窗口大小:10 去除出现次数5以下的词,多线程运行,迭代10次
    model = Word2Vec(PathLineSentences(input_dir),
                     size=256, window=10, min_count=5,
                     workers=multiprocessing.cpu_count(), iter=10)
    model.save(outp1)
    model.wv.save_word2vec_format(outp2, binary=False)

    # 运行命令:输入训练文件目录 python word2vec_model.py data baike.model baike.vector

• 由于语料太大，不能一次性加载到内存训练，gensim提供了PathLineSentences(input_dir)这个类，会去指定目录依次读取语料数据文件，采用iterator方式加载训练数据到内存。
• 从训练日志可以看到，其过程是先依次读取每个文件，生成总的vocab词典，用来统计count，训练时用来过滤min_count小于我们制定数量的词，vocab总词典生成后，会依次读入语料进行model训练，训练速度非常快。

三、word2vec词向量的保存与加载

1. 以model.save()方法保存词向量
   保存词向量

import gensim
model = gensim.models.Word2Vec(documents, size=300)
model.train(documents, total_examples=len(documents), epochs=10)
model.save("../input/Word2vec.w2v")

加载词向量

import gensim
word2vec = gensim.models.word2vec.Word2Vec.load("./input/Quora.w2v").wv

2. 存为二进制的词向量

保存词向量

model.wv.save_Word2Vec_format(embedding_path,binary=True)
#model.wv.save_Word2Vec_format(embedding_path,binary=False)非二进制

加载词向量

import gensim
word2vec = gensim.models.KeyedVectors.load_word2vec_format(embedding_path,binary=True)

3. 使用numpy进行保存和加载

保存数组数据的文件可以是二进制格式或者文本格式，二进制格式的文件可以是Numpy专用的二进制类型和无格式类型。

使用np.save()保存npy文件，np.load()加载npy文件。

模型导出与导入:

最简单的导入与导出

（1）word2vec.save即可导出文件，这边没有导出为.bin

# 模型保存与载入
model.save('/tmp/mymodel')
new_model = gensim.models.Word2Vec.load('/tmp/mymodel')
odel = Word2Vec.load_word2vec_format('/tmp/vectors.txt', binary=False)  # 载入 .txt文件
# using gzipped/bz2 input works too, no need to unzip:
model = Word2Vec.load_word2vec_format('/tmp/vectors.bin.gz', binary=True)  # 载入 .bin文件

word2vec = gensim.models.word2vec.Word2Vec(sentences(), size=256, window=10, min_count=64, sg=1, hs=1, iter=10, workers=25)
word2vec.save('word2vec_wx')

（2）gensim.models.Word2Vec.load的办法导入

model = gensim.models.Word2Vec.load('xxx/word2vec_wx')
pd.Series(model.most_similar(u'微信',topn = 360000))

（3）Numpy的话可以用numpy.load：

import numpy
word_2x = numpy.load('xxx/word2vec_wx.wv.syn0.npy')

（4）其他的导入方式，导入txt格式+bin格式 ：

from gensim.models.keyedvectors import KeyedVectors
word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.txt', binary=False)  # C text format
word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.bin', binary=True)  # C binary format

增量训练

# 增量训练
model = gensim.models.Word2Vec.load(temp_path)
more_sentences = [['Advanced', 'users', 'can', 'load', 'a', 'model', 'and', 'continue', 'training', 'it', 'with', 'more', 'sentences']]
model.build_vocab(more_sentences, update=True)
model.train(more_sentences, total_examples=model.corpus_count, epochs=model.iter)
 

不能对C生成的模型进行再训练

仅用做记录学习。

参考：
https://www.cnblogs.com/Newsteinwell/p/6034747.html
https://www.jianshu.com/p/87798bccee48
https://blog.csdn.net/sinat_26917383/article/details/69803018

前言

  本内容主要介绍使用 gensim 中的 word2vec 训练中文词向量。

1.1 下载数据集

  本内容使用 wiki 中文语料作为训练数据。可以在 wiki 官网下载中文语料，下载后得到一个名为 zhwiki-latest-pages-articles.xml.bz2 的压缩文件，解压后里面是一个 xml 文件。

  下载地址：https://dumps.wikimedia.org/zhwiki/latest/zhwiki-latest-pages-articles.xml.bz2

1.2 预处理

1.2.1 将原始 xml 文件转换为 txt 文件

  因为下载得到的数据是一份 xml 文件，里面存在各种标签，所以我们需要对其进行处理，然后将其保存到一个 txt 文件中。我们可以借助 gensim 中提供的 gensim.corpora.WikiCorpus 实现这个操作，示例代码如下：

from gensim.corpora import WikiCorpus

class ZhWikiPreProcessor:
    def convert_xml_to_text(self, input_file, output_file):
        with open(output_file, mode='w', encoding='utf-8') as out_f:
            index = 0
            space = ' '
            wiki_corpus = WikiCorpus(input_file, dictionary=[])
            for text in wiki_corpus.get_texts():
                # 保存到文件中
                out_f.write(space.join(text) + '\n')
                index += 1
                # 打印处理进度
                if index % 1000 == 0:
                    print("Saved {} articles...".format(index))

zh_wiki_xml_file = r'.\zhwiki\zhwiki-latest-pages-articles.xml.bz2'
zh_wiki_text_file = r'.\zhwiki\zh_wiki_original_text.txt'
preprocessor = ZhWikiPreProcessor()
# 将 xml 内容转换为 txt 内容
preprocessor.convert_xml_to_text(zh_wiki_xml_file, zh_wiki_text_file)

1.2.2 中文繁体转简体

  因为上面获取到的 Wiki 中文语料中包含了很多繁体字，所以我们需要将繁体字转换为简体字。可以使用 OpenCC 实现这个操作，示例代码如下：

from opencc import OpenCC

class ZhWikiPreProcessor:
    def convert_t2s(self, input_file, output_file):
        with open(output_file, mode='w', encoding='utf-8') as output_f:
            with open(input_file, mode='r', encoding='utf-8') as input_f:
                index = 0
                cc = OpenCC('t2s')
                for line in input_f.readlines():
                    # 将中文繁体转换为中文简体
                    line = cc.convert(line.strip())
                    # 保存到文件中
                    output_f.write(line + '\n')
                    index += 1
                    # 打印处理进度
                    if index % 1000 == 0:
                        print('Converted {} articles...'.format(index))

zh_wiki_text_file = r'.\zhwiki\zh_wiki_original_text.txt'
zh_wiki_simple_text_file = r'.\zhwiki\zh_wiki_simple_text.txt'
preprocessor = ZhWikiPreProcessor()
# 将中文繁体转换为中文简体
preprocessor.convert_t2s(zh_wiki_text_file, zh_wiki_simple_text_file)

  如果想了解更多关于 OpenCC 的信息，可以参照 这里。

1.2.3 分词

  下面需要对训练文本进行分词操作，就是将句子分解成一个个的词。中文分词工具有中科院计算所 NLPIR、哈工大 LTP、清华大学 THULAC、北京大学 PKUSeg、FoolNLTK、HanLP、jieba 等。本内容采用了 jieba 分词工具（其使用简单方便、流行度高），示例代码如下：

import jieba

class ZhWikiPreProcessor:
    def text_segment(self, input_file, output_file):
        with open(output_file, mode='w', encoding='utf-8') as output_f:
            with open(input_file, mode='r', encoding='utf-8') as input_f:
                index = 0
                for line in input_f.readlines():
                    # 对文本进行分词操作
                    words = jieba.cut(line.strip(), cut_all=False)
                    # 将词之间使用空格分隔，并保存到文件中
                    output_f.write(' '.join(words) + '\n')
                    index += 1
                    # 打印处理进度
                    if index % 1000 == 0:
                        print("Segment text {} lines...".format(index))

zh_wiki_simple_text_file = r'.\zhwiki\zh_wiki_simple_text.txt'
zh_wiki_simple_segment_text_file = r'.\zhwiki\zh_wiki_simple_segment_text.txt'
preprocessor = ZhWikiPreProcessor()
# 对文本进行分词操作
preprocessor.text_segment(zh_wiki_simple_text_file, zh_wiki_simple_segment_text_file)

1.2.4 去除停用词

  有时候我们可能需要去除停用词。在原有分词代码的基础上，需要新增两处修改：a. 获取停用词集合；b. 移除分词结果中的停用词。示例代码如下：

import jieba

class ZhWikiPreProcessor:
    def text_segment(self, input_file, output_file, stopwords_file=None):
    	# 获取停用词集合（01.新增加内容）
        if stopwords_file is not None:
            stopwords_set = self.get_stopwords(stopwords_file)
        else:
            stopwords_set = set()

        with open(output_file, mode='w', encoding='utf-8') as output_f:
            with open(input_file, mode='r', encoding='utf-8') as input_f:
                index = 0
                for line in input_f.readlines():
                    # 对文本进行分词操作
                    words = jieba.cut(line.strip(), cut_all=False)
                    # 去除停用词（02.新增加内容）
                    words = [word for word in words if word not in stopwords_set]
                    # 将词之间使用空格分隔，并保存到文件中
                    output_f.write(' '.join(words) + '\n')
                    index += 1
                    # 打印处理进度
                    if index % 1000 == 0:
                        print("Segment text {} lines...".format(index))

    @staticmethod
    def get_stopwords(stopwords_file):
        stopwords_set = set()
        with open(stopwords_file, mode='r', encoding='utf-8') as f:
            for stopword in f.readlines():
                stopwords_set.add(stopword.strip())
        return stopwords_set

1.3 训练词向量

  本内容使用 gensim 工具包中的 word2vec 进行训练，示例代码如下：

from gensim.models import Word2Vec
from gensim.models.word2vec import LineSentence

def train_zhwiki():
    # 训练数据文件名
    data_file = r'.\zhwiki\zh_wiki_segment_text.txt'
    # 保存的模型文件名
    model_file = r'.\zhwiki\zh_wiki.model'
    vector_file = r'.\zhwiki\zh_wiki.vector'

    # 训练模型
    model = Word2Vec(LineSentence(data_file), vector_size=100)
    # 保存模型
    model.save(model_file)
    model.wv.save_word2vec_format(vector_file, binary=False)

  下面列出 gensim.models.Word2Vec 的一些主要参数：

  可以通过调整这些参数，从而使训练出来的模型达到最佳效果。

1.4 测试词向量

  下面对训练的词向量效果进行测试，示例代码如下：

from gensim.models import Word2Vec

def test_zhwiki_model():
    # 模型文件名
    model_file = r'.\zhwiki\zh_wiki.model'
    # 加载模型
    model = Word2Vec.load(model_file)

    # 获取词的相似词
    result = model.wv.most_similar('清华大学')
    for word in result:
        print(word)
    print('\n')

    # 获取两个词之间的余弦相似度
    result = model.wv.similarity('男人', '女人')
    print(result)

将输出以下结果：

('北京大学', 0.886064350605011)
('武汉大学', 0.8563425540924072)
('清华', 0.8015897274017334)
('浙江大学', 0.7996682524681091)
('中山大学', 0.7982087135314941)
('复旦大学', 0.7962114214897156)
('中国人民大学', 0.7908720374107361)
('南开大学', 0.7769314050674438)
('南京大学', 0.775385320186615)
('华东师范大学', 0.7644416093826294)

0.915614

1.5 总结

  从上面对词向量的测试结果看，效果还算可以。如果我们需要在实际项目中进行使用，可以考虑从以下几个方向入手：

• 提高分词的准确度。
• 维护一份有效的停用词表。
• 不断调整 gensim.models.Word2Vec 的参数。
• 其他。

参考

[1] 利用Python构建Wiki中文语料词向量模型试验

[1] 使用 gensim 訓練中文詞向量

[2] 以 gensim 訓練中文詞向量

本文是在『词向量』用Word2Vec训练中文词向量（一）—— 采用搜狗新闻数据集 的基础上，将两个语料库合并，进而训练出较好的词向量模型。

参考：基于word2vec使用中文wiki语料库训练词向量
小项目（Gensim库）–维基百科中文数据处理

数据集下载

点此下载：wiki 语料库 选择最新的。

下载下的文件为 zhwiki-latest-pages-articles.xml.bz2，大小为1.75GB（下载速度特慢）。

数据集处理

（一）文本提取

有两种方法可以从压缩文件中提取出文本：

• 使用 gensim.corpora 的 WikiCorpus 来直接对维基语料库进行处理。保存到 wikiCorpus/wikiCorpus.txt

from gensim.corpora import WikiCorpus

if __name__ == '__main__':

    print('主程序开始...')

    input_file_name = 'zhwiki-latest-pages-articles.xml.bz2'
    output_file_name = 'wikiCorpus/wikiCorpus.txt'
    print('开始读入wiki数据...')
    input_file = WikiCorpus(input_file_name, lemmatize=False, dictionary={})
    print('wiki数据读入完成！')

    print('处理程序开始...')
    count = 0
    with open(output_file_name, 'wb') as output_file:
        for text in input_file.get_texts():
            output_file.write(' '.join(text).encode("utf-8"))
            output_file.write('\n'.encode("utf-8"))
            count = count + 1
            if count % 10000 == 0:
                print('目前已处理%d条数据' % count)
    print('处理程序结束！')

    output_file.close()
    print('主程序结束！')

• 下载 Wikipedia Extractor 来提取文本。
  
  数据集处理完成，一共 35w+ 条数据，效果如下所示。我们发现，已经去除了标点，简直不要太赞！！！
  

（二）化繁为简

下载 opencc ，进行繁简转换。

将 wikiCorpus.txt 复制到该文件夹中，用指示符 cd 到该文件夹，输入opencc -i wikiCorpus.txt -o wikiCorpusSim.txt -c t2s.json

即可完成转化，将转化后的 wikiCorpusSim.txt 保存到 python project，效果如图所示：

（三）文档分词

如果之前做过搜狗数据集的话，这一步应该很熟悉了。

import jieba

filePath = 'wikiCorpus/wikiCorpusSim.txt'  # 简化后文本
fileSegWordDonePath = 'wikiCorpus/wikiCorpusSegDone.txt'  # 分词处理后文本

# 将每一行文本依次存放到一个列表
fileTrainRead = []
with open(filePath, encoding='utf-8') as fileTrainRaw:
    for line in fileTrainRaw:
        fileTrainRead.append(line)

# 用jieba进行分词
fileTrainSeg = []
file_userDict = 'dict.txt'  # 自定义的词典
jieba.load_userdict(file_userDict)
for i in range(len(fileTrainRead)):
    fileTrainSeg.append([' '.join(jieba.cut(fileTrainRead[i], cut_all=False))])
    if i % 100 == 0:  # 每处理100个就打印一次
        print(i)

# 处理后写入文件
with open(fileSegWordDonePath, 'wb') as fW:
    for i in range(len(fileTrainSeg)):
        fW.write(fileTrainSeg[i][0].encode('utf-8'))
        fW.write('\n'.encode("utf-8"))
 

（四）合并数据集

将之前处理好的搜狗数据集与维基合并，生成炒鸡无敌中文语料库。

filePath1 = 'wikiCorpus/wikiCorpusSegDone.txt'  # wiki分词后语料库
filePath2 = 'sougouCorpus/sougouCorpusSegDone.txt'  # 搜狗语料库
filePath3 = 'corpusFinal.txt'  # 最终语料库


fileFinal = []
countS = 0  # sougou计数
countW = 0  # wiki计数

# 打开搜狗语料库
with open(filePath2, encoding='utf-8') as ff1:
    print("---成功导入搜狗语料库---")
    for line in ff1:
        fileFinal.append(line)
        countS = countS + 1
        if countS % 10000 == 0:
            print("---------已导入%d篇搜狗文章---------" % countS)

# 打开维基语料库
with open(filePath1, encoding='utf-8') as ff2:
    print("---成功导入wiki语料库---")
    for line in ff2:
        fileFinal.append(line)
        countW = countW + 1
        if countW % 10000 == 0:
            print("---------已导入%d篇维基文章---------" % countW)

# 打开最终文档，逐行写入
with open(filePath3, 'wb') as ff:
    for i in range(len(fileFinal)):
        ff.write(fileFinal[i].encode('utf-8'))
        if i % 10000 == 0:
            print("---------已合并%d篇文章---------" % i)

print("---------一共读入%d行---------" % len(fileFinal))
print("---------完成合并---------")

一共有 212w+ 行数据（其中维基71w 行 + 搜狗 141w 行）

大小为 3.35GB

训练模型

还是用的老代码

import logging
import sys
import gensim.models as word2vec
from gensim.models.word2vec import LineSentence, logger
# import smart_open


def train_word2vec(dataset_path, out_vector):
    # 设置输出日志
    logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
    logger.info("running %s" % ' '.join(sys.argv))
    # 把语料变成句子集合
    sentences = LineSentence(dataset_path)
    # sentences = LineSentence(smart_open.open(dataset_path, encoding='utf-8'))  # 或者用smart_open打开
    # 训练word2vec模型（size为向量维度，window为词向量上下文最大距离，min_count需要计算词向量的最小词频）
    model = word2vec.Word2Vec(sentences, size=128, sg=1, window=6, min_count=5, workers=4, iter=6)
    # (iter随机梯度下降法中迭代的最大次数，sg为1是Skip-Gram模型)
    # 保存word2vec模型
    model.save("word2vec.model")
    model.wv.save_word2vec_format(out_vector, binary=False)


# 加载模型
def load_word2vec_model(w2v_path):
    model = word2vec.Word2Vec.load(w2v_path)
    return model


# 计算词语最相似的词
def calculate_most_similar(self, word):
    similar_words = self.wv.most_similar(word)
    print(word)
    for term in similar_words:
        print(term[0], term[1])


# 计算两个词相似度
def calculate_words_similar(self, word1, word2):
    print(self.wv.similarity(word1, word2))


# 找出不合群的词
def find_word_dismatch(self, list):
    print(self.wv.doesnt_match(list))


if __name__ == '__main__':
    dataset_path = 'corpusFinal.txt'
    out_vector = 'corpusFinal.vector'
    train_word2vec(dataset_path, out_vector)  # 训练模型

    # model = load_word2vec_model("word2vec.model")  # 加载模型

    # calculate_most_similar(model, "病毒")  # 找相近词

    # calculate_words_similar(model, "法律", "制度")  # 两个词相似度

    # print(model.wv.__getitem__('男人'))  # 词向量

    # list = ["早饭", "吃饭", "恰饭", "嘻哈"]

    # find_word_dismatch(model, list)

与“病毒”相关的词：

写在最后

如果时间来不及训练模型，或者是出现了错误，可以加我的Q：2206300581（推荐，比较好发文件），我会提供分词后的结果【corpusSegDone.txt】以及训练好的模型【word2vec.model】。

参考文章

基于word2vec使用中文wiki语料库训练词向量
小项目（Gensim库）–维基百科中文数据处理