向量化/并行化 GEKKO 方程

Question

使用 Phython 的 GEKKO 库并按照示例求解其原始论文中的波动方程，需要创建大量方程。

m.Equations([u[i].dt() == v[i]for i in range(npx)])
m.Equations([v[i].dt() == c**2*(u[mod(i+1,npx)]-2.0*u[mod(i,npx)]+u[mod(i-1,npx)])/dx**2 for i in arange(0,npx,1)])

（我已经通过mod将它减少到两行，结合边界条件并让我从 0 运行到 99，但它基本上仍然与示例中的相同。）

它仍在使用for循环，即v[i]for i in range(npx)] 。 是否可以像使用 numpy arrays 一样通过并行化/矢量化来避免这种情况，从而使代码更具可读性或模拟速度更快？

当然，对于这个问题，我的笔记本电脑上的计算只需要 <18s，但更大的问题可能会非常慢。

文档中有关于 arrays 的内容，但我不明白，我不知道这是否是我正在寻找的。

我附加了一个 MWE，在这里使用上面的代码。

Answer 1

如果您想提高速度，请尝试使用m.options.IMODE=7的顺序解决方案。 对于仿真，它通常比IMODE=4 （同时解）快得多。

from gekko import GEKKO
import numpy as np
import time
start = time.time()
pi = np.pi
#Initialise model
m = GEKKO(remote = False)
#Discretisations(time and space)
npt = 200; npx = 100
m.time = np.linspace(0, 1, npt)
xpos = np.linspace(0, 2*pi, npx)
dx = xpos[1]-xpos[0]
#Define Variables
c = m.Const(value = 10)
u = [m.Var(value = np.cos(xpos[i])) for i in range(npx)]
v = [m.Var(value = np.sin(2*xpos[i])) for i in range(npx)]
#Automatic discretisation in time and manual discretisation in space
m.Equations([u[i].dt() == v[i] for i in range(npx)])
m.Equations([v[i].dt() == c**2*(u[np.mod(i+1,npx)]-2.0*u[np.mod(i,npx)]\
                                 +u[np.mod(i-1,npx)])/dx**2 \
                          for i in np.arange(0,npx,1)])

#Set options
m.options.imode = 7
m.options.solver = 1
m.options.nodes = 3
m.solve(disp = False, GUI = False)
print('Solve Time: ' + str(m.options.SOLVETIME))
print('Total Time: ' + str(time.time()-start))

使用IMODE=4 ，设置问题需要更多时间，但解决问题需要更少时间。

Solve Time: 2.7666
Total Time: 25.547

使用IMODE=7 ，设置问题所需的时间更少，但解决问题的时间更多。

Solve Time: 8.2271
Total Time: 11.819

当您遇到更大的问题时， IMODE=7将比IMODE=4花费更少的时间进行仿真。 对于并行选项，您可以并行构建 model 但该 model 的解决方案除了IMODE=7之外没有很多选项可以更快地解决问题。 您可以通过以下方式创建并行 Gekko 应用程序：

• 在 IPOPT 中与 ma77、ma97 等一起使用并行线性求解器。 与我对大规模问题所做的一些测试相比，这通常只提高了 20-60% 的速度。 这些选项在公开分发的 IPOPT 版本中不可用，因为求解器需要许可证。 线性求解器 MUMPS 与 Gekko 一起分发，但不包括并行支持（尽管这可能会在以后推出）。 问题是求解器只是解决方案的一部分，即使求解器速度无限快，自动微分、客观评估和方程评估仍然需要大约 50% 的 CPU 时间。

• 独立运行。 这通常被称为“大规模并行”，因为可以将进程拆分为单独的线程，然后在所有子进程完成后再次组合代码。 这份关于多线程和如何并行处理 Python Gekko 的说明材料？ 展示如何并行计算。 您的问题不是针对多线程设置的，因为方程是一起求解的。