sklearn-数据预处理

数据预处理

---

---

概要

sklearn是一个比较常用的机器学习库，其中的sklearn.preprocessing包含了常用的预处理函数，一般在kaggle等数据竞赛网站拿到数据的时候，首先要观察数据特征，分布等信息，然后进行数据预处理。数据预处理有利于计算机进行计算。

---

原始数据存在的问题：
1. 存在缺失值
2. 存在异常点及噪声
3. 各个特征的取值范围比例不一
4. 数据表现形式不一
5. 维度过高，部分特征间线性相关

---

Z-score标准化

Z-score标准化就是将数据变化为服从均值为0，方差为1的正太分布，对于不知道数据最大最小值的时候适用，但是会改变数据的分布。

$$x' = \frac{x - \mu}{s}， 其中\mu为均值，s为标准差$$

from sklearn import preprocessing
import numpy as np

x = np.array([[1., 0., 2.],
              [0., -2., 1.],
              [-1., 1., 0.]])

#第一种方法
x_scale_1 = preprocessing.scale(x)
'''
[[ 1.22474487  0.26726124  1.22474487]
 [ 0.         -1.33630621  0.        ]
 [-1.22474487  1.06904497 -1.22474487]]
 '''

#第二种方法
scaler = preprocessing.StandardScaler()
x_scale_2 = scaler.fit_transform(x)
'''
[[ 1.22474487  0.26726124  1.22474487]
 [ 0.         -1.33630621  0.        ]
 [-1.22474487  1.06904497 -1.22474487]]
 '''

StandardScaler(copy=True, with_mean=True, with_std=True)
with_mean=False #不减去均值
with_std=False  #不除以标准差

红色为随机数据，蓝色为Z-score标准化后数据

---

MinMax标准化

MinMax标准化适用于知道最大值和最小值的数据，标准化后的数据将会落在$[0, 1]$区间内，如果有异常值则会将数据分布不均匀，向异常值的另一侧堆积。

$$x' = \frac{x - min}{max - min}，其中min为最小值，max为最大值$$

scaler = preprocessing.MinMaxScaler()
x_scaled = scaler.fit_transform(x)
'''
before
[[ 1.  0.  2.]
 [ 0. -2.  1.]
 [-1.  1.  0.]]
 after
[[ 1.          0.66666667  1.        ]
 [ 0.5         0.          0.5       ]
 [ 0.          1.          0.        ]]
'''

红色为随机数据，蓝色为MinMax标准化后数据

异常点出现

---

MaxAbs标准化

MaxAbs标准化根据最大值的绝对值进行标准化，标准化后的数据将会落在$[-1,1]$区间内

$$x' = \frac{x}{abs(max)}，其中abs为绝对值，max为最大值$$

scaler = preprocessing.MaxAbsScaler()
x_scaled = scaler.fit_transform(x)
'''
before
[[ 1.  0.  2.]
 [ 0. -2.  1.]
 [-1.  1.  0.]]
 after
[[ 1.   0.   1. ]
 [ 0.  -1.   0.5]
 [-1.   0.5  0. ]]
'''

红色为随机数据，蓝色为MaxAbs标准化后数据

中心化数据会破坏原有稀疏数据的结构

---

正则化

正则化数据和之前的标准化数据不同，之前标准化数据是针对特征来说的，而现在正则化是对样本来做的，是用样本数据除以他的范式

$$x = <x_1, x_2,...,x_n> \\ Lp(x) = \sqrt[p]{\sum^{n}_{i = 0}|x_i|^p} \\ x_i' = \frac{x_i'}{L_p(x)}，通常p为1或者2$$

x_scaled = preprocessing.normalize(x, norm = 'l1')
#norm = 'l1' or 'l2'
#或者使用
normalizer = preprocessing.Normalizer()#l2正则化
normalizer.fit(x)#这个fit函数没有任何作用
x = normalizer.transform(x)
'''
before
[[ 1.  0.  2.]
 [ 0. -2.  1.]
 [-1.  1.  0.]]
after
[[ 0.33333333  0.          0.66666667]
 [ 0.         -0.66666667  0.33333333]
 [-0.5         0.5         0.        ]]
 '''

红色为随机数据点，蓝色为l1正则化后数据点

红色为随机数据点，蓝色为l2正则化后数据点

---

阈值划分

连续特征值可以根据阈值划分进行二值化，大于阈值的值为1，否则为0

$$f(x) = \left\{ \begin{aligned} 1 & , & x > threshold\\ 0 & , & else \\ \end{aligned} \right.$$

scaler = preprocessing.Binarizer(threshold=0.5)#threshold为阈值
x_scaled = scaler.fit_transform(x)

'''
before
[[ 1.  0.  2.]
 [ 0. -2.  1.]
 [-1.  1.  0.]]
after
[[ 1.  0.  1.]
 [ 0.  0.  1.]
 [ 0.  1.  0.]]
'''

---

离散变量编码

例如性别有‘男’， ‘女’，然而计算机的许多模型都只能在数值型数据当中进行计算，如果我们简单的将‘男’为1，‘女’为0，虽然也可以完成转换，但是在转换的过程当中我们引入了大小关系，就是‘女’ < ‘男’，这会对后续模型应用造成不必要的困扰。
解决方法为OneHotEncode，就是将其转化为二进制串，除了当前值所在位置为1，其他全部为0，如[0,0,1,0,0], [0,1,0,0,0].。性别可表示为男为[1,0]，女为[0,1]，这样一个性别特征就转化成了两个特征。

df = pd.DataFrame({'pet': ['cat', 'dog', 'dog', 'fish'],'age': [4 , 6, 3, 3],
'salary':[4, 5, 1, 1]})
#例如有数据比较大，OneHotEncoder会生成非常多的特征，或者为字符串数据，先转化为数字，所以先用LabelEncoder处理。
label = preprocessing.LabelEncoder()
df['pet'] = label.fit_transform(df['pet'])
one_hot = preprocessing.OneHotEncoder(sparse = False)
print one_hot.fit_transform(df[['pet']])
'''
before
   age  pet  salary
0    4    0       4
1    6    1       5
2    3    1       1
3    3    2       1
after
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]
'''

---

缺失值处理

由于数据收集的过程，部分样本的属性值有缺失，在处理这部分值的时候可以人工根据经验补充，或者使用均值，出现频率较高的值，中值补充。

imp = Imputer(missing_values=0, strategy='mean', axis=0)
#strategy = 'mean', 'median', 'most_frequent'
x = imp.fit_transform(x)

维度拓展

我们可以考虑复杂化非线性特征，就是生成多项式特征，例如$(x_1, x_2) -> (x_1, x_2, x_1^2, x_1x_2, x_2^2)$，会使特征数量增加

poly = PolynomialFeatures(2)#参数为阶数
poly.fit_transform(X) 
'''
before 
[[0, 1],
 [2, 3],
 [4, 5]]
after
[[  1.,   0.,   1.,   0.,   0.,   1.],
 [  1.,   2.,   3.,   4.,   6.,   9.],
 [  1.,   4.,   5.,  16.,  20.,  25.]]

自定义变换规则

sklearn 还可以提供自定义变换函数，用户只需要提供相应操作，然后用FunctionTransformer包装就可以了。

transformer = FunctionTransformer(np.log1p)
#np.log1p(x) = np.log(1 + x)
X = np.array([[0, 1], [2, 3]])
transformer.transform(X)
'''
array([[ 0.        ,  0.69314718],
       [ 1.09861229,  1.38629436]])
'''