数据分析--数据预处理

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

• 数据的质量评定
• 数据处理步骤
  • 缺失值的处理
    • 标记缺失值
    • 删除缺失值
    • 填充缺失值
  • 重复值处理
  • 异常值的处理
  • 数据集合并
    • pandas.DataFrame.concat()方法合并：
    • pandas.DataFrame.merge() 方法合并：
    • pandas.DataFrame.join() 方法：
    • 数据映射 map()方法完成
  • 分组聚合
  • 数据转换
    • Z-Score 标准化
    • Min-Max 标准化
    • 独热编码
    • 数据离散化
  • 数据规约
    • 主成成分分析(Principal Components Analysis)
    • 线性判别分析
    • 皮尔逊相关系数
    • 卡方检验
  • 数据抽样

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

数据的质量评定

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

数据处理步骤

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

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

缺失值的处理

标记缺失值

# 生成包含缺数据的示例
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 标准化 是常用的标准化手段之一，其公式为：

其中，