Python n_jobs用于大规模概率

时间:2017-08-08 07:54:58

标签: python scikit-learn multiprocessing

当我在 n_jobs 中使用参数cross_val_score()时。

当我的数据比例很小时,它运作良好,但随着我放大数据的比例,multiprocessing似乎不起作用。

怎么会这样?

P.S。:我使用IPython

1 个答案:

答案 0 :(得分:1)

n_jobs完成工作并提供帮助

鉴于您的“小规模”multiprocessing经验令人满意,n_jobs没有理由停止加速更大规模的实际处理。

机器学习处理流水线在很多情况下表现出 O(N f 多项式复杂度,其中 N 是观察数据集(X)和 f 在各种论文中被引用,用于不少于〜(2+)的各种学习算法。

随着数据集大小的增加,计算时间会以多项式扩展。 尽管n_jobs帮助可以(在大多数乐观情况下)通过不超过 1 / { 2, 3, 4, .., 8, .., <max_cpu_cores> }
的常数因子来减少这种增长(并且然而由于Amdahl's Law(参见下图),这个常数因子进一步显着减少,这取决于在n_jobs v / s上并行运行的工作量有多少尚未完成无论已经启动和运行多少个工作,仍然只是连续执行。调整O / S流程优先级确实有所帮助,但是大N - s仍然会增长很多,因此时间就是金钱适用的越多这里)。

一些额外的不利影响来自需要分配复制的数据结构,因此[PSPACE]增加了已经痛苦的[PTIME]头痛。

即使是最有前途的ML学习者也会在复杂性的[时间]维度上增长 O(N log(N))

因此, n_jobs 总能帮助很多,

如果不使用 n_jobs ,您必须等待更长时间,只需尝试使用n_jobs = 1 n_jobs = -1来运行相同的问题

无论如何,请继续关注。 AI / ML-domain充满了 [* TIME,* SPACE] ,其中 * 不仅是多项式的,正如您目前所经历的那样,但很多倍指数,所以准备好与龙战斗:o)

尾声:

好消息是,对于高级AI / ML处理,现代技术可以提供基础设施,具有合理数量的TB RAM,用于对抗[PSPACE] / [EXPSPACE]战斗前线,同时有效地利用数以千计的真实CPU,因此可以使 n_jobs - 如果研究需要加上融资允许 - 最多可以获得数千个工作!

是的,成千上万 - 所以人们可以比没有利用这样的基础设施更快地获得scikit结果(并且云不是这里的答案...... (不要犹豫要不要给我一个请注意,如果你需要为大规模问题启动和运行这样的高性能基础设施,好吗?)

(如果Amdahl Law-the process of the process-graph 可能的加速确实有意义扩展) enter image description here

图片很好,但是看到“SMELL THE SMOKE”的绝对数字
[hr] v / s [min]:

>>> procPAR_SEQ_percent = 1.00
                         #100 % PAR:

                       n_jobs:    Speedup x|       [hr] =          [s] =        [min]
-----------------------------:-------------|------------=--------------=-------------
                            1:   1.000000 x| 3.000 [hr] = 10800.00 [s] = 180.00 [min]
                            2:   1.999985 x| 1.500 [hr] =  5400.04 [s] =  90.00 [min]
                            4:   3.999941 x| 0.750 [hr] =  2700.04 [s] =  45.00 [min]
                            8:   7.999763 x| 0.375 [hr] =  1350.04 [s] =  22.50 [min]
                           16:  15.999052 x| 0.188 [hr] =   675.04 [s] =  11.25 [min]
                           32:  31.996208 x| 0.094 [hr] =   337.54 [s] =   5.63 [min]
                           64:  63.984833 x| 0.047 [hr] =   168.79 [s] =   2.81 [min]
                          128: 127.939347 x| 0.023 [hr] =    84.42 [s] =   1.41 [min]
                          256: 255.757504 x| 0.012 [hr] =    42.23 [s] =   0.70 [min]
                          512: 511.030934 x| 0.006 [hr] =    21.13 [s] =   0.35 [min]
                         1024: 996.309963 x| 0.003 [hr] =    10.84 [s] =   0.18 [min]
                         2048: 996.309963 x| 0.003 [hr] =    10.84 [s] =   0.18 [min]
                         4096: 996.309963 x| 0.003 [hr] =    10.84 [s] =   0.18 [min]
                         8192: 996.309963 x| 0.003 [hr] =    10.84 [s] =   0.18 [min]

>>> procPAR_SEQ_percent = 0.99
                          # 99 % PAR:


                       n_jobs:   Speedup x|       [hr] =          [s] =        [min]
-----------------------------:------------|------------=--------------=-------------
                            1:  1.000000 x| 3.000 [hr] = 10800.00 [s] = 180.00 [min]
                            2:  1.980183 x| 1.530 [hr] =  5507.50 [s] =  91.79 [min]
                            4:  3.883439 x| 0.795 [hr] =  2861.23 [s] =  47.69 [min]
                            8:  7.476428 x| 0.427 [hr] =  1538.09 [s] =  25.63 [min]
                           16: 13.912327 x| 0.243 [hr] =   876.53 [s] =  14.61 [min]
                           32: 24.425271 x| 0.152 [hr] =   545.74 [s] =   9.10 [min]
                           64: 39.258095 x| 0.106 [hr] =   380.35 [s] =   6.34 [min]
                          128: 56.375891 x| 0.083 [hr] =   297.66 [s] =   4.96 [min]
                          256: 72.093421 x| 0.071 [hr] =   256.31 [s] =   4.27 [min]
                          512: 83.771055 x| 0.065 [hr] =   235.63 [s] =   3.93 [min]
                         1024: 90.961156 x| 0.063 [hr] =   225.54 [s] =   3.76 [min]
                         2048: 90.961156 x| 0.063 [hr] =   225.54 [s] =   3.76 [min]
                         4096: 90.961156 x| 0.063 [hr] =   225.54 [s] =   3.76 [min]
                         8192: 90.961156 x| 0.063 [hr] =   225.54 [s] =   3.76 [min]

 >>> procPAR_SEQ_percent = 0.98
                           # 98 % PAR:


                       n_jobs:   Speedup x|       [hr] =          [s] =        [min]
-----------------------------:------------|------------=--------------=-------------
                            1:  1.000000 x| 3.000 [hr] = 10800.00 [s] = 180.00 [min]
                            2:  1.960770 x| 1.559 [hr] =  5613.88 [s] =  93.56 [min]
                            4:  3.773532 x| 0.839 [hr] =  3020.80 [s] =  50.35 [min]
                            8:  7.017361 x| 0.479 [hr] =  1724.26 [s] =  28.74 [min]
                           16: 12.307131 x| 0.299 [hr] =  1075.99 [s] =  17.93 [min]
                           32: 19.751641 x| 0.209 [hr] =   751.85 [s] =  12.53 [min]
                           64: 28.315614 x| 0.164 [hr] =   589.79 [s] =   9.83 [min]
                          128: 36.153350 x| 0.141 [hr] =   508.75 [s] =   8.48 [min]
                          256: 41.960691 x| 0.130 [hr] =   468.24 [s] =   7.80 [min]
                          512: 45.625087 x| 0.124 [hr] =   447.98 [s] =   7.47 [min]
                         1024: 47.656029 x| 0.122 [hr] =   438.09 [s] =   7.30 [min]
                         2048: 47.656029 x| 0.122 [hr] =   438.09 [s] =   7.30 [min]
                         4096: 47.656029 x| 0.122 [hr] =   438.09 [s] =   7.30 [min]
                         8192: 47.656029 x| 0.122 [hr] =   438.09 [s] =   7.30 [min]

最后但并非最不重要的是,我从标准python运行所有AI / ML引擎,从未在生产中运行iPython。利用n_jobs = -1和其他加速技巧,全局模型搜索和超参数优化管道仍然可以跨越很多天,以便能够有效地实现最佳通用模型的全局最小化。