Python数据挖掘入门与实践--用转换器抽取特征

清疚 2022-05-18 03:20 212阅读 0赞

数据来源：[https://archive.ics.uci.edu/ml/datasets/Adult][https_archive.ics.uci.edu_ml_datasets_Adult]

所使用的数据是描述人及其所处的环境，背景及其生活状况，挖掘目标是：预测一个人是否年收入要多于5 万美元

### 1.特征抽取： ###

特征抽取是数据挖掘中最为重要的一个环节，一般而言，它最终的结果影响要高于数据挖掘算法本身。不幸的是，关于如何选取好的特征，还没有严格的规定、便捷的规则可循，其实这也是数据挖掘科学更像是一门艺术所在。创建好的规则离不开直觉，还需要专业领域的知识和数据挖掘经验，光是这些还是不够的，还需要不停的尝试，在试错中前进，有时多少还要靠点运气。

#coding=gbk
    #使用转换器抽取特征
    import pandas as pd 
    import numpy as np 
    
    # 1. 特征抽取
    names = ['Age','Work-Class','fnlwgt','Education',
             'Education-Num','Marital-Status','Occupation',
             'Relationship','Race','Sex','Capital-gain',
             'Capital-loss','Hours-per-week','Native-Country',
             'Earning-Raw'
             ]
    filename = r'D:\datasets\Adult.csv'
    adult = pd.read_csv(filename, header=None, names = names)
    # print(adult.tail())
    print(adult.shape)  #    (32561, 15)
    adult.drop_duplicates()
    adult.dropna(how='all', inplace=True)
    print(adult.shape)  # (32561, 15)
    
    #对于连续性特征，使用常见的统计方法
    print(adult['Hours-per-week'].describe())
    # count    32561.000000
    # mean        40.437456
    # std         12.347429
    # min          1.000000
    # 25%         40.000000
    # 50%         40.000000
    # 75%         45.000000
    # max         99.000000
    # Name: Hours-per-week, dtype: float64
    print(adult['Education-Num'].median())  # 10.0 表示受教育的年限
    #打印出受教育年限为 16 年的总人数
    print(adult['Education-Num'].value_counts()[16])   # 413
    
    #使用unique 方法得到所有的工作情况
    print(adult['Work-Class'].unique())    #可以获得特征的属性
    # [' State-gov' ' Self-emp-not-inc' ' Private' ' Federal-gov' ' Local-gov'
    #  ' ?' ' Self-emp-inc' ' Without-pay' ' Never-worked']
    
    #数值特征也可以离散化转换成类别型特征,但是细节丢失是离散化的不好的情况，也是建模需要考虑的情况
    #这里创建 时长特征 LongHours， 用它表示一个人是否每周工作超过 40 小时， 将数值型转换成 类别型
    adult['LongHours'] = adult['Hours-per-week'] >40
    print(adult['LongHours'][:5].astype(int))   # 将其转换成数值型 0， 1
    # 0    0
    # 1    0
    # 2    0
    # 3    0
    # 4    0
    # Name: LongHours, dtype: int32

### 2.特征选择： ###

通常特征数量很多，我们只选取其中的一小部分。原因如下：

> **1.降低复杂度：**随着特征数量的增加，很多数据挖掘算法需要很多的时间和资源。减少特征数量，是提高算法运行速度，减少资源使用的好办法。
> 
> **2. 降低噪音：**增加特征额外的特征并不总会提升算法的表现。额外特征可能扰乱算法的正常工作。只选取合适的特征有助于减少出现没有实际意义的相关性的几率。
> 
> **3.增加模型的可读性：**根据成千上万的特征创建的模型来解答一个问题，对于计算机是很容易，当模型对我们来说是晦涩难懂的。因此，使用更少的特征，创建可以理解的模型是很有必要的。

选用干净的数据，选取更具有描述性的特征，对算法的效果提升很有帮助。如果数据集的特征都相同，就跟没提供什么信息一样，挖掘就失去了意义。

#使用sckit-learn 中的VarianceThreshold 转换器来删除特征值方差达不到最低标准的特征。
    X = np.arange(30).reshape((10,3))   #输出一个10行 3列 的矩阵，可以将它看成是 10个 个体， 3个特征
    X[:,1] = 1 #将第二列转变成 1, 因此第1,3列的方差大， 第2 列方差 为0
    #使用 转换器 VarianceThreshold处理数据集
    from sklearn.feature_selection import VarianceThreshold
    vt = VarianceThreshold(threshold=2) # 可以设定自定义的阈值
    Xt = vt.fit_transform(X)
    print(Xt)   # 可以看出 第二列的方差是0 ， 表示不包含具有区别意义的信息
    # [[ 0  2]
    #  [ 3  5]
    #  [ 6  8]
    #  [ 9 11]
    #  [12 14]
    #  [15 17]
    #  [18 20]
    #  [21 23]
    #  [24 26]
    #  [27 29]]
    print(vt.variances_)    # [74.25  0.   74.25] 输出每一列的方差

**选择最优的特征：**

**特征很多的情况下，怎么选取出最优的特征是很具有难度的工作。他与解决数据挖掘问题自身问题相关，计算量很大。随着特征数量的增加，寻找子集的任务复杂度呈指数级增加。寻找最佳特征组合的时间复杂同样是指数级增加。**

>  **其中一个变通的方法就是不要找表现好的子集，而是去找表现好的单个特征，单个变量，依据是它们各自能达到的准确度。分类任务一般是这样做，一般只要测量变量与目标类别之间的某种相关性就可以。**
> 
>  **scikit-learn提供了几种用于选择单变量特征的转换器，其中SelectKBest 是返回k 个最佳特征， SelectPercentile 是返回表现最佳的前 r% 个特征。单个特征和某一类别之间的相关性的计算方法有很多，最常用的有卡方分布 ，其他方法还有 信息熵。**

#选择最佳特征，使用 SelectKBest 和 chi2, 和 SelectPecentile
    X = adult[['Age','Education-Num','Capital-gain','Capital-loss','Hours-per-week']].values
    print(X[:5])    # 随意抽取一些特征，将其转换成数组形式
    #将Earning-Raw 税前收入 是否达到 5 万美元作为 目标类别
    adult['Earning-Raw'] = adult['Earning-Raw'] == ' >50K'   # 多于 50k 美元的为True
    adult['Earning-Raw'] = adult['Earning-Raw'].astype(int) # 不转换成0， 1 都可以
    y = adult['Earning-Raw'].values
    print(y[:5])    # [0 0 0 0 0]
    # y = (adult['Earning-Raw'] == ' >50K').values    # 注意 ' >50K' 字符串的格式
     
    #使用SelectKBest 转换器类，用卡方函数打分
    from sklearn.feature_selection import SelectKBest
    from sklearn.feature_selection import chi2
     
    transformer = SelectKBest(score_func=chi2, k=3) # 使用卡方检验， 得到分类效果较好的 3 个特征
    Xt_chi2 = transformer.fit_transform(X, y)
     
    # print(Xt_chi2)
    print(transformer.scores_)
    # [8.60061182e+03 2.40142178e+03 8.21924671e+07 1.37214589e+06
    #  6.47640900e+03]  可以看出 1,3,4 列的值最大，相关性最好
    
    #使用 Peaesonr 相关系数
    #皮尔逊函数返回2个数组，每个特征的皮尔逊相关系数和  p 值
    #皮尔逊函数的参数有2个数组， 第一个是一维数组
    from scipy.stats import pearsonr
    def multivariate_pearsonr(X, y):
        scores, pvalues =[], []
        for column in range(X.shape[1]):
            cur_score, cur_p = pearsonr(X[:,column], y)  # 遍历X 中的每一列，计算系数和p，将其保存到列表当中
            scores.append(abs(cur_score))
            pvalues.append(cur_p)
        return (np.array(scores), np.array(pvalues))
    
    transformer1 = SelectKBest(score_func=multivariate_pearsonr, k=3)
    Xt_pearsonr = transformer1.fit_transform(X, y)
    print(transformer1.scores_)     
    # [0.2340371  0.33515395 0.22332882 0.15052631 0.22968907] 得到 1， 2， 5 列的相关性较大
    
    #使用决策树进行预测
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.model_selection import cross_val_score
    clf = DecisionTreeClassifier(random_state=666)
    score_chi2 = cross_val_score(clf, Xt_chi2, y, scoring='accuracy')
    score_pearsonr = cross_val_score(clf, Xt_pearsonr, y, scoring='accuracy')
    mean_chi2 = np.mean(score_chi2) *100
    mean_peasonr = np.mean(score_pearsonr) *100
    #可以看出使用卡方检验的方法得到的特征组合效果比较好
    print('the chi2 accuracy is %.3f'%mean_chi2 +'%')   # the chi2 accuracy is 82.875%
    print('the chi2 accuracy is %.3f'%mean_peasonr +'%')    #the chi2 accuracy is 77.074%

### 3.创建特征： ###

数据来源：[https://archive.ics.uci.edu/ml/datasets/Internet+Advertisements][https_archive.ics.uci.edu_ml_datasets_Internet_Advertisements]

有时，仅仅选择已有的特征是不够用的，我们就要不同的方法从已有的特征中发掘新的特征。

### 4.创建自己的转换器 ###

随着数据集复杂程度的提高和类型的变化，现成的特征抽取不能满足需求了，那就需要自己编写转换器了。转换器类似于转换函数，它接收一种形式的数据，输出另外一种的形式。转换器可以用训练集训练，训练得到的参数可以用来转换测试数据集。

> 转换器API 有2个关键函数：
> 
> 1、fit() :接收训练数据， 设置内部参数
> 
> 2、transform() : 转换过程。接收训练数据集或相同格式的新的数据集。
> 
> fit() 和 transform() 函数的输入应该是同一种数据类型， 但是transform() 可以是返回不同类型的数据类型。

# 4.创建自己的转换器,Hours-per-week 特征使用均值作为二值化的阈值
    from sklearn.base import TransformerMixin   #需要继承的 Mixin 类
    from sklearn.utils import as_float_array    # 转换函数
    
    class MeanDiscrete(TransformerMixin):
        def fit(self, X, y=None):   # 这里需要传入3 个参数，否则会报错
            X = as_float_array(X)
            self.mean = X.mean(axis =0) #保存每个特征的均值
            return self
        
        def transform(self, X):
            X = as_float_array(X)        #输入必须是numpy数组，还要检查输入的数据列数是否一致。
            assert X.shape[1] == self.mean.shape[0] # X 中的特征数应该与训练集中的特征数一致
            return X > self.mean
    mean_discrete = MeanDiscrete()
    X_mean = mean_discrete.fit_transform(X) # 返回与 X 相同shape大小的 数组
    print(X_mean)
    
    #单元测试
    #为了创建单元测试，从numpy 引入testing 模块中的assert_array_equal 函数，检测2个数组是否相等
    def test_meandiscrete():
        X_test = np.array([[0,2],[3,5],[6,8],[9,11],[12,14],
                           [15,17],[18,20],[21,23],[24,26],[27,29]
                           ])
        mean_discrete = MeanDiscrete()
        mean_discrete.fit(X_test)
        assert_array_equal(mean_discrete.mean, np.array([13.5, 15.5])) 
        X_transformed = mean_discrete.transform(X_test)
        X_expected =np.array([[0,0],[0,0],[0,0],[0,0],[0,0],
                              [1,1],[1,1],[1,1],[1,1],[1,1]
                              ])  
        assert_array_equal(X_transformed, X_expected)
        print('test works')
    test_meandiscrete()
    
    #组装起来,使用Pipeline，创建一个流水线，第一步是使用MeanDiscrete转换器，第二步是使用决策树，然后进行交叉验证
    from sklearn.pipeline import Pipeline
    pipeline = Pipeline([('mean_discrete', MeanDiscrete()),
                         ('classifier',DecisionTreeClassifier(random_state=14))
                         ])
    score_mean_discrete = cross_val_score(pipeline, X, y, scoring= 'accuracy')
    # print('Mean Discrete performance: {0:.3f}'.format(score_mean_discrete.mean()))
    score = np.mean(score_mean_discrete) *100
    print('the accuracy is %.3f'%score +'%')    #  the accuracy is 80.271%

参考：《Python数据挖掘入门与实践》

[https_archive.ics.uci.edu_ml_datasets_Adult]: https://archive.ics.uci.edu/ml/datasets/Adult
[https_archive.ics.uci.edu_ml_datasets_Internet_Advertisements]: https://archive.ics.uci.edu/ml/datasets/Internet+Advertisements