精华内容
下载资源
问答
  • 2022-02-20 23:10:45

    在做文本情感分类的项目,研究到Word2Vec模型了。

    自己来实践一下,网上大多数代码经过时间的流逝,多多少少都出了点小问题,为了方便自己之后的学术垃圾的制造,把自己跑出来的,修改过的代码和方法记录一下。

    1.环境

    1.1环境配置

    Python3.9,Pycharm2021

    1.2需要的库(搭建的虚拟环境,直接通过File->Settings引入)

    import logging
    from gensim.corpora import WikiCorpus
    import jieba
    import logging
    from gensim.models import word2vec
    import warnings
    import os.path
    import sys
    import multiprocessing
    from gensim.models.word2vec import LineSentence

    1.3Opencc简繁置换插件

    根据以下这篇博文的内容进行安装和操作即可。

    windows使用opencc中文简体和繁体互转_修炼之路-CSDN博客_opencc

    2.数据下载

    wiki官网下载中文语料,下载完成后会得到命名为zhwiki-latest-pages-articles.xml.bz2的文件,里面是一个XML文件。(有点大,2G+)(本代码实现不用解压!)
    下载地址:https://dumps.wikimedia.org/zhwiki/latest/zhwiki-latest-pages-articles.xml.bz2

    3.代码实现

    3.1将xml格式文件转换成txt格式

    
    
    import logging
    from gensim.corpora import WikiCorpus
    
    
    def main():
        logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
        logging.info("------------ the program is running -------------")
        path_to_wiki_dump = "zhwiki-latest-pages-articles.xml.bz2"
        wiki_corpus = WikiCorpus(path_to_wiki_dump, dictionary={})
        num = 0
        with open('wiki.zh.txt', 'w', encoding='utf-8') as output:
            for text in wiki_corpus.get_texts():  # get_texts() 将 wiki的一篇文章转为textd的一行
                output.write(' '.join(text) + '\n')
                num += 1
                if num % 10000 == 0:
                    logging.info("已处理 %d 文章" % num)
    
    
    if __name__ == '__main__':
        main()

    得到文件:wiki.zh.txt 

    3.2此文件是一个繁体字形式,需要用Opencc转换成简体字。安装好Opencc之后在cmd按照以下格式输入:

    opencc -i 需要转换的文件路径 -o 转换后的文件路径 -c 配置文件路径

    得到文件:wiki.zh.simp.txt 

    3.3将简体字文件进行分词,得到文件:wiki_seg.txt

    import jieba
    import logging
    
    
    def main():
        logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
        stopword_set = set()
        output = open('wiki_seg.txt', 'w', encoding='utf-8')
        with open('wiki.zh.simp.txt', 'r', encoding='utf-8') as content:
            for texts_num, line in enumerate(content):  # enumerate 给 line前加序号
                line = line.strip('\n')
                words = jieba.cut(line, cut_all=False)
                for word in words:
                    if word not in stopword_set:
                        output.write(word + ' ')
                output.write('\n')
                if (texts_num + 1) % 10000 == 0:
                    logging.info("已完成前 %d 行的断词" % (texts_num + 1))
        output.close()
    
    
    if __name__ == '__main__':
        main()

    3.4模型训练

    获得模型:chinese_wiki_word2vec.model

    from gensim.models import word2vec
    import logging
    
    
    def main():
        logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
        sentences = word2vec.LineSentence("wiki_seg.txt")
        model = word2vec.Word2Vec(sentences, size=250, min_count=5)  # size 用来设置神经网络的层数
        model.save("chinese_wiki_word2vec.model")
    
    
    if __name__ == "__main__":
        main()

    获得向量文件:wiki.zh.text.vector

    import warnings
    warnings.filterwarnings(action='ignore', category=UserWarning, module='gensim')# 忽略警告
    
    import logging
    import os.path
    import sys
    import multiprocessing
    
    from gensim.corpora import WikiCorpus
    from gensim.models import Word2Vec
    from gensim.models.word2vec import LineSentence
    
    
    if __name__ == '__main__':
    
        #print open('/Users/sy/Desktop/pyRoot/wiki_zh_vec/cmd.txt').readlines()
        #sys.exit()
        
        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为原始c版本word2vec的vector格式的模型
        #fdir = '/Users/sy/Desktop/pyRoot/wiki_zh_vec/'
        inp = 'wiki.zh.simp.txt'
        #outp1 = fdir + 'wiki.zh.text.model'
        outp2 = 'wiki.zh.text.vector'
    
        # 训练skip-gram模型
        model = Word2Vec(LineSentence(inp), size=400, window=5, min_count=5,
                         workers=multiprocessing.cpu_count())
    
        # 保存模型
        #model.save(outp1)
        model.wv.save_word2vec_format(outp2, binary=False)

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

    以上代码和过程参考了



    基于wiki的中文语料进行word2vec模型训练_Mrhan的博客-CSDN博客

    利用Python实现wiki中文语料的word2vec模型构建 - 简书

     

    等博文的内容,对其中部分进行修改。感谢各位前辈!

    更多相关内容
  • 基于Jupyter Notebook的腾讯开源word2vec模型
  • 中文分词获取和Word2Vec模型构建.zip
  • 腾讯开源的word2vec模型。 原版15个G,一般爱好者很难玩出来。 所以做了一些小的。方便大家使用。 5000-small.txt 这个有5000词,可以下下来玩玩 45000-small.txt 这个有4.5w的词,已经能解决很多问题了 70000-small...
  • 本语料适合于使用word2vec英文训练的语料,共98M,包括常用的英文词汇,训练后效果不错。
  • word2vec项目提供的Google新闻word2vec模型的REST API。 安装 克隆此仓库。 要构建它读取的烦人文件(是的,这有点愚蠢): 克隆和npm install并按照说明进行设置。 编辑tests/basictests.js以使用所需的度量...
  • 谷歌了一个大型的Word2Vec模型,他们使用Google新闻数据集中的大约1000亿个单词进行了训练。 它正好包含300万个单词,每个单词向量都有300个特征。 我很好奇地探索了这个300万个单词列表的某些方面,这就是这个...
  • 首先使用word2vec命令行工具构建模型。 然后可以将模型加载到Model类中: // load the model from a file var model = Model . Load ( " model.txt " ); // Find the simliarity between words model . Distance ...
  • 基于Word2Vec模型特征扩展的Web搜索结果聚类性能的改进.pdf
  • 土耳其语预训练Word2Vec模型 (下面是土耳其语版本。/Türkçeiçinaşağıyabakın。) 本教程介绍了如何从Wikipedia转储中为土耳其语训练word2vec模型。 此代码使用库以Python 3编写。 土耳其语是一种凝集性语言...
  • 原文件为zhwiki-latest-pages-articles.xml.bz2,大小为1.7G,最新时间为19年7月下载,转为txt文本,繁转简,分词,gensim训练后的model文件
  • word2vec模型训练

    2022-04-08 16:10:15
    import numpy as np ...class word2vec(): def __init__(self): self.n = settings['n'] self.lr = settings['learning_rate'] self.epochs = settings['epochs'] self.window = settings['window_s
    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+1):
                        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)
    
    展开全文
  • 抛开语言模型的思维约束,只看模型本身,我们就会发现,Word2Vec的两个模型 —— CBOW和Skip-Gram —— 实际上大有用途,它们从不同角度来描述了周围词与当前词的关系,而很多基本的NLP任务,都是建立在这个关系之上...
  • 中文word2vector词向量实现 说明:背后的原理暂时不做深究, 主要目的就是尽可能快的训练一个中文词向量模型。 环境 笔记本 i5-4210M CPU @ 2.60GHz × 4 , 8G RAM ubuntu16.04lts 独立系统, python 3.6.1 依赖:...
  • Ubuntu系统下,利用Wiki中文语料训练word2vec模型 开发环境配置 sudo aptitude install opencc(之所以不用opencc-python是因为太慢了) 安装anaconda3 点安装-U gensim 点安装-U cjieba 语料下载 Wikimedia语料...
  • word2vec模型进行词向量训练方法 一、打开语料库官网 搜狗实验室的搜狗新闻语料库官方链接:点击打开官方链接 二、下载语料库数据,首先下拉找到迷你版(样例数据, 110KB),然后点击第一个红色箭头指向的红色框内容...

    word2vec模型原理及实现词向量训练案例

    word2vec模型原理及介绍

    一、博主学习卷积神经网络CNN主要参考下面的四篇文章和视频(需要掌握“两个语言模型”指的是“CBOW”和“Skip-gram”和“两个降低计算复杂度的近似方法”“Hierarchical Softmax”和“Negative Sampling”,两个模型乘以两种方法,共有四种实现):

    二、在看完上面的文章内容,大家对于原理还有疑问可以参考博主自己学习后思考总结的重要内容。

    • Skip-gram是输入为中心词,输出为上下文;CBOW是输入为上下文,输出为中心词。
    • Hierarchical Softmax:翻译成中文是多层Softmax其实就是将神经网络原本设计的最后一层改为哈夫曼树,语料库根据词汇种类构造单词库,根据单词库中的词频进行编码,那么树所有的叶子节点就表示单词库的各个词汇,并且词频越高编码越短,计算效率越快。怎么根据损失函数更新参数的逻辑是(博主以CBOW为例):树中的每个非叶子节点是一个感知机,且是二分类计算,我们根据语料库可以知道对应的输出词汇结果的哈夫曼编码,然后我们根据0和1的不同的概率值(概率之和为1),再分别根据对应词汇的哈夫曼编码结果依次取出代入下面的计算公式可以得出一个值,当然这个L值(下面第二个公式计算后累加)是越大越好,则损失函数值(J=1-L)越小越好,举个例子,设置真实的输出的词汇的编码是1011,那么中间要经历四个感知机也就是四个非叶子节点,假如模型经历的是1001,那么计算的L肯定较小,则损失函数值较大,因为模型在实际运算中第三个感知机既然选择0,那么其选择1的概率小于50%,原本选择1的概率要大于50%,所以如果还是按照1011路线走,那么概率代入公式计算起来肯定L值较小,损失函数值较大,则需要反向传播更新参数,减小损失函数值。
      在这里插入图片描述
      在这里插入图片描述
    • Negative Sampling:负采样,相较于Hierarchical Softmax(正样本是正确二叉树路径,负样本是二叉树的其他路径),没有使用哈夫曼树,而是进行部分负采样,将输入上下文(词汇)和其正确输出词汇(上下文)看作正样本,再用根据词汇表中选NEG个上下文(词汇(文本高频词汇))且非输出上下文(词汇)作为负样本,然后怎么根据损失函数更新参数的逻辑是(下面的公式以CBOW为例):一组正样本,NEG组负样本代入下面最后的公式L,正样本概率越大,负样本概率(1-正样本概率)越小,则L数值计算结果越大,则损失函数J=1-L的值越小。相较于用softmax计算词汇表中所有的词汇概率,负采样只需要计算1+NEG个样本的计算值,效果更好。
      在这里插入图片描述
      在这里插入图片描述

    在这里插入图片描述

    • Skip-gram词向量生成前期数学原理逻辑设置(博主以Skip-gram为例):
      在这里插入图片描述
    • 引入神经网络模型多层感知机(MTP)来生成输入词的词向量,为满足上式输出概率P之和等于1且范围属于(0,1],通过引入Softmax进行实现。注意:输入词向量决定Z的结果,因为是one hot编码只有一个1,其余都是0
      在这里插入图片描述
      在这里插入图片描述
    • Skip-gram模式下语料库词汇概率转换得出损失函数的计算公式(context是指上下文;conditional likelihood叫做条件概率,因常量在后续的计算中不影响计算过程可以选择忽略;Average conditional log likelihood平均条件对数概率,选择此处变换是在不影响整体结果的前提下为后续损失函数计算方便考虑):
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
    • 下图说明一下,设置的窗口是4,也就是上面的m=2,神经网络模型运行2m也就是4次,但是2m次输入的语料库词汇是一样的是Bt。
    • 神经网络模型输入的词汇是语料库的词汇Bt的one hot编码向量,输出的结果是词汇表中的各个词汇作为Bt上下文的概率。注意:单词库是指所有词汇都包含类似新华字典,语料库是指文档类似小说文本,当然语料库的词汇种类<=单词库,当从语料库中新建单词库就能够相等,最后运算得到的语料库各词的词向量仅满足适用于该语料库。
    • 神经网络模型运行2m次期间每次通过模型计算出单词库各个词汇的概率都不变也就是Wo不变,因为运算参数没变化(后面每反向传播一次后会变,因为运算参数每次会发生改变)。
    • 神经网络模型2m次运行期间每次将输入的词汇Bt(语料库)的上下文2m个词汇中的一个如Bt+m(非重复)对应模型输出的词汇如Wo=Bt+m(单词库)的概率值代入损失函数公式进行计算,然后为实现最小化损失函数值选择梯度下降法等进行反向传播,训练多次最后得到输入词汇Bt的词向量Q,其他语料库的词汇同Bt一样求出其词向量
      在这里插入图片描述

    word2vec实现词向量训练案例

    一、打开语料库官网

    搜狗实验室的搜狗新闻语料库官方链接:点击打开官方链接
    在这里插入图片描述

    二、下载语料库数据,首先下拉找到迷你版(样例数据, 110KB),然后点击第一个红色箭头指向的红色框内容(tar.gz格式),自己选择好保存文件的途径之后点击第二个红色箭头指向的红色框内容(保存)。注意:下载来的文件名是“news_sohusite_xml.smarty.tar.gz”。

    在这里插入图片描述
    在这里插入图片描述

    三、首先按键盘“windows键+r”打开资源管理器 ,在打开栏输入“cmd”然后点击“确定”。然后通过转盘和cd转文件夹到之前下载的数据文件所在的文件夹为止。

    在这里插入图片描述
    在这里插入图片描述

    四、复制下面代码到cmd平台执行命令,对之前下载的数据文件进行解压并取出内容(成功与否见下面第二章图,若原下载保存文件夹中出现则表示解压成功)。

    tar -zvxf news_sohusite_xml.smarty.tar.gz
    

    在这里插入图片描述
    在这里插入图片描述

    注意:为Windows系统顺利执行后面用到的命令,需要下载libiconv和grep文件和解压安装及配置。

    五、首先点击打开下方链接,然后点击红色箭头指向的红色框内容(Setup)。

    libiconv下载官方链接:点击打开官方链接
    在这里插入图片描述
    在这里插入图片描述

    六、正常安装解压后进行环境配置,将你bin文件夹的具体位置(博主举例是C:\Program Files (x86)\GnuWin32\bin)复制,然后粘贴加到环境变量中path里面去。

    在这里插入图片描述
    在这里插入图片描述

    七、首先点击打开下方链接,然后点击红色箭头指向的红色框内容(Setup)。

    grep下载官方链接:点击打开官方链接
    在这里插入图片描述
    在这里插入图片描述

    八、正常安装解压后进行环境配置,将你bin文件夹的具体位置(博主举例是G:\GnuWin32\bin)复制,然后粘贴加到环境变量中path里面去。

    在这里插入图片描述
    在这里插入图片描述

    九、因为content字段去除了HTML标签,保存的是新闻正文文本,也就是< content >页面内容< /content >。所以取出content字段中的内容,复制下面代码在cmd平台运行执行命令取出页面内容。(type命令表示打开文件; iconv -f gbk -t utf-8 -c命令中-f --from-code等于名称 原始文本编码,-t --to-code等于名称 输出编码,-c 从输出中忽略无效的字符,整体表示将原文件编码由gbk转换成utf-8且忽略无效的字符;grep "< content >"表示grep命令用于查找取出文件里符合< content >条件的字符串;>命令表示生成相应文件)。

    type news_sohusite_xml.smarty.dat | iconv -f gbk -t utf-8 -c | grep "<content>"  > corpus.txt
    

    在这里插入图片描述
    在这里插入图片描述

    十、得到文件名为corpus.txt的文件后,可以通过复制下面代码在cmd平台打开文件内容。注意:corpus.txt文件编码在上一步命令操作的时候已经由gbk编码转换成utf-8,而cmd平台默认编码为gbk,所以下面在cmd打开文件会出现乱码。

    type corpus.txt
    

    在这里插入图片描述

    十一、为正常显示corpus.txt文件内容,需要复制下面代码在cmd平台命令行输入(65001代表编码格式为utf-8)。

    chcp 65001
    

    在这里插入图片描述
    在这里插入图片描述

    十二、再次通过复制下面代码在cmd平台打开文件内容。注意:cmd平台编码在上一步命令操作的时候已经由gbk编码转换成utf-8,所以下面在cmd打开文件不会出现乱码。

    type corpus.txt
    

    在这里插入图片描述

    十三、全自动安装jieba分词器安装,复制下面代码在cmd平台中安装好pip文件中运行。

    • 注意:在安装jieba分词器首先要安装好pip,若没有安装点击打开博主的在windows系统安装pip详细过程博文:点击打开文章链接
    • 注意:若没有安装python可以点击打开博主Python3.6.3安装详细简单完整版博文:点击打开文章链接
    python -m pip install jieba
    

    在这里插入图片描述

    十四、 jieba分词简要说明

    jieba分词三种分词模式:

    1、精确模式,:将句子精确切开,适合文本分析,比如清华大学就切分为”清华大学“。
    2、全模式:把句子中所有的成词词语都扫描出来,速度快,但是不能解决歧义,比如清华大学可以全分为“清华/大学/清华大学”这三种可能性。
    3、搜索引擎模式在精确模式的基础上,对长词再进行词切分,能短则短可分必分,提高召回率,适合搜索引擎分词,比如清华大学可以再切分为“清华/大学/清华大学”这三种可能性。

    jieba分词四种主要功能:

    1、 jieba.cut:该方法接受三个参数,分别是:需要分词的字符串;cut_all 参数用来控制是否采用全模式(True表示全模式,False表示精确模式,该参数默认为是False也就是精确模式);HMM参数用来控制是否适用HMM模型。
    2、 jieba.cut_for_search:该方法接受两个参数,分别是:需要分词的字符串;是否使用HMM模型。这个方法适用搜索引擎构建倒排索引的分词,粒度比较细。
    3、jieba.cutjieba.cut_for_search返回的结构都是可以得到的generator(生成器), 可以使用for循环来获取之前分词后的每一个词语,或者使用jieb.lcutjieba.lcut_for_search 直接返回list。
    4、jieba.Tokenizer(dictionary=DEFUALT_DICT) 可以新建自定义分词器,可用于同时使用不同字典,jieba.dt为默认分词器,所有全局分词相关函数都是该分词器的映射;jieba.posseg.dt表示默认词性标注分词器,也就是分开句子以词语+词性,如:我 r。
    注意:待分词的字符串编码可以是unicode或者UTF-8字符串或者GBK字符串,但是不建议直接输入GBK字符串,可能无法预料会误解码成UTF-8造成乱码。

    jieba分词器添加自定义词典:

    jieba分词器还有一个优点是开发者可以使用自定义词典,以便包含原词库中没有的词,虽然jieba分词可以进行新词识别,但是用自定义词典添加新词可以保证更高的正确率。使用一行代码命令:jieba.load_userdict(filename) # filename为自定义词典的文件路径。在使用的时候,词典的格式和jieba分词器本身的分词器中的词典格式必须保持一致,一个词占一行,每一行分成三部分,一部分为词语,一部分为词频,最后为词性(可以省略),用空格隔开,如:东北大学 5。

    十五、jieba分词操作

    利用jieba进行关键词抽取

    jieba分词中含有analyse模块,在进行关键词提取时可以使用以下代码(sentence表示提取的文本字符串;topk表示返回N个TF-IDF权重下最大的关键字,默认数值是20;withWeight表示是否选择返回关键值对应的权重值,默认为False不返回;,allowPos表示筛选包含指定性的词,默认值为空也就是不筛选;idf_path表示IDF频率文件):

    import jieba.analyse
    jieba.analyse.extract_tags(sentence,topk=N,withWeight=False,allowPos=())
    jieba.analyse.TFIDF(idf_path=None)
    

    或者使用基于TextRank算法的关键词抽取,代码如下;

    import jieba.analyse
    jieba.analyse.textrank(sentence,topk=N,withWeight=False,allowPos=())
    jieba.analyse.TextRank()
    

    注意:可以使用for循环显示打印。

    jieba分词进行并行运行分词

    jieba分词器如果是对于大的文本进行分词会慢,因此可以使用jieba自带的并行分词功能进行分词,其采用的原理是将目标文本按照每行分开后,把各行文本分配到多个Python进程并行分词,然后归并结果,从而获得分词速度的提升。该过程需要基于python自带的multiprocessing模块。注意:目前暂时不支持windows.

    十六、全自动安装 NumPy,首先复制下面代码在cmd平台中安装好pip文件中运行,最后成功验证NumPy安装成功(from numpy import * ,表示导入 numpy 库;eye(4) ,表示生成对角矩阵)。

    python -m pip install numpy scipy matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple
    

    在这里插入图片描述
    在这里插入图片描述

    十七、全自动安装gensim,首先复制下面代码在cmd平台中安装好pip文件中运行。

    python -m pip install -i https://pypi.tuna.tsinghua.edu.cn/simple gensim
    

    在这里插入图片描述

    十八、复制下面源代码程序运行进行分词和训练操作。

    """
    由原始文本进行分词后保存到新的文件
    """
    import jieba
    import numpy as np
    
    filePath='G:/python/wordvec/corpus.txt' # 存储的文件位置
    fileSegWordDonePath ='corpusSegDone.txt'
    print('fenciqian')
    
    # 打印中文列表
    def PrintListChinese(list):
        for i in range(len(list)):
            print (list[i]) 
                    
    # 读取文件内容到列表
    fileTrainRead = []
    with open(filePath,'r',encoding='UTF-8') 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: # 把分词列表写入fileSegWordDonePath路径中的corpusSegDone.txt文件
        for i in range(len(fileTrainSeg)):
            fW.write(fileTrainSeg[i][0])
            fW.write('\n')
    print('fencihou')
           
    
    """
    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]) # 读取当前文件的文件名,返回path最后的文件名,若path以/或\结尾,那么就会返回空值。
    
        # sys.argv[0]:一个从程序外部获取参数的桥梁,外部参数与程序本身没有任何数据联系,sys.arg是一个列表,第一个也就是sys.argv[0]表示程序本身,随后才依次是外部给予的参数。
        logger = logging.getLogger(program) # 获取日志对象,logging模块中最基础的对象
        logging.basicConfig(format='%(asctime)s: %(levelname)s: %(message)s',level=logging.INFO) #  format格式:%(asctime)s: 打印日志的时间; %(levelname)s: 打印日志级别名称;%(message)s: 打印日志信息
        # level: 设置日志级别,默认为logging.WARNING,程序未按预期运行时使用,但并不是错误;logging.INFO表示程序正常运行时使用
        logger.info("running %s" % ' '.join(sys.argv))
     
        # inp为输入语料, outp1为输出模型, outp2为vector格式的模型
        inp = 'corpusSegDone.txt'
        out_model = 'corpusSegDone.model'
        out_vector = 'corpusSegDone.vector'
        print('chushi')
     
        # 训练skip-gram模型
        model = Word2Vec(LineSentence(inp), size=50, window=5, min_count=5, 
                         workers=multiprocessing.cpu_count()) # 将原始的训练语料转化成一个sentence的迭代器,每一次迭代返回的sentence是一个word(utf8格式)的列表。
        # sentences:可以是一个list,对于大语料集,建议使用BrownCorpus,Text8Corpus或lineSentence构建。
        # size:是指特征向量的维度,默认为100。
        # window:窗口大小,表示当前词与预测词在一个句子中的最大距离是多少。
        # min_count: 可以对字典做截断. 词频少于min_count次数的单词会被丢弃掉也就是不会生成词向量, 默认值为5。
        # workers:用于控制训练的并行数,multiprocessing.cpu_count()获取计算机CPU数量
        # 保存模型
        print('xunci')
        model.save(out_model)
        # 保存词向量
        model.wv.save_word2vec_format(out_vector, binary=False)
    

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    十九、复制下面源代码程序运行进行文本词向量计算分析。(博主只是举例说明,大家可以进行修改扩展功能操作分析!)

    from gensim.models import KeyedVectors
    from gensim.test.utils import datapath
    model= KeyedVectors.load_word2vec_format(datapath('G:/python/wordvec/corpusSegDone.vector'), binary=False)
    for key in model.similar_by_word('康师傅',topn=10): #注意分词时有的词语被筛选没有形成词向量,就会导致无法找到自然就无法计算分析
        print(key)
    

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 基于Word2Vec模型和K-Means算法的信息技术文档聚类研究.pdf
  • word2vec.rar

    2019-08-07 09:34:34
    word2vec+维基百科中文语料库训练模型,从最初的数据处理,到最终的模型测试都有详细的代码,可供学习。
  • 【NLP】word2vec 模型

    千次阅读 2022-03-18 21:59:16
    参考:《深度学习从0到1-基于Tensorflow2》 CBOW 连续词袋模型 CBOW(Continuous Bag of-Words) CBOW 模型是给神经网络传入上下文词汇,然后预测目标词汇。 比如我们有一个用于训练的句子是“我爱北京天安门“,...

    参考:《深度学习从0到1-基于Tensorflow2》

    【参考:深入浅出Word2Vec原理解析 - 知乎

    总结

    word2vec的前生 NNLM(神经网络语言模型)

    【参考:词向量技术原理及应用详解(二) - 木屐呀 - 博客园

    word2vec有哪几种实现方式?

    共两种:
    1)用上下文预测中心词cbow(continue bag of word)
    2)利用中心词预测上下文 skip-gram

    从实现方式上看两者只是输入输出发生了变化。

    word2vec的本质是什么?

    当然是无监督学习,因为输出并没有label。但是从输入的和输出的形式上来看,输入的是一对对单词,看起来像是有监督,其实并不是。

    因为词向量的本质可以看出是一个只有一层的神经网络,因此必须有输入,输出。而训练过程或者说目的不是得到预测结果单词,或对单词进行分类。最为关键的是获得hidden layer的权重。也就是说借助了sequence2sequence模型训练过程,得到hidden layer的权重。

    CBOW

    连续词袋模型 CBOW(Continuous Bag of-Words)

    CBOW 模型是给神经网络传入上下文词汇,然后预测目标词汇

    比如我们有一个用于训练的句子是“我爱北京天安门“,可以给模型传入“爱”和“天安门“,然后用”北京“作为要预测的目标词汇。

    而最简单的CBOW 模型就是传入前一个词然后再预测后一个词。

    Skip-Gram

    Skip-Gram 模型是给神经网络传入一个词汇,然后预测其上下文词汇

    PyTorch实现(乞丐版)

    【参考:nlp-tutorial/Word2Vec-Skipgram.py at master · graykode/nlp-tutorial

    【参考:Word2Vec的PyTorch实现_哔哩哔哩_bilibili

    【参考:Word2Vec的PyTorch实现(乞丐版) - mathor
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述
    总结:

    构建word2id 
    构建数据
    - 窗口内的单词为【C-2,C-1,C,C+1,C+2- 数据 [[C,C-2],[C,C-1],[C,C+1],[C,C+2]] 
    - np.eye(voc_size) 用onehot表示单词
    
    送入模型训练
    
    import torch
    import numpy as np
    import torch.nn as nn
    import torch.optim as optim
    import matplotlib.pyplot as plt
    import torch.utils.data as Data
    
    dtype = torch.FloatTensor
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
    sentences = ["jack like dog", "jack like cat", "jack like animal",
      "dog cat animal", "banana apple cat dog like", "dog fish milk like",
      "dog cat animal like", "jack like apple", "apple like", "jack like banana",
      "apple banana jack movie book music like", "cat dog hate", "cat dog like"]
    
    word_sequence = " ".join(sentences).split() # ['jack', 'like', 'dog', 'jack', 'like', 'cat', 'animal',...]
    vocab = list(set(word_sequence)) # build words vocabulary
    word2idx = {w: i for i, w in enumerate(vocab)} # 假设为{'jack':0, 'like':1,'dog':2,...}
    
    # Word2Vec Parameters
    batch_size = 8
    embedding_size = 2  # 2 dim vector represent one word
    C = 2 # window size 窗口内的单词为【C-2,C-1,C,C+1,C+2】
    voc_size = len(vocab)
    
    # 中心词 center
    # 背景词 context 即上下文词汇
    
    skip_grams = []
    # 这里必须起始从第三个词开始,因为window size为2
    for idx in range(C, len(word_sequence) - C):
      # 举例 idx=2 对应word_sequence[idx]单词为'dog',对应的word2idx索引为2 前面两个是'jack', 'like',后面两个是'jack', 'like'
      center = word2idx[word_sequence[idx]] # center word
      # [0,1,3,4] 即前C个词和后C个词
      context_idx = list(range(idx - C, idx)) + list(range(idx + 1, idx + C + 1)) # context word idx 上下文单词的在word_sequence中的下标
      # word_sequence[i]分别对应'jack', 'like' ,'dog', 'jack' 对应的word2idx索引为0,1,0,1
      context = [word2idx[word_sequence[i]] for i in context_idx]
      for w in context:
        skip_grams.append([center, w])
        # skip_grams:[[2,0],[2,1],[2,0],[2,1]]
    
    
    
    def make_data(skip_grams):
      input_data = []
      output_data = []
      for i in range(len(skip_grams)):
        # eye 是单位矩阵,维度为voc_size 以skip_grams[i][0]的值为下标取出在单位矩阵对应的行向量
        # 举例 [2,0] skip_grams[0][0]为2,即取出单位矩阵的第三行(相当于把单词用onehot表示)
        input_data.append(np.eye(voc_size)[skip_grams[i][0]])
        # 标签值 output_data 即为skip_grams[i][1]:0
        output_data.append(skip_grams[i][1])
      return input_data, output_data
    
    input_data, output_data = make_data(skip_grams)
    input_data, output_data = torch.Tensor(input_data), torch.LongTensor(output_data)
    dataset = Data.TensorDataset(input_data, output_data)
    loader = Data.DataLoader(dataset, batch_size, True)
    
    # Model
    class Word2Vec(nn.Module):
      def __init__(self):
        super(Word2Vec, self).__init__()
    
        # W and V is not Traspose relationship
        # 技巧:先确定输入输出的shape,再来推出超参数的shape
        # 下面就是先确定输入X和隐藏层输出的shape,再来反推W
        # 因为X : [batch_size, voc_size],隐藏层需要输出[batch_size, embedding_size],所以W应该是[voc_size,embedding_size]
        self.W = nn.Parameter(torch.randn(voc_size, embedding_size).type(dtype))
        # V 同理
        self.V = nn.Parameter(torch.randn(embedding_size, voc_size).type(dtype))
    
      def forward(self, X):
        # X : [batch_size, voc_size] one-hot  batch_size就相当于图中的minibatch行,图中有voc_size列
        # torch.mm only for 2 dim matrix, but torch.matmul can use to any dim
        hidden_layer = torch.matmul(X, self.W) # hidden_layer : [batch_size, embedding_size]
        # 相当于有voc_size个分类,即词典里面的每个词都是一个种类
        output_layer = torch.matmul(hidden_layer, self.V) # output_layer : [batch_size, voc_size]
        return output_layer
    
    model = Word2Vec().to(device)
    criterion = nn.CrossEntropyLoss().to(device)
    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    
    # Training
    for epoch in range(2000):
      for i, (batch_x, batch_y) in enumerate(loader):
        batch_x = batch_x.to(device)
        batch_y = batch_y.to(device)
        pred = model(batch_x)
        loss = criterion(pred, batch_y)
        if (epoch + 1) % 1000 == 0:
          print(epoch + 1, i, loss.item())
        
        optimizer.zero_grad() 
        loss.backward()
        optimizer.step()
        
    for i, label in enumerate(vocab):
      W, WT = model.parameters() # WT就是self.V 
      x,y = float(W[i][0]), float(W[i][1]) # embedding_size = 2 
      print(label)
      print(x,y)
      plt.scatter(x, y)
      plt.annotate(label, xy=(x, y), xytext=(5, 2), textcoords='offset points', ha='right', va='bottom')
    plt.show()
    
    1000 0 2.187922716140747
    1000 1 2.1874611377716064
    1000 2 2.1020612716674805
    1000 3 2.1360023021698
    1000 4 1.6479374170303345
    1000 5 2.1080777645111084
    1000 6 2.117255687713623
    1000 7 2.5754618644714355
    1000 8 2.375575065612793
    1000 9 2.4812772274017334
    1000 10 2.2279186248779297
    1000 11 1.9958131313323975
    1000 12 1.9666472673416138
    1000 13 1.792773723602295
    1000 14 1.9790289402008057
    1000 15 2.150097370147705
    1000 16 1.8230916261672974
    1000 17 1.9916845560073853
    1000 18 2.2354393005371094
    1000 19 2.253058910369873
    1000 20 1.8957509994506836
    2000 0 2.1660408973693848
    2000 1 1.9071791172027588
    2000 2 1.9131343364715576
    2000 3 2.0996546745300293
    2000 4 1.9192123413085938
    2000 5 1.6349347829818726
    2000 6 2.433778762817383
    2000 7 2.4247307777404785
    2000 8 2.1594560146331787
    2000 9 1.9543298482894897
    2000 10 1.8078333139419556
    2000 11 2.490055561065674
    2000 12 2.1941933631896973
    2000 13 2.463453531265259
    2000 14 2.2849888801574707
    2000 15 1.7784088850021362
    2000 16 1.8803404569625854
    2000 17 1.9645321369171143
    2000 18 2.036078453063965
    2000 19 1.9239177703857422
    2000 20 2.261594772338867
    
    
    animal
    -0.5263756513595581 3.4223508834838867
    apple
    -0.3384515941143036 1.3274422883987427
    milk
    -1.2358342409133911 0.3438951075077057
    hate
    -1.556404709815979 9.134812355041504
    music
    0.31392836570739746 0.2262829840183258
    movie
    2.375382661819458 1.1577153205871582
    dog
    -0.9016568064689636 0.2671743929386139
    jack
    -0.5878503322601318 0.6020950078964233
    cat
    -0.9074932932853699 0.2849980890750885
    banana
    0.47850462794303894 1.1545497179031372
    book
    0.4761728048324585 0.21939511597156525
    like
    -0.1496874839067459 0.6957748532295227
    fish
    -2.37762188911438 0.04009028896689415
    

    在这里插入图片描述

    因为数据集 jack like 动物名 比较多,所以这几个词在空间中也挨得比较近

    sentences = ["jack like dog", "jack like cat", "jack like animal",
      "dog cat animal", "banana apple cat dog like", "dog fish milk like",
      "dog cat animal like", "jack like apple", "apple like", "jack like banana",
      "apple banana jack movie book music like", "cat dog hate", "cat dog like"]
    

    for epoch in range(10000):
    在这里插入图片描述

    展开全文
  • 预训练语言模型的前世今生 - 从Word Embedding到BERT 词向量 主要针对预训练语言模型(一)中的one-hot和词向量 C(ωi)C(\omega_i)C(ωi​)。 one-hot不再赘述,只说缺点:当使用余弦相似度计算向量之间的相似度时,...
  • 百度百科800w+条,20G+ 搜狐新闻400w+条,12G+ 小说:90G左右 模型参数: window=5 min_count=5 ...ps:其它参数见gensim库,执行代码为:Word2Vec(sentence, window=5, min_count=5,size=64, workers=4)
  • wikipedia 训练简体中文得到的word2vec模型,课程作业,仅供大家参考哈 Word2vec,是一群用来产生词向量的相关模型。这些模型为浅而双层的神经网络,用来训练以重新建构语言学之词文本。网络以词表现,并且需猜测...
  • 使用Word2Vec模型将用户和项目嵌入同一空间 MovieLens10M上的首次尝试(无参数调整)RMSE:0.82965120956 管道是: 1-用户单独设置MovieLens10M评​​级(dat)(splitData.py) - 80% of each user's ratings ...
  • 利用Word2Vec模型训练Word Embedding,根据小说中人物、武功、派别或者其他你感兴趣的特征,基于Word Embedding来进行聚类分析。 实验原理 Word Embedding Harris 在 1954 年提出的分布假说( distributional ...
  • 2. 文件读取 首先,我们先完成读取一篇文本文档,去除stopwords,只保留中文字符后进行分词。以下代码包括两个函数: extract_words_one_file()可以对单个文件进行处理,提取所有中文分词并返回值。 单个文档实现...
  • wiki中文语料的word2vec模型构建 遇到的第一个问题: 按照上图操作发现 原因:可能是并没有运行opencc(不知道如何描述) 解决方法:找到解压的opencc文件夹,将要转换的文件放入。 之后在上方输入cmd进入dos窗口 在...
  • from gensim.models import Word2Vec, word2vec import jieba import multiprocessing # 1. 停用词表 def get_stop_words(filepath='stop_words.txt') -> list: return open(filepath, 'r', encoding='utf-8')...
  • 选取wiki中文语料,并使用python完成Word2vec模型,文件共14G,根据需要下载 原始语料库:zhwiki-latest-pages-articles.xml XML的Wiki数据转换为text格式:wiki.zh.txt 中文繁体转换为简体文件:wiki.zh.simp.txt ...
  • word2vec import make_model filepath = os . path . expanduser ( '~/greek_word2vec_cltk/greek_s100_w30_min5_sg.model' ) make_model ( 'tlg' , lemmatize = False , rm_stops = True , size = 100 , window = ...
  • word2vec模型训练保存加载及简单使用

    万次阅读 多人点赞 2019-11-27 18:11:42
    word2vec模型训练保存加载及简单使用 一 word2vec简介 二、模型训练和保存及加载 模型训练 模型保存和加载 模型的增量训练 三、模型常用API 四、文本相似度计算——文档级别 word2vec模型训练保存加载及...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,173
精华内容 11,269
关键字:

word2vec模型