精华内容
下载资源
问答
  • 共现矩阵(共词矩阵):统计文本中两两词组之间共同出现的次数,以此来描述词组间的亲密度 code(我这里求的对角线元素为该字段在文本中出现的总次数): import pandas as pd def gx_matrix(vol_li): # 整合一下,...
    • 共现矩阵(共词矩阵):统计文本中两两词组之间共同出现的次数,以此来描述词组间的亲密度

    code(我这里求的对角线元素为该字段在文本中出现的总次数):

    import pandas as pd
    
    
    def gx_matrix(vol_li):
        # 整合一下,输入是df列,输出直接是矩阵
        names = locals()
        all_col0 = []   # 用来后续求所有字段的集合
        for row in vol_li:
            all_col0 += row
    	    for each in row:  # 对每行的元素进行处理,存在该字段字典的话,再进行后续判断,否则创造该字段字典
    	        try:
    	            for each1 in row:  # 对已存在字典,循环该行每个元素,存在则在已有次数上加一,第一次出现创建键值对“字段:1”
    	                try:
    	                    names['dic_' + each][each1] = names['dic_' + each][each1] + 1  # 尝试,一起出现过的话,直接加1
    	                except:
    	                    names['dic_' + each][each1] = 1  # 没有的话,第一次加1
    	        except:
    	            names['dic_' + each] = dict.fromkeys(row, 1)  # 字段首次出现,创造字典
    
    
        # 根据生成的计数字典生成矩阵
        all_col = list(set(all_col0))   # 所有的字段(所有动物的集合)
        all_col.sort(reverse=False)  # 给定词汇列表排序排序,为了和生成空矩阵的横向列名一致
        df_final0 = pd.DataFrame(columns=all_col)  # 生成空矩阵
        for each in all_col:  # 空矩阵中每列,存在给字段字典,转为一列存入矩阵,否则先创造全为零的字典,再填充进矩阵
            try:
                temp = pd.DataFrame(names['dic_' + each], index=[each])
            except:
                names['dic_' + each] = dict.fromkeys(all_col, 0)
                temp = pd.DataFrame(names['dic_' + each], index=[each])
            df_final0 = pd.concat([df_final0, temp])  # 拼接
    
    
        df_final = df_final0.fillna(0)
    
    
        return df_final
    
    
    if __name__ == '__main__':
        temp1 = ['狗', '狮子', '孔雀', '猪']
        temp2 = ['大象', '狮子', '老虎', '猪']
        temp3 = ['大象', '北极熊', '老虎', '猪']
        temp4 = ['大象', '狗', '老虎', '小鸡']
        temp5 = ['狐狸', '狮子', '老虎', '猪']
        temp_all = [temp2, temp1, temp3, temp4, temp5]
        vol_li = pd.Series(temp_all)
        df_matrix = gx_matrix(vol_li)
        print(df_matrix)
    

    输入是整成这个样子的series
    在这里插入图片描述
    求出每个字段与各字段的出现次数的字典
    在这里插入图片描述
    最后转为df

    在这里插入图片描述

    补充一点:这里如果用大象所在列,除以大象出现的次数,比值高的,表明两者一起出现的次数多,如果这列比值中,有两个元素a和b的比值均大于0.8(也不一定是0.8啦),就是均比较高,则说明a和b和大象三个一起出现的次数多!!!

    即可以求出文本中经常一起出现的词组搭配,比如这里的第二列,大象一共出现3次,与老虎出现3次,与猪出现2次,则可以推导出大象,老虎,猪一起出现的概率较高。

    也可以把出现总次数拎出来,放在最后一列,
    则代码为:

    # 计算每个字段的出现次数,并列为最后一行
        df_final['all_times'] = ''
        for each in df_final0.columns:
            df_final['all_times'].loc[each] = df_final0.loc[each, each]
    

    放在上述代码df_final = df_final0.fillna(0)的后面即可
    结果为
    在这里插入图片描述
    不好意思啊,我第一次放代码上来的时候中间有一块缩进错了,感谢下面提出问题的这位同学的提醒,现在是更正过的代码!!!

    展开全文
  • 共现矩阵:也称为共词矩阵,能表明两个词之间的关系程度 首先假设我们有两句话,如下图所示,通过jieba分词和停用词词表过滤,我们可以得到以下结果: test = ["E的B的C", "B的C的D"] 接着我们可以通过关键词来...

    共现矩阵

    共现矩阵:也称为共词矩阵,能表明两个词之间的关系程度

    • 首先假设我们有两句话,如下图所示,通过jieba分词和停用词词表过滤,我们可以得到以下结果:
    test = ["E的B的C", "B的C的D"]
    

    在这里插入图片描述

    • 接着我们可以通过关键词来构建共现矩阵,可以看到,BE同时出现一次,则其权重为1,BC同时出现两次,则其权重为2,以此类推
      在这里插入图片描述
    • 由此可以看出,共现矩阵是一个对角矩阵。
    • 共现矩阵的[0][0]为空。
    • 共现矩阵的第一行第一列是关键词。
    • 对角线全为0。
    • 共现矩阵其实是一个对称矩阵。

    代码实现

    # -*- coding: utf-8 -*-
    import networkx as nx
    import matplotlib.pyplot as plt
    import jieba
    import numpy as np
    
    test = ["E的B的C", "B的C的D"]
    
    stopwords = [line.strip() for line in
                 open('stopwords_unduplicated.txt', encoding='UTF-8').readlines()]  # 停用词词表
    cut_text1 = jieba.cut(test[0].replace(' ', ''))
    cut_text2 = jieba.cut(test[1].replace(' ', ''))
    results1 = []
    for word in cut_text1:
        if word not in stopwords:
            if word != '\t':
                results1.append(word)
    print("result1 is :", results1)
    
    results2 = []
    for word in cut_text2:
        if word not in stopwords:
            if word != '\t':
                results2.append(word)
    print("result2 is :", results2)
    
    # 合并列表
    result = list(set(results1).union(set(results2)))
    print("union result is :", result)
    x = len(result)
    # 创建二维矩阵
    matrix = [[0 for x in range(x+1)] for y in range(x+1)]
    weight = 0
    for i in range(0, x):
        matrix[0][i+1] = result[i]
    for j in range(0, x):
        matrix[j+1][0] = result[j]
    
    
    # print(np.array(matrix))
    
    for i in range(1, x+1):  # i的范围为 1 到 词数
        for j in range(1, x + 1 - i):  # n的范围为 1到(词数-i)   i+n的范围为 i 到 词数
            word1 = result[i - 1]
            word2 = result[i + j - 1]
            print("In %d iteration, for No.%d word pair:" % (i, j), word1, word2)
            Common_weight = 0
    
            if word1 in results1 and word1 in results2 and word2 in results1 and word2 in results2:
                # 如果word1和word2同时出现在两个句子中,权重为2
                Common_weight = 2
            elif (word1 in results2) and (word2 in results2):
                Common_weight = 1
            elif (word1 in results1) and (word2 in results1):
                Common_weight = 1
            matrix[i][i + j] = Common_weight    # 该矩阵为对角矩阵
            matrix[i + j][i] = Common_weight
            print("For (%s,  %s), the common_weight is : %d" % (word1, word2, Common_weight))
    print("The co-occurrence matrix is:")
    # np.array() 将二维数组换行输出
    print(np.array(matrix))
    

    networkx可视化

    代码实现

    # 定义有向图
    DG = nx.Graph()
    # 添加五个节点(列表)
    DG.add_nodes_from(['B', 'C', 'D', 'E'])
    print(DG.nodes())
    # 添加边(列表)
    DG.add_edge('B', 'D', weight=1)
    DG.add_edge('B', 'C', weight=2)
    DG.add_edge('B', 'E', weight=1)
    DG.add_edge('C', 'D', weight=1)
    DG.add_edge('C', 'E', weight=1)
    DG.add_edge('D', 'E', weight=1)
    # DG.add_edges_from([('B', 'C'), ('B', 'D'), ('B', 'E'), ('C','D'),('C','E'),('D','E')])
    print("The edges for this graph are: ", DG.edges())
    # 绘制图形 设置节点名显示\节点大小\节点颜色
    colors = ['red', 'green', 'pink', 'orange']
    # 按权重划分为重权值得边和轻权值的边
    # 按权重划分为重权值得边和轻权值的边
    edge_large = [(u, v) for (u, v, d) in DG.edges(data=True) if d['weight'] > 1.5]
    edge_small = [(u, v) for (u, v, d) in DG.edges(data=True) if d['weight'] <= 1.5]
    # 节点位置
    pos = nx.spring_layout(DG)  # positions for all nodes
    # 首先画出节点位置
    # nodes
    nx.draw_networkx_nodes(DG, pos, node_size=500, node_color=colors)
    # 根据权重,实线为权值大的边,虚线为权值小的边
    # edges
    nx.draw_networkx_edges(DG, pos, edgelist=edge_large,
                           width=6)
    nx.draw_networkx_edges(DG, pos, edgelist=edge_small,
                           width=6, alpha=0.5, edge_color='b', style='dashed')
    
    # labels标签定义
    nx.draw_networkx_labels(DG, pos, font_size=20, font_family='sans-serif')
    
    plt.axis('off')
    plt.savefig('fig.png', bbox_inches='tight')
    

    在这里插入图片描述

    问题记录

    1. pycharm画图:warnings.warn("This figure includes Axes that are not
      compatible "
      报错原因在于plt.tight_layout在某些情况下不能顺利工作
      解决方法:删掉plt.show(),加上plt.savefig(‘fig.png’,bbox_inches=‘tight’)

    参考文章

    [Pyhon大数据分析] 五.人民网新闻话题抓取及Gephi构建主题知识图谱
    python 共现矩阵的实现
    python 共现矩阵构建
    python networkx 根据图的权重画图实现

    展开全文
  • python 共现矩阵构建

    千次阅读 热门讨论 2019-04-26 19:44:02
    1.什么是共词矩阵共词矩阵共词矩阵能表明两个词之间的关系程度 2.构建过程: 数据准备: 假设有10篇文本,我们将从这10篇文本中,提取每一篇的分词结果,并存入Single_text_list中。再将由10篇文章的关键词列表...

    1.什么是共现矩阵:
    共现矩阵:也成为共词矩阵,能表明两个词之间的关系程度

    2.构建过程:
    数据准备:
    假设有10篇文本,我们将从这10篇文本中,提取每一篇的分词结果,并存入Single_text_list中。再将由10篇文章的关键词列表合为一个列表Full_text_list,

    Full_text_list=[ [文章1切词结果],[文章2切词结果] ...]
    

    构建:
    1.对每篇文章作词频统计,选出其排名前100的词及词频(或者全部词频统计结果)
    2.对词频统计结果求并集,结果存入一个字典中,keys()为词,values()为每个词的词频。再将所有特征词存入Full_Feature_word列表中,其对应的词频存入Full_Feature_weight列表中。
    3.建一个二维矩阵Common_matrix其大小为: 总特征词词数x总特征词词数 (也就是共词矩阵)。其横竖分别对应总特征词中的每个词,例如矩阵第3行第5列的数值即代表,特征词第3个与特征词第5个的关系程度,同时它的值也等于该矩阵第5行第3列的值。(对,没错,它也是一个对角矩阵)
    4.将共词矩阵对角线上元素赋值为它自身在所有文章出现次数。
    5.循环遍历特征词列表,构建全部两个词之间的组合,再遍历每一篇文章的切词结果,如果该两个词在同一片文章中出现,则该两词的权重+1,再将其存入共词矩阵的对应位置中。例如特征词第6个和特征词第8个,这两个词的权重为3,则将其权重3存入共词矩阵的第6行第8列和第8行第6列中。

    3.重要功能:
    在构建好共词矩阵后,我们需要能够获取 总特征词特征词所对应的共词矩阵。有了这些,我们还希望能够获取一个词与所有特征词的关系列表

    4.python代码
    在这里我构建了一个共词矩阵的类,该类接收 Full_text_list=[ [文章1切词结果],[文章2切词结果] …]参数(即每篇文章分词而得到的矩阵),该类可以返回特征词列表,共词矩阵,并定义了一个方法:参数为一个词,方法返回 该词对应的共词矩阵的那一行

    import os
    import jieba
    import collections
    import numpy as np
    from collections import Counter
    
    class Coword_matrix(object):    #定义了一个共词矩阵的类  初始化参数(切词后的嵌套列表 [[文章1切词结果],[文章2切词结果]...])
        def __init__(self,Fulltext_cut_content):    #传入切词后的嵌套列表,可以得到self.Fulltext_cut_content,self.Full_Feature_word, self.Common_matrix
            # self.Fulltext_cut_content_str = [" ".join(i) for i in self.Fulltext_cut_content]    也可以将列表转化为字符串,使后面对全文本的遍历更快,for...in... 遍历str比遍历list更快!
            self.Fulltext_cut_content=Fulltext_cut_content
            Full_familiar_Feature = {}  # 储存特征和权重,为dict格式
            for Single_text_feature_list in Fulltext_cut_content:
                Single_text_feature_sort_dict = collections.Counter(Single_text_feature_list)  # 词频统计
                Single_text_feature_sort_result = Single_text_feature_sort_dict.most_common(100)  # 选出词频统计排名前100的,请按需选择,无参表示全部排序结果,会运行比较长的时间
                Full_familiar_Feature = dict(Counter(dict(Single_text_feature_sort_result))+Counter(dict(Full_familiar_Feature)))  # 化为Counter后 作并集,再将结果化为dict
            self.Full_Feature_word,self.Full_Feature_weight= list(Full_familiar_Feature.keys()), list(Full_familiar_Feature.values())
    
            self.Common_matrix = np.empty((len(self.Full_Feature_word), len(self.Full_Feature_word)))  # 构建共词矩阵,大小为[词数]x[词数]
            for row in range(len(self.Full_Feature_word)):  # 将共词矩阵 对角线上元素=它自身在所有文章出现次数
                for column in range(len(self.Full_Feature_word)):
                    if column == row:
                        self.Common_matrix[row][column] = int(self.Full_Feature_weight[row])
            for i in range(len(self.Full_Feature_word)):  # i的范围为 1 到 词数
                for n in range(1, len(self.Full_Feature_word) - i):  # n的范围为 1到(词数-i)   i+n的范围为 i 到 词数
                    word1 = self.Full_Feature_word[i]
                    word2 = self.Full_Feature_word[i + n]
                    Common_weight = 0
                    for Single_Text_Cut in self.Fulltext_cut_content:  
                    #遍历每一篇文章的切词结果,如果word1和word2在同一片文章中出现,则该两词的权重+1
                    #也可以将Fulltext_cut_content化为字符串后进行遍历,这样更快!
                    #如果希望统计word1和word2在同一片文章中出现的最小次数,则可以使用 str.count(),或者 list.Counter分别计算次数,再取最小值 赋予权重
                        if ((word1 in Single_Text_Cut) and (word2 in Single_Text_Cut)):
                            Common_weight += 1
                    self.Common_matrix[i][i + n] = Common_weight    #该矩阵为对角矩阵
                    self.Common_matrix[i + n][i] = Common_weight
    
        def get_Full_Feature_word(self):    #返回特征词列表
            return self.Full_Feature_word
    
        def get_Common_matrix(self):    #返回共词矩阵
            return self.Common_matrix
    
        def return_word_row(self,word):    #定义一个方法 参数为一个词,函数返回 该词对应的共词矩阵的那一行
            if word not in self.Full_Feature_word:
                print(word + "   该词不在特征词中!")
            else:
                for row in range(len(self.Full_Feature_word)):
                    if word == self.Full_Feature_word[row]:
                        return self.Common_matrix[row]
    '''
    self.Fulltext_cut_content   初始化参数(切词后的嵌套列表 [[文章1切词结果],[文章2切词结果]...])
    Full_familiar_Feature = {}  # 储存特征和权重,为dict格式
    self.Full_Feature_word  特征词列表
    self.Common_matrix 共词矩阵
    '''
    

    如何对初始文本进行处理,转化为Full_text_list=[ [文章1切词结果],[文章2切词结果] …],其python代码如下:

    def delstopwordslist(classsstr):    #去停用词
        stopwords = [line.strip() for line in open('stop.txt', encoding='UTF-8').readlines()]    #注意停用词文本名称和所在位置
        outstr = ''
        classsstr=classsstr.split(' ')
        for word in classsstr:
            if ((word not in stopwords) and (len(word)>1)):    #去掉停用词和长度小于1的
                outstr += word
                outstr += ' '
        return outstr
    
    def Read_Full_Cut_List(path="测试文本"):
        filenames=os.listdir(path)
        Fulltext_cut_content = []
        for i in filenames:
            Single_text_content = ''
            with open(path+'/'+i,"r",encoding='UTF-8') as f:
                for centence in f.readlines():
                    centence = centence.strip().replace(' ', '').replace(' ', '')
                    Single_text_content += centence
                text = ' '.join(jieba.cut(Single_text_content))    #分词
            Fulltext_cut_content.append(delstopwordslist(text).split())    #去停用词和长度小于1的
        return Fulltext_cut_content    #每篇文章的分词结果str,再apend到一个Fulltext_cut_content中
    

    测试文本格式如下:
    在这里插入图片描述
    测试代码:

    if __name__=="__main__":
        Fulltext_cut_content=Read_Full_Cut_List("测试文本")
        Coword_one=Coword_matrix(Fulltext_cut_content)	#对该类传入初始化参数
        print('=========================特征词===========================')
        print(Coword_one.get_Full_Feature_word())
        print('========================共词矩阵===========================')
        print(Coword_one.get_Common_matrix())
        print('===============“娱乐”词与所有特征词的关系程度===============')
        print(Coword_one.return_word_row("娱乐"))
    

    结果:
    在这里插入图片描述
    以上,如果有什么不清楚的地方,可以在评论区说明,将上面代码组合一下,是可以跑通的,可以试一试。

    展开全文
  • 自编软件使用技能视频演示(一)最新整理完整版的,从收集数据 到 共词矩阵 到 图谱。在做社会网络分析时,首先需要得到共现矩阵,如关键词共现矩阵、作者共现矩阵、机构共现矩阵等。可是如何把从知网里导出的这些数据...

    自编软件使用技能视频演示(一)

    最新整理完整版的,从收集数据 到 共词矩阵 到 图谱。

    在做社会网络分析时,首先需要得到共现矩阵,如关键词共现矩阵、作者共现矩阵、机构共现矩阵等。

    可是如何把从知网里导出的这些数据做成共现矩阵就比较麻烦了。当然可以使用bibexcel或者《书目共现分析系统》(Bibliographic Item Co-Occurrence Matrix Builder,BICOMB)。

    以下是我的经历:

    一年前论文需要自学bibexecl和ucinet两个软件,bibexcel操作过程相当狗血,每天都在摸索,学了好几天,为得到最终结果光步骤总结了三页纸,各种变换格式,可能是英文软件的原因,针对中文比较麻烦吧。当时想如果有一键生成这种结果多好,一年后终于自己实现啦,并且同时把ucinet画图功能也一键生成了!

    基于此,我写了个“小”软件,可以将知网里导出的关键词一步生成共现矩阵,相异矩阵(用于系统聚类、多维尺度分析等),社会网络图谱,从毫无意义的步骤中抽离出来,节约很多很多时间。

    具体如下:

    此步骤是1.0版本,目前更新到1.4版本,有优化的地方。可关注微信公众号“学术点滴”获取最新版本(1.4版)教学视频~~~

    1.0版软件界面如下:

    从知网里导出的原始数据如下,以关键词为例:

    正式开始转换:

    1、打开软件,点击分析,点击 转共现矩阵 ,

    2、导入 关键词 ,其中文件路径自己选择对应关键词表就行,转换结果需要自己命名excel表

    3、点击转换按钮,显示**转换成功**:

    4、结果如下:

    同理可得社会网络图谱,如下:

    优点:从大量繁琐软件步骤和数据格式转化中解脱出来,节约大量时间。

    由于很多人后台回复软件如何使用,因此做了一个视频教程,以供大家快速掌握如何做出共现词表,

    具体视频点击下方“阅读原文”即可获取观看。

    6000篇文章用时5秒左右,50000篇文章用时60秒左右

    同时1.4版本添加了自定义截取关键词频数,统计关键词频数

    所以是时候抛弃那些做关键词共现的软件了。

    后台回复: ”科学分析软件” 免费获取此软件“1.3版本”。

    可关注微信公众号“学术点滴”获取最新版本(1.4版)教学视频~~~

    展开全文
  • Python 实现文本共现网络分析

    千次阅读 2021-01-23 19:13:30
    共词网络方法在知识网络研究中应用普遍,最为常见的就是利用论文关键词及其共现关系构建共词矩阵,进而映射为共词网络并可视化,从而来揭示某一学科某一领域某一主题的研究热点与趋势、知识结构与演化等。...
  • 通过scikit-learn计算文本内容的tfidf并构造N*M矩阵(N个文档 M个特征); 2.调用scikit-learn中的K-means进行文本聚类; 3.使用PAC进行降维处理,每行文本表示成两维数据; 4.最后调用Matplotlib显示聚类效果图...
  • 目录实现思路实验准备一、读取需要分类的文本二、去停用三、转为词频矩阵/TF-IDF四、生成测试集和训练集五、logistic 回归实现六、模型预测 实现思路 1.读取需要分类的文本 2.转为袋模型(词频矩阵或tfi-df) 3....
  • 接下来根据两两关键词在文本中同时出现的频次构建共词矩阵,这个代码怎么实现? 或者在网上看到一段代码,不太会改, fo = open('dic_test.txt', 'w+', ...

空空如也

空空如也

1 2
收藏数 35
精华内容 14
关键字:

python共词矩阵

python 订阅