机器学习从入门到入职--用sklearn与Keras搭建人工智能模型

4.1数据预处理的种类

大致分为：缺失值处理，数据的标准化、规范化，稀疏化，特征编码，特征提取

4.2使用SimpleImputer缺失值处理

第四章4.1根据样本之间关联关系，及数据的行和列，用SimpleImputer方法进行缺失值处理，策略有均值插补、中位数插补和高频数插补。例子如下：

#引用相应的库，numpy用于生成缺失值，sklearn.impute库中的simpleimputer方法用预处理缺失值
import Numpy as np
from sklearn.impute import SimpleImputer
#初始化缺失值处理器，指定缺失值参数missing_values，默认np.nan
#以及缺失值补全策略参数strategy，采用均值补全
#另外还有中位数（median）、常数（constant）、最高频数（most_frequent）
imp_mean=SimpleImputer(missing_values=np.nan,strategy='mean')
imp_median=SimpleImputer(missing_values=np.nan,strategy='median')
imp_constant=SimpleImputer(missing_values=np.nan,strategy='constant')
imp_most_frequent=SimpleImputer(missing_values=np.nan,strategy='most_frequent')
X=[[13,22],[5,3],[7,np.nan],[np.nan,5],[3,7]]
#执行缺失值处理的步骤，在fit原始数据之后对其进行转换
imp_mean.fit(X)
imp_median.fit(X)
imp_constant.fit(X)
imp_most_frequent.fit(X)
print(u"均值处理结果如下")
print(imp_mean.transform(X))
print(u"中位数处理结果如下")
print(imp_median.transform(X))
print(u"最高频处理结果如下")
print(imp_most_frequent.transform(X))

输出如下

均值处理结果如下：
[[13. 22.][5. 3.][7. 9.25][7. 5.][3. 5.]]
中位数处理结果如下：
[[13. 22.][5. 3.][7. 6.][6. 5.][3. 7.]]
常数处理结果如下：
[[13. 22.][5. 3.][7. 0.][0. 5.][3. 7.]]
最高频处理结果如下：
[[13. 22.][5. 3.][7. 3.][3. 5.][3. 7.]]

4.3数据的规范化

4.3.1缩放规范化：最小值最大值缩放和最大绝对值缩放

 1.Min-Max scaling将该样本每个特征下的最大值与最小值之差作为缩放倍数，每个特征下没有任何一个数会超过其最值之差，所以作为分母；分子是每个特征下的值与最小值之差。全为0的特征，缩放后值为0。取值范围[0,1]代码表现如下：

# 引用相应的库，numpy用于生成缺失值，引用sklearn.processing库，其中包含绝大部分数据与处理方法
from sklearn import preprocessing
import numpy as np

# 原始数据X
X = np.array([[3, -2., 2.], [2., 0., 0.], [-1, 1., 3.]])  # 按行表示，按列计算
# 初始化数据预处理器，本例中为最小最大值缩放
min_max_scaler = preprocessing.MinMaxScaler()
# 数据转换并打印
X_minmax = min_max_scaler.fit_transform(X)
print("缩放规范化结果如下：\n")
print(X_minmax)
# 输出其缩放倍数
print("输出其缩放倍数：\n")
print(min_max_scaler.scale_)
# 输出其最小值
print("输出每一列的最小调整：\n")
print(min_max_scaler.min_)
print("输出每一列的最小值：\n")
print(min_max_scaler.data_min_)

输出结果：

缩放规范化结果如下：

[[1.         0.         0.66666667]
 [0.75       0.66666667 0.        ]
 [0.         1.         1.        ]]
输出其缩放倍数：

[0.25       0.33333333 0.33333333]
输出每一列的最小调整：

[0.25       0.66666667 0.        ]
输出每一列的最小值：

[-1. -2.  0.]

2.MAxAbsolute Scaling执行效率更高。它在分子上减少了减法运算，分母上也仅采用特征的最大值的绝对值。取值范围[-1,1]，分布以0为中心，更稀疏、合理。代码实现如下：

# 引用相应的库，numpy用于生成缺失值，引用sklearn.processing库，其中包含绝大部分的数据与处理方法
from sklearn import preprocessing
import numpy as np
#原始数据X
X = np.array([[3, -2., 2.], [2., 0., 0.], [-1, 1., 3.]])  # 按行表示，按列计算
# 初始化数据预处理器，本例中为最大绝对值缩放
max_abs_scaler = preprocessing.MaxAbsScaler()
#数据转换并打印
X_maxabs=max_abs_scaler.fit_transform(X)
print(X_maxabs)

输出结果如下：

[[ 1.         -1.          0.66666667]
 [ 0.66666667  0.          0.        ]
 [-0.33333333  0.5         1.        ]]

对于希望数据分布到特定的取值范围之间的特殊要求，MaxMin Scaling可以预先设置特定的范围，添加一个x_scale表示设定最大值与最小值之后的缩放变换输出（在第一块代码的基础上）

from sklearn import preprocessing
import numpy as np

# 原始数据X
X = np.array([[3, -2., 2.], [2., 0., 0.], [-1, 1., 3.]])  # 按行表示，按列计算
# 初始化数据预处理器，本例中为最小最大值缩放
min_max_scaler = preprocessing.MinMaxScaler()
# 变式 添加x_scale改变缩放变换输出
# 初始化数据预处理器，用MaxMinScaling配置feature——range可转化之后的输出范围
min_max_scaler=preprocessing.MinMaxScaler(feature_range=(-2,6))
# 数据转换并打印
X_minmax=min_max_scaler.fit_transform(X)
print("feature_range=-2,6")
print(X_minmax)

输出结果：

feature_range=-2,6
[[ 6.         -2.          3.33333333]
 [ 4.          3.33333333 -2.        ]
 [-2.          6.          6.        ]]

该方法存在问题，一旦样本某特征的数值超出最大最小值的边界，转化后的特征值存在不稳定的情况（在第一块代码的基础上）

from sklearn import preprocessing
import numpy as np

# 原始数据X
X = np.array([[3, -2., 2.], [2., 0., 0.], [-1, 1., 3.]])  # 按行表示，按列计算
# 初始化数据预处理器，本例中为最小最大值缩放
min_max_scaler = preprocessing.MinMaxScaler()
# 引入新数据，数据超出边界，输出特征值不稳定
X_new=np.array([[-3.,-1.,4.]])
X_new_minmax=min_max_scaler.transform(X_new)
print("缩放规范化效果如下：")
print(X_new_minmax)

输出：

缩放规范化效果如下：
[[-6.          0.66666667  8.66666667]]

4.3.2标准化

 标准化又称标准差规范化或Z标准化（Z_Score Normalization），对样本每个特征分别进行计算使其满足正态分布--均值0、标准差1，

# 引用相应的库，numpy用于生成缺失值，引用sklearn.processing库，其中包含绝大部分的数据与处理方法
from sklearn import preprocessing
import numpy as np
# 原始数据X
X=np.array([[3,-2.,2.],[2.,0.,0.],[1,2.,3.]])
# 初始化数据预处理器，用标准化缩放
standard_scaler=preprocessing.StandardScaler()
# 数据转换并打印
X_standard=standard_scaler.fit_transform(X)
print(u"标准化变换的结果如下：\n")
print(X_standard)
# 输出其均值
print(u"输出标准化变换之后的均值：\n")
print(X_standard.mean(axis=0))
# 输出其标准差
print(u"输出标准化之后的标准差：\n")
print(X_standard.std(axis=0))

 输出结果

标准化变换的结果如下：

[[ 1.22474487 -1.22474487  0.26726124]
 [ 0.          0.         -1.33630621]
 [-1.22474487  1.22474487  1.06904497]]
输出标准化变换之后的均值：

[ 0.00000000e+00  0.00000000e+00 -7.40148683e-17]
输出标准化之后的标准差：

[1. 1. 1.]

标准化转换后均值0，标准差1，满足标准正态分布

所有预处理方法都提供函数接口，函数调用代码实现如下：

# 标准化缩放函数化实现
X_standard=preprocessing.scale(X)
print(X_standard)

输出

标准化变换后结果如下
[[ 1.22474487 -1.22474487  0.26726124]
 [ 0.          0.         -1.33630621]
 [-1.22474487  1.22474487  1.06904497]]

4.3.3范数规范化

 范数基本概念这里不予赘述，L0，L1，L2和无穷范数

范数规范化代码如下

from sklearn import preprocessing
import numpy as np

# 原始数据X
X = np.array([[3, -2., 2.], [2., 0., 0.], [-1, 1., 3.]])  # 按行表示，按列计算
# 范数规范化的函数化实现，其中规范化系数norm为L2,还有其他形式，诸如L1,max
X_norm=preprocessing.normalize(X,norm='l2')
print(u"范数L2规范化变换后的输出：\n")
print(X_norm)

# 范数规范化的类实现，其中规范化系数norm为L1
normalizer=preprocessing.Normalizer(norm='l1').fit(X)
print(u"范数L1规范化变换之后的输出：\n")
print(normalizer.transform(X))

输出结果：

[[ 0.72760688 -0.48507125  0.48507125]
 [ 1.          0.          0.        ]
 [-0.30151134  0.30151134  0.90453403]]
范数L1规范化变换之后的输出：

[[ 0.42857143 -0.28571429  0.28571429]
 [ 1.          0.          0.        ]
 [-0.2         0.2         0.6       ]]

4.4非线性变换

4.4.1二值化变换

待更新。。。