Python下的机器学习工具scikit-learn --数据预处理

sklearn里的predict proba返回值？

返回你测试集中每个测试样例各分类的概率

eg：

#测试样例：
X_test = [
[2,3,4,5]
[3,4,5,6]
]
#假设分类结果为可能为0，1两类
model.predict_proba(X_test)=
array([[0.1,0.9],   #代表[2,3,4,5]被判断为0的概率为0.1，被判断为1的概率为0.9
       [0.8,0.2]])  #代表[3,4,5,6]被判断为0的概率为0.8，被判断为1的概率为0.2

作者：一葛圆木
链接：https://www.zhihu.com/question/55209923/answer/224301812
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

一. 标准化Standardization（这里指移除均值和方差标准化） 
标准化是很多数据分析问题的一个重要步骤，也是很多利用机器学习算法进行数据处理的必要步骤。

1.1 z-score标准化 

z-score标准化指的是将数据转化成均值为0方差为1的高斯分布，也就是通常说的z-score标准化，但是对于不服从标准正态分布的特征，这样做效果会很差。

在实际应用中，我们经常忽视分布的形状，将数据进行z-score标准化。如果不将数据进行标准化处理，在利用机器学习算法（例如SVM）的过程中，如果目标函数中的一个特征的方差的阶数的量级高于其他特征的方差，那么这一特征就会在目标函数中占主导地位，从而“淹没”其他特征的作用。

Python中的scale函数是一种快速进行z-score标准化的方法，能够处理类似于数组结构的数据。Z-score标准化后的数据的均值为0，方差为1。

from sklearn import preprocessing
X=[[1.,-1.,2.],
       [2.,0.,0.],
       [0.,1.,-1.]]
X_scaled = preprocessing.scale(X)
print X_scaled
print X_scaled.mean(axis=0)  #均值为0
print X_scaled.std(axis=0)   #方差为1

结果:

[[ 0.         -1.22474487  1.33630621]
 [ 1.22474487  0.         -0.26726124]
 [-1.22474487  1.22474487 -1.06904497]]
[ 0.  0.  0.]
[ 1.  1.  1.]

2、preprocessing模块还提供了一个实用类StandardScaler，这个类实现了一个叫做Transformer的应用程序接口，能够计算训练数据的均值和标准差，从而在训练数据集上再次使用。

from sklearn import preprocessing
X=[[1.,-1.,2.],
       [2.,0.,0.],
       [0.,1.,-1.]]
scaler = preprocessing.StandardScaler().fit(X)
print scaler
print scaler.mean_ #每列的平均数
print scaler.scale_   #缩放比例
print scaler.transform(X)
scaler = preprocessing.StandardScaler().fit(X)
print scaler
print scaler.transform([[-1., 1., 0.]])  # 在其他数据集上使用

结果：

StandardScaler(copy=True, with_mean=True, with_std=True)
[ 1.          0.          0.33333333]
[ 0.81649658  0.81649658  1.24721913]
[[ 0.         -1.22474487  1.33630621]
 [ 1.22474487  0.         -0.26726124]
 [-1.22474487  1.22474487 -1.06904497]]
StandardScaler(copy=True, with_mean=True, with_std=True)
[[-2.44948974  1.22474487 -0.26726124]]

一般会把train和test集放在一起做标准化，或者在train集上做标准化后，用同样的标准化器去标准化test集，此时可以用scaler

1 2 3

scaler = sklearn.preprocessing.StandardScaler().fit(train) scaler.transform(train) scaler.transform(test)

实际应用中，需要做特征标准化的常见情景：SVM

1.3 将特征数据缩放到一个范围 scale to a range 
利用最大值和最小值进行缩放，通常是将数据缩放到0-1这个范围，或者是将每个特征的绝对值最大值缩放到单位尺度，分别利用MinMaxScaler和MaxAbsScaler实现。 
使用这一方法的情况一般有两种： 
(1) 特征的标准差较小 
(2) 可以使稀疏数据集中的0值继续为0

1）MinMaxScaler   计算方式是特征值减去最小值除以最大值减去最小值 

from sklearn import preprocessing
X=[[1.,-1.,2.],
   [2.,0.,0.],
   [0.,1.,-1.]]
min_max_scaler = preprocessing.MinMaxScaler()
x_scaled_minmax = min_max_scaler.fit_transform(X)
print x_scaled_minmax

#可以查看缩放算子的一些属性:
#这个transformer的实例还能够应用于新的数据集，此时的缩放比例与之前训练集上的缩放比例是相同的。
x_test = np.array([[3., 1., 4.]])
print min_max_scaler.transform(x_test)

print min_max_scaler.scale_  # 缩放比例=1/(max-min)
print min_max_scaler.min_   # (x-min)/(max-min), 这里min_代表min/(max-min)

结果：
[[ 0.5         0.          1.        ]
 [ 1.          0.5         0.33333333]
 [ 0.          1.          0.        ]]
[[ 1.5         1.          1.66666667]]
[ 0.5         0.5         0.33333333]
[ 0.          0.5         0.33333333]

分析：

[1.,-1.,2.]
[2.,0.,0.]
[0.,1.,-1.]

第一列的最大值为2，最小值为0，x_scaled_minmax第一列数据为：

（1-最小值）/(最大值 -最小值) =（1-0）/(2-0）=0.5

（2-最小值）/(最大值 -最小值) =（2-0）/(2-0）=1

（0-最小值）/(最大值 -最小值) =（0-0）/(2-0）=0

同理：min_max_scaler  也是如此，同样的标准化器去标准化 x_test集[3., 1., 4.]
min_max_scaler  这一行数据为： 1.5         1.          1.66666667
第一列的最大值为2，最小值为0，
（3-最小值）/(最大值 -最小值) =（3-0）/(2-0）=1.5
第二列的最大值为1，最小值为-1
（1-最小值）/(最大值 -最小值) =（1- （-1））/(1-（-1））=1
第三列的最大值为2，最小值为-1
（4-最小值）/(最大值 -最小值) =（4-（-1））/(2-（-1））=1.66666667

MaxAbsScaler与上述用法相似，但是标准化后的数据的取值范围为[-1, 1]。这对于稀疏数据或者是数据中心已经为0的数据很有意义。

from sklearn import preprocessing
X=[[1.,-1.,2.],
   [2.,0.,0.],
   [0.,1.,-1.]]
max_abs_scaler = preprocessing.MaxAbsScaler()
print max_abs_scaler.fit_transform(X)
x_test = [[-2., 4., 2.]]
print max_abs_scaler.transform(x_test)
print max_abs_scaler.scale_

结果：
[[ 0.5 -1.   1. ]
 [ 1.   0.   0. ]
 [ 0.   1.  -0.5]]
[[-1.  4.  1.]]
[ 2.  1.  2.]

二、标签预处理（Label preprocessing）
1、标签二值化（Label binarization）
LabelBinarizer通常用于通过一个多类标签（label）列表，创建一个label指示器矩阵？？？有什么用？

from sklearn import preprocessing
lb = preprocessing.LabelBinarizer()
print lb.fit([1, 2, 6, 4, 2])
print lb.classes_
print lb.transform([1, 6])# 不明白

结果：
LabelBinarizer(neg_label=0, pos_label=1, sparse_output=False)
[1 2 4 6]
[[1 0 0 0]
 [0 0 0 1]]

2、上例中每个实例中只有一个标签（label），LabelBinarizer也支持每个实例数据显示多个标签：
1）、标签编码（Label encoding）

from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
le.fit([1, 2, 2, 6]) #编码
print le.classes_
print le.transform([1, 1, 2, 6])
print le.inverse_transform([0, 0, 1, 2])

结果：
[1 2 6]
[0 0 1 2]
[1 1 2 6]
2）也可以用于非数值类型的标签到数值类型标签的转化：

le.fit(["paris", "paris", "tokyo", "amsterdam"])
print le.classes_                                        #['amsterdam' 'paris' 'tokyo']
print list(le.classes_)  #去掉重复的值，并按从小到大排序  ['amsterdam', 'paris', 'tokyo']
print le.transform(["tokyo", "tokyo", "paris"])  #[2 2 1]
print list(le.inverse_transform([2, 2, 1]))  #['tokyo', 'tokyo', 'paris']

结果：
['amsterdam' 'paris' 'tokyo']
['amsterdam', 'paris', 'tokyo']
[2 2 1]
['tokyo', 'tokyo', 'paris']