本文主要记录使用sklearn库对数据集进行预处理的相关操作，通过了解相关知识，运行已有的代码来进行新内容的学习
- standardization
标准化，我们通常会忽略分布的形状而仅仅通过去除每个特征分量的均值将数据变换到中心，然后通过除以特征值的标准差对数据进行尺度缩放variance scaling
标准化不易受到异常值的影响。
from sklearn import preprocessing
import numpy as np
x = np.array([[1, -1, 2],
[2, 0, 0],
[0, 1, -1]])
x_1 = preprocessing.scale(x)
print(x_1)
print(x_1.mean(axis=1))
preprocessing模块提供了一个standardscaler类，实现变换器的api用于计算训练数据集的均值和标准差，然后将结果用于测试数据集中去。
from sklearn import preprocessing
import numpy as np
x = np.array([[1, -1, 2],
[2, 0, 0],
[0, 1, -1]])
x_1 = preprocessing.StandardScaler().fit(x)
print(x_1)
print(x_1.mean_)
print(x_1.transform(x))
StandardScaler(copy=True, with_mean=True, with_std=True)
[1. 0. 0.33333333]
[[ 0. -1.22474487 1.33630621]
[ 1.22474487 0. -0.26726124]
[-1.22474487 1.22474487 -1.06904497]]
#会使用训练集的均值和方差进行变换操作
print(x_1.transform([[2,1,2]]))
[[1.22474487 1.22474487 1.33630621]]
#矩阵尺度缩放到（0，1）之间
#归一化操作
from sklearn import preprocessing
import numpy as np
x = np.array([[1, -1, 2],
[2, 0, 0],
[0, 1, -1]])
x_1 = preprocessing.MinMaxScaler(feature_range=(1,2))
#feature_range=(0,1)是默认的我们可以设置数据集到固定的区间
x_1_1 = x_1.fit_transform(x)
print(x_1_1)
x_test = np.array([[-3, -1, 4]])
x_text_1 = x_1.fit_transform(x_test)
print(x_text_1)
[[0.5 0. 1. ]
[1. 0.5 0.33333333]
[0. 1. 0. ]]
[[0. 0. 0.]]
from sklearn import preprocessing
import numpy as np
x = np.array([[1., -1., 2.],
[2., 0., 0.],
[0., 1., -1.]])
x_1 = preprocessing.MaxAbsScaler()
#这个函数的作用是让数据训练区间变成【-1，1】，但是没有feature_range的函数
x_train = x_1.fit_transform(x)
print(x_train)
x_text = np.array([[1., 2., 3.]])
x_text_1 = x_1.transform(x_text)
print(x_text_1)
print(x_1.scale_)
[[ 0.5 -1. 1. ]
[ 1. 0. 0. ]
[ 0. 1. -0.5]]
[[0.5 2. 1.5]]
[2. 1. 2.]
缩放稀疏数据
1.MaxAbsScaler和maxabs_scale都有专门设计的用于稀疏变换的功能，推荐使用
2.sacle和standarscaler可以接受scipy.sparse矩阵为输入，只要参数with_mean=false被显示的传入构造函数里面去就可以了
3.robustscaler不接受稀疏输入，但可以使用transoform methond来处理稀疏输入数据
如果数据存在很多误差，那么可以使用robust_scale和RobustScaler来增加数据的可靠性。
- normalization
标准化是将单个样本的特征变为具有单位长度的特征向量的过程。用于两个样本的相似性时，很有作用。
normalize提供了快速简单的方法使l1和l2范数执行规范化操作，l2为欧氏距离。
from sklearn.preprocessing import normalize
x = [[1, 2, 3],
[2, 2, 3],
[3, 3, 3]]
x_normalize1 = normalize(x, norm="l2")
x_normalize2 = normalize(x, norm="l1")
print(x_normalize1)
print(x_normalize2)
[[0.26726124 0.53452248 0.80178373]
[0.48507125 0.48507125 0.72760688]
[0.57735027 0.57735027 0.57735027]]
[[0.16666667 0.33333333 0.5 ]
[0.28571429 0.28571429 0.42857143]
[0.33333333 0.33333333 0.33333333]]
#分别使用L1和L2范数的不同结果
该变换是一个变换器，所以具有transformer Api包括fit等，但是不存在在所有样本上的统计学习过程
normalize=preprocessing.Normalizer().fit()
normalize.transform([[1,2,3]])
Out[8]: array([[0.26726124, 0.53452248, 0.80178373]])
无论normalize和Nomarlizer函数都接受scipy.sparse作为输入，对于稀疏输入，都会转换为CSR格式，为了避免不必要的内存拷贝，推荐使用CSR格式(scipy.sparse.csr_matrix)
- binarization
将数值型特征阈值化转变为布尔型特征值，这一过程主要为概率型学习器提供与处理机制。
概率型学习器假定输入数据服从多变量伯努利分布。
在文本处理中也普遍使用二至特征简化概率推断过程。
同normalize一样用于pipeline的早期。
from sklearn.preprocessing import Binarizer
x = [[1, 2, 3],
[2, -1, 3],
[3, 3, 3]]
x_binarize = Binarizer(threshold=1).fit(x)#threshold为设置阈值，小于等于1为0，大于1为1，变成一个二值结果
print(x_binarize.transform(x))
[[0 1 1]
[1 0 1]
[1 1 1]]
4.标称特征编码
特征在一定情况下是离散的，对于整数型特征，无法被skLearn的学习器使用，一种变换标称型特征的方法事故one-of-k和one-hot编码
from sklearn import preprocessing
x = [[0, 1, 1],
[0, 0, 2],
[0, 2, 1],
[1, 0, 2]]
enc = preprocessing.OneHotEncoder()
enc.fit(x)
print(enc.transform([[0,2,2]]).toarray())
[[1. 0. 0. 0. 1. 0. 1.]]
因为我们在fit之后，编码器就仿照了x的格式，第一列有0，1两个结果，所以维度为2，第二列有0，1，2三个结果，维度为3，第三列为1，2两个结果所以维度为2，最后的输出
1，0为0
0，0，1为2
0，1为2
from sklearn import preprocessing
#因为我们可能无法全部写出所以的可能，但是可以通过
#n_value来指定所以列的可能性
x = [[1, 2, 3],
[0, 1, 0]]
enc = preprocessing.OneHotEncoder(n_values=[2, 3, 4])
enc.fit(x)
print(enc.transform([[0, 1, 1]]).toarray())
[[1. 0. 0. 1. 0. 0. 1. 0. 0.]]
#编码器在fit适应之后，我们为其指定维度分别为2，3，4
#最后的输入是0，1，1
#第一个有两个维度，从0开始，有0，1，所以1，0表示0
#第二个有3各维度，1表示第二个，所以是0，1，0
#第三个4各维度，所以输出应为，0,1,0,0
5.缺失值填充
第一种是，如果某个行或列值不存在，则把整行或整列都删掉，这种有可能会造成数据有效性的缺失。
另外一种是用相邻数据的相关性来对缺失值进行填补，sklearn提供了三种补全策略，使用一行或一列的均值，中值，出现次数最多的值进行补充。
import numpy as np
from sklearn.preprocessing import Imputer
imp = Imputer(missing_values='NaN',
strategy='mean',
axis=0)
imp.fit([[1, 2],
[np.nan, 3],
[7, 6]])
print(imp.transform([[np.nan, 2],
[6, np.nan],
[7, 6]]))
[[4. 2. ]
[6. 3.66666667]
[7. 6. ]]
#这里缺失值的补充使用fit之后矩阵的均值来对我们transform的矩阵进行填补
#imputer支持稀疏矩阵输入
from sklearn.preprocessing import Imputer
import scipy.sparse as sp
imp = Imputer(missing_values=0,
strategy='mean',
axis=0)
x = sp.csc_matrix([[1, 2],
[0, 3],
[7, 6]])
imp.fit(x)
x_test = sp.csc_matrix([[0, 2],
[6, 0],
[7, 6]])
print(imp.transform(x_test))
[[4. 2. ]
[6. 3.66666667]
[7. 6. ]]
6.多项式特征
为输入数据添加非线性特征可以增加模型复杂度
（x1,x2）拓宽到（1，x1,x2,x1²,x1,x2,x2²）
import numpy as np
from sklearn.preprocessing import PolynomialFeatures
x = np.arange(6).reshape(3, 2)
print(x)
poly = PolynomialFeatures(2)
print(poly.fit_transform(x))
[[0 1]
[2 3]
[4 5]]
[[ 1. 0. 1. 0. 0. 1.]
[ 1. 2. 3. 4. 6. 9.]
[ 1. 4. 5. 16. 20. 25.]]
import numpy as np
from sklearn.preprocessing import PolynomialFeatures
x = np.arange(9).reshape(3, 3)
print(x)
poly = PolynomialFeatures(degree=3,interaction_only=True)
print(poly.fit_transform(x))
[[0 1 2]
[3 4 5]
[6 7 8]]
[[ 1. 0. 1. 2. 0. 0. 2. 0.]
[ 1. 3. 4. 5. 12. 15. 20. 60.]
[ 1. 6. 7. 8. 42. 48. 56. 336.]]
#我们只想得到输入的每个数据相互之间的乘积关系
7.自定义变换器
from sklearn.preprocessing import FunctionTransformer
import numpy as np
t = FunctionTransformer(func=np.sin)
x = np.arange(6).reshape(2,3)
print(x)
print(t.transform(x))
[[0 1 2]
[3 4 5]]
[[ 0. 0.84147098 0.90929743]
[ 0.14112001 -0.7568025 -0.95892427]]
#定义一个sin变换器，输入的结果每一位都进行sin正弦变换
8.数据降维（维度：降低特征的数量）