python数据分析之特征预处理-第六次笔记_特征分析与特征选择-优快云博客

本文介绍Python中数据预处理的方法，包括特征选择、特征提取、数据规范化等关键步骤，并通过具体代码实例展示如何使用sklearn库进行操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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()