Scikit learn 在一个网格搜索中尝试多个估计器

是否有一种方法可以在Sklearn或任何其他库中一次网格搜索多个估计器。例如，我们可以在一个网格搜索中传递SVM和随机林吗？

是。例如：

pipeline=管道([
（'vect'，CountVectorizer（）），
（'clf'，sgdclassizer（）），
])
参数=[
{
“向量最大值”：（0.5,0.75,1.0），
“clf”：（sgdclassizer（），），
“clf__α”：（0.00001,0.000001），
“clf__惩罚”：（“l2”，“elasticnet”），
"clf_un_iter":(10,50,80)，
}, {
“向量最大值”：（0.5,0.75,1.0），
“clf”：（LinearSVC（），），
"clf____C":(0.01,0.5,1.0)
}
]
grid_search=GridSearchCV（管道、参数）

我想你要找的是：

from sklearn.svm import LinearSVC
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

names = [
         "Naive Bayes",
         "Linear SVM",
         "Logistic Regression",
         "Random Forest",
         "Multilayer Perceptron"
        ]

classifiers = [
    MultinomialNB(),
    LinearSVC(),
    LogisticRegression(),
    RandomForestClassifier(),
    MLPClassifier()
]

parameters = [
              {'vect__ngram_range': [(1, 1), (1, 2)],
              'clf__alpha': (1e-2, 1e-3)},
              {'vect__ngram_range': [(1, 1), (1, 2)],
              'clf__C': (np.logspace(-5, 1, 5))},
              {'vect__ngram_range': [(1, 1), (1, 2)],
              'clf__C': (np.logspace(-5, 1, 5))},
              {'vect__ngram_range': [(1, 1), (1, 2)],
              'clf__max_depth': (1, 2)},
              {'vect__ngram_range': [(1, 1), (1, 2)],
              'clf__alpha': (1e-2, 1e-3)}
             ]

for name, classifier, params in zip(names, classifiers, parameters):
    clf_pipe = Pipeline([
        ('vect', TfidfVectorizer(stop_words='english')),
        ('clf', classifier),
    ])
    gs_clf = GridSearchCV(clf_pipe, param_grid=params, n_jobs=-1)
    clf = gs_clf.fit(X_train, y_train)
    score = clf.score(X_test, y_test)
    print("{} score: {}".format(name, score))

来自sklearn.base导入BaseEstimator
从sklearn.model_选择导入GridSearchCV
类别估计量（基本估计量）：
def-fit（自我）：通过
def分数（自我）：通过
#创建管道
管道=管道（[（'clf'，dummeyestimator（））]）#占位符估计器
#候选学习算法及其超参数
搜索空间=[{'clf'：[LogisticRegression（）]，实际估计量
“clf_________________________________，
'clf_u;C'：np.logspace（0,4,10）}，
{'clf'：[DecisionTreeClassifier（）]，实际估计量
“clf__标准”：[“基尼”，“熵”]}]
#创建网格搜索
gs=网格搜索CV（管道、搜索空间）

您可以创建一个类，该类接受任何分类器，并为每个分类器设置任何参数

创建一个适用于任何估计器的切换器类 现在，您可以根据自己的喜好对tfidf进行预训练。 现在用这个预先训练好的tfidf创建一个管道 执行超参数优化 如何解释clf估计器损失

clf\uu estimator\uu loss

被解释为任何

estimator

的

loss

参数，其中

estimator=sgdclassizer（）

在最上面的示例中，它本身就是

clf

的一个参数，是

ClfSwitcher

对象。

您可以使用。 此类用于在拟合前转换目标变量，以回归器和一组变压器为参数。但是您可以不提供转换器，然后应用标识转换器（即，不转换）。由于回归器是一个类参数，我们可以通过网格搜索对象来更改它

import numpy as np
from sklearn.compose import TransformedTargetRegressor
from sklearn.linear_model import LinearRegression
from sklearn.neural_network import MLPRegressor
from sklearn.model_selection import GridSearchCV

Y = np.array([1,2,3,4,5,6,7,8,9,10])
X = np.array([0,1,3,5,3,5,7,9,8,9]).reshape((-1, 1))

为了进行网格搜索，我们应该将参数网格指定为dict列表，每个dict对应不同的估计器。这是因为不同的估计器使用不同的参数集（例如，使用

mlprepressor

设置

fit_intercept

会导致错误）。 请注意，“回归器”的名称是自动赋予回归器的

model = TransformedTargetRegressor()
params = [
    {
        "regressor": [LinearRegression()],
        "regressor__fit_intercept": [True, False]
    },
    {
        "regressor": [MLPRegressor()],
        "regressor__hidden_layer_sizes": [1, 5, 10]
    }
]

我们可以像往常一样合身

g = GridSearchCV(model, params)
g.fit(X, Y)

g.best_estimator_, g.best_score_, g.best_params_

# results in like
(TransformedTargetRegressor(check_inverse=True, func=None, inverse_func=None,
               regressor=LinearRegression(copy_X=True, fit_intercept=False, n_jobs=None,
          normalize=False),
               transformer=None),
 -0.419213380219391,
 {'regressor': LinearRegression(copy_X=True, fit_intercept=False, n_jobs=None,
           normalize=False), 'regressor__fit_intercept': False})

---

你想通过它实现什么？我曾试图在onceHi j-a创建一个多算法的网格搜索，谢谢你的回答。我一直在寻找的是如何创建一个管道，在这里我们可以并行使用两个模型，比如SGDClassizer和SVM。在这种情况下，CountVectorizer的结果将传递给SGDClassizer。无论如何，为了解决这个问题，我稍微改变了我的方法。@tj89它将并行运行，但我想你的具体意思是CountVectorizer应该运行一次，然后它的结果将被每个分类器重用？。您是如何改变您的方法的？如果使用OneVsRestClassifier，您将如何继续，您正在测试的估计器将在OneVsRestClassifier中调用？您似乎能够将不同的估计器/参数网格传递给外部估计器，但是我无法找到将参数传递给内部估计器的方法。只是徘徊，如果有任何魔术一起完成。即使我对每个内部估计器进行单独的网格搜索，我仍然面临一个问题，即我不知道如何将参数传递给内部估计器，以便进行网格搜索。为什么要用clf预先固定它？你可以随意称呼它吗@Maths12，你真的可以随意称呼它，但通过前缀选择的一致性，你可以对每个估计器使用

GridSearchCV

进行参数调整。不过，使用上面示例中的名称可以获得相同的效果。

from sklearn.naive_bayes import MultinomialNB
from sklearn.linear_model import SGDClassifier
from sklearn.model_selection import GridSearchCV



parameters = [
    {
        'clf__estimator': [SGDClassifier()], # SVM if hinge loss / logreg if log loss
        'clf__estimator__penalty': ('l2', 'elasticnet', 'l1'),
        'clf__estimator__max_iter': [50, 80],
        'clf__estimator__tol': [1e-4],
        'clf__estimator__loss': ['hinge', 'log', 'modified_huber'],
    },
    {
        'clf__estimator': [MultinomialNB()],
        'clf__estimator__alpha': (1e-2, 1e-3, 1e-1),
    },
]

gscv = GridSearchCV(pipeline, parameters, cv=5, n_jobs=12, verbose=3)
# param optimization
gscv.fit(train_data, train_labels)

import numpy as np
from sklearn.compose import TransformedTargetRegressor
from sklearn.linear_model import LinearRegression
from sklearn.neural_network import MLPRegressor
from sklearn.model_selection import GridSearchCV

Y = np.array([1,2,3,4,5,6,7,8,9,10])
X = np.array([0,1,3,5,3,5,7,9,8,9]).reshape((-1, 1))

model = TransformedTargetRegressor()
params = [
    {
        "regressor": [LinearRegression()],
        "regressor__fit_intercept": [True, False]
    },
    {
        "regressor": [MLPRegressor()],
        "regressor__hidden_layer_sizes": [1, 5, 10]
    }
]

g = GridSearchCV(model, params)
g.fit(X, Y)

g.best_estimator_, g.best_score_, g.best_params_

# results in like
(TransformedTargetRegressor(check_inverse=True, func=None, inverse_func=None,
               regressor=LinearRegression(copy_X=True, fit_intercept=False, n_jobs=None,
          normalize=False),
               transformer=None),
 -0.419213380219391,
 {'regressor': LinearRegression(copy_X=True, fit_intercept=False, n_jobs=None,
           normalize=False), 'regressor__fit_intercept': False})