Scipy 的优化与多处理不兼容？

Question

在尝试使用 Scipy 的优化算法来最小化在子进程中计算其值的函数时，我发现基于梯度的算法（到目前为止的盆地跳跃和 L-BFGS-B）在优化的第 562 行遇到以下错误.py：

grad[k] = (f(*((xk + d,) + args)) - f0) / d[k]

TypeError: 不支持的操作数类型 -: 'NoneType' 和 'NoneType'

下面是一个产生此错误的简单代码示例：

import multiprocessing as mp
from scipy.optimize import basinhopping

def runEnvironment(x):
    return x**2

def func(x):
    if __name__ == '__main__':
        print "x:",x
        pool = mp.Pool(processes=1)

        results=pool.apply(runEnvironment,(x,))
        pool.close()
        return results

x0=5    
ret=basinhopping(func, x0, niter=100, T=1.0, stepsize=0.1, minimizer_kwargs=None, take_step=None, accept_test=None, callback=None, interval=50, disp=False, niter_success=None)

请注意，如果删除了多处理组件，或者使用了非基于梯度的算法（如 COBYLA），则此代码运行良好。谁能想到发生这种情况的原因？

Answer 1

您的 if __name__ == '__main__': 成语位置不正确 - 以这种方式重新排列可以：

import multiprocessing as mp
from scipy.optimize import basinhopping

def runEnvironment(x):
    return x**2

def func(x):

    print "x:",x
    pool = mp.Pool(processes=1)

    results=pool.apply(runEnvironment,(x,))
    pool.close()
    return results

if __name__ == '__main__':
    x0=5
    ret=basinhopping(func, x0, niter=100, T=1.0, stepsize=0.1, minimizer_kwargs=None, take_step=None, accept_test=None, callback=None, interval=50, disp=False, niter_success=None)

Answer 2

创建许多小的mp.Pools 每个只有一个工人是低效的 过程。每次调用func 创建一个池也是低效的，因为 func 被多次调用。

相反，在程序开始时创建 一个 Pool，并将池传递给对 func 的每次调用：

if __name__ == '__main__':
    pool = mp.Pool()
    x0=5    
    ret = optimize.basinhopping(
        func, x0, niter=100, T=1.0, stepsize=0.1,
        minimizer_kwargs=dict(args=pool), 
        take_step=None, accept_test=None, callback=None,
        interval=50, disp=False, niter_success=None)
    pool.close()
    print(ret)

minimizer_kwargs=dict(args=pool) 告诉optimize.basinhopping 将pool 作为附加参数传递给func。

---

你也可以使用

logger = mp.log_to_stderr(logging.INFO)

获取显示函数在哪个进程中被调用的日志记录语句。例如，

import multiprocessing as mp
from scipy import optimize
import logging
logger = mp.log_to_stderr(logging.INFO)

def runEnvironment(x):
    logger.info('runEnvironment({}) called'.format(x))
    return x**2

def func(x, pool):
    logger.info('func({}) called'.format(x))
    results = pool.apply(runEnvironment,(x,))
    return results

if __name__ == '__main__':
    pool = mp.Pool()
    x0=5    
    ret = optimize.basinhopping(
        func, x0, niter=100, T=1.0, stepsize=0.1,
        minimizer_kwargs=dict(args=pool), 
        take_step=None, accept_test=None, callback=None,
        interval=50, disp=False, niter_success=None)
    pool.close()
    print(ret)

打印

[INFO/PoolWorker-1] child process calling self.run()
[INFO/PoolWorker-2] child process calling self.run()
[INFO/PoolWorker-3] child process calling self.run()
[INFO/PoolWorker-4] child process calling self.run()
[INFO/MainProcess] func([ 5.]) called
[INFO/PoolWorker-1] runEnvironment([ 5.]) called
[INFO/MainProcess] func([ 5.00000001]) called
[INFO/PoolWorker-2] runEnvironment([ 5.00000001]) called
[INFO/MainProcess] func([ 5.]) called
[INFO/PoolWorker-3] runEnvironment([ 5.]) called
[INFO/MainProcess] func([-5.]) called
[INFO/PoolWorker-4] runEnvironment([-5.]) called

这说明func总是被主进程调用，而 runEnvironment 由工作进程运行。

请注意，对func 的调用是按顺序进行的。从中获得任何好处 pool，每次调用 func，您都必须使用更多的处理器。