[Feature] Feature selection - Embedded topic

基于惩罚项的特征选择法

---

一、直接对特征筛选

Ref: 1.13.4. 使用SelectFromModel选择特征(Feature selection using SelectFromModel)

通过 L1 降维特征

L1惩罚项降维的原理在于保留多个对目标值具有同等相关性的特征中的一个，所以没选到的特征不代表不重要。故，可结合L2惩罚项来优化。

(1) [Scikit-learn] 1.1 Generalized Linear Models - from Linear Regression to L1&L2【as part 1】

(2) [Scikit-learn] 1.1 Generalized Linear Models - Lasso Regression【as part 2，重点解析了Lasso，作为part 1的补充】

示例代码如下，但问题来了，如何图像化参数的重要性。

from sklearn.svm import LinearSVC
　　
X.shape
# (150, 4)

lsvc = LinearSVC(C=0.01, penalty="l1", dual=False).fit(X, y)
model = SelectFromModel(lsvc, prefit=True)

# 原数据 -->　转变为　--> 降维后的数据
X_new = model.transform(X)
X_new.shape
# (150, 3)

L1 参数筛选

直接得到理想的模型，查看最后参数的二维分布：Feature selection using SelectFromModel and LassoCV

# Author: Manoj Kumar <mks542@nyu.edu>
# License: BSD 3 clause

print(__doc__)

import matplotlib.pyplot as plt
import numpy as np

from sklearn.datasets import load_boston
from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LassoCV

# Load the boston dataset.
boston = load_boston()
X, y = boston['data'], boston['target']

# We use the base estimator LassoCV since the L1 norm promotes sparsity of features.
clf = LassoCV()

# Set a minimum threshold of 0.25
sfm = SelectFromModel(clf, threshold=0.25)
sfm.fit(X, y)
n_features = sfm.transform(X).shape[1]

# Reset the threshold till the number of features equals two.
# Note that the attribute can be set directly instead of repeatedly
# fitting the metatransformer.
while n_features > 2:
    sfm.threshold += 0.1
    X_transform = sfm.transform(X)
    n_features = X_transform.shape[1]

# Plot the selected two features from X.
plt.title(
    "Features selected from Boston using SelectFromModel with "
    "threshold %0.3f." % sfm.threshold)
feature1 = X_transform[:, 0]
feature2 = X_transform[:, 1]
plt.plot(feature1, feature2, 'r.')
plt.xlabel("Feature number 1")
plt.ylabel("Feature number 2")
plt.ylim([np.min(feature2), np.max(feature2)])
plt.show()

二、轨迹图

Sparse recovery: feature selection for sparse linear models

学习可视化 L1 过程，代码分析。

Ref: scikit-learn 线性回归算法库小结

Ref: Lasso权重可视化

注意，该标题的代码过期了：Deprecate randomized_l1 module #8995

轨迹图

Ref: LARS算法的几何意义

Ref: 1.1. Generalized Linear Models【更多轨迹图】

从右往左看，重要的参数在最后趋于0。

print(__doc__)

# Author: Fabian Pedregosa <fabian.pedregosa@inria.fr>
#         Alexandre Gramfort <alexandre.gramfort@inria.fr>
# License: BSD 3 clause

import numpy as np
import matplotlib.pyplot as plt

from sklearn import linear_model
from sklearn import datasets

diabetes = datasets.load_diabetes()
X = diabetes.data
y = diabetes.target

print("Computing regularization path using the LARS ...")
_, _, coefs = linear_model.lars_path(X, y, method='lasso', verbose=True)

# 注释一：累加，然后变为“比例”
xx = np.sum(np.abs(coefs.T), axis=1)
xx /= xx[-1]

plt.plot(xx, coefs.T)
ymin, ymax = plt.ylim()
plt.vlines(xx, ymin, ymax, linestyle='dashed')
plt.xlabel('|coef| / max|coef|')
plt.ylabel('Coefficients')
plt.title('LASSO Path')
plt.axis('tight')
plt.show()

“注释一” 的结果显示：

Computing regularization path using the LARS ...

[   0.           60.11926965  663.66995526  888.91024335 1250.6953637
 1440.79804251 1537.06598321 1914.57052862 2115.73774356 2195.55885543
 2802.37509283 2863.01080401 3460.00495515]

[0.         0.01737549 0.19181185 0.25691011 0.36147213 0.41641502
 0.44423809 0.55334329 0.61148402 0.63455367 0.80993384 0.82745858
 1.        ]

三、L2 协助 L1 优化

L1惩罚项降维的原理在于保留多个对目标值具有同等相关性的特征中的一个，所以没选到的特征不代表不重要。故，可结合L2惩罚项来优化。

具体操作为：若一个特征在L1中的权值为1，选择在L2中权值差别不大且在L1中权值为0的特征构成同类集合，将这一集合中的特征平分L1中的权值，故需要构建一个新的逻辑回归模型：

• • __init__中，默认L1, 但内部又“配置了一个L2"的额外的模型。
  • fit()进行了重写：先用L1训练一次，再用L2训练一次。

from sklearn.linear_model import LogisticRegression

class LR(LogisticRegression):
    def __init__(self, threshold=0.01, dual=False, tol=1e-4, C=1.0,
                 fit_intercept=True, intercept_scaling=1, class_weight=None,
                 random_state=None, solver='liblinear', max_iter=100,
                 multi_class='ovr', verbose=0, warm_start=False, n_jobs=1):

        #权值相近的阈值
        self.threshold = threshold

        #初始化模型
        LogisticRegression.__init__(self, penalty='l1', dual=dual, tol=tol, C=C,
                 fit_intercept=fit_intercept, intercept_scaling=intercept_scaling, class_weight=class_weight,
                 random_state=random_state, solver=solver, max_iter=max_iter,
                 multi_class=multi_class, verbose=verbose, warm_start=warm_start, n_jobs=n_jobs)
        #使用同样的参数创建L2逻辑回归
        self.l2 = LogisticRegression(penalty='l2', dual=dual, tol=tol, C=C, fit_intercept=fit_intercept, intercept_scaling=intercept_scaling, class_weight = class_weight, random_state=random_state, solver=solver, max_iter=max_iter, multi_class=multi_class, verbose=verbose, warm_start=warm_start, n_jobs=n_jobs)

    def fit(self, X, y, sample_weight=None):
        #训练L1逻辑回归
        super(LR, self).fit(X, y, sample_weight=sample_weight)
        self.coef_old_ = self.coef_.copy()
        #训练L2逻辑回归
        self.l2.fit(X, y, sample_weight=sample_weight)

        cntOfRow, cntOfCol = self.coef_.shape
        # 权值系数矩阵的行数对应目标值的种类数目
        for i in range(cntOfRow):
            for j in range(cntOfCol):
                coef = self.coef_[i][j]
                #L1逻辑回归的权值系数不为0
                if coef != 0:
                    idx = [j]
                    #对应在L2逻辑回归中的权值系数
                    coef1 = self.l2.coef_[i][j]
                    for k in range(cntOfCol):
                        coef2 = self.l2.coef_[i][k]
                        #在L2逻辑回归中，权值系数之差小于设定的阈值，且在L1中对应的权值为0
                        if abs(coef1-coef2) < self.threshold and j != k and self.coef_[i][k] == 0:
                            idx.append(k)
                    #计算这一类特征的权值系数均值
                    mean = coef / len(idx)
                    self.coef_[i][idx] = mean
        return self


from sklearn.feature_selection import SelectFromModel

#带L1和L2惩罚项的逻辑回归作为基模型的特征选择
#参数threshold为权值系数之差的阈值
SelectFromModel(LR(threshold=0.5, C=0.1)).fit_transform(iris.data, iris.target)

基于树模型的特征选择法

---

一、Feature importances with forests of trees

基于树的预测模型（见 sklearn.tree 模块，森林见 sklearn.ensemble 模块）能够用来计算特征的重要程度，因此能用来去除不相关的特征（结合 sklearn.feature_selection.SelectFromModel ）：

print(__doc__)

import numpy as np
import matplotlib.pyplot as plt

from sklearn.datasets import make_classification
from sklearn.ensemble import ExtraTreesClassifier

# Build a classification task using 3 informative features
# 自定义一个数据集合，这是个好东西
X, y = make_classification(n_samples=1000,
                           n_features=10,
                           n_informative=3,
                           n_redundant=0,
                           n_repeated=0,
                           n_classes=2,
                           random_state=0,
                           shuffle=False)

# Build a forest and compute the feature importances
forest = ExtraTreesClassifier(n_estimators=250, random_state=0)
forest.fit(X, y)

# 森林中许多树，每棵树对应了一套自己的标准得到的”重要性评估"
importances = forest.feature_importances_
std = np.std([tree.feature_importances_ for tree in forest.estimators_], axis=0)
indices = np.argsort(importances)[::-1]

# Print the feature ranking
print("Feature ranking:")

for f in range(X.shape[1]):
    print("%d. feature %d (%f)" % (f + 1, indices[f], importances[indices[f]]))

# Plot the feature importances of the forest
plt.figure()
plt.title("Feature importances")
plt.bar(range(X.shape[1]), importances[indices],
       color="r", yerr=std[indices], align="center")
plt.xticks(range(X.shape[1]), indices)
plt.xlim([-1, X.shape[1]])
plt.show()

结果：

aaarticlea/png;base64,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" alt="" />

End.