python - Julia 符号和数字性能对比 Python

Question

我刚刚翻译了一组涉及矩阵的科学计算，其中的元素是符号表达式，它们被区分并与各种其他数学表达式组合，然后进行数值积分。为了重现我遇到的性能差距，下面的代码片段构成了一个最小的示例。我知道先用符号区分然后用数字积分是没有意义的，但同样，重点是性能差距。需要注意的是，导入库并不代表太多时间，也不能解释性能差距。
Julia 代码:

using Symbolics, QuadGK

@variables x

m = [i * 10*x^3 + 1/i * sin(x) + 5*i*x^3 * cos(x) - 8i*x^2 + 2/sin(i*3.0)*x + exp(1/(x+10)) for i in 1:500]

m_d = expand_derivatives.(Differential(x).(m))
m_d_expr = build_function(m, x)
m_d_f = eval(m_d_expr[1])
v = quadgk(m_d_f, 0, 1)
print(v[1])

python 代码:

import pandas as pd
import numpy as np
from sympy import sin, diff, pi, lambdify, integrate, cos, exp
from sympy.abc import x
from sympy.matrices import Matrix
from scipy.integrate import quad

def integrate_matrix(m, v, a, b):
    mi = np.zeros((m.rows, m.cols))
    for i in range(m.rows):
        for j in range(m.cols):
            f = lambdify(v, m[i, j])
            integral_value = quad(f, a, b)[0]
            mi[i, j] = integral_value
            
    return mi


m = Matrix([i * 10*x**3 + 1/i * sin(x) + 5*i*x**3 * cos(x) - 8*i*x**2 + 2/sin(i*3.0)*x + exp(1/(x+10)) for i in range(1, 501)])

v = integrate_matrix(m, x, 0, 1)
print(v)

我的问题:有没有办法改进 Julia 代码以匹配 Python 代码性能。每次我试图让我的码头对 Julia 的表现留下深刻印象时，我都会感到尴尬。我仍然是一个 Julia noob，但我真的不知道该怎么做。
大约时间:
python :6 秒
Julia :30+ 秒
Julia 1.6 版
python 3.7
注意:由于差距很大，我发布了这个。不，CAS 并没有解释这一切。此外，我们正在做一个符号差异而不是集成，更不用说 sympy 是缓慢的。我可以将代码添加到精确的时间，然后呢？我遇到问题的原始科学代码是 6 秒 Python vs 75 秒 Julia。多可惜。

Answer 1

Running the entire thing faster is what any sane person cares about.

据我了解，Julia 关心的是将东西运行的速度提高几倍，而只运行一次总是比较慢，因为 Julia 代码需要在执行前进行编译。与 Julia 不同，Python 不进行任何 JIT 编译，并且随时准备以相同的速度运行。
Julia 1.6
因此，我将您的 Julia 代码粘贴到 code.jl 中，并在同一个 session 中多次运行它:

# New Julia session!
julia> @time include("code.jl")
[long array...]
 24.660636 seconds (42.99 M allocations: 2.607 GiB, 3.82% gc time, 0.02% compilation time)

julia> @time include("code.jl")
[long array...]
  2.761062 seconds (5.61 M allocations: 240.159 MiB, 10.39% gc time, 57.06% compilation time)

julia> @time include("code.jl")
[long array...]
  2.608917 seconds (5.61 M allocations: 240.164 MiB, 4.47% gc time, 61.75% compilation time)

# Restarted Julia
julia> @time include("code.jl")
 25.538249 seconds (42.99 M allocations: 2.607 GiB, 3.76% gc time, 0.02% compilation time)

julia> @time include("code.jl")
  2.740550 seconds (5.61 M allocations: 240.159 MiB, 9.94% gc time, 56.72% compilation time)

因此，第一次运行代码大约需要 25 秒，再次运行大约需要 3 秒(!)，即使这 3 秒中有 50% 用于编译内容。但是，最初的 25 秒中只有 0.02% 用于编译。显然，放缓不是由于编译时间？还要注意它在第一次运行时执行了多少内存分配:4300 万对下一次运行的大约 550 万(少 7 倍!)。但无论如何，第一次运行真的很慢，而随后的运行却是闪电般的快。
第一次加载包也很慢:

julia> @time using Symbolics
  3.503349 seconds (6.42 M allocations: 460.519 MiB, 3.53% gc time, 0.13% compilation time)

julia> @time using Symbolics
  0.000241 seconds (136 allocations: 9.641 KiB)
  0.000280 seconds (136 allocations: 9.641 KiB)
  0.000249 seconds (136 allocations: 9.641 KiB)
  0.000251 seconds (136 allocations: 9.641 KiB)
  0.000252 seconds (136 allocations: 9.641 KiB)
  0.000246 seconds (136 allocations: 9.641 KiB)

# I didn't import it before,
# but apparently `Symbolics` did
julia> @time using QuadGK
  0.000276 seconds (137 allocations: 9.688 KiB)
  0.000276 seconds (136 allocations: 9.641 KiB)
  0.000240 seconds (136 allocations: 9.641 KiB)
  0.000251 seconds (136 allocations: 9.641 KiB)

也就是说，仅运行带有导入的代码的第一行就花费了 3.5 秒。我想，由于缓存，后续导入显然更快。
列表理解的第一次运行也很慢

julia> @time m = [i * 10*x^3 + 1/i * sin(x) + 5*i*x^3 * cos(x) - 8i*x^2 + 2/sin(i*3.0)*x + exp(1/(x+10)) for i in 1:500];
  2.590259 seconds (4.69 M allocations: 284.672 MiB, 10.86% gc time, 98.69% compilation time)

julia> @time m = [i * 10*x^3 + 1/i * sin(x) + 5*i*x^3 * cos(x) - 8i*x^2 + 2/sin(i*3.0)*x + exp(1/(x+10)) for i in 1:500];
  0.102573 seconds (231.21 k allocations: 12.507 MiB, 72.61% compilation time)
  0.098871 seconds (231.21 k allocations: 12.508 MiB, 72.39% compilation time)
  0.108458 seconds (231.21 k allocations: 12.512 MiB, 7.93% gc time, 67.73% compilation time)
  0.099787 seconds (231.22 k allocations: 12.508 MiB, 72.99% compilation time)
  0.098378 seconds (231.21 k allocations: 12.507 MiB, 73.80% compilation time)

同样，启动缓慢(98.69% 的编译时间)，但接下来的运行速度要快得多。

python 3.9.2

~/t/SO_q $ time python3 thecode.py
________________________________________________________
Executed in    5,88 secs
~/t/SO_q $ time python3 thecode.py
________________________________________________________
Executed in    5,90 secs
Executed in    5,36 secs
Executed in    5,39 secs
Executed in    5,35 secs
Executed in    5,36 secs
Executed in    5,77 secs
Executed in    6,10 secs
Executed in    5,38 secs

因此，Python 代码始终运行约 6 秒。
这比后续运行 Julia 代码慢 2 倍!但是，一旦启动 Python 解释器，您就会获得这种速度，而 Julia 将花时间编译代码并做……其他需要 4300 万内存分配的事情。但是 Julia 用糟糕的启动时间换取的是编译代码的性能(在这个例子中，Julia 比 Python 快 2 倍)。

如何让 Julia 运行得更快

Build a custom sysimage 。这对我来说看起来有点矫枉过正，除非你真的每次都需要重新启动 Julia 来运行你的代码。

只需从同一个 REPL 运行您的代码。最简单的变体是修改代码后到 include("your_code.jl")。这可能会导致奇怪的错误，因为环境将由以前运行的数据填充。

在 Pluto 中运行代码，这是一个笔记本，也保持实时 Julia session ，但在管理环境方面很聪明