Kamada-Kawai 布局算法实战：如何用 nx.kamada_kawai_layout 优化社交网络可视化

1. 为什么你的社交网络图总是一团乱麻？

不知道你有没有遇到过这种情况：好不容易从数据库里导出了一堆用户关系数据，用 NetworkX 建好了图，兴冲冲地调用 nx.draw() 想看看这个社交网络长什么样，结果画出来的图却是一团密密麻麻、节点挤在一起、线条交错纵横的“毛线球”。别说分析结构了，连看清楚谁和谁相连都费劲。

我刚开始做社交网络分析的时候就经常被这个问题困扰。那时候我用的是默认的随机布局或者简单的圆形布局，出来的图毫无结构可言，完全体现不出用户社群、核心人物或者关系疏密这些关键信息。直到后来，我接触到了 力导向布局算法，特别是 Kamada-Kawai 算法，才算是真正打开了社交网络可视化的大门。

简单来说，Kamada-Kawai 算法就像一个智能的“图面规划师”。它不再随机或按固定规则摆放节点，而是把整个网络想象成一个真实的物理系统：每个用户（节点）是一个有质量的点，他们之间的好友关系（边）是一根根弹簧。关系紧密的好友之间，弹簧的“理想长度”就短，它会努力把这两个点拉近；而关系疏远或者没有直接联系的用户之间，弹簧的“理想长度”就长，甚至会产生一种排斥力，让它们彼此远离。整个算法运行的过程，就是不断调整每个点的位置，让整个系统的“能量”降到最低，最终达到一个平衡稳定的状态。

这个平衡状态下的图，就是我们梦寐以求的清晰可视化效果。紧密的社群会自然地聚集在一起，形成一个个“小团体”；连接不同社群的“桥梁用户”会出现在合适的位置；整个网络的整体结构，比如是星型、环状还是分散的多个集群，都能一目了然。nx.kamada_kawai_layout(G) 就是 NetworkX 库对这个强大算法的封装，你只需要一行代码，就能把上面那团“毛线球”变成一张结构清晰、信息量丰富的网络地图。

所以，如果你正在处理社交网络、知识图谱、论文引用关系、公司内部通讯网络这类关系数据，并且希望可视化结果不仅能“看”，更能“分析”，那么掌握 Kamada-Kawai 布局算法就是你必须要走的一步。接下来，我就带你从零开始，手把手搞定这个算法，并用真实的社交网络案例，让你看到它化腐朽为神奇的力量。

2. Kamada-Kawai 算法：把社交网络变成弹簧模型

要真正用好一个工具，不能只停留在调 API 的层面，稍微理解一下它的“内心戏”会让你在调试参数和解读结果时事半功倍。Kamada-Kawai 算法的核心思想非常直观，我们可以用一个生活中的场景来类比。

想象一下，你是一个幼儿园老师，要安排一群小朋友在操场上做游戏。这些小朋友之间，有的彼此是好朋友，喜欢待在一起（强连接）；有的只是普通同学（弱连接）；还有的甚至互相不太对付（无连接或负连接，在算法中体现为距离远）。你的目标是给他们安排站位，让好朋友之间靠得近些，关系一般的站得中等距离，互相不喜欢的就离远点。同时，你还希望整个队伍看起来均匀、不拥挤也不松散。

Kamada-Kawai 算法就是你这个老师手中的“智能排位系统”。它通过下面几个步骤来解决问题：

2.1 定义“理想距离”：谁和谁应该有多近？

这是算法的第一步，也是最关键的一步。算法需要知道，图中每一对节点之间的“理想距离”应该是多少。注意，这里说的不是“图上直接相连的两点”，而是图中任意两点之间。

对于直接相连的两个节点（比如用户A和用户B是好友），它们的理想距离通常被设为1（一个基础单位）。对于不直接相连的节点，比如用户A和用户C，它们之间可能通过用户B相连（A-B-C）。那么，A和C之间的理想距离，就与它们之间的最短路径长度成正比。路径越长，理想距离就越远。

具体计算公式是：对于图中任意两点 i 和 j，它们的理想距离 d_ij 等于它们之间的最短路径长度 L_ij 乘以一个基础单位长度 k。即 d_ij = k * L_ij。k 是一个可以调节的参数，它控制了整个图的“紧凑程度”，k 值越大，最终布局的图幅面就越大。

这就好比，你规定好朋友（直接相连）的间距是1米。那么通过一个共同朋友认识的两个人（最短路径为2），他们的理想间距可能就是2米。完全不沾边的两个人（最短路径很长），理想间距就会非常大，算法会倾向于把他们放在布局的两端。

2.2 构建“能量函数”：衡量当前布局有多糟糕

有了理想距离，我们就可以评价任何一个随机布局的好坏。算法定义了一个全局的能量函数 E，这个函数值越高，说明当前布局越糟糕，节点位置和它们的理想距离相差越大；函数值越低，说明布局越接近理想状态。

能量函数的具体形式是这样的： E = Σ Σ ( (dist_ij - d_ij)^2 / (d_ij^2) ) 这个双求和符号 ΣΣ 表示对图中所有节点对（i, j）进行计算。dist_ij 是当前布局下节点i和节点j之间的实际欧几里得距离，d_ij 就是我们上一步算出来的理想距离。

这个公式非常巧妙：

• 分子 (dist_ij - d_ij)^2 衡量的是“实际距离”与“理想距离”的差距。差距越大，贡献的能量就越高。
• 分母 d_ij^2 是一个归一化因子。它意味着，对于理想距离本身就很大的节点对（即关系很远的两个节点），即使它们的实际距离偏差一些，对总能量的“贡献”也不会太大；而对于理想距离很小的节点对（好朋友），它们的位置偏差会被放大，对总能量影响更大。这确保了算法会优先保证“好朋友”们靠得足够近。

我们的目标，就是找到一组节点的坐标（x, y），让这个总能量 E 达到最小。

2.3 最小化能量：让系统自己找到平衡点

如何找到那组让能量最小的坐标呢？这本质上是一个数学上的优化问题。Kamada-Kawai 原始论文采用的是类似牛顿迭代法的数值优化方法。你可以把它想象成在这样一个能量 landscape（能量景观）上，通过计算每个节点在各个方向上的“受力”（即能量下降最快的方向，梯度），然后让节点沿着这个方向移动一小步。

这个过程是迭代进行的：

1. 算法从一个初始布局开始（比如随机布局）。
2. 计算当前布局下的总能量 E，以及每个节点在x和y方向上的“受力”（偏导数）。
3. 找到当前“能量贡献最大”或者说“最不开心”的那个节点。
4. 移动这个节点，使得它的局部能量降到最低（通过解一个小的二次方程）。
5. 更新这个节点的位置。
6. 重复步骤2-5，直到总能量 E 的变化小于一个很小的阈值，或者达到了最大迭代次数。此时系统达到平衡，布局完成。

整个过程，就像你轻轻拨动那个站得最别扭的小朋友，把他放到让他自己感觉最舒服（局部能量最低），同时也让整个队伍更和谐（全局能量降低）的位置。然后不断重复，直到所有小朋友都基本满意为止。

理解了这三个步骤，你再去看 nx.kamada_kawai_layout 的各个参数，就会非常清晰了。接下来，我们就进入实战环节。

3. 实战准备：搭建你的社交网络分析环境

在开始画图之前，我们得先把“画板”和“颜料”准备好。这里不需要复杂的配置，一个 Python 环境加上几个常用的库就足够了。我强烈建议使用 Anaconda 来管理环境，它能帮你省去很多依赖库安装的麻烦。

3.1 安装核心库

打开你的终端（Windows 上是 CMD 或 PowerShell，Mac/Linux 上是 Terminal），创建一个新的虚拟环境是个好习惯，可以避免库版本冲突。

# 创建名为 sn_visual 的虚拟环境，指定 Python 版本
conda create -n sn_visual python=3.9
# 激活环境
conda activate sn_visual

激活环境后，安装我们需要的几个核心库：

# 安装 NetworkX，这是我们操作图数据的基础
pip install networkx
# 安装 Matplotlib，这是最常用的绘图库
pip install matplotlib
# 安装 NumPy，NetworkX 底层计算会用到
pip install numpy

如果你想得到更美观、交互性更强的图，还可以安装一个强大的库 pyvis，它可以生成基于 HTML 的交互式网络图，支持鼠标拖动、缩放、点击查看节点属性等。

pip install pyvis

3.2 准备一份社交网络数据

为了演示，我们需要一份关系数据。这里我提供两种方式：一种是使用 NetworkX 内置的经典社交网络数据集，另一种是模拟一份简单的数据。

方法一：使用经典数据集（推荐） NetworkX 内置了一些小型社交网络数据，非常适合学习和测试。比如著名的“空手道俱乐部”数据集，它记录了大学空手道俱乐部成员之间的社交关系。

import networkx as nx

# 加载空手道俱乐部图
G = nx.karate_club_graph()
print(f"节点数: {G.number_of_nodes()}")
print(f"边数: {G.number_of_edges()}")
print(f"节点列表: {list(G.nodes())[:5]}...")  # 查看前5个节点
print(f"边列表: {list(G.edges())[:5]}...")   # 查看前5条边

运行这段代码，你会看到这个图有34个节点（成员）和78条边（社交关系）。每个节点还有 club 属性，标识该成员最后属于哪个阵营，这在我们后续上色时会用到。

方法二：自己模拟一份数据 如果你想完全从零开始，可以模拟一个小型的社交网络。假设我们有10个用户，他们之间随机建立一些好友关系。

import networkx as nx
import random

# 创建一个空的无向图
G = nx.Graph()
# 添加10个节点，标签为0到9
G.add_nodes_from(range(10))
# 随机添加一些边，模拟好友关系
for i in range(10):
    for j in range(i+1, 10):
        if random.random() < 0.3:  # 以30%的概率创建边
            G.add_edge(i, j)
# 再添加一个“明星用户”，与很多人连接
for i in range(1, 9):
    G.add_edge(0, i)  # 节点0是明星用户

print(f"模拟网络节点数: {G.number_of_nodes()}")
print(f"模拟网络边数: {G.number_of_edges()}")

环境搭建好了，数据也准备好了，我们的“画布”和“颜料”都已就位。下一节，我们将请出今天的主角 nx.kamada_kawai_layout，看看它如何施展魔法。

4. 核心函数 nx.kamada_kawai_layout 详解与调参

现在，让我们聚焦到 nx.kamada_kawai_layout 这个函数本身。直接调用它很简单，但想让它发挥出最佳效果，理解它的参数是关键。函数的完整签名是这样的：

nx.kamada_kawai_layout(G, dist=None, pos=None, weight='weight', scale=1, center=None, dim=2)

看起来参数不少，别担心，我们一个个拆解，我会用最直白的语言告诉你每个参数是干嘛的，以及什么时候需要调整它。

4.1 基础调用与可视化

我们先从最简单的开始，用上一节准备好的空手道俱乐部数据。

import networkx as nx
import matplotlib.pyplot as plt

# 加载数据
G = nx.karate_club_graph()
# 核心一行代码：计算 Kamada-Kawai 布局
pos = nx.kamada_kawai_layout(G)
# 可视化
plt.figure(figsize=(10, 8))  # 设置画布大小
nx.draw(G, pos, with_labels=True, node_color='lightblue', edge_color='gray', node_size=500, font_size=10)
plt.title("Karate Club Network - Kamada-Kawai Layout")
plt.show()

运行这段代码，你应该能看到一张34个节点的网络图。与随机布局的“毛线球”相比，这张图的结构清晰多了：节点不再拥挤，边交叉较少，整个图呈现出一种自然的疏密分布。仔细观察，你会发现有些节点紧密地簇拥在一起，有些节点则处于连接不同簇的“桥梁”位置。这就是力导向布局的威力。

4.2 关键参数深度解析

现在，我们来深入看看那些能让你“定制”布局效果的参数。

1. dist：自定义理想距离矩阵 这是最强大但也最复杂的参数。默认情况下，算法使用节点间的最短路径长度来计算理想距离。但有时候，你的业务逻辑可能不同。比如，在社交网络中，你可能认为“共同好友数”比“最短路径”更能衡量用户间的亲密程度。这时，你就可以通过 dist 参数传入一个自定义的距离字典。

import numpy as np
# 假设我们有一个自定义的距离函数，例如：距离 = 1 / (1 + 共同邻居数)
# 这里为了演示，我们随机生成一个距离矩阵，实际中你需要根据业务计算
n = G.number_of_nodes()
custom_dist = {}
for i in range(n):
    for j in range(n):
        if i != j:
            # 模拟一个自定义距离：基础路径距离加上一些随机扰动
            try:
                path_len = nx.shortest_path_length(G, i, j)
                custom_dist[(i, j)] = path_len + np.random.rand()*0.5
            except nx.NetworkXNoPath:
                # 如果两点不连通，给一个很大的距离
                custom_dist[(i, j)] = n

pos_custom = nx.kamada_kawai_layout(G, dist=custom_dist)

2. pos：提供初始布局 算法需要一个起点来开始迭代优化。默认是随机初始布局 (pos=None)。但如果你已经有一个不错的布局（比如用其他更快算法算的），或者你想在现有布局上微调，可以传入 pos 参数。这能加速收敛，有时也能得到更好的结果。

# 先用一个快速布局算法（如spring_layout）获得一个粗略布局
pos_initial = nx.spring_layout(G, seed=42)
# 然后以这个布局为起点，用Kamada-Kawai进行精细优化
pos_refined = nx.kamada_kawai_layout(G, pos=pos_initial)

3. weight：考虑边的权重 如果你的图是有权重的（比如，好友亲密度、通讯频率），那么 weight 参数就派上用场了。默认是 'weight'，算法会尝试读取边的 weight 属性，并用它来影响理想距离。权重越大，通常意味着关系越紧密，算法会倾向于让这两个节点靠得更近。

# 假设我们给空手道俱乐部的边随机添加一些权重
import random
for u, v in G.edges():
    G[u][v]['weight'] = random.uniform(0.5, 2.0)

# 计算布局时，算法会自动考虑权重（如果存在的话）
pos_weighted = nx.kamada_kawai_layout(G, weight='weight')

4. scale 与 center：控制画布

• scale：缩放因子。默认是1。增大这个值（比如设为2），会让所有节点坐标等比例放大，整个图在画布上看起来更“舒展”；减小则更“紧凑”。
• center：布局的中心点坐标。默认是 (0, 0)。如果你想将布局的中心放在画布的特定位置，可以设置这个参数，例如 center=(5, 5)。

# 生成一个更舒展、中心在(0,0)的布局
pos_large = nx.kamada_kawai_layout(G, scale=2)
# 生成一个布局，并希望其中心在画布(5,5)的位置
pos_centered = nx.kamada_kawai_layout(G, center=(5,5))

5. dim：扩展到三维空间 Kamada-Kawai 算法不仅限于二维平面。设置 dim=3，你可以得到一个三维空间的节点坐标。这对于某些复杂网络的可视化（尤其是使用 3D 渲染工具时）非常有帮助。

pos_3d = nx.kamada_kawai_layout(G, dim=3)
print(f"节点0的三维坐标: {pos_3d[0]}")  # 输出类似 (0.123, -0.456, 0.789)

4.3 一个综合调参的示例

让我们把上面这些参数组合起来，为一个带权重的网络计算一个定制化的布局。

# 1. 创建一个带权重的模拟社交网络
G_weighted = nx.Graph()
nodes = ['Alice', 'Bob', 'Carol', 'Dave', 'Eve', 'Frank']
G_weighted.add_nodes_from(nodes)
# 添加带权重的边，权重代表联系强度
edges_with_weight = [('Alice', 'Bob', 5), ('Alice', 'Carol', 3),
                     ('Bob', 'Dave', 2), ('Carol', 'Eve', 4),
                     ('Dave', 'Eve', 1), ('Eve', 'Frank', 3),
                     ('Frank', 'Alice', 2)]
for u, v, w in edges_with_weight:
    G_weighted.add_edge(u, v, weight=w)

# 2. 使用带权重的 Kamada-Kawai 布局，并指定初始布局和缩放
# 先计算一个初始布局（这里用spectral布局，它通常比较稳定）
pos_init = nx.spectral_layout(G_weighted)
# 基于初始布局，考虑边权重，计算最终布局，并适当放大
pos_final = nx.kamada_kawai_layout(G_weighted, pos=pos_init, weight='weight', scale=1.5)

# 3. 可视化，用边的宽度来体现权重
plt.figure(figsize=(8, 6))
# 绘制节点
nx.draw_networkx_nodes(G_weighted, pos_final, node_color='lightgreen', node_size=800)
# 绘制边，线条宽度与权重成正比
edge_widths = [G_weighted[u][v]['weight'] for u, v in G_weighted.edges()]
nx.draw_networkx_edges(G_weighted, pos_final, width=edge_widths, alpha=0.7)
# 绘制节点标签
nx.draw_networkx_labels(G_weighted, pos_final, font_size=12)
plt.title("Weighted Social Network with Custom KK Layout")
plt.axis('off')  # 关闭坐标轴
plt.show()

运行这段代码，你会看到一张图，其中联系紧密的节点（如 Alice 和 Bob，权重5）被拉得更近，而联系较弱的边（如 Dave 和 Eve，权重1）则相对较长。边的粗细直观地展示了关系的强弱。

5. 进阶技巧：让社交网络图会“说话”

掌握了基础布局之后，我们的图虽然结构清晰了，但信息量还不够丰富。一张优秀的可视化图，应该能让观者一眼就抓住关键信息：谁是核心人物？有哪些社群？哪些连接至关重要？这就需要我们给图添加更多的视觉元素。

5.1 根据节点属性上色与调整大小

在社交网络中，节点往往带有各种属性，比如用户的性别、年龄组、所属社区、活跃度等。用颜色和大小来编码这些属性，是提升信息密度的最有效方法。

让我们回到空手道俱乐部数据集。它有一个 club 属性，标识成员最终属于哪个教练的阵营（“Mr. Hi” 或 “Officer”）。我们来用颜色区分它们。

# 获取每个节点的 'club' 属性
club_color_map = []
for node in G.nodes():
    # G.nodes[node] 可以访问该节点的所有属性
    club = G.nodes[node].get('club', 'Unknown')
    if club == 'Mr. Hi':
        club_color_map.append('red')
    elif club == 'Officer':
        club_color_map.append('blue')
    else:
        club_color_map.append('gray')

# 计算布局
pos = nx.kamada_kawai_layout(G)
plt.figure(figsize=(12, 10))
# 绘制，传入颜色列表
nx.draw(G, pos, node_color=club_color_map, with_labels=True,
        edge_color='lightgray', node_size=800, font_size=9)
plt.title("Karate Club - Colored by Faction (Kamada-Kawai Layout)")
plt.show()

现在，红蓝两色清晰地分开了网络中的两个主要阵营。你可以立刻看出，算法计算出的布局不仅考虑了连接关系，还使得同属一个阵营的节点在空间上也更加聚集，这与我们的直觉和数据的真实情况完美吻合。

除了颜色，节点大小也可以传递信息。假设我们通过某种算法（比如 PageRank）计算了每个节点的重要性（中心性）。

# 计算度中心性（最简单的中心性指标，即好友数）
node_degree = dict(G.degree())
# 将度中心性映射为节点大小，例如：节点大小 = 300 + 度 * 100
node_sizes = [300 + node_degree[node] * 100 for node in G.nodes()]

plt.figure(figsize=(12, 10))
nx.draw(G, pos, node_color=club_color_map, node_size=node_sizes,
        with_labels=True, edge_color='lightgray', font_size=9)
plt.title("Karate Club - Size by Degree Centrality")
plt.show()

在这张图上，节点越大，代表该成员在俱乐部中的直接连接越多（度中心性越高）。结合颜色和大小，谁是每个阵营中的核心人物，谁又是连接两个阵营的关键桥梁，就变得一目了然。

5.2 边的样式与交互式可视化

静态图适合汇报和印刷，但交互式图能让你探索更多细节。pyvis 库在这方面是神器。

from pyvis.network import Network

# 创建一个 pyvis 网络对象
net = Network(notebook=True, height="600px", width="100%", bgcolor="#222222", font_color="white")
# 将 networkx 图转换为 pyvis 能识别的格式
# 我们需要把节点和边的属性都传过去
for node in G.nodes():
    club = G.nodes[node].get('club', 'Unknown')
    color = 'red' if club == 'Mr. Hi' else 'blue' if club == 'Officer' else 'grey'
    net.add_node(node, label=str(node), color=color, title=f"Node {node}, Club: {club}")

for u, v in G.edges():
    net.add_edge(u, v)

# 使用我们之前算好的 Kamada-Kawai 布局
# pyvis 需要节点位置是一个列表形式的字典
pos = nx.kamada_kawai_layout(G)
for node, (x, y) in pos.items():
    # 将坐标缩放并平移，以适应 pyvis 的画布
    net.nodes[node]['x'] = x * 1000
    net.nodes[node]['y'] = y * 1000

# 生成一个可交互的 HTML 文件
net.show("karate_club_interactive.html")

运行后，会生成一个 HTML 文件。用浏览器打开它，你可以用鼠标拖动节点、滚轮缩放、点击节点或边查看其属性。这种交互性对于探索中等规模的网络极其有用，你可以手动调整你觉得不完美的局部布局，或者聚焦到某个子网络进行详细观察。

5.3 处理大规模网络的策略

Kamada-Kawai 算法虽然效果好，但其计算复杂度较高，对于成千上万个节点的大规模网络，直接使用可能会非常慢。这里有几个实战策略：

策略一：先采样，再布局 如果你的网络太大，可以先使用一些图采样算法（如随机游走采样、度排序采样等）获取一个能代表原网络结构的子图，对这个子图应用 Kamada-Kawai 布局，研究其结构。

策略二：分层布局 对于超大规模网络，可以考虑使用“骨架图”或“中心性筛选”的方法。先找出网络中最重要的一部分节点（例如，度中心性最高的前200个节点），用 Kamada-Kawai 对这部分核心节点进行精细布局。然后，再将其他节点根据它们与核心节点的连接关系，用更快的算法（如力导向的 spring_layout）附着上去。

策略三：使用更快算法做初始化 正如前面参数部分提到的，先用一个计算速度快的算法（如 nx.spring_layout 或 nx.spectral_layout）得到一个粗略的、但结构大致正确的布局，然后将这个布局作为 pos 参数传给 kamada_kawai_layout。这样，Kamada-Kawai 算法只需要在好的起点上进行微调，可以大大减少迭代次数，缩短计算时间。

# 对于大图 G_large
print("正在计算快速初始布局...")
pos_fast = nx.spring_layout(G_large, seed=42, k=0.5, iterations=50)  # 降低迭代次数和力常数以加速
print("正在基于初始布局进行 Kamada-Kawai 优化...")
pos_kk = nx.kamada_kawai_layout(G_large, pos=pos_fast, scale=2)
print("布局计算完成。")

在实际项目中，我处理过一个约5000个节点的通讯网络，直接使用 Kamada-Kawai 布局需要近十分钟。而采用“快速 spring 布局初始化 + Kamada-Kawai 微调”的策略，时间缩短到了两分钟以内，并且最终的可视化效果几乎没有损失。这个技巧在应对稍大规模数据时非常实用。

6. 避坑指南：我踩过的那些坑

用了这么多年 Kamada-Kawai 布局，我也不是一帆风顺的，遇到过不少让人头疼的问题。这里把我总结的几个常见“坑”和解决方案分享给你，希望能帮你节省时间。

坑一：布局结果每次都不一样？ 如果你没有设置随机种子，那么算法的初始位置是随机的，这可能导致每次运行得到的布局在旋转、镜像或轻微扰动上有所不同。虽然整体结构一致，但对于需要复现的结果来说是个问题。 解决方案：在调用任何可能涉及随机性的布局算法之前，先为 pos 参数提供一个确定性的初始布局。最常用的方法是先用一个固定种子的 spring_layout。

import numpy as np
# 固定全局随机种子，保证可复现性
np.random.seed(42)
# 或者，为 spring_layout 提供 seed 参数
pos_init = nx.spring_layout(G, seed=42)
pos_kk = nx.kamada_kawai_layout(G, pos=pos_init)

坑二：图中有孤立节点或小团体，布局很奇怪？ Kamada-Kawai 算法假设整个图是连通的。如果图中存在完全孤立的节点（度数为0）或者多个互不连通的子图，算法为它们计算的距离将是无穷大（或非常大），这可能导致这些节点被“抛”到画布非常远的地方，甚至导致布局失败。 解决方案：布局前先检查图的连通性。

# 检查是否连通
if not nx.is_connected(G):
    print("图不连通，包含多个连通分量。")
    # 找出最大的连通子图进行布局
    largest_cc = max(nx.connected_components(G), key=len)
    G_main = G.subgraph(largest_cc).copy()
    pos = nx.kamada_kawai_layout(G_main)
    # 对于其他孤立节点，可以手动设置位置，比如放在角落
    # ... 手动处理逻辑 ...
else:
    pos = nx.kamada_kawai_layout(G)

坑三：节点太多，布局太慢甚至内存溢出？ 这是 Kamada-Kawai 算法的主要瓶颈。它需要计算所有节点对之间的最短路径（O(N^3) 复杂度）并维护一个巨大的距离矩阵。 解决方案：

1. 严格限制规模：如前一节所述，对于超过1000个节点的图，谨慎使用。考虑采样或分层策略。
2. 使用 dist 参数：如果你能通过其他更高效的方式（如基于节点属性的相似度）预先计算好一个近似的“距离”矩阵，可以绕过内部的最短路径计算。但这需要你对业务有很深的理解。
3. 换用其他算法：对于超大规模图，nx.spring_layout (Fruchterman-Reingold) 是更好的选择，它速度更快，虽然局部细节可能不如 Kamada-Kawai 完美，但整体结构依然清晰。

坑四：布局过于紧凑或过于松散？ 有时候算出来的图所有节点挤在正中间一小团，有时候又分散在画布边缘。 解决方案：主要调整 scale 参数。如果太挤，就增大 scale 值（如1.5, 2）；如果太散，就减小 scale 值（如0.5, 0.8）。同时，检查你的画布大小 plt.figure(figsize=(w, h))，确保其与 scale 参数匹配。

坑五：特定类型的图布局效果不佳？ Kamada-Kawai 算法在层次结构非常明显的图（如树状图）或规则图（如网格）上，效果可能不如专门为这些图设计的布局算法（如 nx.nx_agraph.graphviz_layout 中的 dot 布局用于层次图）。 解决方案：没有一种布局算法是万能的。了解你的图类型：

• 层次结构明显的图（树、流程图）：尝试 nx.nx_agraph.graphviz_layout(G, prog='dot')。
• 社区结构明显的图（社交网络）：Kamada-Kawai 和 spring_layout 是首选。
• 环形或网格状图：可以尝试 nx.circular_layout 或 nx.shell_layout。

记住，可视化是一门艺术，更是一门实验科学。多尝试不同的参数、不同的算法，甚至组合使用它们，才能为你的特定数据找到最合适的“地图绘制法”。当你调出一张既能清晰展现全局结构，又能突出关键局部细节的网络图时，那种成就感会让你觉得所有的折腾都是值得的。