亚洲免费在线-亚洲免费在线播放-亚洲免费在线观看-亚洲免费在线观看视频-亚洲免费在线看-亚洲免费在线视频

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜

系統 2481 0

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

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

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

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

文章目錄

  • 一.最終效果圖
  • 二.中國知網導出數據
  • 三.什么是共現關系
  • 四.Python構建共現矩陣和三元組
  • 五.Gephi構建知識圖譜
    • (一).數據準備
    • (二).數據導入
    • (三).知識圖譜參數設置
    • (四).可視化顯示
  • 六.總結

前文參考
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繪制時間軸線及顯示實體


一.最終效果圖

作者合作知識圖譜

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第1張圖片
[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第2張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第3張圖片
[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第4張圖片

關鍵詞共現知識圖譜


二.中國知網導出數據

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

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第5張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第6張圖片

選擇下一頁:

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第7張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第8張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第9張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第10張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第11張圖片

三.什么是共現關系

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

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

            
          

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

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

(1) [ ? A B C D A 0 2 2 2 B 1 0 2 2 C 0 0 0 1 D 1 0 0 0 ] \left[ \begin{matrix} -& 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{matrix} \right] \tag{1} ? ? ? ? ? ? ? ? A B C D ? A 0 1 0 1 ? B 2 0 0 0 ? C 2 2 0 0 ? D 2 2 1 0 ? ? ? ? ? ? ? ? ( 1 )

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

(1) [ ? A B C D A 0 3 2 3 B 0 0 2 2 C 0 0 0 1 D 0 0 0 0 ] \left[ \begin{matrix} -& 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{matrix} \right] \tag{1} ? ? ? ? ? ? ? ? A B C D ? A 0 0 0 0 ? B 3 0 0 0 ? C 2 2 0 0 ? D 3 2 1 0 ? ? ? ? ? ? ? ? ( 1 )

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

(2) [ S o u r c e T a r g e t W e i g h t A B 3 A C 2 A D 3 B C 2 B D 2 C D 1 ] \left[ \begin{matrix} Source & Target & Weight \\ A & B & 3 \\ A & C & 2 \\ A & D & 3 \\ B & C & 2 \\ B & D & 2 \\ C & D & 1 \end{matrix} \right] \tag{2} ? ? ? ? ? ? ? ? ? ? ? S o u r c e A A A B B C ? T a r g e t B C D C D D ? W e i g h t 3 2 3 2 2 1 ? ? ? ? ? ? ? ? ? ? ? ? ( 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和Gephi實現中國知網合作關系知識圖譜_第12張圖片

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


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

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第13張圖片

第二步:運行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

            
          

則輸出結果如下圖所示:

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第14張圖片

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

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第15張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第16張圖片

注意,如果作者數較多時,代碼中盡量不要使用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
              
            
          
[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第17張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第18張圖片

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

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

            
          
[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第19張圖片

(二).數據導入

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

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第20張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第21張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第22張圖片
[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第23張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第24張圖片
[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第25張圖片

導入成功后如下圖所示:

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第26張圖片
[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第27張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第28張圖片

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

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第29張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第30張圖片

顯示結果如下所示:

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第31張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第32張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第33張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第34張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第35張圖片

顯示結果如下所示:

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第36張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第37張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第38張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第39張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第40張圖片

(四).可視化顯示

顯示標簽如下圖所示:

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第41張圖片

最終顯示如下圖所示。

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第42張圖片
[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第43張圖片

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

[Python知識圖譜] 四.Python和Gephi實現中國知網合作關系知識圖譜_第44張圖片

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


六.總結

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

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

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



更多文章、技術交流、商務合作、聯系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號聯系: 360901061

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對您有幫助就好】

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長會非常 感謝您的哦!!!

發表我的評論
最新評論 總共0條評論
主站蜘蛛池模板: 日韩亚洲欧美一区 | 中文亚洲欧美 | 久久国产精品亚洲77777 | 日日摸夜夜添夜夜添人人爽 | 麻豆传煤一区免费入 | 毛片毛片毛片毛片 | 天天综合亚洲 | 五月天在线免费视频 | 手机看片日韩国产 | 欧美 亚洲 中文字幕 | 欧美一级毛片香蕉网 | 香蕉久久久久 | 毛片天天看 | 久久久国产精品免费看 | 国产精品夜色视频一区二区 | 国产福利小视频在线观看 | 久久影视免费体验区午夜啪啪 | 天天操夜夜操免费视频 | 波多野一区二区三区在线 | 色综合综合色综合色综合 | 国产亚洲精品一区二区久久 | 999热视频 | 97天天干 | 欧美一区二区三区高清视频 | 国产亚洲男人的天堂在线观看 | 国产91九色在线播放 | 国产高清精品久久久久久久 | 天天做天天爱天天影视综合 | 九九这里只有精品视频 | 天天射夜夜骑 | 这里只有精品免费视频 | 香蕉久久a毛片 | 欧美金8天国 | 日本一级特黄毛片免费视频 | 亚洲另类图片专区 | 97在线观免费视频观看 | 日本裤袜xxxx视频 | 中文字幕在线播 | 在线播放日本爽快片 | 成人影院高清在线观看免费网站 | 日本免费一区二区三区看片 |