快捷导航

共词分析中的共词关系是怎么得到的?

2022-8-22 11:22| 发布者: Fuller| 查看: 1298| 评论: 0

摘要: 本文将GooSeeker分词和情感分析软件生成的选词矩阵和共词矩阵excel文件读入到NumPy数组中,而且可以看到共词矩阵实际上是可以由选词矩阵生成的。我们把选词矩阵叫做关系矩阵R,那么共词矩阵叫做邻接矩阵A(adjacency ...

1  介绍

这一系列Jupyter Notebook主要演练社会网络分析算法中的几个主要计算方法,计划用5-8个notebook演练一下。所使用的数据集都是GooSeeker分词和情感分析软件的分析结果,可以从互联网上把感兴趣的热点事件导入GooSeeker分词软件,导出的词和文档数据构成一个向量空间,在其上构建社会网络图,使用networkx程序库做社会网络分析算法演练。

GooSeeker分词和情感分析软件将分析结果转换成Excel文件,导出以后可用于进一步量化分析和数据挖掘,比如,社会网络分析法,是一个方法族,含有一系列分析方法。比较常见的是共词分析法,期望通过共词分析能快速发现数据集含有的话题构成以及相互关系。

共词就是两个词同时出现在一个文档中(或者其他语言单位中),我们将在一些列Jupyter Notebook中讲解一下共词关系是怎么得到的?共词关系除了可以用是否出现(0或者1)进行衡量以外,是否还可以有更加精细的衡量?采用社会网络图分析法,可以怎样用python编程和可视化?

GooSeeker分词和情感分析软件导出的文件中有两个文件,分别是《选词矩阵》表和《共词矩阵》表。2022年8月15日发布的新版GooSeeker分词和情感分析软件(V3.10.1)修改了《选词矩阵》的内容。

  • 以前版本:矩阵中的数值表示某个词是否出现在一个文档中,如果出现就是1,如果不出现就是0
  • V3.10.1及以后:矩阵中的数值表示某个词在一个文档中出现的次数。如果不出现就是0,如果出现就是出现次数。可见新版本的选词矩阵表包含更多信息。


本Jupyter Notebook将探索GooSeeker分词软件导出的共词矩阵可以怎样从选词矩阵转计算出来,从而理解共词关系的含义。

共词矩阵是大家用的比较多的数据表。因为可以用共词矩阵画图,观察词的中心度。本质上,共词矩阵是由选词矩阵算出来的。选词矩阵表示所选词与文档的关系,是一个矩阵,可横向或者纵向不同角度看。

如果用选词矩阵表研究词与词之间的关系,比如,根据出现的文档情况看词之间的相似度(距离),那么,可以画成网络图,使用社会网络分析方法做一些计算和观察,还可以用Gephi对图进行更灵活的处理;相反,如果研究文档与文档之间的关系,比如,文档的相似度,那么,就是把矩阵横过来看。

我计划用多个notebook分别讲解,本notebook只讲共词矩阵是怎么来的,共词关系还可以用什么其他方法度量。

本notebook使用的文件放在data/raw目录中,被分析的数据是利用网络爬虫软件从知乎的关于二舅的一个话题采集下来的回答。

【千万注意】GooSeeker分词和情感分析软件导出共词矩阵的时候会调整词的顺序,会跟选词矩阵的词的顺序不一样,当处理词的对应数值的时候,要用对词数组。

2  准备运行环境

2.1  引入需要用到的库

# -*- coding: utf-8 -*-

import os

import time

import numpy as np

import pandas as pd

2.2  常量和配置

在我们发布的一系列Jupyter Notebook中,凡是处理GooSeeker分词软件导出的结果文件的,都给各种导出文件起了固定的名字。为了方便大家使用,只要把导出文件放在data/raw文件夹,notebook就会找到导出文件,赋值给对应的文件名变量。下面罗列了可能用到的文件名变量:

  • file_all_word:词频表
  • file_chosen_word: 选词结果表
  • file_seg_effect: 分词效果表
  • file_word_occurrence_matrix: 选词矩阵表(是否出现)
  • file_word_frequency_matrix: 文档词频对应矩阵
  • file_word_document_match: 选词匹配表
  • file_co_word_matrix: 共词矩阵表

代码如下:

pd.set_option('display.width', 1000)  # 设置字符显示宽度

pd.set_option('display.max_rows', None)  # 设置显示最大

# np.set_printoptions(threshold=np.inf) # threshold 指定超过多少使用省略号,np.inf代表无限大

# 存原始数据的目录

raw_data_dir = os.path.join(os.getcwd(), '../../data/raw')

# 存处理后的数据的目录

processed_data_dir = os.path.join(os.getcwd(), '../../data/processed')

filename_temp = pd.Series(['词频','分词效果','选词矩阵','选词匹配','选词结果','共词矩阵'])

file_all_word = ''

file_seg_effect = ''

file_word_occurrence_matrix = ''

file_word_fequency_matrix = ''

file_word_document_match = ''

file_chosen_word = ''

file_co_word_matrix = ''

2.3  检测data/raw目录下是否有待分析的GooSeeker分词结果表

本notebook只使用选词矩阵表和共词矩阵表,下面的代码将检查data/raw中有没有这两个表,如果没有会报错,后面的程序就没法执行了。

# 0:'词频', 1:'分词效果', 2:'选词矩阵', 3:'选词匹配', 4:'选词结果', 5:'共词矩阵'

print(raw_data_dir + '\r\n')

for item_filename in os.listdir(raw_data_dir):

    if filename_temp[2] in item_filename:

        file_word_fequency_matrix = item_filename

        continue

    if filename_temp[5] in item_filename:

        file_co_word_matrix = item_filename

        continue

if file_word_fequency_matrix:

    print("选词矩阵表:", "data/raw/", file_word_fequency_matrix)

else:

    print("选词矩阵表:不存在")

if file_co_word_matrix:

    print("共词矩阵表:", "data/raw/", file_co_word_matrix)

else:

    print("共词矩阵表:不存在")

输出结果:

C:\Users\work\workspace\notebook\发布-二舅\发布1\notebook\eda\../../data/raw

选词矩阵表: data/raw/ 选词矩阵-知乎-二舅.xlsx

共词矩阵表: data/raw/ 共词矩阵-知乎-二舅.xlsx

3  读取数据表并存入矩阵

如果将GooSeeker分词和情感分析软件生成的结果文件交给sklearn都机器学习库做进一步计算,或者对导出的excel文件做其他进一步处理,那么通常需要转换成numpy数组,也可能需要转换成numpy矩阵(按照官网的解释,不推荐转换成矩阵(matrix),除非是为了跟其他软件对接)。而从numpy数组到numpy矩阵,只需要调用numpy一个函数就行了。那么,关键是从分词工具生成的excel文件到numpy数组的转换。这个转换用Pandas桥接一下,都是很简单的过程。总之,路线是:excel转换成Pandas dataframe,然后在转换成numpy数组。

3.1  选词矩阵表

3.1.1  读入Pandas DataFrame

下面将展示转换成数组和矩阵需要用到的函数。这是一种最简单的情形,转换过程中没有任何对excel单元格进行处理计算的过程。

df_word_occurrence_matrix = pd.read_excel(os.path.join(raw_data_dir, file_word_fequency_matrix))

查看选词矩阵表前5行数据

df_word_occurrence_matrix.head()

3.1.2  去掉不需要的列

df_word_occurrence_matrix.drop(labels='序号', axis=1, inplace=True)

df_word_occurrence_matrix.head(2)

3.1.3  将列名存入一个数组中

第一个元素(“正文”)并不是所选词,用切片方法把第一个元素切除。

column_names = df_word_occurrence_matrix.columns.values[1:]

print("There are ", len(column_names), " words")

column_names

3.1.4  将选词矩阵表转换成数组

可以用两种方案:

  • df.values
  • np.array(df)

代码如下:

# np_array_word_frequence_matrix = np.array(df_word_occurrence_matrix)

# np_array_word_frequence_matrix

array_word_frequence_matrix = df_word_occurrence_matrix.values[:, 1:]

array_word_frequence_matrix

输出结果:

array([[0, 1, 0, ..., 0, 0, 0],

       [0, 0, 0, ..., 0, 0, 0],

       [0, 0, 0, ..., 0, 0, 0],

       ...,

       [0, 0, 0, ..., 0, 0, 0],

       [1, 0, 0, ..., 0, 0, 0],

       [1, 0, 0, ..., 0, 0, 0]], dtype=object)

用切片方法把第一列数据切出来,放到一个数组中,这是所有文档正文。

array_doc = df_word_occurrence_matrix.values[:, 0]

array_doc

输出结果:

array(['懒惰致贫的才是真正少数,...',

       '我实在好奇up主为什么不打上...',

      ...

       '一个简单而又平凡的故事,一个...'],

      dtype=object)

3.1.5  将结果转换为矩阵

有两种方案

  • numpy matrix()和
  • numpy mat/asmatrix 既可以从DataFrame转换过来,也可以从array转换过来

区别:如果输入已经是矩阵或ndarray,则asmatrix不会复制。等效于matrix(data, copy=False)。详细参看:numpy.asmatrix — NumPy v1.21 Manual

matrix_word_frequence_matrix = np.mat(array_word_frequence_matrix)

matrix_word_frequence_matrix

输出结果

matrix([[0, 1, 0, ..., 0, 0, 0],

        [0, 0, 0, ..., 0, 0, 0],

        [0, 0, 0, ..., 0, 0, 0],

        ...,

        [0, 0, 0, ..., 0, 0, 0],

        [1, 0, 0, ..., 0, 0, 0],

        [1, 0, 0, ..., 0, 0, 0]], dtype=object)

3.1.6  转换成老版本的选词矩阵

老版本的选词矩阵中只有0和1两个值,表示一个词是否出现。用下面的代码可以转换成这样的矩阵

array_word_occurrence_matrix = array_word_frequence_matrix.copy()

array_word_occurrence_matrix[array_word_occurrence_matrix > 0] = 1

array_word_occurrence_matrix

输出结果:

array([[0, 1, 0, ..., 0, 0, 0],

       [0, 0, 0, ..., 0, 0, 0],

       [0, 0, 0, ..., 0, 0, 0],

       ...,

       [0, 0, 0, ..., 0, 0, 0],

       [1, 0, 0, ..., 0, 0, 0],

       [1, 0, 0, ..., 0, 0, 0]], dtype=object)

上面的代码先将array_word_frequence_matrix拷贝了一份,再替换其中的内容,所以,原先的数组并没有改变,可以检查一下

array_word_frequence_matrix

输出结果:

array([[0, 1, 0, ..., 0, 0, 0],

       [0, 0, 0, ..., 0, 0, 0],

       [0, 0, 0, ..., 0, 0, 0],

       ...,

       [0, 0, 0, ..., 0, 0, 0],

       [1, 0, 0, ..., 0, 0, 0],

       [1, 0, 0, ..., 0, 0, 0]], dtype=object)

3.2  共词矩阵表

像选词矩阵表一样读入并转换成数组,下面就不分步讲解了

df_co_word_matrix = pd.read_excel(os.path.join(raw_data_dir, file_co_word_matrix))

df_co_word_matrix.head(2)

coword_names = df_co_word_matrix.columns.values[1:]

print("There are ", len(coword_names), " words")

coword_names

array_co_word_matrix = df_co_word_matrix.values[:, 1:]

array_co_word_matrix

输出结果:

array([[101, 74, 24, ..., 1, 1, 1],

       [74, 403, 59, ..., 5, 1, 1],

       [24, 59, 76, ..., 1, 1, 1],

       ...,

       [1, 5, 1, ..., 7, 0, 0],

       [1, 1, 1, ..., 0, 1, 0],

       [1, 1, 1, ..., 0, 0, 1]], dtype=object)

4  共词关系的含义是什么

4.1  对矩阵的观察

在一开始我们说了,当数据表示成矩阵的形式的时候,最重要的先要清楚研究的对象是什么。要针对这一堆对象做什么对比计算(比如,相似度)。

目前观察,行代表文档,列代表词。本文我们的研究重点是词,想考察词与词之间的相似度(或者距离),那么,每个词都是一个属性,而每个文档是一个观察样本,每个样本是一个多维数据,由多个属性变量描述。当然也可以行列调过来看,但是本文想研究词,下面也是都词进行一些统计运算。

4.2  选词矩阵与共词矩阵的关系

基于array_word_occurrence_matrix矩阵,可以得到共词矩阵:

例如,两个词wi和wj ,对应的列向量分别是Wi和Wj,那么,求这两个向量的点积,Wi⋅Wi 就是wi和wi的共现次数。

【提示】上面的算式也可以用于其他共现关系的运算,比如,社交关系,论文的引用关系,专利的引用关系等等。

我们把上面的矩阵array_word_occurrence_matrix叫做关系矩阵R,而把邻接矩阵A(adjacency matrix)这个名字留给下面的图,比较符合惯例。那么,RTR(由于本平台无法显示公式,这串字符串表示R的转置乘以R)就是共词矩阵。可见,RTR是一个对称矩阵,我们称之为A矩阵,后续的notebook将深入探讨这个A矩阵的特点以及用array_word_frequence_matrix参与计算后做更多观察,比如计算均值(mean)、方差(variance)、协方差(covariance)和皮尔森相关系数(Pearson correlation coefficient)。

下面我们先验证观察一下RTR就是GooSeeker分词工具导出的共词矩阵。

【注意】矩阵相乘需要使用dot()函数,虽然matrix类型的矩阵可以使用 * 符号做乘法,但是算出来的结果并不是dot product。可以查阅关于numpy的broadcast概念的材料。

matrix_coword = np.dot(np.transpose(array_word_occurrence_matrix), array_word_occurrence_matrix)

# matrix_coword = np.transpose(matrix_word_occurrence_matrix) * matrix_word_occurrence_matrix

matrix_coword

输出结果:

array([[403, 204, 123, ..., 20, 13, 12],

       [204, 293, 99, ..., 12, 8, 12],

       [123, 99, 184, ..., 7, 6, 5],

       ...,

       [20, 12, 7, ..., 20, 2, 2],

       [13, 8, 6, ..., 2, 15, 0],

       [12, 12, 5, ..., 2, 0, 16]], dtype=object)

下面我们将对比一下,这样算出来的结果跟GooSeeker分词软件导出的共词矩阵是否一样。

4.3  做个实验:对比两个表是否有一致的数据

matrix_coword是从选词矩阵中计算出来的共词矩阵,而array_co_word_matrix是从GooSeeker分词软件导出的共词矩阵表读入进来的。下面做一个数值对比,要注意他们的字段顺序是不一样的。

下面以matrix_coword作为基准,进行循环,检查array_co_word_matrix中的值是否正确。

【注意】column_names和array_co_word_matrix都是numpy的array,本质是ndarray类型的数据,要从这样的数组中确定一个元素的位置,需要使用专门的函数numpy.where()。

word_num = len(matrix_coword)

word_num

输出结果:133

for i in range(word_num):

    for j in range(i, word_num):

        word_i = column_names[i]

        word_j = column_names[j]

        # 因为coword_names是一维数组,所以,下面的idx_i后面有个逗号

        idx_i, = np.where(coword_names == word_i)

        idx_j, = np.where(coword_names == word_j)

        # idx_i和idx_j实际上是一个数组,也就是说,可以用where得到多个位置序号,本例只有一个唯一序号

        #print("found at ", idx_i, " and ", idx_j)

        if matrix_coword[i][j] != array_co_word_matrix[idx_i[0]][idx_j[0]]:

            print(word_i, " 和 ", word_j, " 的共词文档数分别是:", matrix_coword[i][j], " : ", array_co_word_matrix[idx_i[0]][idx_j[0]])

            

print("Consistent!")

输出结果:Consistent!

5  常用的统计计算

度量共词关系,其实就是看两个词在语料库的所有文档中的分布情况有多么相似,那么,很自然,可以使用皮尔森相关系数,也可以使用协方差矩阵,甚至可以像共词矩阵那样直接使用两个向量的点积。后面的notebook我们将结合networkx的图算法来分别观察他们的不同,而且看看别人是怎么评价和选择的。

5.1  求Pearson相关系数

用一个函数就可以求皮尔森相关系数。

【注意】要用选词矩阵来算,在共词矩阵上计算没有意义。而且最好使用新版GooSeeker分词和情感分析软件导出的选词矩阵,因为矩阵中的数值表示词频,是0或者大于0的数值,比0和1两个值含有的信息更多。

# 列的方向是变量,行的方向是样本

#pearson_corr = np.corrcoef(array_word_occurrence_matrix.astype(float), rowvar = False)

pearson_corr = np.corrcoef(array_word_frequence_matrix.astype(float), rowvar = False)

pearson_corr

输出结果:

array([[ 1.        ,  0.53004538,  0.28459398, ...,  0.18865428,

         0.10032949,  0.10133586],

       [ 0.53004538,  1.        ,  0.21525746, ...,  0.09881271,

         0.04032969,  0.09035983],

       [ 0.28459398,  0.21525746,  1.        , ...,  0.02588627,

         0.00654365, -0.00807632],

       ...,

       [ 0.18865428,  0.09881271,  0.02588627, ...,  1.        ,

         0.05056049,  0.10530439],

       [ 0.10032949,  0.04032969,  0.00654365, ...,  0.05056049,

         1.        , -0.01411261],

       [ 0.10133586,  0.09035983, -0.00807632, ...,  0.10530439,

        -0.01411261,  1.        ]])

5.2  求协方差矩阵

皮尔森系数是用协方差、方差和标准差算出来的,有时候需要直接使用协方差(covariance),更能看到变量在样本上的分布的变化,那么用下面的函数

# 列的方向是随机变量,行的方向是样本

covariance_matrix = np.cov(array_word_frequence_matrix.astype(float), rowvar = False)

covariance_matrix

输出结果:

array([[ 2.46042976e+01,  6.18038032e+00,  3.36027827e+00, ...,

         1.93754805e-01,  1.44304255e-01,  1.33315244e-01],

       [ 6.18038032e+00,  5.52577669e+00,  1.20447814e+00, ...,

         4.80938814e-02,  2.74894858e-02,  5.63356397e-02],

       [ 3.36027827e+00,  1.20447814e+00,  5.66615038e+00, ...,

         1.27583322e-02,  4.51657396e-03, -5.09881065e-03],

       ...,

       [ 1.93754805e-01,  4.80938814e-02,  1.27583322e-02, ...,

         4.28707095e-02,  3.03554470e-03,  5.78279745e-03],

       [ 1.44304255e-01,  2.74894858e-02,  4.51657396e-03, ...,

         3.03554470e-03,  8.40795007e-02, -1.08533442e-03],

       [ 1.33315244e-01,  5.63356397e-02, -5.09881065e-03, ...,

         5.78279745e-03, -1.08533442e-03,  7.03432370e-02]])

5.3  求均值(mean)

往往先要把随机变量的观察值做中心化处理(得到mean-deviation-form),也就是减去平均值。那么用下面的函数一次性求出所有变量的平均值。

# 列的方向是随机变量,行的方向是样本

# 也就是在列的方向求平均

mean_vector = np.mean(array_word_frequence_matrix.astype(float), axis=0)

mean_vector

输出结果:

array([2.28943759, 1.04115226, 0.73799726, 0.61042524, 0.44855967,

       0.38545953, 0.33333333, 0.31001372, 0.27709191, 0.25377229,

       0.23731139, 0.23045267, 0.23045267, 0.19615912, 0.19478738,

       0.18106996, 0.17695473, 0.15500686, 0.15363512, 0.13854595,

       0.13717421, 0.13580247, 0.13580247, 0.13305898, 0.13168724,

       0.1303155 , 0.12071331, 0.11796982, 0.11659808, 0.11522634,

       0.11248285, 0.11111111, 0.11111111, 0.10699588, 0.1042524 ,

       0.10288066, 0.10288066, 0.09876543, 0.08916324, 0.08916324,

       0.08504801, 0.08367627, 0.08093278, 0.07956104, 0.07956104,

       0.0781893 , 0.07681756, 0.07407407, 0.07407407, 0.07270233,

       0.07133059, 0.06995885, 0.06995885, 0.06858711, 0.06721536,

       0.06721536, 0.06721536, 0.06721536, 0.06721536, 0.06584362,

       0.06584362, 0.06584362, 0.06310014, 0.06310014, 0.0617284 ,

       0.0617284 , 0.06035665, 0.06035665, 0.05898491, 0.05761317,

       0.05761317, 0.05624143, 0.05486968, 0.05486968, 0.05349794,

       0.05349794, 0.0521262 , 0.0521262 , 0.05075446, 0.05075446,

       0.05075446, 0.05075446, 0.05075446, 0.04938272, 0.04938272,

       0.04938272, 0.04801097, 0.04801097, 0.04801097, 0.04801097,

       0.04663923, 0.04663923, 0.04663923, 0.04526749, 0.04526749,

       0.04526749, 0.04389575, 0.04389575, 0.04389575, 0.04252401,

       0.04252401, 0.04252401, 0.04115226, 0.04115226, 0.04115226,

       0.04115226, 0.03978052, 0.03978052, 0.03978052, 0.03978052,

       0.03978052, 0.03978052, 0.03978052, 0.03840878, 0.03840878,

       0.03840878, 0.03703704, 0.03703704, 0.03703704, 0.03703704,

       0.03566529, 0.03566529, 0.03566529, 0.03566529, 0.03566529,

       0.03566529, 0.03429355, 0.03429355, 0.03429355, 0.03429355,

       0.03292181, 0.03292181, 0.03292181])

5.4  求方差(variance)

# 列的方向是变量,行的方向是样本

variance_vector = np.var(array_word_frequence_matrix.astype(float), axis=0)

variance_vector

输出结果:

array([24.57054687,  5.51819675,  5.65837788,  3.06085153,  1.84131823,

        1.76225771,  1.08093278,  1.7639738 ,  1.15230101,  0.60638152,

        0.96563118,  0.59984081,  0.86595878,  0.49787276,  1.21583017,

        0.42263205,  0.97691748,  3.0939427 ,  0.25623164,  0.73389144,

        0.47226691, 11.11050145,  0.59472641,  0.24978502,  0.44905079,

        0.78548701,  2.63837754,  0.40034924,  0.25663808,  0.34337584,

        0.19036544,  0.31001372,  0.28532236,  0.36166574,  3.30600386,

        0.16911379,  0.19106166,  7.1013565 ,  0.30892235,  0.14705678,

        0.15463241,  0.24402709,  0.21430036,  0.1390747 ,  0.11163986,

        0.84573829,  0.16419508,  0.24691358,  0.21124829,  0.19087349,

        0.1430601 ,  0.15559959,  0.12542126,  0.28061817,  0.18615425,

        0.08190185,  0.22181954,  0.15048895,  0.1779238 ,  0.09443005,

        0.09991702,  0.14381277,  0.20177969,  0.14416652,  0.21155312,

        0.1100442 ,  0.14724871,  0.21034884,  2.0884275 ,  0.11739403,

        0.08447222,  0.25060919,  0.18354625,  0.12867656,  0.09178818,

        1.59247405,  0.09056132,  0.060383  ,  1.87533894,  0.06463935,

        0.1085351 ,  0.08658722,  0.18809614,  0.19234873,  0.26093583,

        0.07712239,  0.27341511,  0.07314076,  0.11429303,  0.07588425,

        0.13774248,  0.07738582,  0.33801683,  0.07888364,  0.11180545,

        0.07888364,  0.05842982,  0.07763421,  0.05294285,  0.06540707,

        0.05443314,  0.09284191,  0.05317618,  0.05043269,  0.15742858,

        0.14096767,  0.06837636,  0.10678514,  0.07386333,  0.07935029,

        0.06288939,  0.13970695,  0.05465894,  0.0616249 ,  0.05613793,

        0.11923807,  0.04389575,  0.12345679,  0.09327846,  0.12620027,

        0.05359767,  0.19077188,  0.10298039,  0.06731509,  0.04262373,

        0.45414637,  0.08524371,  0.04683493,  0.09347416,  0.05506538,

        0.0428119 ,  0.08396417,  0.07024674])

5.5  求标准差(standard deviation)

# 列的方向是变量,行的方向是样本

std_vector = np.std(array_word_occurrence_matrix.astype(float), axis = 0)

std_vector

输出结果:

array([0.49720306, 0.49028604, 0.43438982, 0.46193301, 0.41935393,

       0.37571713, 0.37082734, 0.36450675, 0.33815043, 0.35927599,

       0.34690162, 0.3454721 , 0.31084415, 0.32257238, 0.28497922,

       0.31084415, 0.27273186, 0.21086492, 0.30558769, 0.24559164,

       0.26410934, 0.10418018, 0.2527507 , 0.29273118, 0.26846924,

       0.2330105 , 0.17843196, 0.24559164, 0.25737626, 0.25507765,

       0.27895313, 0.23814644, 0.24800855, 0.22228149, 0.1419604 ,

       0.26630175, 0.25964727, 0.03701163, 0.23038734, 0.24314298,

       0.24066159, 0.20178135, 0.20486315, 0.24314298, 0.24800855,

       0.15091657, 0.22772572, 0.20789022, 0.22228149, 0.21666579,

       0.21949588, 0.20486315, 0.21949588, 0.18545426, 0.20789022,

       0.23559646, 0.18885257, 0.21086492, 0.20178135, 0.22228149,

       0.21666579, 0.21086492, 0.19544317, 0.20486315, 0.17479892,

       0.21086492, 0.18545426, 0.18545426, 0.08253283, 0.19218102,

       0.20789022, 0.18198216, 0.17479892, 0.18545426, 0.19218102,

       0.08253283, 0.18885257, 0.21086492, 0.03701163, 0.20486315,

       0.17479892, 0.18545426, 0.17479892, 0.14651336, 0.15518278,

       0.19218102, 0.1323429 , 0.19218102, 0.17479892, 0.18545426,

       0.16726256, 0.18198216, 0.12190767, 0.18545426, 0.17479892,

       0.17843196, 0.18545426, 0.17107775, 0.19218102, 0.18198216,

       0.18545426, 0.15518278, 0.18545426, 0.18885257, 0.15091657,

       0.15091657, 0.16334678, 0.15932299, 0.16334678, 0.15932299,

       0.17479892, 0.14651336, 0.17843196, 0.16726256, 0.17479892,

       0.13724278, 0.17843196, 0.15091657, 0.15091657, 0.13724278,

       0.15932299, 0.09751919, 0.14651336, 0.15518278, 0.17479892,

       0.11042311, 0.1419604 , 0.16726256, 0.14651336, 0.15932299,

       0.16334678, 0.1419604 , 0.14651336])

这一系列计算完成了,如果有兴趣,可以套上皮尔森相关系数的计算公式,用上面这些分别算出来的数值求出来,跟用函数一下子求出来的结果对比一下。

6  总结

本文将GooSeeker分词和情感分析软件生成的选词矩阵和共词矩阵excel文件读入到NumPy数组中,而且可以看到共词矩阵实际上是可以由选词矩阵生成的。我们把选词矩阵叫做关系矩阵R,那么共词矩阵叫做邻接矩阵A(adjacency matrix),为了跟后面要networkx做中心度分析保持一样的命名惯例。在这里,我们的研究对象是词,那么邻接矩阵就是两个词通过同时出现这两个词的文档联系在一起。

那么, RTR就是共词矩阵。显然, RTR是一个对称矩阵,我们称之为A矩阵。类似的计算也会出现在社交关系分析、论文的引用关系分析、专利的引用关系分析等等场景中。后续的notebook将深入探讨这个A矩阵的特点,比如,特征向量(eigen vector),而且可以进一步做PCA计算,减少所选词的数量(即所谓的降维),甚至可以用于演练NLP(natural language processing)用到的机器学习的algebraic model。

以上这些主要是出于对计算方法的演练目的做讲解的,并不是一定都要经过这些计算。至于这些实际数据能探索出来什么模式或者现象,还需要读者自己去摸索。

7 下载源代码

本notebook下载网址:共词分析中的共词关系是怎么得到的?.zip

1

鲜花

握手

雷人

路过

鸡蛋

刚表态过的朋友 (1 人)

最新评论

GMT+8, 2023-2-8 22:07