R:如何在Linux服务器上使用ParallelMAP(使用MLR，XGBoost)?与Windows相比，意外的性能

Question

我试图在调谐的超参数级别并行化一个我正在mlr中调整的xgboost模型，并试图与parallelMap并行化。我有在Windows机器(只有8个内核(上成功使用的代码，并希望使用Linux服务器(带有72个内核(。我无法成功地获得任何计算优势转移到服务器，我认为这是我对ParallelMap参数的理解的结果。

我不理解并行模式中的多核与本地与插座的差异。根据我的阅读，我认为Multicore适合我的情况，但我不确定。我在Windows机器上成功使用了套接字，并且在Linux服务器上尝试了套接字和多功能，结果不成功。

parallelStart(mode="socket", cpu=8, level="mlr.tuneParams")

但我的理解是，插座可能是不必要的，或者可能会使许多不需要彼此通信的内核并行，就像平行的超参数调谐一样。

为了详细说明我在Linux服务器上的不成功结果：我没有遇到错误，但是串行24小时的序列需要24个小时的时间才能并行2周。查看过程，我可以看到我确实在使用几个内核。

每个单独的呼叫XGBoost在几分钟内运行，我并没有试图加快速度。我只是想在几个内核上调整超级固定器。

我担心我在Linux服务器上的结果也许是由于XGBoost在模型构建中使用可用的内核的尝试，因此我通过MLR将nthread = 1喂入XGBoost，以确保不会发生这种情况。尽管如此，我的代码在较大的Linux服务器上的运行似乎比在较小的Windows计算机上慢得多 - 关于可能发生的事情的任何想法？

非常感谢。

xgb_learner_tune <- makeLearner(
  "classif.xgboost",
  predict.type = "response",
  par.vals = list(
    objective = "binary:logistic",
    eval_metric = "map",
    nthread=1))
library(parallelMap)
parallelStart(mode="multicore", cpu=8, level="mlr.tuneParams")
tuned_params_trim <- tuneParams(
  learner = xgb_learner_tune,
  task = trainTask,
  resampling = resample_desc,
  par.set = xgb_params,
  control = control,
  measures = list(ppv, tpr, tnr, mmce)
)
parallelStop()

编辑

我仍然因为缺乏在调音级别并行化的性能提高而感到惊讶。我的期望不公平吗？我的parallelMap性能比在以下过程中的序列上的调整要慢：

numeric_ps = makeParamSet(
  makeNumericParam("C", lower = 0.5, upper = 2.0),
  makeNumericParam("sigma", lower = 0.5, upper = 2.0)
)
ctrl = makeTuneControlRandom(maxit=1024L)
rdesc = makeResampleDesc("CV", iters = 3L)
#In serial
start.time.serial <- Sys.time()
res.serial = tuneParams("classif.ksvm", task = iris.task, resampling = rdesc,
                 par.set = numeric_ps, control = ctrl)
stop.time.serial <- Sys.time()
stop.time.serial - start.time.serial
#In parallel with 2 CPUs
start.time.parallel.2 <- Sys.time()
parallelStart(mode="multicore", cpu=2, level="mlr.tuneParams")
res.parallel.2 = tuneParams("classif.ksvm", task = iris.task, resampling = rdesc,
                 par.set = numeric_ps, control = ctrl)
parallelStop()
stop.time.parallel.2 <- Sys.time()
stop.time.parallel.2 - start.time.parallel.2
#In parallel with 16 CPUs
start.time.parallel.16 <- Sys.time()
parallelStart(mode="multicore", cpu=16, level="mlr.tuneParams")
res.parallel.16 = tuneParams("classif.ksvm", task = iris.task, resampling = rdesc,
                          par.set = numeric_ps, control = ctrl)
parallelStop()
stop.time.parallel.16 <- Sys.time()
stop.time.parallel.16 - start.time.parallel.16 

我的控制台输出是(省略了调整详细信息(：

> stop.time.serial - start.time.serial
Time difference of 33.0646 secs
> stop.time.parallel - start.time.parallel
Time difference of 2.49616 mins
> stop.time.parallel.16 - start.time.parallel.16
Time difference of 2.533662 mins

我会期望事情并行更快。对于此示例来说这是不合理的吗？如果是这样，我应该什么时候期望并行提高绩效？

看终端，我似乎确实在使用2(和16(个线程/过程(如果我的术语不正确，则表示歉意(。

非常感谢您的进一步输入。

Answer 1

这个问题更多是关于猜测设置中的问题，而不是实际提供"真实"答案。也许您也可以更改标题，因为您没有获得"意外结果"。

一些要点：

• nthread = 1已经是mlr中xgboost的默认值
• multicore是Unix Systems上的首选模式
• 如果您的本地计算机比服务器快，那么您的计算都非常快地完成，并且两者之间的CPU FREQ显然有所不同，或者您应该考虑与mlr.tuneParams相比其他级别(有关更多信息，请参见此处(
(

编辑

我的机器上的所有件都很好。看起来像是当地的问题。

library(mlr)
#> Loading required package: ParamHelpers
#> Registered S3 methods overwritten by 'ggplot2':
#>   method         from 
#>   [.quosures     rlang
#>   c.quosures     rlang
#>   print.quosures rlang
library(parallelMap)
numeric_ps = makeParamSet(
  makeNumericParam("C", lower = 0.5, upper = 2.0),
  makeNumericParam("sigma", lower = 0.5, upper = 2.0)
)
ctrl = makeTuneControlRandom(maxit=1024L)
rdesc = makeResampleDesc("CV", iters = 3L)
#In serial
start.time.serial <- Sys.time()
res.serial = tuneParams("classif.ksvm", task = iris.task, resampling = rdesc,
  par.set = numeric_ps, control = ctrl)
#> [Tune] Started tuning learner classif.ksvm for parameter set:
#>          Type len Def   Constr Req Tunable Trafo
#> C     numeric   -   - 0.5 to 2   -    TRUE     -
#> sigma numeric   -   - 0.5 to 2   -    TRUE     -
#> With control class: TuneControlRandom
#> Imputation value: 1
stop.time.serial <- Sys.time()
stop.time.serial - start.time.serial
#> Time difference of 31.28781 secs

#In parallel with 2 CPUs
start.time.parallel.2 <- Sys.time()
parallelStart(mode="multicore", cpu=2, level="mlr.tuneParams")
#> Starting parallelization in mode=multicore with cpus=2.
res.parallel.2 = tuneParams("classif.ksvm", task = iris.task, resampling = rdesc,
  par.set = numeric_ps, control = ctrl)
#> [Tune] Started tuning learner classif.ksvm for parameter set:
#>          Type len Def   Constr Req Tunable Trafo
#> C     numeric   -   - 0.5 to 2   -    TRUE     -
#> sigma numeric   -   - 0.5 to 2   -    TRUE     -
#> With control class: TuneControlRandom
#> Imputation value: 1
#> Mapping in parallel: mode = multicore; level = mlr.tuneParams; cpus = 2; elements = 1024.
#> [Tune] Result: C=1.12; sigma=0.647 : mmce.test.mean=0.0466667
parallelStop()
#> Stopped parallelization. All cleaned up.
stop.time.parallel.2 <- Sys.time()
stop.time.parallel.2 - start.time.parallel.2
#> Time difference of 16.13145 secs

#In parallel with 4 CPUs
start.time.parallel.16 <- Sys.time()
parallelStart(mode="multicore", cpu=4, level="mlr.tuneParams")
#> Starting parallelization in mode=multicore with cpus=4.
res.parallel.16 = tuneParams("classif.ksvm", task = iris.task, resampling = rdesc,
  par.set = numeric_ps, control = ctrl)
#> [Tune] Started tuning learner classif.ksvm for parameter set:
#>          Type len Def   Constr Req Tunable Trafo
#> C     numeric   -   - 0.5 to 2   -    TRUE     -
#> sigma numeric   -   - 0.5 to 2   -    TRUE     -
#> With control class: TuneControlRandom
#> Imputation value: 1
#> Mapping in parallel: mode = multicore; level = mlr.tuneParams; cpus = 4; elements = 1024.
#> [Tune] Result: C=0.564; sigma=0.5 : mmce.test.mean=0.0333333
parallelStop()
#> Stopped parallelization. All cleaned up.
stop.time.parallel.16 <- Sys.time()
stop.time.parallel.16 - start.time.parallel.16 
#> Time difference of 10.14408 secs

^{由Reprex软件包(v0.3.0(在2019-06-14创建}