sklearn-数据预处理-特征变换

标准化

z-score标准化

经过去均值来对某个特征进行中心化，再通过除以非常量特征(non-constant features)的标准差进行缩放。

class preprocessing.StandardScaler(copy=True, with_mean=True, with_std=True)：标准正态分布化的类属性：scale_：ndarray，缩放比例mean_：ndarray，均值var_：ndarray，方差n_samples_seen_：int，已处理的样本个数，调用partial_fit()时会累加，调用fit()会重设

preprocessing.robust_scale(X, axis=0, with_centering=True, with_scaling=True, copy=True)：
通过 Interquartile Range (IQR) 标准化数据，即四分之一和四分之三分位点之间
属性：
center_：ndarray，中心点
scale_：ndarray，缩放比例
preprocessing.scale(X, axis=0, with_mean=True, with_std=True, copy=True)：
将数据转化为标准正态分布（均值为0，方差为1）
class preprocessing.KernelCenterer：
生成 kernel 矩阵，用于将 svm kernel 的数据标准化（参考资料不全）
class preprocessing.MaxAbsScaler(copy=True)：
数据的缩放比例为绝对值最大值，并保留正负号，即在区间 [-1.0, 1.0] 内。可以用于稀疏数据 scipy.sparse
属性：
scale_：ndarray，缩放比例
max_abs_：ndarray，绝对值最大值
n_samples_seen_：int，已处理的样本个数

from sklearn.preprocessing import StandardScaler #z-score标准化:特征值减去均值，除以标准 scaler = sklearn.preprocessing.StandardScaler().fit(train) scaler.transform(train) scaler.transform(test)

最小-最大规范化 特征缩放至特定范围

axis=0轴按列 np.sum(x,axis=0) ((X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0)))* (max - min) + min (x-x最小/x最大-x最小)*(规约的最大-规约的最小)+规约的最小
class preprocessing.MinMaxScaler(feature_range=(0, 1), copy=True)：
将数据在缩放在固定区间的类，默认缩放到区间 [0, 1]
属性：
min_：ndarray，缩放后的最小值偏移量
scale_：ndarray，缩放比例
data_min_：ndarray，数据最小值
data_max_：ndarray，数据最大值
data_range_：ndarray，数据最大最小范围的长度

from sklearn.preprocessing import MinMaxScalermin_max_scaler = MinMaxScaler()min_max_scaler.fit_transform(x)

将训练数据特征缩放至 [-1, 1]、稀疏数据缩放

适合稀疏数据缩放

max_abs_scaler = preprocessing.MaxAbsScaler()X_train_maxabs = max_abs_scaler.fit_transform(X_train)

含异常值数据缩放

robust_scale，它们使用更加鲁棒的中心和范围估计来缩放你的数据

数据归一化/规范化（Normalization）

规范化是使单个样本具有单位范数的缩放操作。
经常在文本分类和聚类当中使用。
规范化（Normalization）规范化是将不同变化范围的值映射到相同的固定范围，常见的是[0,1]，此时也称为归一化,默认L2规范 变换后每个样本的各维特征的平方和为1 0.4^2+0.4^2+0.81^2=1 L1 norm则是变换后每个样本的各维特征的绝对值和为1。还有max norm，则是将每个样本的各维特征除以该样本各维特征的最大值
preprocessing.normalize(X, norm=’l2’, axis=1, copy=True)：
将数据归一化到区间 [0, 1]，norm 可取值 ‘l1’、’l2’、’max’。可用于稀疏数据 scipy.sparse

 import sklearn X = [[ 1, -1, 2],[ 2, 0, 0], [ 0, 1, -1]] sklearn.preprocessing.normalize(X, norm='l2') array([[ 0.40, -0.40, 0.81], [ 1, 0, 0], [ 0, 0.70, -0.70]])

normalizer = preprocessing.Normalizer().fit(X)  # fit函数没有任何效果normalizer.transform(X)    

数值特征二值化（Binarization）

是将数值型特征变成布尔型特征.
将数据转化为 0 和 1，其中小于等于 threshold 为 0，可用于稀疏数据 scipy.sparse
大于阈值为1 小于阈值为0

 X = [1,2,0.5,0.1,4,5] binarizer = sklearn.preprocessing.Binarizer(threshold=2.1) binarizer.transform(X)

#threshold二值器的阈值binarizer = preprocessing.Binarizer(threshold=1.1)binarizer.transform(X)

类别数据编码 OneHot 编码

eg:A样本在3个纬度下分别属于1,0,2的类别 转换成独热编码 [ 1. 1. 1.]
class preprocessing.OneHotEncoder(n_values=’auto’, categorical_features=’all’, dtype=’float’, sparse=True, handle_unknown=’error’)：
将具有多个类别的特征转换为多维二元特征，所有二元特征互斥，当某个二元特征为 1 时，表示取某个类别
参数：
n_values：处理的类别个数，可以为‘auto’，int 或者 int数组
categorical_features：被当作类别来处理的特征，可以为“all”或者下标数组指定或者mask数组指定
属性：
active_features_：ndarray，实际处理的类别数
feature_indices_：ndarray，第 i 个原特征在转换后的特征中的下标在 feature_indices_[i] 和 feature_indices_[i+1] 之间
n_values_：ndarray，每维的类别数
方法：fit(X[, y])、transform(X[, y, copy])、fit_transform(X[, y])、get_params([deep])、set_params(**params)

from sklearn import preprocessingenc = preprocessing.OneHotEncoder()enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])enc.transform([[0, 1, 3]]).toarray()  #array([[ 1., 0., 0., 1., 0., 0., 0., 0., 1.]])from sklearn.preprocessing import OneHotEncoderonehot=[]for i in xrange(train_all.shape[0]) :  tmp=[]  tmp.append(train_all["cate_1_name"][i])  tmp.append(train_all["cate_2_name"][i])  tmp.append(train_all["cate_3_name"][i])  onehot.append(tmp)enc = OneHotEncoder()enc.fit(onehot)onehot_feature=enc.transform(onehot).toarray()onehot_feature=pd.DataFrame({'onehot':onehot})

标签二值化

将classes标注的标签所在位置标为1 其他位置标为0 几类就输出几维
class preprocessing.LabelBinarizer(neg_label=0, pos_label=1, sparse_output=False)：
和 OneHotEncoder 类似，将类别特征转换为多维二元特征，并将每个特征扩展成用一维表示
属性：
classes：ndarry，所有类别的值
y_type_：str
multilabel_：bool
sparse_input_：bool
indicator_matrix_：str

 from sklearn.preprocessing import label_binarize label_binarize([1, 6], classes=[1, 2, 4, 6])  #输出[1, 0, 0, 0],[0, 0, 0, 1] label_binarize(['yes', 'no', 'no', 'yes'], classes=['no', 'yes'])

类别编码

class preprocessing.LabelEncoder：
将类别特征标记为 0 到 n_classes - 1 的数

from sklearn import preprocessingtmp=['A','A','b','c']le = preprocessing.LabelEncoder()le.fit(tmp)le.transform(tmp)

缺失值处理

使用缺失数值所在行或列的均值、中位数、众数来替代缺失值
class preprocessing.Imputer(missing_values=’NaN’, strategy=’mean’, axis=0, verbose=0, copy=True)：
参数：
missing_values：int 或者 “NaN”，对np.nan的值用 “NaN”
strategy：”mean”、”median”、”most_frequent”
属性：
statistics_：ndarray，当axis==0时，取每列填补时用的值

import numpy as npfrom sklearn.preprocessing import Imputer##均值填补nan  axis=0是行 1是列imp = Imputer(missing_values='NaN', strategy='mean', axis=0)imp.fit([[1, 2], [np.nan, 3], [7, 6]])print(imp.transform(X))##填补0值imp = Imputer(missing_values=0, strategy='mean', axis=0)

生成多项式特征

可以将数据多项式结合生成多维特征，比如 [a, b] 的二次多项式特征为 [1, a, b, a^2, ab, b^2]
特征向量X从:math:(X_1, X_2) 被转换成:math:(1, X_1, X_2, X_1^2, X_1X_2, X_2^2)。
class preprocessing.PolynomialFeatures(degree=2, interaction_only=False, include_bias=True)：
参数：
degree：int，多项式次数
interaction_only：boolean，是否只产生交叉相乘的特征
include_bias：boolean，是否包含偏移列，即全为 1 的列
属性：
powers_：ndarray，二维数组。powers_[i, j] 表示第 i 维输出中包含的第 j 维输入的次数
n_input_features_：int，输入维数
n_output_features_：int，输出维数

X = np.arange(6).reshape(3, 2)poly = PolynomialFeatures(2) #poly = PolynomialFeatures(interaction_only=True)poly.fit_transform(X)

增加伪特征

preprocessing.add_dummy_feature(X, value=1.0)：
在 X 的第一列插入值为 value 的列

转换器定制

preprocessing.FunctionTransformer
将一个已经存在的python函数转换成转换器以便于在数据清理和预处理当中使用。

import numpy as npfrom sklearn.preprocessing import FunctionTransformertransformer = FunctionTransformer(np.log1p)X = np.array([[0, 1], [2, 3]])transformer.transform(X)

特征维度合并

import numpy as npdef mergeToOne(X,X2):    X3=[]    for i in xrange(X.shape[0]):        tmp=np.array([list(X[i]),list(X2[i])])        X3.append(list(np.hstack(tmp)))    X3=np.array(X3)    return X3X = np.arange(9).reshape(3, 3)X2 = np.array([[0, 1], [2, 3],[4, 5]])t=merge(X,X2)print t    ##array转换成DataFrameimport pandas as pdadd_all=pd.DataFrame(t)##特征命名add_all.columns=['t1','t2','t3','t4','t5']

模型保存

使用 joblib 保存,读取速度也相对pickle快

from sklearn.externals import joblib #jbolib模块#保存Model(注:save文件夹要预先建立，否则会报错)joblib.dump(clf, 'save/clf.pkl')#读取Modelclf3 = joblib.load('save/clf.pkl')#测试读取后的Modelprint(clf3.predict(X[0:1]))

使用 pickle 保存

import pickle #pickle模块#保存Model(注:save文件夹要预先建立，否则会报错)with open('save/clf.pickle', 'wb') as f:    pickle.dump(clf, f)#读取Modelwith open('save/clf.pickle', 'rb') as f:    clf2 = pickle.load(f)    #测试读取后的Model    print(clf2.predict(X[0:1]))

参考01
参考02
中文文档