Scikit-learn: GridSearchCV在启用多线程的情况下无限期冻结（即w / n_jobs！= 1）

您在该平台上是否一直遇到问题？

在多线程方面：有些估计器可能会从中获得实质性收益，而大多数工作是在不使用GIL的numpy或Cython操作中完成的。 的确，我认为这没有得到太多评价。 backend='threading'是相当新的东西。

真正的问题是：我们还能做些什么来确定问题所在？

首先，您考虑了哪些基本估计量？

@jnothman通过平台，您是OSX 10.9.5吗？ 如果是这样，那不是我第一次遇到这个问题。

我之前省略的一个可能的主要细节是，当我遇到问题时我总是使用IPython笔记本。 我现在已经加载了一个笔记本的内核，如果在其中添加n_jobs！= 1的“得分”参数，则GridSearchCV会永远挂起，但是如果我删除该参数，一切都很好。 即使我给出的评分函数除了返回恒定的float值外什么也不做，它仍然冻结（但与n_jobs = 1完全一样）。

回复：线程听起来很不错，所以也许GridSearchCV的那个选项实际上是有意义的。

至于我有什么问题，我不确定我能否将其范围缩小很多。 我通常会尝试尽可能多的方法，尽管在这里我会设法为您提供一些有用的信息，但我只是验证了我可以使用任何估计量来重现上面提到的条件，并且发现我可以在所有情况下使用（或至少我尝试过LogisticRegression，SGDClassifier，GBRT和RF）。

我很乐意做任何事情，我可以提供更多的东西，尽管我不熟悉哪种上下文通常对这种多线程问题最有帮助。 有什么建议吗？

您是否使用numpy链接了加速框架？

不，除非我错过了什么。 我以为安装的numpy版本会在您更改时更改，或者至少会出现加速包：

（research3.4）eczech $点冻结| grep numpy的
numpy == 1.9.2
（research3.4）eczech $ conda更新加速
错误：/Users/eczech/anaconda/envs/research3.4中未安装软件包“ accelerate”

原谅我无法以100％的信心回答该问题的无知，但我当然没有做任何有意安装的事情。

康达加速不同于苹果加速：
http://docs.continuum.io/accelerate/index
https://developer.apple.com/library/mac/documentation/Accelerate/Reference/AccelerateFWRef/

康达加速是MKL加速包的版本，苹果加速是其替代MKL的方式。

你能给我们numpy.__config__.show()吗？

多处理不适用于加速IIRC。 ping @ogrisel

当然：

np。 配置.show（）
atlas_3_10_blas_threads_info：
无法使用
atlas_info：
无法使用
atlas_3_10_info：
无法使用
atlas_threads_info：
无法使用
atlas_3_10_blas_info：
无法使用
blas_opt_info：
extra_compile_args = ['-msse3'，'-DAPPLE_ACCELERATE_SGEMV_PATCH'，'-I / System / Library / Frameworks / vecLib.framework / Headers']
extra_link_args = ['-Wl，-framework'，'-Wl，Accelerate']
define_macros = [（'NO_ATLAS_INFO'，3）]
lapack_mkl_info：
无法使用
atlas_blas_info：
无法使用
mkl_info：
无法使用
lapack_opt_info：
extra_compile_args = ['-msse3'，'-DAPPLE_ACCELERATE_SGEMV_PATCH']
extra_link_args = ['-Wl，-framework'，'-Wl，Accelerate']
define_macros = [（'NO_ATLAS_INFO'，3）]
blas_mkl_info：
无法使用
atlas_3_10_threads_info：
无法使用
openblas_info：
无法使用
openblas_lapack_info：
无法使用
atlas_blas_threads_info：
无法使用

是的，这是我在问题跟踪器中找不到的已知问题。 加速不适用于多处理。

我有点困惑。 线程后端仅在释放GIL时才起作用，对吗？

知道，您知道我该如何重建numpy吗？ 我应该只是点子安装它，而不是使用conda软件包吗？ 还是我会更好地从源头构建并确保不存在那些苹果加速论点？

听起来这似乎是一个问题的起点。 如果它只是在击败一匹死马，那就走开。

如果您可以加快conda的速度，那就可以了；）

也许我们可以尝试以joblib保释？

太好了，连续性一定要付钱给苹果去做那个哈哈。

有任何建议$ 0？ 并感谢您的见解。

哦，我也知道以前有人问过这个问题，但是事实是，在使用自定义评分功能时，我只会在当前平台上遇到这个问题吗？ 在我的一生中，给定grid_search.py​​源代码，我看不到可能有什么问题，但是它可能与自定义函数的腌制有关吗？

与此无关的是，我只是想起过去我也曾尝试通过创建使用IPython并行后端的GridSearchCV修改版来解决此问题，所以假设我重新访问该解决方案，是否值得以某种方式共享？ 该解决方案效果很好，但使用起来有点麻烦，因为任何自定义类和函数都必须在pythonpath中可用，而不是在笔记本本身中可用，但是如果没有其他更好的选择，则可能有一些选择。

您可以针对图集进行链接，但是方法会更慢[apple]加速。
也许有免费的MKL链接的numpy可以用于OS X？ 有一个窗户。

[如果您是学者，则连续加速是免费的]

我很确定这与使用自定义评分功能完全无关。
您能否提供包含自定义评分功能但又不能没有的独立代码段？

定制评分功能的事实可能是相关的（例如，可能出现酸洗问题或嵌套的并行性）。 我们可以看到代码吗？

还是只不过是用make_scorer表示标准指标？

当然，这是相关的部分，使用make_scorer看起来没问题，但是没有使用自定义函数：

from sklearn.linear_model import LogisticRegression
from sklearn.grid_search import GridSearchCV
from sklearn.cross_validation import StratifiedKFold
from sklearn.metrics import average_precision_score, make_scorer
import functools

res = []
clfs = []

for response in responses:
    X, y = d_in[features], d_in[response]
    for i, (train, test) in enumerate(StratifiedKFold(y, 5)):
        X_train, y_train, X_test, y_test = X.iloc[train], y.iloc[train], X.iloc[test], y.iloc[test]
        clf = LogisticRegression(penalty='l1')
        grid = {
            'class_weight': [{0: 1, 1: 10}, {0: 1, 1: 100}, {0: 1, 1: 1000}],
            'C': np.logspace(-3, 0, num=4)
        }

        # Using make_scorer doesn't cause any issues
        # clf = GridSearchCV(clf, grid, cv=StratifiedKFold(y_train, 3),  
        #                    scoring=make_scorer(average_precision_score), n_jobs=-1)

        # This however is a problem:
        def avg_prec_score(estimator, X, y):
            return average_precision_score(y, estimator.predict_proba(X)[:, 1])
        clf = GridSearchCV(clf, grid, cv=StratifiedKFold(y_train, 5),  
                           scoring=avg_prec_score, n_jobs=-1)

        clf = clf.fit(X_train, y_train)
        print('Best parameters for response {} inferred in fold {}: {}'.format(response, i, clf.best_params_))

        y_pred = clf.predict(X_test)
        y_proba = clf.predict_proba(X_test)

        clfs.append((response, i, clf))
        res.append(pd.DataFrame({
            'y_pred': y_pred, 
            'y_actual': y_test, 
            'y_proba': y_proba[:,1],
            'response': np.repeat(response, len(y_pred))
        }))

res = functools.reduce(pd.DataFrame.append, res)
res.head()

我将使用一个自包含的版本，该版本也包含我正在使用的某些版本的数据（但是会花费更长的时间）。 但是，与此同时，对这些自定义函数进行酸洗听起来很不错-我已经尝试了好几次以确保它与自定义函数的挂起时间分别为100％和与make_scorer一起使用时的发生时间为0％一些已知的导入度量函数。

并且是在主目录（即正在解释的顶层脚本）还是
导入模块？

2015年8月15日，23：37，Eric Czech [email protected]写道：

当然，这是相关的部分，看起来一切都很好
使用make_scorer但不使用自定义函数：

从sklearn.linear_model导入LogisticRegression从sklearn.grid_search导入GridSearchCV从sklearn.cross_validation导入StratifiedKFold从sklearn.metrics导入average_precision_score，make_scorer导入功能工具

res = []
clfs = []
回应：
X，y = d_in [功能]，d_in [响应]
对于i，（train，test）枚举（StratifiedKFold（y，5））：
X_train，y_train，X_test，y_test = X.iloc [train]，y.iloc [train]，X.iloc [test]，y.iloc [test]
clf = LogisticRegression（惩罚='l1'）
网格= {
'class_weight'：[{0：1、1：10}，{0：1、1：100}，{0：1、1：1000}]，
'C'：np.logspace（-3，0，num = 4）
}

    # Using make_scorer doesn't cause any issues
    # clf = GridSearchCV(clf, grid, cv=StratifiedKFold(y_train, 3),
    #                    scoring=make_scorer(average_precision_score), n_jobs=-1)

    # This however is a problem:
    def avg_prec_score(estimator, X, y):
        return average_precision_score(y, estimator.predict_proba(X)[:, 1])
    clf = GridSearchCV(clf, grid, cv=StratifiedKFold(y_train, 5),
                       scoring=avg_prec_score, n_jobs=-1)

    clf = clf.fit(X_train, y_train)
    print('Best parameters for response {} inferred in fold {}: {}'.format(response, i, clf.best_params_))

    y_pred = clf.predict(X_test)
    y_proba = clf.predict_proba(X_test)

    clfs.append((response, i, clf))
    res.append(pd.DataFrame({
        'y_pred': y_pred,
        'y_actual': y_test,
        'y_proba': y_proba[:,1],
        'response': np.repeat(response, len(y_pred))
    }))

res = functools.reduce（pd.DataFrame.append，res）
res.head（）

我将研究一个独立版本，其中涉及某些版本的
我也使用的数据（但需要更长的时间）。 同时，
那些自定义函数的酸洗听起来很不错-我已经尝试过了
可以确定几次，并通过自定义挂起100％的时间
函数，并且在使用make_scorer并使用某些已知方法时，占0％的时间，
导入的度量功能。

-
直接回复此电子邮件或在GitHub上查看
https://github.com/scikit-learn/scikit-learn/issues/5115#issuecomment -131376298
。

哦，是ipynb。 嗯，很有趣。 是的，腌制可能是一个问题。

2015年8月15日，23：51，Joel Nothman joel。 [email protected]写道：

并且是主要的（即正在解释的顶层脚本）还是
导入的模块？

2015年8月15日，23：37，Eric Czech [email protected]写道：

当然，这是相关的部分，看起来一切都很好
使用make_scorer但不使用自定义函数：

从sklearn.linear_model导入LogisticRegression从sklearn.grid_search导入GridSearchCV从sklearn.cross_validation导入StratifiedKFold从sklearn.metrics导入average_precision_score，make_scorer导入功能工具

res = []
clfs = []
回应：
X，y = d_in [功能]，d_in [响应]
对于i，（train，test）枚举（StratifiedKFold（y，5））：
X_train，y_train，X_test，y_test = X.iloc [train]，y.iloc [train]，X.iloc [test]，y.iloc [test]
clf = LogisticRegression（惩罚='l1'）
网格= {
'class_weight'：[{0：1、1：10}，{0：1、1：100}，{0：1、1：1000}]，
'C'：np.logspace（-3，0，num = 4）
}

    # Using make_scorer doesn't cause any issues
    # clf = GridSearchCV(clf, grid, cv=StratifiedKFold(y_train, 3),
    #                    scoring=make_scorer(average_precision_score), n_jobs=-1)

    # This however is a problem:
    def avg_prec_score(estimator, X, y):
        return average_precision_score(y, estimator.predict_proba(X)[:, 1])
    clf = GridSearchCV(clf, grid, cv=StratifiedKFold(y_train, 5),
                       scoring=avg_prec_score, n_jobs=-1)

    clf = clf.fit(X_train, y_train)
    print('Best parameters for response {} inferred in fold {}: {}'.format(response, i, clf.best_params_))

    y_pred = clf.predict(X_test)
    y_proba = clf.predict_proba(X_test)

    clfs.append((response, i, clf))
    res.append(pd.DataFrame({
        'y_pred': y_pred,
        'y_actual': y_test,
        'y_proba': y_proba[:,1],
        'response': np.repeat(response, len(y_pred))
    }))

res = functools.reduce（pd.DataFrame.append，res）
res.head（）

我将研究一个独立版本，其中涉及某些版本的
我也使用的数据（但需要更长的时间）。 同时，
那些自定义函数的酸洗听起来很不错-我已经尝试过了
可以确定几次，并通过自定义挂起100％的时间
函数，并且在使用make_scorer并使用某些已知方法时，占0％的时间，
导入的度量功能。

-
直接回复此电子邮件或在GitHub上查看
https://github.com/scikit-learn/scikit-learn/issues/5115#issuecomment -131376298
。

在笔记本上

我将尝试从模块导入它，然后看看它如何进行

嗯，您所知道的，在笔记本之外定义时可以正常工作。

我在python 2.7中运行的代码基本相同（我需要一个更旧的lib），在python 3.4中运行此代码，而2.7中存在挂起的问题，无论它是自定义函数还是使用make_scorer的东西，我认为这解决了我在较新版本中的所有问题，因此我只能使用旧版本中的变通方法。

我还能做些什么来追踪为什么笔记本中定义的酸洗功能可能会出现问题？

好吧，我们想了解：

• 对于该平台上本地定义的功能来说，酸洗和酸洗通常是一个问题，还是我们遇到了特殊的障碍？
• 如果酸洗是一个问题，为什么会悬挂而不是引发异常？ 您能否尝试猴子修补或类似方法，以查看是否替换了pickle.dumps(function)检查https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/externals/joblib/parallel。 py＃L150与pickle.loads(pickle.dumps(function))导致错误？ （要说明，这是一项安全检查，以确保在运行多处理之前的可腌制性。）

@ogrisel可能对此感兴趣。

从我在Windows上看到的信息来看，笔记本电脑与多处理程序之间存在怪异的交互。

您是否尝试过对同一笔记本中定义的功能进行酸洗和酸洗？

今天，我不小心看到了这个https://pythonhosted.org/joblib/parallel.html#bad -interaction-of-multiprocessing-and-third-party-libraries，这不相关吗？
也许您应该只升级到python 3.4或更高版本？

对不起，我放了一个长假。 不过要回答您的问题：

1. re @jnothman ：我将pickle.loads(pickle.dumps(function))放在parallel.py中，并在其后添加一条打印语句，以确保其执行得很干净，并且那里没有问题。 需要明确的是，从笔记本中调用的GridSearchCV.fit仍然像以前一样卡住，没有任何变化（除了我添加的打印语句，使用n_jobs = -1显示了16次）。
2. 回复@amueller ：如果我正确理解了您的意思，那么我在笔记本中运行了类似的内容，没有任何问题：

def test_function(x):
    return x**2
pickle.loads(pickle.dumps(test_function))(3)
# 9

1. 回复@olologin ：我在3.4.3。 或更具体地说：'3.4.3 | Continuum Analytics，Inc. | （默认值，2015年3月6日，12：07：41）n [GCC 4.2.1（Apple Inc.内部版本5577）]'

我没有阅读上面的对话，但是我想指出，此最小测试在travis的Python 2.6版本下失败，但在我的PC上以类似配置通过了……（建议在n_jobs = -1时失败。是在旧的python / joblib / scipy版本的单核计算机上设置的？）

def test_cross_val_score_n_jobs():
    # n_jobs = -1 seems to hang in older versions of joblib/python2.6
    # See issue 5115
    cross_val_score(LinearSVC(), digits.data, digits.target, cv=KFold(3),
                    scoring="precision_macro", n_jobs=-1)

+1这个问题，如果有帮助，愿意提供详细信息

@ eric-czech如果您使用的是Python 3.4或3.5，请尝试设置以下环境变量，然后重新启动python程序：

export JOBLIB_START_METHOD="forkserver"

如joblib文档中所述。 默认情况下，forkserver is模式未启用，因为它破坏了交互式定义的功能。

在装有最新软件的OS X 10.11.4和Ubuntu 14.04上都存在相同的问题。

# Metrics
B_R = 10.0

def raw_TPR(y_true, y_pred):
    return np.sum((y_true == 1) & (y_pred == y_true))

def raw_FPR(y_true, y_pred):
    return np.sum((y_true == 0) & (y_pred != y_true))

def AMS(y_true, y_pred):
    print("Hello")
    tpr = raw_TPR(y_true, y_pred)
    fpr = raw_FPR(y_true, y_pred)
    score = np.sqrt(2 * ((tpr + fpr + B_R) * np.log(1 + tpr / (fpr + B_R))) - tpr)
    return score


# Grid search

param_grid = {
    "max_depth":[6, 10],
    "learning_rate":[0.01, 0.5],
    "subsample":[0, 1],
    "min_child_weight":[0.1, 1],
    "colsample_bytree":[0.1, 1],
    "base_score":[0.1, 1],
    "gamma":[0.5, 3.5]
}

scorer = make_scorer(AMS, greater_is_better=True)


clf = XGBClassifier()
gridclf = GridSearchCV(clf, param_grid, scorer, n_jobs=-1, verbose=2)
gridclf.fit(X_train, y_train)

实际上，仅当n_jobs=1 ，此代码不会冻结。

现在，默认情况下，它应该在python 3上可以正常工作，并且在python 2上是不会修复的，对@ogrisel吗？ 我们应该关闭吗？

如果它在Python 2上无提示地挂起而没有引发任何警告或错误（“ Python 2不支持n_jobs> 1”），则不可接受； 我们可以抛出一个错误吗？

@amueller在Python 3上，您可以遵循https://github.com/scikit-learn/scikit-learn/issues/5115#issuecomment -187683383来解决此问题，即默认情况下，即使在Python 3上也无法使用。

不知道我们是否应该关闭，因为原始OP似乎说将joblib start_method设置为forkserver并不总是有效的...

顺便说一句xgboost之一是已知的，请参阅https://github.com/scikit-learn/scikit-learn/issues/6627#issuecomment -206351138。

编辑：下面的更改可能无法真正解决问题。 我对Pathos进行多处理的方式也进行了不相关的更改，这可能是我真正的解决方法。

快速解决：
np.random.seed(0)

说明：
我也曾在遇到过这个问题。 我第一次（2？）运行GridSearchCV，这很好，但是随后的运行将挂起而不会出错。

我只是在每个测试中设置了np.random.seed(0) ，以确保可重复性，同时仍使自己能够灵活地随时间重新排序测试，而不会影响随机性。 这样做之后，所有挂在GSCV错误上的测试都重新开始工作。

def test_name():
    np.random.seed(0)
    test_code_involving_gscv_here

希望这有助于调试！

开发环境：
Mac OS X（Sierra）
Python 2.7
库的最新版本。

@ClimbsRocks好吧，这可能是您的估算器中存在一些错误。 让我们知道您是否有可复制的示例;）

@amueller ：好的电话。 我赶紧给你们剪了一个树枝，以重现这一点，但是这次一切运行正常。

当我还在程序的其他部分中使用Pathos的并行化时，我认为使用GSCV的并行化可能是一个问题。 这是过去一周左右我更改的唯一其他相关内容。

从那以后，我进行了重构，以更彻底地关闭和打开其多处理池。

让我感到惊讶的是，不仅仅是一个估算器中的错误，是在构建测试套件时，每个测试都是单独运行和通过的。 只有当我在同一遍中运行多个测试时，所有测试都依赖于GSCV才开始挂起。

编辑较早的评论以注意到这种不确定性。

如果将joblib与任何其他并行化结合使用，则很有可能会崩溃，并且您不应该尝试这样做。

对不起，这个线程，但我也遇到了这个问题。
我创建了一个Python 3.5内核，并为forkserver定义了作业库启动方法，但仍然存在问题。

实际上，它甚至在n_jobs = 1时也不起作用。

有什么消息吗？

实际上，它甚至在n_jobs = 1时也不起作用。

这很奇怪，很可能与这个问题无关（大约是n_jobs != 1 ）。 获得良好反馈的最佳方法是打开一个单独的问题，并使用一个独立的代码段重现该问题。

我很确定自己会遇到这个问题。 在尝试了多种组合之后，我对n_jobs> 1所做的一切都会在折叠几遍后冻结。 我使用的是sklearn = 0.19.0的Ubuntu Linux笔记本电脑，因此这与我读过的其他笔记本电脑不同。 这是“令人反感”的代码：

import xgboost as xgb
from sklearn.model_selection import GridSearchCV
cv_params = {'max_depth': [3,5,7], 'min_child_weight': [1,3,5]}

ind_params = {'learning_rate': 0.1, 'n_estimators': 1000, 'seed':0, 'subsample': 0.8, 'colsample_bytree': 0.8,  'objective': 'binary:logistic'}
optimized_XGB = GridSearchCV(xgb.XGBClassifier(**ind_params), 
                            cv_params, scoring = 'roc_auc', cv = 5, n_jobs = 1, verbose=2) 
optimized_XGB.fit(xgboost_train, label_train,eval_metric='auc')

有趣的事情之一是，当我导入xgboost时，我在GridSearchCV上收到了弃用警告，就好像它不是从model_selection导入一样。 但是，我使用的是xgboost 0.62，在查看他们的存储库时，好像他们正在导入正确的GridSearchCV。 需要明确的是，弃用警告不是我关心的问题，而是一个即将发生的问题：n_jobs> 1冻结执行。 只是指出以防万一。

您能否提供数据来帮助解决问题？

2017年8月24日20：29，Xavier Amatriain [email protected]
写道：

我很确定自己会遇到这个问题。 经过很多尝试
组合，我用n_jobs> 1做的所有事情在经过几次后都会冻结
褶皱。 我正在使用sklearn = 0.19.0的Ubuntu Linux笔记本电脑，所以这是一个
与其他已阅读的配置不同。 这里是
“违规”代码：

`将xgboost导入为xgb
从sklearn.model_selection导入GridSearchCV
cv_params = {'max_depth'：[3,5,7]，'min_child_weight'：[1,3,5]}

ind_params = {'learning_rate'：0.1，'n_estimators'：1000，'seed'：0，
'subsample'：0.8，'colsample_bytree'：0.8，'objective'：' binary：logistic '}
Optimized_XGB = GridSearchCV（xgb.XGBClassifier（** ind_params），
cv_params，得分='roc_auc'，cv = 5，n_jobs = 1，详细= 2）
Optimized_XGB.fit（xgboost_train，label_train，eval_metric ='auc'）`

有趣的事情之一是，当我导入xgboost时，
GridSearchCV上的弃用警告，好像它不是从导入
model_selection。 但是，我使用的是xgboost 0.62，
似乎他们正在导入正确的GridSearchCV。 成为
显然，弃用警告不是我关心的问题，而是
一个即将发生：n_jobs> 1冻结执行。 只是指出
可能会有所帮助。

-
您收到此邮件是因为有人提到您。
直接回复此电子邮件，在GitHub上查看
https://github.com/scikit-learn/scikit-learn/issues/5115#issuecomment-324597686 ，
或使线程静音
https://github.com/notifications/unsubscribe-auth/AAEz66DbfTlnU_-dcxLKa5zkrcZ-0qVOks5sbVCmgaJpZM4FqYlN
。

当然，您可以从以下位置下载我正在使用的确切文件：
https://xamat.github.io/xgboost_train.csv
https://xamat.github.io/label_train.csv

HTTP404

抱歉，第一个链接有错误，现在应该修复。 第二个也应该没问题，我刚刚检查了一下。

xgboost的已知问题，例如，请参见https://github.com/scikit-learn/scikit-learn/issues/6627#issuecomment -206351138。

仅供参考， joblib中的

这仍然是错误吗？ 我在默认值（n_jobs = 1）以及pre_dispatch = 1上也遇到了相同的问题，使用RandomForestClassifier ，其中包含80个参数组合和ShuffleSplit CV（n = 20）。

它也挂在管道上（ SelectKBest(score_func=mutual_info_classif, k=10)后跟RandomForestClassifier ），无论是最新版本还是开发版本。

让我知道你们是否找到了一种解决方法，或者其他可靠的模型选择方法。 尝试尝试scikit-optimize 。

您是说n_jobs = 1还是错别字？ 此问题与n_jobs！= 1有关。

获得高质量反馈的最好方法是提供一种重现问题的方法。 如果您看到的问题确实与n_jobs = 1有关，请在这种情况下打开一个单独的问题。

我写了我的意思，即“启用多线程”
n_jobs！= 1，例如“不等于1”。 等效地，n_jobs>1。例如，n_jobs = 4

您是说无法复制n_jobs = 4的冻结？

如果是这样，我将在一个月内提供测试用例（我正在更换新机器。）

2017年9月12日上午7：10，LoïcEstève< [email protected] [email protected] >写道：

您是说n_jobs = 1还是错别字？ 此问题与n_jobs！= 1有关。

获得高质量反馈的最好方法是提供一种重现问题的方法。 如果您看到的问题确实与n_jobs = 1有关，请在这种情况下打开一个单独的问题。

-
您收到此邮件是因为有人提到您。
直接回复此电子邮件，在GitHub https://github.com/scikit-learn/scikit-learn/issues/5115#issuecomment-328864498上查看，或忽略线程https://github.com/notifications/unsubscribe- auth / ABH-rd7wgU5lcS6oD5VMl0YOB8CXfSTJks5shpDZgaJpZM4FqYlN 。

@smcinerney您是@raamana吗？ 我认为@lesteve回复了@raamana ，他写了n_jobs=1 ，这似乎与该问题无关。

哦，抱歉，不，我不是@raamana。 是的@raamana的问题有所不同（但可能由于相同的代码）

2017年9月12日上午9：23，Andreas Mueller < [email protected] [email protected] >写道：

@smcinerney https://github.com/smcinerney您是@raamana https://github.com/raamana吗？ 我认为@lesteve https://github.com/lesteve回复了@raamana https://github.com/raamana谁写了n_jobs = 1，这似乎与这个问题无关。

-
您收到此邮件是因为有人提到您。
直接回复此电子邮件，在GitHub https://github.com/scikit-learn/scikit-learn/issues/5115#issuecomment-328905819上查看，或忽略线程https://github.com/notifications/unsubscribe- auth / ABH-rYKQA3L5ifINBX6enrk5oDIsf1Lqks5shrASgaJpZM4FqYlN 。

不好意思，我不是故意把事情混在一起。 我将打开另一个问题（使用最少的代码来重现），但是即使n默认为n_jobs = 1，也不会将GridSearchCV挂起而不是n_jobs> 1。

@raamana是的，这是一个更大的问题，但也不太可能是由相关问题引起的。

@ eric-czech @jnothman
因此，如果您决定使用backend ='threading'。 一种不更改sklearn代码的简单方法是使用parallel_backend上下文管理器，而不更改GSV的fit方法。

from sklearn.externals.joblib import parallel_backend

clf = GridSearchCV()
with parallel_backend('threading'):
    clf.fit(x_train, y_train)

PS：我不确定“线程”是否适用于所有估计量。 但是我的GSV njob> 1的估算器遇到了相同的问题，并且在不更改库的情况下按预期使用了此方法。

系统尝试：
MAC OS：10.12.6
的Python：3.6
numpy == 1.13.3
熊猫== 0.21.0
scikit学习== 0.19.1

嗯...在后台使用线程后端可能存在一些并发问题
网格搜索，例如＃10329中的错误创建了竞争条件...

2017年12月22日03：59，Trideep Rath [email protected]写道：

@ eric-czech https://github.com/eric-czech @jnothman
https://github.com/jnothman
因此，如果您决定使用backend ='threading'。 一种简单的方法，无需
更改sklearn代码将使用parallel_backend上下文管理器
而不会改变GSV的拟合方法。

从sklearn.externals.joblib导入parallel_backend

clf = GridSearchCV（）
使用parallel_backend（'threading'）：
clf.fit（x_train，y_train）

PS：我不确定“线程”是否适用于所有估计量。 但我是
我的估算器的GSV njob> 1有相同的问题，并使用此
无需更改库即可按我的预期工作。

系统尝试：
MAC OS：10.12.6
的Python：3.6
numpy == 1.13.3
熊猫== 0.21.0
scikit学习== 0.19.1

-
您收到此邮件是因为有人提到您。
直接回复此电子邮件，在GitHub上查看
https://github.com/scikit-learn/scikit-learn/issues/5115#issuecomment-353402474 ，
或使线程静音
https://github.com/notifications/unsubscribe-auth/AAEz64SfwYpjLU1JK0vukBRXJvWYs3LKks5tCo51gaJpZM4FqYlN
。

案例：使用后端作为“线程”，并使用扩展BaseEstimator和ClassifierMixin的Estimator。 我不确定比赛条件是在哪里引起的。 您能详细说明一下吗？

根据我的理解和实验，我没有观察到任何比赛情况。

out = Parallel(
    n_jobs=self.n_jobs, verbose=self.verbose,
    pre_dispatch=pre_dispatch
)(delayed(_fit_and_score)(clone(base_estimator), X, y, scorers, train,
                          test, self.verbose, parameters,
                          fit_params=fit_params,
                          return_train_score=self.return_train_score,
                          return_n_test_samples=True,
                          return_times=True, return_parameters=False,
                          error_score=self.error_score)
  for parameters, (train, test) in product(candidate_params,
                                           cv.split(X, y, groups)))

在克隆（base_estimator）上调用_fit_and_score。 这会进行deep_copy并拥有其自己的数据的副本。

out是_fit_and_score方法的输出。 因此，在此之后，所有线程都已完成执行估计器的fit方法并报告了结果。

结果就是您从GCV_clf.cv_results_获得的结果

您能在这种情况下解释为什么会导致竞态吗？

如果您设置嵌套参数，则竞争条件就会发生，即
一个已更改的参数是一个估计量，另一个是该参数的一个参数
估算器。

我在Windows 7下使用make_scorer与GridSearchCv和n_jobs=-1结合使用最新版本时遇到相同的问题：

Windows-7-6.1.7601-SP1
Python 3.6.4 |Anaconda, Inc.| (default, Jan 16 2018, 10:22:32) [MSC v.1900 64 bit (AMD64)]
NumPy 1.12.1
SciPy 1.0.0
Scikit-Learn 0.19.1

@mansenfranzen感谢您发布您的版本和平台！ 获得高质量反馈的最佳机会是提供一个独立的片段来重现该问题。 请阅读https://stackoverflow.com/help/mcve了解更多详细信息。

在Win7下使用任何自定义预处理步骤都会遇到相同的问题。
工具链：

Python 3.6.2
NumPy 1.13.1, 1.14.2 (under both)
SciPy 1.0.0
SkLearn 0.19.1

MCVE：

from sklearn.pipeline import Pipeline, make_pipeline
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score
import numpy as np

class CustomTransformer:
    def fit(self, X, y):
        return self

    def transform(self, X):
        return X

pipeline = make_pipeline(CustomTransformer(),
                         SVC())

X_train = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]])
y_train = np.array([1.0, 0.0, 0.0, 1.0])

print(cross_val_score(pipeline, X_train, y_train, cv=2, n_jobs=-1))

您是否知道，如果没有if __name__ == '__main__' ，Windows中的python多重处理将无法运行？

我是。 抱歉，忘了告诉我我正在使用Jupyter。
具有if __name__ == '__main__'的独立脚本将打印以下跟踪，然后仍然冻结：

Process SpawnPoolWorker-1:
Traceback (most recent call last):
  File "C:\Python\Python36\lib\multiprocessing\process.py", line 249, in _bootstrap
    self.run()
  File "C:\Python\Python36\lib\multiprocessing\process.py", line 93, in run
    self._target(*self._args, **self._kwargs)
  File "C:\Python\Python36\lib\multiprocessing\pool.py", line 108, in worker
    task = get()
  File "C:\Python\Python36\lib\site-packages\sklearn\externals\joblib\pool.py", line 362, in get
    return recv()
  File "C:\Python\Python36\lib\multiprocessing\connection.py", line 251, in recv
    return _ForkingPickler.loads(buf.getbuffer())
AttributeError: Can't get attribute 'CustomTransformer' on <module '__mp_main__' from 'C:\\projects\\Python\\Sandbox\\test.py'>
< same for SpawnPoolWorker-3 here >

哦，有趣。 出于懒惰，我将整个脚本放在if __name__ == '__main__'并从上一条注释中得到了结果。

现在，我只放置了pipeline = make_pipeline... ，它成功执行了。 也许是Jupyter的原因？

无论如何，我不知道前面的注释中的行为是否有效，并且是由于不正确地使用if __name__ == '__main__' ，还是由SkLearn的过错造成的。

听起来这不是我们库的问题，而是关于执行的问题
Windows中多处理的上下文...

真讨厌确实，我无法在所有相同版本的Ubuntu下重现任何问题。 感谢帮助！

可以确认此错误仍然有效。

在Jupyter笔记本，Python3，Sklearn 0.19.1中的Windows 10上运行

Linux Mint（Ubuntu 16.10）Python 3.5上的相同问题

一切都停留在每个内核的第一个Epoch上，并且CPU处于混乱状态，因此未完成任何工作。

@MrLobs听起来像是一个酸洗错误，对吗？ 将CustomTransformer放在单独的python文件中。

@ Chrisjw42 @avatsaev没有更多的上下文，我们真的无法做很多事情。
@avatsaev听起来好像您正在使用tensorflow？

@amueller是的tensorflow

@avatsaev仍然不是足够的信息。 您是否有复制的最低限度的示例？ 您使用的是什么blas，您使用的是GPU，您使用的是什么版本的scikit-learn...。

好的，结果是因为我使用的是TF GPU，所以将n_jobs设置为> 1并不能真正起作用，这是正常的，因为我只有一个GPU大声笑

是的，您都不应该在TF中同时使用n_jobs。

为什么不？

@amueller ，是的，将自定义转换器放入单独的文件即可解决该问题

n_jobs！= 1是否有可能在将要挂起的环境中引发错误（或至少是警告）？ 我刚刚在jupyter笔记本电脑中遇到了这个问题，如果我是一个初学者（像班上的其余部分一样），我永远也不会弄清楚为什么gridsearchcv会一直挂着，实际上，我们的老师甚至建议我们使用n_jobs =- 1。 如果这里的问题已知，包装（keras或sklearn，以哪个为准）是否可以警告它会发生并防止挂起？

我不认为任何人都知道将要挂在什么环境下……我不相信任何人都能够以可靠的方式重现此错误。

但是我们正在努力改善我们的多处理基础架构。
我不清楚这是否可以解决所有这些问题。

@ jnothman👍

真高兴！

我不确定为什么将其标记为0.21。 在大多数情况下，这可以在0.20中解决。 我认为我们应该解决这个问题，并让人们提出新的问题。 这个时间太长，没有具体说明。

我刚刚在具有jupyter的AWS Ubuntu上遇到了同样的问题...

使用parallel_backend似乎可以工作...

from sklearn.externals.joblib import parallel_backend

clf = GridSearchCV(...)
with parallel_backend('threading'):
    clf.fit(x_train, y_train)

@morienor，如果您可以使用scikit-learn 0.20.1重现此问题，请打开一个新问题，其中包含所有必要的详细信息，以便其他人可以重现此问题（伪造的随机数据集上带有import语句的完整脚本）以及以及python，scikit-learn，numpy，scipy和操作系统的所有版本号。

我刚刚在具有jupyter的AWS Ubuntu上遇到了同样的问题...

使用parallel_backend似乎可以工作...

from sklearn.externals.joblib import parallel_backend

clf = GridSearchCV(...)
with parallel_backend('threading'):
    clf.fit(x_train, y_train)

这对我有用！ 非常感谢！

@ jmq19950824 @morienor是的，但是由于GIL，使用threading后端没有意义。

我刚刚在具有jupyter的AWS Ubuntu上遇到了同样的问题...

使用parallel_backend似乎可以工作...

from sklearn.externals.joblib import parallel_backend

clf = GridSearchCV(...)
with parallel_backend('threading'):
    clf.fit(x_train, y_train)

天才为我工作