Sklearn速查

type

Post

status

Published

summary

本篇笔记收集整理了一些sklearn常用方法（不包含算法的调用，算法调用详见上一篇）的调用、参数详解和调用案例，仅供学习记录和快速查询，还在持续更新中。

slug

sklearn

date

Jun 1, 2023

datasets

自带数据集


from sklearn import datasets

boston = datasets.load_boston()                 # 波士顿房价，506条，13维，回归,`load_boston` has been removed from scikit-learn since version 1.2.
iris = datasets.load_iris()                     # 鸢尾花，150条，4维，三分类
breast_cancer = datasets.load_breast_cancer()   # 乳腺癌，568条、30维，二分类
diabetes = datasets.load_diabetes()             # 糖尿病，442条、10维，回归
digits = datasets.load_digits()                 # 手写数字，1797条、64维，图片多分类
wine = datasets.load_wine()                     # 红酒，178条，13维，三分类

print(iris.keys())  # 查看键(属性)     ['data','target','feature_names','DESCR', 'filename'] 
print(iris.data.shape,boston.target.shape)  # 查看数据的形状 (150, 4) (150,)
print(iris.feature_names)  # 查看有哪些特征 这里共4种
print(iris.DESCR)  # described 描述这个数据集的信息 
print(iris.filename)  # 文件路径

data = iris.data       # 返回的是ndarray类型数据
target = iris.target   # 返回的是ndarray类型数据

样本生成器


from sklearn import datasets

"""生成簇"""
x, y = datasets.make_blobs(n_samples=1000, n_features=2, centers=4,cluster_std=1,random_state=0)
# n_samples:样本数；n_features:特征数（维度）；centers:中心数，也可以是中心的坐标；cluster_std:簇的方差

"""同心圆"""
x, y = datasets.make_circles(n_samples=5000, noise=0.04, factor=0.7,random_state=0)
# noise:噪声；factor:内圆与外圆的距离 为1的时候最小 值在0~1之间 不能为0或1

""""月牙"""
x, y = datasets.make_moons(n_samples=3000, noise=0.05,random_state=0)

"""分类数据"""
x, y =datasets.make_classification(n_classes=4, n_samples=1000, n_features=2, n_informative=2 , n_redundant=0, n_clusters_per_class=1,n_repeated=0, random_state=0)
# n_classes:类的数目
# n_informative:有效的特征数
# n_redundant:冗余特征数 有效特征数的线性组合
# n_repeated:有效特征数和冗余特征数的有效组合
# n_informative + n_redundant + n_repeated < = n_features
# n_clusters_per_class:每一类的簇数
# n_classes * n_clusters_per_class <= 2**n_informative

Metrics

pairwise

pairwise_distances：成对距离


from sklearn.metrics.pairwise import pairwise_distances

"""参数详解
pairwise_distances(X, Y=None, metric=’euclidean’, n_jobs=None, **kwds)
# 计算数组或矩阵之间的成对距离（两两样本之间的距离）
# 如果只输入X：
	# 如果X是数组，计算素组中的每个向量与其他向量的距离。
	# 如果X是矩阵，计算矩阵每一行与其他行的成对距离（矩阵的每一行也相当于一个向量）。
# 如果输入X和Y，则计算X和Y的距离矩阵（X中的每个向量与Y中的每个向量的距离）
# metric：计算距离的方式；可选：['cityblock'，'cosine'，'euclidean'，'l1'，'l2'，'manhattan']
	# 'manhattan'、'cityblock'、'l1'：曼哈顿距离（也叫城市街区距离）
	# 'euclidean'、'l2'：欧式距离
	# 'cosine'：余弦距离
# 各种距离公式详见
# 输出len(X) * len(Y)形状的矩阵
"""

a=[[1,3],[2,2]]
b=[[1,3],[2,2],[1,1]]
pairwise_distances(a,Y=b,metric="euclidean")
"""
array([[0.        , 1.41421356, 2.        ],
       [1.41421356, 0.        , 1.41421356]])
"""

评分方法


from sklearn.metrics import accuracy_score    # 准确率
from sklearn.metrics import precision_score   # 精确率
from sklearn.metrics import recall_score      # 召回率
from sklearn.metrics import f1_score          # f1

from sklearn.metrics import auc                         # 根据输入的不同，可以计算AUC-ROC，也可以计算AUC-PR
from sklearn.metrics import roc_curve                   # ROC 曲线
from sklearn.metrics import roc_auc_score               # AUC-ROC
from sklearn.metrics import precision_recall_curve      # PR 曲线
from sklearn.metrics import average_precision_score     # AUC-PR


y_true = np.array([0, 0, 1, 1])
y_pred = np.array([0.1, 0.4, 0.35, 0.8])
y_lable = (y_pred>=0.5)*1        # 将概率转换成标签
print(y_lable)   # [0 0 0 1]

# AUC 计算方法一，先获取曲线返回值，再算 AUC
fpr, tpr, thresholds = roc_curve(y_true, y_pred, pos_label=1)      # ROC 曲线，返回fpr, tpr，阈值。pos_label:正样本标签,如果是{0,1}则这里是1
roc_auc = auc(fpr, tpr)

precision, recall, thresholds = precision_recall_curve(y_true, y_pred)   # pr曲线，返回精确率，召回率，阈值
pr_auc = auc(recall, precision)


# AUC 计算方法二，直接计算（需要用到预测的概率）
roc_auc = roc_auc_score(y_true, y_pred)             # 计算的时候使用预测的概率
pr_auc = average_precision_score(y_true, y_pred)    # 计算的时候使用预测的概率

a = accuracy_score(y_true, y_lable)    # 准确率,需要将概率转换成标签
p = precision_score(y_true, y_lable)   # 精确率,需要将概率转换成标签
r = recall_score(y_true, y_lable)      # 召回率,需要将概率转换成标签
f1 = f1_score(y_true, y_lable)         # f1值,需要将概率转换成标签

print('auc1:',auc1)
print('auc2:',auc2)
print('准确率:',a)
print('精确率:',p)
print('召回率:',r)
print('f1值:',f1)

Model_selection

如果ShuffleSplit和train_test_split设置的随机种子相同，也就是random_state一样，那么ShuffleSplit的第一次切分方式与train_test_split完全一致

train_test_split：数据集切分（一次）


from sklearn.model_selection import train_test_split

"""参数详解
train_test_split（* arrays，** options ）
train_test_split（data, tag, train_size, test_size, random_state, shuffle=True, stratify）
- train_size：
	- 如果是小数，则表示训练数据的比例，如果不指定test_size，则用1-train_size作为test_size的参数；
	- 如果是整数，则表示获取整数个样本作为训练集，如果不指定test_size，则用所有样本数-train_size作为test_size的参数；
- test_size：同上
- random_state：随机数种子；需要重复实验时，可以设置相同的随机数种子，保证数据相同；
- shuffle：默认值为True，在拆分前打乱数据；
- stratify：指定一个列，如果列中有多个类别，则对每个类别的数据取相同的比例（分层切分数据），一般按照标签的比例拆分所以一般为test_size
"""

X_train, X_test, y_train, y_test = train_test_split（data, tag, test_size=0.3）
# 在使用时，如果没有标签数据，可以只放一个数据就行
train_data, test_data = train_test_split(data_small, test_size=0.3, stratify=data_small['userId'])

ShuffleSplit：数据集切分（多次随机划分）


from sklearn.model_selection import ShuffleSplit

"""参数详解
ShuffleSplit(n_splits=10, test_size=None, train_size=None, random_state=None)
- n_splits：随机划分多少次，默认是10
- test_size：每一折的测试集样本多大
- train_size：每一折的训练集样本多大，一般设置测试集即可
- random_state：随机种子数，通常情况选定一个数就行
"""

rs = ShuffleSplit(n_splits=10,test_size=0.3,random_state=1)
for index in rs.split(df):
    X_train = df.loc[index[0],X.columns]
    y_train = df.loc[index[0],'y']
    X_test = df.loc[index[1],X.columns]
    y_test = df.loc[index[1],'y']

KFold：数据集切分（交叉验证）

KFold通过参数n_splits把数据集分为互斥的n折，每次循环取一折作为测试集；如果shuffle是False，那么程序会按照原始数据集按索引顺序划分


from sklearn.model_selection import KFold

"""参数详解
KFold(n_splits=5, shuffle=False, random_state=None)
- n_splits：划分多少折
- shuffle：是否打乱原始数据集的顺序，默认为False
- random_state：随机种子数，只有在shuffle为True的时候起作用
"""

kf = KFold(n_splits=2)
for train_index, test_index in kf.split(X):
		print("TRAIN:", train_index, "TEST:", test_index)
		X_train, X_test = X.iloc[train_index], X.iloc[test_index]
		y_train, y_test = y.iloc[train_index], y.iloc[test_index]

StratifiedKFold：数据集切分（分层交叉验证）

StratifiedKFold的参数跟KFold是一样的，但是它的功能是实现分层抽样。


from sklearn.model_selection import StratifiedKFold

# 参数详解，详见KFold
StratifiedKFold(n_splits=5, shuffle=False, random_state=None)

skf = StratifiedKFold(n_splits=2)
for train_index, test_index in skf.split(X, y):
		print("TRAIN:", train_index, "TEST:", test_index)
		X_train, X_test = X[train_index], X[test_index]
		y_train, y_test = y[train_index], y[test_index]

cross_value_score：模型选择（交叉验证）


from sklearn.model_selection import cross_val_score

scores = cross_val_score(estimator, X, y=None, scoring=None, cv=None, n_jobs=None, ...)
"""
- estimator：估计方法对象(分类器)
- X：特征
- y：标签
- scoring：模型评分方法
		- https://blog.csdn.net/qq_41076797/article/details/102755893
		- https://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter
- cv：输入整型数字K就调用默认的(Stratified)KFold交叉验证，也可自定义
"""

from sklearn import datasets
from sklearn import svm
from sklearn.model_selection import cross_val_score
iris = datasets.load_iris()
clf = svm.SVC(kernel='linear', C=1)
scores = cross_val_score(clf, iris.data, iris.target, cv=5)
print(scores)

cross_validate：模型选择（交叉验证）

cross_validate方法和cross_validate_score有个两个不同点：

它允许传入多个评估方法，可以列表或字典的形式传入。

最后返回的scores为一个字典(cross_validate_score返回一个 array)，字典的key为：dict_keys(['fit_time', 'score_time', 'test_score', 'train_score'])

fit_time：训练时间；score_time：评分的次数；test_score：测试集的准确率数组；train_score：训练集的准确率数组；train_score和test_score的对比可以帮助判断模型是否存在过拟合或欠拟合等问题


from sklearn.model_selection import cross_validate

scores = cross_validate(estimator, X, y=None, scoring=None, cv=None, n_jobs=None, ...)
"""
- estimator：估计方法对象(分类器)
- X：特征
- y：标签
- scoring：模型评分方法，允许传入多个评估方法，可以列表或字典的形式传入
		- https://blog.csdn.net/qq_41076797/article/details/102755893
		- https://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter
- cv：输入整型数字K就调用默认的(Stratified)KFold交叉验证，也可自定义
"""

from sklearn.model_selection import cross_validate
from sklearn.svm import SVC
from sklearn.datasets import load_iris
iris = load_iris()

scoring = ['precision_macro', 'recall_macro']
# scoring = ['precision','recall','f1','roc_auc','average_precision']
clf = SVC(kernel='linear', C=1, random_state=0)
scores = cross_validate(clf, iris.data, iris.target, scoring=scoring,cv=5, return_train_score=False)

print(scores.keys())   # 获取返回字典的key
print(scores['test_recall_macro'])   # 只获取测试集的召回率分数

💡

负均方误差：虽然均方误差永远为正，但是sklearn中的参数scoring下，均方误差作为评判标准时，却是计算”负均方误差“（neg_mean_squared_error）。这是因为sklearn在计算模型评估指标的时候，会考虑指标本身的性质，均方误差本身是一种误差，所以被sklearn划分为模型的一种损失(loss)。在sklearn当中，所有的损失都使用负数表示，因此均方误差也被显示为负数了。真正的均方误差MSE的数值，其实就是 neg_mean_squared_error去掉负号的数字。

sklearn.model_selection.cross_val_score — scikit-learn 1.2.2 documentation

sklearn.model_selection.cross_validate — scikit-learn 1.2.2 documentation

使用sklearn进行交叉验证 - 小舔哥 - 博客园

机器学习模型评估方法入门到实战[三] - 掘金

GridSearchCV：网格搜索


from sklearn.model_selection import GridSearchCV

"""
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：准确度评价标准，默认None.
	- 常用评分标准设置：‘accuracy’、‘precision’、‘recall’、‘f1’、‘roc_auc’
	- scoring 设置参考：
		- https://blog.csdn.net/qq_41076797/article/details/102755893
		- https://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter
- n_jobs：并行数，int，默认1，-1表示使用所有能用的核
- cv：交叉验证次数，int，默认5，
"""

from sklearn import svm, datasets
from sklearn.model_selection import GridSearchCV
iris = datasets.load_iris()
parameters = {'kernel':('linear', 'rbf'), 'C':[1, 10]}
svc = svm.SVC()
grid_search = GridSearchCV(svc, parameters)
grid_search.fit(iris.data, iris.target)

grid_search.best_score_   # 获取最高分
grid_search.best_params_   # 获取被搜索的最好参数
grid_search.best_estimator_   # 获取最佳估计器（带所有参数的值）

sklearn.model_selection.GridSearchCV — scikit-learn 1.2.2 documentation

Grid SearchCV（网格搜索） - 战争热诚 - 博客园

机器学习之Grid Search网格搜索（自动调参）_图灵的猫.的博客-CSDN博客

RandomizedSearchCV：随机网格搜索


from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import RandomForestClassifier
from scipy.stats import randint

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# 加载数据
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = RandomForestClassifier()
param_dist = {
    'n_estimators': randint(50, 200),  # 树的数量
    'max_features': ['auto', 'sqrt', 'log2'],  # 特征选择策略
    'max_depth': randint(1, 20),  # 树的最大深度
    'min_samples_split': randint(2, 10)  # 内部节点再划分所需的最小样本数
}
random_search = RandomizedSearchCV(model, param_distributions=param_dist, 
                                   n_iter=100, cv=5, verbose=1, 
                                   random_state=42, n_jobs=-1)
random_search.fit(X_train, y_train)
print("Best parameters found: ", random_search.best_params_)
print("Best score found: ", random_search.best_score_)
best_model = random_search.best_estimator_
score = best_model.score(X_test, y_test)
print("Test set score: ", score)


"""
RandomizedSearchCV(
    estimator=model,                    # 要优化的模型（估计器）
    param_distributions=param_dist,     # 字典或列表，指定要调优的超参数及其分布。
    scoring=roc_auc,                    # 评估指标，详见：https://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter；设置多个评估指标：scoring = {'accuracy': 'accuracy', 'precision': 'precision', 'recall': 'recall', 'f1': 'f1'}
    n_iter=100,                         # 要随机选择的参数组合的数量。训练次数=min(超参数空间组合数, n_iter)
    cv=5,                               # 指定交叉验证的折数。
    verbose=1,                          # 控制详细程度。0 表示不输出，1 表示输出简单信息，2 或更高则输出更详细的信息。
    random_state=42,                    # 随机数生成器的种子，用于确保结果的可重现性。
    n_jobs=-1,                          # 并行执行的作业数。-1 表示使用所有可用的 CPU 核心，1 表示单线程执行。
    return_train_score=True             # 如果设置为 True，将返回训练集的分数。默认值为 False。
)
"""


from sklearn import datasets
from sklearn.model_selection import RandomizedSearchCV
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from scipy.stats import uniform
from sklearn.metrics import f1_score, make_scorer

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义模型
model = SVC()

# 定义超参数空间
param_distributions = {
    'C': uniform(0.1, 10),  # 正则化参数
    'kernel': ['linear', 'rbf'],  # 核函数类型
    'gamma': ['scale', 'auto'] + list(uniform(0.001, 0.1).rvs(10)),  # 核系数
}

# 定义自定义评分函数
f1_scorer = make_scorer(f1_score, average='weighted')

# 定义随机搜索
random_search = RandomizedSearchCV(
    model, 
    param_distributions=param_distributions, 
    n_iter=50,  # 采样次数
    cv=5,  # 交叉验证折数
    scoring=f1_scorer,  # 使用自定义评分函数
    random_state=42, 
    n_jobs=-1  # 使用所有CPU核心
)

# 执行随机搜索
random_search.fit(X_train, y_train)

# 输出最佳参数
print("Best parameters found: ", random_search.best_params_)

# 使用最佳参数的模型进行预测
best_model = random_search.best_estimator_
y_pred = best_model.predict(X_test)

# 输出模型性能
from sklearn.metrics import accuracy_score
print("Test accuracy: ", accuracy_score(y_test, y_pred))
print("Test F1 score: ", f1_score(y_test, y_pred, average='weighted'))

Bayesian Optimization：贝叶斯优化

贝叶斯优化（Bayesian Optimization）是一种用于全局优化的技术，特别适用于高维、非凸、昂贵的目标函数。在机器学习中，贝叶斯优化常用于超参数调优，因为它可以在较少的评估次数下找到接近最优的超参数配置。

他是通过拟合一个超参数到评估指标的一个函数，然后求最优解。

scikit-learn本身并没有内置的贝叶斯优化工具，但你可以使用第三方库如scikit-optimize（简称skopt）来实现贝叶斯优化。

pip install scikit-optimize


from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
from skopt import BayesSearchCV
from skopt.space import Real, Categorical, Integer

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义模型
model = SVC()

# 定义超参数空间
param_space = {
    'C': Real(0.1, 10, prior='log-uniform'),  # 正则化参数
    'kernel': Categorical(['linear', 'rbf']),  # 核函数类型
    'gamma': Real(0.001, 0.1, prior='log-uniform'),  # 核系数
}

# 定义贝叶斯搜索
bayes_search = BayesSearchCV(
    model, 
    param_space, 
    n_iter=50,  # 采样次数
    cv=5,  # 交叉验证折数
    random_state=42, 
    n_jobs=-1  # 使用所有CPU核心
)

# 执行贝叶斯搜索
bayes_search.fit(X_train, y_train)

# 输出最佳参数
print("Best parameters found: ", bayes_search.best_params_)

# 使用最佳参数的模型进行预测
best_model = bayes_search.best_estimator_
y_pred = best_model.predict(X_test)

# 输出模型性能
print("Test accuracy: ", accuracy_score(y_test, y_pred))

n_iter参数在贝叶斯优化中表示要进行的优化迭代次数，即在超参数空间中采样的次数。选择合适的n_iter值是一个权衡计算资源和优化效果的问题。以下是一些一般性的建议：

1. 初始探索阶段

在初始探索阶段，通常建议设置较小的n_iter值，以便快速了解超参数空间的大致情况。这个阶段的目的是识别出哪些超参数对模型性能影响较大。

建议区间：10-50次迭代

2. 详细优化阶段

在初始探索阶段之后，可以根据初步结果调整超参数空间，并增加n_iter值以进行更详细的优化。这个阶段的目的是找到更接近最优的超参数配置。

建议区间：50-200次迭代

3. 计算资源允许的情况下

如果计算资源允许，可以进一步增加n_iter值，以获得更精确的优化结果。通常，迭代次数越多，找到最优超参数配置的可能性越大，但计算成本也会相应增加。

建议区间：200-500次迭代

Hyperband优化

Hyperband 是一种用于超参数优化的算法，特别适用于高维、昂贵的目标函数。它通过动态分配资源来加速超参数搜索过程。Hyperband 结合了随机搜索和早停策略，以在有限的计算资源下找到接近最优的超参数配置。

Hyperband的思想是跑多个Successive Halving

Successive Halving的思想如下：

假设优化算法关注n组参数，每组参数训练m轮；

在第一时刻n=16，m=25，进行训练；

第一时刻训练完成之后保留效果最好的前一半的参数，并加大训练轮数m

在第二时刻n=8， m=50，进行训练；

循环，直到找到最优参数。

Hyperband中每一次跑Successive Halving就在之前的Successive Halving结果上进行筛选。

pip install optuna


import optuna
from sklearn import datasets
from sklearn.model_selection import cross_val_score
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义目标函数
def objective(trial):
    C = trial.suggest_loguniform('C', 0.1, 10)
    gamma = trial.suggest_loguniform('gamma', 0.001, 0.1)
    kernel = trial.suggest_categorical('kernel', ['linear', 'rbf'])
    
    model = SVC(C=C, gamma=gamma, kernel=kernel)
    scores = cross_val_score(model, X_train, y_train, cv=5)
    return 1.0 - scores.mean()  # 最大化准确率，即最小化1 - 准确率

# 创建 Optuna 研究
study = optuna.create_study(direction='minimize', sampler=optuna.samplers.TPESampler(), pruner=optuna.pruners.HyperbandPruner())

# 运行 Hyperband 优化
study.optimize(objective, n_trials=50)

# 输出最佳参数
print("Best parameters found: ", study.best_params)

# 使用最佳参数的模型进行预测
best_model = SVC(**study.best_params)
best_model.fit(X_train, y_train)
y_pred = best_model.predict(X_test)

# 输出模型性能
from sklearn.metrics import accuracy_score
print("Test accuracy: ", accuracy_score(y_test, y_pred))

feature_selection

VarianceThreshold：方差特征选择器


from sklearn.feature_selection import VarianceThreshold

"""
VarianceThreshold(threshold=0.0)
- threshold：方差阈值。训练集方差低于此阈值的特征将被删除。默认设置是保留所有具有非零方差的特征，即删除所有样本中具有相同值的特征。
"""

X = [[0, 2, 0, 3], [0, 1, 4, 3], [0, 1, 1, 3]]
selector = VarianceThreshold()
selector.fit_transform(X)

""""
方差阈值确认方法
1、经验或领域知识（领域内常用、论文推荐值等）
2、方差分布：绘制直方图或箱线图来可视化特征的方差分布
3、通过使用交叉验证来评估方差阈值的效果
"""
# 使用绘图法确定阈值
df = df.apply(lambda x: x/x.mean())   # 对数据进行归一化，原数据可能每个特征的分布范围不一样
variances = np.var(df, axis=0)   # var函数计算每个特征的方差，将返回一个包含每个特征方差的一维数组
plt.bar(range(len(variances)), variances)
plt.xlabel('Feature Index')
plt.ylabel('Variance')
plt.title('Variance Distribution')
plt.show()   # 根据绘图结果选择合适的阈值

SelectKBest：特征选择器（按个数选择）


from sklearn.feature_selection import SelectKBest

"""
SelectKBest(score_func=<function f_classif>, *, k=10)
- score_func：特征选择函数
	- 分类问题：
		- chi2：卡方检验——要求数据非负
		- f_classif：F检验
		- mutual_info_classif：互信息
	- 回归问题：
		- f_regression：F检验
		- mutual_info_regression：互信息
- k：期望选择的特征个数
"""

from sklearn.datasets import load_digits
from sklearn.feature_selection import SelectKBest, chi2
X, y = load_digits(return_X_y=True)
X.shape

X_new = SelectKBest(chi2, k=20).fit_transform(X, y)   # 使用卡方检验选择最好的20个特征
X_new.shape

SelectPercentile：特征选择器（按比例选择）


from sklearn.datasets import load_digits
from sklearn.feature_selection import SelectPercentile, chi2
X, y = load_digits(return_X_y=True)
X.shape

X_new = SelectPercentile(chi2, percentile=10).fit_transform(X, y)   # 使用卡方检验选择最好的10%的特征
X_new.shape

RFE、RFECV：特征选择器（递归特征消除法）


from sklearn.feature_selection import RFE
from sklearn.feature_selection import RFECV   # 含交叉验证
from sklearn.svm import SVR
from sklearn.datasets import make_friedman1

"""
RFECV(estimator, *, step=1, min_features_to_select=1, cv=None, scoring=None, verbose=0, n_jobs=None, importance_getter='auto')
- estimator：监督学习估计器
- step：
	- 大于1：每次迭代要删除的特征个数
	- 小于1：每次迭代要删除的特征比例
- min_features_to_select：最少要选择的特征数量
- cv：交叉验证折数
- scoring：评分函数，详见
- verbose：控制输出的详细程度
"""

X, y = make_friedman1(n_samples=50, n_features=10, random_state=0)
estimator = SVR(kernel="linear")
selector = RFECV(estimator, step=1, cv=5)
selector = selector.fit(X, y)
selector.support_   # 所选特征的掩码，返回一个长度与原字段数相同的布尔值数组，对应值为1，则特征被保留，否则被删除
selector.ranking_   # 特征排序，ranking_[i] 对应第i个特征的排名位置

SelectFromModel：特征选择器（嵌入法）


from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LogisticRegression

"""
SelectFromModel(estimator, *, threshold=None, prefit=False, norm_order=1, max_features=None, importance_getter='auto')
- estimato：估计器
- threshold：选择特征的阈值
- max_features：要选择的最大特征数
"""

from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LogisticRegression
X = [[ 0.87, -1.34,  0.31 ],
     [-2.79, -0.02, -0.85 ],
     [-1.34, -0.48, -2.55 ],
     [ 1.92,  1.48,  0.65 ]]
y = [0, 1, 0, 1]
selector = SelectFromModel(estimator=LogisticRegression()).fit(X, y)

selector.estimator_.coef_
selector.threshold_
selector.get_support()
selector.transform(X)

天猫用户重复购买预测赛题——特征优化最终结果 148/0.6812_jialun0116的博客-CSDN博客

Feature_extraction

text

CountVectorizer：词频统计


from sklearn.feature_extraction.text import CountVectorizer

"""
# 参数
CountVectorizer(*, input='content')
- input：string {‘filename’, ‘file’, ‘content’}, default=’content’
	- filename：文件名列表
	- file：文件名
	- 否则，类型可以是string或byte。

# 属性
vocabulary_：返回词组成的字典

# 方法：
fit()
fit_transform()
get_feature_names()
get_stop_words()
get_params()
"""

# 示例
corpus = ['This is the first document.','This document is the second document.','And this is the third one.','Is this the first document?']
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(corpus)
# 获取字典，每个词有一个编号索引
print(sorted(vectorizer.vocabulary_.items(),key=lambda x: x[1],reverse=False))
# 将词袋转换成矩阵
X.toarray()

Externals

joblib：保存和加载模型&参数


from sklearn.ensemble import RandomForestClassifier
from sklearn import datasets

# sklearn在 0.23 之后的版本中就不包含joblib库了
from sklearn.externals import joblib  # 旧版
import joblib   # 新版

(X,y) = datasets.load_iris(return_X_y=True)
rfc = RandomForestClassifier(n_estimators=100,max_depth=100)
rfc.fit(X,y)
print(rfc.predict(X[0:1,:]))

joblib.dump(rfc, 'saved_model/rfc.pkl')   #save model
rfc2 = joblib.load('saved_model/rfc.pkl')   #load model
print(rfc2.predict(X[0:1,:]))

Compose

ColumnTransformer：特征变换方法


"""
功能：将数据中的指定的特征按照指定的方式进行转换
参数：参数很多，但一般只需要看前两个
ColumnTransformer(transformers, *, remainder='drop', sparse_threshold=0.3, n_jobs=None, transformer_weights=None, verbose=False, verbose_feature_names_out=True)
	- remainder：剩余部分的处理方式：drop删除，passthrough忽略，不做任何处理
	- transformers：转换器，一个三元素元组，分别是转换器的名称、转换的方式、需要转换的列(组成的列表)，例如：（名称，对象，列）
"""
import numpy as np
import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder   # 独热编码
from sklearn.preprocessing import StandardScaler   # 标准化
from sklearn.preprocessing import MinMaxScaler   # 最大最小值归一化
from sklearn.preprocessing import KBinsDiscretizer   # 离散化
from sklearn.preprocessing import LabelEncoder   # 连续编号编码，只接受一维数据(在ColumnTransformer中使用会报错)
from sklearn.preprocessing import OrdinalEncoder   # 连续编号编码，接受二维及以上数据

data = {
    'age': [21, 15, 22, 25, 26],
    'gender': ['男', '女', '男', '男', '女'],
    'major': ['计算机', '软件工程', '物理', '计算机', '数学'],
		'score': [87, 38, 90, 95, 60],
		'hobby': ['篮球', None, '足球', '乒乓球', '游泳']
}
data = pd.DataFrame(data)

ct = ColumnTransformer([
    ('ordinal', OrdinalEncoder(), ['gender','hobby']),          # 连续编号编码
    ('onehot', OneHotEncoder(sparse=False), ['major']),         # onehot
    ('discretizer', KBinsDiscretizer(n_bins=3), ['age']),       # 离散化
    ('scale', StandardScaler(), ['score']),                     # 标准化
		('num', SimpleImputer(strategy='median'), [0, 1]),          # 填充缺失值

],remainder='passthrough')                                      # 剩余字段不做操作
],remainder=StandardScaler())                                   # 剩余字段标准化
ct.fit_transform(data)

"""
array([[ 1.        ,  2.        ,  0.        ,  0.        ,  1.        ,
         0.        ,  1.        ,  0.        ,  0.        ,  0.59862721],
       [ 0.        ,  4.        ,  0.        ,  0.        ,  0.        ,
         1.        ,  1.        ,  0.        ,  0.        , -1.65773689],
       [ 1.        ,  3.        ,  0.        ,  1.        ,  0.        ,
         0.        ,  0.        ,  1.        ,  0.        ,  0.73677195],
       [ 1.        ,  0.        ,  0.        ,  0.        ,  1.        ,
         0.        ,  0.        ,  0.        ,  1.        ,  0.96701319],
       [ 0.        ,  1.        ,  1.        ,  0.        ,  0.        ,
         0.        ,  0.        ,  0.        ,  1.        , -0.64467546]])
"""

超好用的特征变换方法-ColumnTransformer

impute

SimpleImputer：缺失填充


"""
SimpleImputer(*, missing_values=nan, strategy=‘mean’, fill_value=None, verbose=0, copy=True, add_indicator=False)
	- missing_values：缺失值类型：int, float, str, np.nan(默认)或是None
	- strategy：空值填充的策略：mean(均值)、median(中位数)、most_frequent(众数)、constant(自定义值，由fill_value的值指定)
	- fill_value：填充值，当strategy=="constant"时生效，默认为Zone(0)
	- copy：（默认）True，表示对数据的副本进行处理，False对数据原地修改。
"""

import numpy as np
from sklearn.impute import SimpleImputer   # 缺失值填充
X1 = np.array([[1, 2, np.nan],
               [4, np.nan, 6],
               [np.nan, 8, 9]])
imp = SimpleImputer(missing_values=np.nan, strategy='mean')
print(imp.fit_transform(X1))

缺失值处理：SimpleImputer（简单易懂 + 超详细）