Question

我有一个代码，我设法成功，感谢this question：

 1| def function(name, params):
 2|   results = fits.open(name)
 3|    <do something more to results>
 4|    return results
 5|
 6| def function_wrapper(args):
 7|     return function(*args)
 8| 
 9| params = [...,...,..., etc]    
10|
11| p = multiprocessing..Pool(processes=(max([2, mproc.cpu_count() // 10])))
12| args_generator = ((name, params) for name in names)
13| 
14| dictionary = dict(zip(names, p.map(function_wrapper, args_generator)))

如果我正确理解pool的工作原理，则行 11 中指定的进程数应该是在给定时间生成的最大进程数。因此，这应该限制我的CPU使用率，对吗？我的意思是，我理解它的方式，如第11行所示，所使用的最大进程数/ CPU数应该是[2, number_of_cpus / 10]的最大值。

尽管如此，当我运行我的代码时，我发现在我启动后不久，所有CPU都达到了100％。我错过了什么吗？

注意：对于上下文，我需要将CPU使用率限制为最大核心数，因为我将使用共享服务器。

更新：添加我的代码的修剪版本。我没有打开fits文件，而是创建了一个类似于我的频谱的嘈杂高斯曲线（尽管表现得更好......）。

削减它有助于解决问题。在函数fnBootstrapInstance内，拟合在2-D阵列（基本上是echelles谱）上进行，我使用for loop进行迭代。出于某种原因，删除循环，解决问题，并且仅使用我指定的核心数。我的猜测是，由于某种原因，for循环产生了一系列子过程（就像它出现在htop上的那样）。一次迭代一次ecehelles光谱就解决了这个问题。

# Imports
#%matplotlib inline
import sys
import numpy as np
import matplotlib.pyplot as mplt
import numpy.random as rnd
import scipy.optimize as opt
import multiprocessing as mproc

# Functions ==================================================
def fnBootstrapInstance(XXX = None, YYY= None, function= None, lenght=None, fitBounds= None, initParams=None, **kwargs):

    # define samples
    indexes = sorted(rnd.choice(range(len(XXX)), size=lenght, replace=True))
    samplesXXX = XXX[indexes]
    samplesYYY = YYY[indexes]

    fitBounds = ([-np.inf,-np.inf,0,-np.inf],[np.inf,np.inf,np.inf,np.inf])

    params, cov = opt.curve_fit(function, samplesXXX.ravel(), samplesYYY.ravel(), p0=initParams,
                                bounds = fitBounds,
                                )

    return params

def wrapper_fnBootstrapInstance(args):
    return fnBootstrapInstance(**args)

def fnGaussian(dataXXX, Amp, mean, FWHM, B):
    return B - Amp * np.exp(-4 * np.log(2) * (((dataXXX - mean) / FWHM) ** 2))
# Functions ==================================================


# Noise Parameters
arrLen = 1000
noiseAmp = 0.
noiseSTD = .25

# Gaussian Data Parameters
amp = 1.
mean = 10
FWHM = 30.
B = 1.

# generate random gauss data
arrGaussXXX = np.linspace(-50, 60,num = arrLen)
arrGaussNoise = rnd.normal(noiseAmp,noiseSTD, arrLen)
arrGaussYYY = fnGaussian(arrGaussXXX, amp, mean, FWHM, B) + arrGaussNoise

# multiprocessing bit
numIterations = 1000

mprocPool = mproc.Pool(processes=(max([2, mproc.cpu_count() // 10])))

initParams = [max(arrGaussYYY) - min(arrGaussYYY), np.median(arrGaussXXX),
                        max(arrGaussXXX) - min(arrGaussXXX), max(arrGaussYYY)]

args_generator = [{'XXX':arrGaussXXX, 'YYY':arrGaussYYY, 'function':fnGaussian, 'initParams':initParams,
                    'lenght':200} for n in range(numIterations)]

fitParams = []
for results in  mprocPool.imap(wrapper_fnBootstrapInstance, args_generator):
    fitParams.append([results[0],results[1],results[2],results[3]])



bootParams = [(np.nanmedian(param),np.nanstd(param)) for param in np.array(fitParams).T]
print '\n'.join('{:.2f}+-{:.2f} ({:.1f}%)'.format(param[0],param[1], param[1]/param[0]*100) for param in bootParams)

mplt.figure(figsize=(20,10))
mplt.plot(arrGaussXXX, arrGaussYYY,'+')  
for params in fitParams: 
    mplt.plot(arrGaussXXX,fnGaussian(arrGaussXXX,*params),'r', alpha = .5) 
mplt.show()


mprocPool.close()

全部谢谢！

Answer 1

考虑使用multiprocessing.pool.ThreadPool。它提供与multiprocessing.Pool相同的API，但将工作负载抽象为线程集合。请注意，如果您的CPU支持超线程，那么它很可能会将工作负载分配到物理内核上。

多处理 - 限制CPU使用率

1 个答案: