特征工程-数据预处理、特征选择、降维

曾经终败给现在 2022-05-22 06:43 255阅读 0赞

**理论知识和代码参考知乎https://www.zhihu.com/question/29316149/answer/110159647**

**\# -\*- coding: utf-8 -\*-  
"""  
Created on Mon Jun 18 09:53:43 2018  
  
  
@author: Administrator  
"""  
  
  
'''  
特征工程 Feature Engineering  
'''  
import numpy as np  
from sklearn.datasets import load\_iris\#加载数据集  
'''  
数据预处理  
'''  
from sklearn.preprocessing import StandardScaler\#数据预处理-标准化  
from sklearn.preprocessing import MinMaxScaler\#数据预处理-区间缩放法\[0,1  
from sklearn.preprocessing import Normalizer\#数据预处理-归一化  
from sklearn.preprocessing import Binarizer\#数据预处理-二值化  
from sklearn.preprocessing import OneHotEncoder\#数据预处理-哑编码  
from sklearn.preprocessing import Imputer\#数据预处理-缺省值计算   
from sklearn.preprocessing import PolynomialFeatures\#数据预处理-多项式转化  
from sklearn.preprocessing import FunctionTransformer\#数据预处理-自定义函数转换  
'''  
特征选择  
'''  
from sklearn.feature\_selection import VarianceThreshold\#方差选择法  
from sklearn.feature\_selection import SelectKBest\#相关系数法-计算各个特征对类别标记的相关系数  
from scipy.stats import pearsonr\#计算相关系数  
from sklearn.feature\_selection import chi2\#卡方检验  
from minepy import MINE\#互信息法  
from sklearn.feature\_selection import RFE\#递归特征消除法  
from sklearn.linear\_model import LogisticRegression\#选择基模型  
from sklearn.feature\_selection import SelectFromModel\#基于惩罚项的特征选择  
from sklearn.ensemble import GradientBoostingClassifier\#\#GBDT作为基模型的特征选择  
'''  
降维，L1惩罚项降维；PCA是为了让映射后的样本具有最大的发散性；而LDA是为了让映射后的样本有最好的分类性能  
PCA是一种无监督的降维方法，而LDA是一种有监督的降维方法。  
'''  
from sklearn.decomposition import PCA\#PCA降维  
from sklearn.decomposition import LatentDirichletAllocation as LDA\#LDA降维  
\#from sklearn.lda import LDA\#出错  
\#import sklearn  
\#print(sklearn.\_\_version\_\_)\#0.19.  
'''  
数据预处理  
'''  
iris = load\_iris()  
data = iris.data\#数据集  
target = iris.target\#类别标记  
data1 = StandardScaler().fit\_transform(data)  
data2 = MinMaxScaler().fit\_transform(data)  
data3 = Normalizer().fit\_transform(data)  
data4 =Binarizer(threshold = 3).fit\_transform(data)\#二值化的阈值设置为3  
data5 = OneHotEncoder().fit\_transform(target.reshape(-1,1))  
\#data = np.vstack((np.array(\[np.nan, np.nan, np.nan, np.nan\]),data))\#增加一个缺省值样本  
\#data6 = Imputer().fit\_transform(data)  
data7 = PolynomialFeatures(degree = 2).fit\_transform(data)  
data8 = FunctionTransformer(np.log1p).fit\_transform(data)\#对数函数-单变元函数  
'''  
特征选择  
'''  
  
  
data9 = VarianceThreshold(threshold = 3).fit\_transform(data)\#计算各个特征向量的方差，方差大于阈值的特征保留   
data10 = SelectKBest(lambda X, Y: np.array(list(map(lambda x:pearsonr(x, Y), X.T))).T\[0\], k=2).fit\_transform(data, target)  
data11 = SelectKBest(chi2, k=2).fit\_transform(data, target)  
def mic(x, y):\#由于MINE的设计不是函数式的，定义mic方法将其为函数式的，返回一个二元组，二元组的第2项设置成固定的P值0.5  
    m = MINE()  
    m.compute\_score(x, y)  
    return(m.mic(), 0.5)  
data12 = SelectKBest(lambda X, Y: np.array(list(map(lambda x:mic(x, Y), X.T))).T\[0\], k=2).fit\_transform(data, target)  
data13 = RFE(estimator=LogisticRegression(), n\_features\_to\_select=2).fit\_transform(data, target)  
data14 = SelectFromModel(LogisticRegression(penalty="l1", C=0.1)).fit\_transform(iris.data, iris.target)\#带l1惩罚项的逻辑回归  
\#L1机L2惩罚项结合  
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  
data15 = SelectFromModel(LR(threshold=0.5, C=0.1)).fit\_transform(data, target)  
data16 = SelectFromModel(GradientBoostingClassifier()).fit\_transform(data, target)\#GBDT作为基模型的特征选择  
'''  
降维  
'''  
data17 = PCA(n\_components = 2).fit\_transform(data)\#n\_components降维后的维数  
data18 = LDA(n\_components = 2).fit\_transform(data, target)\#n\_components降维后的维数**