1.数据无量纲化

将不同规格的数据转换到同一规格，将不同分布的数据转换到某个特定分布
无量纲化 加快求解速度 & 提升精度// 避免某个特别大的特征对距离计算造成影响

# MinMaxScaler - 数据归一化：归一化之后数据服从正态分布；压缩到 [0,1]
import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler

data = [[-1, 2], [-0.5, 6], [0, 10], [1, 18]]
df = pd.DataFrame(data)
print(df[0])

scaler = MinMaxScaler()
result = scaler.fit_transform(data)
result = scaler.fit_transform(df[0].values.reshape(-1, 1)) # 如果只是对df[0]归一化
print(result)

归一化到[0,1]以外的范围
scaler = MinMaxScaler(feature_range=[5,10])

# StandardScaler - 数据标准化：
当数据(x)按均值(mean)中心化后，再按标准差(σ)缩放，数据就会服从 mean=0，std=1的正态分布
from sklearn.preprocessing import StandardScaler
data = [[-1, 2], [-0.5, 6], [0, 10], [1, 18]]

scaler = StandardScaler() # 实例化
scaler.fit(data) # fit，本质是生成均值和方差
print(scaler.mean) # 查看均值的属性mean
print(scaler.var) # 查看方差的属性var
x_std = scaler.transform(data) # 通过接口导出结果

print(x_std.mean()) # 导出的结果是一个数组，用mean()查看均值
print(x_std.std()) # 用std()查看方差
reasult = scaler.fit_transform(data) # 使用fit_transform(data)一步达成结果

raw = scaler.inverse_transform(x_std) # 使用inverse_transform逆转标准化

其中NaN会被当做缺失值，在fit的时候忽略，在transform的时候保持NaN状态
如果一定要输入一维数组 // result = scaler.fit_transform(df[0].values.reshape(-1, 1))

大多数机器学习算法中，会选择StandardScaler来进行特征缩放，因为MinMaxScaler对异常值非常敏感。
在PCA，聚类，逻辑回归，支持向量机，神经网络这些算法中，StandardScaler往往是最好的选择。

MinMaxScaler在不涉及距离度量、梯度、协方差计算以及数据需要被压缩到特定区间时使用广泛，比如数字图像处理中量化像素强度时，都会使用MinMaxScaler将数据压缩于[0,1]区间之中

建议先试试看StandardScaler，效果不好换MinMaxScaler。

MaxAbsScaler - 缩放
# RobustScaler - 无量纲化
……

2.缺失值

# impute.SimpleImputer
class sklearn.impute.SimpleImputer (missing_values=nan, strategy=’mean’, fill_value=None, verbose=0, copy=True)
“””
这个类是专门用来填补缺失值的
missing_values - 告诉SimpleImputer，数据中的缺失值长什么样，默认np.nan
strategy - 填补策略，default=mean // median, most_frequent 众数，constant 参考fill_value值
fill_value - 当strategy=’constant’, 为输入的值
copy - 默认为True，将创建特征矩阵的副本，反之直接填补到原特征矩阵中
“””

# 用 pandas & numpy 填补缺失值
import pandas as pd
data = pd.read_csv()

data.loc[:, ‘Age’] = data.loc[:, ‘Age’].fillna(data.loc[:, ‘Age’].median())

data.dropna(axis=0,inplace=True)
# .dropna(axis=0)删除所有有缺失值的行，.dropna(axis=1)删除所有有缺失值的列
# 参数inplace，为True表示在原数据集上进行修改，False表示生成一个复制对象，不修改原数据，默认为False

3.处理分类型特征：编码和哑变量

在机器学习中，大多数算法，譬如逻辑回归，支持向量机SVM，k近邻算法等都只能够处理数值型数据，不能处理文字。
在sklearn当中，除了专用来处理文字的算法，其他算法在fit的时候全部要求输入数组或矩阵，也不能够导入文字型数据
（其实手写决策树和普斯贝叶斯可以处理文字，但是sklearn中规定必须导入数值型）

而例如 学历 = [ 小学，初中，高中，大学 ] or 付费方式 = [ 支付宝，现金，微信 ] 这类情况，
需要对数据进行编码，即将 文字型数据 —> 数值型

# preprocessing.LabelEncoder：标签专用，将 分类 —> 分类数值
from sklearn.preprocessing import LabelEncoder

y = data.iloc[:, -1] // y = [‘zfb’, ‘xj’, ‘wechat’]

le = LabelEncoder() # 实例化
le = le.fit(y) # 导入数据
label = le.transform(y) # transform接口调取结果

print(le.classes_) # 查看原先类别list
# [‘wechat’ ‘xj’ ‘zfb’]
print(label)
# [2 1 0]

一步到位
from sklearn.preprocessing import LabelEncoder
data.iloc[:,-1] = LabelEncoder().fit_transform(data.iloc[:,-1])

# preprocessing.OrdinalEncoder：特征专用，分类特征 —> 分类数值
import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import OrdinalEncoder

def create_data():
datasets = [[‘青年’, ‘否’, ‘否’, ‘一般’, ‘否’],
[‘青年’, ‘否’, ‘否’, ‘好’, ‘否’],
[‘青年’, ‘是’, ‘否’, ‘好’, ‘是’],
[‘青年’, ‘是’, ‘是’, ‘一般’, ‘是’],
[‘青年’, ‘否’, ‘否’, ‘一般’, ‘否’],
[‘中年’, ‘否’, ‘否’, ‘一般’, ‘否’],
[‘中年’, ‘否’, ‘否’, ‘好’, ‘否’],
[‘中年’, ‘是’, ‘是’, ‘好’, ‘是’],
[‘中年’, ‘否’, ‘是’, ‘非常好’, ‘是’],
[‘中年’, ‘否’, ‘是’, ‘非常好’, ‘是’],
[‘老年’, ‘否’, ‘是’, ‘非常好’, ‘是’],
[‘老年’, ‘否’, ‘是’, ‘好’, ‘是’],
[‘老年’, ‘是’, ‘否’, ‘好’, ‘是’],
[‘老年’, ‘是’, ‘否’, ‘非常好’, ‘是’],
[‘老年’, ‘否’, ‘否’, ‘一般’, ‘否’]]
labels = [u’年龄’, u’有工作’, u’有自己的房子’, u’信贷情况’, u’类别’]
return datasets, labels

datasets, labels = create_data()
data = pd.DataFrame(datasets, columns=labels)

y = data.iloc[:, -1]
x = data.iloc[:, :-1]
data.iloc[:, -1] = LabelEncoder().fit_transform(data.iloc[:, -1])
data.iloc[:, :-1] = OrdinalEncoder().fit_transform(data.iloc[:, :-1])
# print(data)

 年龄  有工作  有自己的房子  信贷情况  类别<br />0   2.0  0.0     0.0   0.0   0<br />1   2.0  0.0     0.0   1.0   0<br />2   2.0  1.0     0.0   1.0   1<br />3   2.0  1.0     1.0   0.0   1<br />4   2.0  0.0     0.0   0.0   0<br />5   0.0  0.0     0.0   0.0   0<br />6   0.0  0.0     0.0   1.0   0<br />7   0.0  1.0     1.0   1.0   1<br />8   0.0  0.0     1.0   2.0   1<br />9   0.0  0.0     1.0   2.0   1<br />10  1.0  0.0     1.0   2.0   1<br />11  1.0  0.0     1.0   1.0   1<br />12  1.0  1.0     0.0   1.0   1<br />13  1.0  1.0     0.0   2.0   1<br />14  1.0  0.0     0.0   0.0   0

print(OrdinalEncoder().fit(data.iloc[:, :-1]).categories) #对应LabelEncoder的接口classes

# preprocessing.OneHotEncoder：独热编码，创造哑变量

1 舱门(S, C, Q) - 彼此之间完全没有联系；名义变量
2 学历(小学，初中，高中) - 高中>初中>小学 But不能说 小学+X=初中；有序变量
3 体重(>45kg, >90kg, >135kg) - 各取值之间有联系，可以相互计算；有距变量

有序变量可以用OrdinalEncoder来处理
名义变量有使用哑OneHotEncoder来处理，才能够尽量向算法传达最准确的信息

result = OneHotEncoder(categories=’auto’).fit_transform(x).toarray()
# 如果要OneHotEncoder支持字符串的话，就必须使用categories=’auto’

4.处理连续型特征：二值化和分段

# preprocessing.Binarizer
二值化 - 根据阈值将数据分为 1/0 # 仅考虑某种现象的存在与否
transformer = Binarizer(threshold=30).fit_transform(x)
# 小于等于30的转为0，大于等于30的转为1 // 只支持数值型数据

# preprocessing.KBinsDiscretizer
将连续型变量 划分为分类变量，排序后 按先后顺序 分箱编码
from sklearn.preprocessing import KBinsDiscretizer

x, y = create_data()
split = x[:,0].reshape(-1,1)
// onehot
est = KBinsDiscretizer(n_bins=3, encode=’onehot’,strategy=’uniform’)
splited = est.fit_transform(split).toarray()
// ordinal
est = KBinsDiscretizer(n_bins=3, encode=’ordinal’,strategy=’uniform’)
splited = est.fit_transform(split)

print(splited)

当数据预处理完成之后，开始特征工程！