Python 努巴'；s jit无法编译具有另一个函数作为输入的函数

我试图用数值方法求解一个允许离散跳跃的常微分方程。我使用的是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

将numpy导入为np
从numba导入jit
dt=1e-5
T=1
x0=1
noiter=int（T/dt）
res=np.零（黑度）
def fdot（x，t）：
回报率-x+t/（x+1）**2
def solve_my_ODE（res，fdot，x0，T，dt）：
res[0]=x0
noiter=int（T/dt）
对于范围内的i（黑线-1）：
res[i+1]=res[i]+dt*fdot（res[i]，i*dt）
如果res[i+1]>=2：
res[i+1]-=2
返回res
%timeit fdot（x0，T）
%timeit解算我的代码（res，fdot，x0，T，dt）
->最慢的跑步比最快的跑长8.38倍。这可能意味着正在缓存中间结果
->1000000个循环，最佳3个：每个循环465纳秒
->10个环路，最好为3:122毫秒/环路
@jit（nopython=True）
def fdot（x，t）：
回报率-x+t/（x+1）**2
%timeit fdot（x0，T）
%timeit解算我的代码（res，fdot，x0，T，dt）
->最慢的跑步比最快的跑长106695.67倍。这可能意味着正在缓存中间结果
->1000000个循环，最好3个：每个循环240纳秒
->10个回路，最佳3个：99.3毫秒/回路
@jit（nopython=True）
def solve_my_ODE（res，fdot，x0，T，dt）：
res[0]=x0
noiter=int（T/dt）
对于范围内的i（黑线-1）：
res[i+1]=res[i]+dt*fdot（res[i]，i*dt）
如果res[i+1]>=2：
res[i+1]-=2
返回res
%timeit fdot（x0，T）
%timeit解算我的代码（res，fdot，x0，T，dt）
->最慢的跑步比最快的跑长10.21倍。这可能意味着正在缓存中间结果
->1000000个循环，最佳3个：每个循环274纳秒
->打字机错误回溯（最近一次呼叫最后一次）
ipython-input-10-27199e82c72c>输入（）
1 get_ipython（）.magic（'timeit fdot（x0，T）'））
---->2 get_-ipython（）.magic（'timeit solve_my_ODE（res，fdot，x0，T，dt）'
(...)
打字机错误：在nopython（nopython前端）失败
未声明的pyobject（float64，float64）
文件“”，第6行

我不明白我为什么会犯这个错误。我怀疑numba不识别输入字段fdot（这是一个python函数，顺便说一句，它已经用numba编译过了）

因为我对Numba很陌生，所以我有几个问题

• 我该怎么做才能让Numba理解输入字段fdot是一个函数
• 在函数fdot“only”上使用JIT将导致减少50%。我应该期待更多吗？还是这很正常
• 这个脚本看起来像是模拟带有离散跳跃的ODE的合理方法吗？从数学上讲，这相当于用delta函数求解常微分方程

---

Numba版本为0.17

您认为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倍——加速循环会产生很大的不同

你的第三个问题：“这个脚本看起来像是用离散跳跃模拟常微分方程的合理方法吗？从数学上讲，这相当于用增量函数求解常微分方程。”我真的不知道。对不起

到最后一点：

• 在当前形式中，它甚至不是 表现良好的颂歌。它过早地停止了一步，即最后一个“常规”步骤 应该是<<代码> NOTE**DT <代码>，并且不考虑时间。 余数

  T-noiter*dt

  请注意，

  range（N）

  生成数字

  0,1，…，N-1

  。同样地，

  res=zero（N）

  生成一个包含

  N

  项的数组，从

  res[0]

  到

  res[N-1]

• 切换不应依赖于离散化，即步骤 长度。因此，更准确的穿越时间 应通过插值（线性或线性）确定切换条件 然后，修改后的系统或新系统重新启动 新的初始条件。要保留所需的栅格，请使用短的 第一步

---

---

• 似乎需要比

  1e-4

  更好的最终精度。 这里使用

  dt=1e-5

  计算使用

  100000

  步骤 以及同样多的功能评估
  使用

  h=0.05的经典龙格库塔法将
  导致误差略大于
  1e-5
  （
  dt**4=6.25e-6
  ），
  i、 e.，具有与Euler方法误差相当的大小。
  但是，现在只需要
  T/dt=20
  步骤，总共
  80
  功能评估。请注意，切换时间也需要调整
  顺序准确，无污染
  全局错误顺序
  
  因此，如果以速度为目标，那么在中国进行调查是有益的
  高阶方法
  

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