优化三层嵌套循环解决大数据集下的MemoryError问题

你的核心问题在于三层Python循环的低效，以及20万×20万规模的矩阵直接存储导致的内存爆炸。下面是针对这两个问题的针对性优化：

核心思路 #

1. 用Numpy向量化替代Python循环：Python循环在大数据量下性能极差，Numpy的广播运算能将列级别的差异计算并行化，速度提升几个数量级。
2. 分块处理避免内存溢出：20万×20万的矩阵会占用约160GB内存（按int32计算），完全无法直接存储。通过分块处理原数据集，每次只计算部分行的权重矩阵，大幅降低内存占用。
3. 可选：去重减少计算量：如果数据中存在大量重复配置，可以先对数据集去重，计算唯一行之间的权重矩阵后再映射回原索引，进一步减少计算和内存压力。

具体实现代码 #

基础配置与数据预处理 #

首先定义列权重，将DataFrame转换为Numpy数组以便广播运算：

import numpy as np
import pandas as pd

# 定义各列权重（根据实际需求调整）
COL_WEIGHTS = {
    'processorName': 2,
    'GraphicsCardname': 3,
    'ProcessorBrand': 1
}

# 提取目标列并转换为Numpy数组
cols = list(COL_WEIGHTS.keys())
orig_arr = df_original[cols].values
comp_arr = df_compare[cols].values
weight_values = np.array(list(COL_WEIGHTS.values()), dtype=np.int32)

方案一：分块向量化计算（必选，解决内存问题） #

每次处理原数据集中的一小部分行（比如1000行，可根据内存调整chunk_size），计算该块与所有对比行的权重矩阵，可选择直接保存到磁盘或合并结果：

chunk_size = 1000  # 每次处理的行数，根据内存调整
result_chunks = []

for start_idx in range(0, orig_arr.shape[0], chunk_size):
    # 截取当前处理的原数据块
    end_idx = min(start_idx + chunk_size, orig_arr.shape[0])
    orig_chunk = orig_arr[start_idx:end_idx]
    
    # 广播计算差异矩阵：(chunk_rows, comp_rows, n_cols)
    # 比较每个块行与所有对比行的每一列是否不同
    diff_matrix = orig_chunk[:, None, :] != comp_arr[None, :, :]
    
    # 计算权重和：沿列维度求和，得到(chunk_rows, comp_rows)的矩阵
    chunk_weights = (diff_matrix * weight_values).sum(axis=2)
    
    # 可选：直接保存到磁盘，避免占用内存
    # np.save(f'weight_chunk_{start_idx}_{end_idx}.npy', chunk_weights)
    
    # 或者将块结果存入列表（如果内存允许合并）
    result_chunks.append(chunk_weights)

# 合并所有块得到完整矩阵（内存足够时执行）
final_weight_matrix = np.vstack(result_chunks)

方案二：去重优化（可选，进一步提速减内存） #

如果数据中存在大量重复配置，先去重计算唯一行的权重矩阵，再映射回原索引：

# 对原数据集去重，得到唯一行和原索引映射
orig_unique, orig_inverse = np.unique(orig_arr, axis=0, return_inverse=True)
# 对对比数据集去重
comp_unique, comp_inverse = np.unique(comp_arr, axis=0, return_inverse=True)

# 计算唯一行之间的权重矩阵
diff_unique = orig_unique[:, None, :] != comp_unique[None, :, :]
weight_unique = (diff_unique * weight_values).sum(axis=2)

# 映射回原数据集的完整矩阵
final_weight_matrix = weight_unique[orig_inverse][:, comp_inverse]

为什么比原代码高效？ #

• 向量化运算：Numpy的底层是C实现，广播运算能将列级别的对比并行处理，速度比Python循环快100~1000倍。
• 分块处理：将超大矩阵拆分为多个小矩阵，内存占用从160GB降至几百MB（取决于chunk_size），彻底避免MemoryError。
• 去重优化：如果重复率高，能将计算量从4e10次降至数万次，进一步提升效率。

内容的提问来源于stack exchange，提问作者My name is jeff