基于代理的模拟：性能问题：Python vs NetLogo & Repast答案

【问题标题】：agent-based simulation: performance issue: Python vs NetLogo & Repast基于代理的模拟：性能问题：Python vs NetLogo & Repast
【发布时间】：2011-06-21 19:26:00
【问题描述】：

我正在 Python 3 中复制一小部分 Sugarscape 代理模拟模型。我发现我的代码的性能比 NetLogo 慢约 3 倍。这可能是我的代码的问题，还是 Python 的固有限制？

显然，这只是代码的一部分，但这正是 Python 花费了三分之二的运行时间的地方。我希望如果我写了一些非常低效的东西，它可能会出现在这个片段中：

UP = (0, -1)
RIGHT = (1, 0)
DOWN = (0, 1)
LEFT = (-1, 0)
all_directions = [UP, DOWN, RIGHT, LEFT]
# point is just a tuple (x, y)
def look_around(self):
    max_sugar_point = self.point
    max_sugar = self.world.sugar_map[self.point].level
    min_range = 0

    random.shuffle(self.all_directions)
    for r in range(1, self.vision+1):
        for d in self.all_directions:
            p = ((self.point[0] + r * d[0]) % self.world.surface.length,
                (self.point[1] + r * d[1]) % self.world.surface.height)
            if self.world.occupied(p): # checks if p is in a lookup table (dict)
                continue
            if self.world.sugar_map[p].level > max_sugar:
                max_sugar = self.world.sugar_map[p].level
                max_sugar_point = p
    if max_sugar_point is not self.point:
        self.move(max_sugar_point)

大致相当于code in NetLogo（这个片段比上面的 Python 函数做了一点点）：

; -- The SugarScape growth and motion procedures. --
to M    ; Motion rule (page 25)
    locals [ps p v d]
    set ps (patches at-points neighborhood) with [count turtles-here = 0]
    if (count ps > 0) [
        set v psugar-of max-one-of ps [psugar]              ; v is max sugar w/in vision
        set ps ps with [psugar = v]                         ; ps is legal sites w/ v sugar
        set d distance min-one-of ps [distance myself]      ; d is min dist from me to ps agents
        set p random-one-of ps with [distance myself = d]   ; p is one of the min dist patches
        if (psugar >= v and includeMyPatch?) [set p patch-here]
        setxy pxcor-of p pycor-of p                         ; jump to p
        set sugar sugar + psugar-of p                       ; consume its sugar
        ask p [setpsugar 0]                                 ; .. setting its sugar to 0
    ]
    set sugar sugar - metabolism    ; eat sugar (metabolism)
    set age age + 1
end

在我的电脑上，Python 代码运行 1000 步需要 15.5 秒；在同一台笔记本电脑上，在浏览器中以 Java 运行的 NetLogo 模拟在不到 6 秒的时间内完成了 1000 步。

编辑：刚刚检查了 Repast，使用 Java 实现。它也与 5.4 秒的 NetLogo 大致相同。 Java 和 Python 之间的Recent comparisons 表明 Java 没有优势，所以我想应该怪我的代码？

编辑：我知道MASON 应该比 Repast 更快，但它最终仍然运行 Java。

【问题讨论】：

标签： python performance simulation netlogo agent-based-modeling

【解决方案1】：

这可能不会带来显着的加速，但您应该知道，与访问全局变量或属性相比，Python 中的局部变量要快得多。因此，您可以尝试将内部循环中使用的一些值分配给局部变量，如下所示：

def look_around(self):
    max_sugar_point = self.point
    max_sugar = self.world.sugar_map[self.point].level
    min_range = 0

    selfx = self.point[0]
    selfy = self.point[1]
    wlength = self.world.surface.length
    wheight = self.world.surface.height
    occupied = self.world.occupied
    sugar_map = self.world.sugar_map
    all_directions = self.all_directions

    random.shuffle(all_directions)
    for r in range(1, self.vision+1):
        for dx,dy in all_directions:
            p = ((selfx + r * dx) % wlength,
                (selfy + r * dy) % wheight)
            if occupied(p): # checks if p is in a lookup table (dict)
                continue
            if sugar_map[p].level > max_sugar:
                max_sugar = sugar_map[p].level
                max_sugar_point = p
    if max_sugar_point is not self.point:
        self.move(max_sugar_point)

Python 中的函数调用也有相对较高的开销（与 Java 相比），因此您可以尝试通过将 occupied 函数替换为直接字典查找来进一步优化。

您还应该看看psyco。它是 Python 的即时编译器，在某些情况下可以显着提高速度。但是，它还不支持 Python 3.x，因此您需要使用旧版本的 Python。

【讨论】：

不错。执行时间从 15.5 秒下降到 11.4 秒 (~26%)。为什么 Python 不会优化那些东西，至少当我为解释器指定 -O 选项时？？？
当我摆脱 occupied 函数时，进一步下降到 10.4 秒。
@ max：感谢您回信并提供您所经历的加速。

【解决方案2】：

我猜想neighborhood 在 NetLogo 中的实现方式与你的双循环不同。具体来说，我认为他们预先计算了一个邻域向量，例如

n = [ [0,1],[0,-1],[1,0],[-1,0]....]

（对于 vision=1,2,...，您需要一个不同的循环），然后在 n 上只使用一个循环，而不是像您正在做的那样使用嵌套循环。这消除了乘法的需要。

我认为这不会让您获得 3 倍的加速。

【讨论】：

我们需要在最高糖分中的一个随机点。在我的方法中，它是由单个shuffle 在循环前的方向上完成的。在 NetLogo 中，它是通过跟踪所有最佳点然后从列表中随机选择一个来完成的（我在 Python 中尝试过，但速度稍慢）。在您的方法中，我要么需要尝试再次跟踪多个最佳点，要么需要 shuffle 每个邻域向量（n shuffles 而不是一个）。我会试试的。
另外，由于我需要检查环面中的环绕，我需要预先计算每个点的邻域，或者继续使用% 操作。前者快几个百分点，后者慢得多。
从 netLogo 获取环绕世界行为的更快方法是将您的世界建模在一个 numpy 数组中，在 x 和 y 方向的两端都有额外的索引。如果相邻距离为 1，则数组索引将从 0 到 width+1，从 0 到 height+1。计算只需要在代表世界的索引子集内完成，然后可以从另一端的世界复制每个维度任一端的额外索引的补丁值。这避免了计算世界内部每个 python 等效 netLogo 补丁的百分比。

【解决方案3】：

这是一个老问题，但我建议您考虑使用 NumPy 来加快您的操作。使用逻辑组织（1、2、3 或 N 维网格）同质数据对象（所有整数或所有浮点数等）的字典和列表的地方在表示和访问为 Numpy 时将具有更少的开销数组。

http://numpy.org

【讨论】：

【解决方案4】：

这里是 NetLogo 和一个版本的 Repast 的相对最新的比较。我不一定会假设 Repast 更快。 NetLogo 似乎包含一些非常聪明的算法，可以弥补它的任何成本。 http://condor.depaul.edu/slytinen/abm/Lytinen-Railsback-EMCSR_2012-02-17.pdf

【讨论】：