sklearn.preprocessing之数据预处理
sklearn.preprocessing 提供了多个数据预处理类和方法，将原始特征向量转换为更适合于下游模型的表示。
-
Standardization 标准化是列处理，对不同样本的同一个属性值进行标准化
-
Normalization 归一化是行处理，对每一个样本的不同的属性值进行归一化
Standardization 标准化
标准化为均值为0，标准差为1的标准正态分布
对训练样本中的每个属性统计计算均值 μ \mu μ和标准差 σ \sigma σ，然后对需要标准化的数据进行处理：
x ∗ = x − μ σ x^{*}=\frac{x-\mu}{\sigma} x∗=σx−μ
from sklearn import preprocessing
import numpy as np
X_train = np.array([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.], [1., 1., -1.]])
scaler = preprocessing.StandardScaler().fit(X_train)
# 对每一列的值，即同一个属性对应的值，求均值和方差
print(scaler)
print("均值:", scaler.mean_)
print("标准差:", scaler.scale_)
X_scaled = scaler.transform(X_train)
print("转换后的数据:", X_scaled)
print("转换后的均值:", X_scaled.mean(axis=0))
print("转换后的标准差:", X_scaled.std(axis=0))
输出：
StandardScaler()
均值: [1. 0.25 0. ]
方差: [0.70710678 0.8291562 1.22474487]
转换后的数据: [[ 0. -1.50755672 1.63299316]
[ 1.41421356 -0.30151134 0. ]
[-1.41421356 0.90453403 -0.81649658]
[ 0. 0.90453403 -0.81649658]]
转换后的均值: [0.00000000e+00 5.55111512e-17 0.00000000e+00]
转换后的标准差: [1. 1. 1.]
用训练集得到的scaler ，通过transform方法来标准化测试集。用inverse_transform 可还原得到原来的数据
# 用训练得到的scaler，来标准化测试集
X_test = np.array([[4., -4., 20.], [8., 10., 10.], [10., 11., -11.]])
X_scaled = scaler.transform(X_test)
print("转换后的数据：\n", X_scaled)
# 还原数据
X_ori = scaler.inverse_transform(X_scaled)
print("还原数据：\n", X_ori)
转换后的数据：
[[ 3.67423461 -4.89897949 15.76841327]
[ 8.5732141 12.24744871 7.75057602]
[11.02270384 13.47219359 -9.08688223]]
还原数据：
[[ 4. -4. 20.]
[ 8. 10. 10.]
[ 10. 11. -11.]]
注意，测试集标准化后并不一定服从标准正态分布，因为先前统计的均值和标准差只是训练集的；而测试集只要保证和原来的训练集做一致的变化即可，下同。
标准化一定的取值范围
以标准化到0-1之间为例，对训练样本中的每个属性统计最大值 max \max max和最小值 min \min min，然后对需要标准化的数据进行处理：
x ∗ = x − min max − min x^{*}=\frac{x-\min }{\max -\min } x∗=max−minx−min
from sklearn import preprocessing
import numpy as np
X_train = np.array([[1., -1., 2.],
[2., 0., 0.],
[0., 1., -1.]])
min_max_scaler = preprocessing.MinMaxScaler()
# fit_transform 将初始化scaler和transform合成一步
X_train_minmax = min_max_scaler.fit_transform(X_train)
print(X_train_minmax)
# 如何计算的，不太懂
print(min_max_scaler.scale_)
输出：
[[0.5 0. 1. ]
[1. 0.5 0.33333333]
[0. 1. 0. ]]
[0.5 0.5 0.33333333]
用训练集得到的scaler ，通过transform方法来标准化测试集。用inverse_transform 可还原得到原来的数据
X_test = np.array([[-3., -1., 4.]])
X_test_minmax = min_max_scaler.transform(X_test)
print(X_test_minmax)
original_X_test = min_max_scaler.inverse_transform(X_test_minmax)
print(original_X_test)
输出：
[[-1.5 0. 1.66666667]]
[[-3. -1. 4.]]
注意，测试集标准化后，范围可能不在[0,1]之间，因为先前统计的最大值和最小值只是训练集的；而测试集只要保证和原来的训练集做一致的变化即可
更通用的，标准化到a，b之间，传入(a,b)作为MinMaxScaler参数，例如:
x ′ = x − min max − min x^{'}=\frac{x-\min }{\max -\min } x′=max−minx−min
x ∗ = x ′ ∗ ( b − a ) + a x^{*}=x^{'}*(b-a) + a x∗=x′∗(b−a)+a
from sklearn import preprocessing
import numpy as np
X_train = np.array([[1., -1., 2.],
[2., 0., 0.],
[0., 1., -1.]])
a = -1
b = 1
min_max_scaler = preprocessing.MinMaxScaler((a, b))
X_train_minmax = min_max_scaler.fit_transform(X_train)
print(X_train_minmax)
#
print(min_max_scaler.scale_)
输出：
[[ 0. -1. 1. ]
[ 1. 0. -0.33333333]
[-1. 1. -1. ]]
[1. 1. 0.66666667]
标准化到[-1,1]为例，使用MaxAbsScaler，对训练样本中的每个属性统计最大值 max \max max，然后对需要标准化的数据进行处理：
x ∗ = x max x^{*}=\frac{x}{\max} x∗=maxx
from sklearn import preprocessing
import numpy as np
X_train = np.array([[1., -1., 2.],
[2., 0., 0.],
[0., 1., -1.]])
max_abs_scaler = preprocessing.MaxAbsScaler()
X_train_maxabs = max_abs_scaler.fit_transform(X_train)
print(X_train_maxabs)
# 每一列的最大值
print(max_abs_scaler.scale_)
输出：
[[ 0.5 -1. 1. ]
[ 1. 0. 0. ]
[ 0. 1. -0.5]]
[2. 1. 2.]
X_test = np.array([[-3., -1., 4.]])
X_test_maxabs = max_abs_scaler.transform(X_test)
print(X_test_maxabs)
输出：
[[-1.5 -1. 2. ]]
注意：用这种方法将数据转到[-1,1]之间与MaxAbsScaler是不一样的
Normalization 归一化
对每个样本进行处理.
每个样本的归一化都只与当前的样本有关，而与其他样本为无关，而Standardization 需要用到不同样本之间某个属性取值
L2
对每个样本 x x x中的第 i i i个特征做如下处理
x i ∗ = x i ( x 1 2 + x 2 2 + x 3 2 + . . . + x n 2 ) 1 2 x_{i}^{*}=\frac{x_i}{(x_1^2 +x_2^2+x_3^2+...+x_n^2)^{\frac{1}{2}}} xi∗=(x12+x22+x32+...+xn2)21xi
from sklearn import preprocessing
import numpy as np
X = [[1., -1., 2.],
[2., 0., 0.],
[0., 1., -1.]]
X_normalized = preprocessing.normalize(X, norm='l2')
print(X_normalized)
输出：
[[ 0.40824829 -0.40824829 0.81649658]
[ 1. 0. 0. ]
[ 0. 0.70710678 -0.70710678]]
L1
对每个样本 x x x中的第 i i i个特征做如下处理
x i ∗ = x i ( ∣ x 1 ∣ + ∣ x 2 ∣ + ∣ x 3 ∣ + . . . + ∣ x n ∣ ) x_{i}^{*}=\frac{x_i}{(|x_1| +|x_2|+|x_3|+...+|x_n|)} xi∗=(∣x1∣+∣x2∣+∣x3∣+...+∣xn∣)xi
from sklearn import preprocessing
import numpy as np
X = [[1., -1., 2.],
[2., 0., 0.],
[0., 1., -1.]]
X_normalized = preprocessing.normalize(X, norm='l1')
print(X_normalized)
输出：
[[ 0.25 -0.25 0.5 ]
[ 1. 0. 0. ]
[ 0. 0.5 -0.5 ]]
max
对每个样本 x x x中的第 i i i个特征做如下处理
x i ∗ = x i m a x ( x 1 , x 2 , x 3 , . . . , x n ) x_{i}^{*}=\frac{x_i}{max(x_1,x_2,x_3,...,x_n)} xi∗=max(x1,x2,x3,...,xn)xi
from sklearn import preprocessing
import numpy as np
X = [[1., -1., 2.],
[2., 0., 0.],
[0., 1., -1.]]
X_normalized = preprocessing.normalize(X, norm='max')
print(X_normalized)
输出：
[[ 0.5 -0.5 1. ]
[ 1. 0. 0. ]
[ 0. 1. -1. ]]
主要内容来自官网