python数据分析之特征预处理-第六次笔记

冷不防 2022-05-17 10:00 469阅读 0赞

## python数据分析之特征预处理-第六次笔记 ##

--------------------

\-**\*1.特征选择**  
\- - **\*1.1过滤思想**  
\- - **\*1.2包裹思想**  
\- - **\*1.3嵌入思想**  
\-**\*2.特征提取**  
\- - **\*2.1対指化**  
\- - **\*2.2离散化**  
\- - **\*2.3归一化** — **MinMaxScaler()算法**  
\- - **\*2.4标准化** — **StandardScaler()算法**  
\- - **\*2.5数值化-标签化** — **LabelEncoder()算法**  
\- - **\*2.6数值化-独热** — **OneHotEncoder()算法**  
\- - **\*2.7正规化** — **Normalizer()算法**  
\-**\*3.降维**—**PCA算法**

--------------------

### 1.特征选择 ###

**导入模块**

#导入模块
    import numpy as np
    import pandas as pd
    import scipy.stats as ss
    from sklearn.svm import SVR
    from sklearn.tree import DecisionTreeRegressor
    #SelectKBest过滤思想，类,RFE 包裹思想 类,SelectFromModel 嵌入思想 类
    from sklearn.feature_selection import SelectKBest,RFE,SelectFromModel

**导入数据**

#生成一个二维的Data表，行为10，列为4，“A”“B”“C”服从正态分布，“D”为标注  标注为0,1
    df = pd.DataFrame({
       "A":ss.norm.rvs(size=10),"B":ss.norm.rvs(size=10),"C":ss.norm.rvs(size=10),"D":np.random.randint(low=0,high=2,size=10)})
    #特征为X
    X=df.loc[:,["A","B","C"]]
    #标注为Y
    Y=df.loc[:,"D"]

#### 1.1过滤思想 ####

过滤思想：去掉相关性差的特征

#过滤思想，SelectKBest()的参数k,score_func指定函数，默认f_classif方差分析f值，等。
    skb=SelectKBest(k=2)
    #拟合
    skb.fit(X,Y)
    #值
    skb.transform(X)

#### 1.2包裹思想 ####

包裹思想：构造简单模型，根据系数去掉弱特征

#estimator=SVR(kernel="linear"线性回归器  特征选择
    #n_features_to_select=2,就是最终要选择几个特征
    #step=1，每迭代一次，要去掉一个特征
    rfe=RFE(estimator=SVR(kernel="linear"),n_features_to_select=2,step=1)
    rfe.fit_transform(X,Y)

#### 1.3嵌入思想 ####

嵌入思想：一般利用回归的方法，

#嵌入思想
    #SelectFromModel（）必须要有feature_importances和coef_这两个参数才能用
    #estimator=DecisionTreeRegressor()特征选择
    #threshold=0.1  重要性因子，低于0.1就会被去掉
    sfm=SelectFromModel(estimator=DecisionTreeRegressor(),threshold=0.1)
    sfm.fit_transform(X,Y)

### 2.特征提取 ###

#### 2.1対指化 ####

对值化：一般利用y=e^x或者y=lnx函数对特征放大或者缩放  
y=e^x：对小的特征放大  
y=lnx：对大的特征缩放

#### 2.2离散化 ####

离散化：是把连续的变量离散化  
一般有等频，等距，自因变量优化等方法  
引入pandas模块  
等频：等频分箱–pd.qcut(lst,q=3)函数 等数分三份  
等距：等宽分箱–pd.cut(lst,bins=3)函数 分了三个区间

#### 2.3归一化 —MinMaxScaler()算法 ####

#### 2.4标准化 —StandardScaler()算法 ####

一般归一化和标准化所用的对象都是一样的。标准化可以称为狭义的归一化。  
通俗来讲就是把数据替换为\[0,1\]之间，

#导入模块
    from sklearn.preprocessing import MinMaxScaler,StandardScaler
        #特征选取
        #sl,le,npr,amh,tsc,wa,pl5为False:采用归一化MinMaxScaler()算法，为True,采用标准化StandardScaler()算法
        #特征处理
        scaler_lst=[sl,le,npr,amh,tsc,wa,pl5]
        column_lst=["satisfaction_level","last_evaluation","number_project",\
                    "average_monthly_hours","time_spend_company","Work_accident",\
                    "promotion_last_5years"]
        for i in range(len(scaler_lst)):
            if not scaler_lst[i]:
                df[column_lst[i]]=\
                MinMaxScaler().fit_transform(df[column_lst[i]].values.reshape(-1,1)).reshape(1,-1)[0]
            else:
                df[column_lst[i]]=\
                StandardScaler().fit_transform(df[column_lst[i]].values.reshape(-1,1)).reshape(1,-1)[0]

#### 2.5数值化-标签化 —LabelEncoder()算法 ####

#### 2.6数值化-独热 —OneHotEncoder()算法 ####

首先，数据要数值化，肯定数据是英文表示的数据，且是离散值，这个时候，要先对数据进行赋值，比如:

d=dict([("low",0),("medium",1),("high",2)])
    def map_salary(s):
        return d.get(s,0)

可以采用作者这样的格式，来对所需要的数据进行赋值，然后在利用下面的程序，进行便利数据，赋值。

#导入模块
    from sklearn.preprocessing import LabelEncoder,OneHotEncoder
    #pd.get_dummies（）代表的就是OneHotEncoder()算法
    #slr,dp：为False:采用数值化-标签化LabelEncoder()算法，为True,采用数值化-独热 OneHotEncoder()算法
    #且最后利用采用归一化MinMaxScaler()算法数据预处理
        scaler_lst=[slr,dp]
        column_lst=[ "salary","department"]
        for i in range(len(scaler_lst)):
            if not scaler_lst[i]:
                if column_lst[i]=="salary":
                    df[column_lst[i]]=[map_salary(s) for s in df["salary"].values]
                else:
                    df[column_lst[i]]=LabelEncoder().fit_transform(df[column_lst[i]])
                df[column_lst[i]] = MinMaxScaler().fit_transform(df[column_lst[i]].values.reshape(-1, 1)).reshape(1, -1)[0]
            else:
                df=pd.get_dummies(df,columns=[column_lst[i]])

#### 2.7正规化 — Normalizer()算法 ####

有两种方法:L1和L2

#导入模块
    import numpy as np
    from  sklearn.preprocessing import Normalizer
    Normalizer(norm="l1").fit_transform(np.array([[1,1,3,-1,2]]))
    Normalizer(norm="l2").fit_transform(np.array([[1,1,3,-1,2]]))

### 3.降维**—PCA算法** ###

#导入模块
    from sklearn.decomposition import PCA
    #lower_d为True执行PCA算法，False否则不执行，ld_n表示降维，要留下几个特征。
    
        if lower_d:
            return PCA(n_components=ld_n).fit_transform(df.values),label

完整的程序：

#encoding utf-8
    # time: 2018/08/08
    # name: py粉
    import pandas as pd
    import numpy as np
    from sklearn.preprocessing import MinMaxScaler,StandardScaler
    from sklearn.preprocessing import LabelEncoder,OneHotEncoder
    from sklearn.preprocessing import Normalizer
    from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
    from sklearn.decomposition import PCA
    
    
    #sl:satisfaction_level---Flase:MinMaxScaler;Ture:StandardScaler
    #le:last_evaluation---Flase:MinMaxScaler;Ture:StandardScaler
    #npr:number_project---Flase:MinMaxScaler;Ture:StandardScaler
    #amh:average_monthly_hours---Flase:MinMaxScaler;Ture:StandardScaler
    #tsc:time_spend_company---Flase:MinMaxScaler;Ture:StandardScaler
    #wa:Work_accident---Flase:MinMaxScaler;Ture:StandardScaler
    #pl5:promotion_last_5years---Flase:MinMaxScaler;Ture:StandardScaler
    #dp:department---False:LabelEncoding;True:OneHotEncoding
    #slr:salary---False:LabelEncoding;True:OneHotEncoding
    
    def hr_preprocessing(sl=False,le=False,npr=False,amh=False,tsc=False,wa=False,pl5=False,dp=False,slr=False,lower_d=False,ld_n=1):
        f = open("D:\Python\python'数据分析与建模实现\data\HR.csv")
        df = pd.read_csv(f)
    
        #1.清洗数据
        #satisfaction_level, last_evaluation, number_project,\
        #average_monthly_hours, time_spend_company, Work_accident,
        #  left, promotion_last_5years, department, salary
        df=df.dropna(subset=["satisfaction_level","last_evaluation"])
        df=df[df["satisfaction_level"]<=1][df["salary"]!="nme"]
        # 2.得到标注
        label = df["left"]
        df = df.drop("left", axis=1)
        #3.特征选取
        #4.特征处理
        scaler_lst=[sl,le,npr,amh,tsc,wa,pl5]
        column_lst=["satisfaction_level","last_evaluation","number_project",\
                    "average_monthly_hours","time_spend_company","Work_accident",\
                    "promotion_last_5years"]
        for i in range(len(scaler_lst)):
            if not scaler_lst[i]:
                df[column_lst[i]]=\
                MinMaxScaler().fit_transform(df[column_lst[i]].values.reshape(-1,1)).reshape(1,-1)[0]
            else:
                df[column_lst[i]]=\
                StandardScaler().fit_transform(df[column_lst[i]].values.reshape(-1,1)).reshape(1,-1)[0]
    
    
    
        scaler_lst=[slr,dp]
        column_lst=[ "salary","department"]
        for i in range(len(scaler_lst)):
            if not scaler_lst[i]:
                if column_lst[i]=="salary":
                    df[column_lst[i]]=[map_salary(s) for s in df["salary"].values]
                else:
                    df[column_lst[i]]=LabelEncoder().fit_transform(df[column_lst[i]])
                df[column_lst[i]] = MinMaxScaler().fit_transform(df[column_lst[i]].values.reshape(-1, 1)).reshape(1, -1)[0]
            else:
                df=pd.get_dummies(df,columns=[column_lst[i]])
        if lower_d:
            return PCA(n_components=ld_n).fit_transform(df.values),label
    
    
        return df,label
    d=dict([("low",0),("medium",1),("high",2)])
    def map_salary(s):
        return d.get(s,0)
    
    def main():
        print(hr_preprocessing(sl=True,le=True,dp=True,lower_d=True,ld_n=3))
    
    if __name__ == '__main__':
        main()