精华内容
下载资源
问答
  • 共现矩阵生成器.zip

    2019-11-27 09:37:07
    共现矩阵生成python实现 包括源代码和打包好的exe Co-occurrence_Matrix.exe 软件本体 data.csv 原始数据 上面让你准备的那个 node.csv 节点数据 (包含节点名称+词频数) edge.csv 节点关系的三元...
  • 共现矩阵

    2021-05-22 09:44:26
    希望将共现矩阵加入到查重算法中; 共现矩阵:主要用于发现主题,解决词向量相近关系的表示。 这个特性并不能很好地被查重方法利用,至少在处理代码时作用不大; 或许可以考虑处理正文。 做法 这里给出一种共现矩阵...

    想法

    希望将共现矩阵加入到查重算法中;
    共现矩阵:主要用于发现主题,解决词向量相近关系的表示。
    这个特性并不能很好地被查重方法利用,至少在处理代码时作用不大;
    或许可以考虑处理正文。

    做法

    这里给出一种共现矩阵的实现:
    可以遍历一个文件夹下的文件,给出词频的共现矩阵(中文)。
    code:

    # coding:utf-8
    import numpy as np
    import pandas as pd
    import jieba.analyse
    import os
    
    # 获取关键词
    def Get_file_keywords(dir):
        data_array = []  # 每篇文章关键词的二维数组
        set_word = []  # 所有关键词的集合
    
        try:
    
            for home, dirs, files in os.walk(dir):  # 遍历文件夹下的每篇文章
                for filename in files:
                    fullname = os.path.join(home, filename)
                    f = open(fullname, 'r', encoding='utf-8')
                    sentence = f.read()
                    words = " ".join(jieba.analyse.extract_tags(sentence=sentence, topK=30, withWeight=False,
                                                                allowPOS=('n')))  # TF-IDF分词
                    words = words.split(' ')
                    data_array.append(words)
                    for word in words:
                        if word not in set_word:
                            set_word.append(word)
            set_word = list(set(set_word))  # 所有关键词的集合
            return data_array, set_word
        except Exception as reason:
            print('出现错误:', reason)
    
            return data_array, set_word
    
    
    # 初始化矩阵
    def build_matirx(set_word):
        edge = len(set_word) + 1  # 建立矩阵,矩阵的高度和宽度为关键词集合的长度+1
        '''matrix = np.zeros((edge, edge), dtype=str)'''  # 另一种初始化方法
        matrix = [['' for j in range(edge)] for i in range(edge)]  # 初始化矩阵
        matrix[0][1:] = np.array(set_word)
        matrix = list(map(list, zip(*matrix)))
        matrix[0][1:] = np.array(set_word)  # 赋值矩阵的第一行与第一列
        return matrix
    
    
    # 计算各个关键词的共现次数
    def count_matrix(matrix, formated_data):
        for row in range(1, len(matrix)):
            # 遍历矩阵第一行,跳过下标为0的元素
            for col in range(1, len(matrix)):
                # 遍历矩阵第一列,跳过下标为0的元素
                # 实际上就是为了跳过matrix中下标为[0][0]的元素,因为[0][0]为空,不为关键词
                if matrix[0][row] == matrix[col][0]:
                    # 如果取出的行关键词和取出的列关键词相同,则其对应的共现次数为0,即矩阵对角线为0
                    matrix[col][row] = str(0)
                else:
                    counter = 0  # 初始化计数器
                    for ech in formated_data:
                        # 遍历格式化后的原始数据,让取出的行关键词和取出的列关键词进行组合,
                        # 再放到每条原始数据中查询
                        if matrix[0][row] in ech and matrix[col][0] in ech:
                            counter += 1
                        else:
                            continue
                    matrix[col][row] = str(counter)
        return matrix
    
    
    def main():
        formated_data, set_word = Get_file_keywords(r'E:\python\py_pick\result')
        print(set_word)
        print(formated_data)
        matrix = build_matirx(set_word)
        matrix = count_matrix(matrix, formated_data)
        data1 = pd.DataFrame(matrix)
        data1.to_csv('data.csv', index=0, columns=None, encoding='utf_8_sig')
    
    main()
    
    展开全文
  • 一个基本的共现函数,主要供学生使用
  • 要使用此软件包,您需要一个稀疏共现矩阵。 该矩阵由嵌套字典表示,这些字典使用int作为具有0索引的键。 例如,下面有3个索引的语料库。 低于0的情况与2发生3.5次: import glove cooccur = { 0 : { 0 : 1.0 , ...
  • 共现矩阵生成

    2011-11-02 19:29:58
    可生成基于词频共现的对称MDS矩阵,然后输入SPSS进行聚类。
  • python 共现矩阵的实现

    千次阅读 2020-02-29 15:26:58
    文章目录前言什么是共现矩阵共现矩阵的构建思路 前言 最近在学习python词库的可视化,其中有一个依据共现矩阵制作的可视化,感觉十分炫酷,便以此复刻。 什么是共现矩阵 比如我们有两句话: ls = ['我永远喜欢三上...

    1.前言

    最近在学习python词库的可视化,其中有一个依据共现矩阵制作的可视化,感觉十分炫酷,便以此复刻。
    在这里插入图片描述

    2.项目背景

    本人利用爬虫获取各大博客网站的文章,在进行jieba分词,得到每篇文章的关键词,对这些关键词进行共现矩阵的可视化。

    3.什么是共现矩阵

    比如我们有两句话:

    ls = ['我永远喜欢三上悠亚', '三上悠亚又出新作了']
    

    在jieba分词下我们可以得到如下效果:
    在这里插入图片描述
    我们就可以构建一个以关键词的共现矩阵:

    ['',    '我', '永远', '喜欢', '三上', '悠亚', '又', '出', '新作', '了']
    ['我',    0,      1,     1,     1,    1,    0,    0,      0,     0]
    ['永远',  1,      0,     1,      1,    1,    0,    0,     0,     0] 
    ['喜欢'   1,      1,     0,      1,    1,    0,    0,     0,     0]
    ['三上',  1,      1,     1,      0,    1,    1,    1,     1,     1]
    ['悠亚',  1,      1,     1,      1,    0,    1,    1,     1,     1]
    ['又',    0,      0,     0,      1,    1,    0,    1,     1,     1]
    ['出',    0,      0,     0,      1,    1,    1,    0,     1,     1]
    ['新作',  0,      0,     0,      1,    1,    1,    1,     0,     1]
    ['了',    0,      0,     0,      1,    1,    1,    1,     1,     0]]
    

    解释一下,“我永远喜欢三上悠亚”,这一句话中,“我”和“永远”共同出现了一次,在共现矩阵对应的[ i ] [ j ]和[ j ][ i ]上+1,并依次类推。
    基于这个原因,我们可以发现,共现矩阵的特点是:

    1. 共现矩阵的[0][0]为空。
    2. 共现矩阵的第一行第一列是关键词。
    3. 对角线全为0。
    4. 共现矩阵其实是一个对称矩阵。

    当然,在实际的操作中,这些关键词是需要经过清洗的,这样的可视化才干净。

    4.共现矩阵的构建思路

    1. 每篇文章关键词的二维数组data_array。
    2. 所有关键词的集合set_word。
    3. 建立关键词长度+1的矩阵matrix。
    4. 赋值矩阵的第一行与第一列为关键词。
    5. 设置矩阵对角线为0。
    6. 遍历formated_data,让取出的行关键词和取出的列关键词进行组合,共现则+1。

    5.共现矩阵的代码实现

    # coding:utf-8
    import numpy as np
    import pandas as pd
    import jieba.analyse
    import os
    
    
    # 获取关键词
    def Get_file_keywords(dir):
        data_array = []  # 每篇文章关键词的二维数组
        set_word = []  # 所有关键词的集合
    
        try:
            fo = open('dic_test.txt', 'w+', encoding='UTF-8')
            # keywords = fo.read()
            for home, dirs, files in os.walk(dir):  # 遍历文件夹下的每篇文章
                for filename in files:
                    fullname = os.path.join(home, filename)
                    f = open(fullname, 'r', encoding='UTF-8')
                    sentence = f.read()
                    words = " ".join(jieba.analyse.extract_tags(sentence=sentence, topK=30, withWeight=False,
                                                                allowPOS=('n')))  # TF-IDF分词
                    words = words.split(' ')
                    data_array.append(words)
                    for word in words:
                        if word not in set_word:
                            set_word.append(word)
            set_word = list(set(set_word))  # 所有关键词的集合
            return data_array, set_word
        except Exception as reason:
            print('出现错误:', reason)
            return data_array, set_word
    
    
    # 初始化矩阵
    def build_matirx(set_word):
        edge = len(set_word) + 1  # 建立矩阵,矩阵的高度和宽度为关键词集合的长度+1
        '''matrix = np.zeros((edge, edge), dtype=str)'''  # 另一种初始化方法
        matrix = [['' for j in range(edge)] for i in range(edge)]  # 初始化矩阵
        matrix[0][1:] = np.array(set_word)
        matrix = list(map(list, zip(*matrix)))
        matrix[0][1:] = np.array(set_word)  # 赋值矩阵的第一行与第一列
        return matrix
    
    
    # 计算各个关键词的共现次数
    def count_matrix(matrix, formated_data):
        for row in range(1, len(matrix)):
            # 遍历矩阵第一行,跳过下标为0的元素
            for col in range(1, len(matrix)):
                # 遍历矩阵第一列,跳过下标为0的元素
                # 实际上就是为了跳过matrix中下标为[0][0]的元素,因为[0][0]为空,不为关键词
                if matrix[0][row] == matrix[col][0]:
                    # 如果取出的行关键词和取出的列关键词相同,则其对应的共现次数为0,即矩阵对角线为0
                    matrix[col][row] = str(0)
                else:
                    counter = 0  # 初始化计数器
                    for ech in formated_data:
                        # 遍历格式化后的原始数据,让取出的行关键词和取出的列关键词进行组合,
                        # 再放到每条原始数据中查询
                        if matrix[0][row] in ech and matrix[col][0] in ech:
                            counter += 1
                        else:
                            continue
                    matrix[col][row] = str(counter)
        return matrix
    
    
    def main():
        formated_data, set_word = Get_file_keywords(r'D:\untitled\test')
        print(set_word)
        print(formated_data)
        matrix = build_matirx(set_word)
        matrix = count_matrix(matrix, formated_data)
        data1 = pd.DataFrame(matrix)
        data1.to_csv('data.csv', index=0, columns=None, encoding='utf_8_sig')
    
    
    main()
    
    展开全文
  • 将高维数据组转换为二维数据组,方便数据处理工作人员的数据分析,并包含自然语言处理
  • 基于多尺度共现矩阵的铜浮选故障状态识别
  • 并以CSSCI数据库中1998—2008年“信息可视化”引文数据为例,数据经过预处理后,由Bibexcel构建其知识单元共现矩阵,利用Ucinet、Netdraw软件,实现了作者共现、关键词共现、引文共现的可视化分析。该研究扩展了...
  • IPC分类号的共现矩阵,技术融合,PYTHON代码
  • 文章目录背景Java实现共现矩阵程序运行结果关于社区发现算法 背景 最近,在做研究的时候,需要使用到Louvain社区检测算法(Louvain Community Detection)。而该算法的输出是节点-节点或节点-节点-权重。如节点-节点的...

    本文作者:合肥工业大学 电子商务研究所 钱洋 email:1563178220@qq.com 。
    内容可能有不到之处,欢迎交流。
    未经本人允许禁止转载。

    背景

    最近,在做研究的时候,需要使用到Louvain社区检测算法(Louvain Community Detection)。而该算法的输出是节点-节点或节点-节点-权重。如节点-节点的格式如下:

    0 1
    0 2
    0 3
    0 4
    1 3
    2 5
    3 5
    4 6
    ...
    

    而对于一些网络数据,节点与节点之间是存在权重的(表明节点之间的连接强弱)。例如,文献合作网络:
    在这里插入图片描述
    在比如,点击流网络:
    在这里插入图片描述
    上面的点击流网络,可以转化成如下形式的共现矩阵:
    在这里插入图片描述
    即可表示A-B的权重为4,A-C的权重为2等。

    而本博客的目的,是将如下数据转化成节点-节点-权重的形式:

    470 657 66
    2139 3204 3677 470 657
    109 111 2778 2980 3397 3405 3876 448
    117 4147
    375 66 470 657
    4083 66
    2541 3059
    2988 3104 375
    2088 2123 2304 2615 2778 3080 3195
    2123 2556
    16 453 50 813
    117 164 2561 3589 588 66
    659 771 3204 3677
    

    转化后的数据形式如下:

    470 66 2
    66 3589 1
    117 3589 1
    657 3204 1
    375 3104 1
    2123 2556 1
    2304 3195 1
    ...
    

    下面,介绍如何使用Java实现这一过程。

    Java实现共现矩阵

    下图为工程的目录结构:
    在这里插入图片描述

    首先,介绍一下文件操作类FileUtils。其中,readLines()负责读取数据,将writeLines()方法负责将ArrayList类型的数据写入指定文档,writeHashMap()方法负责将Hashtable类型的数据写入指定文档。
    该类用于读取文本文件,将ArrayList

    package cooccurrence;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.util.ArrayList;
    import java.util.Hashtable;
    import java.util.Map;
    
    public class FileUtils {
    	/**
    	 * 读文件
    	 * @param file 输入文件
    	 * @param lines 多行文本转化成集合
    	 * @param code 输出文件编码
    	 */
    	public static void readLines(String file, ArrayList<String> lines, String code) {
    		BufferedReader reader = null;
    		try {
    			reader = new BufferedReader( new InputStreamReader( new FileInputStream( new File(file)),code));
    			String line = null;
    			while ((line = reader.readLine()) != null) {
    				lines.add(line);
    			}
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			if (reader != null) {
    				try {
    					reader.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    
    	}
    	/**
    	 * 写文件
    	 * @param file 输入文件
    	 * @param lines 集合内容
    	 * @param code 输出文件编码
    	 */
    	public static void writeLines(String file, ArrayList<?> lines, String code) {
    		BufferedWriter writer = null;
    		try {
    			writer = new BufferedWriter( new OutputStreamWriter( new FileOutputStream( new File(file)),code));
    			for (int i = 0; i < lines.size(); i++) {
    				writer.write(lines.get(i) + "\n");
    			}
    
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			if (writer != null) {
    				try {
    					writer.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    	/**
    	 * 写文件
    	 * @param file 输入文件
    	 * @param hashmap HashMap集合
    	 * @param code 输出文件编码
    	 */
    	public static void writeHashMap(String file, Hashtable<?, ?> hashmap, String code) {
    		BufferedWriter writer = null;
    		try {
    			writer = new BufferedWriter( new OutputStreamWriter( new FileOutputStream( new File(file)),code));
    			for (Map.Entry<?, ?> entry : hashmap.entrySet()) {
    				writer.write(entry.getKey() + " " + entry.getValue() + "\n");
    			}
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			if (writer != null) {
    				try {
    					writer.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }
    
    

    下面,介绍核心的算法Pair:

    package cooccurrence;
    
    
    public class Pair {
    	public int w1;
    	public int w2;
    	public Pair(int w1,int w2){
    		this.w1 = min(w1, w2);
    		this.w2 = max(w1, w2);
    	}
    	private static int min(int x,int y){
    		if(x<y)
    			return x;
    		else
    			return y;
    	}
    	private static int max(int x,int y){
    		if(x>y)
    			return x;
    		else
    			return y;
    	}
    }
    
    

    该类中的构造方法Pair()输入的是两个编过号的词,经过方法处理之后,将w1赋值为较小数字编号的词,将w2赋值为较大编号的词。举个例子:

    输入:w1=1,w2=2
    或输入:w1=2,w2=1
    
    其输出结果都是:w1=1,w2=2
    

    通过这种操作就会保证,生成的词对都是“小-大”的形式。

    下面介绍CooccurrenceMatrix类。

    package cooccurrence;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Hashtable;
    import java.util.List;
    import java.util.Map;
    
    public class CooccurrenceMatrix {
    	//word to index
    	public Map<String, Integer> wordToIndexMap = new HashMap<String, Integer>();
    	//index to String word 
    	public List<String> indexToWordMap = new ArrayList<String>();  
    	public  int [][] docword;//word index array
    	public  int M; // 文档总数
    	public ArrayList<String> wordpair=new ArrayList<>();
    	public String code;  //输入输出文件编码
    	public String outputFileP; //输出共现词对
    	public String outputFilePMatr; //输出共现矩阵
    	/**
    	 * 创建一个构造方法
    	 * @param inputFile 输入文件
    	 * @param inputFileCode 输入文件和输入文件的编码
    	 * @param outputFilePair  词对输出文件
    	 * @param outputFile  词对频率输出文件
    	 */
    	public CooccurrenceMatrix(String inputFile, String inputFileCode, String outputFilePair, String outputFileMatirx){
    		//读数据
    		ArrayList<String> docLines = new ArrayList<String>();
    		FileUtils.readLines(inputFile, docLines,inputFileCode);
    		M = docLines.size();
    		docword = new int[M][];  //重新编号文档
    		int j = 0;
    		//编号
    		for(String line : docLines){
    			//基于空格分割文件
    			String[] words = line.split(" ");
    			docword[j] = new int[words.length];
    			for(int i = 0; i < words.length; i++){
    				String word = words[i];
    				if(!wordToIndexMap.containsKey(word)){
    					int newIndex = wordToIndexMap.size();
    					wordToIndexMap.put(word, newIndex);
    					indexToWordMap.add(word);
    					docword[j][i] = newIndex;
    				} else {
    					docword[j][i] = wordToIndexMap.get(word);
    				}
    			}
    			j++;
    		}
    		code = inputFileCode;
    		outputFileP = outputFilePair;
    		outputFilePMatr = outputFileMatirx;
    	}
    	//共现处理
    	public void toMatrix(){
    		System.out.println("......开始产生共现词对.........");
    		//循环每篇文档,产生共现词对
    		for(int docu = 0;docu < M; docu++){
    			//对文档的词进行循环
    			for(int i = 0; i < docword[docu].length; i++)
    				for(int j = i+1;j < docword[docu].length; j++){
    					//空格分割
    					String wordp = indexToWordMap.get(new Pair(docword[docu][i],docword[docu][j]).w1) + " " + indexToWordMap.get(new Pair(docword[docu][i],docword[docu][j]).w2);
    					wordpair.add(wordp);
    					FileUtils.writeLines(outputFileP, wordpair, code);
    				}
    		}
    		System.out.println("......写入共现词对,统计词对频率.........");
    		//统计词对的频率
    		Hashtable<String, Integer>  wordCount = new Hashtable<String, Integer>();
    		for (int pair = 0; pair < wordpair.size(); pair++) {
    			if (!wordCount.containsKey(wordpair.get(pair))) {
    				wordCount.put(wordpair.get(pair), Integer.valueOf(1));
    			} else {
    				wordCount.put(wordpair.get(pair), Integer.valueOf(wordCount.get(wordpair.get(pair)).intValue() + 1));
    			}
    		}
    		//写入文档
    		FileUtils.writeHashMap(outputFilePMatr, wordCount, code);
    		System.out.println("......写入词对频率结束.........");
    	}
    	
    	public static void main(String[] args) {
    		CooccurrenceMatrix matrix = new CooccurrenceMatrix("cooccurrencedata/train_raw.txt", "gbk", "cooccurrencedata/cpair.txt", "cooccurrencedata/cmatrix.txt");
    		matrix.toMatrix();
    	}
    
    }
    
    

    该类的构造方法CooccurrenceMatrix()的输入参数包括:

    /**
    	 * 创建一个构造方法
    	 * @param inputFile 输入文件
    	 * @param inputFileCode 输入文件和输入文件的编码
    	 * @param outputFilePair  词对输出文件
    	 * @param outputFile  词对频率输出文件
    	 */
    

    其中,docword数组存储文档数据(重新编号后的)。toMatrix()方法,首先利用Pair类产生共现词对,之后利用FileUtils中的writeLines()方法将其写入指定文件;接着,我对所有产生的词对统计频率(这里使用了Hashtable集合),最后,利用FileUtils类中的writeHashMap()方法将其写入指定文件。

    程序运行结果

    运行CooccurrenceMatrix类,可以看到工程目录下的cooccurrencedata文件夹多了两个文件,即共现词对文件和词对频率文件。“cpair.txt”文件内容如下:

    470 657
    470 66
    657 66
    2139 3204
    2139 3677
    470 2139
    657 2139
    3204 3677
    470 3204
    657 3204
    470 3677
    ...
    

    “cmatrix.txt”文件内容如下:

    470 66 2
    66 3589 1
    117 3589 1
    657 3204 1
    375 3104 1
    2123 2556 1
    2304 3195 1
    66 588 1
    2088 3080 1
    3589 588 1
    3080 3195 1
    50 813 1
    ...
    

    关于社区发现算法

    Louvain算法对应的论文为:
    Blondel V D, Guillaume J L, Lambiotte R, et al. Fast unfolding of communities in large networks[J]. Journal of statistical mechanics: theory and experiment, 2008, 2008(10): P10008.
    在这里插入图片描述
    从引用次数可以看出其影响力。
    该算法可使用Gephi进行可视化,读者可参考下面这篇博客进行操作:

    https://blog.csdn.net/eastmount/article/details/85046305
    

    如下为笔者使用Gephi所做的一个图:
    在这里插入图片描述

    展开全文
  • 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("娱乐"))
    

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

    展开全文
  • Python实现共现矩阵及networkx可视化结果共现矩阵代码实现networkx可视化代码实现参考文章 共现矩阵 共现矩阵:也称为共词矩阵,能表明两个词之间的关系程度 首先假设我们有两句话,如下图所示,通过jieba分词和...
  • 【NLP】关键词共现/属性共现矩阵

    千次阅读 2020-02-11 19:39:42
    【NLP】关键词共现/属性共现矩阵 【共现】理解起来无非是两个词语同时出现的频次作为一个指标,构造矩阵。矩阵的第一列和第一行都是词语列表中的所有词,因此对角线一般设置为0——即不把自己和自己共现算进去。假如...
  • python-共现矩阵(共词矩阵)计算

    热门讨论 2021-04-20 11:27:37
    共现矩阵(共词矩阵):统计文本中两两词组之间共同出现的次数,以此来描述词组间的亲密度 code(我这里求的对角线元素为该字段在文本中出现的总次数): import pandas as pd def gx_matrix(vol_li): # 整合一下,...
  • 所谓的共现矩阵,就是词表示矩阵。不过目前有2种不同的共现矩阵。一种是词在文章中的出现次数。比如下面两篇“文章”: 1)我爱北京天安门 2)我爱吃北京烤鸭 北京就在两篇文章中各出现一次。而天安门只在第一篇文章...
  • Python Pandas 构建共现矩阵

    千次阅读 2018-11-16 16:35:19
    作者共现、词共现等各种共现情况的研究需求在我们这个学科还是挺多的,来写一下如何使用Python构建共现矩阵。 基本思路 构建共现矩阵,我一个基本思路是先根据所有的目标对象构建一个单位矩阵,然后对目标对象的...
  • Python 共现矩阵

    2019-08-22 19:11:34
    https://blog.csdn.net/Dity_Lee/article/details/69663610
  • 关键词提取一:构造共现矩阵

    万次阅读 2018-01-28 21:48:22
    因为TFIDF算法的提取关键词的准确性很差,tfidf提取出的关键词很难看出...因为构造词语网络需要先构造关键词共现图,关键词共现图需要先构造关键词共现矩阵,所以第一步就是构造关键词共现矩阵。 构造关键词共现矩阵
  • 【NLP学习笔记】词共现矩阵

    千次阅读 2020-07-16 22:02:53
    共现矩阵定义 通过统计一个事先指定大小的窗口内的word共现次数,以word周边的共现词的次数做为当前word的vector。具体来说,我们通过从大量的语料文本中构建一个共现矩阵来定义word representation。 例子 有语料...
  • # 整合一下,输入是df列,输出直接是矩阵 names = locals() all_col0 = [] # 用来后续求所有字段的集合 for row in vol_li: all_col0 += row for each in row: #对每行的元素进行处理,存在该字段字典的话,再...
  • Co-Occurrence Matrix的计算方法Co-Occurrence Matrix的介绍Co...Co-Occurrence Matrix 是 具有固定上下文窗口的共现矩阵 (Co-Occurrence Matrix with a fixed context window)。 遵循的基本原理是:类似的词往往出现
  • def compute_co_occurrence_matrix(corpus, window_size=4): """ Compute co-occurrence matrix for the given corpus and window_size (default of 4). Note: Each word in a document should be at the center...
  • COOC1.9软件 一键做共现矩阵与相异矩阵 COOC1.8软件介绍: 本次更新解决因为电脑编码问题导致相异矩阵部分电脑做不成功难题。 如图:一个入口相异矩阵做不成功直接换别的入口即可,包含所有情况啦! COOC1.8软件优势...
  • python构建关键词共现矩阵

    万次阅读 多人点赞 2017-04-05 15:44:37
    本文仅仅提供了实现思路,如果对算法速度有追求的请移步python构建关键词共现矩阵速度优化(在此非常感谢这位同学的优化) 非常感谢南京大学的张同学发现我代码中的bug,现文中的代码均已经更新请放心使用,并且代码...
  • (三)语言模型和共现矩阵

    万次阅读 2018-05-25 19:23:47
    对称的窗口指的是,“like I”也是2次 将共现矩阵行(列)作为词向量表示后,可以知道like,enjoy都是在I附近且统计数目大约相等,他们意思相近 共现矩阵不足: 面临稀疏性问题、向量维数随着词典大小线性增长 解决:...
  • Python 实现共现矩阵算法

    千次阅读 2017-04-08 00:01:47
    用到的模块: xlrd​最后得到文件: txt(全部复制txt 打开新表格粘贴即可得到xls文件)​​///开始写这个方法的目的是完成作业目标: 对表格里的关键词提取, 然后计算其共现次数, 生成共现矩阵

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,546
精华内容 1,818
关键字:

共现矩阵