StackingCVClassifier: 交叉验证堆叠
一个集成学习元分类器，用于堆叠，通过交叉验证为第二层分类器准备输入，以防止过拟合。
from mlxtend.classifier import StackingCVClassifier
概述
堆叠是一种集成学习技术，通过元分类器组合多个分类模型。StackingCVClassifier 扩展了标准堆叠算法（实现为 StackingClassifier），使用交叉验证为第二层分类器准备输入数据。
在标准的堆叠过程中，第一层分类器拟合用于为第二层分类器准备输入的相同训练集，这可能导致过拟合。然而，StackingCVClassifier 使用了交叉验证的概念：数据集被分割成 k 个折叠，在 k 个连续的回合中，使用 k-1 个折叠来拟合第一层分类器；在每个回合中，然后将第一层分类器应用于在每次迭代中未用于模型拟合的剩余 1 个子集。然后将得到的预测堆叠起来并提供给第二层分类器作为输入数据。在 StackingCVClassifier 训练完成后，第一层分类器将拟合到整个数据集上，如下图所示。
更正式地，堆叠交叉验证算法可以概括如下（来源：[1]）
参考文献
- [1] Tang, J., S. Alelyani, and H. Liu. "Data Classification: Algorithms and Applications." 《数据挖掘与知识发现系列》，CRC Press (2015): pp. 498-500。
- [2] Wolpert, David H. "Stacked generalization." Neural networks 5.2 (1992): 241-259。
- [3] Marios Michailidis (2017), StackNet, StackNet 元建模框架, https://github.com/kaz-Anova/StackNet
示例 1 - 简单交叉验证堆叠分类
from sklearn import datasets
iris = datasets.load_iris()
X, y = iris.data[:, 1:3], iris.target
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier
from mlxtend.classifier import StackingCVClassifier
import numpy as np
import warnings
warnings.simplefilter('ignore')
RANDOM_SEED = 42
clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = RandomForestClassifier(random_state=RANDOM_SEED)
clf3 = GaussianNB()
lr = LogisticRegression()
# Starting from v0.16.0, StackingCVRegressor supports
# `random_state` to get deterministic result.
sclf = StackingCVClassifier(classifiers=[clf1, clf2, clf3],
meta_classifier=lr,
random_state=RANDOM_SEED)
print('3-fold cross validation:\n')
for clf, label in zip([clf1, clf2, clf3, sclf],
['KNN',
'Random Forest',
'Naive Bayes',
'StackingClassifier']):
scores = model_selection.cross_val_score(clf, X, y,
cv=3, scoring='accuracy')
print("Accuracy: %0.2f (+/- %0.2f) [%s]"
% (scores.mean(), scores.std(), label))
3-fold cross validation:
Accuracy: 0.91 (+/- 0.01) [KNN]
Accuracy: 0.95 (+/- 0.01) [Random Forest]
Accuracy: 0.91 (+/- 0.02) [Naive Bayes]
Accuracy: 0.93 (+/- 0.02) [StackingClassifier]
import matplotlib.pyplot as plt
from mlxtend.plotting import plot_decision_regions
import matplotlib.gridspec as gridspec
import itertools
gs = gridspec.GridSpec(2, 2)
fig = plt.figure(figsize=(10,8))
for clf, lab, grd in zip([clf1, clf2, clf3, sclf],
['KNN',
'Random Forest',
'Naive Bayes',
'StackingCVClassifier'],
itertools.product([0, 1], repeat=2)):
clf.fit(X, y)
ax = plt.subplot(gs[grd[0], grd[1]])
fig = plot_decision_regions(X=X, y=y, clf=clf)
plt.title(lab)
plt.show()
示例 2 - 使用概率作为元特征
或者，可以通过设置 use_probas=True 使用第一层分类器的类别概率来训练元分类器（第二层分类器）。例如，在具有 2 个第一层分类器的 3 类设置中，这些分类器可能对 1 个训练样本做出以下“概率”预测
- 分类器 1: [0.2, 0.5, 0.3]
- 分类器 2: [0.3, 0.4, 0.4]
通过堆叠这些第一层概率，将产生 k 个特征，其中 k = [n_classes * n_classifiers]
- [0.2, 0.5, 0.3, 0.3, 0.4, 0.4]
clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = RandomForestClassifier(random_state=1)
clf3 = GaussianNB()
lr = LogisticRegression()
sclf = StackingCVClassifier(classifiers=[clf1, clf2, clf3],
use_probas=True,
meta_classifier=lr,
random_state=42)
print('3-fold cross validation:\n')
for clf, label in zip([clf1, clf2, clf3, sclf],
['KNN',
'Random Forest',
'Naive Bayes',
'StackingClassifier']):
scores = model_selection.cross_val_score(clf, X, y,
cv=3, scoring='accuracy')
print("Accuracy: %0.2f (+/- %0.2f) [%s]"
% (scores.mean(), scores.std(), label))
3-fold cross validation:
Accuracy: 0.91 (+/- 0.01) [KNN]
Accuracy: 0.95 (+/- 0.01) [Random Forest]
Accuracy: 0.91 (+/- 0.02) [Naive Bayes]
Accuracy: 0.95 (+/- 0.02) [StackingClassifier]
示例 3 - 堆叠交叉验证分类与网格搜索
该堆叠允许调整基础模型和元模型的超参数！可以通过 estimator.get_params().keys() 获取可调参数的完整列表。
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from mlxtend.classifier import StackingCVClassifier
# Initializing models
clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = RandomForestClassifier(random_state=RANDOM_SEED)
clf3 = GaussianNB()
lr = LogisticRegression()
sclf = StackingCVClassifier(classifiers=[clf1, clf2, clf3],
meta_classifier=lr,
random_state=42)
params = {'kneighborsclassifier__n_neighbors': [1, 5],
'randomforestclassifier__n_estimators': [10, 50],
'meta_classifier__C': [0.1, 10.0]}
grid = GridSearchCV(estimator=sclf,
param_grid=params,
cv=5,
refit=True)
grid.fit(X, y)
cv_keys = ('mean_test_score', 'std_test_score', 'params')
for r, _ in enumerate(grid.cv_results_['mean_test_score']):
print("%0.3f +/- %0.2f %r"
% (grid.cv_results_[cv_keys[0]][r],
grid.cv_results_[cv_keys[1]][r] / 2.0,
grid.cv_results_[cv_keys[2]][r]))
print('Best parameters: %s' % grid.best_params_)
print('Accuracy: %.2f' % grid.best_score_)
0.947 +/- 0.03 {'kneighborsclassifier__n_neighbors': 1, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 10}
0.933 +/- 0.02 {'kneighborsclassifier__n_neighbors': 1, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 50}
0.940 +/- 0.02 {'kneighborsclassifier__n_neighbors': 1, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 10}
0.940 +/- 0.02 {'kneighborsclassifier__n_neighbors': 1, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 50}
0.953 +/- 0.02 {'kneighborsclassifier__n_neighbors': 5, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 10}
0.953 +/- 0.02 {'kneighborsclassifier__n_neighbors': 5, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 50}
0.953 +/- 0.02 {'kneighborsclassifier__n_neighbors': 5, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 10}
0.953 +/- 0.02 {'kneighborsclassifier__n_neighbors': 5, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 50}
Best parameters: {'kneighborsclassifier__n_neighbors': 5, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 10}
Accuracy: 0.95
如果我们计划多次使用回归算法，我们只需在参数网格中添加额外的数字后缀，如下所示
from sklearn.model_selection import GridSearchCV
# Initializing models
clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = RandomForestClassifier(random_state=RANDOM_SEED)
clf3 = GaussianNB()
lr = LogisticRegression()
sclf = StackingCVClassifier(classifiers=[clf1, clf1, clf2, clf3],
meta_classifier=lr,
random_state=RANDOM_SEED)
params = {'kneighborsclassifier-1__n_neighbors': [1, 5],
'kneighborsclassifier-2__n_neighbors': [1, 5],
'randomforestclassifier__n_estimators': [10, 50],
'meta_classifier__C': [0.1, 10.0]}
grid = GridSearchCV(estimator=sclf,
param_grid=params,
cv=5,
refit=True)
grid.fit(X, y)
cv_keys = ('mean_test_score', 'std_test_score', 'params')
for r, _ in enumerate(grid.cv_results_['mean_test_score']):
print("%0.3f +/- %0.2f %r"
% (grid.cv_results_[cv_keys[0]][r],
grid.cv_results_[cv_keys[1]][r] / 2.0,
grid.cv_results_[cv_keys[2]][r]))
print('Best parameters: %s' % grid.best_params_)
print('Accuracy: %.2f' % grid.best_score_)
0.940 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 1, 'kneighborsclassifier-2__n_neighbors': 1, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 10}
0.940 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 1, 'kneighborsclassifier-2__n_neighbors': 1, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 50}
0.940 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 1, 'kneighborsclassifier-2__n_neighbors': 1, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 10}
0.940 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 1, 'kneighborsclassifier-2__n_neighbors': 1, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 50}
0.960 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 1, 'kneighborsclassifier-2__n_neighbors': 5, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 10}
0.953 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 1, 'kneighborsclassifier-2__n_neighbors': 5, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 50}
0.953 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 1, 'kneighborsclassifier-2__n_neighbors': 5, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 10}
0.953 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 1, 'kneighborsclassifier-2__n_neighbors': 5, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 50}
0.960 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 5, 'kneighborsclassifier-2__n_neighbors': 1, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 10}
0.953 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 5, 'kneighborsclassifier-2__n_neighbors': 1, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 50}
0.953 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 5, 'kneighborsclassifier-2__n_neighbors': 1, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 10}
0.953 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 5, 'kneighborsclassifier-2__n_neighbors': 1, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 50}
0.953 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 5, 'kneighborsclassifier-2__n_neighbors': 5, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 10}
0.953 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 5, 'kneighborsclassifier-2__n_neighbors': 5, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 50}
0.953 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 5, 'kneighborsclassifier-2__n_neighbors': 5, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 10}
0.953 +/- 0.02 {'kneighborsclassifier-1__n_neighbors': 5, 'kneighborsclassifier-2__n_neighbors': 5, 'meta_classifier__C': 10.0, 'randomforestclassifier__n_estimators': 50}
Best parameters: {'kneighborsclassifier-1__n_neighbors': 1, 'kneighborsclassifier-2__n_neighbors': 5, 'meta_classifier__C': 0.1, 'randomforestclassifier__n_estimators': 10}
Accuracy: 0.96
注意
StackingClassifier 也支持对 classifiers 参数进行网格搜索。当存在混合层超参数时，GridSearchCV 将尝试按自上而下的顺序替换超参数，即 分类器 -> 单个基础分类器 -> 分类器超参数。例如，给定一个超参数网格，例如
params = {'randomforestclassifier__n_estimators': [1, 100],
'classifiers': [(clf1, clf1, clf1), (clf2, clf3)]}
它将首先使用 (clf1, clf1, clf1) 或 (clf2, clf3) 的实例设置。然后，它将根据 'randomforestclassifier__n_estimators': [1, 100] 替换匹配分类器的 'n_estimators' 设置。
示例 4 - 对在不同特征子集上操作的分类器进行堆叠
不同的第一层分类器可以拟合训练数据集中的不同特征子集。以下示例演示了如何使用 scikit-learn pipeline 和 ColumnSelector 在技术层面实现这一点
from sklearn.datasets import load_iris
from mlxtend.classifier import StackingCVClassifier
from mlxtend.feature_selection import ColumnSelector
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
iris = load_iris()
X = iris.data
y = iris.target
pipe1 = make_pipeline(ColumnSelector(cols=(0, 2)),
LogisticRegression())
pipe2 = make_pipeline(ColumnSelector(cols=(1, 2, 3)),
LogisticRegression())
sclf = StackingCVClassifier(classifiers=[pipe1, pipe2],
meta_classifier=LogisticRegression(),
random_state=42)
sclf.fit(X, y)
StackingCVClassifier(classifiers=[Pipeline(memory=None,
steps=[('columnselector',
ColumnSelector(cols=(0, 2),
drop_axis=False)),
('logisticregression',
LogisticRegression(C=1.0,
class_weight=None,
dual=False,
fit_intercept=True,
intercept_scaling=1,
l1_ratio=None,
max_iter=100,
multi_class='auto',
n_jobs=None,
penalty='l2',
random_state=None,
solver='lbfgs',
tol=0.0...
fit_intercept=True,
intercept_scaling=1,
l1_ratio=None,
max_iter=100,
multi_class='auto',
n_jobs=None,
penalty='l2',
random_state=None,
solver='lbfgs',
tol=0.0001, verbose=0,
warm_start=False),
n_jobs=None, pre_dispatch='2*n_jobs', random_state=42,
shuffle=True, store_train_meta_features=False,
stratify=True, use_clones=True,
use_features_in_secondary=False, use_probas=False,
verbose=0)
示例 5 -- 使用 decision_function 的 ROC 曲线
与其他 scikit-learn 分类器一样，StackingCVClassifier 具有一个 decision_function 方法，可用于绘制 ROC 曲线。请注意，decision_function 期望并要求元分类器实现 decision_function。
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from mlxtend.classifier import StackingCVClassifier
from sklearn.metrics import roc_curve, auc
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn import datasets
from sklearn.preprocessing import label_binarize
from sklearn.multiclass import OneVsRestClassifier
iris = datasets.load_iris()
X, y = iris.data[:, [0, 1]], iris.target
# Binarize the output
y = label_binarize(y, classes=[0, 1, 2])
n_classes = y.shape[1]
RANDOM_SEED = 42
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.33, random_state=RANDOM_SEED)
clf1 = LogisticRegression()
clf2 = RandomForestClassifier(random_state=RANDOM_SEED)
clf3 = SVC(random_state=RANDOM_SEED)
lr = LogisticRegression()
sclf = StackingCVClassifier(classifiers=[clf1, clf2, clf3],
meta_classifier=lr)
# Learn to predict each class against the other
classifier = OneVsRestClassifier(sclf)
使用 predict_proba()
y_score = classifier.fit(X_train, y_train).predict_proba(X_test)
# Compute ROC curve and ROC area for each class
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_classes):
fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_score[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])
# Compute micro-average ROC curve and ROC area
fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_score.ravel())
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])
plt.figure()
lw = 2
plt.plot(fpr[2], tpr[2], color='darkorange',
lw=lw, label='ROC curve (area = %0.2f)' % roc_auc[2])
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()
使用 decision_function()
y_score = classifier.fit(X_train, y_train).decision_function(X_test)
# Compute ROC curve and ROC area for each class
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_classes):
fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_score[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])
# Compute micro-average ROC curve and ROC area
fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_score.ravel())
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])
plt.figure()
lw = 2
plt.plot(fpr[2], tpr[2], color='darkorange',
lw=lw, label='ROC curve (area = %0.2f)' % roc_auc[2])
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()
API
StackingCVClassifier(classifiers, meta_classifier, use_probas=False, drop_proba_col=None, cv=2, shuffle=True, random_state=None, stratify=True, verbose=0, use_features_in_secondary=False, store_train_meta_features=False, use_clones=True, n_jobs=None, pre_dispatch='2*n_jobs')
一个用于 scikit-learn 估计器的“堆叠交叉验证”分类器。
mlxtend v0.4.3 新增
参数
-
classifiers: array-like, shape = [n_classifiers]分类器列表。在
StackingCVClassifer上调用fit方法将拟合这些原始分类器的克隆，这些克隆将存储在类属性self.clfs_中。 -
meta_classifier: object用于拟合分类器集成的元分类器
-
use_probas: bool (默认值: False)如果为 True，则基于预测概率而不是类别标签训练元分类器。
-
drop_proba_col: string (默认值: None)删除特征集中的额外“概率”列，因为它存在冗余：p(y_c) = 1 - p(y_1) + p(y_2) + ... + p(y_{c-1})。这对于对完全共线特征敏感的元分类器很有用。如果设置为
last，则删除最后一个概率列。如果设置为first，则删除第一个概率列。仅当use_probas=True时相关。 -
cv: int, 交叉验证生成器或可迭代对象, 可选 (默认值: 2)确定交叉验证分割策略。cv 的可能输入包括：- None，使用默认的 2 折交叉验证，- 整数，指定
(Stratified)KFold中的折叠数，- 用作交叉验证生成器的对象，- 一个生成训练、测试分割的可迭代对象。对于整数/None 输入，将根据stratify参数的值使用KFold或StratifiedKFold交叉验证。 -
shuffle: bool (默认值: True)如果为 True 且
cv参数是整数，则在交叉验证之前的拟合阶段将对训练数据进行洗牌。如果cv参数是特定的交叉验证技术，则忽略此参数。 -
random_state: int, RandomState 实例或 None, 可选 (默认值: None)控制 cv 分割器的随机性。当
cv为整数且shuffle=True时使用。v0.16.0 新增。 -
stratify: bool (默认值: True)如果为 True 且
cv参数是整数，它将遵循分层 K 折交叉验证技术。如果cv参数是特定的交叉验证技术，则忽略此参数。 -
verbose: int, 可选 (默认值=0)控制构建过程的详细程度。-
verbose=0(默认值)：不打印任何内容 -verbose=1：打印正在拟合的回归器的编号和名称以及当前用于拟合的折叠 -verbose=2：打印有关正在拟合的回归器参数的信息 -verbose>2：将底层回归器的verbose参数更改为 self.verbose - 2 -
use_features_in_secondary: bool (默认值: False)如果为 True，元分类器将同时使用原始分类器的预测和原始数据集进行训练。如果为 False，元分类器将仅使用原始分类器的预测进行训练。
-
store_train_meta_features: bool (默认值: False)如果为 True，则计算自用于拟合元分类器的训练数据的元特征将存储在
self.train_meta_features_数组中，该数组可以在调用fit后访问。 -
use_clones: bool (默认值: True)如果为 True (默认值)，则克隆分类器用于堆叠分类，否则使用原始分类器，它们将在调用
fit方法时重新拟合数据集。因此，如果 use_clones=True，原始输入分类器在使用 StackingCVClassifier 的fit方法后将保持不变。如果您使用的估计器支持 scikit-learn 的 fit/predict API 接口但不兼容 scikit-learn 的clone函数，建议将use_clones设置为 False。 -
n_jobs: int 或 None, 可选 (默认值: None)用于计算的 CPU 数量。
None表示 1 个，除非在 :obj:joblib.parallel_backend上下文中。-1表示使用所有处理器。有关更多详细信息，请参见 :term:术语表 <n_jobs>。v0.16.0 新增。 -
pre_dispatch: int 或 string, 可选控制并行执行期间调度的作业数量。当调度的作业多于 CPU 可处理的数量时，减少此数字有助于避免内存消耗激增。此参数可以是：- None，在这种情况下，所有作业都会立即创建和生成。这适用于轻量级和快速运行的作业，以避免因按需生成作业而导致的延迟 - 一个整数，表示生成的总作业数量 - 一个字符串，表示一个与 n_jobs 相关的表达式，例如 '2*n_jobs'。v0.16.0 新增。
属性
-
clfs_: list, shape=[n_classifiers]已拟合的分类器（原始分类器的克隆）
-
meta_clf_: estimator已拟合的元分类器（原始元估计器的克隆）
-
train_meta_features: numpy array, shape = [n_samples, n_classifiers]训练数据的元特征，其中 n_samples 是训练数据中的样本数量，n_classifiers 是分类器的数量。
示例
有关使用示例，请参阅 https://mlxtend.cn/mlxtend/user_guide/classifier/StackingCVClassifier/
方法
decision_function(X)
预测 X 的类别置信度得分。
参数
-
X: {array-like, sparse matrix}, shape = [n_samples, n_features]训练向量，其中 n_samples 是样本数量，n_features 是特征数量。
返回值
-
scores: shape=(n_samples,) 如果 n_classes == 2，否则为 (n_samples, n_classes)。每个（样本，类别）组合的置信度得分。在二元情况下，大于 0 的 self.classes_[1] 的置信度得分表示将预测此类别。
fit(X, y, groups=None, sample_weight=None)
拟合集成分类器和元分类器。
参数
-
X: numpy array, shape = [n_samples, n_features]训练向量，其中 n_samples 是样本数量，n_features 是特征数量。
-
y: numpy array, shape = [n_samples]目标值。
-
groups: numpy array/None, shape = [n_samples]每个样本所属的组。特定折叠策略（如 GroupKFold()）会使用此参数。
-
sample_weight: array-like, shape = [n_samples], 可选样本权重作为 sample_weights 传递给回归器列表中的每个回归器以及元回归器。如果某些回归器的 fit() 方法不支持 sample_weight，则会引发错误。
返回值
self: object
fit_transform(X, y=None, ***fit_params)
拟合数据，然后转换。
使用可选参数 fit_params 将转换器拟合到 X 和 y，并返回转换后的 X 版本。
参数
-
X: numpy array, shape [n_samples, n_features]训练集。
-
y: numpy array, shape [n_samples]目标值。
-
**fit_params: dict附加拟合参数。
返回值
-
X_new: numpy array, shape [n_samples, n_features_new]转换后的数组。
get_params(deep=True)
返回估计器参数名称，用于支持 GridSearch。
predict(X)
预测 X 的目标值。
参数
-
X: numpy array, shape = [n_samples, n_features]训练向量，其中 n_samples 是样本数量，n_features 是特征数量。
返回值
-
labels: array-like, shape = [n_samples]预测的类别标签。
predict_meta_features(X)
获取测试数据的元特征。
参数
-
X: numpy array, shape = [n_samples, n_features]测试向量，其中 n_samples 是样本数量，n_features 是特征数量。
返回值
-
meta-features: numpy array, shape = [n_samples, n_classifiers]返回测试数据的元特征。
predict_proba(X)
预测 X 的类别概率。
参数
-
X: {array-like, sparse matrix}, shape = [n_samples, n_features]训练向量，其中 n_samples 是样本数量，n_features 是特征数量。
返回值
-
proba: array-like, shape = [n_samples, n_classes] 或如果 n_outputs > 1，则为包含 n_outputs 个此类数组的列表。每个样本的各类别概率。
score(X, y, sample_weight=None)
返回给定测试数据和标签上的平均准确率。
在多标签分类中，这是子集准确率，这是一个严格的指标，因为它要求每个样本的每个标签集都必须被正确预测。
参数
-
X: array-like, shape (n_samples, n_features)测试样本。
-
y: array-like, shape (n_samples,) 或 (n_samples, n_outputs)X 的真实标签。
-
sample_weight: array-like, shape (n_samples,), 默认值=None样本权重。
返回值
-
score: floatself.predict(X) 相对于 y 的平均准确率。
set_params(**params)
设置此估计器的参数。
有效参数键可以通过 get_params() 列出。
返回值
self
属性
named_classifiers
None