Question

我试图在数字上解决一个承认离散跳跃的ODE。我正在使用Euler方法，并希望Numba的jit可以帮助我加快这个过程（现在脚本需要300秒才能运行，我需要它运行200次）。

这是我的第一次简化尝试：

import numpy as np
from numba import jit

dt = 1e-5
T = 1
x0 = 1
noiter = int(T / dt)
res = np.zeros(noiter)

def fdot(x, t):
    return -x + t / (x + 1) ** 2

def solve_my_ODE(res, fdot, x0, T, dt):
    res[0] = x0
    noiter = int(T / dt)
    for i in range(noiter - 1):
        res[i + 1] = res[i] + dt * fdot(res[i], i * dt)
        if res[i + 1] >= 2:
            res[i + 1] -= 2
    return res

%timeit fdot(x0, T)
%timeit solve_my_ODE(res, fdot, x0, T, dt)
    ->The slowest run took 8.38 times longer than the fastest. This could mean that an intermediate result is being cached 
    ->1000000 loops, best of 3: 465 ns per loop
    ->10 loops, best of 3: 122 ms per loop

@jit(nopython=True)
def fdot(x, t):
    return -x + t / (x + 1) ** 2
%timeit fdot(x0, T)
%timeit solve_my_ODE(res, fdot, x0, T, dt)
    ->The slowest run took 106695.67 times longer than the fastest. This could mean that an intermediate result is being cached 
    ->1000000 loops, best of 3: 240 ns per loop
    ->10 loops, best of 3: 99.3 ms per loop

@jit(nopython=True)
def solve_my_ODE(res, fdot, x0, T, dt):
    res[0] = x0
    noiter = int(T / dt)
    for i in range(noiter - 1):
        res[i + 1] = res[i] + dt * fdot(res[i], i * dt)
        if res[i + 1] >= 2:
            res[i + 1] -= 2
    return res
%timeit fdot(x0, T)
%timeit solve_my_ODE(res, fdot, x0, T, dt)
    ->The slowest run took 10.21 times longer than the fastest. This could mean that an intermediate result is being cached 
    ->1000000 loops, best of 3: 274 ns per loop
    ->TypingError                               Traceback (most recent call last)
ipython-input-10-27199e82c72c> in <module>()
  1 get_ipython().magic('timeit fdot(x0, T)')
----> 2 get_ipython().magic('timeit solve_my_ODE(res, fdot, x0, T, dt)')

(...)


TypingError: Failed at nopython (nopython frontend)
Undeclared pyobject(float64, float64)
File "<ipython-input-9-112bd04325a4>", line 6

我不明白为什么会收到此错误。我怀疑numba不识别输入字段fdot（这是一个已经用Numba编译的python函数）。

由于我对Numba这么新，我有几个问题

如何让Numba了解输入字段fdot是一个函数？
在函数fdot上使用JIT“仅”导致减少50％。我应该期待更多吗？或者这是正常的吗？
这个脚本看起来像是一种合理的方式来模拟具有离散跳跃的ODE吗？在数学上，这相当于用delta函数求解ODE。

Numba版本为0.17

Answer 1

到最后一点：

在当前形式中，它甚至不是a的有效实现表现良好的ODE。它过早地停止了一步，最后一次＆＃34;常规＆＃34;步应该是noiter*dt，而不考虑时间余数T-noiter*dt。

请注意，range(N)会生成数字0,1,…,N-1。相等， res=zeros(N)生成一个包含N条目的数组，从res[0]到 res[N-1]。
切换不应取决于离散化，即步骤长度。为此，一个更准确的时间跨越了切换条件应通过插值确定（线性或反向二次方）然后重新启动修改或新系统新的初始条件。要保留所需的网格，请使用简短的第一步。

def solve_my_ODE(res, fdot, x0, T, dt):
    noiter = int(T / dt)
    dt = T/noiter          #adapt the timestep 
    res = zeros(noiter+1)
    res[0] = x0
    for i in range(noiter):
        res[i + 1] = res[i] + dt * fdot(res[i], i * dt)
        if res[i + 1] >= 2:
            h = (2-res[i])/(res[i+1]-res[i]) # precautions against zero division ?
            res[i + 1] = 0 + (1-h)*dt * fdot(0, (i+h)*dt)
    return res

似乎需要最终准确度优于1e-4。这里使用dt=1e-5计算使用100 000步骤同样多的功能评估。

将经典的Runge-Kutta方法与h=0.05一起使用导致误差略大于1e-5（dt**4=6.25e-6），即，具有与欧拉方法误差相当的大小。但是，现在这只需要T/dt=20个步骤，总计80 功能评估。注意，切换时间也需要准确，订单O(dt**4)不会污染全局错误顺序。

因此，如果速度是目标，那么调查是有利可图的更高阶的方法。

Answer 2

你认为numba不会将fdot识别为numba编译函数。我不认为你可以把它识别为函数参数，但是你可以使用这种方法（使用变量捕获，以便在构建函数时知道fdot）来构建ODE求解器：

def make_solver(f):
    @jit(nopython=True)
    def solve_my_ODE(res, x0, T, dt):
        res[0] = x0
        noiter = int(T / dt)
        for i in range(noiter - 1):
            res[i + 1] = res[i] + dt * f(res[i], i * dt)
            if res[i + 1] >= 2:
                res[i + 1] -= 2
        return res
    return solve_my_ODE

fdot_solver = make_solver(fdot) # call this for each function you 
      # want to make an ODE solver for

这是一个替代版本，不要求您将res传递给它。只有循环才会加速，但由于这是慢速位，这是唯一重要的位。

def make_solver_2(f):
    @jit
    def solve_my_ODE(x0, T, dt):
        # this bit ISN'T in no python mode
        noiter = int(T / dt)
        res = np.zeros(noiter)
        res[0] = x0
        # but the loop is nopython (so fast)
        for i in range(noiter - 1):
            res[i + 1] = res[i] + dt * f(res[i], i * dt)
            if res[i + 1] >= 2:
                res[i + 1] -= 2
        return res
    return solve_my_ODE

我更喜欢这个版本，因为它为您分配了返回值，所以它更容易使用。这虽然与你的真实问题略有不同。

就我得到的时间而言（以秒为单位，进行20次迭代）：

6.90394687653（仅适用于numba的fdot）
0.0584900379181（版本1）
0.0640540122986（对于版本2 - 即它稍慢但更容易使用）

因此，它的速度大约快了100倍 - 加速循环会产生很大的不同！

你的第三个问题：＆＃34;这个脚本看起来像是一种合理的方法来模拟具有离散跳跃的ODE吗？在数学上，这相当于用delta函数求解ODE。＆＃34;我真的不知道。遗憾！

Numba的jit无法编译具有另一个函数作为输入的函数

2 个答案: