【机器学习|Python】sklearn中的数据预处理方法_sklearn.impute

前言

本篇文章主要讲解Python的sklearn库中常用的数据预处理方法，主要介绍工具中的内容，即该库中的相关方法包含的常用接口和基本使用，并不适合手把手入门学习，此外将涉及更少的原理和使用情况说明。

• 更多关于本文涉及的数据预处理方法的原理知识：【机器学习】数据预处理方法中的数学原理 (1) - 掘金 (juejin.cn)

sklearn中的数据预处理

• sklearn.preprocessing：sklearn中的数据预处理模块
• sklearn.impute：sklearn中的缺失值填充模块

本文主要涉及的方法：

• 极差归一化：sklearn.preprocessing.MinMaxScaler
• 数据标准化：sklearn.preprocessing.StandardScaler
• 标签编码：sklearn.preprocessing.LabelEncoder
• 特征编码：sklearn.preprocessing.OrdinalEncoder
• 数据二值化：sklearn.preprocessing.Binarizer
• 数据分箱：sklearn.preprocessing.KBinsDiscretizer
• 缺失值处理：sklearn.impute.SimpleImputer

ps：拟合的时候可以传入多个特征数据，sklearn中的方法大多都会自动分别对每一列进行处理，但sklearn一般不支持一维数据导入，至少为二维，若想传入一维数组进行处理可以使用reshape(-1, 1)转为二维数组，若想传入单个Series对象则需要先将其转为DataFrame对象。

数据无量纲化

极差归一化：统一量纲，将某特征下所有的值归一化在指定范围内，默认该范围为 [0,1][0, 1][0,1]，也可以手动确定范围。

常用接口如下：

import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler

data = pd.DataFrame(np.random.randint(10, 100, (5, 2)))  # 准备测试数据

# 常用接口
scaler = MinMaxScaler()  # 默认范围为 [0,1]
scaler = MinMaxScaler(feature_range=[5, 10])  # 自定义归一化数据范围

scaler.fit(data)  # 拟合数据
scaler.partial_fit(data)  # 数据量大的时候fit()报错，可以使用partial_fit()

result = scaler.transform(data)   # 变换数据
result = scaler.fit_transform(data)    # 拟合和变换一步达成
data = scaler.inverse_transform(result)  # 逆向变换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

.partial_fit()：该方法是一种增量学习的方式，可以逐步从流式数据中学习缩放参数，当数据量太大导致 .fit() 接口报错时，可以使用该接口

我们把大批量的数据想象成一个大湖，既然我们无法一次性将这个大湖中的所有水进行处理（学习），但我们可以将其延伸出来一条小河，对顺着小何流动的水（数据流）不断进行处理（学习）。

• 增量学习：是一种可以逐步从新数据中学习的机器学习方法。它不需要重新训练整个模型,而是可迭代地更新模型参数。
• 流式数据：指的是连续不断产生的数据流

Z-score标准化：统一量纲，且变换后的数据服从均值为0方差为1的标准正态分布。

常用接口如下：和MinMaxScaler基本一样

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler

data = pd.DataFrame(np.random.randint(10, 100, (5, 2)))  # 准备测试数据

# 常用接口
scaler = StandardScaler()  # 创建对象

scaler.fit(data)  # 拟合数据
scaler.partial_fit(data)  # 数据量大的时候fit()报错，可以使用partial_fit()

result = scaler.transform(data)  # 变换数据
result = scaler.fit_transform(data)  # 拟合和变换一步达成
data = scaler.inverse_transform(result)  # 逆向变换

# 常用属性
scaler.var_  # 拟合后查看各列数据的方差
scaler.mean_  # 拟合后查看各列数据的均值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

对于 StandardScaler 和 MinMaxScaler 来说，空值NaN会被当做是缺失值，在 fit 的时候忽略，在 transform 的时候保持缺失 NaN 的状态显示。

缺失值处理

SimpleImputer 是sklearn中的简单填充方案，可以填充均值、中位数、众数或特定值

常用参数：

• missing_values：改组数据中的缺失值是什么样的，默认为 np.nan
• strategy：填充策略，默认为'mean'
  • 'mean'：均值填充
  • 'median'：中位数填充
  • 'most_frequent'：众数填充
  • 'constant'：填充固定值，该值在 fill_value参数中设置
• fill_value：在 strategy 参数设置为 'constant' 时，设置填充值
• copy：默认为True，给处理后的数据创建副本并返回，否则在原对象上进行修改

常用接口：

import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer

data = pd.DataFrame(np.random.randint(10, 100, (5, 2)))  # 准备测试数据

# 常用接口
imp_mean = SimpleImputer()  # 均值填充缺失值
imp_median = SimpleImputer(strategy='median')  # 中位数填充缺失值
imp_mode = SimpleImputer(strategy='most_frequent')  # 众数填充
imp_0 = SimpleImputer(strategy='constant', fill_value=0)  # 0填充

imp_mean.fit(data)  # 拟合数据

result = imp_mean.transform(data)  # 变换数据
result = imp_mean.fit_transform(data)  # 拟合和变换一步到位

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

除了使用sklearn中的SimpleImputer进行简单填充，利用pandas也可以直接进行填充：

import pandas as pd
import numpy as np

data = pd.DataFrame(np.random.randint(10, 100, (5, 2)))  # 准备测试数据
data.iloc[0:2, 0:2] = np.nan

# 使用pandas进行缺失值填充
result = data.fillna(0)  # 0填充所有缺失值
# 均值填充第0列,中位数填充、众数填充同理
result = data.iloc[:, 0] = data.iloc[:, 0].fillna(data.iloc[:, 0].mean())  
result = data.dropna(axis=0)  # 删除所有含有缺失值的样本数据

1
2
3
4
5
6
7
8
9
10
11
12

注意：pandas中的.mean()和.median()方法返回对应均值或中位数，但由于众数可能含有多个，取众数.mode()方法返回的是一个Series对象，填充时取其中的任意值即可，一般取索引为0的值。

中位数只可能是一个或者两个，若为两个，则取这两个数的均值，但众数则可能有很多个

编码和哑变量

LabelEncoder和OrdinalEncoder分别用于给标签和特征数据进行编码，主要用于非名义变量。

import pandas as pd
from sklearn.preprocessing import LabelEncoder, OrdinalEncoder, OneHotEncoder

# 准备测试数据
data_dic = {
    '性别': ['男', '女', '女', '男', '女'],
    '学历': ['小学', '初中', '初中', '大学', '高中'],
    '标签': ['标签3', '标签1', '标签2', '标签3', '标签2'],
}

data = pd.DataFrame(data_dic) 

# 常用接口
le = LabelEncoder()  # 创建对象
oe = OrdinalEncoder()

le = le.fit(data.loc[:, '标签'])  # 拟合数据

result = le.transform(data.loc[:, '标签'])  # 变换数据
result = le.fit_transform(data.loc[:, '标签'])  # 拟合和变换一步达成
data = le.inverse_transform(result)  # 逆向变换

data = pd.DataFrame(data_dic)

# 一般这样写
result = LabelEncoder().fit_transform(data.loc[:, '标签']) 
result = OrdinalEncoder().fit_transform(data.loc[:, ['性别', '学历']])

# 常用属性
le.classes_   # 返回原来的字符串标签唯一值数组, 按该数组顺序编号
oe.categories_    # 返回原来的字符串标签数组, 按该数组顺序编号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

OrdinalEcoder和LabelEncoder用法和接口几乎一致，区别在于LabelEncoder可以处理一维数据，且使用.classes_属性来查看标签编号数组，OrdinalEncoder不能处理一维数据，且使用.categories_属性来查看标签编号数组

OneHotEncoder独热编码主要用于名义变量，将特征转换为哑变量。

特征可以转换为哑变量，标签也可以，许多算法可以处理多标签问题，但这样的做法在现实中不常见。

常用参数：

• categories：表示每个特征都有哪些类别，默认为 ‘auto’，一般情况我们都用默认值
  • 'auto'：为自行判断
  • 嵌套列表：列表中里面每个元素都是一个包含特征类别的列表。
• 'handle_unknown'：表示对于未注明特征或类别的处理方式，默认为 'error'
  • 'error'：设置categories后，算法遇到了列表中没有包含的特征或类别时，会报错，
  • 'ignore'：未在 categories 注明的特征或类别的哑变量都会显示0，在逆向变换时未知特征或类别则会显示None

import pandas as pd
from sklearn.preprocessing import OneHotEncoder
# 准备测试数据
data_dic = {
    '性别': ['男', '女', '女', '男', '女'],
    '学历': ['小学', '初中', '初中', '大学', '高中'],
    '标签': ['标签3', '标签1', '标签2', '标签3', '标签2'],
}

data = pd.DataFrame(data_dic) 

# 常用接口
encoder = OneHotEncoder()

encoder.fit(data[['性别']])  # 拟合数据

result = encoder.transform(data[['性别']])  # 变换数据
result = encoder.fit_transform(data[['性别']])  # 拟合和变换一步到位
data = encoder.inverse_transform(result)  # 逆向变换

# 一般这样写
result = OneHotEncoder().fit_transform(data[['性别']])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

注意：OneHotEncoder在transform后返回的是稀疏矩阵，需要使用 .toarray() 方法转为矩阵(二维数组)；inverse_transfrom可以接收稀疏矩阵也可以接收正常的矩阵，返回正常的矩阵。

此外，在经过OneHotEncoder处理后我们需要自行使用pandas将哑变量拼接到原矩阵（pd.concat()）和删除原来的特征（pd.drop()）

连续型特征处理

Binarizer用于将数据二值化，所谓数据二值化，就是设置一个阈值，小于等于该阈值的记为0，大于该阈值的记为1。

常用接口：

import numpy as np
from sklearn.preprocessing import Binarizer

data = np.arange(10, 20).reshape(-1, 1)

bin = Binarizer(threshold=15)  # 默认threshold为0

bin.fit(data)  # 拟合数据

result = bin.transform(data)  # 变换数据
result = bin.fit_transform(data)  # 拟合和变换一步达成

# 一般这样用
result = Binarizer(threshold=15).fit_transform(data)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

KBinsDiscretizer用于将连续型变量划分为分类变量，能够将连续型变量排序后按顺序分箱后编码。

常用参数：

• 'n_bins'：每个特征中分箱的个数，默认为5，
• 'encode'：编码方式，默认为 'onehot'
  • 'onehot'：独热编码为哑变量，返回一个稀疏矩阵
  • 'onehot-dense'：独热编码为哑变量，返回一个密集矩阵 (一般的矩阵)
  • 'ordinal'：每个特征的每箱数据都被编码为一个整数，返回编码后的矩阵
• 'strategy'：定义分箱方式，默认为 'quantile'
  • 'uniform'：等宽分箱，每个特征的每箱数据中的极差不得高于 max(x)−min(x)Nbins\frac{max(x)-min(x)}{N_{bins}}Nbins​max(x)−min(x)​，其中 xxx 表示某特征下的数据，NbinsN_{bins}Nbins​ 表示分箱个数
  • 'quantile'：等位分箱，即每个特征中的每个箱内的样本数量都相同
  • 'kmeans'：按kmeans聚类分箱，每个箱中的值到最近的一维k均值聚类的簇心的距离都相同

常用接口：

import numpy as np
import pandas as pd
from sklearn.preprocessing import KBinsDiscretizer

data = pd.DataFrame(np.random.randint(10, 100, (5, 2)))  # 准备测试数据
est = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='quantile')

est.fit(data)  # 拟合数据

result = est.transform(data)  # 变换数据
result = est.fit_transform(data)  # 拟合和变换一步到位
data = est.inverse_transform(result)  # 

# 一般这样用
result = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='quantile').fit_transform(data)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

需要注意的是，这里的inverse_transform已经无法将数据转为原来的数据，因为在进行分箱离散化时,原始的连续值已经被转换到了分箱区间中，inverse_transform不可能恢复到与原始值完全相同的结果，但是它可以通过区间映射，将分类变量映射回连续值的范围中，从而部分恢复原始数据的连续分布区间，结果并不会每一个值都完全等于原始数据，但整体上逼近了原始数据的分布范围。

不建议使用inverse_transform，因为逆向变换后的数据已经不是原本的数据了。

Reference

• 菜菜的sklearn机器学习
• 相关网络资源和书籍

---------------------------END---------------------------

题外话


感兴趣的小伙伴，赠送全套Python学习资料，包含面试题、简历资料等具体看下方。