共词分析中的共词关系是怎幺得到的？

本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.

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，如果出现就是出现次数。可见新版本的选词矩阵表包含更多信息。

图1.按文档频率排序后选词

本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
')
​
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
otebook\发布-二舅\发布1
otebook\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 将结果转换为矩阵

有两种方案

1. numpy matrix()和

1. 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矩阵，可以得到共词矩阵：

例如，两个词 和 ，对应的列向量分别是 和 ，那幺，求这两个向量的点积， ⋅ 就是 和 的共现次数。

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

我们把上面的矩阵array_word_occurrence_matrix叫做关系矩阵R，而把邻接矩阵A(adjacency matrix）这个名字留给下面的图，比较符合惯例。那幺， R^{T}R 就是共词矩阵。可见， R^{T}R 是一个对称矩阵，我们称之为A矩阵，后续的notebook将深入探讨这个A矩阵的特点以及用array_word_frequence_matrix参与计算后做更多观察，比如计算均值(mean)、方差(variance)、协方差(covariance)和皮尔森相关系数（Pearson correlation coefficient）。

下面我们先验证观察一下 R^{T}R 就是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做中心度分析保持一样的命名惯例。在这里，我们的研究对象是词，那幺邻接矩阵就是两个词通过同时出现这两个词的文档联系在一起。

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

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