進階網路分析：殼層佈局優化與虛擬模型應用

在複雜網路分析中，標準視覺化佈局難以同時呈現節點中心性、社群歸屬與連結強度等多重資訊。本文旨在探討超越基礎佈局的進階策略，從結構化的「殼層佈局」出發，展示如何結合節點度數與社群資訊，創造具解釋力的視覺階層。接著，我們轉向動態的「力導向佈局」，解析其如何模擬物理系統以呈現社群聚集，並探討其「毛球效應」限制。最後，文章引入「虛擬模型」作為分析濾鏡，說明如何量化邊權重的期望與實際差異，以識別統計上顯著的連結，將視覺化從單純呈現提升至結構洞察的層次。

網路視覺化進階：殼層佈局的優化與力導向佈局的應用

本章節將深入探討如何進一步優化殼層佈局，使其更能反映網路結構的中心性與社群特徵。我們將解析程式碼中如何結合節點度數和社群資訊來構建精確的殼層分佈，並繪製出視覺效果更佳的圖表。隨後，我們將介紹「力導向佈局」(Force-directed Layout) 的原理、優點與潛在的「毛球效應」問題，並以 Frankenstein 詞語共現網路為例，預告下一節將探討如何透過「虛擬模型」(Null Models) 來調整邊權重，以識別網路中特別重要的連結。

優化殼層佈局：結合度數與社群的節點分層

程式碼解析 (shell_labels 構建部分)：
- 節點度數排序：labels = sorted(degrees.keys(), key=lambda x: degrees[x], reverse=True)：此步驟已在先前介紹，用於獲取按度數降序排列的節點列表。
- 迭代構建殼層：
  - i, k = 0, 6：i 是當前節點在 labels 列表中的起始索引，k 是第一個殼層的節點數量（初始為 6）。
  - while i < len(labels):：迴圈執行，直到所有節點都被分配到殼層。
  - shell_labels = labels[i:i+k]：提取當前殼層的節點（基於度數排序）。
  - 社群導向的殼層內排序：
    - ordered_labels = sorted(shell_labels, key=lambda x: node_community[x])：這是關鍵的優化步驟。在選定了當前殼層的節點後，不是直接將它們按度數順序放入，而是進一步根據這些節點所屬的「社群索引」 (node_community[x]) 來對它們進行排序。這意味著，即使在同一個殼層內，屬於同一社群的節點也會被盡可能地聚集在一起。
    - nlist.append(ordered_labels)：將排序後的節點列表作為一個新的殼層添加到 nlist 中。
  - 更新參數：
    - i += k：移動到下一個殼層的起始節點。
    - k += 12：殼層大小遞增。這是一個重要的策略，表示外層的殼層比內層的殼層容納更多的節點。這有助於在有限的空間內更好地佈局節點，並可能將度數較低的節點（通常是較外圍的）分佈在外層。
- 生成佈局：pos = nx.shell_layout(G, nlist=nlist)：使用構建好的、結合了度數排序和社群內排序的 nlist 來生成節點位置。
繪製與結果：
- cm = plt.get_cmap('cool')：選擇一個顏色映射（Coolwarm, cool 等），用於為節點賦色。
- nx.draw_networkx(G, pos, alpha=1, node_color=node_color, with_labels=True)：繪製網路。這裡的 node_color 參數（來自前文的 community_net 函數）確保了不同社群的節點有不同的顏色。
視覺化解讀：
- 中心節點：圖示顯示，度數最高的節點（如 John A. 和 Mr. Hi）位於「最內圈」(centermost circle)，這與我們預期的一致，因為它們被放置在度數排序的前面，並在殼層大小較小的內層。
- 外圍節點：度數最低的節點則分佈在「邊緣」(around the edge)，位於殼層大小較大的外層。
- 社群與殼層的結合：透過 ordered_labels 的排序，同一社群的節點在同一個殼層內會盡可能靠近，同時不同社群的節點會被分開，即使在同一殼層內，也能通過顏色和相對位置來區分。

力導向佈局 (Force-directed Layout)

基本原理：
- 力導向佈局將網路中的節點和邊模擬為一個物理系統。節點之間存在「排斥力」(repulsive forces)，而邊則產生「吸引力」(attractive forces)，類似於彈簧。
- 系統經過迭代計算，直到達到一個能量最低的穩定狀態，此時節點的位置就確定了。
優點：
- 適應大型網路：能夠處理相對較大的網路。
- 清晰傳達社群結構：是視覺化社群結構的「絕佳選擇」，因為相似的節點會被推到一起。
缺點與挑戰：
- 「毛球」傾向：力導向佈局也是「最容易產生毛球效應的方法之一」，特別是當網路中存在一個非常大的社群，將所有其他節點都「拉」到其周圍時。
- 最佳適用場景：在「稀疏網路」(sparser networks) 中，且存在「多個社群」(multiple communities) 時，效果最佳。
NetworkX 實現：
- NetworkX 提供了多種力導向佈局算法，例如 nx.spring_layout()（最常用，基於 Fruchterman-Reingold 算法）、nx.fruchterman_reingold_layout()、nx.kamada_kawai_layout() 等。
- 這些函數通常需要一些參數來調整力的強度、迭代次數等，以獲得最佳佈局。

Frankenstein 詞語共現網路與虛擬模型

案例回顧：
- 在「第三章：從數據到網路」中，我們曾展示過 Frankenstein 詞語共現網路的預設力導向佈局，當時認為其「資訊量不大」。
本節目標：
- 重新檢視這個網路。
- 展示如何透過「虛擬模型」(Null Models) 來「聚焦於網路的不同方面」並「減少雜亂」。
虛擬模型 (Null Models)：
- 定義：虛擬模型是一組「假設」(assumptions)，用於預測邊的「強度」(strength) 或權重。
- 用途：透過比較實際邊的權重與虛擬模型預測的權重，可以識別出「超出預測的邊」，即那些比隨機情況下更顯著或更弱的連結。
- 與引力模型的關聯：前一章使用的「引力模型」就是一種虛擬模型。
- 本節將使用的簡單模型：假設邊的權重與「端點度數的乘積成正比」。這意味著，如果兩個節點的度數都很大，它們之間的連結預計會比較強。
- residual_net 函數：
  - 輸入：一個圖 G。
  - 輸出：一個新的圖 G_residual，其中每條邊都包含一個 log_residual 屬性。
  - log_residual 屬性：代表該邊的實際權重與其預測權重（基於端點度數乘積）之間的「偏差」(deviation)。這個值可以幫助我們識別出那些「意外地」強或弱的連結。
  - 計算步驟：
    1. 複製輸入圖 G。
    2. 計算所有節點的「加權度數」(weighted degrees)。
    3. 遍歷每條邊，計算其預測權重（基於端點度數乘積）。
    4. 計算實際權重與預測權重之間的殘差（通常是 log 殘差，以處理權重範圍較大的情況）。
    5. 將殘差值儲存為邊的屬性。

import networkx as nx
import matplotlib.pyplot as plt
import numpy as np
import community as nxcom
from pathlib import Path
import pandas as pd
import math

# --- 載入 Zachary 空手道俱樂部網路 
---
try:
    G_karate = nx.karate_club_graph()
    print(f"成功載入 Zachary 空手道俱樂部網路: {G_karate.number_of_nodes()} 個節點, {G_karate.number_of_edges()} 條邊。")
except Exception as e:
    print(f"載入 Zachary 空手道俱樂部網路時發生錯誤: {e}")
    G_karate = nx.Graph()

# --- 優化殼層佈局：結合度數與社群 
---
def draw_optimized_shell_layout(G, title="Optimized Shell Layout"):
    """
    繪製結合度數排序和社群資訊的殼層佈局。
    """
    if G.number_of_nodes() == 0:
        print("圖為空，無法繪製優化殼層佈局。")
        return

    # 1. 獲取節點度數並排序
    degrees = dict(G.degree())
    # 節點按度數降序排序
    labels_by_degree = sorted(degrees.keys(), key=lambda x: degrees[x], reverse=True)

    # 2. 獲取社群劃分
    try:
        communities = list(nxcom.greedy_modularity_communities(G))
        num_communities = len(communities)
        node_community_map = {}
        for i, community in enumerate(communities):
            for node in community:
                node_community_map[node] = i
    except Exception as e:
        print(f"計算社群時發生錯誤: {e}")
        communities = [[node] for node in G.nodes()]
        num_communities = len(communities)
        node_community_map = {node: i for i, node in enumerate(G.nodes())} # 每個節點一個社群

    # 3. 構建 nlist：結合度數排序和社群排序
    nlist = []
    i = 0 # 當前節點索引
    k = 6 # 起始殼層大小
    
    # 為了確保所有節點都被分配，我們需要一個包含所有節點的列表
    all_nodes_list = list(G.nodes())
    
    # 創建一個臨時列表，包含所有節點，並按度數排序
    nodes_for_layering = sorted(all_nodes_list, key=lambda x: degrees.get(x, 0), reverse=True)

    current_node_index = 0
    while current_node_index < len(nodes_for_layering):
        # 確定當前殼層的節點範圍
        shell_nodes_subset = nodes_for_layering[current_node_index : current_node_index + k]
        
        # 在這個子集內部，根據節點所屬的社群進行排序
        # 如果節點不在社群映射中（例如孤立節點），給予一個預設社群索引
        ordered_shell_nodes = sorted(shell_nodes_subset, key=lambda x: node_community_map.get(x, num_communities)) # 將孤立節點放在最後
        
        nlist.append(ordered_shell_nodes)
        
        # 更新索引和殼層大小
        current_node_index += k
        k += 12 # 增加下一個殼層的大小

    # 確保 nlist 中的節點總數等於圖中的節點數
    # 如果由於 k 的增加導致最後一個殼層節點數不足，或者有遺漏的節點
    # 需要額外處理，但對於大多數情況，上述邏輯應該涵蓋所有節點
    
    print(f"構建了 {len(nlist)} 個殼層。")

    # 4. 生成佈局
    try:
        pos = nx.shell_layout(G, nlist=nlist)
    except Exception as e:
        print(f"生成 shell_layout 時發生錯誤: {e}")
        print("退回到預設的 shell_layout。")
        pos = nx.shell_layout(G) # 退回到預設佈局

    # 5. 繪製
    plt.figure(figsize=(8, 8))
    
    # 使用社群顏色映射
    num_communities_actual = max(node_community_map.values()) + 1 if node_community_map else 1
    cmap = plt.get_cmap('viridis', num_communities_actual)
    node_colors = [cmap(node_community_map.get(node, num_communities_actual)) for node in G.nodes()] # 孤立節點用最後一種顏色

    nx.draw_networkx(
        G, 
        pos=pos, 
        with_labels=True, 
        node_size=300, 
        node_color=node_colors, # 使用社群顏色
        edge_color='gray', 
        alpha=0.7, 
        width=0.5
    )
    plt.title(title, fontsize=16)
    plt.axis('off')
    plt.show()

# 繪製優化後的殼層佈局
draw_optimized_shell_layout(G_karate, title="Zachary Karate Club: Optimized Shell Layout")

# --- 力導向佈局 (Force-directed Layout) 
---
print("\n--- 力導向佈局 (Force-directed Layout) 
---
")

# 載入 Frankenstein 詞語共現網路 (假設 G_frank 已載入)
# 為了演示，我們模擬一個簡單的 G_frank
G_frank = nx.Graph()
# 添加一些節點和邊，模擬詞語共現
words = ["frankenstein", "monster", "victor", "creator", "creature", "lab", "science", "life", "death", "family", "love", "hate", "fear"]
G_frank.add_nodes_from(words)
# 添加一些邊，模擬共現關係
edges = [
    ("frankenstein", "victor"), ("frankenstein", "monster"), ("frankenstein", "creator"),
    ("monster", "creature"), ("monster", "victor"), ("monster", "family"), ("monster", "hate"),
    ("victor", "creator"), ("victor", "lab"), ("victor", "science"), ("victor", "life"), ("victor", "death"),
    ("creature", "life"), ("creature", "death"), ("creature", "family"), ("creature", "fear"),
    ("lab", "science"), ("lab", "life"),
    ("science", "life"), ("science", "death"),
    ("life", "love"), ("life", "family"),
    ("death", "hate"), ("death", "fear"),
    ("love", "family"),
    ("hate", "fear")
]
G_frank.add_edges_from(edges)
print(f"模擬的 Frankenstein 網路: {G_frank.number_of_nodes()} 個節點, {G_frank.number_of_edges()} 條邊。")

def draw_force_directed_layout(G, title="Force-Directed Layout"):
    """
    繪製網路的力導向佈局。
    """
    if G.number_of_nodes() == 0:
        print("圖為空，無法繪製力導向佈局。")
        return

    plt.figure(figsize=(8, 8))
    # 使用 spring_layout 作為力導向佈局的代表
    # k 參數調整節點間的平均距離，iterations 調整迭代次數
    pos = nx.spring_layout(G, k=0.5, iterations=50, seed=42) # 使用 seed 以保證結果可重複
    
    # 為了更好地展示社群，可以嘗試根據社群進行著色
    try:
        communities = list(nxcom.greedy_modularity_communities(G))
        num_communities = len(communities)
        node_community_map = {}
        for i, community in enumerate(communities):
            for node in community:
                node_community_map[node] = i
        
        node_colors = [plt.cm.viridis(node_community_map.get(node, num_communities) % num_communities) for node in G.nodes()]
    except Exception:
        print("社群偵測失敗，使用預設顏色。")
        node_colors = 'skyblue' # 預設顏色

    nx.draw_networkx(
        G, 
        pos=pos, 
        with_labels=True, 
        node_size=500, 
        node_color=node_colors, 
        edge_color='gray', 
        alpha=0.7, 
        width=0.5
    )
    plt.title(title, fontsize=16)
    plt.axis('off')
    plt.show()

# 繪製力導向佈局
draw_force_directed_layout(G_frank, title="Frankenstein Word Co-occurrence: Force-Directed Layout")

# --- 虛擬模型 (Null Models) 
---
print("\n--- 虛擬模型 (Null Models) 
---
")

def residual_net(G):
    """
    計算邊的 log_residual 屬性，基於邊權重與端點度數乘積的預測。
    假設圖 G 中的邊權重是 'weight' 屬性。
    """
    G_residual = nx.Graph(G) # 複製圖
    
    # 計算節點的加權度數 (如果邊有權重)
    # 如果沒有權重屬性，則視為度數
    weighted_degrees = {}
    for node in G_residual.nodes():
        degree = 0
        for neighbor in G_residual.neighbors(node):
            # 假設邊權重為 'weight'，如果不存在則為 1
            edge_data = G_residual.get_edge_data(node, neighbor)
            # MultiGraph 可能有多條邊，取所有邊權重之和，或根據需求處理
            if edge_data:
                if isinstance(edge_data, dict): # 單一邊
                    degree += edge_data.get('weight', 1)
                elif isinstance(edge_data, list): # MultiGraph
                    degree += sum(data.get('weight', 1) for data in edge_data)
        weighted_degrees[node] = degree
        
    # 為每條邊計算 log_residual 屬性
    for u, v, data in G_residual.edges(data=True):
        # 獲取邊的實際權重
        actual_weight = data.get('weight', 1)
        
        # 獲取端點的加權度數
        degree_u = weighted_degrees.get(u, 0)
        degree_v = weighted_degrees.get(v, 0)
        
        # 預測權重：度數乘積
        predicted_weight = degree_u * degree_v
        
        # 計算 log residual
        # 避免除以零或 log(0)
        if predicted_weight > 0 and actual_weight > 0:
            log_residual = math.log(actual_weight / predicted_weight)
        elif predicted_weight == 0 and actual_weight > 0:
            log_residual = float('inf') # 預測為0但實際大於0，殘差無限大
        elif predicted_weight > 0 and actual_weight == 0:
            log_residual = float('-inf') # 預測大於0但實際為0，殘差無限小
        else:
            log_residual = 0 # 兩者皆為0或負數（不應發生）
            
        G_residual[u][v][0]['log_residual'] = log_residual # 在 MultiGraph 中，假設只有一條邊或取第一條邊
        
    return G_residual

# 為了演示 residual_net，我們需要一個帶有權重的圖
# 模擬一個帶權重的 Frankenstein 網路
G_frank_weighted = nx.Graph()
G_frank_weighted.add_nodes_from(words)
# 為邊隨機賦予權重，模擬共現頻率
np.random.seed(42)
for u, v in edges:
    weight = np.random.randint(1, 10) # 隨機權重
    G_frank_weighted.add_edge(u, v, weight=weight)

print("\n計算邊的 log_residual 屬性...")
G_frank_residual = residual_net(G_frank_weighted)

# 檢查一些邊的 log_residual 值
print("範例邊的 log_residual 值:")
for u, v, data in list(G_frank_residual.edges(data=True))[:5]: # 檢查前5條邊
    print(f"Edge ({u}, {v}): Actual Weight={G_frank_weighted.get_edge_data(u,v)['weight']}, Log Residual={data.get('log_residual', 'N/A')}")

print("\n虛擬模型用於識別顯著的邊。")
print("log_residual > 0 表示該邊比預期更強。")
print("log_residual < 0 表示該邊比預期更弱。")

@startuml
!define DISABLE_LINK
!define PLANTUML_FORMAT svg
!theme _none_

skinparam dpi auto
skinparam shadowing false
skinparam linetype ortho
skinparam roundcorner 5
skinparam defaultFontName "Microsoft JhengHei UI"
skinparam defaultFontSize 16
skinparam minClassWidth 100

start

:網路視覺化進階：殼層佈局優化與力導向佈局;:優化殼層佈局：結合度數與社群;
note right
程式碼解析:
  - 節點度數排序 (labels)
  - 社群偵測 (nxcom.greedy_modularity_communities)
  - 構建 nlist:
    - 提取度數排序的節點子集 (shell_labels)
    - 在子集內按社群索引排序 (ordered_labels)
    - 殼層大小遞增 (k += 12)
  - 生成佈局: nx.shell_layout(G, nlist=nlist)
繪製:
  - 使用社群顏色映射
  - 顯示中心節點 (高度數) 在內層，外圍節點 (低度數) 在外層
視覺化解讀:
  - 中心性與社群結構的結合
end note

:力導向佈局 (Force-directed Layout);
note right
基本原理:
  - 節點間排斥力, 邊間吸引力
  - 模擬物理系統達到穩定狀態
優點:
  - 適應大型網路
  - 清晰傳達社群結構
缺點:
  - 毛球傾向 (尤其大社群)
  - 最佳用於稀疏網路, 多社群
NetworkX 實現: nx.spring_layout(), nx.fruchterman_reingold_layout() 等
end note

:Frankenstein 詞語共現網路與虛擬模型;
note right
案例回顧: Frankenstein 網路預設佈局資訊量不大
本節目標:
  - 重新檢視網路
  - 透過虛擬模型聚焦網路方面, 減少雜亂
虛擬模型 (Null Models):
  - 定義: 預測邊強度的假設集
  - 用途: 識別超出預測的邊 (顯著連結)
  - 簡單模型: 邊權重 ~ 端點度數乘積
residual_net 函數:
  - 輸入: 圖 G (帶權重邊)
  - 輸出: 新圖 G_residual
  - 屬性: log_residual (實際權重 vs. 預測權重偏差)
end note

stop

@enduml

看圖說話：

此圖示總結了「網路視覺化進階：殼層佈局的優化與力導向佈局的應用」的內容，重點在於解析如何優化殼層佈局，並介紹力導向佈局的原理及虛擬模型的應用。流程開頭首先聚焦於「優化殼層佈局：結合度數與社群」，詳細說明了程式碼如何結合節點度數排序和社群資訊來構建精確的節點分層結構，接著詳細闡述了「力導向佈局 (Force-directed Layout)」的基本原理、優點與缺點，並以 Frankenstein 詞語共現網路為例，預告了下一節將探討「虛擬模型 (Null Models)」的應用，說明了 residual_net 函數如何計算邊的 log_residual 屬性，以識別網路中顯著的連結。

縱觀現代管理者的多元挑戰，我們檢視這些高階視覺化技術在複雜數據環境下的實踐效果，其價值遠不僅止於圖表的美化，而是一場深刻的認知突破。傳統佈局常導致的「毛球效應」，恰如管理者面臨的資訊過載困境，使人迷失於數據噪音中。優化的殼層佈局與力導向佈局雖提供了初步的結構化視野，但真正的躍升在於導入「虛擬模型」的分析思維。

此方法將視覺化從被動的「呈現」，轉化為主動的「探問」。透過 log_residual 等指標，我們得以校準認知，濾除因節點自身影響力所產生的預期連結，從而放大那些「超乎預期」的關鍵關係。這不僅是技術的精進，更是決策品質的精煉，使領導者能從繁雜的表象中，精準識別出隱藏的機會與風險。

玄貓認為，未來3-5年，數據洞察力的核心將不再是擁有多少數據，而是能否建立有效的「訊號放大器」。將統計模型與視覺化深度融合的趨勢，將成為高階管理者駕馭複雜性、提升決策直覺的關鍵修養。對於追求深度洞察的管理者，應將視覺化從單純的「呈現」提升至「探問」的層次，利用虛擬模型等工具，主動發掘數據背後的隱藏結構。

玄貓 BlackCat

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。