特征工程（三）特征选择

经过“数据清理”和“特征变换”后的数据集，已经满足了数据科学项目中算法对数值的基本要求。但是，不呢止步于此，数据集的特征数量、质量会影响计算效率和最终模型的预测、分类效果。所以要对特征进行选择，即根据具体的项目选择适合的特征。

3.1 特征选择简述

是不是维度越大的数据越好？是不是所有的维度都是必须的？

import pandas as pd
df_wine = pd.read_csv("datasets/wine_data.csv")
df_wine.head()

Class_label	Alcohol	Malic_acid	Ash	Alcalinity_of_ash	Magnesium	Total_phenols	Flavanoids	Nonflavanoid_phenols	Proanthocyanins	Color_intensity	Hue	OD280/OD315_of_diluted_wines	Proline
0	1	14.23	1.71	2.43	15.6	127	2.80	3.06	0.28	2.29	5.64	1.04	3.92	1065
1	1	13.20	1.78	2.14	11.2	100	2.65	2.76	0.26	1.28	4.38	1.05	3.40	1050
2	1	13.16	2.36	2.67	18.6	101	2.80	3.24	0.30	2.81	5.68	1.03	3.17	1185
3	1	14.37	1.95	2.50	16.8	113	3.85	3.49	0.24	2.18	7.80	0.86	3.45	1480
4	1	13.24	2.59	2.87	21.0	118	2.80	2.69	0.39	1.82	4.32	1.04	2.93	735

依据机器学习的一般流程，把数据集划分为训练集和测试集，并且对测试集和训练集分别实现特征标准化。

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
X, y = df_wine.iloc[:, 1:], df_wine.iloc[:, 0].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0, stratify=y)

std = StandardScaler()
X_train_std = std.fit_transform(X_train)
X_test_std = std.fit_transform(X_test)

以Class_label为标签，建立对数回归模型，寻找另外13个特征与标签之间的关系。

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(penalty='l1', C=1.0 , solver='liblinear') 
lr.fit(X_train_std, y_train)

LogisticRegression(penalty='l1', solver='liblinear')

在创建对数概率回归模型时候，使用了参数penalty='l1', C=1.0，这意味着在本模型中遵照此规则增加了惩罚项，其意图是避免训练得到的模型过拟合，也正是出于这个原因，模型舍弃了部分特性——表现出来就是系数为0

lr.coef_

array([[ 1.24568008,  0.18066268,  0.74500129, -1.16270324,  0.        ,
         0.        ,  1.16473536,  0.        ,  0.        ,  0.        ,
         0.        ,  0.55281296,  2.50976773],
       [-1.53710813, -0.38760504, -0.99525286,  0.36504305, -0.05948103,
         0.        ,  0.66797894,  0.        ,  0.        , -1.93413502,
         1.23360251,  0.        , -2.23189735],
       [ 0.13448113,  0.16969503,  0.35805173,  0.        ,  0.        ,
         0.        , -2.43221807,  0.        ,  0.        ,  1.56308975,
        -0.81943572, -0.49548102,  0.        ]])

lr.intercept_

array([-1.26347923, -1.21597948, -2.36926979])

在机器学习中，过拟合是比较常见的现象，通常采用如下避免方法：

训练集和测试集五五开
在模型中增加惩罚项，简化模型
尽可能选用参数少的模型
降低数据集的维度

特征选择，是指去除数据集中的冗余和无关的特征，从数据集中找出主要特征，最终得到得到的是原有特征的子集。因此，特征选择也称为“特征子集选择”

为实现特征选择，这里介绍三类方法：封装器法、过滤器法和嵌入法。

3.2 封装器法

封装器法的基本思路是：

选用一个特征子集训练模型，此处的模型通常是一种机器学习算法，也称为目标函数。
用验证数据集对模型进行评估。
依据某种搜索方式，对不同的特征子集进行上述操作，
依据评估结果，选出相对最佳的特征子集。

这种方式属于贪心搜索算法，计算量较大。针对特征子集的组合搜索问题，封装法有下述三种常见的选择方式。

循序特征选择

包括循环向前（SFS）和循环向后（SBS）

基础知识

以SFS为例：

（1）创建一个空的集合X，作为特征子集
（2）从原特征集合中“一次挑选一个”——这就是“循序”的含义，与特征子集X中的特征组合，并使得目标函数（选定的某个机器学习模型）结果最佳（模型预测的误差最小）
（3）将挑选出来的特征从原特征中移除，同时将其追加到X中。
（4）重复（2）、（3）步骤，直到集合X的特征数量达到规定的数量为止，中止上述循环。

显然，SFS不是把所有可能都实现一遍，而是找到一种可能最优解即中止寻找，这样就大大降低了计算量。
mlxtend的第三库提供了实现包含SFS的多种循环特征选择方法

pip install mlxtend

mlxtend中集成了几个数据集，这里使用关于葡萄酒的数据。X有13个特征178个样本，y是每个样本的标签，即每种葡萄酒的等级（共有3级，用0,1,2表示）。其中，X的13特征依次对应的名称是：

Alcohol
Malic acid
Ash
Alcalinity of ash
Magnesium
Total phenols
Flavanoids
Nonflavanoid phenols
Proanthocyanins
Color intensity
Hue
OD280/OD315 of diluted wines
Proline

https://archive.ics.uci.edu/ml/datasets/Wine

from mlxtend.feature_selection import SequentialFeatureSelector as SFS
from sklearn.neighbors import KNeighborsClassifier
from mlxtend.data import wine_data
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = wine_data()
X.shape

(178, 13)

X_train, X_test, y_train, y_test= train_test_split(X, y, 
                                                   stratify=y,
                                                   test_size=0.3,
                                                   random_state=1)
std = StandardScaler() #标准化
X_train_std = std.fit_transform(X_train)

knn = KNeighborsClassifier(n_neighbors=3)    # knn作为SFS的目标函数
sfs = SFS(estimator=knn,     # SFS封装器
           k_features=4,     # 选择4个最佳特征
           forward=True, 
           floating=False, 
           verbose=2,         # 2输出训练过程的全部日志信息
           scoring='accuracy',#模型评估方法
           cv=0)              # 0 表示不进行交叉验证
sfs.fit(X_train_std, y_train)

[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  13 out of  13 | elapsed:    0.0s finished

[2022-06-09 19:28:12] Features: 1/4 -- score: 0.8548387096774194[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  12 out of  12 | elapsed:    0.0s finished

[2022-06-09 19:28:12] Features: 2/4 -- score: 0.9596774193548387[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  11 out of  11 | elapsed:    0.0s finished

[2022-06-09 19:28:12] Features: 3/4 -- score: 0.9919354838709677[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  10 out of  10 | elapsed:    0.0s finished

[2022-06-09 19:28:12] Features: 4/4 -- score: 0.9838709677419355

从输出的日志信息可以很明确地看出，当选择3个特征的时候，模型knn表现最好

sfs.subsets_

{1: {'feature_idx': (6,),
  'cv_scores': array([0.85483871]),
  'avg_score': 0.8548387096774194,
  'feature_names': ('6',)},
 2: {'feature_idx': (6, 9),
  'cv_scores': array([0.95967742]),
  'avg_score': 0.9596774193548387,
  'feature_names': ('6', '9')},
 3: {'feature_idx': (6, 9, 11),
  'cv_scores': array([0.99193548]),
  'avg_score': 0.9919354838709677,
  'feature_names': ('6', '9', '11')},
 4: {'feature_idx': (6, 8, 9, 11),
  'cv_scores': array([0.98387097]),
  'avg_score': 0.9838709677419355,
  'feature_names': ('6', '8', '9', '11')}}

利用SFS的属性subsets_得到了每次选择出来的特征及其相应的评估分数，feature_names表示特征名称。

项目案例

使用随机森林回归作为目标函数，从房价数据集中，选择出10佳特征

import pandas as pd
from sklearn.ensemble import RandomForestRegressor

df = pd.read_csv("datasets/housprice.csv")
cols = list(df.select_dtypes(include=['int64', 'float64']).columns)  
data = df[cols]

X_train,X_test,y_train,y_test= train_test_split(
            data.drop('SalePrice',axis=1),
            data['SalePrice'],
            test_size=.2,
            random_state=1#随机数生成器使用的种子
)

X_train.fillna(0, inplace=True)    # 用0填充缺失值

sfs3 = SFS(RandomForestRegressor(),    
           k_features=10,
           forward=True,
           verbose=0,
           cv=5,
           n_jobs=-1,
           scoring='r2')
sfs3.fit(X_train,y_train)
sfs3.k_feature_names_

('MSSubClass',
'OverallQual',
'OverallCond',
'YearRemodAdd',
'BsmtFinSF1',
'TotalBsmtSF',
'GrLivArea',
'Fireplaces',
'GarageCars',
'3SsnPorch')

穷举特征选择

指封装器中的搜索算法先将所有特征组合都实现一遍，然后通过比较各种特征组合后的模型表现，从中选择出最佳得到特征子集。
显然穷举特征选择必然浪费更大的计算量。

# 对上面SFS练习题中的10个特征的数据集，对它使用穷举法，从10佳中选出5强
mini_data = X_train[X_train.columns[list(sfs3.k_feature_idx_)]]    
mini_data.shape

(1168, 10)

import numpy as np
from mlxtend.feature_selection import ExhaustiveFeatureSelector as EFS
efs = EFS(RandomForestRegressor(),
          min_features=1,
          max_features=5,
          scoring='r2',
          n_jobs=-1)    
efs.fit(np.array(mini_data),y_train)
mini_data.columns[list(efs.best_idx_)]

Index(['MSSubClass', 'OverallQual', 'YearRemodAdd', 'BsmtFinSF1', 'GrLivArea'], dtype='object')

很显然，穷举特征选择也是构建了一个封装器，在封装器里使用了一种机器学习算法作为目标函数。

递归特征消除

递归特征消除RFE也是封装器法的一种具体实施，其主要思想是利用训练集数据生成模型，再根据模型的特征权重，对特征进行取舍，消除权重不同的特征，从而得到数据集的特征子集。然后，对这个特征子集重复上述过程，直到特征数量达到规定值为止。显然，这种寻找最优特征子集的方法依然是贪心搜索算法。

from sklearn.feature_selection import RFE
# 为避免大规模计算，还是从10佳中选择5强，
mini_data = X_train[X_train.columns[list(sfs3.k_feature_idx_)]]  

rfe = RFE(RandomForestRegressor(), #依旧使用随机森林回归
          n_features_to_select=5)     
rfe.fit(np.array(mini_data),y_train)
rfe.ranking_

array([4, 1, 3, 2, 1, 1, 1, 5, 1, 6])

对mini_data的各个特征的权重从高到低排序之后，表示顺序的序号，1表示相应索引的特征权重最靠前，也就是权重最高。

mini_data.columns[rfe.ranking_==1]

Index(['OverallQual', 'BsmtFinSF1', 'TotalBsmtSF', 'GrLivArea', 'GarageCars'], dtype='object')

对比发现，使用不同的方法选出的5强不完全一致，因此不同的特征方法会训练出不同效果的模型

3.3 过滤器法

过滤器法不评估子集的预测误差，而是使用某些统计指标，比如相关系数、互信息等——目标函数不同，根据这些统计指标，对各特征进行排序，以确定特征的取舍。

下面用卡方检验（皮尔森卡方检验）作为统计指标选择特征

from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest    # 过滤器类
from sklearn.feature_selection import chi2    #引用一个统计指标函数
iris = load_iris()
X, y = iris.data, iris.target
skb = SelectKBest(chi2, k=2)    #k为2表示特征子集中的特征数量
result = skb.fit(X, y)    # 根据从大到小的排序取2个特征
print("X^2 is: ", result.scores_)
print("P-values is: ", result.pvalues_)

X^2 is:  [ 10.81782088   3.7107283  116.31261309  67.0483602 ]
P-values is:  [4.47651499e-03 1.56395980e-01 5.53397228e-26 2.75824965e-15]

卡方检验是统计学上的假设检验方法。值越大，两个变量之间的偏差越大；反之，偏差越小。
P值是统计学中用于判断假设检验结果的参数。P值越小，原假设发生的概率就越小。

利用训练得到的模型对数据集X进行特征选择，得到含有两个特征的新数据集

X_new = skb.transform(X) 
X_new.shape

(150, 2)

显示数据对应的特征名称

import numpy as np
[iris.feature_names[np.where(X[0, :]==i)[0][0]] for i in X_new[0, :]]

['petal length (cm)', 'petal width (cm)']

过滤法中利用统计指标对特征排序，然后依据特征排序结果选择特征

iris.feature_names

['sepal length (cm)',
'sepal width (cm)',
'petal length (cm)',
'petal width (cm)']

过滤器的实现路径可以表示为:

过滤器法和封装器法对比：

过滤器法通常不对数据集执行迭代计算，因此计算速度比封装器法要快
封装器的目标函数是某个机器学习算法，过滤器的函数则是通用的统计函数，这样使得过滤器法所得到的特征更具有通用性，非专门针对某个算法有良好表现
利用过滤器法进行特征选择时，用户需要武断地输入阈值，这可能会导致一定的选择成本。
如果特征数量过少，过滤器可能无法找到最佳的特征子集，而封装器总能返回特征子集
因为过滤器所得特征子集与某种算法无关，所以一般不会出现过拟合现象，而经由封装器法所得特征子集训练的模型，会出现过拟合现象。

在项目中，应依据具体数据和项目要求，确定特征选择的实施方法。

3.4 嵌入法

在3.1节中曾用对数概率回归模型研究了葡萄酒的等级与特征的关系。因为在模型中使用了L1惩罚项，从而得到了特征系数的稀疏解，某些特征的系数为0。如此，可以对系数排序——特征权重，然后依据某个阈值选择部分特征。

这种特性选择的实现方法显然不是封装法，也不是过滤器法，而是在训练模型的同时，得到了特征权重，并完成特征选择。像这样将特征选择过程与训练模型融为一体，在模型训练过程中自动进行特征选择，被称为嵌入法特征选择。

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LogisticRegression

df_wine = pd.read_csv("datasets/wine_data.csv")
X, y = df_wine.iloc[:, 1:], df_wine.iloc[:, 0].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0, stratify=y)

std = StandardScaler()
X_train_std = std.fit_transform(X_train)
X_test_std = std.fit_transform(X_test)
# 创建对数概率回归模型，采用L1惩罚项
lr = LogisticRegression(C=1.0, penalty='l1', solver='liblinear')  
# 规定选择特征的阈值--特征权重的中位数
# 能够用的机器学习模型还有随机森林模型、决策树模型、LASSO回归模型、岭回归模型等
model = SelectFromModel(lr, threshold='median')   
X_new = model.fit_transform(X_train_std, y_train)

X_new.shape

(124, 7)

X_train_std.shape

(124, 13)

3.5 综合练习

import pandas as pd
df = pd.read_csv("datasets/app_small.csv")
df.drop('Unnamed: 0', axis=1, inplace=True) # 删除第一列
df.shape

(30751, 122)

df.columns

Index(['SK_ID_CURR', 'TARGET', 'NAME_CONTRACT_TYPE', 'CODE_GENDER',
'FLAG_OWN_CAR', 'FLAG_OWN_REALTY', 'CNT_CHILDREN', 'AMT_INCOME_TOTAL',
'AMT_CREDIT', 'AMT_ANNUITY',
...
'FLAG_DOCUMENT_18', 'FLAG_DOCUMENT_19', 'FLAG_DOCUMENT_20',
'FLAG_DOCUMENT_21', 'AMT_REQ_CREDIT_BUREAU_HOUR',
'AMT_REQ_CREDIT_BUREAU_DAY', 'AMT_REQ_CREDIT_BUREAU_WEEK',
'AMT_REQ_CREDIT_BUREAU_MON', 'AMT_REQ_CREDIT_BUREAU_QRT',
'AMT_REQ_CREDIT_BUREAU_YEAR'],
dtype='object', length=122)

共有122个特征

数字类型的特征和非数字类型的特征分别保存到不同的列表中

categorical_list = []
numerical_list = []
for i in df.columns.tolist():
    if df[i].dtype=='object':
        categorical_list.append(i)
    else:
        numerical_list.append(i)
print('Number of categorical features:', str(len(categorical_list)))
print('Number of numerical features:', str(len(numerical_list)))

Number of categorical features: 16
Number of numerical features: 106

将数值类型和分类型分别查出来共有16个分类型，106个数值类型

df[numerical_list].isna().any()

SK_ID_CURR False
TARGET False
CNT_CHILDREN False
AMT_INCOME_TOTAL False
AMT_CREDIT False
...
AMT_REQ_CREDIT_BUREAU_DAY True
AMT_REQ_CREDIT_BUREAU_WEEK True
AMT_REQ_CREDIT_BUREAU_MON True
AMT_REQ_CREDIT_BUREAU_QRT True
AMT_REQ_CREDIT_BUREAU_YEAR True
Length: 106, dtype: bool

检查numerical_list中的特征是否有缺失值，如果有缺失值，则用中位数填补

from sklearn.impute  import SimpleImputer
df[numerical_list] = SimpleImputer(strategy='median').fit_transform(df[numerical_list])

categorical_list中的特征都是分类型特征，于是乎进行OneHot编码（创建虚拟变量）

df = pd.get_dummies(df, drop_first=True)
df.shape

(30751, 228)

df

SK_ID_CURR	TARGET	CNT_CHILDREN	AMT_INCOME_TOTAL	AMT_CREDIT	AMT_ANNUITY	AMT_GOODS_PRICE	REGION_POPULATION_RELATIVE	DAYS_BIRTH	DAYS_EMPLOYED	...	FONDKAPREMONT_MODE_reg oper spec account	HOUSETYPE_MODE_specific housing	HOUSETYPE_MODE_terraced house	WALLSMATERIAL_MODE_Mixed	WALLSMATERIAL_MODE_Monolithic	WALLSMATERIAL_MODE_Others	WALLSMATERIAL_MODE_Panel	WALLSMATERIAL_MODE_Stone, brick	WALLSMATERIAL_MODE_Wooden	EMERGENCYSTATE_MODE_Yes
0	100003.0	0.0	0.0	270000.000	1293502.5	35698.5	1129500.0	0.003541	-16765.0	-1188.0	...	0	0	0	0	0	0	0	0	0	0
1	100015.0	0.0	0.0	38419.155	148365.0	10678.5	135000.0	0.015221	-20417.0	365243.0	...	0	0	0	0	0	0	0	0	0	0
2	100051.0	0.0	0.0	202500.000	661702.5	48280.5	598500.0	0.007114	-9827.0	-758.0	...	0	0	0	0	0	0	0	0	0	0
3	100054.0	0.0	0.0	99000.000	260640.0	26838.0	225000.0	0.022625	-20121.0	-5332.0	...	0	0	0	0	0	0	0	0	0	0
4	100069.0	0.0	1.0	360000.000	640458.0	27265.5	517500.0	0.007330	-14186.0	-1743.0	...	0	0	0	0	0	0	0	0	0	0
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
30746	456195.0	0.0	0.0	94500.000	270000.0	15075.0	270000.0	0.028663	-20246.0	-5452.0	...	0	0	0	0	0	0	0	1	0	0
30747	456212.0	0.0	1.0	135000.000	808650.0	23773.5	675000.0	0.009657	-18042.0	-186.0	...	0	0	0	0	0	0	0	0	0	0
30748	456219.0	0.0	1.0	112500.000	521280.0	31630.5	450000.0	0.006207	-13346.0	-1972.0	...	0	0	0	0	0	0	0	0	0	0
30749	456237.0	0.0	0.0	135000.000	946764.0	37678.5	765000.0	0.019689	-17533.0	-2306.0	...	0	0	0	0	0	0	0	0	0	0
30750	456253.0	0.0	0.0	153000.000	677664.0	29979.0	585000.0	0.005002	-14966.0	-7921.0	...	0	0	0	0	0	0	1	0	0	0

30751 rows × 228 columns

X = df.drop(['SK_ID_CURR', 'TARGET'], axis=1)
y = df['TARGET']
feature_name = X.columns.tolist()

先对X进行特征规范化操作，而后利用卡方检验选择50个特征

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
from sklearn.preprocessing import MinMaxScaler

X_norm = MinMaxScaler().fit_transform(X)    # MinMax区间化
chi_selector = SelectKBest(chi2, k=50)    # 过滤器法
chi_selector.fit(X_norm, y)

SelectKBest(k=50, score_func=<function chi2 at 0x000001C74C48F310>)

chi_support = chi_selector.get_support()
chi_feature = X.loc[:,chi_support].columns.tolist()

使用封装器，选50个特征

from sklearn.feature_selection import RFE    
from sklearn.linear_model import LogisticRegression
rfe_selector = RFE(estimator=LogisticRegression(penalty="l1",solver='liblinear'), n_features_to_select=50, step=10, verbose=5)   
rfe_selector.fit(X_norm, y)    
rfe_support = rfe_selector.get_support()
rfe_feature = X.loc[:,rfe_support].columns.tolist()

用嵌入法选择特征

from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LogisticRegression    #使用logistic回归模型

embeded_lr_selector = SelectFromModel(LogisticRegression(penalty="l1",solver='liblinear'),threshold= '1.25*median')
embeded_lr_selector.fit(X_norm, y)

embeded_lr_support = embeded_lr_selector.get_support()
embeded_lr_feature = X.loc[:,embeded_lr_support].columns.tolist()
print(str(len(embeded_lr_feature)), 'selected features')

105 selected features

不用对数机率回归模型，改为随机森林分类

from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import RandomForestClassifier    #相对上面，模型换了

embeded_rf_selector = SelectFromModel(RandomForestClassifier(n_estimators=50), threshold='1.25*median')
embeded_rf_selector.fit(X, y)

embeded_rf_support = embeded_rf_selector.get_support()
embeded_rf_feature = X.loc[:,embeded_rf_support].columns.tolist()
print(str(len(embeded_rf_feature)), 'selected features')

98 selected features

# 下把特征按照被选择的次数从高到低列出来
feature_selection_df = pd.DataFrame({'Feature':feature_name, 
                                     'Chi-2':chi_support, 
                                     'RFE':rfe_support, 
                                     'Logistics':embeded_lr_support,
                                     'Random Forest':embeded_rf_support})
# 每个特征在不同方式中被选择的次数总和
feature_selection_df['Total'] = np.sum(feature_selection_df, axis=1)
# 按照次数大小，显示前50个
feature_selection_df = feature_selection_df.sort_values(['Total','Feature'] , ascending=False)
feature_selection_df.index = range(1, len(feature_selection_df)+1)
feature_selection_df.head(50)

	Feature	Chi-2	RFE	Logistics	Random Forest	Total
1	REGION_RATING_CLIENT_W_CITY	True	True	True	True	4
2	ORGANIZATION_TYPE_Self-employed	True	True	True	True	4
3	ORGANIZATION_TYPE_Construction	True	True	True	True	4
4	ORGANIZATION_TYPE_Business Entity Type 3	True	True	True	True	4
5	FLAG_OWN_CAR_Y	True	True	True	True	4
6	EXT_SOURCE_3	True	True	True	True	4
7	EXT_SOURCE_2	True	True	True	True	4
8	EXT_SOURCE_1	True	True	True	True	4
9	DAYS_ID_PUBLISH	True	True	True	True	4
10	CODE_GENDER_M	True	True	True	True	4
11	WALLSMATERIAL_MODE_Monolithic	True	True	True	False	3
12	ORGANIZATION_TYPE_Transport: type 3	True	True	True	False	3
13	ORGANIZATION_TYPE_Police	True	True	True	False	3
14	ORGANIZATION_TYPE_Military	True	True	True	False	3
15	ORGANIZATION_TYPE_Industry: type 9	True	True	True	False	3
16	OCCUPATION_TYPE_Low-skill Laborers	True	True	True	False	3
17	OCCUPATION_TYPE_Laborers	True	False	True	True	3
18	OCCUPATION_TYPE_High skill tech staff	True	True	True	False	3
19	OCCUPATION_TYPE_Drivers	True	False	True	True	3
20	NONLIVINGAPARTMENTS_MODE	False	True	True	True	3
21	NAME_FAMILY_STATUS_Married	True	False	True	True	3
22	NAME_EDUCATION_TYPE_Higher education	True	False	True	True	3
23	LIVINGAREA_MEDI	False	True	True	True	3
24	FLOORSMIN_MEDI	False	True	True	True	3
25	FLOORSMAX_MODE	False	True	True	True	3
26	FLAG_WORK_PHONE	True	False	True	True	3
27	FLAG_DOCUMENT_3	True	False	True	True	3
28	ENTRANCES_AVG	False	True	True	True	3
29	DEF_60_CNT_SOCIAL_CIRCLE	False	True	True	True	3
30	DEF_30_CNT_SOCIAL_CIRCLE	False	True	True	True	3
31	BASEMENTAREA_AVG	False	True	True	True	3
32	APARTMENTS_MEDI	False	True	True	True	3
33	AMT_REQ_CREDIT_BUREAU_MON	False	True	True	True	3
34	AMT_GOODS_PRICE	False	True	True	True	3
35	AMT_CREDIT	False	True	True	True	3
36	AMT_ANNUITY	False	True	True	True	3
37	YEARS_BEGINEXPLUATATION_MODE	False	False	True	True	2
38	YEARS_BEGINEXPLUATATION_MEDI	False	False	True	True	2
39	WEEKDAY_APPR_PROCESS_START_TUESDAY	False	False	True	True	2
40	WALLSMATERIAL_MODE_Wooden	False	True	True	False	2
41	REG_CITY_NOT_WORK_CITY	True	False	False	True	2
42	REG_CITY_NOT_LIVE_CITY	True	False	False	True	2
43	REGION_RATING_CLIENT	True	False	False	True	2
44	ORGANIZATION_TYPE_Transport: type 1	False	True	True	False	2
45	ORGANIZATION_TYPE_Realtor	False	True	True	False	2
46	ORGANIZATION_TYPE_Other	False	False	True	True	2
47	ORGANIZATION_TYPE_Insurance	False	True	True	False	2
48	ORGANIZATION_TYPE_Industry: type 3	False	True	True	False	2
49	ORGANIZATION_TYPE_Industry: type 2	False	True	True	False	2
50	ORGANIZATION_TYPE_Industry: type 12	False	True	True	False	2

特征工程（三）特征选择

3.1 特征选择简述

3.2 封装器法

循序特征选择

基础知识

项目案例

穷举特征选择

递归特征消除

3.3 过滤器法

3.4 嵌入法

3.5 综合练习

牛客SQL-大廠面試真題

Flink CDC

數據庫流轉工具—Maxwell

騰訊音樂SQL題

森林火災模擬軟件--FlamMap

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結