数据处理与转换

Posted 2020-12-29 jin-liang

目录

一.归一化

　　1.1 最小最大值标准化（MinMaxScaler）

　　1.2绝对值最大标准化（ MaxAbsScaler）

二.标准化

　　2.1 零均值单位方差（scale）

　　2.2 训练数据的均值方差（StandardScaler）

三.正则化（Normalization）

　　3.1  L1、L2正则化

四.其他方法

　　4.1 特征二值化

　　4.2 自定义转换

---

 

一.归一化

　　1.1 最小最大值标准化（MinMaxScaler）

将属性缩放到一个指定的最大和最小值（通常是0-1）之间，常用的最小最大规范化方法(x-min(x))/(max(x)-min(x))，这可以通过preprocessing.MinMaxScaler类实现。

使用这种方法的目的包括：

1、对于方差非常小的属性可以增强其稳定性。

2、维持稀疏矩阵中为0的条目,即保留数据中的0元素

import numpy as np
from sklearn import preprocessing 

X_train = np.array([[ 1., -1., 2.],
     [ 2., 0., 0.],
    [ 0., 1., -1.]])
min_max_scaler = preprocessing.MinMaxScaler()
X_train_minmax = min_max_scaler.fit_transform(X_train)
X_train_minmax 
[out]array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

#缩放因子等属性
min_max_scaler.scale_
[out]array([0.5       , 0.5       , 0.33333333])

min_max_scaler.min_
[out]array([0.        , 0.5       , 0.33333333])

 

　　1.2绝对值最大标准化（ MaxAbsScaler）

与上述标准化方法相似，但是它通过除以最大值将训练集缩放至[-1,1]。应用于数据以０为中心或者是含有非常非常多０的稀疏数据。

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)
X_train_maxabs 
[out]array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])

二.标准化

数据的标准化是将数据按比例缩放，使之落入一个小的特定区间，标准化后的数据可正可负，但是一般绝对值不会太大。一般是 z-score规范化方法：(x-mean(x))/std(x)

实现时，有两种不同的方式：

　　2.1 零均值单位方差（scale）

使用sklearn.preprocessing.scale()函数，可以直接将给定数据进行标准化。

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

X_scaled = preprocessing.scale(X) 
X_scaled
[out]array([[ 0.        , -1.22474487,  1.33630621],
       [ 1.22474487,  0.        , -0.26726124],
       [-1.22474487,  1.22474487, -1.06904497]])

#scaled之后的数据零均值，单位方差
X_scaled.mean(axis=0)
[out]array([0., 0., 0.])

X_scaled.std(axis=0)
[out]array([1., 1., 1.])

　　

　　2.2 训练数据的均值方差（StandardScaler）

使用sklearn.preprocessing.StandardScaler类，使用该类的好处在于可以保存训练集中的参数（均值、方差）直接使用其对象转换测试集数据。

scaler = preprocessing.StandardScaler().fit(X)
scaler
[out]StandardScaler(copy=True, with_mean=True, with_std=True)

#均值
scaler.mean_  
[out]array([1.        , 0.        , 0.33333333])

#方差
scaler.var_ 
[out]array([0.66666667, 0.66666667, 1.55555556])

#数据转换
scaler.transform(X)  
[out]array([[ 0.        , -1.22474487,  1.33630621],
       [ 1.22474487,  0.        , -0.26726124],
       [-1.22474487,  1.22474487, -1.06904497]])

注：1.若设置with_mean=False 或者 with_std=False，则不做centering 或者scaling处理。

 　　2.scale和StandardScaler可以用于回归模型中的目标值处理。

三.正则化

　　3.1  L1、L2正则化（Normalization）

正则化的过程是将每个样本缩放到单位范数（每个样本的范数为1），如果后面要使用如二次型（点积）或者其它核方法计算两个样本之间的相似性这个方法会很有用。

Normalization主要思想是对每个样本计算其p-范数，然后对该样本中每个元素除以该范数，这样处理的结果是使得每个处理后样本的p-范数（L1-norm,L2-norm）等于1。

             p-范数的计算公式：||X||p=(|x1|^p+|x2|^p+...+|xn|^p)^1/p

该方法主要应用于文本分类和聚类中。

可以使用preprocessing.normalize()函数对指定数据进行转换：

X = [[ 1., -1.,  2.],
     [ 2.,  0.,  0.],
    [ 0.,  1., -1.]]
X_normalized = preprocessing.normalize(X, norm=‘l2‘)
 
X_normalized  
[out]array([[ 0.40824829, -0.40824829,  0.81649658],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.        ,  0.70710678, -0.70710678]])

可以使用processing.Normalizer()类实现对训练集和测试集的拟合和转换：

normalizer = preprocessing.Normalizer().fit(X)  # fit does nothing
normalizer
[out]Normalizer(copy=True, norm=‘l2‘)
 
normalizer.transform(X)                            
[out]array([[ 0.40..., -0.40...,  0.81...],
       [ 1.  ...,  0.  ...,  0.  ...],
       [ 0.  ...,  0.70..., -0.70...]])
 
normalizer.transform([[-1.,  1., 0.]])             
[out]array([[-0.70...,  0.70...,  0.  ...]])

 

 

 

四.其他方法

　　4.1 特征二值化

特征二值化是把数值特征转化成布尔值的过程。这个方法对符合多变量伯努利分布的输入数据进行预测概率参数很有效。详细可以见这个例子sklearn.neural_network.BernoulliRBM.

#data
X = [[ 1., -1.,  2.],
         [ 2.,  0.,  0.],
         [ 0.,  1., -1.]]

#binary
binarizer = preprocessing.Binarizer().fit(X)  # fit does nothing
binarizer
[out]Binarizer(copy=True, threshold=0.0)

#transform
binarizer.transform(X)
[out]array([[ 1.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  1.,  0.]])     

# 调整阈值
binarizer = preprocessing.Binarizer(threshold=1.1)
binarizer.transform(X)
[out]array([[ 0.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  0.,  0.]])

 

　

　　4.2 自定义转换

如果以上的方法觉得都不够，譬如你想用对数据取对数，可以自己用 FunctionTransformer自定义一个转化器,并且可以在Pipeline中使用

from sklearn.preprocessing import FunctionTransformer

transformer = FunctionTransformer(np.log1p)#括号内的就是自定义函数
X = np.array([[0, 1], [2, 3]])
transformer.transform(X)
[out]array([[0.        , 0.69314718],
       [1.09861229, 1.38629436]])

 

参考：

https://www.cnblogs.com/charlotte77/p/5622325.html

https://www.cnblogs.com/zhanglianbo/p/5690974.html