Python n_jobs 用于大规模问题

Question

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

当我的数据规模较小时，它效果很好，但当我扩大数据规模时，多处理似乎不起作用。

怎么会这样？

附注:我使用 IPython

Answer 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] 头痛。

即使是最有前途的机器学习学习者，复杂性的 [TIME] 维度也会增长 O( N log( N ) )

<小时/>

所以， n_jobs 总是有很大帮助，

如果不使用 n_jobs ，您将不得不等待更长的时间，只需尝试使用 n_jobs = 1 和 n_jobs = -1 运行同样的问题。

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

<小时/>

结语:

好消息是，对于先进的 AI/ML 处理，当代技术可以提供基础设施，这些基础设施具有合理数量的 TB RAM，用于对抗 [PSPACE]/[EXPSPACE] 前线，同时高效利用数千个真正的CPU，这样就可以创造 n_jobs ——如果研究需要加上资金允许的话——多达数千个工作岗位!

是的，有数千个——因此，与不利用此类基础设施相比，人们可以更快地接收 scikit 结果(云不是这里的答案......_{(如果您需要，请随时给我留言)这样的高性能基础设施可以解决您的大规模问题，好吗？)})

(如果流程图的阿姆达尔定律 View 可能的加速确实对规模有意义)

<小时/>

图片不错，
但请参阅“闻烟味”的绝对数字
[小时] vs [分钟]:

>>> 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 和其他加速技巧，全局模型搜索和超参数优化管道仍然需要花费很多天才能稳健地达到最佳泛化模型的全局最小值。