從網路結構解析社會學習的收斂過程

import networkx as nx
import matplotlib.pyplot as plt
import numpy as np
import random

# --- 社會學習的學習步驟與收斂 ---

# 延續前文的 G_karate 和 initial_beliefs_karate

# 1. 定義學習步驟函數 (與前文相同，為完整性再次貼出)
def learning_step(G, beliefs):
    """
    模擬一個社會學習回合，代理人根據鄰居的平均估計更新自己的信念。
    :param G: NetworkX graph 物件。
    :param beliefs: 當前所有代理人的信念字典。
    :return: 更新後的代理人信念字典。
    """
    new_beliefs = {}
    for v in G.nodes():
        total = beliefs[v]  # 包含自身信念
        count = 1
        for w in G.neighbors(v):
            total += beliefs[w]
            count += 1
        new_beliefs[v] = total / count
    return new_beliefs

# 2. 定義繪製信念演變的函數
def plot_beliefs_evolution(G, initial_beliefs, true_value=0, steps=10, title="Belief Evolution Over Time"):
    """
    模擬多輪社會學習，並繪製每個代理人信念隨時間的演變。
    :param G: NetworkX graph 物件。
    :param initial_beliefs: 初始信念字典。
    :param true_value: 真實值，用於繪製參考線。
    :param steps: 模擬的學習回合數。
    :param title: 圖表的標題。
    """
    current_beliefs = dict(initial_beliefs)
    belief_history = [current_beliefs.copy()] # 儲存每一輪的信念狀態

    # 儲存繪圖數據
    # x 軸是時間步，y 軸是信念值
    x_values = list(range(steps + 1)) # 從 0 開始到 steps
    y_values = {v: [] for v in G.nodes()} # 每個節點的信念隨時間的列表

    # 記錄初始信念
    for v in G.nodes():
        y_values[v].append(current_beliefs[v])

    # 模擬多輪學習
    for step in range(steps):
        current_beliefs = learning_step(G, current_beliefs)
        belief_history.append(current_beliefs.copy())
        # 記錄當前輪次的信念
        for v in G.nodes():
            y_values[v].append(current_beliefs[v])

    # --- 繪製圖表 ---
    plt.figure(figsize=(12, 7))
    
    # 繪製每個節點的信念演變線
    for v in G.nodes():
        plt.plot(x_values, y_values[v], label=f'Agent {v}' if v < 5 else "", alpha=0.6, linewidth=1) # 只標記前幾個節點

    # 繪製真實值參考線
    plt.axhline(y=true_value, color='r', linestyle='--', label=f'True Value ({true_value})')

    # 添加圖表標題和標籤
    plt.title(title, fontsize=16)
    plt.xlabel("Learning Steps (Rounds)", fontsize=12)
    plt.ylabel("Belief Value", fontsize=12)
    plt.legend(loc='best', fontsize=10)
    plt.grid(True, linestyle='--', alpha=0.6)
    plt.ylim(min(initial_beliefs.values()) - 10, max(initial_beliefs.values()) + 10) # 調整 y 軸範圍以更好地顯示
    plt.show()

    # 輸出最終收斂的信念值
    final_beliefs = current_beliefs
    print("\n--- 學習過程結束 ---")
    print(f"經過 {steps} 輪學習後，最終信念值:")
    avg_final_belief = np.mean(list(final_beliefs.values()))
    print(f"  所有節點的平均最終信念: {avg_final_belief:.2f}")
    # 檢查是否接近真實值
    print(f"  與真實值 ({true_value}) 的差異: {abs(avg_final_belief - true_value):.2f}")
    
    # 顯示部分節點的最終信念
    print("部分節點的最終信念:")
    for i, node in enumerate(G_karate.nodes()):
        if i < 5:
            print(f"  節點 {node}: {final_beliefs[node]:.2f}")
        elif i == 5:
            print("  ...")

# --- 執行模擬與繪製 ---
# 假設 G_karate 和 initial_beliefs_karate 已在前文定義
num_learning_steps = 20 # 模擬 20 輪學習
plot_beliefs_evolution(G_karate, initial_beliefs_karate, true_value=true_value_karate, steps=num_learning_steps, title="Social Learning Convergence in Karate Club Network")

print("\n觀察圖表：")
print("  - 每條線代表一個代理人（節點）的信念值如何隨學習回合數增加而變化。")
print("  - 可以看到，隨著學習回合的增加，不同代理人的信念逐漸靠近。")
print("  - 最終，所有代理人的信念趨於收斂到一個共同的值，該值接近於真實值。")
print("  - 這種收斂是社會學習過程中，透過鄰居互動和平均化來達成共識的體現。")

import networkx as nx
import matplotlib.pyplot as plt
import numpy as np
import random

# --- 重新定義或確保所需函數存在 ---

# 假設 initial_beliefs 和 learning_step 函數已定義 (如前文所示)

def initial_beliefs(G, true_value=0, std=15):
    """Generate estimates of a true value with normally-distributed errors."""
    beliefs = {}
    for v in G.nodes():
        beliefs[v] = random.gauss(true_value, std)
    return beliefs

def learning_step(G, beliefs):
    """Update each node's beliefs based on its neighbors' beliefs."""
    new_beliefs = {}
    for v in G.nodes():
        total = beliefs[v]  # Include old belief in average
        count = 1
        for w in G.neighbors(v):
            total += beliefs[w]
            count += 1
        new_beliefs[v] = total / count
    return new_beliefs

# 完善的 plot_beliefs_evolution 函數 (用於繪製單一網路)
def plot_beliefs_evolution(G, initial_beliefs, true_value=0, steps=10, title="Belief Evolution Over Time"):
    """Plot change in beliefs over time."""
    current_beliefs = dict(initial_beliefs)
    belief_history = [current_beliefs.copy()]

    x_values = list(range(steps + 1))
    y_values = {v: [] for v in G.nodes()}

    for v in G.nodes():
        y_values[v].append(current_beliefs[v])

    for i in range(steps):
        current_beliefs = learning_step(G, current_beliefs)
        belief_history.append(current_beliefs.copy())
        for v in G.nodes():
            y_values[v].append(current_beliefs[v])

    # Plot evolution of each node's beliefs
    plt.figure(figsize=(12, 7))
    for v in G.nodes():
        # 為了避免圖表過於擁擠，只標記少數節點，或使用更細的線條
        if v < 5 or v > G.number_of_nodes() - 5: # 標記前5個和後5個節點
             plt.plot(x_values, y_values[v], alpha=0.6, linewidth=1.5, label=f'Agent {v}')
        else:
             plt.plot(x_values, y_values[v], alpha=0.3, linewidth=1)

    # Plot mean value
    mean_value = np.mean(list(initial_beliefs.values()))
    plt.plot([0, steps], [mean_value, mean_value], 'k--', label=f'Initial Mean ({mean_value:.2f})')

    # Plot true value
    plt.axhline(y=true_value, color='r', linestyle=':', label=f'True Value ({true_value})')

    # Add spines to plot
    ax = plt.gca()
    for spine in ax.spines.values():
        spine.set_visible(True)

    plt.xlim([0, steps])
    # 根據實際數據調整 ylim
    all_beliefs_flat = [val for beliefs_round in belief_history for val in beliefs_round.values()]
    min_belief = min(all_beliefs_flat) if all_beliefs_flat else 0
    max_belief = max(all_beliefs_flat) if all_beliefs_flat else 0
    plt.ylim(min_belief - 5, max_belief + 5)

    plt.title(title, fontsize=16)
    plt.xlabel("Learning Steps (Rounds)", fontsize=12)
    plt.ylabel("Belief Value", fontsize=12)
    plt.legend(loc='best', fontsize=10)
    plt.grid(True, linestyle='--', alpha=0.6)
    plt.show()

    # 輸出最終收斂的平均信念值
    final_beliefs = belief_history[-1]
    avg_final_belief = np.mean(list(final_beliefs.values()))
    print(f"\n--- Simulation Results for '{title}' ---")
    print(f"  Final average belief after {steps} steps: {avg_final_belief:.2f}")
    print(f"  Difference from true value ({true_value}): {abs(avg_final_belief - true_value):.2f}")
    # 檢查最終信念的標準差，衡量收斂程度
    std_dev_final = np.std(list(final_beliefs.values()))
    print(f"  Standard deviation of final beliefs: {std_dev_final:.2f}")

# --- 設定模擬參數 ---
true_value_global = 50
std_dev_global = 20
num_learning_steps = 30 # 增加學習步數以確保充分收斂
num_nodes_small = 50 # 較小的網路用於快速測試
num_nodes_large = 200 # 較大的網路用於觀察規模效應

# --- 創建不同類型的網路 ---
networks_to_simulate = {}

# 1. 隨機圖 (Random Graph)
G_random = nx.erdos_renyi_graph(num_nodes_small, p=0.1, seed=42)
if nx.is_connected(G_random): # 確保網路連通
    networks_to_simulate["Random Graph"] = G_random
else:
    print("Random graph not connected, skipping.")

# 2. 小世界網路 (Watts-Strogatz)
n_ws = num_nodes_small
k_ws = 4
p_ws = 0.1
G_ws = nx.watts_strogatz_graph(n_ws, k_ws, p_ws, seed=42)
if nx.is_connected(G_ws):
    networks_to_simulate["Small-World Network"] = G_ws
else:
    print("Watts-Strogatz graph not connected, skipping.")

# 3. 尺度不變性網路 (Barabási-Albert)
n_ba = num_nodes_large
m_ba = 2 # 每次添加 2 條邊
G_ba = nx.barabasi_albert_graph(n_ba, m_ba, seed=42)
if nx.is_connected(G_ba):
    networks_to_simulate["Scale-Free Network"] = G_ba
else:
    print("Barabási-Albert graph not connected, skipping.")

# 4. 空手道俱樂部網路 (Karate Club) - 使用較小的節點數
G_karate_small = nx.karate_club_graph()
networks_to_simulate["Karate Club Network"] = G_karate_small

# --- 執行多個網路的社會學習模擬 ---
print("\n--- Starting Social Learning Simulations on Different Networks ---")

for name, G in networks_to_simulate.items():
    print(f"\nSimulating on: {name} ({G.number_of_nodes()} nodes)")
    
    # 為每個網路生成獨立的初始信念
    # 為了公平比較，確保初始信念的平均值大致相同，或使用相同的隨機種子
    # 這裡我們為每個網路生成新的初始信念
    initial_beliefs_net = initial_beliefs(G, true_value=true_value_global, std=std_dev_global)
    
    # 執行模擬並繪製結果
    plot_beliefs_evolution(G, initial_beliefs_net, true_value=true_value_global, steps=num_learning_steps, title=f"Social Learning: {name}")

print("\n--- All Simulations Completed ---")
print("Analysis of results should focus on comparing convergence speed and final belief standard deviation across different network structures.")