python - 与Joblib并行训练sklearn模型会阻止该过程

Question

如this answer中的建议，我尝试使用joblib并行训练多个scikit-learn模型。

import joblib
import numpy
from sklearn import tree, linear_model

classifierParams = {
                "Decision Tree": (tree.DecisionTreeClassifier, {}),''
                "Logistic Regression" : (linear_model.LogisticRegression, {})
}


XTrain = numpy.array([[1,2,3],[4,5,6]])
yTrain = numpy.array([0, 1])

def trainModel(name, clazz, params, XTrain, yTrain):
    print("training ", name)
    model = clazz(**params)
    model.fit(XTrain, yTrain)
    return model


joblib.Parallel(n_jobs=4)(joblib.delayed(trainModel)(name, clazz, params, XTrain, yTrain) for (name, (clazz, params)) in classifierParams.items())

但是，对最后一行的调用会花费很多时间，而没有使用CPU，实际上，它似乎只是阻塞并且从不返回任何内容。我怎么了

在 XTrain中使用非常少量的数据进行的测试表明，跨多个进程复制numpy数组并不是造成延迟的原因。

Answer 1

生产级机器学习管道的CPU使用率更像这样，几乎为24/7/365：



检查该节点上的CPU%以及其他资源的状态图。



我怎么了

主席先生，读完您的个人资料真是令人震惊的时刻：


  _{I am a computer scientist specializing on algorithms and data analysis by training, and a generalist by nature. My skill set combines a strong scientific background with experience in software architecture and development, especially on solutions for the analysis of big data. I offer consulting and development services and I am looking for challenging projects in the area of data science.}


该问题由对基本计算机科学+算法规则的尊重来深层次确定。

问题不是需要强大的科学背景，而是常识。

问题不是特别重要的大数据，而是需要了解事物的实际运行方式。





情感因素？ ... 这就是问题所在！ （丹麦王子哈姆雷特的悲剧）



我可以诚实吗？让我们更喜欢事实，总是：

步骤1：
不要雇用或解雇不尊重事实的每位顾问（上面提到的答案没有提出任何建议，更不要答应了）。在PR / MARCOM /广告/媒体业务中忽略事实可能是“成功的罪过”（以防客户容忍这种不诚实和/或操纵性的习惯），但在科学上合理的定量范围内则不然。这是不可原谅的。

第2步：
切勿雇用或声称拥有软件体系结构经验的每位顾问，特别是在...大数据解决方案方面，但对将由其引入的所有附加间接费用的累积总付不加关注。一旦处理开始分布在某个硬件和软件资源池中，系统体系结构的各个元素便会相应分布。这是不可原谅的。

步骤3：
切勿雇用或解雇每位顾问，一旦事实不符合她/他的意愿，他们就会变得被动进取，并开始指责已经提供帮助的其他知识渊博的人宁可“提高（他们的）沟通技巧”而不是学习来自错误。当然，技巧可能会以其他方式帮助表达明显的错误，但是，巨大的错误仍将是巨大的错误，每位科学家（对她/他的科学头衔都是公平的）应该永远不要诉诸于帮助同事的攻击，但是而是开始寻找错误的根本原因，一个接一个。这个 - -


  @sascha ... May I suggest you take little a break from stackoverflow to cool off, work a little on your interpersonal communication skills


---只是对@sascha的直截了当且在理论上令人无法接受的犯规。



接下来，玩具重要的体系结构，资源和流程调度事实：

语法构造函数的命令式形式引发了大量的活动以开始：

joblib.Parallel( n_jobs = <N> )( joblib.delayed( <aFunction> )
                                               ( <anOrderedSetOfFunParameters> )
                                           for ( <anOrderedSetOfIteratorParams> )
                                           in    <anIterator>
                                 )

至少要猜测会发生什么，一种科学合理的方法是测试几个代表性的案例，对它们的实际执行进行基准测试，收集定量支持的事实，并对行为模型及其对CPU_core-count，RAM大小的主要依赖关系进行假设， <aFunction>-复杂性和资源分配信封等。

测试案例A：

def a_NOP_FUN( aNeverConsumedPAR ):
    """                                                 __doc__
    The intent of this FUN() is indeed to do nothing at all,
                             so as to be able to benchmark
                             all the process-instantiation
                             add-on overhead costs.
    """
    pass

##############################################################
###  A NAIVE TEST BENCH
##############################################################
from zmq import Stopwatch; aClk = Stopwatch()
JOBS_TO_SPAWN =  4         # TUNE:  1,  2,  4,   5,  10, ..
RUNS_TO_RUN   = 10         # TUNE: 10, 20, 50, 100, 200, 500, 1000, ..
try:
     aClk.start()
     joblib.Parallel(  n_jobs = JOBS_TO_SPAWN
                      )( joblib.delayed( a_NOP_FUN )
                                       ( aSoFunPAR )
                                   for ( aSoFunPAR )
                                   in  range( RUNS_TO_RUN )
                         )
except:
     pass
finally:
     try:
         _ = aClk.stop()
     except:
         _ = -1
         pass
print( "CLK:: {0:_>24d} [us] @{1: >3d} run{2: >5d} RUNS".format( _,
                                                                 JOBS_TO_SPAWN,
                                                                 RUNS_TO_RUN
                                                                 )
        )

在合理缩放的 [ RUNS_TO_RUN, JOBS_TO_SPAWN]-笛卡尔空间DataPoint的2D地形上，在此NOP情况下收集了足够有代表性的数据，以便至少对启动实际本质上是空的，与命令式 joblib.Parallel(...)( joblib.delayed(...) )语法构造函数相关的进程的开销工作负载，仅由几个 joblib管理的 a_NOP_FUN()实例产生到系统调度程序中。

我们还同意，所有实际问题（包括机器学习模型）都是更复杂的工具，与刚刚测试的 a_NOP_FUN()相比，而在两种情况下，您都必须支付已经基准化的间接费用（即使已支付）以获得字面上为零的产品）。

因此，在这种最简单的情况下，将进行科学合理，严谨的工作，已经显示了所有相关设置开销的基准成本，这是有史以来最小的 joblib.Parallel()惩罚正弦准非正向一个实际算法运行的方向-最好，接下来在测试循环中添加一些越来越大的“有效载荷”大小：

测试案例B：

def a_NOP_FUN_WITH_JUST_A_MEM_ALLOCATOR( aNeverConsumedPAR ):
    """                                                 __doc__
    The intent of this FUN() is to do nothing but
                             a MEM-allocation
                             so as to be able to benchmark
                             all the process-instantiation
                             add-on overhead costs.
    """
    import numpy as np              # yes, deferred import, libs do defer imports
    SIZE1D    = 1000                # here, feel free to be as keen as needed
    aMemALLOC = np.zeros( ( SIZE1D, #       so as to set
                            SIZE1D, #       realistic ceilings
                            SIZE1D, #       as how big the "Big Data"
                            SIZE1D  #       may indeed grow into
                            ),
                          dtype = np.float64,
                          order = 'F'
                          )         # .ALLOC + .SET
    aMemALLOC[2,3,4,5] = 8.7654321  # .SET
    aMemALLOC[3,3,4,5] = 1.2345678  # .SET

    return aMemALLOC[2:3,3,4,5]

再次，
通过在 a_NOP_FUN_WITH_JUST_A_MEM_ALLOCATOR()规模的合理范围内运行 SIZE1D，收集有关实际远程过程MEM分配成本的足够有代表性的定量数据，
再次
在 [ RUNS_TO_RUN, JOBS_TO_SPAWN]-笛卡尔空间DataPoints的合理缩放的2D地形上，以便在性能扩展中触及新的维度，这是在 joblib.Parallel()工具内扩展的黑盒PROCESS_under_TEST实验下进行的，但其魔力尚未得到解决-打开。

测试用例C：

def a_NOP_FUN_WITH_SOME_MEM_DATAFLOW( aNeverConsumedPAR ):
    """                                                 __doc__
    The intent of this FUN() is to do nothing but
                             a MEM-allocation plus some Data MOVs
                             so as to be able to benchmark
                             all the process-instantiation + MEM OPs
                             add-on overhead costs.
    """
    import numpy as np              # yes, deferred import, libs do defer imports
    SIZE1D    = 1000                # here, feel free to be as keen as needed
    aMemALLOC = np.ones(  ( SIZE1D, #       so as to set
                            SIZE1D, #       realistic ceilings
                            SIZE1D, #       as how big the "Big Data"
                            SIZE1D  #       may indeed grow into
                            ),
                          dtype = np.float64,
                          order = 'F'
                          )         # .ALLOC + .SET
    aMemALLOC[2,3,4,5] = 8.7654321  # .SET
    aMemALLOC[3,3,4,5] = 1.2345678  # .SET

    aMemALLOC[:,:,:,:]*= 0.1234567
    aMemALLOC[:,3,4,:]+= aMemALLOC[4,5,:,:]
    aMemALLOC[2,:,4,:]+= aMemALLOC[:,5,6,:]
    aMemALLOC[3,3,:,:]+= aMemALLOC[:,:,6,7]
    aMemALLOC[:,3,:,5]+= aMemALLOC[4,:,:,7]

    return aMemALLOC[2:3,3,4,5]

Bang，与架构有关的问题开始慢慢显现出来：

可能很快就会注意到，不仅静态大小问题，而且MEM-transport BANDWIDTH（硬件-硬接线）都将开始引起问题，因为将数据从CPU转移到CPU或从MEM转移数据的成本很低 ~ 100 .. 300 [ns]比“ CPU_core”内部的几个字节的任何智能改组要多得多。 CPU_core_shared |单独使用CPU_die_shared} -cache层次结构（以及任何非本地NUMA传输都表现出相同数量级的附加痛苦）。



以上所有测试案例都没有要求CPU付出很多努力

因此，让我们开始燃烧油！

如果上面的所有方法都适合开始闻到引擎盖下的东西实际上是如何工作的，那么它将变得丑陋和肮脏。

测试案例D：

def a_CPU_1_CORE_BURNER_FUN( aNeverConsumedPAR ):
    """                                                 __doc__
    The intent of this FUN() is to do nothing but
                             add some CPU-load
                             to a MEM-allocation plus some Data MOVs
                             so as to be able to benchmark
                             all the process-instantiation + MEM OPs
                             add-on overhead costs.
    """
    import numpy as np              # yes, deferred import, libs do defer imports
    SIZE1D    = 1000                # here, feel free to be as keen as needed
    aMemALLOC = np.ones(  ( SIZE1D, #       so as to set
                            SIZE1D, #       realistic ceilings
                            SIZE1D, #       as how big the "Big Data"
                            SIZE1D  #       may indeed grow into
                            ),
                          dtype = np.float64,
                          order = 'F'
                          )         # .ALLOC + .SET
    aMemALLOC[2,3,4,5] = 8.7654321  # .SET
    aMemALLOC[3,3,4,5] = 1.2345678  # .SET

    aMemALLOC[:,:,:,:]*= 0.1234567
    aMemALLOC[:,3,4,:]+= aMemALLOC[4,5,:,:]
    aMemALLOC[2,:,4,:]+= aMemALLOC[:,5,6,:]
    aMemALLOC[3,3,:,:]+= aMemALLOC[:,:,6,7]
    aMemALLOC[:,3,:,5]+= aMemALLOC[4,:,:,7]

    aMemALLOC[:,:,:,:]+= int( [ np.math.factorial( x + aMemALLOC[-1,-1,-1] )
                                               for x in range( 1005 )
                                ][-1]
                            / [ np.math.factorial( y + aMemALLOC[ 1, 1, 1] )
                                               for y in range( 1000 )
                                ][-1]
                              )

    return aMemALLOC[2:3,3,4,5]

与机器学习的多维空间领域中有效载荷的普通等级相比，这仍然不是什么特别的事情，在这种情况下， { aMlModelSPACE, aSetOfHyperParameterSPACE, aDataSET }状态空间的所有维度都会影响所需处理的范围（有些具有 O( N )，其他一些 O( N.logN )复杂性），几乎可以立即完成，即使在一个“作业”运行中，经过精心设计的多个CPU_core很快也得到了利用。

一旦出现幼稚的（读取资源-使用不协调的）CPU负载混合物，并且当与任务相关的CPU负载的混合开始与幼稚的混合时，就会发出一种确实令人讨厌的气味。 ）O / S调度程序进程争用公共资源（仅靠一种朴素的共享使用策略），即MEM（将SWAP引入为HELL），CPU（引入高速缓存未命中和MEM重新获取（是的，对于SWAP））加上罚款），而不是说要支付比 ~ 15+ [ms]延迟费更多的钱，如果有人忘记让进程触摸 fileIO-（5（！）-数量级慢+共享+被一个纯自然的 [SERIAL]设备。这里没有祈祷的帮助（包括SSD，仅少了几个数量级，但仍然难以共享并快速运行并磨损它的设备）。



如果所有产生的进程都不适合物理RAM，会发生什么情况？

虚拟内存分页和交换实际上从某种意义上开始恶化了到目前为止的其余部分，“巧合”（读：弱协调）- [CONCURRENTLY]调度处理（读：进一步降低了单个PROCESS-under -TEST性能）。



如果没有适当的控制和监督，事情可能很快就会遭受破坏。

再次-事实很重要：轻量级的资源监控器类可能会帮助：

aResRECORDER.show_usage_since0() method returns:

ResCONSUMED[T0+   166036.311 (           0.000000)]
user=               2475.15
nice=                  0.36
iowait=                0.29
irq=                   0.00
softirq=               8.32
stolen_from_VM=       26.95
guest_VM_served=       0.00

类似地，构造更丰富的资源监视器可能会报告更广泛的O / S上下文，以查看其他资源窃取/争用/竞争条件在哪里恶化了实际实现的流程：

>>> psutil.Process( os.getpid()
                    ).memory_full_info()
                                      ( rss          =       9428992,
                                        vms          =     158584832,
                                        shared       =       3297280,
                                        text         =       2322432,
                                        lib          =             0,
                                        data         =       5877760,
                                        dirty        =             0
                                        )
           .virtual_memory()
                          (             total        =   25111490560,
                                        available    =   24661327872,
                                        percent      =             1.8,
                                        used         =    1569603584,
                                        free         =   23541886976,
                                        active       =     579739648,
                                        inactive     =     588615680,
                                        buffers      =             0,
                                        cached       =    1119440896
                                        )
           .swap_memory()
                       (                total        =    8455712768,
                                        used         =     967577600,
                                        free         =    7488135168,
                                        percent      =            11.4,
                                        sin          =  500625227776,
                                        sout         =  370585448448
                                        )

Wed Oct 19 03:26:06 2017
        166.445 ___VMS______________Virtual Memory Size  MB
         10.406 ___RES____Resident Set Size non-swapped  MB
          2.215 ___TRS________Code in Text Resident Set  MB
         14.738 ___DRS________________Data Resident Set  MB
          3.305 ___SHR_______________Potentially Shared  MB
          0.000 ___LIB_______________Shared Memory Size  MB
                __________________Number of dirty pages           0x

最后但并非最不重要的一点，为什么人们可以轻易付出比赚取更多的回报？

除了逐步建立的证据记录之外，实际的系统部署附加开销是如何累积成本的， recently re-formulated Amdahl's Law, extended so as to cover both the add-on overhead-costs plus the "process-atomicity" of the further indivisible parts' sizing, defines最大附加成本阈值，如果某些分布式处理要提供任何费用，则可以合理地支付高于 >= 1.00计算过程速度。

违反重新制定的《阿姆达尔定律》的明确逻辑会导致流程进行得比纯流程安排的流程差（有时，不良的设计和/或操作实践的结果可能看起来像是如果是这种情况，则 [SERIAL]方法“阻止该进程”）。