526互联

sklearn模块中的preprocessing、model_selection、feature_selection

发布时间 2023-04-23 15:59:06作者: 木田心

sklearn模块中的preprocessing、model_selection、feature_selection

1. preprocessing

1.1. LabelEncoder()

  • 可以给标签分配一个可数的连续编号

    from sklearn.preprocessing import LabelEncoder
label = LabelEncoder()
label.fit(['grade 1', 'grade 3', 'grade 1', 'grade 2', 'grade3', 'grade 1']) #对标签分类
list(label.classes_)
## 输出结果
['grade 1', 'grade 2', 'grade 3', 'grade3']

    label.transform(['grade 3', 'grade 1', 'grade 2']) #得到对应的编号
## 输出结果
array([2, 0, 1])

    label.inverse_transform([1,0,2]) #得到编号对应的类别标签
## 输出结果
array(['grade 2', 'grade 1', 'grade 3'], dtype='<U7')

2. model_selection

2.1. 样本分割——train_test_split()

  • 用来分割训练集和测试集，直接得到训练集和测试集的数据

    ## 语法
sklearn.model_selection.train_test_split(x, y=None, test_size=None, train_size=None, random_state=None, shuffle=True, stratify=None)

    test_size：默认值0.25

    shuffle：分割数据前是否打散重新排序，默认是打乱顺序

    stratify：分别将训练集、测试集中不同类别的数据比例保持某个比例，即分层采样

    ## 示例
import numpy as np
from sklearn.model_selection import train_test_split

x = np.random.randint(1,100,20).reshape(10,2)
print('x: \n',x)
x_train, x_test = train_test_split(x, random_state=1)
print('x_train:\n', x_train)
print('x_test:\n', x_test)

## 输出结果
x: 
 [[27 69]
 [58  8]
 [26 83]
 [98 87]
 [80 42]
 [86 26]
 [92 87]
 [71 16]
 [19 75]
 [91 41]]
x_train:
 [[80 42]
 [27 69]
 [98 87]
 [58  8]
 [71 16]
 [19 75]
 [86 26]]
x_test:
 [[26 83]
 [91 41]
 [92 87]]

2.2. 样本分割——ShuffleSplit()

  • 用来分割训练集和测试集，像是train_test_split的升级版，可以随机划分n次，做交叉验证。得到的不是训练集和测试集数据，而是训练集和测试集数据所在的样本行

    ## 语法
sklearn.model_selection.ShuffleSplit(n_splits=10, test_size=None, train_size=None, random_state=None)

    n_splits：随机排列、划分的次数，默认是10次

    test_size：测试集比例

    train_size：训练集比例

    random_state：设置随即状态数，可以得到相同的划分结果

    ## 示例
import numpy as np
from sklearn.model_selection import ShuffleSplit

x = np.random.randint(1,100,20).reshape(10,2)
print('x: \n',x)
ts = ShuffleSplit(n_splits=10, test_size=0.3, random_state=0)
for train, test in ts.split(x):
    print('train:{}, test:{}'.format(train,test))

## 输出结果
x: 
 [[47 40]
 [44 53]
 [53 92]
 [21 84]
 [71 81]
 [57 67]
 [69  1]
 [32 88]
 [24 89]
 [84 85]]
train:[9 1 6 7 3 0 5], test:[2 8 4]
train:[2 9 8 0 6 7 4], test:[3 5 1]
train:[4 5 1 0 6 9 7], test:[2 3 8]
train:[2 7 5 8 0 3 4], test:[6 1 9]
train:[4 1 0 6 8 9 3], test:[5 2 7]
train:[5 2 6 3 7 4 0], test:[1 8 9]
train:[7 8 6 5 4 9 0], test:[3 2 1]
train:[3 5 6 7 1 8 4], test:[0 9 2]
train:[1 4 5 3 6 0 2], test:[7 8 9]
train:[0 8 3 7 9 6 4], test:[1 2 5]

2.3. 样本分割——KFold()

  • K折交叉验证

  • 语法

    sklearn.model_selection.KFold(n_splits=5, *, shuffle=False, random_state=None)

    n_splits：划分的折数，至少是2

    shuffle：bool，控制是否打乱样本顺序，但是划分后每组数据中顺序不会被打乱

    random_state：设置随机状态数据，只对shuffle=True时有效

  • 当样本数不能平均分配给每组时，前几组数据比后几组数据多一个样本

  • 方法

    get_n_splits([X, y, groups])：返回折数

    split(X[, y, groups])：返回生成的训练集和测试集的样本索引

  • 示例

    import numpy as np
from sklearn.model_selection import KFold
x = np.random.randint(1,100,(20,3))
print('x:',x)
kf = KFold(n_splits=3)
print('折数为',kf.get_n_splits(x))
for i, (train, test) in enumerate(kf.split(x)):
    print('fold：', i)
    print('train:', train)
    print('test:', test)

## 输出结果
x: [[12 53 76]
 [54 25 51]
 [49 74 23]
 [48 12 11]
 [ 8 33  3]
 [26 14 15]
 [52 28 15]
 [51 15 85]
 [82 95 89]
 [81 19 84]
 [67 50 46]
 [79  9 70]
 [27 57 49]
 [96 54 21]
 [99 44 71]
 [48 37 93]
 [24 26 91]
 [51  7  5]
 [37 34 42]
 [ 1 22 38]]
折数为 3
fold： 0
train: [ 7  8  9 10 11 12 13 14 15 16 17 18 19]
test: [0 1 2 3 4 5 6]
fold： 1
train: [ 0  1  2  3  4  5  6 14 15 16 17 18 19]
test: [ 7  8  9 10 11 12 13]
fold： 2
train: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13]
test: [14 15 16 17 18 19]

2.4. 交叉验证——cross_validate()

  • 交叉验证

    ## 语法
sklearn.model_selection.cross_validate(estimator, X, y=None, *, groups=None, scoring=None, cv=None, n_jobs=None, verbose=0, fit_params=None, pre_dispatch='2*n_jobs', return_train_score=False, return_estimator=False, error_score=nan)

    estimator：用来拟合数据的对象

    X：要拟合的数据，可以是列表或数组

    y：在监督学习的情况下要预测的目标变量

    groups：将数据集拆分为训练集、测试集时使用的样本分组标签，仅与 “Group” cv 实例(例如 GroupKFold )结合使用

    scoring：列表、元组或字典，评估cross-validated模型在测试集上的性能的指标

    cv：可以是int、交叉验证生成器、迭代器。默认是5折交叉验证，若为int，则指定折数

    n_jobs：并行运算的数量

    fit_params：字典，传递给估计器的拟合方法的参数

    return_train_score：是否包含训练得分

    return_estimator：是否返回每种划分的估计器

    error_score：在估计器拟合发生错误时分配给得分的值

  • ## 示例
from sklearn import datasets, linear_model
from sklearn.model_selection import cross_validate
diabetes = datasets.load_diabetes()  #数据集
x = diabetes.data[:150]
y = diabetes.target[:150]
lasso = linear_model.Lasso()
##单个评估指标
cv_results = cross_validate(lasso, x, y, cv=3)
print(cv_results)

## 输出结果
{'fit_time': array([0.0029819 , 0.00101924, 0.        ]), 'score_time': array([0., 0., 0.]), 'test_score': array([0.33150734, 0.08022311, 0.03531764])}

    ##多个评估指标
cv_results = cross_validate(lasso, x, y, cv=3, scoring=('r2','neg_mean_squared_error'), return_train_score=True)
print(cv_results)

## 输出结果
{'fit_time': array([0.00100017, 0.00100017, 0.0010078 ]), 'score_time': array([0., 0., 0.]), 'test_r2': array([0.33150734, 0.08022311, 0.03531764]), 'train_r2': array([0.28010158, 0.39088426, 0.22784852]), 'test_neg_mean_squared_error': array([-3635.51152303, -3573.34242148, -6114.78229547]), 'train_neg_mean_squared_error': array([-4141.52635215, -3755.8476331 , -3657.43943045])}

2.5. 参数选择——GridSearchCV()

  • 选择模型参数，对估计器的指定参数值进行详尽搜索

  • 语法

    sklearn.model_selection.GridSearchCV(estimator, param_grid, *, scoring=None, n_jobs=None, refit=True, cv=None, verbose=0, pre_dispatch='2*n_jobs', error_score=nan, return_train_score=False)

    estimator：估计器

    param_grid：估计器的参数，字典形式，参数名作为字典的键，参数值列表作为值

    scoring：对交叉验证模型评估的策略

    n_jobs：并行运算的个数

    refit：使用整个数据集上找到的最佳参数重新拟合估计器

    cv：划分策略，默认None表示5折交叉验证

    pre_dispatch：控制在并行运算时调度的作业数

    error_score：在估计器拟合发生错误时分配给得分的值，若设置为'raise'，会引发错误

    return_train_score：是否返回训练集得分

  • 属性

    cv_results_：返回字典

    best_estimator_：具有最高得分的估计器

    best_score_：最优估计器的mean cross-validated score

    best_params_：最优估计器对应的参数

    best_index_：最优估计器对应的参数的索引

    scorer_：用来选择最优估计器的指标

    n_splits_：交叉验证的折数

    refit_time_：在整个数据集上重新拟合最优模型所用的秒数

    multimetric_：bool，是否计算多个指标

  • 方法

    decision_function(X)：返回基于最优估计器的y_score

    fit(X[, y, groups])

    get_params([deep])：返回估计器的参数字典

    inverse_transform(X)：基于最优估计器计算的结果

    predict(X)：返回基于最优估计器预测的结果

    predict_log_proba(X)：返回基于最优估计器预测的对数概率

    predict_proba(X)：返回基于最优估计器预测的概率

    score(X[, y])：返回按照scorer_定义的得分，若没有定义，则用best_estimator_.score方法

    score_samples(X)：基于最优估计器计算

    set_params(**params)：设置估计器的参数

    transform(X)：基于最优估计器计算

  • 示例

    from sklearn import datasets, svm
from sklearn.model_selection import GridSearchCV
iris = datasets.load_iris()  #鸢尾花数据集
parameters = {'kernel':('linear', 'rbf'), 'C':[1, 10]}  #参数
svc = svm.SVC()
clf = GridSearchCV(svc, parameters) #建立选择支持向量机的参数的函数
clf.fit(iris.data, iris.target)
print(clf.cv_results_)

## 输出结果
{'mean_fit_time': array([0.00067449, 0.00040631, 0.00040002, 0.00040131]), 'std_fit_time': array([0.00093521, 0.00049773, 0.00048992, 0.00049151]), 'mean_score_time': array([0.00020099, 0.00019956, 0.        , 0.00019999]), 'std_score_time': array([0.00040197, 0.00039911, 0.        , 0.00039997]), 'param_C': masked_array(data=[1, 1, 10, 10],
             mask=[False, False, False, False],
       fill_value='?',
            dtype=object), 'param_kernel': masked_array(data=['linear', 'rbf', 'linear', 'rbf'],
             mask=[False, False, False, False],
       fill_value='?',
            dtype=object), 'params': [{'C': 1, 'kernel': 'linear'}, {'C': 1, 'kernel': 'rbf'}, {'C': 10, 'kernel': 'linear'}, {'C': 10, 'kernel': 'rbf'}], 'split0_test_score': array([0.96666667, 0.96666667, 1.        , 0.96666667]), 'split1_test_score': array([1.        , 0.96666667, 1.        , 1.        ]), 'split2_test_score': array([0.96666667, 0.96666667, 0.9       , 0.96666667]), 'split3_test_score': array([0.96666667, 0.93333333, 0.96666667, 0.96666667]), 'split4_test_score': array([1., 1., 1., 1.]), 'mean_test_score': array([0.98      , 0.96666667, 0.97333333, 0.98      ]), 'std_test_score': array([0.01632993, 0.02108185, 0.03887301, 0.01632993]), 'rank_test_score': array([1, 4, 3, 1])}

    print('最优参数：', clf.best_params_)
## 输出结果
最优参数： {'C': 1, 'kernel': 'linear'}

3. feature_selection

3.1. RFECV()

  • 递归特征消除，通过交叉验证来选择特征

  • 语法

    sklearn.feature_selection.RFECV(estimator, *, step=1, min_features_to_select=1, cv=None, scoring=None, verbose=0, n_jobs=None, importance_getter='auto')

    estimator：一个有监督的估计器，并且具有fit方法，通过coef_或feature_importances_属性提供特征重要度

    step：int or float，若为大于等于1的整数，则表示每次迭代移除的特征数；若为0到1之间的小数，则表示每次迭代移除的特征百分比

    min_features_to_select：被选择的特征的最小数量

    cv：int, cross-validation generator or an iterable，决定交叉验证的划分策略，默认是None，表示5折交叉验证；若为整数表示折数

    scoring：str或可调用的函数

    verbose：控制输出的冗长长度

    n_jobs：并行运算的数量，默认是None，表示1

    importance_getter：默认是'auto'，表示通过coef_或feature_importances_属性获得特征重要度；也可以通过字符串指定获取特征重要度的属性名；还可以用可调用的函数

  • 属性

    classes_：当估计器是分类器时，获得类别标签

    estimator_：用于选择特征的拟合的估计器

    cv_results_：字典，键包含split(k)_test_score，mean_test_score，std_test_score

    n_features_：通过交叉验证选择特征的个数

    n_features_in_：输入特征的数量

    feature_names_in_：输入特征的名字，若没有，则默认是['x0', 'x1', ... , 'x(n_features_in_ - 1)']

    ranking_：特征的排序，被选择的特征的排序都为1，其余特征从2开始往后排

    support_：返回bool值，表示特征是否被选中

  • 方法

    decision_function(X)：返回的类别顺序对应属性classes_中的顺序

    fit(X, y[, groups])

    fit_transform(x[, y])

    get_feature_names_out([input_features])：根据模型选择的特征得到特征的标记

    get_params([deep])：返回估计器的参数字典

    get_support([indices])：返回bool值或整数索引，表示特征是否被选中

    inverse_transform(X)

    predict(X)：将x减少到所选特征，并预测

    predict_log_proba(X)：

    predict_proba(X)：返回预测的各类的概率

    score(X, y, **fit_params)：将x减少到所选特征，返回估计器得分

    set_output(*[, transform])：设置输出

    set_params(**params)：设置估计器的参数

    transform(X)：将x减少到所选特征

  • 示例

    from sklearn.datasets import make_friedman1
from sklearn.feature_selection import RFECV
from sklearn.svm import SVR
x, y = make_friedman1(n_samples=50, n_features=20, random_state=1) #生成数据
estimator = SVR(kernel='linear')  #SVR估计器
selector = RFECV(estimator, step=2, cv=5)  #选择器
selector.fit(x, y)
print('变量选择情况：', selector.support_)
print('变量排序：', selector.ranking_)
print('模型得分：', selector.score(x, y))

## 输出结果
变量选择情况： [ True  True False  True  True False False False False False False False False False False False False False False False]
变量排序： [1 1 7 1 1 4 6 5 3 9 4 9 3 6 2 7 5 2 8 8]
模型得分： 0.5930325713633828