該系列文章主要講解知識圖譜或關系圖譜的構建方法，前文介紹了Neo4j圖數據庫和Jieba、PyLTP的基本用法。本篇文章主要采用Python和Gephi構建中國知網某個領域的作者合作關系和主題詞共現的知識圖譜，重點闡述了一種可操作的關系圖譜構建方法，可用于論文發表、課程或企業可視化展示等。其基本步驟如下：

1.在中國知網搜索“清水江”關鍵詞，并導出論文Excel格式。
2.使用Python處理文本，獲取作者合作的共現矩陣及三元組。
3.Gephi導入CSV節點及邊文件，并構建關系圖譜。
4.Gephi調整參數，優化關系圖譜。

這是一篇非?；A的文章，而且不需要撰寫網絡爬蟲，最終生成的效果還不錯，可廣泛應用于知識圖譜、引文分析、企業合作等領域。希望大家喜歡，尤其是研究自然語言處理和知識圖譜的同學。同時，從今天起，博客的代碼盡量上傳到Github和CSDN下載，腳踏實地，與君同在。

下載地址：https://download.csdn.net/download/eastmount/11650953

前文參考
Neo4j圖數據庫系列：
[知識圖譜構建] 一.Neo4j圖數據庫安裝初識及藥材供應圖譜實例
[知識圖譜構建] 二.《Neo4j基礎入門》基礎學習之創建圖數據庫節點及關系
[知識圖譜構建] 三.Neo4j創建高校教師關系圖譜及查詢語句入門詳解

Python知識圖譜構建系列：
[Python知識圖譜] 一.哈工大pyltp安裝及中文分句、中文分詞、導入詞典基本用法
[Python知識圖譜] 二.哈工大pyltp詞性標注、命名實體識別、依存句法分析和語義角色標注
[Python知識圖譜] 三.Jieba工具中文分詞、添加自定義詞典及詞性標注詳解

關系圖譜系列：
[關系圖譜] 一.Gephi通過共現矩陣構建知網作者關系圖譜
[關系圖譜] 二.Gephi導入共線矩陣構建作者關系圖譜

知識圖譜實例系列：
[知識圖譜實戰篇] 一.數據抓取之Python3抓取JSON格式的電影實體
[知識圖譜實戰篇] 二.Json+Seaborn可視化展示電影實體
[知識圖譜實戰篇] 三.Python提取JSON數據、HTML+D3構建基本可視化布局
[知識圖譜實戰篇] 四.HTML+D3+CSS繪制關系圖譜
[知識圖譜實戰篇] 五.HTML+D3添加鼠標響應事件顯示相關節點及邊
[知識圖譜實戰篇] 六.HTML+D3實現點擊節點顯示相關屬性及屬性值
[知識圖譜實戰篇] 七.HTML+D3實現關系圖譜搜索功能
[知識圖譜實戰篇] 八.HTML+D3繪制時間軸線及顯示實體

---

一.最終效果圖

作者合作知識圖譜

下面是另一個主題“網絡安全”以某作者為中心的區域，分別是武大和北郵。

關鍵詞共現知識圖譜

---

二.中國知網導出數據

第一步：在中國知網CNKI中搜索“清水江”關鍵詞，返回期刊論文1007篇，作為目標分析數據。

注意，中國知網最多能導出5000篇文獻，如果文章過多建議增加按年份統計，最后再匯總。同時，由于博士論文、會議論文、報紙作者關系較為單一，所以這里僅分析期刊論文。

第二步：點擊左上角勾選文獻。每次最多選擇50篇論文，接著點擊下一頁，導出500篇文獻。

選擇下一頁：

選中500篇論文之后，接著點擊“導出/參考文獻”選項。

第三步：在彈出的 界面中，選擇“Reforks”格式，點擊XLS導出。

到處的表格如下圖所示，包括各種論文信息，可惜沒有下載量和被引用量（網絡爬蟲實現），但我們的知識圖譜分析也夠了。

第四步：再下載剩余的所有文獻，每次500篇的下載，并整理在一個Excel表格中，過濾掉英文和無作者的論文，剩下958篇，即為分析的數據集。

---

三.什么是共現關系

引文分析常見的包括兩類，一種是共現關系，另一種是引用和被引用關系。本文主要講解共現關系，假設現在存在四篇文章，如下所示：

            
              文章標題                                        作者
大數據發展現狀分析                              A，B，C，D
Python網絡爬蟲                                 A，B，C
貴州省大數據戰略                                 B，A，D
大數據分析重要                                    D，A

            
          

第一步：寫代碼抓取該領域文章的所有作者，即：A、B、C、D。

第二步：接著獲取對應的共現矩陣，比如文章“大數據發展現狀分析”，則認為A、B、C、D共現，在他們之間建立一條邊。共現矩陣如下所示，共13條邊。

$$?\begin{array}{ccccc}?& A& B& C& D\\ A& 0& 2& 2& 2\\ B& 1& 0& 2& 2\\ C& 0& 0& 0& 1\\ D& 1& 0& 0& 0\end{array}?\text{\hspace{1em}( 1 )}$$

第三步：由于最后的圖譜是無向圖，為了方便計算，我們將矩陣的下三角數據加至上三角，從而減少計算量。

$$?\begin{array}{ccccc}?& A& B& C& D\\ A& 0& 3& 2& 3\\ B& 0& 0& 2& 2\\ C& 0& 0& 0& 1\\ D& 0& 0& 0& 0\end{array}?\text{\hspace{1em}( 1 )}$$

第四步：通過共現矩陣分別獲取兩兩關系及權重，再寫入CSV或Excel文件中，如下所示。知識圖譜通常由三元組構成，包括 {實體，屬性，屬性值}、{實體、關系、實體}，這里的{Source、Weight、Weight}也可以稱為一個三元組。

$$?\begin{array}{ccc}Source& Target& Weight\\ A& B& 3\\ A& C& 2\\ A& D& 3\\ B& C& 2\\ B& D& 2\\ C& D& 1\end{array}?\text{\hspace{1em}( 2 )}$$

第五步：將該CSV文件導入Gephi中，并繪制相關的圖形。因為該實例節點比較少，下面是Pyhton調用Networkx繪制的代碼及圖形。

            
              
                # -*- coding: utf-8 -*-
              
              
                import
              
               networkx 
              
                as
              
               nx

              
                import
              
               matplotlib
              
                .
              
              pyplot 
              
                as
              
               plt
 

              
                #定義有向圖
              
              
DG 
              
                =
              
               nx
              
                .
              
              Graph
              
                (
              
              
                )
              
              
                #添加五個節點(列表)
              
              
DG
              
                .
              
              add_nodes_from
              
                (
              
              
                [
              
              
                'A'
              
              
                ,
              
              
                'B'
              
              
                ,
              
              
                'C'
              
              
                ,
              
              
                'D'
              
              
                ]
              
              
                )
              
              
                print
              
               DG
              
                .
              
              nodes
              
                (
              
              
                )
              
              
                #添加邊(列表)
              
              
DG
              
                .
              
              add_edge
              
                (
              
              
                'A'
              
              
                ,
              
              
                'B'
              
              
                ,
              
               weight
              
                =
              
              
                3
              
              
                )
              
              
DG
              
                .
              
              add_edge
              
                (
              
              
                'A'
              
              
                ,
              
              
                'C'
              
              
                ,
              
               weight
              
                =
              
              
                2
              
              
                )
              
              
DG
              
                .
              
              add_edge
              
                (
              
              
                'A'
              
              
                ,
              
              
                'D'
              
              
                ,
              
               weight
              
                =
              
              
                3
              
              
                )
              
              
DG
              
                .
              
              add_edge
              
                (
              
              
                'B'
              
              
                ,
              
              
                'C'
              
              
                ,
              
               weight
              
                =
              
              
                2
              
              
                )
              
              
DG
              
                .
              
              add_edge
              
                (
              
              
                'B'
              
              
                ,
              
              
                'D'
              
              
                ,
              
               weight
              
                =
              
              
                2
              
              
                )
              
              
DG
              
                .
              
              add_edge
              
                (
              
              
                'C'
              
              
                ,
              
              
                'D'
              
              
                ,
              
               weight
              
                =
              
              
                1
              
              
                )
              
              
                #DG.add_edges_from([('A', 'B'), ('A', 'C'), ('A', 'D'), ('B','C'),('B','D'),('C','D')])
              
              
                print
              
               DG
              
                .
              
              edges
              
                (
              
              
                )
              
              
                #繪制圖形 設置節點名顯示\節點大小\節點顏色
              
              
colors 
              
                =
              
              
                [
              
              
                'red'
              
              
                ,
              
              
                'green'
              
              
                ,
              
              
                'blue'
              
              
                ,
              
              
                'yellow'
              
              
                ]
              
              
nx
              
                .
              
              draw
              
                (
              
              DG
              
                ,
              
              with_labels
              
                =
              
              
                True
              
              
                ,
              
               node_size
              
                =
              
              
                900
              
              
                ,
              
               node_color 
              
                =
              
               colors
              
                )
              
              
plt
              
                .
              
              show
              
                (
              
              
                )
              
            
          

繪制圖形如下所示：

接下來我們將告訴大家如何撰寫Python代碼獲取作者共現矩陣及三元組。

---

四.Python構建共現矩陣和三元組

第一步 ：將Excel中作者列單獨提取至word.txt文件中，如下圖所示。

第二步：運行Python代碼獲取共現矩陣和{Source， Weight，Target}三元組。

• 按行讀取TXT數據，并調用split(’;’)分割作者，將所有作者信息存儲至word列表中（不含重復項）
• 建立 word_vector[作者數][作者數] 共現矩陣，依次獲取每行的兩個作者下標位置，記錄在變量w1、w2、n1、n2中
• 詞頻矩陣賦值，這里通過判斷計算上三角矩陣 word_vector[n1][n2] += 1 或 word_vector[n2][n1] += 1
• 兩層循環獲取共現矩陣 word_vector[i][j] 中不為0的數值，word[i]、word[j] 和權重 word_vector[i][j] 即為三元組
• 將最終結果輸出至TXT和CSV文件

            
              
                # -*- coding: utf-8 -*-
              
              
                """
@author: eastmount CSDN 楊秀璋 2019-09-02
"""
              
              
                import
              
               pandas 
              
                as
              
               pd

              
                import
              
               numpy 
              
                as
              
               np

              
                import
              
               codecs

              
                import
              
               networkx 
              
                as
              
               nx

              
                import
              
               matplotlib
              
                .
              
              pyplot 
              
                as
              
               plt

              
                import
              
               csv
 

              
                #---------------------------第一步:讀取數據-------------------------------
              
              
word 
              
                =
              
              
                [
              
              
                ]
              
              
                #記錄關鍵詞
              
              
f 
              
                =
              
              
                open
              
              
                (
              
              
                "word.txt"
              
              
                )
              
                          
line 
              
                =
              
               f
              
                .
              
              readline
              
                (
              
              
                )
              
              
                while
              
               line
              
                :
              
              
                #print line
              
              
    line 
              
                =
              
               line
              
                .
              
              replace
              
                (
              
              
                "\n"
              
              
                ,
              
              
                ""
              
              
                )
              
              
                #過濾換行
              
              
    line 
              
                =
              
               line
              
                .
              
              strip
              
                (
              
              
                '\n'
              
              
                )
              
              
                for
              
               n 
              
                in
              
               line
              
                .
              
              split
              
                (
              
              
                ';'
              
              
                )
              
              
                :
              
              
                #print n
              
              
                if
              
               n 
              
                not
              
              
                in
              
               word
              
                :
              
              
            word
              
                .
              
              append
              
                (
              
              n
              
                )
              
              
    line 
              
                =
              
               f
              
                .
              
              readline
              
                (
              
              
                )
              
              
f
              
                .
              
              close
              
                (
              
              
                )
              
              
                print
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                #作者總數
              
              
                #--------------------------第二步 計算共現矩陣----------------------------
              
              
a 
              
                =
              
               np
              
                .
              
              zeros
              
                (
              
              
                [
              
              
                2
              
              
                ,
              
              
                3
              
              
                ]
              
              
                )
              
              
                print
              
               a


              
                #共現矩陣
              
              
                #word_vector = np.zeros([len(word),len(word)], dtype='float16') 
              
              
                #MemoryError：矩陣過大匯報內存錯誤
              
              
                #https://jingyan.baidu.com/article/a65957f434970a24e67f9be6.html
              
              
                #采用coo_matrix函數解決該問題
              
              
                from
              
               scipy
              
                .
              
              sparse 
              
                import
              
               coo_matrix

              
                print
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                #類型
                
              
              
word_vector 
              
                =
              
               coo_matrix
              
                (
              
              
                (
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                ,
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                )
              
              
                ,
              
               dtype
              
                =
              
              np
              
                .
              
              int8
              
                )
              
              
                .
              
              toarray
              
                (
              
              
                )
              
              
                print
              
               word_vector
              
                .
              
              shape

f 
              
                =
              
              
                open
              
              
                (
              
              
                "word.txt"
              
              
                )
              
              
line 
              
                =
              
               f
              
                .
              
              readline
              
                (
              
              
                )
              
              
                while
              
               line
              
                :
              
              
    line 
              
                =
              
               line
              
                .
              
              replace
              
                (
              
              
                "\n"
              
              
                ,
              
              
                ""
              
              
                )
              
              
                #過濾換行
              
              
    line 
              
                =
              
               line
              
                .
              
              strip
              
                (
              
              
                '\n'
              
              
                )
              
              
                #過濾換行
              
              
    nums 
              
                =
              
               line
              
                .
              
              split
              
                (
              
              
                ';'
              
              
                )
              
              
                #循環遍歷關鍵詞所在位置 設置word_vector計數
              
              
    i 
              
                =
              
              
                0
              
              
    j 
              
                =
              
              
                0
              
              
                while
              
               i
              
                <
              
              
                len
              
              
                (
              
              nums
              
                )
              
              
                :
              
              
                #ABCD共現 AB AC AD BC BD CD加1
              
              
        j 
              
                =
              
               i 
              
                +
              
              
                1
              
              
        w1 
              
                =
              
               nums
              
                [
              
              i
              
                ]
              
              
                #第一個單詞
              
              
                while
              
               j
              
                <
              
              
                len
              
              
                (
              
              nums
              
                )
              
              
                :
              
              
            w2 
              
                =
              
               nums
              
                [
              
              j
              
                ]
              
              
                #第二個單詞
              
              
                #從word數組中找到單詞對應的下標
              
              
            k 
              
                =
              
              
                0
              
              
            n1 
              
                =
              
              
                0
              
              
                while
              
               k
              
                <
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                :
              
              
                if
              
               w1
              
                ==
              
              word
              
                [
              
              k
              
                ]
              
              
                :
              
              
                    n1 
              
                =
              
               k
                    
              
                break
              
              
                k 
              
                =
              
               k 
              
                +
              
              
                1
              
              
                #尋找第二個關鍵字位置
              
              
            k 
              
                =
              
              
                0
              
              
            n2 
              
                =
              
              
                0
              
              
                while
              
               k
              
                <
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                :
              
              
                if
              
               w2
              
                ==
              
              word
              
                [
              
              k
              
                ]
              
              
                :
              
              
                    n2 
              
                =
              
               k
                    
              
                break
              
              
                k 
              
                =
              
               k 
              
                +
              
              
                1
              
              
                #重點: 詞頻矩陣賦值 只計算上三角
              
              
                if
              
               n1
              
                <=
              
              n2
              
                :
              
              
                word_vector
              
                [
              
              n1
              
                ]
              
              
                [
              
              n2
              
                ]
              
              
                =
              
               word_vector
              
                [
              
              n1
              
                ]
              
              
                [
              
              n2
              
                ]
              
              
                +
              
              
                1
              
              
                else
              
              
                :
              
              
                word_vector
              
                [
              
              n2
              
                ]
              
              
                [
              
              n1
              
                ]
              
              
                =
              
               word_vector
              
                [
              
              n2
              
                ]
              
              
                [
              
              n1
              
                ]
              
              
                +
              
              
                1
              
              
                #print n1, n2, w1, w2
              
              
            j 
              
                =
              
               j 
              
                +
              
              
                1
              
              
        i 
              
                =
              
               i 
              
                +
              
              
                1
              
              
                #讀取新內容
              
              
    line 
              
                =
              
               f
              
                .
              
              readline
              
                (
              
              
                )
              
              
f
              
                .
              
              close
              
                (
              
              
                )
              
              
                #--------------------------第三步  TXT文件寫入--------------------------
              
              
res 
              
                =
              
              
                open
              
              
                (
              
              
                "word_word_weight.txt"
              
              
                ,
              
              
                "a+"
              
              
                )
              
              
i 
              
                =
              
              
                0
              
              
                while
              
               i
              
                <
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                :
              
              
    w1 
              
                =
              
               word
              
                [
              
              i
              
                ]
              
              
    j 
              
                =
              
              
                0
              
              
                while
              
               j
              
                <
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                :
              
              
        w2 
              
                =
              
               word
              
                [
              
              j
              
                ]
              
              
                #判斷兩個詞是否共現 共現&詞頻不為0的寫入文件
              
              
                if
              
               word_vector
              
                [
              
              i
              
                ]
              
              
                [
              
              j
              
                ]
              
              
                >
              
              
                0
              
              
                :
              
              
                #print w1 +" " + w2 + " "+ str(int(word_vector[i][j]))
              
              
            res
              
                .
              
              write
              
                (
              
              w1 
              
                +
              
              
                " "
              
              
                +
              
               w2 
              
                +
              
              
                " "
              
              
                +
              
              
                str
              
              
                (
              
              
                int
              
              
                (
              
              word_vector
              
                [
              
              i
              
                ]
              
              
                [
              
              j
              
                ]
              
              
                )
              
              
                )
              
              
                +
              
              
                "\r\n"
              
              
                )
              
              
        j 
              
                =
              
               j 
              
                +
              
              
                1
              
              
    i 
              
                =
              
               i 
              
                +
              
              
                1
              
              
res
              
                .
              
              close
              
                (
              
              
                )
              
              
                #共現矩陣寫入文件 如果作者數量較多, 建議刪除下面部分代碼
              
              
res 
              
                =
              
              
                open
              
              
                (
              
              
                "word_jz.txt"
              
              
                ,
              
              
                "a+"
              
              
                )
              
              
i 
              
                =
              
              
                0
              
              
                while
              
               i
              
                <
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                :
              
              
    j 
              
                =
              
              
                0
              
              
    jz 
              
                =
              
              
                ""
              
              
                while
              
               j
              
                <
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                :
              
              
        jz 
              
                =
              
               jz 
              
                +
              
              
                str
              
              
                (
              
              
                int
              
              
                (
              
              word_vector
              
                [
              
              i
              
                ]
              
              
                [
              
              j
              
                ]
              
              
                )
              
              
                )
              
              
                +
              
              
                " "
              
              
        j 
              
                =
              
               j 
              
                +
              
              
                1
              
              
    res
              
                .
              
              write
              
                (
              
              jz 
              
                +
              
              
                "\r\n"
              
              
                )
              
              
    i 
              
                =
              
               i 
              
                +
              
              
                1
              
              
res
              
                .
              
              close
              
                (
              
              
                )
              
              
                #--------------------------第四步  CSV文件寫入--------------------------
              
              
c 
              
                =
              
              
                open
              
              
                (
              
              
                "word-word-weight.csv"
              
              
                ,
              
              
                "wb"
              
              
                )
              
              
                #創建文件
              
              
                #c.write(codecs.BOM_UTF8)                   #防止亂碼
              
              
writer 
              
                =
              
               csv
              
                .
              
              writer
              
                (
              
              c
              
                )
              
              
                #寫入對象
              
              
writer
              
                .
              
              writerow
              
                (
              
              
                [
              
              
                'Word1'
              
              
                ,
              
              
                'Word2'
              
              
                ,
              
              
                'Weight'
              
              
                ]
              
              
                )
              
              

i 
              
                =
              
              
                0
              
              
                while
              
               i
              
                <
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                :
              
              
    w1 
              
                =
              
               word
              
                [
              
              i
              
                ]
              
              
    j 
              
                =
              
              
                0
              
              
                while
              
               j
              
                <
              
              
                len
              
              
                (
              
              word
              
                )
              
              
                :
              
              
        w2 
              
                =
              
               word
              
                [
              
              j
              
                ]
              
              
                #判斷兩個詞是否共現 共現詞頻不為0的寫入文件
              
              
                if
              
               word_vector
              
                [
              
              i
              
                ]
              
              
                [
              
              j
              
                ]
              
              
                >
              
              
                0
              
              
                :
              
              
                #寫入文件
              
              
            templist 
              
                =
              
              
                [
              
              
                ]
              
              
            templist
              
                .
              
              append
              
                (
              
              w1
              
                )
              
              
            templist
              
                .
              
              append
              
                (
              
              w2
              
                )
              
              
            templist
              
                .
              
              append
              
                (
              
              
                str
              
              
                (
              
              
                int
              
              
                (
              
              word_vector
              
                [
              
              i
              
                ]
              
              
                [
              
              j
              
                ]
              
              
                )
              
              
                )
              
              
                )
              
              
                #print templist
              
              
            writer
              
                .
              
              writerow
              
                (
              
              templist
              
                )
              
              
        j 
              
                =
              
               j 
              
                +
              
              
                1
              
              
    i 
              
                =
              
               i 
              
                +
              
              
                1
              
              
c
              
                .
              
              close
              
                (
              
              
                )
              
            
          

如果輸入數據為：

            
              A
              
                ;
              
              B
              
                ;
              
              C
              
                ;
              
              D
A
              
                ;
              
              B
              
                ;
              
              C
B
              
                ;
              
              A
              
                ;
              
              D
D
              
                ;
              
              A

            
          

則輸出結果如下圖所示：

第三步：最終的“清水江”文獻輸出結果如下所示，主要是 word-word-weight.csv 文件。

由于split函數分割過程中，可能存在多余空格的現象，如下圖所示，我們將含有空白的欄目刪除。

完整的三元組共1255組，即構成了1255條邊。

注意，如果作者數較多時，代碼中盡量不要使用print輸出中間結果，并且只做 word-word-weight.csv 文件寫入操作即可。同時，建議先嘗試運行小的數據集，如前面的ABCD，代碼能正確運行之后再加載大的數據集。

---

五.Gephi構建知識圖譜

眾所周知，知識圖譜都是有節點和邊組成的，每一個作者或每一個關鍵詞可以作為一個節點，而共現關系可以構造邊。如果共現的次數越多，表示合作越緊密，則邊越粗，反之越細。當使用度來表示節點大小時，如果某個節點越大，則表示該節點共現合作的數量越多。下面開始分享Gephi軟件繪制關系圖譜的流程。

(一).數據準備

edges.csv
包含邊的文件就是前面的 word-word-weight.csv，但需要修改表頭并增加一列類型Type，其值為Undirected（無向圖）。

            
              Source
              
                ,
              
              Target
              
                ,
              
              Type
              
                ,
              
              Weight
趙艷
              
                ,
              
              吳娟
              
                ,
              
              Undirected
              
                ,
              
              
                1
              
              
趙艷
              
                ,
              
              楊興
              
                ,
              
              Undirected
              
                ,
              
              
                1
              
              
趙艷
              
                ,
              
              張詩瑩
              
                ,
              
              Undirected
              
                ,
              
              
                1
              
              
傅慧平
              
                ,
              
              張金成
              
                ,
              
              Undirected
              
                ,
              
              
                2
              
              
傅慧平
              
                ,
              
              楊正宏
              
                ,
              
              Undirected
              
                ,
              
              
                1
              
              
周相卿
              
                ,
              
              劉嘉寶
              
                ,
              
              Undirected
              
                ,
              
              
                1
              
              
曹端波
              
                ,
              
              付前進
              
                ,
              
              Undirected
              
                ,
              
              
                1
              
              
李紅香
              
                ,
              
              馬國君
              
                ,
              
              Undirected
              
                ,
              
              
                4
              
              
胡世然
              
                ,
              
              楊興
              
                ,
              
              Undirected
              
                ,
              
              
                3
              
              
胡世然
              
                ,
              
              周承輝
              
                ,
              
              Undirected
              
                ,
              
              
                4
              
              
胡世然
              
                ,
              
              李建光
              
                ,
              
              Undirected
              
                ,
              
              
                7
              
              
胡世然
              
                ,
              
              朱玲
              
                ,
              
              Undirected
              
                ,
              
              
                3
              
            
          

nodes.csv
接下來我們還要創建一個包含節點的信息。只需要將Source和Target兩列數據復制到nodes.csv中，然后去除重復的即可。當然，如果數量很大，Python寫個循環代碼也能處理。

接著將第一列復制到第二列，需要注意id表示編號（名稱）、label表示節點類標，這里中文顯示。nodes.csv最終輸出結果如下圖所示：

            
              
                id
              
              
                ,
              
              label
趙艷
              
                ,
              
              趙艷
傅慧平
              
                ,
              
              傅慧平
周相卿
              
                ,
              
              周相卿
曹端波
              
                ,
              
              曹端波
李紅香
              
                ,
              
              李紅香
王華
              
                ,
              
              王華
韋建麗
              
                ,
              
              韋建麗
徐杰舜
              
                ,
              
              徐杰舜

            
          

(二).數據導入

數據準備充分之后，開始我們的知識圖譜構建之旅吧！

第一步：安裝并打開Gephi軟件。軟件我已經上傳到下載包中供大家使用了。

第二步：新建工程，并選擇“數據資料”，輸入電子表格。

第三步：導入節點文件nodes.csv，注意CSV文件中表頭切記定位為 id、label，導入一定選擇“節點表格”和“GB2312”編碼，點擊“完成”即可。

第四步：導入邊文件edges.csv，注意CSV文件中表頭切記為Source（起始點）、Target（目標點）、Weight（權重）、Tpye（無向邊 Undirected）。

導入成功后如下圖所示：

導入成功后點擊“概覽”顯示如下所示，接著就是調整參數。

(三).知識圖譜參數設置

設置外觀如下圖所示，主要包括顏色、大小、標簽顏色、標簽尺寸。

1.設置節點大小和顏色。
選中顏色，點擊“數值設定”，選擇渲染方式為“度”。

顯示結果如下所示：

接著設置節點大小，數值設定為“度”，最小尺寸為20，最大尺寸為80。

2.設置邊大小和顏色。
設置邊顏色的數值設定為“邊的權重”，如下圖所示。

設置邊的大小數值設定為“邊的權重”。

3.在布局中選擇“Fruchterman Reingold”。

顯示結果如下所示：

4.設置模塊化。在右邊統計中點擊“運行”，設置模塊性。

5.設置平均路徑長度。在右邊統計中點擊“運行”，設置邊概述。

6.重新設置節點屬性。
節點大小數值設定為“度”，最小值還是20，最大值還是80。
節點顏色數值設定為“Modularity Class”，表示模塊化。

此時圖形顯示如下所示，非常好看，有關系的人物顏色也設置為了類似的顏色。

(四).可視化顯示

顯示標簽如下圖所示：

最終顯示如下圖所示。

講到這里，整篇文章就結束了，同理可以生成關鍵詞的共現圖譜。

同時，如果讀者對如何實現以某一個作者為中心的區域領域，后面作者可以再分享一篇文章。

---

六.總結

最后簡單總結下，Neo4圖數據庫的j缺點是無法設置節點的權重大小，所有節點大小一致，并且運行時間較長。Gephi缺點是不支持語句查詢，希望未來自己能搞一個開源的、靈活的關系圖譜繪制框架。同時，真正的知識圖譜是涉及語義、命名實體識別、關系抽取、實體對齊及消歧等，后面作者在有時間的情況下將繼續為讀者分享相關知識，前行路上與你同在。

珞珞如石，溫而若珈；瀟灑坦蕩，一生澄澈。新學期，新生活，新里程。
一個多月的閉關，深深體會到數學和英語的重要性，短板抓緊補起來，長板卻沒有。開學八門課，《信息論》《現代密碼學》《網絡安全協議》《信息安全前沿》《信息安全與可信計算》《自然語言處理》等，就NLP熟悉點，得加油了，更要靜下心來去“做”、“學”、“問”。Stay hungry，Stay foolish~

(By:Eastmount 2019-09-02 下午5點 http://blog.csdn.net/eastmount/ )

---