Sklearn
安装：
pip install -U scikit-learndatasets
自带数据集
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去掉负号的数字。
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_ # 获取最佳估计器（带所有参数的值）
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-optimizefrom 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 optunaimport 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)
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]]) """
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))