Skip to main content
 首页 » 编程设计

python之在 python 中优化 Euler-Maruyama 实现

2025年05月04日15kerrycode

我的任务是解决一个特定的随机微分方程 (SDE) 和一个普通的 DE,两者相互依赖。我一直在使用 Euler-Maruyama method求解方程,目前需要求解其中的 100 000 个(它们模拟粒子路径和动量)。代码本身运行良好,但问题是由于我需要增加算法的时间步长,计算时间自然也会增加。我最初选择 python 作为我最习惯的任务,尽管我非常清楚它不是 HPC 东西(慢循环)的最佳选择。在某些时候,我可能不得不改为使用 python 作为 fortran 子例程的“粘合剂”,但我想知道是否还有一些方法可以从当前代码中提取一点性能。

我目前正在使用函数 EM 来求解(模拟)DE,然后使用一个辅助函数来收集所有模拟的时间、路径和动量并将它们附加到各自的数组中。代码看起来像这样:

def EM(tstart, tend, steps, x1, x2, x3, x4, x5): 
    dt = float((tend - tstart))/steps     # Timestep 
    T = np.linspace(tstart, tend, steps) 
    y = [x3*T[0] - 0.01]    # Table for the paths 
    p = [x3*x2*x4]  # Table for the momentum 
    pos = 0.0 
    mom = 0.0 
 
    for i in range(1, steps): 
        pos =  y[i-1] + dt*(((x1*y[i-1])/(x3*T[i-1])) + (3.0*p[i-1]*(T[0]/T[i-1])/x2)*((2*(x3*T[i-1]-y[i-1])/(y[i-1]+x5))-1)) + (np.sqrt(6*(p[i-1]*(T[0]/T[i-1])/x2)*(x3*T[i-1]-y[i-1])) * np.sqrt(dt) * np.random.normal(0,1)) 
 
        #Boundary condition 
        if(pos > x3*T[i]): 
            v = (pos-y[i-1])/dt 
            tdot = (y[i-1]-v*T[i-1])/(x3-v) 
            pos = x3*tdot - v*(T[i-1]+dt-tdot) 
 
        mom = p[i-1] - (1.0/3.0)*p[i-1]*(x1/(x3*T[i-1]))*(1 + (2*y[i-1]/(y[i-1]+x5)))*dt 
 
        y.append(pos) 
        p.append(mom) 
 
        #Boundary condition             
        if(pos < 0): 
            break 
 
 
 
    return T[0:i+1], y, p 

其中 x1,...,x5 是一些常量。截至目前,我需要使用 108 000 个时间步,并使用内置的 %timeit 测试运行代码

%timeit EM(1.0, 10.0, 108000, 1.0, 1.0, 2.0, 3.0, 1.0) 

给我 65 毫秒到 25 毫秒之间的最佳案例结果。

我用来将所有这些收集在一起的辅助函数非常简单:

def helper(tstart, tend, steps, x1, x2, x3, x4, x5, no_of): 
    timespan = []  
    momentums = [] 
    paths = [] 
    for i in range(0, no_of): 
            t, y, p = EM(tstart, tend, steps, x1, x2, x3, x4, x5) 
            timespan.append(t) 
            paths.append(y) 
            momentums.append(p) 
 
    return timespan, paths, momentums 

使用以下参数通过 timeit 运行它

%timeit multi(1.0, 10.0, 108000, 1.0, 1.0, 2.0, 3.0, 1.0, 1000) 

给出 1 分 14 秒(74 秒)的最佳情况结果,如果有 100 000 个粒子,则相当于 7400 秒或大约两个小时。我仍然可以使用它,但将来我可能必须为此添加模拟或时间步长。

我最初使用的是 numpy 数组,但改为使用常规 python 列表实际上使代码速度更快。我猜这是因为您必须在使用 np.zeros() 方法之前声明 numpy 数组的大小(除非您想使用 np.append 方法,但在这种情况下速度非常慢)。因此,尽管使用的步数为 108000,但只有一小部分模拟最终会如此长,因此我最终需要使用 np.trim_zeros() 将零从数组中删除。

我一直在尝试使用 Numba library它是@jit 方法,但我无法让它工作。它给了我以下错误:

    NotImplementedError: Failed at nopython (nopython frontend) 
   (<class 'numba.ir.Expr'>, build_list(items=[Var($0.20, <ipython-input-   32-4529989cafc0> (5))])) 

是否可以删除辅助函数,并仅使用附加模拟数组的 for 循环运行代码来改善运行时间?有没有一种方法可以在不使用 for 循环的情况下运行代码,而是使用数组操作?我听说这会加快速度。

还有其他想法吗?非常感谢您的帮助。

请您参考如下方法:

由于这个问题的迭代性质,不可能用数组操作代替循环。

作为替代方案,我认为 Numba 确实是一个不错的选择。 Numba 不适用于 Python 列表(因此您会收到异常),因此您只能使用 Numpy 数组。为了处理先验的未知数组大小,ndarray.resize 实例方法很好用,因为它释放了未使用的内存(与获取切片相反,切片保留对整个数组的引用) .代码看起来像这样:

from numba import jit 
 
@jit(nopython=True) 
def EM_helper(T, x1, x2, x3, x5, y, p): 
    dt = (T[-1] - T[0]) / T.shape[0] 
    for i in range(1, T.shape[0]): 
 
        # ...big calculation 
 
        y[i] = pos 
        p[i] = mom 
 
        #Boundary condition             
        if(pos < 0): 
            break 
 
    return i+1 
 
def EM(T, x1, x2, x3, x4, x5): 
    y = np.empty_like(T, dtype=float)  # Table for the path 
    p = np.empty_like(T, dtype=float)  # Table for the momentum 
 
    y[0] = x3*T[0] - 0.01 
    p[0] = x3*x2*x4 
    count = EM_helper(T, x1, x2, x3, x5, y, p) 
 
    y.resize(count) 
    p.resize(count) 
    return T[:count], y, p 

除了 EM_helper 函数,您还可以尝试依赖自动“循环提升”,但根据我的经验,这不太可靠。

时间数组的创建 T = np.linspace(tstart, tend, steps) 我移到了函数之外,因为在快速测试中我发现它会成为性能瓶颈。