sklearn.preprocessing归一化标准化等

目录

sklearn.preprocessing

1. StandardScaler，标准化，也叫z-score规范化
2. 最小-最大规范化
3. 正则化（normalize）
4. one-hot编码
5. 特征二值化
6. 标签编码（Label encoding）

 

sklearn.preprocessing

属于数据预处理阶段，经过一定缩放，标准化等处理使得数据能被模型识别

sklearn.preprocessing 有多个缩放器（Scaler）：

• StandardScaler
• MinMaxScaler
• RobustScaler
• Normalizer

还有可以直接使用的函数：scale()，maxabs_scale()，minmax_scale()，robust_scale()，normaizer（）

1.StandardScaler，标准化，也叫z-score规范化

                z = (x - u) / s

其中u是训练样本或者特征的均值，s是训练样本或者特征的标准偏差，z是标准化之后的值

这个方法被广泛使用在支持向量机，逻辑回归神经网络等

StandardScaler有fit，fit_transform，transform等方法

fit：用于计算训练数据的均值和方差

fit_transform：不仅计算训练数据的值和方差，还会基于计算出来的均值方差来转换训练数据，将数据转为标准正态分布

transform：只进行转换，把数据转换成标准正态分布

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

from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import pandas as pd 
import numpy as np
iris=load_iris()
df=pd.DataFrame(iris.data,columns=iris.feature_names)
df['sample']=iris.target
train_x=df.iloc[:,:4]
train_y=df.iloc[:,-1]

x_train,x_test,y_train,y_test=train_test_split(train_x,train_y,test_size=0.3,random_state=0)

#一般这样使用,其中fit_transform可以代替fit位置
scaler=preprocessing.StandardScaler().fit(x_train)
scaler.transform(x_train)
scaler.transform(x_test)

 其中计算原理，标准化之后的值如下：

#(x-均值)/标准差
 (x_train.values[:,0]- x_train.values[:,0].mean())/ x_train.values[:,0].std()

 

2.最小-最大规范化

使用这个缩放的情况包括：增强极小方差的值还有保留稀疏样本中的零值。也叫作最大最小标准化，[0,1]标准化

对原始数据的线性变换，使得结果落在[ 0,1 ]区间，

      z=(x-min)/(max-min)

这种方法有一个缺陷就是当有新数据加入时，可能导致max和min的变化，需要重新定义

#feature_range: 定义归一化范围，注用（）括起来
scaler = preprocessing.MinMaxScaler(feature_range=(0, 1)).fit(train_data)
scaler.transform(train_data)
scaler.transform(test_data)

还有一个例子：

import numpy as np
from sklearn import preprocessing

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

min_max_sacler = preprocessing.MinMaxScaler()
min_max_sacler.fit(X_train)

print(min_max_sacler.transform(X_train))

'''
[[0.5        0.         1.        ]
 [1.         0.5        0.33333333]
 [0.         1.         0.        ]]
'''

 

3.正则化（normalize）

首先求出样本的p范数，然后该样本的所有元素都要除以该范数，这样最终使得每个样本的范数都是1。

规范化（Normalization）是将不同变化范围的值映射到相同的固定范围，常见的是[0,1]，也成为归一化

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

sklearn.preprocessing.Normalizer(norm=’l2’, copy=True)

norm：可以为l1、l2或max，默认为l2

• 若为l1时，每个样本（每行）的值除以每个样本（每行）各值的绝对值之和
• 若为l2时，变换后每个样本（每行）的各维特征的平方和为1
• 若为max时，样本各个特征值除以样本中特征值最大的值

也有这样的说法：

需要说明是，这里的归一化不是对一列的特征进行操作，而是对一行的样本（记录）进行操作。归一化适用于这样的场景：需要使用点积，或者有的模型需要对样本的相似性进行度量。

preprocessing中的normalize方法提供了这样的操作，这个方法有个参数叫做norm，取值可以为 ‘l1’,’l2’,’max’，取不同的值，使用不同的方式进行归一化。

当取值为’l1‘的时候，运用l1范数进行归一化，计算的方法是 ：

 

 运用l2范数进行归一化的时候，计算方法是这样的：

 

 

preproceing 的Normalizer也提供了标准化的方法，可以进行fit和transform操作,而preprocessing.normalize()函数不可以

from sklearn import preprocessing
X = [[ 1., -1., 2.], [ 2., 0., 0.],[ 0., 1., -1.]]

#1、可以使用preprocessing.normalize()函数对指定数据进行转换：
 preprocessing.normalize(X, norm='l2')
 '''
 array([[ 0.40824829, -0.40824829,  0.81649658],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.        ,  0.70710678, -0.70710678]])
'''

 preprocessing.normalize(X, norm='l1')
 '''
 array([[ 0.25, -0.25,  0.5 ],
       [ 1.  ,  0.  ,  0.  ],
       [ 0.  ,  0.5 , -0.5 ]])
 '''
 preprocessing.normalize(X, norm='max')
 '''
 array([[ 0.5, -0.5,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -1. ]])
'''
 
 

#2、可以使用processing.Normalizer()类实现对训练集和测试集的拟合和转换：
normalizer = preprocessing.Normalizer().fit(X)#fit does nothing
normalizer  #Normalizer(copy=True, norm='l2') 
normalizer.transform(X)  
normalizer.transform([[-1.,  1., 0.]])   # array([[-0.70...,  0.70...,  0.  ...]])

norm不同算法：

#norm='l2',
X = [[ 1., -1., 2.], [ 2., 0., 0.],[ 0., 1., -1.]]
X=np.array(X)
X/np.sqrt(np.sum(X*X,axis=1))

#norm='l1'
X = [[ 1., -1., 2.], [ 2., 0., 0.],[ 0., 1., -1.]]
X=np.array(X)
X/np.sum(abs(X),axis=1)

#norm='max'
X = [[ 1., -1., 2.], [ 2., 0., 0.],[ 0., 1., -1.]]
X=np.array(X)
X/np.max(X,axis=0)

 

4.one-hot编码

one-hot编码是一种对离散特征值的编码方式，在LR模型中常用到，用于给线性模型增加非线性能力

就是看看每个特征有多少个唯一值n，然后组成n列，按照顺序排唯一值，如果轮到该值，则1，其余是0 

from sklearn import preprocessing
data = [[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]]
encoder = preprocessing.OneHotEncoder().fit(data)
encoder.transform(data).toarray()
#输出
array([[1., 0., 1., 0., 0., 0., 0., 0., 1.],
       [0., 1., 0., 1., 0., 1., 0., 0., 0.],
       [1., 0., 0., 0., 1., 0., 1., 0., 0.],
       [0., 1., 1., 0., 0., 0., 0., 1., 0.]])

 

5.特征二值化

Binarizer类和binarize方法根据指定的阈值将特征二值化，小于等于阈值的，将特征值赋予0，大于特征值的赋予1，其阈值threshold默认都为0

sklearn.preprocessing.binarize(X, threshold=0.0, copy=True)

binarizer = sklearn.preprocessing.Binarizer(threshold=1.1)
binarizer.transform(X)

 

6.标签编码（Label encoding）

sklearn.preprocessing.LabelEncoder()：标准化标签，将标签值统一转换成range(标签值个数-1)范围内

from sklearn import preprocessing
le = preprocessing.LabelEncoder()
le.fit([1,2,2,6,3])


#获取标签值
le.classes_   #array([1, 2, 3, 6])

#将标签标准化
le.transform([1, 1, 2, 6])  #array([0, 0, 1, 2])

#将标准化的标签值反转
le.inverse_transform([0, 0, 2, 3, 1])  #array([1, 1, 3, 6, 2])

#非数值型转化为数值型
le.fit(["paris", "paris", "tokyo", "amsterdam"])
le.transform(["tokyo", "tokyo", "paris"])  #array([2, 2, 1])