【机器学习】基于scikit-learn进行特征工程
编辑：Peter 作者：Peter
今天给大家分享如何基于机器学习建模全能包scikit-learn进行特征工程feature-engineering。
特征工程
机器学习的特征工程（Feature Engineering）是机器学习项目中一个至关重要的步骤，它涉及从原始数据中提取、选择和转换特征，以便更好地训练机器学习模型。特征工程直接影响到模型的性能，因为机器学习算法的性能很大程度上依赖于输入数据的表示（即特征）。
数据和特征决定了机器学习的上限，而模型和算法只是逼近这个上限而已。
基于scikit-learn做特征工程
scikit-learn中主要用于特征的工具包：
- 数据预处理sklearn-Processing-data: https://scikit-learn.org/stable/modules/preprocessing.html#non-linear-transformation
- 特征选择sklearn-feature-selection：https://scikit-learn.org/stable/modules/feature_selection.html
- 降维sklearn-Dimensionality-reduction：https://scikit-learn.org/stable/modules/decomposition.html#decompositions
import numpy as np
import pandas as pd
import warnings
warnings.filterwarnings('ignore')
导入数据
使用鸢尾花数据集iris
from sklearn.datasets import load_iris
iris = load_iris()
# 特征数据X
X = iris.data
# 目标变量
y = iris.target
X[:5]
array([[5.1, 3.5, 1.4, 0.2],
[4.9, 3. , 1.4, 0.2],
[4.7, 3.2, 1.3, 0.2],
[4.6, 3.1, 1.5, 0.2],
[5. , 3.6, 1.4, 0.2]])
y[:5]
array([0, 0, 0, 0, 0])
数据预处理processing-data
数据标准化
标准化是将数据缩放到均值为0，标准差为1的过程。使用preproccessing库的StandardScaler类对数据进行标准化的代码如下：
- ：x的均值
- S：x的标准差
from sklearn.preprocessing import StandardScaler
# 标准化后的数据
ss_data = StandardScaler().fit_transform(X)
ss_data[:5]
array([[-0.90068117, 1.01900435, -1.34022653, -1.3154443 ],
[-1.14301691, -0.13197948, -1.34022653, -1.3154443 ],
[-1.38535265, 0.32841405, -1.39706395, -1.3154443 ],
[-1.50652052, 0.09821729, -1.2833891 , -1.3154443 ],
[-1.02184904, 1.24920112, -1.34022653, -1.3154443 ]])
用于稀疏数据（比如文本数据）的标准化MaxAbsScaler（最大值缩放到1）：
from sklearn.preprocessing import MaxAbsScaler
scaler = MaxAbsScaler()
X_scaled = scaler.fit_transform(X)
数据归一化
方式1：基于最大值最小值的归一化
from sklearn.preprocessing import MinMaxScaler
mm_data = MinMaxScaler().fit_transform(X)
mm_data[:5]
array([[0.22222222, 0.625 , 0.06779661, 0.04166667],
[0.16666667, 0.41666667, 0.06779661, 0.04166667],
[0.11111111, 0.5 , 0.05084746, 0.04166667],
[0.08333333, 0.45833333, 0.08474576, 0.04166667],
[0.19444444, 0.66666667, 0.06779661, 0.04166667]])
方式2：基于规则l2的归一化处理
from sklearn.preprocessing import Normalizer
#归一化，返回值为归一化后的数据
normal_data = Normalizer().fit_transform(X)
normal_data[:5]
array([[0.80377277, 0.55160877, 0.22064351, 0.0315205 ],
[0.82813287, 0.50702013, 0.23660939, 0.03380134],
[0.80533308, 0.54831188, 0.2227517 , 0.03426949],
[0.80003025, 0.53915082, 0.26087943, 0.03478392],
[0.790965 , 0.5694948 , 0.2214702 , 0.0316386 ]])
数据二值化处理Binarizer
连续型特征的二值化处理方法：大于设置阈值的赋值为1，其他为0：
from sklearn.preprocessing import Binarizer
#二值化处理：阈值设置为3
bin_data = Binarizer(threshold=3).fit_transform(X)
bin_data[:5]
array([[1., 1., 0., 0.],
[1., 0., 0., 0.],
[1., 1., 0., 0.],
[1., 1., 0., 0.],
[1., 1., 0., 0.]])
独热码Onehot
from sklearn.preprocessing import OneHotEncoder
# 哑编码：对IRIS数据集的目标值进行独热码
OneHotEncoder().fit_transform(y.reshape((-1,1)))
<150x3 sparse matrix of type '<class 'numpy.float64'>'
with 150 stored elements in Compressed Sparse Row format>
scikit-learn中的OneHotEncoder通常与ColumnTransformer一起使用，特别是在处理混合类型数据时：
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
# 假设 X_categorical 是包含分类变量的DataFrame
categorical_features = ['feature1', 'feature2']
onehot = OneHotEncoder(handle_unknown='ignore')
col_trans = ColumnTransformer([("onehot", onehot, categorical_features)], remainder='passthrough')
X_transformed = col_trans.fit_transform(X_categorical)
# 注意：X_transformed 是一个稀疏矩阵，用toarray() 转换为NumPy数组
X_transformed_array = X_transformed.toarray()
缺失指填充Imputer
模拟存在缺失值的数据
import pandas as pd
import numpy as np
df = pd.DataFrame({
"chinese":[100,np.nan,98,90,np.nan],
"math":[100,np.nan,98,80,94],
})
df
| chinese | math | |
|---|---|---|
| 0 | 100.0 | 100.0 |
| 1 | NaN | NaN |
| 2 | 98.0 | 98.0 |
| 3 | 90.0 | 80.0 |
| 4 | NaN | 94.0 |
from sklearn.impute import SimpleImputer
# 列方向：使用现有值的均值填充
imputer = SimpleImputer(missing_values=np.nan, strategy="mean")
imputer.fit(df)
官网地址：https://scikit-learn.org/stable/modules/generated/sklearn.impute.SimpleImputer.html
sklearn.impute.SimpleImputer(
missing_values=nan,
strategy='mean',
fill_value=None,
copy=True,
add_indicator=False,
keep_empty_features=False
)
impute_data = imputer.transform(df)
impute_data
array([[100., 100.],
[ 96., 93.],
[ 98., 98.],
[ 90., 80.],
[ 96., 94.]])
(100+98+90) / 3 # chinese列
96.0
(100+98+80+94) / 4 # math列
93.0
手动计算的结果和自动填充的结果是吻合的。
数据变换
基于多项式、指数、对数、平方根等进行变换；
from sklearn.preprocessing import PolynomialFeatures
# 参数degree为度，默认值为2
poly_data = PolynomialFeatures(degree=2).fit_transform(X) # X = iris.data
可以自定义变换函数：
from sklearn.preprocessing import FunctionTransformer
# 自定义变换函数
def custom_transform(X):
return X * 2
transformer = FunctionTransformer(custom_transform)
X_transformed = transformer.fit_transform(X)
还有其他的变换，比如：Box-Cox变换等
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from scipy import stats
# 生成一组不符合正态分布的数据（例如，指数分布数据）
data = np.random.exponential(size=100)
# 进行Box-Cox变换
transformed_data, lambda_value = stats.boxcox(data)
# ----------
plt.scatter(x=range(len(data)),y=data)
plt.scatter(x=range(len(data)),y=transformed_data)
plt.show()
特征选择
根据特征选择的形式又可以将特征选择方法分为3种：
- Filter：过滤法，不用考虑后续学习器，按照发散性或者相关性对各个特征进行评分，设定阈值或者待选择阈值的个数，选择特征。
- Wrapper：包装法，需考虑后续学习器，根据目标函数（通常是预测效果评分），每次选择若干特征，或者排除若干特征。
- Embedded：嵌入法，是Filter与Wrapper方法的结合。先使用某些机器学习的算法和模型进行训练，得到各个特征的权值系数，根据系数从大到小选择特征。我们使用sklearn中的feature_selection库来进行特征选择。
Filter方法
基于方差
使用方差选择法，先要计算各个特征的方差，然后根据阈值，选择方差大于阈值的特征
from sklearn.feature_selection import VarianceThreshold
# 方差选择法：threshold为方差的阈值
var_data = VarianceThreshold(threshold=3).fit_transform(X)
var_data[:5]
array([[1.4],
[1.4],
[1.3],
[1.5],
[1.4]])
基于卡方检验
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
chi_data = SelectKBest(chi2,k=3).fit_transform(X,y)
Wrapper方法
递归特征消除（Recursive Feature Elimination，RFE）
递归特征消除（Recursive Feature Elimination，RFE）是一种在机器学习中广泛使用的特征选择方法。它首先使用所有特征训练一个模型，通过迭代地训练模型并剔除不重要的特征，直到达到预设的特征数量或满足其他停止条件为止。
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
# estimator基模型；n_features_to_select 选择的特征数
rfe_data = RFE(estimator=LogisticRegression(), n_features_to_select=3).fit_transform(iris.data, iris.target)
rfe_data[:5]
array([[3.5, 1.4, 0.2],
[3. , 1.4, 0.2],
[3.2, 1.3, 0.2],
[3.1, 1.5, 0.2],
[3.6, 1.4, 0.2]])
Embedded方法
带有惩罚项的特征选择
from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LogisticRegression
# 基模型：带L2惩罚项的逻辑回归
sfm_data1 = SelectFromModel(LogisticRegression(penalty="l2", C=0.1)).fit_transform(X, y)
sfm_data1[:5]
array([[1.4, 0.2],
[1.4, 0.2],
[1.3, 0.2],
[1.5, 0.2],
[1.4, 0.2]])
基于树模型的特征选择
树模型比如GBDT可用来作为基模型进行特征选择
from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import GradientBoostingClassifier
# GBDT作为基模型的特征选择
sfm_data2 = SelectFromModel(GradientBoostingClassifier()).fit_transform(X, y)
sfm_data2[:5]
array([[1.4, 0.2],
[1.4, 0.2],
[1.3, 0.2],
[1.5, 0.2],
[1.4, 0.2]])
数据降维
机器学习建模过程中，当特征数量非常大时，模型的训练时间、预测时间以及所需的计算资源（如内存和CPU/GPU）都会显著增加。通过降维，可以减少特征的数量，从而降低计算成本，使模型更加高效。
基于主成分分析PCA
PCA算法，全称为主成分分析（Principal Component Analysis），是一种无监督学习算法，主要用于数据降维和特征提取。PCA通过线性变换将原始数据映射到一个新的低维空间，以保留数据中的最大方差，即保留数据的主要信息。
from sklearn.decomposition import PCA
# PCA：n_components为主成分数目
pca_data = PCA(n_components=2).fit_transform(X)
pca_data[:5]
array([[-2.68412563, 0.31939725],
[-2.71414169, -0.17700123],
[-2.88899057, -0.14494943],
[-2.74534286, -0.31829898],
[-2.72871654, 0.32675451]])
基于线性判别分析（LDA）
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
#线性判别分析法LDA: n_components为降维后的维数
lda_data = LDA(n_components=2).fit_transform(X, y)
lda_data[:5]
array([[ 8.06179978, -0.30042062],
[ 7.12868772, 0.78666043],
[ 7.48982797, 0.26538449],
[ 6.81320057, 0.67063107],
[ 8.13230933, -0.51446253]])