如何利用Numpy优化Python中节点索引对的迭代效率以加速图构建？

我来帮你分析一下各个方法速度差异的原因，以及给出几个能显著提升运行效率的优化方向——你遇到的问题其实挺典型的，核心是Python循环的开销、Numpy数组的访问特性，以及数据结构的选择问题。

一、为什么不同方法的速度差这么大？ #

先拆解你遇到的“反直觉”现象：为什么筛选出30M对迭代反而比遍历50M对加判断更慢？

1. Numpy数组遍历的额外开销
   你用np.where得到的overlapping_pairs_indices是Numpy数组，在Python循环里遍历它的每一行时，每次取出的i和j是Numpy的int64类型，而不是Python原生的int——每次类型转换都会带来微小但累积的开销，30M次循环下来就是很大的浪费。相比之下，range生成的是原生Python整数，访问和操作都快得多。

2. 你处理了重复的节点对！
   你的overlap_matrix是对称矩阵（如果i和j满足条件，j和i也一定满足），所以np.where会同时返回(i,j)和(j,i)这两组对，导致你的30M对里其实包含了一倍的重复工作（而itertools.combinations只生成i<j的唯一对）。你代码里的if i != j其实没解决重复问题，反而多了一层判断开销。

3. 直接遍历矩阵的“跳过”开销更低
   你第三个方法里，for i in range(...): for j in range(i+1, ...)的循环中，大部分overlap_matrix[i,j]为False的情况，只是做了一次Numpy数组的快速索引访问和布尔判断就跳过了——Python里这种“快速跳过”的开销远小于执行get_loc_similarity的开销，而你筛选出30M对后，每一次循环都要执行这个昂贵的相似度计算，相当于没跳过任何一次，自然时间没降下来。

二、针对性优化方案 #

根据上面的分析，我们可以从几个方向入手，把速度提上去：

1. 先修正Numpy筛选的节点对，只保留i<j的唯一对 #

首先，在生成overlapping_pairs_indices后，过滤掉i >= j的对，避免重复计算：

# 只保留i < j的对，和combinations的逻辑一致
mask = overlapping_pairs_indices[:, 0] < overlapping_pairs_indices[:, 1]
overlapping_pairs_indices = overlapping_pairs_indices[mask]

这样你的实际迭代次数会从30M降到15M左右，直接砍掉一半的工作量。

2. 把Numpy数组转成Python列表再遍历，消除类型转换开销 #

Numpy数组在Python循环里的元素访问开销大，转成原生列表后遍历会快很多：

# 把i和j分别转成Python列表
i_list = overlapping_pairs_indices[:, 0].tolist()
j_list = overlapping_pairs_indices[:, 1].tolist()

# 遍历列表的zip对
for i, j in zip(i_list, j_list):
    artist1_data = artist_data_list[i]
    artist2_data = artist_data_list[j]
    val = process.get_loc_similarity(artist1_data, artist2_data)
    if val > 0:
        G.add_edge(artist_names[i], artist_names[j], weight=val)

3. 预转数据结构，消除字典访问开销 #

你当前每次循环都要做artist1 = artist_names[i]然后artist_data[artist1]——字典的键查找开销比列表索引大得多。预先把artist_data转成按索引排序的列表：

# 提前把艺术家数据按索引顺序存到列表里，避免每次字典查找
artist_data_list = [artist_data[name] for name in artist_names]

之后循环里直接用artist_data_list[i]访问，能节省大量的字典查找时间。

4. 用Numba JIT编译加速核心循环 #

如果get_loc_similarity是纯Python实现的函数，用Numba对整个循环或者这个函数做JIT编译，能把Python循环的开销降到接近C的速度。比如：
首先安装numba：pip install numba
然后修改代码：

from numba import jit

# 先把数据转成Numba能高效处理的numpy数组
birth_years = np.array([d['birth_year'] for d in artist_data_list])
death_years = np.array([d['death_year'] for d in artist_data_list])
# 假设位置可以编码为整数（比如用字典映射城市到ID）
location_ids = np.array([city_id_map[d['location']] for d in artist_data_list])

# 用numba JIT编译相似度计算函数
@jit(nopython=True)
def get_loc_similarity_numba(birth1, death1, loc1, birth2, death2, loc2):
    # 重写原来的相似度计算逻辑，用纯数值运算
    overlap_start = max(birth1, birth2)
    overlap_end = min(death1, death2)
    overlap_duration = max(0, overlap_end - overlap_start)
    if overlap_duration < 3:  # 假设最小时间重叠阈值
        return 0
    if loc1 != loc2:
        return 0
    return overlap_duration

# 编译核心循环函数
@jit(nopython=True)
def compute_edges(birth_years, death_years, location_ids, threshold):
    n = len(birth_years)
    edges = []
    for i in range(n):
        for j in range(i+1, n):
            # 先判断时间重叠条件
            if birth_years[i] < death_years[j] and death_years[i] > birth_years[j]:
                val = get_loc_similarity_numba(
                    birth_years[i], death_years[i], location_ids[i],
                    birth_years[j], death_years[j], location_ids[j]
                )
                if val > threshold:
                    edges.append((i, j, val))
    return edges

# 调用得到所有边，再添加到图中
edges = compute_edges(birth_years, death_years, location_ids, 0)
for i, j, val in edges:
    G.add_edge(artist_names[i], artist_names[j], weight=val)

Numba的nopython模式会把Python代码编译成机器码，循环速度能提升10-100倍，这是最显著的优化手段。

三、预期效果 #

按上面的优化步骤，先修正重复对+转列表+预转数据结构，应该能把时间从13分钟降到6-7分钟左右；再加上Numba JIT编译，时间能压缩到1分钟以内，甚至几十秒，完全解决你的性能问题。

备注：内容来源于stack exchange，提问作者me9hanics