sklearn学习笔记 lesson1_Preprocessing

查看sklearn.preprocessing中的模块或者方法：

整体上，数据的预处理表现在两个方面：

（1）：是对数据集上的X进行数据转换处理；

（2）：是对数据集上Y进行标签处理；

（3）：对缺失值的处理

from ._function_transformer import FunctionTransformer

#（1）：是对数据集上的X数值型进行数据转换处理；

from .data import Binarizer

from .data import KernelCenterer

from .data import MinMaxScaler

from .data import MaxAbsScaler

from .data import Normalizer

from .data import RobustScaler

from .data import StandardScaler

from .data import add_dummy_feature

from .data import binarize

from .data import normalize

from .data import scale

from .data import robust_scale

from .data import maxabs_scale

from .data import minmax_scale

from .data import OneHotEncoder

from .data import PolynomialFeatures

#（2）：是对数据集上x离散型进行标签处理---转换哑变量

from .label import label_binarize

from .label import LabelBinarizer

from .label import LabelEncoder

from .label import MultiLabelBinarizer

#（3）：对缺失值的处理

from .imputation import Imputer

一、对数据中数值型数据进行处理

• 标准化（Z-Score），或者去除均值和方差缩放

公式为：(X-mean)/std  计算时对每个属性/每列分别进行。

将数据按期属性（按列进行）减去其均值，并处以其方差。得到的结果是，对于每个属性/每列来说所有数据都聚集在0附近，方差为1。

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

(1) sklearn.processing.scale() #函数的形式

from sklearn import preprocessing

import numpy as np

X = np.random.randn(12).reshape(3,4)

print(preprocessing.scale(X))

(2) sklearn.preprocessing.StandardScaler #类的形式

#先训练模型，保存训练集中的参数（均值、方差），然后实例化（对数据集进行transform(x)）

scaler = preprocessing.StandardScaler().fit(X) #得到实例化后的模型

print(scaler.transform(X)) #转换后的结果

print(scaler.std_) #查看实例的标准差，以此类推，mean_;

• 将属性缩放到一个指定范围

公式为：(X-mix)/(max-min) 

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

将属性缩放到一个指定的最大和最小值（通常是1-0）之间

（1）preprocessing.MinMaxScaler类：

可以先实例化再转换；或者是先定义类后再拟合转换

#1-----可以保留模型结果，用户测试集数据转换

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

              [ 2.,  0.,  0.],

              [ 0.,  1., -1.]])

min_max_scaler = preprocessing.MinMaxScaler().fit(X) #训练集

print(min_max_scaler.transform(X))

X_test = np.array([[ -3., -1.,  4.]])

X_test_minmax = min_max_scaler.transform(X_test) #测试集

print(X_test_minmax)

#[-1.5         0.          1.66666667]

#2 -----定义类，得到方法，不会保留模型结果，用户对不同的数据集进行拟合和数据转换

min_max_scaler2 = preprocessing.MinMaxScaler()  

min_max = min_max_scaler2.fit_transform(X)

print(min_max)

• 正则化（Normalization）

正则化的过程是将每个样本缩放到单位范数（每个样本的范数为1）

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

该方法主要应用于文本分类和聚类中。例如，对于两个TF-IDF向量的l2-norm进行点积，就可以得到这两个向量的余弦相似性。

（l1）1-范数：║x║1=│x1│+│x2│+…+│xn│

（l2）2-范数：║x║2=（│x1│2+│x2│2+…+│xn│2）1/2

#1-----可以保留模型结果，用户测试集数据转换

normalizer = preprocessing.Normalizer().fit(X)

print(normalizer) #模型的参数输出

print(normalizer.transform(X)) #训练集的数据转换

X_test = np.array([[ -3., -1.,  4.]])

print(normalizer.transform(X_test)) #测试集的数据转换

#2-----定义类，得到方法，不会保留模型结果，用户对不同的数据集进行拟合和数据转换

x_normalized = preprocessing.normalize(X, norm='l2')

print(x_normalized)

• 特征二值化（Binarization）

二值化过程：即给定阈值，将特征转换为0/1

#1-----可以保留模型结果，用户测试集数据转换

X = np.random.randn(12).reshape(3,4)

binarizer = preprocessing.Binarizer(threshold=1.1).fit(X)   #threshold默认为0

print(binarizer.transform(X))

X_test = np.array([[ -3., -1.,  0.9, 1.4]])

print(binarizer.transform(X_test)) #测试集的数据转换

#2-----定义类，得到方法，不会保留模型结果，用户对不同的数据集进行拟合和数据转换

binarizer1 = preprocessing.Binarizer(threshold=1.1)

print(binarizer1.transform(X))

print(binarizer1.transform(X_test))

二、对标签类数据进行转化（哑变量）

• MultiLabelBinarizer 对不同的标签转换为哑变量

#1-----可以保留模型结果，用户测试集数据转换

mlb = preprocessing.MultiLabelBinarizer()

mlb_fit = mlb.fit([set(['sci-fi', 'thriller']), set(['comedy'])]) #拟合模型而已

print(mlb_fit.classes_) #输出模型的类别标签

x_test = ['a','b','c','c','a']

mlb = preprocessing.MultiLabelBinarizer()

mlb_fit = mlb.fit(x_test)

print(mlb_fit.transform(x_test))

#2-----用户对不同的数据集进行拟合和数据转换

mlb_transform = mlb.fit_transform([set(['sci-fi', 'thriller']), set(['comedy'])])

print(mlb_transform) #编码后的数据

#备注：打印不了模型标签，难道是模型本身没有被保存下来？

• LableBinarizer()

#1

lb = preprocessing.LabelBinarizer()

lb_fit = lb.fit([1,2,4,4])

print(lb_fit.transform([1,4]))

print(lb_fit.classes_)

#[[1 0 0]

# [0 0 1]]

#2

lb1 = preprocessing.LabelBinarizer()

lb1.fit_transform(['yes', 'no', 'no', 'yes'])

三、对缺失值进行处理

由于不同的原因，许多现实中的数据集都包含有缺失值，要么是空白的，要么使用NaNs或者其它的符号替代。这些数据无法直接使用scikit-learn分类器直接训练，所以需要进行处理。幸运地是，sklearn中的Imputer类提供了一些基本的方法来处理缺失值，如使用均值、中位值或者缺失值所在列中频繁出现的值来替换。

• Imputer类

#missing_values为integer（整型） or "NaN"

#strategy == "most_frequent"/'mean'/ "median"/

# axis=0, then impute along columns；else  axis=1 rows

import numpy as np

from sklearn.preprocessing import Imputer

imp = Imputer(missing_values = 'NaN',strategy='mean',axis=0)

x = [[1,2],[np.nan,23],[3,4]]

imp_fit = imp.fit(x)

print(imp_fit.transform(x))

imp1 = Imputer(missing_values = 0,strategy='mean',axis=0)

x1 = [[1,2],[0,23],[3,4]]

imp1_fit = imp1.fit(x1)

print(imp1_fit.transform(x1))

参考文献：http://scikit-learn.org/stable/modules/preprocessing.html#imputation-of-missing-values