?🔎大家好，我是Sonhhxg_柒，希望你看完之后，能對你有所幫助，不足請指正！共同學習交流🔎

📝個人主頁－Sonhhxg_柒的博客_CSDN博客?📃

🎁歡迎各位→點贊👍 + 收藏⭐️ + 留言📝?

📣系列專欄 - 機器學習【ML】?自然語言處理【NLP】? 深度學習【DL】

??

?🖍foreword

✔說明?本人講解主要包括Python、機器學習（ML）、深度學習（DL）、自然語言處理（NLP）等內容。

如果你對這個系列感興趣的話，可以關注訂閱喲👋

文章目錄

技術要求

社區檢測及其應用介紹

識別節點集群

社區檢測方法的應用

推薦引擎和有針對性的營銷

欺詐識別

預測屬性或鏈接

社區檢測技術的簡要概述

檢測圖形組件和可視化社區

弱連接組件

強連接組件

將 GDS 結果寫入圖表

使用 neovis.js 可視化圖表

使用 NEuler，圖形數據科學游樂場

用于社區檢測可視化

運行標簽傳播算法

定義標簽傳播

加權節點和關系

半監督學習

在 Python 中實現標簽傳播

使用 GDS 中的標簽傳播算法

使用種子

將結果寫入圖表

了解Louvain算法

定義模塊化

所有節點都在自己的社區中

所有節點都在同一個社區

最優分區

重現 Louvain 算法的步驟

GDS 中的 Louvain 算法

句法

關系投影中的聚合方法

中間步驟

Zachary 的空手道俱樂部圖上的 Label Propagation 和 Louvain 之間的比較

超越 Louvain的重疊社區檢測

Louvain算法的注意事項

分辨率限制

Louvain的替代品

重疊社區檢測

動態網絡

測量節點之間的相似性

基于集合的相似性

重疊

杰卡德相似度

基于向量的相似性

歐幾里得距離

余弦相似度

概括

問題

進一步閱讀

---

現實世界的圖既不是規則的也不是完全隨機的網格。它們的邊緣密度不均勻，因此我們最終找到了一些有趣的模式。中心性算法利用一些節點可以比其他節點擁有更多連接的事實來評估節點重要性（參見第 6 章，節點重要性）。在本章中，我們將發現一種新型算法，其目標是識別彼此高度連接的節點組并形成社區或集群。其中一些社區檢測算法已經在 GDS 中實現：組件算法、標簽傳播算法和 Louvain 算法。?本章是我們使用 JavaScript 構建社區圖形表示并發現 NEuler（由 Neo4j 開發的圖形算法游樂場應用程序）的機會。最后，我們還將了解 GDS 中實現的不同指標，以在本地測量兩個節點之間的相似性。

本章將涵蓋以下主題：

• 社區檢測及其應用介紹
• 檢測圖形組件和可視化社區
• 運行標簽傳播算法
• 了解Louvain算法
• 超越 Louvain 的重疊社區檢測
• 測量節點之間的相似性

技術要求

在本章中，我們將使用以下工具：

• Neo4j 圖形數據庫列出了以下縮進擴展：
• 插件：圖形數據科學庫
• Neo4j 桌面應用程序
• 用于圖形可視化的 NEuler
• 您還需要一個瀏覽器來打開 HTML 和我們將為圖形可視化構建的 JavaScript 文件。
• Python（推薦≥3.6）運行一些算法的示例實現。
• 本章使用的代碼可在本書的 GitHub 存儲庫中找到，網址為
  https://github.com/PacktPublishing/Hands-On-Graph-Analytics-with-Neo4j/ch7

• 如果您使用的是Neo4j < 4.0，那么GDS的最后一個兼容版本是1.1。
• 如果您使用的是Neo4j ≥ 4.0，那么GDS的第一個兼容版本是1.2。

社區檢測及其應用介紹

社區檢測收集已開發用于理解圖結構并從中提取信息的技術。這種結構隨后可以用于許多應用中，例如推薦引擎、欺詐檢測、屬性預測和鏈接預測。

在本章中，我將使用community、cluster或partition來指代一組共享公共屬性的節點。

識別節點集群

下圖顯示了我們在第 2 章“?Cypher 查詢語言”中構建的 Neo4j GitHub 用戶圖表。社區檢測算法能夠識別幾個社區：

使用 Louvain 算法和 neoviz.js 生成的圖像

在本章結束時，您將能夠重現此圖像。需要進一步分析以了解紫羅蘭社區用戶的共同屬性。對該圖的更深入分析告訴我們，紫羅蘭社區中的用戶顯然從人群中脫穎而出，并且大部分都為獨特的存儲庫做出了貢獻。

在深入每個算法的技術細節之前，我們首先要更多地討論知道節點屬于哪個社區的優勢。雖然我們在這里談論的是由用戶組成的社區，但這可以應用于許多其他領域。我們將在本節的其余部分介紹其中的一些。

社區檢測方法的應用

社區檢測和圖聚類有很多應用。例如，它們可用于以下領域：

• 生物學：蛋白質-蛋白質相互作用網絡模擬細胞內的蛋白質相互作用。屬于同一群落的蛋白質更有可能參與相同的功能。
• 神經科學：研究人員將人腦建模為圖形，其中每個節點都是少量細胞。事實證明，了解該圖的社區結構對于了解大腦的不同部分如何相互協調特別有用。
• 公共衛生：我們可以使用人口的社區結構來嘗試和預測疾病的演變和傳播。

接下來的部分將重點介紹一些更有可能對您直接有用的應用程序。

推薦引擎和有針對性的營銷

我們已經在第 3 章“使用 Pure Cypher 為您的業務賦能”中探討了使用 Neo4j 和 Cypher 的建議。但當時，我們只使用圖遍歷來查找一起購買的產品或當前客戶通過社交關系連接到的用戶購買的產品。社區檢測為游戲帶來了一種新的信息，可用于提供更相關的建議。

產品集群

例如，能夠將相似的產品歸為一組有助于識別通常不會歸入同一類別的相似產品。它還可用于查找 eBay 等市場上不同零售商銷售的相同產品。使用該信息，您可以防止從其他供應商推薦給定客戶已經購買的產品。

用戶群

使用社區檢測來改進推薦引擎的另一種方法是嘗試創建客戶組。通過這種方式，您可以創建具有相似習慣的客戶群體，這些客戶群體可以反映相似的興趣。在提議體育相關文章的電子商務網站上，您可以創建一個漁民社區和一個足球運動員社區，除了他們的購買之外，您不需要任何關于您的用戶的先驗知識：如果購買的產品主要是關于釣魚的，那么您認識這個客戶很可能是漁夫。該知識可用于擴展相關建議的列表。例如，一些尚未被任何人購買的新足球襪可能會被推薦給被識別為足球運動員的用戶。

欺詐識別

欺詐檢測在前一章（第 6 章，節點重要性）中討論過。我們討論了欺詐者創建犯罪團伙并相互合作以避免被發現的方式。這種組織很難通過傳統方法檢測到，但由于其基于關系的原生結構，圖表是打擊所有類型欺詐的非常有用的工具。假設欺詐者之間會進行更多互動，例如在假用戶共享相同電話號碼或地址的情況下，圖表可以形成一個社區并且更容易識別。

預測屬性或鏈接

社區檢測和上述大多數應用的基本思想之一是屬于同一社區的節點共享一些屬性。這可用于根據圖的社區結構進行預測。讓我們從下圖所示的子圖開始：

它包含三個節點A、B和C，以及兩條邊（（A，B）和（A，C））。這可能是具有更多輸出邊的更大圖的一部分。節點A和B有一個值為 1 的屬性。這可能是某些用戶的年齡類別，這并不總是可用的。用戶A和B填寫了該字段，表明他們在 21 到 30 之間。最重要的是，一些社區檢測算法已經設法將所有三個節點聚集到同一個社區中。直觀地說，我們可以說節點C的概率隨著有關圖結構的新知識，也屬于 21-30 歲年齡段。

類似地，如果我們試圖測量B和C之間的邊在我們不知道或將來出現的情況下存在的概率，那么對于同一社區中的節點來說它會更高。

社區檢測技術的簡要概述

最早的圖結構研究之一是由 Weiss 和 Jacobson 進行的，并于 1955 年發表。從那時起，已經使用不同類型的規則研究和實現了幾種類型的算法。

至于節點重要性問題，在社區檢測問題的情況下，首先要考慮的是定義度量或目標函數，它將量化圖分區的好壞。社區最常見的定義指出，社區是一組節點，其社區內連接（同一社區中的節點之間的邊更多）比社區間連接（兩個不同社區中的節點之間的邊）多。但是即使有了這個定義，也有幾種可能的方法可以實現令人滿意的分區。

已經提出了許多算法，使用不同的度量。例如，層次聚類使用一些規則來創建樹狀圖，從而創建聚類的層次結構。Girvan-Newman 算法是層次聚類的一個例子，它使用了通常用于節點到邊的中介中心性的擴展：具有最高中介中心性的邊是圖中兩對節點之間的最短路徑中最常涉及的邊。其他層次聚類算法使用相似性度量而不是拓撲度量。在本章的最后（在測量節點之間的相似性部分），我們將學習如何測量節點之間的相似性。

在本書中，我們將重點介紹 Neo4j 中實現的一些算法：

• 連接組件，它允許我們檢測斷開連接的子圖。
• 標簽傳播，顧名思義，通過基于多數投票規則的圖傳播社區標簽，以將每個節點分配給其新社區。
• Louvain 算法優化了模塊化，定義為社區內連接數與社區間連接數之間的差異。

即使尚未在 GDS 中實現，我們也會討論這些算法的一些改進建議，尤其是 Leiden 算法，該算法旨在解決 Louvain 算法的一些問題。我們還將簡要解決上述算法未涵蓋的重疊社區問題。

現在讓我們使用連接組件算法開始我們的社區檢測之旅。在下一節中，我們將學習組件算法。我們還將發現以圖形格式可視化檢測到的社區的工具，這對于理解中圖的結構至關重要。

檢測圖形組件和可視化社區

圖形組件具有明確的數學定義。在給定的組件中，兩個節點始終通過路徑相互連接，但不連接到組件外的任何其他節點。有兩個版本的連接組件：

• 強連接組件：這些確保同一組件中的兩個節點之間的路徑存在于兩個方向。
• 弱連接組件：對于弱連接組件，單個方向就足夠了。

讓我們看看 Neo4j 中的一個例子。在本節中，我們還將在本書中首次使用寫入過程將算法結果存儲在 Neo4j 中。我們還將引入一個新的 JavaScript 庫來自定義大圖的可視化。

讓我們從以下有向圖開始：

用于創建圖表的 Cypher 代碼可在 GitHub (?https://github.com/PacktPublishing/Hands-On-Graph-Analytics-with-Neo4j/blob/master/ch7/test_graph.cql?) 上獲得。

在視覺上，我們可以說這個圖中至少有兩個組件。節點Y和Z與圖中的任何其他節點完全斷開連接，因此從這兩個節點到圖中的任何其他節點都沒有任何路徑。讓我們看看如何從 GDS 中實現的算法中學習這些信息。

我們將使用以下投影圖：

CALL gds.graph.create("simple_projected_graph", "Node", "LINKED_TO")

此投影圖包含帶有標簽的所有節點Node以及與自然方向上的類型的所有關系LINKED_TO（如使用 Cypher 創建它們時定義的那樣，如上圖所示），它們沒有附加任何屬性。

弱連接組件

我們將在這里學習的第一個算法是弱連接組件或聯合查找。

弱連接組件，連同我們將在本章后面介紹的 Louvain 和標簽傳播算法，都是 GDS 1.0 版中的生產就緒算法。

要查看使用弱連接組件進行圖分區的結果，請使用以下查詢：

CALL gds.wcc.stream("simple_projected_graph") 
YIELD nodeId, componentId
RETURN gds.util.asNode(nodeId).name as nodeName, componentId
ORDER BY componentId

這是我們的結果：

╒══════════╤═════════════╕
│"nodeName"│"componentId"│
╞══════════╪═════════════╡
│"A"       │0            │
├──────────┼─────────────┤
│"B"       │0            │
├──────────┼─────────────┤
│"C"       │0            │
├──────────┼─────────────┤
│"D"       │0            │
├──────────┼─────────────┤
│"E"       │0            │
├──────────┼─────────────┤
│"F"       │0            │
├──────────┼─────────────┤
│"G"       │0            │
├──────────┼─────────────┤
│"Y"       │7            │
├──────────┼─────────────┤
│"Z"       │7            │
└──────────┴─────────────┘

如您所見，該算法成功識別出兩個組件：

• 此示例中標記的組件7，包含節點Y和Z
• 另一個標記為 的組件0，包含所有其他節點

用于標記社區的確切數字不相關；這取決于 GDS 的內部功能。根據您的圖表的創建方式，您獲得的數字可能會有所不同，但應該檢測到相同的社區。

考慮到圖是無向的，弱連接組件告訴我們，我們的圖中有兩個不連接的分區。如果關系方向很重要，例如在道路網絡中，那么我們將不得不使用強連通分量算法。

強連接組件

在強連接的組件中，關系的方向很重要。組件中的每個節點都必須能夠在兩個方向上連接同一組件中的任何其他節點。關注節點A到G，通過弱連通分量算法將它們分組在同一個社區中，您可以看到并非總是可以從一個節點到另一個節點在兩個方向上。例如，從D到A是可能的（通過C），但從A到D是不可能的。

要查看使用此更強規則標識的組件，我們可以gds.alpha.scc按以下方式使用該過程：

CALL gds.alpha.scc.stream("simple_projected_graph") 
YIELD nodeId, partition as componentId
RETURN gds.util.asNode(nodeId).name as nodeName, componentId
ORDER BY componentId

以下是前面代碼的結果：

╒══════════╤═════════════╕
│"nodeName"│"componentId"│
╞══════════╪═════════════╡
│"A"       │0            │
├──────────┼─────────────┤
│"B"       │0            │
├──────────┼─────────────┤
│"C"       │0            │
├──────────┼─────────────┤
│"D"       │3            │
├──────────┼─────────────┤
│"E"       │3            │
├──────────┼─────────────┤
│"F"       │3            │
├──────────┼─────────────┤
│"G"       │3            │
├──────────┼─────────────┤
│"Y"       │7            │
├──────────┼─────────────┤
│"Z"       │7            │
└──────────┴─────────────┘

這一次，確定了三個組件：雖然節點Y和Z仍在它們自己的組件中，但節點A、B和C現在與D、E、F和斷開連接G。

連通分量對于理解我們的圖結構是非常有用的算法。一些算法，如 PageRank（參見第 6 章，節點重要性）可能會在具有多個組件的圖上導致意外結果。在圖形數據分析的數據探索部分運行連接組件算法是一種很好的做法。

在繼續研究其他社區檢測算法之前，我們將討論一些允許我們以更好的格式可視化社區的工具。其中一些將要求社區編號 (?componentID) 是節點屬性。這就是為什么我們現在要解決 GDS 的一個功能，我們目前還沒有利用：在 Neo4j 圖中寫入算法結果的可能性，而不是將它們流回給用戶并讓他們決定如何處理它們.

將 GDS 結果寫入圖表

在第 4 章，圖形數據科學庫和路徑查找中，我們介紹了 GDS 的寫入功能，允許我們將算法的結果存儲在 Neo4j 中。此功能適用于 GDS 中實現的幾乎所有算法。基本上，不提供此選項的算法是返回矩陣的算法，例如All Pairs 最短路徑算法或我們將在本章末尾介紹的一些相似性算法。

讓我們看一下使用連接組件算法的寫入過程的應用。

寫入過程的語法與流一非常相似。主要區別在于它接受另一個配置參數 ，writeProperty它允許我們配置將添加到每個節點的屬性的名稱。

以下查詢會將弱連接組件算法的結果寫入wcc每個節點的屬性中：

CALL gds.wcc.write("simple_projected_graph", {writeProperty: "wcc"}
)

這里，返回的結果包含有關算法運行時間和圖結構的信息：

但是要查看每個節點所屬的分區，我們將不得不使用另一個 Cypher 查詢：

MATCH (n:Node) 
RETURN n.name as nodeName, n.wcc

使用強連接的組件也可以實現相同的目標：

CALL gds.alpha.scc.write("simple_projected_graph", {writeProperty: "scc"})

在其之上name，每個節點現在還包含另外兩個名為wccand的屬性scc，其中包含根據弱連接和強連接組件算法該節點所屬的組件的 ID。在這里，您可以看到 node 的內容D：

{"name": "D","scc": 3,"wcc": 0
}

當圖非常大時，將結果寫入圖有時是唯一的解決方案（我們將在第 12 章，Neo4j at Scale中更多地討論大數據的情況）。但它在其他情況下也很有用。我們現在將討論其中之一。

到目前為止，我們只使用了非常小的圖表，通過從表格中讀取結果很容易理解它們。但這不是圖算法最常見的用例，它主要用于中型和大型圖。在這些情況下，以圖形格式可視化社區檢測算法的結果對于理解圖形的結構可能更為重要。在下一節中，我們將發現兩種根據屬性繪制不同大小或顏色的節點的方法：第一種是neovis.js用于將圖形可視化嵌入 HTML 頁面的 JavaScript 庫，第二種是 NEuler，Graph Algorithms Playground，一個基于此包的 Neo4j 桌面應用程序。

使用 neovis.js 可視化圖表

當涉及到社區時，有一種方法來可視化節點分類和它們之間的關系總是有用的。圖形可視化本身就是一個研究領域，并且存在許多用于良好可視化的軟件包。例如，用于數據可視化的最完整的 JavaScript 庫之一d3.js，也具有繪制圖形的功能。但是，在使用時d3.js，必須管理與 Neo4j 的連接、數據檢索和格式化。這就是為什么在本節和本章的其余部分中，我們將使用開源neovis.jsJavaScript 庫的原因。它非常易于使用，因為與 Neo4j 的連接是在內部管理的，我們不需要任何有關 Neo4j JavaScript 驅動程序的知識就可以使其工作。neovis.js還創建了非常漂亮的可視化，就像本章第一張圖展示的 Neo4j GitHub 社區一樣，它有很多可自定義的參數。

完整的工作示例可在https://github.com/PacktPublishing/Hands-On-Graph-Analytics-with-Neo4j/ch7/connected_components/graph_viz.htmlgraph_viz.html上的文件中找到。

使用以下命令從 GitHub 存儲庫導入庫：

    <script src="https://rawgit.com/neo4j-contrib/neovis.js/master/dist/neovis.js"></script>

最小的 HTML 代碼如下：

    <body onload="draw()"><div id="graph"></div></body>

加載body后會調用前面draw的函數，將圖形繪制到div函數中id="graph"。主函數是draw函數，包含配置參數和渲染方法：

function draw() {let config = {// the ID of the "div" the graph will be drawn intocontainer_id: "graph",// connection parameters to your Neo4j Graph// default is "bolt://localhost:7687" server_url: "bolt://localhost:7687",server_user: "neo4j",server_password: "*****",// Node labels to be fetched// and properties used to customize each node renderinglabels: {"Node": {"caption": "name",  // label drawn next to each node"community": "scc",  // defines the node color}},relationships: {"LINKED_TO": {// disable caption for relationships // since they do not carry any relevant information in our case"caption": false, }},arrows: true, // display the relationships directioninitial_cypher: "MATCH (n:Node)-[r:LINKED_TO]->(m) RETURN *"};let viz = new NeoVis.default(config);viz.render();}

您需要更新圖表的連接參數：?server_url、server_user和server_password。server_password對應于在 Neo4j Desktop 中添加新圖形時要求您創建的密碼。

可以使用您喜歡的瀏覽器打開該文件graph_viz.html，以查看我們圖中的不同社區，由強連通分量算法（scc屬性）標識。生成的圖像應如下圖所示：

如果需要，您還可以通過在draw函數中指示節點配置的大小參數以及包含其重要性的節點的屬性來可視化節點重要性；例如：

             labels: {"Node": {"caption": "name",  // label drawn next to each node"community": "scc",  // defines the node color"size": "pagerank"}},

要使此代碼正常工作，您需要在投影圖上使用寫入過程運行 PageRank 算法：
CALL gds.pageRank("simple_projected_graph", {writeProperty: "pagerank"})

但請記住，PageRank 可能會在圖不連貫的情況下產生意想不到的結果。

neoviz.js如果您想將圖形嵌入到 HTML 頁面中，它是一個強大而有趣的工具。但是，如果您只需要測試算法的結果，則存在一個更簡單的解決方案：NEuler。

使用 NEuler，圖形數據科學游樂場

NEuler 是集成在 Neo4j Desktop 中的開源應用程序，其代碼可在 GitHub 上的GitHub - neo4j-devtools/neuler: Playground for Neo4j Graph Algorithms上找到。

它是一個非常強大的工具，允許我們測試 GDS 中實現的所有算法，從路徑查找（第 4 章，圖形數據科學庫和路徑查找）和中心性（第 5 章，節點重要性）到社區檢測和相似性。它還可以使用基于neoviz.js.

本書的 GitHub 存儲庫中提供了安裝說明。

用于社區檢測可視化

以下屏幕截圖所示的主屏幕是您可以選擇要運行的算法類型的地方：

選擇社區檢測算法后，您可以從上方菜單中選擇要嘗試的算法。對于這個例子，我們將使用強連通分量算法。單擊其名稱后，您可以從右側欄中配置投影圖和算法參數。以下屏幕截圖中所示的配置將執行以下操作：

• 在包含節點標簽Node和關系類型LINKED_TO的投影圖上運行算法orientation=UNDIRECTED。

• 將結果存儲在名為 的屬性中scc。

????????????????????????????????????????

????????

單擊“運行”按鈕將調用正確的 Cypher 程序，您可以通過“代碼”選項卡進行檢查：

最后，您可以在“可視化”選項卡中可視化結果。在那里，您可以自定義將用于為它們著色的節點屬性，就像我們在上一節中所做的那樣neovis.js：

這將關閉我們關于連接組件的部分。我們已經了解了弱連接和強連接組件算法如何幫助我們識別圖中不連接的社區。我們還發現了兩種不同的可視化社區檢測算法結果的方法。我們將在以下部分繼續使用它們，我們將在其中發現新型社區檢測算法：標簽傳播和 Louvain 算法，它們都是 GDS 生產質量層的一部分。

運行標簽傳播算法

標簽傳播是社區檢測算法的另一個例子。于 2017 年提出，其優勢在于可以為已知節點設置一些標簽，并以半監督的方式從中導出未知標簽。它還可以考慮關系和節點權重。在本節中，我們將通過 Python 中的簡單實現來詳細介紹該算法。

定義標簽傳播

存在標簽傳播的幾種變體。主要思想如下：

1. 標簽被初始化，使得每個節點都位于自己的社區中。
2. 標簽根據多數投票規則迭代更新：每個節點接收其鄰居的標簽，并將其中最常見的標簽分配給節點。當最常見的標簽不是唯一的時，就會出現沖突。在這種情況下，需要定義一個規則，它可以是隨機的或確定性的（就像在 GDS 中一樣）。
3. 重復迭代過程，直到所有節點都有固定的標簽。

最佳解決方案是連接具有不同標簽的兩個節點的邊數最少的分區。讓我們考慮下圖：

經過一些迭代，算法將節點A和B分配給一個社區（我們稱之為CR），將節點E和G分配給另一個社區（CG）。根據多數投票規則，在下一次迭代中，節點C將被分配到CR社區，因為連接到C的兩個節點已經屬于這個分區，而只有一個節點 (?D?) 屬于另一個集群。同樣，節點D將分配給CG社區。生成的圖表如下圖所示：

加權節點和關系

為了考慮節點或關系的權重，我們可以更新多數投票規則，使其不僅計算具有給定標簽的節點數，而且計算它們的權重。所選標簽將是權重總和最高的標簽。

讓我們考慮下圖所示的上圖的加權版本：

這一次，為了選擇節點D的標簽，我們必須考慮連接到D的每條邊的權重：

• CR社區的權重= 1 (C) + 8 (D) = 9
• CG社區的權重= 1 (E) + 2 (G) = 3

因此，在該圖的加權版本中，節點D將屬于CR社區。

半監督學習

標簽傳播的另一個有趣的方面是它考慮先驗知識的能力。?如果您已經知道某些節點的社區，則可以在初始化階段使用此信息，而不是設置隨機初始值。這種技術被稱為半監督學習，因為只有一些節點被標記為他們的社區。

在 Python 中實現標簽傳播

在本節中，我們將實現標簽傳播的簡化版本，考慮到種子標簽只能取兩個不同的值：0 或 1。

我們將使用與前幾章相同的圖形表示，基于 Python 字典。我們將使用的圖形由以下對象表示：

    G = {'A': {'B': 1, 'C': 1},'B': {'A': 1, 'C': 1},'C': {'A': 1, 'B': 1, 'D': 1},'D': {'C': 1, 'E': 1, 'G': 1},'E': {'D': 1, 'F': 1, 'G': 1},'F': {'E': 1, 'G': 1},'G': {'D': 1, 'E': 1, 'F': 1},}

它告訴我們節點A連接到節點B和C，兩條邊的權重都等于 1。

現在讓我們開始算法。在初始化階段，我們用唯一值初始化所有標簽。查找唯一值的一種方法是在循環中使用它們的索引來遍歷 的鍵G，這可以在 Python 中通過以下方式實現：

    labels = {node:k  for k, node in enumerate(G)}

該enumerate(iterable)函數返回一個元組，其中包含一個計數（從 0 開始）和通過迭代獲得的值iterable。在這里，iterable是我們的字典G，并且迭代G相當于在 Python 中迭代它的鍵。

然后我們進入主循環。在每次迭代中，我們在圖中的所有節點上執行一個循環，并為每個節點計算它收到的票數：

    for it in range(max_iterations):print("======= Iteration", it)# create a copy of the labels computed in previous iterationold_labels = dict(labels)for node, neighbors in G.items():# counting the number of votes from each neighbors:votes = Counter([old_labels[n] for n in neighbors])

為了找到多數票，我們可以使用以下代碼，它將遍歷收到的票，并在每次找到高于當前最大值的值時更新新標簽的值：

            max_vote = -9999new_label = old_labels[node]for label, vote  in votes.items():if vote > max_vote:max_vote = votenew_label = labelelif vote == max_vote:  # deterministic rule to disentangle equality votes (arbitrary)if label > new_label:new_label = labellabels[node] = new_label

為了區分兩個標簽具有相同投票數的情況，我們使用完全任意的規則來選擇具有最高值的標簽。

一旦所有標簽都更新了，我們可以通過檢查自上次迭代以來沒有標簽發生變化來檢查算法的收斂性：

        end = Truefor node in G:if old_labels[node] != labels[node]:# if at least one node's label has changed, go to next iterationend = Falsebreakif end:return labels

在本節開頭定義的圖 G 上運行此代碼，我們得到以下結果：

{'A'：3，'B'：3，'C'：3，'D'：6，'E'：6，'F'：6，'G'：6}

確定了兩個社區：第一個社區被標記3并包含節點A、B和C，而第二個社區被標記6并包含節點Dto?G。請記住，標簽本身是沒有意義的，因為它們只是來自圖形定義中的節點位置。不同的實現會為標簽返回不同的值，但會保留社區結構。

Label Propagation 不能保證收斂，我們最終可能會出現振蕩，其中給定節點的標簽不穩定并且在每次迭代時在兩個值之間振蕩，從而導致收斂失敗。

完整代碼可在 GitHub 上的https://github.com/PacktPublishing/Hands-On-Graph-Analytics-with-Neo4j/ch7/label_propagation/label_propagation.py 獲得。我們鼓勵您復制和修改它以幫助您了解它的工作原理。例如，更新代碼以考慮節點和關系權重。請注意，實現保持盡可能簡單，以允許您利用您對 Python 的先驗知識。例如，如果您已經了解networkx和numpy，您可以嘗試修改此代碼以使其適用于netwokx圖形或使用矩陣公式（參見前一章，第 6 章，節點重要性）。

使用 GDS 中的標簽傳播算法

標簽傳播算法是生產質量算法的一部分，這意味著它經過了很好的測試和針對大型圖的優化。我們將在我們在弱連接組件部分研究的圖上測試運行標簽傳播算法。創建它的 Cypher 代碼可在https://github.com/PacktPublishing/Hands-On-Graph-Analytics-with-Neo4j/ch7/test_graph.cql獲得。

讓我們創建一個無向投影圖：

CALL gds.graph.create("projected_graph", "Node", {LINKED_TO: {type: "LINKED_TO", orientation: "UNDIRECTED"}}
)

要在該圖上執行標簽傳播算法，我們可以使用以下查詢：

CALL gds.labelPropagation.stream("projected_graph")
YIELD nodeId, communityId
RETURN gds.util.asNode(nodeId).name AS nodeName, communityId
ORDER BY communityId

結果如下：

╒══════════╤═════════════╕
│"nodeName"│"communityId"│
╞══════════╪═════════════╡
│"A"       │39           │
├──────────┼─────────────┤
│"B"       │39           │
├──────────┼─────────────┤
│"C"       │39           │
├──────────┼─────────────┤
│"D"       │42           │
├──────────┼─────────────┤
│"E"       │42           │
├──────────┼─────────────┤
│"F"       │42           │
├──────────┼─────────────┤
│"G"       │42           │
├──────────┼─────────────┤
│"Y"       │46           │
├──────────┼─────────────┤
│"Z"       │46           │
└──────────┴─────────────┘

已經確定了三個社區：兩個類似于我們在上一節中確定的社區，加上一個包含節點Y和的額外社區Z，這些社區沒有包含在我們之前的研究中。

同樣， 的確切值communityId可能會有所不同；它與nodeId財產有關。但是同一社區中的所有節點將始終具有相同的communityId.

使用種子

為了測試我們的算法，我們首先需要向圖中添加一個新屬性，該屬性將保持我們對節點社區成員身份的先驗信念——?knownCommunity：

MATCH (A:Node {name: "A"}) SET A.knownCommunity = 0;
MATCH (B:Node {name: "B"}) SET B.knownCommunity = 0;
MATCH (F:Node {name: "F"}) SET F.knownCommunity = 1;
MATCH (G:Node {name: "G"}) SET G.knownCommunity = 1;

對于某些節點，我們添加了一個名為 的屬性knownCommunity，它存儲了我們關于每個節點所屬社區的先驗知識（或信念）。

然后，我們可以創建命名的投影圖。該圖將包含帶有Node標簽的所有節點以及帶有類型的所有關系LINKED_TO。為了以半監督的方式使用該算法，我們還需要明確告訴 GDS 將knownCommunity節點屬性存儲在投影圖中。最后，我們會將我們的圖視為無向圖，這是通過orientation: "UNDIRECTED"在關系投影中指定參數來實現的：

CALL gds.graph.create("projected_graph_with_properties", { // node projection:Node: {label: "Node",properties: "knownCommunity"}}, { // relationship projection:LINKED_TO: {type: "LINKED_TO",orientation: "UNDIRECTED"}
})

現在我們可以在這個命名的投影圖上運行標簽傳播算法，并使用以下內容流式傳輸結果：

CALL gds.labelPropagation.stream("projected_graph_with_properties", {seedProperty: "knownCommunity"
})
YIELD nodeId, communityId
RETURN gds.util.asNode(nodeId).name AS nodeName, communityId
ORDER BY communityId

您可以從結果中看到已識別的社區相似，但是communityId現在反映了通過 給出的值seedProperty。

將結果寫入圖表

要使用我們在上一節中編寫的代碼在瀏覽器中可視化結果，我們需要將結果存儲在圖形中，這可以通過以下gds.labelPropagation.write過程來實現：

CALL gds.labelPropagation.write("projected_graph_with_properties", {seedProperty: "knownCommunity",writeProperty: "lp"}
)

諸如標簽傳播之類的算法是一個很好的例子，說明圖算法已經被用于更經典的機器學習模型中。事實上，標簽傳播用于機器學習中的分類和回歸，其中傳播是通過相似矩陣（而不是前一章討論的鄰接矩陣）執行的。

現在，我們將關注另一個重要的社區檢測算法：Louvain 算法。

了解Louvain算法

魯汶算法是由比利時魯汶大學的研究人員于 2008 年提出的，該算法因此得名。它依賴于與其他節點的連接相比，社區內連接密度的度量。這個度量被稱為模塊化，它是我們首先要理解的變量。

定義模塊化

與不同社區中節點之間的鏈接相比，模塊化是量化同一社區中節點內鏈接密度的度量。

從數學上講，它的定義如下：

Q = 1/(2m) * Σ?ij?[ A?ij?- k?i?k?j?/ (2m)] δ(c?i?, c?j?)

在哪里：

• 如果節點i和j連接，則A?ij為 1，否則為 0。
• k?i是節點i的度數。
• m是邊緣攜帶的所有權重的總和。我們也有關系Σ?i?k?i?= 2m，因為所有節點的總和將對每條邊計算兩次。
• c?i是算法分配給節點i的社區。
• δ(x, y)是 Kronecker delta 函數，如果x=y則等于 1?，否則等于 0。

為了理解這個等式的含義，讓我們分別關注每個術語。具有k?i個邊的節點i有k?i個機會連接到圖中的任何其他節點。所以兩個節點i和j有k?i?xk?j機會相互連接。因此，術語k?i?k?j?/ (2m)對應于節點i和j相互連接的概率。

在等式的另一邊，A?ij是i和j之間的真實連接狀態。因此，sigma 符號下的項量化了同一社區（在隨機圖中）的兩個節點之間的實際邊數和預期邊數之間的差異。

同一個社區中的兩個節點應該比平均值更頻繁地連接，因此A?ij?> k?i?k?j?/ (2m)。Louvain 算法就是基于這個性質，并試圖最大化模塊化Q。

這種模塊化的定義也適用于加權圖。在這種情況下，A?ij是i和j之間關系的權重。

在繼續討論算法本身之前，讓我們研究一下特殊的圖分區以及模塊化對它們的價值。可以使用https://github.com/PacktPublishing/Hands-On-Graph-Analytics-with-Neo4j/ch7/louvain/modularity.py上的簡單 Python 實現來挑戰結果。

在本節的其余部分，為了簡單起見，我們將使用與前一節類似的圖表，不包括節點Y和Z，以便處理單個組件。

所有節點都在自己的社區中

如果所有節點都在自己的社區中，則δ(c?i?, c?j?)始終為 0，因為c?i始終不同于c?j，除非i=j的情況。由于我們的圖沒有自環（連接到自身的節點），因此 A?ii始終等于 0，并且僅保留和中的負項。所以在那種特殊情況下，模塊化Q是負的。在下文中，我們將其寫為Q?diag，它在我們的圖表中的值為Q?diag?=-0.148。

所有節點都在同一個社區

在另一個極端情況下，所有節點都在同一個社區中，δ(c?i?, c?j?)始終為 1。因此模塊化如下：

Q = 1/(2m) * Σ?ij?[ A?ij?- k?i?k?j?/ (2m)]

Aij項的所有節點對的總和對應于所有邊的權重總和，計算兩次（對于ij和ji對）。所以，我們有以下內容：

Σ?ij?A?ij?= 2m

讓我們重寫方程的第二項：

Σ?ij?k?i?k?j?/ (2m) = Σ?i?(k?i?(Σ?j?k?j?)) / 2m = Σ?i?(k?i?(2m) / 2m = Σ?i?k?i?= 2m

因此，在所有節點都在同一個社區中的特殊情況下，模塊化Q=0。

最優分區

我們在本節中使用的簡單圖的最佳分區類似于使用連接組件或標簽傳播算法獲得的分區：節點A、B和C在它們自己的分區中，而節點D到G在另一個社區中。

當 m = 9 時，這種情況下的模塊性如下：

Q = 1/18 (
2 * (AAB?- kAkB?/ 18 + AAC?- kAkC?/ 18 + ABC?- kBkC?/ 18)
+ 2 * (ADE?- kDkE?/ 18 + ADG?- kDkG?/ 18 + ADF?- kDkF?/ 18 + AEF?- kEkF?/ 18 + AEG?- kEkG?/ 18 + AGF?- kGkF?/ 18 )
) + Qdiag
= 1 / 18 * 2 * (
1 - 2 * 2 / 18 + 1 - 2 * 3 / 18 + 1 - 2 * 3 / 18
+ 1 - 3 * 3 / 18 + 1 - 3 * 3 / 18 + 0 - 3 * 2 / 18 + 1 - 3 * 2 / 18 + 1 - 3 * 3 / 18 + 1 - 3 * 2 / 18
) - 0.148
= 0.364 > 0

由于我們的圖是無向的，我們可以將對應于 A 和 B ( ) 之間關系的項加倍A - B，而不是將項A -> B?和相加B -> A。

模塊化也可以用來衡量另一種算法檢測到的分區的質量。

現在我們對模塊化有了更好的理解，在展示 Neo4j 和 GDS 的一些示例之前，我們將看看如何重現 Louvain 算法。

重現 Louvain 算法的步驟

Louvain 算法旨在最大化模塊化，作為損失函數。從每個節點分配到自己的社區（Q=0）的圖開始，算法將嘗試將節點移動到其鄰居的社區，并且僅當它使模塊化增加時才保持此配置。

該算法在每次迭代中執行兩個步驟。在第一個過程中，對所有節點執行迭代。對于每個節點n及其每個鄰居k，該算法嘗試將節點n移動到與k相同的社區。節點n被移動到導致模塊化程度最高的社區。如果無法通過這樣的操作增加模塊性，則節點n的社區在此迭代中保持不變。

在第二步中，算法將屬于同一社區的節點組合在一起以創建新節點，并將社區間邊的權重相加以在它們之間創建新的加權邊。

通過將單個節點從一個社區移動到另一個社區所引起的模塊性變化可以計算而無需再次循環整個圖。

GDS 中的 Louvain 算法

從 1.0 版開始，Louvain 算法是 Graph Data Science 庫中生產質量實施的一部分。

句法

Louvian 算法的用法與其他算法類似。要流式傳輸結果，請使用gds.louvain.stream帶有命名投影圖作為參數的過程：

CALL gds.louvain.stream(<projectedGraphName>)

我們還可以使用等效的過程將結果保存在圖中write：

CALL gds.louvain.write(<projectedGraphName>, {writeProperty: <newNodeProperty>})

在我們的圖上使用 Louvain 算法會導致兩個常見的分區，一側是節點A、B和C?，另一側是節點D到G。要查看這些算法之間的差異，我們將不得不轉向稍大的圖表。我們將在后面的章節中看到 Zachary 的空手道俱樂部的例子。

關系投影中的聚合方法

如果您改用該write過程，您會注意到它返回的信息包括最終的模塊化。如果您在我們之前創建的投影圖上運行此過程projected_graph，您會注意到與我們在上一節中獲得的模塊化值略有不同。解釋來自我們的投影圖。D存儲在 Neo4j 中的初始圖包含and之間的兩個關系E（一個 from?DtoE和一個 from?Eto?D）。當 GDS 創建投影圖時，默認行為是存儲這兩種關系，這相當于增加了這條邊的權重（A?ij項）。因此，我們的投影圖等價于以下內容：

    G = { 'A'：{'B'：1，'C'：1}，'B'：{'A'：1，'C'：1}，'C'：{'A'：1， 'B': 1, 'D': 1}, 'D': {'C': 1, 'E': 2, 'G': 1}, 'E': {'D': 2, 'F '：1，'G'：1}，'F'：{'E'：1，'G'：1}，'G'：{'D'：1，'E'：1，'F'： 1}, }

D和之間的邊E的權重為 2 而不是 1。

如果我們希望投影圖只包含兩個節點之間的一個關系，我們必須向關系投影添加另一個屬性：aggregation: "SINGLE"，這將強制每對節點通過給定類型的一個關系連接。以下查詢將創建一個啟用該屬性的新投影圖：

CALL gds.graph.create("projected_graph_single", "Node",{LINKED_TO: {type: "LINKED_TO", orientation: "UNDIRECTED", aggregation: "SINGLE"}}
)

使用以下語句在這個新投影圖上運行 Louvain 算法：

CALL gds.louvain.write("projected_graph_single", {writeProperty: "louvain"})
YIELD nodePropertiesWritten, modularity
RETURN nodePropertiesWritten, modularity

您將再次找到相同的模塊化值，大約為 0.36，如以下屏幕截圖所示：

如果您查看gds.louvain程序的完整結果，您會發現另一個名為modularities.?它對應于在算法的每個階段計算的模塊化。

中間步驟

GDS 的一個有趣特性是它能夠在算法的中間步驟存儲社區。需要通過將配置參數設置為 來啟用此includeIntermediateCommunities選項true。例如，以下查詢將為我們的投影圖流式傳輸 Louvain 算法的結果，返回一個額外的列，其中包含每個節點在每次迭代時分配到的社區列表：

CALL gds.louvain.stream("projected_graph_single",{includeIntermediateCommunities: true}
)
YIELD nodeId, communityId, intermediateCommunityIds
RETURN gds.util.asNode(nodeId).name as name, communityId, intermediateCommunityIds
ORDER BY name

在我們的簡單圖表中，該intermediateCommunityIds列包含一個列表，其中包含一個與最終社區相對應的元素。這意味著一次迭代就足以收斂，鑒于圖的尺寸非常小，這并不奇怪。在較大的圖上使用此算法時，您將能夠在每個步驟中看到圖的狀態。

如果intermediateCommuntiyIds與 write 過程一起使用，書面屬性將包含與中間社區 ID 對應的 ID 列表，而不是僅對最終社區進行編碼的單個整數。

Zachary 的空手道俱樂部圖上的 Label Propagation 和 Louvain 之間的比較

到目前為止，使用我們使用的小型測試圖，標簽傳播和 Louvain 算法產生相同的社區，但一般情況并非如此。Zachary 的空手道俱樂部圖是一個稍大的圖，也是圖專家中最著名的圖之一。它由芝加哥大學的教師韋恩·W·扎卡里 (Wayne W. Zachary) 收集。他觀察了 1970 年代這所大學空手道俱樂部成員之間的不同聯系。

下圖顯示了該圖上標簽傳播（左）和 Louvain 算法（右）的結果，包含 34 個節點（學生）。雖然標簽傳播僅捕獲兩個社區，但 Louvain 算法能夠檢測到四個集群：

讓我給你更多的背景來更好地理解這個結果。1970年左右，在芝加哥大學的空手道俱樂部，兩名教練之間開始發生沖突，導致俱樂部分裂為兩個實體。當時，雙方都在努力吸引學生，每個導師和學生之間的互動很重要。Zachary 用圖表對這些交互進行了建模，其中每個節點都是學生，它們之間的邊表示他們在此期間是否進行了交互。所以這張圖有一個很大的優勢，就是擁有真實信息：扎卡里記錄了每個成員在分裂后選擇去俱樂部的哪個部分。

回到兩種算法檢測到的社區劃分，Label Propagation 做對了，檢測到兩個與真實學生劃分一致的社區。查看 Louvain 算法的結果，似乎又檢測到了一個分區。但是，如果我們合并包含節點 17 的分區（頂部）和包含節點 2 的分區（中間），那么結果非常相似。唯一的區別是節點 10 將位于頂部社區，而在標簽傳播中，它位于底部社區。

像一些著名的數據科學數據集一樣scikit-learn，Zachary 的空手道俱樂部包含在主要的 Python 包中，用于處理圖形networkx： import?networkx?as?nx?G?=?nx.karate_club_graph()

我們現在對模塊化和 Louvain 算法有了很多了解。在下一節中，我們將了解該算法的一些限制，以及已經提出的一些改進它的替代方案，即使它們（尚未）在 GDS 中實現。

超越 Louvain的重疊社區檢測

與所有算法一樣，Louvain 算法也有其局限性。了解它們非常重要，因此我們將在本節中嘗試這樣做。我們還將處理可能的替代方案。最后，我們還將討論一些允許節點屬于多個社區的算法。

Louvain算法的注意事項

與任何其他算法一樣，Louvain 算法也有一些已知的缺點。主要的一個是分辨率限制。

分辨率限制

考慮下圖，由每個具有七個節點的強連接 blob 組成，通過一條邊彼此弱連接：

在此圖上運行社區檢測，您會期望每個 blob 形成一個社區。雖然這對于小圖上的 Louvain 算法效果很好，但眾所周知，它在大圖上會失敗。例如，當在一個結構類似于上圖所示但有 100 個 blob 的圖上運行時，Louvain 算法將僅識別 50 個社區。這個問題被稱為分辨率限制問題：對于具有固定大小（節點數）和密度的邊的圖，Louvain 算法檢測到的社區不能大于（或小于）給定節點數。這意味著該算法將無法在大型網絡中發現小型社區（100 個 blob 的情況）。它也將無法檢測小型網絡中的大型社區。最后一個例子的一個特殊情況是小型網絡中的無社區情況。

您可以嘗試通過檢查可以由 Louvain 算法的 GDS 實現返回的中間步驟來識別大型網絡問題，如上一節所述。

另一個限制是模塊化是一個全局度量的事實。因此，圖表某一部分的更新可能會產生遠離它的后果。例如，如果您在上圖中的環中反復添加 blob，則在某些時候，社區會突然變得非常不同，即使圖的只有一小部分發生了變化。

Louvain的替代品

已經提出了 Louvain 算法的許多替代方案。其中包括：

• 涉及分辨率參數γ的算法，以解決 Louvain 算法的分辨率限制。
• Leiden 算法是 Louvain 算法的變體，它還能夠拆分集群，而不僅僅是合并它們。通過這樣做，Leiden 算法能夠保證社區將連接良好，而 Louvain 算法則不是這種情況（請參閱進一步閱讀部分以獲取更深入該主題的資源鏈接）。

在上一節列出的案例中，這些算法已被證明比 Louvain 表現更好。但是，到目前為止，還沒有解決的算法涵蓋了其他兩種情況：

• 重疊社區：給定節點可以屬于多個社區的情況
• 動態網絡：當網絡隨時間演變時社區如何變化（新邊和/或新節點）

這兩個主題將在接下來的兩個小節中分別介紹。

重疊社區檢測

到目前為止，我們研究的所有算法都有一個共同點：每個節點都分配給一個且只有一個社區。但這并不總是代表現實：朋友也可以是同事，同事也可以是家人。能夠檢測到屬于多個社區的節點還可以提供有關圖結構和社區邊界的有趣信息，如下圖所示。

重疊社區檢測最著名的算法之一是Clique Percolation Method?(?CPM?)。圖論中的派系是節點的子集，其中每個節點都連接到所有其他節點。k-clique是包含k個節點的clique。最簡單的 clique 示例是3-clique，它是由三個完全連接的節點組成的三角形。CPM 算法基于相鄰的k-clique定義社區，其中如果兩個k?-clique共享k-1個節點，則認為它們是相鄰的，這使得第k個節點可以分配給多個社區。

動態網絡

動態網絡是隨時間演化的圖，其中可以添加、修改甚至刪除節點和邊。社區檢測問題變得更加復雜，因為社區可以執行以下操作：

• 出現
• 生長
• 被減少
• 與另一個社區融合
• 分裂
• 消失

一個社區也可以保持不變，甚至暫時消失，只在稍后的某個時間再次出現。解決此類問題的一種技術包括在不同時間使用圖形的快照。然后可以在每個快照上使用諸如本書中研究的靜態算法。然而，當比較在兩個連續快照中發現的社區時，將很難確定差異是由于真實的社區進化還是算法的不穩定性（想想 Louvain 算法的分辨率限制）。已經提出了許多解決方案來通過使用平滑技術來解決這個問題。例如，您可以構建一個算法，要求時間 t 的社區與時間t的社區在某種程度上相似t-1。有關此主題的更多詳細信息，請參閱參考資料（請參閱進一步閱讀部分）。

我們現在已經介紹了社區檢測算法，了解它們是如何工作的，何時使用它們，以及如何在 Neo4j 中的 GDS 中使用它們。我們甚至超越了 GDS 并描述了一些用于重疊社區檢測的技術。社區是將具有相似性的節點組合在一起：與圖的其余部分（Louvain）相比，相似的鄰域（標簽傳播）和相似的邊密度。如果要量化兩個節點之間的相似性，可以從檢查它們是否屬于同一個社區開始。但是存在更精確的指標，我們將在下一節中介紹。

測量節點之間的相似性

有幾種技術用于量化節點之間的相似性。它們可以分為兩類：

• 基于集合的度量：在全局范圍內比較兩個集合的內容。例如，集合 (?A?,?B?,?C?) 和 (?C?,?D?,?B?) 有兩個共同的元素。
• 基于向量的度量：逐元素比較向量，這意味著每個元素的位置很重要。歐幾里得距離是此類度量的一個示例。

讓我們從基于集合的相似性開始更詳細地了解這些指標。

基于集合的相似性

GDS 1.0 實現了我們將在此處介紹的基于集合的相似性的兩種變體。

重疊

重疊相似度是衡量兩個集合之間共同元素的數量，相對于最小集合的大小。

定義

該度量的數學定義如下：

O(A, B) = |?A ∩ B |?/ 分鐘(|A|, |B|)

A ∩ B是集合 A 和 B（公共元素）和|A|之間的交集?表示集合 A 的大小。

GDS 在其 alpha 層中包含一個功能，可以讓我們測試和理解這種相似性度量。我們通過以下方式使用它：

RETURN gds.alpha.similarity.overlap(<set1>, <set2>) AS similarity

以下語句返回O([1, 2, 3], [1, 2, 3, 4]) 的結果：

RETURN gds.alpha.similarity.overlap([1,2,3], [1,2,3,4]) AS similarity

集合 [1, 2, 3] 和 [1, 2, 3, 4] 之間的交集包含兩個集合中的元素：1、2 和 3。它包含三個元素，因此它的大小為|?A ∩ B |?= 3。在分母上，我們需要找到最小集合的大小。在我們的例子中，最小的集合是 [?1?,?2?,?3?] 包含三個元素。所以重疊相似度的期望值為 1，也就是 GDS 函數返回的值。下表包含更多示例：

A	B	A ∩ B	|A∩B|	min(|A|, |B|)	O(A, B)
[1, 2, 3]	[1, 2, 3, 4]	[1, 2, 3]	3	3	1
[1, 2, 3]	[1, 2, 4]	[1, 2]	2	3	2/3≈0.67
[1, 2]	[3, 4]	[]	0	2	0

注意重疊相似度是對稱的；交換A和B不會改變結果。

在 GitHub 圖中量化用戶相似度

我們將使用 Neo4j 社區 GitHub 圖，其中包含以登錄為特征的 GitHub 用戶、Neo4j 擁有的存儲庫以及CONTRIBUTED_TO用戶與他們貢獻的存儲庫之間的類型關系。如果你還沒有從本書的前面部分構建圖表，數據和加載說明可以在本書的 GitHub 存儲庫中找到。

使用相似度算法的第一步是建立一組與每個用戶相關的數據：

MATCH (user:User)-[:CONTRIBUTED_TO]->(repo:Repository)
WITH {item: user.login, categories: collect(repo.name)} as userData
RETURN userData

userData對于具有 login 的給定用戶，包含以下內容j：

{"item": "j","categories": ["cypher-shell","neo4j-ogm","docker-neo4j","doctools"]
}

在這種情況下，計算兩個用戶之間的相似性意味著比較他們貢獻的存儲庫（存儲在categories密鑰中）。為了能夠被 GDS 使用，我們只需要將我們的用戶登錄名和存儲庫名稱替換為 Neo4j 內部 ID：

MATCH (user:User)-[:CONTRIBUTED_TO]->(repo:Repository)
WITH {item: id(user), categories: collect(id(repo))} as userData
RETURN userData

userData然后可以用于饋送gds.alpha.overlap.stream過程：

MATCH (user:User)-[:CONTRIBUTED_TO]->(repo:Repository)
WITH {item:id(user), categories: collect(id(repo))} as userData
WITH collect(userData) as data
CALL gds.alpha.similarity.overlap.stream({nodeProjection: '*', relationshipProjection: 'CONTRIBUTED_TO', data: data}
)
YIELD item1, item2, count1, count2, intersection, similarity
RETURN *

該過程返回相似性，但也返回中間結果，例如兩個類別集中的項目數和交集的大小。

item1并且item2是節點 ID。要檢索節點對象，您可以使用該gds.util.asNode函數。例如，要獲取與 對應的用戶登錄item1，您可以編寫gds.util.asNode(item1).login.

以下是從我們的結果中選擇的一些行：

╒════════════════════╤═════════════════╤════════╤════════╤══════════════╤══════════════════╕
│"user1"             │"user2"          │"count1"│"count2"│"intersection"│"similarity"      │
╞════════════════════╪═════════════════╪════════╪════════╪══════════════╪══════════════════╡
│"systay"            │"nawroth"        │4       │13      │4             │1.0               │
├────────────────────┼─────────────────┼────────┼────────┼──────────────┼──────────────────┤
│"chrisvest"         │"systay"         │3       │4       │3             │1.0               │
└────────────────────┴─────────────────┴────────┴────────┴──────────────┴──────────────────┘

如您所見，即使對于相似度等于 1 的節點對。交集的大小之間存在很大差異：我們可能期望systay比 更相似，因為貢獻了chrisvest比多九個存儲庫，而差異存儲庫的數量只是 和 之間的一個。這可以通過我們將在下一段中看到的 Jaccard 相似性來解決。nawrothnavrothsystaysystaychrisvest

杰卡德相似度

Jaccard 相似度定義類似于重疊相似度，只是分母包含集合A和B的并集的大小：

J(A, B) = |?A ∩ B |?/ |A ∪ B|

在分母中使用兩個集合的并集對于識別用戶將貢獻給單個存儲庫的情況非常有用，其中有許多不同的貢獻者。通過重疊相似度，該用戶與所有其他貢獻者的相似度為 1。使用 Jaccard 公式，相似度將取決于每個其他用戶貢獻的存儲庫數量，并且僅對于也為該單個存儲庫做出貢獻的貢獻者才等于 1。

在這個投影圖上運行 Jaccard 相似度算法就像這樣簡單：

MATCH (u:User)
MATCH (v:User)
RETURN u, v, gds.alpha.similarity.jaccard(u, v) as score

您可以systay在此圖中檢查 和其他用戶之間的相似度，并注意到，現在，與 的相似度chrisvest遠高于與的相似度navroth。

這些相似性是基于節點所連接的元素之間的比較。在下一節中，我們將了解如何在 GDS 中使用基于向量的相似度度量，例如歐幾里得距離或余弦相似度。即使它們不是特定于圖表的，它們在數據分析方面也提供了有用的信息。

基于向量的相似性

基于向量的相似性類似于經典機器學習管道中遇到的相似性。他們比較兩個包含有序數字列表的向量。

歐幾里得距離

歐幾里得距離是兩點之間距離的度量。它是笛卡爾平面中距離度量的擴展，使用以下公式計算：

d(u, v) = √( (u?1?- v?1?)?2?+ (u?2?- v?2?)?2?+ ... + (u?n?- v?n?)?2?)

我們可以嘗試量化他們的貢獻向量之間的距離，而不是簡單地計算每對用戶共有的存儲庫數量。讓我們通過一個例子更清楚地說明。我們將為某些關系添加一個新屬性，以計算用戶對給定存儲庫的貢獻頻率：

MATCH (u1:User {login: "systay"})-[ct1]->(repo)
SET ct1.nContributions = round(rand() * 10)

為簡單起見，我在這里使用隨機數，但這意味著您的結果可能會有所不同。如果我們為另一個用戶做同樣的事情，例如，chrisvest，我們可以創建每個用戶對每個存儲庫的貢獻向量：

MATCH (u1:User {login: 'chrisvest'})-[ct1]->(repo)
MATCH (u2:User {login: 'systay'})-[ct2]->(repo)
WITH collect(ct1.nContributions) as contrib1, collect(ct2.nContributions) as contrib2
RETURN contrib1, contrib2

該collect語句為每個用戶創建了兩個列表，其中包含該用戶對每個存儲庫的貢獻。要計算這兩個向量之間的歐幾里得距離，我們只需要調用gds.alpha.similarity.euclideanDistance函數：

MATCH (u1:User {login: 'chrisvest'})-[ct1]->(repo)
MATCH (u2:User {login: 'systay'})-[ct2]->(repo)
WITH collect(ct1.nContributions) as contrib1, collect(ct2.nContributions) as contrib2
RETURN gds.alpha.similarity.euclideanDistance(contrib1, contrib2) AS similarity

在我的情況下，這導致相似度接近 38。

與重疊相似度類似，GDS 還包含在投影圖上運行并計算所有節點對之間的相似度的過程。

請記住，您可以通過以下內容找到您的 GDS 版本中可用的功能和過程的全名和簽名：

CALL gds.list() YIELD name, signature
WHERE name =~ '.*euclidean.*'
RETURN *

余弦相似度

余弦相似度是眾所周知的，尤其是在 NLP 社區中，因為它被廣泛用于衡量兩個文本之間的相似度。余弦相似度不是像歐幾里得相似度那樣計算兩點之間的距離，而是基于兩個向量之間的角度。考慮以下場景：

????????????????????????????????

?向量 A 和 C 之間的歐幾里得距離為d?AC，而θ?AC表示余弦相似度。

同理， A和B的歐式距離用d?AB線表示，但它們之間的夾角為 0，由于cos(0)=1，A和B的余弦相似度為 1——遠高于余弦相似度在A和C之間。

要在 GitHub 貢獻者的上下文中替換此示例，我們可以使用以下內容：

• A對兩個存儲庫R1和R2有貢獻，對R1（x軸）有 5個貢獻，對R2（y軸）有 10 個貢獻。
• B對相同存儲庫的貢獻是：對R1的 1 個貢獻和對R2的 2 個貢獻，因此向量是對齊的。
• C對R1的貢獻更多，比如 8，但對R2的貢獻更少（比如 8）。

僅從貢獻總數來看，用戶A和C比A和B更相似。然而，用戶A和B的貢獻分布更相似：他們每個人對R1的貢獻是對R2的兩倍。最后一個事實以余弦相似度編碼，A和B之間的余弦相似度高于A和C之間的余弦相似度（見下表）。

GDS 的余弦相似度用法與歐幾里得距離相同，使用以下名稱：

• 一個函數，gds.alpha.similarity.cosine
• 兩個程序，gds.alpha.similarity.cosine.stream和gds.alpha.similarity.cosine.write

下表顯示了用戶A、B和C之間的歐幾里得和余弦相似度與前面給出的值的比較：

	歐幾里得	余弦
A/B	RETURN gds.alpha.similarity.euclidean([5, 10], [1, 2]) ~ 0.10	RETURN gds.alpha.similarity.cosine([5, 10], [1, 2]) 1.0
A/C	RETURN gds.alpha.similarity.euclidean([5, 10], [8, 8]) ~ 0.22	RETURN gds.alpha.similarity.cosine([5, 10], [8, 8]) ~ 0.95

這是我們專門討論節點相似性的部分的結尾。我們將在接下來的章節中回到它，屆時我們將使用我們在本章中發現的一些指標以及前面的指標作為機器學習模型中的特征。

概括

在本章中，我們討論了很多測量節點之間相似度的方法，無論是在全球范圍內通過將節點分組為社區還是使用更局部的相似度評估，例如使用 Jaccard 相似度度量。研究了幾種算法——弱連接和強連接組件、標簽傳播算法和魯汶算法。我們還使用了 GDS 提供的一項功能，該功能允許我們將算法的結果寫入 Neo4j 以供將來使用。我們還使用了兩個新工具來可視化圖形以及在 GDS 中實現的圖形算法的結果：neovis.js用于將 Neo4j 圖形可視化嵌入到 HTML 頁面中，以及 NEuler，它是圖形算法游樂場，您可以從中使用無需編寫代碼即可運行圖算法。

我們對 GDS (1.0) 中實現的算法的探索現已完成。在接下來的章節中，我們將學習如何在機器學習管道中使用圖和這些算法來進行預測。首先，在下一章中，我們將構建一個機器學習管道并引入一個基于圖形的特性來提高性能。

問題

• 連接組件：
• 如果您在無向投影圖上運行強連通分量算法，您認為會發生什么？
• 如果我們添加從 D 到 C 的關系，測試圖的社區結構將如何變化？或者如果我們刪除從 D 到 E 的關系？
• 標簽傳播：
• 更新我們的算法實現以考慮種子，即關于節點社區的先驗知識。

進一步閱讀

• 社區檢測技術在腦圖上的應用：算法考慮和對神經功能的影響，?JO Garcia 等人。,?IEEE doi 論文集：10.1109/JPROC.2017.278671
• 一種分析復雜組織結構的方法，RS Weiss和E. Jacobson，美國社會學評論，卷。20，第 6 期，1955 年，第 661-668 頁。doi:10.2307/2088670
• Louvain算法：原論文：
  https ://arxiv.org/abs/0803.0476
• 動態網絡中的社區檢測，一項調查，G. Rossetti和R. Cazabet，ACM 期刊（全文可在Community Discovery in Dynamic Networks: a Survey - Archive ouverte HAL獲得）

總結

以上是生活随笔為你收集整理的【Neo4j】第 7 章：社区检测和相似性措施的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。