数据分析--数据预处理

本文主要是个人的学习笔记总结，数据预处理的基本思路和方法，包括一些方法的使用示例和参数解释，具体的数据预处理案例case详见其他文章。如有错误之处还请指正！

数据在进行建模和分析前，对其进行数据处理是必不可少的，这样做能帮助我们从根本上保证数据质量，提高数据的准确性和可靠性。主要包括数据清洗、数据转换、数据集成、数据降维等过程。

数据的质量评定

从五个维度来对数据质量进行评定

数据处理步骤

数据处理的常见四个步骤：

下面将详细介绍常用的数据处理方法：

缺失值的处理

标记缺失值

# 生成包含缺数据的示例
import numpy as np
import pandas as pd

null_data = {'A': [10, np.nan, 25, np.nan, 42, np.nan],
             'B': [12, 15, np.nan, 14, 17, np.nan],
             'C': [10, 13, 27, 13, 19, 40]}

df = pd.DataFrame(null_data)

• 空值也有不同类型

  数值型空值 ：NaN (not a number)

  空字符串 ：None

• 定位缺失数据：

  • 使用 isnUll() 返回 True 代表缺失值
  • notnull()则与之相反

删除缺失值

• 直接删除
  • 缺失数据占全部数据比例非常低，可忽略不计且删除后不会对整体数据分布产生影响
  • 缺失数据因为本身特性无法填充，比如对于某些检测指标，填充数值会对结果产生影响的宁愿删除也不要进行处理

# 删除缺失值
import pandas as pd

# 创建一个示例数据框
data = {'A': [1, 2, None, 4],
        'B': [5, None, 7, 8],
        'C': [None, 10, None, 12]}
df = pd.DataFrame(data)

# 删除包含缺失值的行
cleaned_df1 = df.dropna()  # 默认删除包含缺失值的行
cleaned_df2 = df.dropna(axis=1)  # 删除包含缺失值的列
cleaned_df3 = df.dropna(how='all')  # 当所有值为缺失值时删除行
cleaned_df4 = df.dropna(thresh=2)  # 至少要有 2 个非缺失值才保留行
cleaned_df5 = df.dropna(subset=['B', 'C'])  # 只有在 'B' 和 'C' 列中同时存在空值的情况下，对应的行才会被删除

print(cleaned_df1)
print(cleaned_df2)
print(cleaned_df3)
print(cleaned_df4)
print(cleaned_df5)

填充缺失值

• 固定值填充：人为指定，使用行/列均值、中位数等

  # Pandas 提供的 replace t填充固定值
  print(df.replace(np.nan,0)) # 缺失值填充为0
  # 专门用于填充缺失值的函数 fillna()
  print(df.fillna(0)) 
  # 使用各列的平均值填充
  print(df.fillna(df.mean()))
  # 使用格列中位数填充
  print(df.fillna(df.median()))
  

• 临近值填充：使用缺失值相临近的数值填充

  # 使用后一个临近的数据向前填充
  print(df.fillna(method='bfill'))
  # 使用前一个临近的数据向后填充
  print(df.fillna(method='ffill'))
  

• 数字填充：使用函数插值填充

  数据缺失但能看出数据的变化趋势，更好的缺失值填充方法时是使用数据方法进行插值Pandas中的interpolate()可以快速应用一些常用的插值函数

  sample_data = {'A': [1, np.nan, 3, np.nan, 5, 6],
                 'B': [1, 4, np.nan, np.nan, 25, 36]}
  
  df = pd.DataFrame(sample_data)
  # 线性插值
  print(df.interpolate(method='linear'))
  # 2次函数插值
  print(df.interpolate(method='polynomial', order=2))
  

重复值处理

# 示例数据
df = pd.DataFrame({'name': ['amy', 'david'] * 3 +
                   ['jam'], 'class': [2, 2, 2, 4, 3, 2, 4]})

• duplicated() 判断是否存在重复值

  print(df.duplicated()) # 判断重复值 存在则返回True
  print(df.duplicated().sum()) # 统计判断重复值
  

• dropduplicates() 去除重复值

df.drop_duplicatep() #去除全部重复值
df.drop_duplicates(['name']) #去除name列的重复值
df.drop_duplicates(keep='last') # 默认保留重复项前面的值，而去除后面的值，‘last’则为保留最后一个

异常值的处理

当涉及 Pandas 应用数学与统计学领域中的异常值检测时，有一些比较深入的方法，包括概率方法，矩阵分解，以及神经网络等。下面是一些具体示例展示：

1. 概率方法 - 一元正态分布检测异常值：

   import pandas as pd
   import numpy as np
   
   # 创建一个示例数据集
   data = pd.DataFrame({'value': [1, 2, 3, 4, 5, 1000]})
   
   # 计算均值和标准差
   mean = data['value'].mean()
   std = data['value'].std()
   
   # 设置异常值阈值，例如均值加减3倍标准差
   threshold = 3 * std
   
   # 使用一元正态分布方法检测异常值
   data['is_outlier'] = np.abs(data['value'] - mean) > threshold
   print(data)
   

2. 概率方法 - 多元高斯方法检测异常值：

   from scipy import stats
   
   # 创建一个示例数据集
   data = pd.DataFrame({
       'feature1': [1, 2, 3, 4, 5],
       'feature2': [2, 4, 6, 8, 10]
   })
   
   # 计算多元高斯分布概率密度
   multivariate_dist = stats.multivariate_normal(mean=data.mean(), cov=data.cov())
   
   # 设置异常值阈值
   threshold = 0.01  # 例如设置一个较小的阈值
   
   # 使用多元高斯方法检测异常值
   data['is_outlier'] = multivariate_dist.pdf(data) < threshold
   print(data)
   

3. 矩阵分解方法检测异常值：

   from sklearn.decomposition import PCA
   
   # 创建一个示例数据集
   data = pd.DataFrame({
       'feature1': [1, 2, 3, 4, 5],
       'feature2': [2, 4, 6, 8, 100]
   })
   
   # 使用主成分分析（PCA）进行矩阵分解
   pca = PCA(n_components=2)
   pca.fit(data)
   
   # 计算重构误差
   reconstruction_error = np.sum((data - pca.inverse_transform(pca.transform(data))) ** 2, axis=1)
   
   # 设置异常值阈值
   threshold = 20  # 例如设置一个阈值
   
   # 使用矩阵分解方法检测异常值
   data['is_outlier'] = reconstruction_error > threshold
   print(data)
   

4. 神经网络方法检测异常值：

   from sklearn.neighbors import LocalOutlierFactor
   
   # 创建一个示例数据集
   data = pd.DataFrame({'value': [1, 2, 3, 4, 5, 1000]})
   
   # 使用局部异常因子（Local Outlier Factor）进行异常值检测
   lof = LocalOutlierFactor(n_neighbors=2, contamination=0.1)  # 设置参数
   data['is_outlier'] = lof.fit_predict(data[['value']])
   
   print(data)
   

数据集合并

这里主要是用pandas中的常见方法进行数据集的连接合并。

pandas.DataFrame.concat()方法合并：

pandas.concat(
    objs,              # 接受一个列表或字典，表示要连接的 pandas 对象（Series 或 DataFrame）
    axis=0,            # 沿指定轴进行连接，0 表示沿第一个轴（行方向）连接，1 表示沿第二个轴（列方向）连接
    join='outer',      # 指定连接的方式，'outer'表示并集（union），'inner'表示交集（intersection）
    ignore_index=False,# 如果为 True，将忽略原始索引并生成一个新的整数索引
    keys=None,         # 创建层次化索引，用于识别每个片段
    levels=None,       # 指定多级索引的级别（通常自动推断）
    names=None,        # 指定多级索引的级别名称
    verify_integrity=False,  # 如果为 True，在连接操作之前验证轴是否包含重复项
    sort=False         # 如果为 True，对非连接轴上的索引进行排序
)

以下是对各个参数的详细解释：

• objs：要连接的 pandas 对象列表。可接受一个列表（或字典），其中包含要连接的 DataFrame 或 Series 对象。
• axis：指定连接的轴方向。0 表示在行方向上连接，1 表示在列方向上连接。
• join：指定连接的方式。默认为 'outer'，表示取并集进行连接，也可以选择 'inner'，表示取交集进行连接。
• ignore_index：如果为 True，将忽略原始索引并生成一个新的整数索引。
• keys：当数组沿着连接轴堆叠时，可以用 keys 参数创建一个层次化索引（MultiIndex），以便识别每个片段。
• levels：指定键的层次化级别，通常不需要手动指定，会根据 keys 推断。
• names：指定多级索引的级别名称。
• verify_integrity：如果为 True，在连接操作之前验证轴是否包含重复项，如果包含重复项则会抛出 ValueError 异常。
• sort：如果为 True，在连接操作之后对非连接轴上的索引进行排序。

​

pandas.DataFrame.merge() 方法合并：

pandas.merge(
    left,                     # 左侧的 DataFrame 对象
    right,                    # 右侧的 DataFrame 对象
    how='inner',              # 合并方式，默认为 'inner'，表示取两个 DataFrame 的交集
    on=None,                  # 指定列名或索引级别作为合并的键，默认为 None，表示自动根据列名的交集进行合并
    left_on=None,             # 指定左侧 DataFrame 中的列名或索引级别作为合并的键
    right_on=None,            # 指定右侧 DataFrame 中的列名或索引级别作为合并的键
    left_index=False,         # 如果为 True，在左侧 DataFrame 中使用索引作为合并键
    right_index=False,        # 如果为 True，在右侧 DataFrame 中使用索引作为合并键
    sort=False,               # 如果为 True，根据合并键对结果进行排序
    suffixes=('_left', '_right'),  # 如果列名冲突，为列名添加后缀来区分，默认为 '_left' 和 '_right'
    copy=True                 # 如果为 True，在执行合并操作时复制数据
)

以下是对各个参数的详细解释：

• left：左侧的 DataFrame 对象。
• right：右侧的 DataFrame 对象。
• how：指定合并的方式，默认为 'inner'，即取两个 DataFrame 的交集。还可以选择 'outer'，表示取两个 DataFrame 的并集；'left'，表示以左侧 DataFrame 的键为基准进行合并；'right'，表示以右侧 DataFrame 的键为基准进行合并。
• on：指定列名或索引级别作为合并的键。默认为 None，表示自动根据列名的交集进行合并。
• left_on：指定左侧 DataFrame 中的列名或索引级别作为合并的键。
• right_on：指定右侧 DataFrame 中的列名或索引级别作为合并的键。
• left_index：如果为 True，在左侧 DataFrame 中使用索引作为合并键。
• right_index：如果为 True，在右侧 DataFrame 中使用索引作为合并键。
• sort：如果为 True，根据合并键对结果进行排序。
• suffixes：如果列名冲突，为列名添加后缀来区分，默认为 ('_left', '_right')。
• copy：如果为 True，在执行合并操作时复制数据。

pandas.DataFrame.join() 方法：

DataFrame.join(
    other,                     # 合并的另一个 DataFrame 对象
    on=None,                   # 指定列名或索引级别作为合并的键，默认为 None，表示根据索引进行合并
    how='left',                # 合并方式，默认为 'left'，表示以左侧 DataFrame 为基准进行左外连接
    lsuffix='',                # 左侧 DataFrame 列名相同时的后缀，默认为 ''，不添加任何后缀
    rsuffix='',                # 右侧 DataFrame 列名相同时的后缀，默认为 ''，不添加任何后缀
    sort=False                 # 如果为 True，根据合并键对结果进行排序
)

以下是对各个参数的详细解释：

• other：合并的另一个 DataFrame 对象。
• on：指定列名或索引级别作为合并的键。默认为 None，表示根据索引进行合并。
• how：指定合并的方式，默认为 'left'，即以左侧 DataFrame 为基准进行左外连接。还可以选择 'inner'，表示取两个 DataFrame 的交集；'outer'，表示取两个 DataFrame 的并集；'right'，表示以右侧 DataFrame 为基准进行右外连接。
• lsuffix：表示左侧 DataFrame 中列名相同时的后缀，默认为 ''，即不添加任何后缀。
• rsuffix：表示右侧 DataFrame 中列名相同时的后缀，默认为 ''，即不添加任何后缀。
• sort：如果为 True，根据合并键对结果进行排序。

数据映射 map()方法完成

df = pd.DataFrame({'name': ['amy', 'david', 'jam'], 'age': [14, 13, 12]})
name_to_gender = {'amy': 'girl', 'david': 'boy', 'jam': 'boy'}  # 建立映射字典
df['gender'] = df['name'].map(name_to_gender)

分组聚合

pandas.DataFrame.groupby()对数据集进行分组聚合

df = pd.DataFrame({'key1': ['A', 'B', 'C', 'A', 'B', 'C'],
                   'key2': ['X', 'Y', 'X', 'Y', 'X', 'Y'],
                   'data': [1, 2, 3, 4, 5, 6]})
df.groupby(by='key1').sum()
df.groupby(by=['key1', 'key2']).mean() # 替换为count().mean()等其它函数

数据转换

不仅是数据格式或类型的转换，更多的是通过一些统计学方法对数据进行标准化或离散化处理。

特征工程：需要去设计数据特征，以帮助训练得到性能更加优异的模型。

标准化 Normalization（无量纲化）是数据预处理中的常用手段。标准化的目的主要是消除不同特征之间的量纲和取值范围不同造成的差异。这些差异，不仅会造成数据偏重不均，还会在可视化方面造成困扰

import numpy as np
import pandas as pd
%matplotlib inline

np.random.seed(10)  # 随机数种子
df = pd.DataFrame({'A': np.random.random(
    20), 'B': np.random.random(20) * 10000})
print(df.plot())  # 绘图

此时，B列数据太大，A列已经无法看出趋势，近似一条直线.

Z-Score 标准化

Z-Score 标准化 是常用的标准化手段之一，其公式为：

其中， 𝜇

为样本数据的均值， 𝜎

为样本数据的标准差。Z-Score 标准化之后的数据的均值为 0，方差为 1。

通过Z-Score 标准化，可以使不同数据集之间的数据具有可比性，同时可以减小异常值对数据分析和模型建立的影响。

# 使用Z-Score标准化对上面的DataFrame进行标准化处理并绘图
df_z_score = (df - df.mean()) / df.std()  # Z-Score 标准化
df_z_score.plot()

Z-Score 标准化方法在 Scipy 中有一个对应的APIscipy.stats.zscore 可以使用

from scipy import stats
stats.zscore(df)

也可以将 DataFrame 处理从 NumPy 数组再运算

(df.values - df.values.mean(axis=0)) / df.values.std(axis=0)  #  NumPy 数组运算

除了 SciPy，scikit-learn 也提供了 Z-Score 标准化API sklearn.preprocessing.StandardScaler()

Min-Max 标准化

该方法可以将数据转化到一个特定的区间范围内，通常是[0, 1]或者[-1, 1]之间。这种标准化方法适用于以下场景：

1. 数据需要落入特定区间范围内：例如神经网络的输入层，很多情况下都要求输入数据的范围在[0, 1]或者[-1, 1]之间。

2. 需要保留原始数据的相对性质：Min-Max 标准化会保持原始数据中不同数值之间的相对大小关系，不会改变数据的分布形态。

3. 异常值较少：Min-Max 标准化对异常值比较敏感，如果数据中存在较多的异常值，可能会导致标准化后的数据集不够均衡。

公式为：

其中， 𝑥𝑚𝑎𝑥为样本数据的最大值， 𝑥𝑚𝑖𝑛为样本数据的最小值， 𝑥𝑚𝑎𝑥−𝑥𝑚𝑖𝑛为极差。

# 使用Min-Max标准化对上面的DataFrame进行标准化处理
df_min_max = (df - df.min()) / (df.max() - df.min())  # Min-Max 标准化
df_min_max.plot()

同样，scikit-learn 也提供了 Min-Max 标准化的 API sklearn.preprocessing.MinMaxScaler()，使用方法如下：

from sklearn.preprocessing import MinMaxScaler
MinMaxScaler().fit_transform(df)

独热编码

在对数据的预处理过程中，我们会遇到有一些特征列中的样本并不是连续存在的，而是以分类形式存在的情况。例如，某一装置的状态有三种情况，分别为：正常、机械故障、电路故障。如果我们要将这些数据运用到后续的预测分析中，就需要对文字状态进行转换。一般情况下，可以用 0 表示正常，1 代表机械故障，2 代表电路故障。

所以，对于以分类形式存在的特征变量，我们会采用一种叫 独热编码 One-Hot Encoding 的方式将其转换成二元特征编码，进一步对特征进行了稀疏处理。独热编码采用位状态寄存器来对个状态进行编码，每个状态都由它独立的寄存器位，并且在任意时候只有一位有效。

# Pandas 中，可以使用 get_dummies 很方便地完成独热编码。
df = pd.DataFrame({'fruits': ['apple', 'banana', 'pineapple']*2})  # 示例装置状态表
pd.get_dummies(df)  # 独热编码

数据离散化

数据离散化有时候是为了算法实施需要，也有可能离散数据更适合数据的信息表达。当我们对连续数据进行按区间离散化时，你可以通过编写代码实现。不过，这里介绍 Pandas 中一个非常方便的区间离散化方法 pd.cut(适用于等宽离散化)

# 将数组等间距分割为3部分
pd.cut(np.array([1, 2, 7, 8, 5, 4, 12, 6, 3]), bins=3)  # bins 指定划分数量

此时，如果我们按照 3 个区间对数据添加类别标签 "small", "medium", "large"，只需要指定 labels= 参数即可

pd.cut(np.array([1, 2, 7, 8, 5, 4, 12, 6, 3]),
       bins=3, labels=["small", "medium", "large"])

一般情况下，区间返回会以最大值为准，向最小值方向扩展 0.1% 以保证元素被有效分割。所以上面的区间不是以最小值 1 开始，而是 0.989。其中

当然，也可以自行指定划分区间：

pd.cut(np.array([1, 2, 7, 8, 5, 4, 12, 6, 3]), 
       bins=[0, 5, 10, 15], labels=["small", "medium", "large"])

数据规约

主成成分分析(Principal Components Analysis)

通过对协方差矩阵进行特征分解，从而得出主成分（特征向量）与对应的权值（特征值）。然后剔除那些较小特征值（较小权值）对应的特征，从而达到降低数据维数的目的。

PCA最便捷方式通过scikit-learn完成

下面以常见的鸢尾花示例数据集作为示例：

# 加载鸢尾花实例数据集
import pandas as pd
from sklearn.datasets import load_iris
from matplotlib import pyplot as plt
%matplotlib inline

iris = load_iris()  # 加载原始数据
iris_df = pd.DataFrame(iris.data, columns=iris.feature_names)  # 处理为 DataFrame

数据集包含有4列，代表鸢尾花的4个特征。若想将上面的数据绘制成数据点图（平面散点图），就无法实现，此时就需要对数据进行降维处理

介绍以下 sklearn.decomposition.PCA 方法中的几个参数：

• n_components= 表示需要保留主成分（特征）的数量。
• copy= 表示针对原始数据降维还是针对原始数据副本降维。当参数为 False 时，降维后的原始数据会发生改变，这里默认为 True。
• whiten= 白化表示将特征之间的相关性降低，并使得每个特征具有相同的方差。
• svd_solver= 表示奇异值分解 SVD 的方法。有 4 参数，分别是：auto, full, arpack, randomized。

# 续上段代码， 进行PCA
iris_pca = PCA(n_components=2).fit_transform(iris_df)  # PCA 降 2 维
iris_pca = pd.DataFrame(iris_pca, columns=['pca_x', 'pca_y'])  # 整理 DataFrame
iris_pca.plot.scatter(x='pca_x', y='pca_y')  # 绘制数据点
iris_pca.plot.scatter(x='pca_x', y='pca_y',
                      c=iris.target, cmap='plasma')  # 数据点着色

PCA在很多情况下是非常有用的, 上述是从可视化角度进行，以下是常见使用：

1. 降低数据维度：高维数据集会增加分析数据的复杂性，而PCA可以将高维数据投影到低维空间中，同时保留了大部分数据的变异性。这有助于简化数据集、减少存储空间和计算成本。

2. 消除数据间的相关性：在许多数据集中，不同特征之间存在相关性。PCA可以消除或减轻这些特征之间的相关性，从而更好地反映数据之间的独立性，减少重复信息。

3. 提高模型的性能：在一些机器学习任务中，高维数据可能会导致过拟合，而PCA可以有效减少数据的维度，帮助改善模型的泛化能力，并提高预测的准确性。

4. 数据可视化：通过PCA技术，可以将高维数据转换为二维或三维，从而更好地将数据可视化展现，以便更好地理解数据的结构和特征。

5. 去除噪声：在某些数据集中可能会存在噪声或不重要的信息，而PCA可以帮助排除这些噪声，提取出数据中最重要的信号和特征。

6. 特征提取：PCA可以帮助识别和提取主要的特征，从而更好地描述数据的内在结构，有助于模式识别、数据挖掘和预测任务。

线性判别分析

线性判别分析（Linear Discriminant Analysis，英文：LDA）同样可以用于特征降维。LDA 本来是一种分类模型，它试图找到两类物体或事件的特征的一个线性组合，以便能够特征化或区分它们。

LDA 和 PCA 的本质相似，都会将原始的样本映射到维度更低的样本空间中。不过，PCA 映射后的样本具有更大的发散性，而 LDA 映射后的样本具有更明显的类别区分。

scikit-learn 同样提供了可以用于 LDA 处理的 API：sklearn.discriminant_analysis.LinearDiscriminantAnalysis，使用方法如下：

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

iris_lda = LinearDiscriminantAnalysis(
    n_components=2).fit_transform(iris_df, iris.target)  # lda 降 2 维

iris_lda = pd.DataFrame(iris_lda, columns=['lda_x', 'lda_y'])  # 整理 DataFrame

通过绘制子图来对比PCA和LDA两种方法降维之后的数据分布:

fig, axes = plt.subplots(ncols=2, nrows=1, figsize=(12, 3))
iris_lda.plot.scatter(x='lda_x', y='lda_y', c=iris.target,
                        cmap='plasma', ax=axes[0])  # 数据点着色
iris_pca.plot.scatter(x='pca_x', y='pca_y', c=iris.target,
                        cmap='plasma', ax=axes[1])  # 数据点着色

可以从上图看出二者的区别。PCA 和 LDA 是两种不同的降维方法，没有方法的好坏之说。一般情况下，PCA 会使用多一些，你可以看到 LDA 需要输入目标值，而 PCA 则无需这一点

皮尔逊相关系数

在统计学中， 皮尔逊积矩相关系数（英语：Pearson product-moment correlation coefficient）用于度量两个变量 𝑋 和 𝑌 之间的相关（线性相关），其值介于 -1 与 1 之间。在自然科学领域中，该系数广泛用于度量两个变量之间的相关程度。它是由卡尔·皮尔逊从弗朗西斯·高尔顿在 19 世纪 80 年代提出的一个相似却又稍有不同的想法演变而来。这个相关系数也称作「皮尔逊相关系数」。

两个变量之间的皮尔逊相关系数定义为两个变量之间的协方差和标准差的商：

有了皮尔逊相关性系数，我们就可以评估不同特征与目标值直接的相关性，从而剔除那些相关性弱的特征，达到特征压缩的目的。接下来，我们使用 SciPy 提供的皮尔逊相关性系数计算方法 scipy.stats.pearsonr 来求解 iris 示例数据集各特征与目标值之间的相关系数。

from scipy.stats import pearsonr

for i in range(4):
    p = pearsonr(iris_df.iloc[:, i], iris.target)[0]  # 求解每个特征与目标值的相关性
    print("{}: {}".format(iris.feature_names[i], p))  # 输出

上文说过，皮尔逊相关系数介于 -1 与 1 之间，越接近 1 则代表越正相关。所以，iris 示例数据集中与目标值更为相关的特征是 sepal length，petal length 和 petal width。

这里再补充一种计算数据集特征和目标之间皮尔逊相关性系数的方法，你可以直接在 DataFrame 后添加 corr() 属性获得。更为常用的是通过 Seaborn 可视化工具绘制热图。

import seaborn as sns

# 得到特征和目标拼合后的 DataFrame
iris_full_df = pd.concat([pd.DataFrame(iris.data, columns=iris.feature_names),
                            pd.DataFrame(iris.target, columns=['iris_target'])], axis=1)

sns.heatmap(iris_full_df.corr(), square=True, annot=True)  # corr() 函数计算皮尔逊相关系数

区别于手动计算各特征和目标之间的相关系数，上方热图还计算了特征之间的相关系数。观察热图最后一行，不难发现与通过 scipy.stats.pearsonr 计算的结果一致。

卡方检验

在 1900 年，皮尔逊发表了著名的关于 卡方检验（ Chi-Squared Test）的文章，该文章被认为是现代统计学的基石之一。简单来讲，实际观测值与理论推断值之间的偏离程度就决定卡方值的大小。若卡方值越小，代表偏差越小，越趋于符合。

scikit-learn 提供了 sklearn.feature_selection.SelectKBest 可以返回 k 个最佳特征，不过我们需要使用 sklearn.feature_selection.chi2 来计算卡方值。接下来，同样使用 iris 数据集来进行卡方检验。

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2

kafang = SelectKBest(score_func=chi2, k=3)  # 保留 3 个最佳特征，并使用卡方检验
kafang.fit_transform(iris_df, iris.target)

transformer 输出了需要保留的最佳特征，与 iris_df 对比后你会发现，它保留了与皮尔逊相关系数结果一致的 sepal length，petal length 和 petal width 特征。你可以通过 scores_ 属性输出卡方值的计算结果。

kafang.scores_  # 各特征与目标值之间的卡方值

这里要补充一点是，实际使用中卡方检验和皮尔逊相关系数的评估结果并不会都像 IRIS 数据集上一致，往往会得到不同的结果。这其实也就反映出选取最好的特征往往取决于评估指标，而没有唯一答案。

上面我们介绍依据皮尔逊相关系数和卡方检验进行特征选择的方法在特征工程中又被归类于 Filter 过滤法，它主要侧重于单个特征跟目标变量的相关性。这种方法的优点在于计算速度快，且有较高的鲁棒性。但是，Filter 方法的缺点在于不考虑特征之间的相关性。因为，有可能某一个特征自身不具备代表性，但是它和某些其它特征组合起来会使得模型会得到不错的效果。这一点就是 Filter 方法无法考虑到的了。

除此之外，从特征工程的角度来讲，还可以使用 Wrapper 封装法和 Embeded 集成方法来完成特征选择。

数据抽样

数据抽样是通过减少样本而非特征的数据来达到数据规约的效果。数据抽样通过从原始数据集中随机采集样本构成子集，从而降低数据规模。

最简单的抽样当然就是「随机抽样」了，我们可以生成一组随机索引，然后从数据集中抽取到相应的数据。这里，我们使用上方的 IRIS 数据集来完成。

import numpy as np

chosen_idx = np.random.choice(
    len(iris_df), replace=False, size=10)  # 从 IRIS 数据集中抽取 10 条数据
iris_df.iloc[chosen_idx]  # 抽取相应索引的数据

还可以直接使用 Pandas 提供的 pandas.DataFrame.sample 方法完成随机抽样过程，其中只需要指定抽样数目即可。

iris_df.sample(n=10) 

注意：数据抽样虽然在这里被归入数据规约，但实际上更多用于前面的环节中。一般情况下，会从清洗后的数据中抽样，使用抽样数据来完成特征工程和建模，以探索方法实施的可能性。最终再使用完整数据集进行建模分析

热门相关：隐身侍卫   在遗忘的时光里重逢   都市最强小村医   唐枭   邪王独宠：纨绔异能妃