七、特征工程

作者：Chris Albon

译者：飞龙

协议：CC BY-NC-SA 4.0

稀疏特征矩阵上的降维

  1. # 加载库
  2. from sklearn.preprocessing import StandardScaler
  3. from sklearn.decomposition import TruncatedSVD
  4. from scipy.sparse import csr_matrix
  5. from sklearn import datasets
  6. import numpy as np
  8. # 加载数据
  9. digits = datasets.load_digits()
  11. # 标准化特征矩阵
  12. X = StandardScaler().fit_transform(digits.data)
  14. # 生成稀疏矩阵
  15. X_sparse = csr_matrix(X)
  17. # 创建 TSVD
  18. tsvd = TruncatedSVD(n_components=10)
  20. # 在稀疏矩阵上使用 TSVD
  21. X_sparse_tsvd = tsvd.fit(X_sparse).transform(X_sparse)
  23. # 展示结果
  24. print('Original number of features:', X_sparse.shape[1])
  25. print('Reduced number of features:', X_sparse_tsvd.shape[1])
  27. '''
  28. Original number of features: 64
  29. Reduced number of features: 10 
  30. '''
  32. # 前三个主成分的解释方差比之和
  33. tsvd.explained_variance_ratio_[0:3].sum()
  35. # 0.30039385372588506

核 PCA 降维

七、特征工程 - 图1

  1. # 加载库
  2. from sklearn.decomposition import PCA, KernelPCA
  3. from sklearn.datasets import make_circles
  5. # 创建线性不可分的数据
  6. X, _ = make_circles(n_samples=1000, random_state=1, noise=0.1, factor=0.1)
  8. # 应用带有径向基函数（RBF）核的核 PCA
  9. kpca = KernelPCA(kernel="rbf", gamma=15, n_components=1)
  10. X_kpca = kpca.fit_transform(X)
  12. print('Original number of features:', X.shape[1])
  13. print('Reduced number of features:', X_kpca.shape[1])
  15. '''
  16. Original number of features: 2
  17. Reduced number of features: 1 
  18. '''

使用 PCA 的降维

七、特征工程 - 图2

  1. # 加载库
  2. from sklearn.preprocessing import StandardScaler
  3. from sklearn.decomposition import PCA
  4. from sklearn import datasets
  6. # 加载数据
  7. digits = datasets.load_digits()
  9. # 标准化特征矩阵
  10. X = StandardScaler().fit_transform(digits.data)
  12. # 创建保留 99% 方差的 PCA
  13. pca = PCA(n_components=0.99, whiten=True)
  15. # 使用 PCA
  16. X_pca = pca.fit_transform(X)
  18. # 展示结果
  19. print('Original number of features:', X.shape[1])
  20. print('Reduced number of features:', X_pca.shape[1])
  22. '''
  23. Original number of features: 64
  24. Reduced number of features: 54 
  25. '''

PCA 特征提取

主成分分析（PCA）是数据科学中常见的特征提取方法。 从技术上讲，PCA 找到具有最高特征值的协方差矩阵的特征向量，然后使用这些特征向量将数据投影到相等或更小维度的新子空间。 实际上，PCA 将 n 个特征矩阵转换为（可能）小于 n 个特征的新数据集。 也就是说，它通过构造新的较少变量来减少特征的数量，这些变量捕获原始特征中找到的信息的重要部分。 但是，本教程的目的不是要解释 PCA 的概念，这在其他地方做得非常好，而是用于演示 PCA 的实际应用。

  1. # 导入库
  2. import numpy as np
  3. from sklearn import decomposition, datasets
  4. from sklearn.preprocessing import StandardScaler
  6. # 加载乳腺癌数据集
  7. dataset = datasets.load_breast_cancer()
  9. # 加载特征
  10. X = dataset.data

请注意，原始数据包含 569 个观测和 30 个特征。

  1. # 查看数据集的形状
  2. X.shape
  4. # (569, 30)

这里是数据的样子

  1. # 查看数据
  2. X
  4. '''
  5. array([[  1.79900000e+01,   1.03800000e+01,   1.22800000e+02, ...,
  6.           2.65400000e-01,   4.60100000e-01,   1.18900000e-01],
  7.        [  2.05700000e+01,   1.77700000e+01,   1.32900000e+02, ...,
  8.           1.86000000e-01,   2.75000000e-01,   8.90200000e-02],
  9.        [  1.96900000e+01,   2.12500000e+01,   1.30000000e+02, ...,
  10.           2.43000000e-01,   3.61300000e-01,   8.75800000e-02],
  11.        ..., 
  12.        [  1.66000000e+01,   2.80800000e+01,   1.08300000e+02, ...,
  13.           1.41800000e-01,   2.21800000e-01,   7.82000000e-02],
  14.        [  2.06000000e+01,   2.93300000e+01,   1.40100000e+02, ...,
  15.           2.65000000e-01,   4.08700000e-01,   1.24000000e-01],
  16.        [  7.76000000e+00,   2.45400000e+01,   4.79200000e+01, ...,
  17.           0.00000000e+00,   2.87100000e-01,   7.03900000e-02]]) 
  18. '''
  20. # 创建缩放器对象
  21. sc = StandardScaler()
  23. # 使缩放器拟合特征并转换
  24. X_std = sc.fit_transform(X)

请注意，PCA 包含一个参数，即成分数。 这是输出特征的数量，需要进行调整。

  1. # 创建 PCA 对象，使用两个成分作为参数
  2. pca = decomposition.PCA(n_components=2)
  4. # 拟合 PCA 并转换数据
  5. X_std_pca = pca.fit_transform(X_std)

在 PCA 之后，新数据已降到了两个特征，其行数与原始特征相同。

  1. # 查看新特征数据的形状
  2. X_std_pca.shape
  4. # (569, 2) 
  6. # 查看新特征数据
  7. X_std_pca
  9. '''
  10. array([[  9.19283683,   1.94858307],
  11.        [  2.3878018 ,  -3.76817174],
  12.        [  5.73389628,  -1.0751738 ],
  13.        ..., 
  14.        [  1.25617928,  -1.90229671],
  15.        [ 10.37479406,   1.67201011],
  16.        [ -5.4752433 ,  -0.67063679]]) 
  17. '''

使用 KMeans 聚类对观测分组

  1. # 加载库
  2. from sklearn.datasets import make_blobs
  3. from sklearn.cluster import KMeans
  4. import pandas as pd
  6. # 制作模拟特征矩阵
  7. X, _ = make_blobs(n_samples = 50,
  8.                   n_features = 2,
  9.                   centers = 3,
  10.                   random_state = 1)
  12. # 创建 DataFrame
  13. df = pd.DataFrame(X, columns=['feature_1','feature_2'])
  15. # 创建 KMeans 聚类器
  16. clusterer = KMeans(3, random_state=1)
  18. # 拟合聚类器
  19. clusterer.fit(X)
  21. '''
  22. KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,
  23.     n_clusters=3, n_init=10, n_jobs=1, precompute_distances='auto',
  24.     random_state=1, tol=0.0001, verbose=0) 
  25. '''
  27. # 预测值
  28. df['group'] = clusterer.predict(X)
  30. # 前几个观测
  31. df.head(5)
feature_1feature_2group
0-9.877554-3.3361450
1-7.287210-8.3539862
2-6.943061-7.0237442
3-7.440167-8.7919592
4-6.641388-8.0758882

为 LDA 选择最佳数量的成分

在 scikit-learn 中，LDA 是使用LinearDiscriminantAnalysis实现的，包含一个参数n_components，表示我们想要返回的特征数。 为了找出用于n_components的参数值（例如，要保留多少参数），我们可以利用一个事实，explain_variance_ratio_告诉我们每个输出特征的解释方差并且是有序数组。

具体来说，我们可以运行Linear_iscriminantAnalysis，将n_components设置为None来返回由每个特征成分的解释方差比，然后计算需要多少成分才能超过解释方差的阈值（通常为 0.95 或 0.99）。

  1. # 加载库
  2. from sklearn import datasets
  3. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
  5. # 加载鸢尾花数据集
  6. iris = datasets.load_iris()
  7. X = iris.data
  8. y = iris.target
  10. # 创建并运行 LDA
  11. lda = LinearDiscriminantAnalysis(n_components=None)
  12. X_lda = lda.fit(X, y)
  14. # 创建解释方差比的数组
  15. lda_var_ratios = lda.explained_variance_ratio_
  17. # 创建函数
  18. def select_n_components(var_ratio, goal_var: float) -> int:
  19.     # 设置目前为止的初始解释方差
  20.     total_variance = 0.0
  22.     # 设置初始特征数
  23.     n_components = 0
  25.     # 对于每个特征的解释方差
  26.     for explained_variance in var_ratio:
  28.         # 将解释方差添加到总体
  29.         total_variance += explained_variance
  31.         # 成分数加一
  32.         n_components += 1
  34.         # 如果我们达到了我们的解释方差目标
  35.         if total_variance >= goal_var:
  36.             # 结束循环
  37.             break
  39.     # 返回成分数量
  40.     return n_components
  42. # 执行函数
  43. select_n_components(lda_var_ratios, 0.95)
  45. # 1

为 TSVD 选择最佳数量的成分

  1. # 加载库
  2. from sklearn.preprocessing import StandardScaler
  3. from sklearn.decomposition import TruncatedSVD
  4. from scipy.sparse import csr_matrix
  5. from sklearn import datasets
  6. import numpy as np
  8. # 加载数据
  9. digits = datasets.load_digits()
  11. # Standardize the feature matrix
  12. X = StandardScaler().fit_transform(digits.data)
  14. # 制作系数矩阵
  15. X_sparse = csr_matrix(X)
  17. # 创建并使用特征数减一运行 TSVD
  18. tsvd = TruncatedSVD(n_components=X_sparse.shape[1]-1)
  19. X_tsvd = tsvd.fit(X)
  21. # 解释方差的列表
  22. tsvd_var_ratios = tsvd.explained_variance_ratio_
  24. # 创建函数
  25. def select_n_components(var_ratio, goal_var: float) -> int:
  26.     # 设置目前为止的初始解释方差
  27.     total_variance = 0.0
  29.     # 设置初始特征数
  30.     n_components = 0
  32.     # 对于每个特征的解释方差
  33.     for explained_variance in var_ratio:
  35.         # 将解释方差添加到总体
  36.         total_variance += explained_variance
  38.         # 成分数加一
  39.         n_components += 1
  41.         # 如果我们达到了我们的解释方差目标
  42.         if total_variance >= goal_var:
  43.             # 结束循环
  44.             break
  46.     # 返回成分数量
  47.     return n_components
  49. # 执行函数
  50. select_n_components(tsvd_var_ratios, 0.95)
  52. # 40

将 LDA 用于降维

  1. # 加载库
  2. from sklearn import datasets
  3. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
  5. # 加载鸢尾花数据集
  6. iris = datasets.load_iris()
  7. X = iris.data
  8. y = iris.target
  10. # 创建 LDA，它将数据降维到 1 个特征
  11. lda = LinearDiscriminantAnalysis(n_components=1)
  13. # 运行 LDA 并使用它转换特征
  14. X_lda = lda.fit(X, y).transform(X)
  16. # 打印特征数
  17. print('Original number of features:', X.shape[1])
  18. print('Reduced number of features:', X_lda.shape[1])
  20. '''
  21. Original number of features: 4
  22. Reduced number of features: 1 
  23. '''
  25. ## 查看解释方差比
  26. lda.explained_variance_ratio_
  28. # array([ 0.99147248])