Numpy、Python 多进程 (joblib)最佳参数传递方法

在本文中，我们将介绍如何使用 Numpy 和 Python 多进程 (joblib) 进行最佳的参数传递方法。

阅读更多：Numpy 教程

什么是 Numpy?

Numpy 是用于 Python 的一个专门用于科学计算的库。它允许在 Python 中进行快速操作和转换 N 维数组。

大多数数据科学家和机器学习工程师都使用 Numpy 来处理数据。Numpy 提供了几个强大的功能，例如：

N 维数组对象
矩阵数学操作 (线性代数、随机数生成等)
广播功能 (用于处理不同形状的数组)
易于接口的 C/C++/Fortran 代码库

什么是 Python 多进程 (joblib)?

Python 多进程 (joblib) 是一个用于在 Python 中运行大型并行计算的库。这种并行处理可以极大地提高代码的速度。joblib 实际上是 Scikit-Learn 的一部分，但它也可以单独使用，因为它具有几个强大的功能，例如：

能够将大型计算分解为小的块并在多个 CPU 核心上并行运行。
在分布式计算环境中可以很好地工作。
提供了一个易于使用的 API。

joblib 中提供了两种方法：一种是用于并行化 for 循环的 Parallel API，另一种是用于内存共享的 Memory API。

使用 Numpy 和 Python 多进程 (joblib) 进行最佳的参数传递方法

在我们深入探讨 Numpy 和 Python 多进程 (joblib) 如何进行最佳的参数传递方法之前，我们应该理解一下内存共享和对象复制的概念。

Python 共享内存不可变对象，这意味着当你修改一个变量时，Python 不会复制整个对象，而是只是修改它的指针。例如：

a = [1, 2, 3]
b = a
b += [4, 5, 6]
print(a)
# 输出 [1, 2, 3, 4, 5, 6]

这意味着如果我们在多个进程中传递相同的 Numpy 数组，Python 不会将整个数组复制过去。相反，它将传递一个指向数组相同部分的指针。这可以极大地减少内存占用。

另一方面，Python 在函数之间传递可变对象时会进行复制。这意味着如果您使用一个可变对象作为参数，在函数中修改参数时，您只是创建了该对象的副本。例如：

a = [1, 2, 3]
def append_a(l):
    l += [4, 5, 6]
append_a(a)
print(a)
# 输出 [1, 2, 3]

现在让我们来看一下如何在 Numpy 和 Python 多进程 (joblib) 中使用这些知识。

内存共享

如果您的 Numpy 数组不需要修改，那么您可以安全地共享内存。

例如，考虑下面这个示例：

import numpy as np
from joblib import Parallel, delayed

def square(x):
    return x ** 2

def calculate_squares(arr):
    # 不共享内存，每个进程都会复制 arr
    results = Parallel(n_jobs=-1)(delayed(square)(x) for x in arr)
    return results

def calculate_squares_shared(arr):
    # 共享内存
    shared_arr = np.array(arr)
    results = Parallel(n_jobs=-1)(delayed(square)(x) for x in shared_arr)
    return results

if __name____ == "__main__":
    arr = np.array([1, 2, 3, 4, 5])
    print(calculate_squares(arr))  # [1, 4, 9, 16, 25]
    print(calculate_squares_shared(arr))  # [1, 4, 9, 16, 25]

在上面的示例中，我们定义了两个函数 calculate_squares 和 calculate_squares_shared。首先，我们通过使用 Parallel 函数和 delayed 迭代器将 square 函数应用于每个数组元素。在 calculate_squares 函数中，我们在不共享内存的情况下运行上述操作。反之，在 calculate_squares_shared 函数中，我们将 arr 复制到 shared_arr 中，以在多个进程之间安全共享内存。

你可以尝试实验并测量内存占用和运行时间，发现共享内存的本质上是不显著的。

对象复制

如果您的 Numpy 数组需要修改，那么您需要使用对象复制来避免共享内存。并行处理期间共享内存时，由于因果关系（原因和结果顺序）不确定，很难预测循环中的每个各自的任务的时间，这很容易导致内存被锁住或意外的共享，这将导致无法预测的结果。

例如，考虑下面这个示例：

import numpy as np
from joblib import Parallel, delayed

def increment(x):
    x += 1
    return x

def increment_arr(arr):
    # 具有对象复制，每个进程都会复制 arr
    results = Parallel(n_jobs=-1)(delayed(increment)(x) for x in arr)
    return results

if __name__ == "__main__":
    arr = np.array([1, 2, 3, 4, 5])
    print(increment_arr(arr))  # [2, 3, 4, 5, 6]
    print(arr)  # [1, 2, 3, 4, 5]

在上面的示例中，我们定义了两个函数 increment 和 increment_arr。首先，我们使用 Parallel 函数和 delayed 迭代器将 increment 函数应用于每个数组元素。在 increment_arr 函数中，我们在每个进程中都使用对象复制，以避免共享内存。这是实现不同进程之间变量独立的一种方法。