Python多进程构建Jacobian矩阵：如何跨进程共享矩阵变量？

问题概述 #

尝试用中心差分法构建Jacobian矩阵，希望利用多核并行加速。使用Process库实现时，发现子进程内的Jacobian矩阵列计算正确，但主进程返回的始终是初始零矩阵；同时不确定Process和Pool哪个更适合多核利用。

核心问题原因 #

Python多进程采用内存隔离机制：子进程会复制父进程的内存空间，你传入Jac矩阵后，子进程修改的只是自己内存里的副本，主进程的原矩阵不会被同步更新，所以最终返回的还是初始的零矩阵。

Process vs Pool 选型建议 #

• Pool更适合这类并行计算场景：它封装了进程池管理、任务分发和结果收集逻辑，代码更简洁，无需手动处理进程的创建、销毁和数据传递。
• Process适合需要精细控制进程生命周期、自定义通信规则的复杂场景，但需要开发者手动处理数据同步，代码复杂度更高。

可行解决方案 #

方案1：使用Pool.map收集结果后组装矩阵 #

将每一列的计算逻辑改为返回单独的列数据，主进程收集所有列结果后再组装成完整的Jacobian矩阵，避免直接修改共享数据：

import numpy as np
import multiprocessing
from multiprocessing import Pool

def Jacobian(f, h=1e-6):
    return lambda x: jacobian_pool(f, x, h=h)

def jacobian_pool(f, x, h):
    n = len(x)
    # 创建进程池，用CPU核心数-1避免占满资源
    with Pool(multiprocessing.cpu_count()-1) as pool:
        # 生成所有列的任务参数
        args_list = [(i, x, h, f) for i in range(n)]
        # 并行计算每一列
        columns = pool.starmap(jac_part, args_list)
    
    # 将所有列组装成Jacobian矩阵
    Jac = np.column_stack(columns)
    return Jac

def jac_part(i, x, h, f):
    x_plus = x.copy()
    x_minus = x.copy()
    x_plus[i] += h
    x_minus[i] -= h
    f_plus = f(x_plus)
    f_minus = f(x_minus)
    # 返回计算好的列
    return (f_plus - f_minus) / (2 * h)

def f(x):
    return np.array([x[0]**2 + x[1], 2*x[0]**2 + x[1]**2])

if __name__ == "__main__":
    x = np.array([1., 2.])
    jf = Jacobian(f)
    print(jf(x))

方案2：使用共享内存直接修改矩阵（适合大矩阵） #

通过multiprocessing.Array创建共享内存数组，转换为numpy矩阵后让子进程直接修改共享区域，避免数据复制：

import numpy as np
import multiprocessing
from multiprocessing import Process

def Jacobian(f, h=1e-6):
    return lambda x: jacobian_pool(f, x, h=h)

def jacobian_pool(f, x, h):
    n = len(x)
    # 创建共享内存数组，类型为float64
    shared_array = multiprocessing.Array('d', n*n)
    # 转换为numpy矩阵
    Jac = np.frombuffer(shared_array.get_obj()).reshape((n, n))
    
    processes = []
    for i in range(n):
        p = Process(target=jac_part, args=(i, x, h, Jac, f))
        processes.append(p)
    
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    
    return Jac.copy()  # 返回副本避免后续共享内存问题

def jac_part(i, x, h, Jac, f):
    x_plus = x.copy()
    x_minus = x.copy()
    x_plus[i] += h
    x_minus[i] -= h
    f_plus = f(x_plus)
    f_minus = f(x_minus)
    Jac[:, i] = (f_plus - f_minus) / (2 * h)

def f(x):
    return np.array([x[0]**2 + x[1], 2*x[0]**2 + x[1]**2])

if __name__ == "__main__":
    x = np.array([1., 2.])
    jf = Jacobian(f)
    print(jf(x))

注意：使用共享内存时，需要确保子进程的修改操作是无冲突的（这里按列修改不会出现多进程同时改写同一区域的问题），避免数据混乱。

内容的提问来源于stack exchange，提问作者Eigenvalue