概述
数据预处理与特征工程
数据挖掘的五大流程：
- 获取数据
- 数据预处理
- 数据预处理是检测、纠正或删除数据中损坏、不准确或不适用于模型的记录的过程
- 可能面临的问题有：数据类型不同，比如有的是文字，有的是数字，有的含时间序列，有的连续，有的间断。也有可能，数据质量不行，有噪声，有缺失，数据出错，量纲不同，有重复，数据是偏态，数据量太大或太小
- 数据预处理的目的：让数据适应模型，匹配模型的需求
- 特征工程
- 特征工程是将原始数据转换为更能代表预测的潜在问题的特征的过程，可以通过挑选最相关的特征，提取特征以及创造来实现。其中创造特征又经常以降维算法的方式实现。
- 可能面对的问题有：特征之间有相关性，特征和标签无关，特征太多或太小，或者无法表现出应用的数据现象或无法展示数据的真实面貌
- 特征工程的目的：降低计算成本；提升模型上限
- 建模，测试模型并预测结果
- 上线，验证模型效果
sklearn 中的数据预处理和特征工程
- 模块
preprocessing：几乎包含数据预处理的所有内容 - 模块
Impute：填补缺失值专用 - 模块
feature_selection：包含特征选择的各种方法的实践 - 模块
decomposition：包含降维算法
数据预处理 Preprocessing & Impute
数据无量纲化
在机器学习算法实践中，我们往往有着将不同规格的数据转换到同一规格，或不同分布的数据转换到某个特定分布的需求，这种需求统称为将数据无量纲化。数据无量纲化可以是线性的，也可以是非线性的。线性的无量纲化包括中心化（Zero-centered 或者 Mean-subtraction）处理和缩放处理（Scale）。
preprocessing.MinMaxScaler
数据归一化（Normalization，又称 Min-Max Scaling）
\[{x}' = \frac{x-min(x)}{max(x)-min(x)}\]归一化后的数据服从 (0,1) 均匀分布。
在 sklearn 中，我们使用 preprocessing.MinMaxScaler 来实现归一化。
from sklearn.preprocessing import MinMaxScaler
data = [[-1, 2],
[-0.5, 6],
[0, 10],
[1, 18]]
scaler1 = MinMaxScaler() # 实例化
scaler1.fit(data) # 本质是生成min(x)和max(x)
result1 = scaler1.transform(data) # 导出结果
result1
# array([[0. , 0. ],
# [0.25, 0.25],
# [0.5 , 0.5 ],
# [1. , 1. ]])
scaler2 = MinMaxScaler() # 实例化
result2 = scaler2.fit_transform(data) # fit+transformtransform
result2
# array([[0. , 0. ],
# [0.25, 0.25],
# [0.5 , 0.5 ],
# [1. , 1. ]])
scaler1.inverse_transform(result1) # 将归一化的结果逆转
# array([[-1. , 2. ],
# [-0.5, 6. ],
# [ 0. , 10. ],
# [ 1. , 18. ]])
scaler3 = MinMaxScaler(feature_range=(2,5)) # 实例化，归一化到非(0,1)的其他范围
result3 = scaler3.fit_transform(data)
result3
# array([[2. , 2. ],
# [2.75, 2.75],
# [3.5 , 3.5 ],
# [5. , 5. ]])
# 当特征数量非常多时，可用 partial_fit 替代 fit
scaler4 = MinMaxScaler()
scaler4.partial_fit(data)
result4 = scaler4.transform(data)
result4
# array([[0. , 0. ],
# [0.25, 0.25],
# [0.5 , 0.5 ],
# [1. , 1. ]])
使用 numpy 实现归一化
import numpy as np
X = np.array(data)
# 归一化
X_nor = (X - X.min(axis=0))/(X.max(axis=0) - X.min(axis=0))
X_nor
# 逆转归一化
X_rev = X_nor * (X.max(axis=0) - X.min(axis=0)) + X.min(axis=0)
X_rev
preprocessing.StandardScaler
数据标准化（Standardization，又称 Z-score normalization）
\[{x}' = \frac{x-\mu}{\sigma}\]其中 \(\mu\) 为均值，\(\sigma\) 为标准差。标准化后的数据服从 \(N(\mu,\sigma)\) 正态分布。
from sklearn.preprocessing import StandardScaler
data = [[-1, 2],
[-0.5, 6],
[0, 10],
[1, 18]]
scaler = StandardScaler() # 实例化
scaler.fit(data) # 生成均值和方差
scaler.mean_ # array([-0.125, 9. ])
scaler.var_ # array([ 0.546875, 35. ])
x_std = scaler.transform(data)
x_std
# array([[-1.18321596, -1.18321596],
# [-0.50709255, -0.50709255],
# [ 0.16903085, 0.16903085],
# [ 1.52127766, 1.52127766]])
scaler.fit_transform(data) # fit+transformtransform
scaler.inverse_transform(x_std) # 逆转标准化
StandardScaler 和 MinMaxScaler 选哪个？
大多数机器学习算法中，会选择 StandardScaler 来进行特征缩放，因为 MinMaxScaler 对异常值非常敏感。在 PCA、聚类、逻辑回归、支持向量机、神经网络等算法中，StandardScaler 往往是更好的选择。
MinMaxScaler 在不涉及距离度量、梯度、协方差计算以及数据需要被压缩到特定区间时使用广泛，比如数字图像处理中量化像素强度，都会使用 MinMaxScaler 将数据压缩到 [0,1] 区间。
除此之外，sklearn.preprocessing 中还提供了其他各种缩放处理，比如，压缩数据但不影响数据的稀疏性（不影响为0的数据）时，我们会使用 MaxAbsScaler；在异常值多、噪声大时，我们可能会选用分位数来无量纲化，此时使用 RobustScaler。
缺失值
impute.SimpleImputer
class sklearn.impute.SimpleImputer(*, missing_values=nan, strategy=’mean’, fill_value=None, verbose=0, copy=True, add_indicator=False)
这个类专门用来填补缺失值，它包括四个重要参数：
| 参数 | 含义 |
|---|---|
| missing_value | 指定数据中哪些为缺失值，默认np.nan |
| strategy | 选择填补缺失值的策略，可选：mean（默认，均值）、median（中值）、most_frequent（众数）、constan（指定默认值） |
| fill_value | 当参数strategy为’constant’时可用，指定默认值 |
| copy | 是否创建新的矩阵，默认为True |
# 导入数据
import pandas as pd
data = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/data/Narrativedata.csv', index_col=0)
data.info()
# <class 'pandas.core.frame.DataFrame'>
# Int64Index: 891 entries, 0 to 890
# Data columns (total 4 columns):
# # Column Non-Null Count Dtype
# --- ------ -------------- -----
# 0 Age 714 non-null float64
# 1 Sex 891 non-null object
# 2 Embarked 889 non-null object
# 3 Survived 796 non-null object
# dtypes: float64(1), object(3)
# memory usage: 34.8+ KB
# 处理单行数据
Age = data['Age'].values.reshape(-1,1)
Embarked = data['Embarked'].values.reshape(-1,1)
Survived = data['Survived'].values.reshape(-1,1)
from sklearn.impute import SimpleImputer
# 实例化
imp_mean = SimpleImputer(strategy='mean')
imp_median = SimpleImputer(strategy='median')
imp_most = SimpleImputer(strategy='most_frequent')
imp_0 = SimpleImputer(strategy='constant', fill_value='unknown')
# 一步调取结果
data['Age'] = imp_mean.fit_transform(Age)
data['Embarked'] = imp_most.fit_transform(Embarked)
data['Survived'] = imp_0.fit_transform(Survived)
data.info()
使用 numpy 填补缺失值
data['Age'].fillna(data['Age'].mean(), inplace=True)
data['Embarked'].fillna(data['Embarked'].mode()[0], inplace=True)
data['Survived'].fillna('unknown', inplace=True)
处理分类型特征：编码和哑变量
在机器学习中，大多数算法，例如逻辑回归LR、支持向量机SVM、k近邻算法等只能处理文字，为了让数据适应算法和库，我们必须将数据编码，将文字型数据转换为数值型。
preprocessing.LabelEncoder
标签专用，能够将分类数据转换为分类数值
from sklearn.preprocessing import LabelEncoder
y = data.iloc[:, -1]
le = LabelEncoder() # 实例化
le.fit(y)
label = le.transform(y)
le.classes_
label
le.fit_transform(y)
le.inverse_transform(label)
data.iloc[:,-1] = label
data.head()
preprocessing.OrdinalEncoder
特征专用，能够将分类特征转换为分类数值
from sklearn.preprocessing import OrdinalEncoder
data[['Sex', 'Embarked']] = OrdinalEncoder().fit_transform(data[['Sex', 'Embarked']])
preprocessing.OneHotEncoder
我们来考虑三种不同性质的分类数据：
- 名义变量：例如
性别（男，女） - 有序变量：例如
学历（小学，初中，高中） - 有距变量：例如
重量（5kg，10kg，15kg）
对于名义变量，我们只有使用哑变量的方式来处理，才能够尽量向算法传达最准确的信息.
from sklearn.preprocessing import OneHotEncoder
X = data[['Sex', 'Embarked']]
enc = OneHotEncoder(categories='auto').fit(X)
result = enc.transform(X).toarray()
result
enc.inverse_transform(result)
enc.get_feature_names()
# array(['Female', 'Male', 'Embarked_C', 'Embarked_Q', 'Embarked_S'], dtype=object)
newdata = pd.concat([data, pd.DataFrame(result)], axis=1)
newdata.drop(['Sex', 'Embarked'], axis=1, inplace=True)
newdata.columns = ['Age', 'Survived', 'Female', 'Male', 'Embarked_C', 'Embarked_Q', 'Embarked_S']
newdata.head()
特征可以做哑变量，标签也可以吗？可以，使用类 preprocessing.LabelBinarizer，许多算法都可以处理多标签问题（比如决策树），但是这样的做法在现实中不常见，因此我们在这里就不赘述了。
处理连续型特征：二值化与分段
preprocessing.Binarizer
根据阈值将数据二值化，用于处理连续型变量，大于阈值的映射为1，小于或等于阈值的映射为0.
from sklearn.preprocessing import Binarizer
X = data.loc[:, 'Age'].values.reshape(-1,1)
bz = Binarizer(threshold=30).fit_transform(X)
bz
preprocessing.KBinsDiscretizer
将连续型变量划分为分类变量，能够将连续型变量排序后按顺序分箱后编码。包含三个重要参数：
| 参数 | 含义 |
|---|---|
| n_bins | 分箱的箱数，默认5 |
| encode | 编码方式：onehot（默认）、ordinal、onehot-dense |
| strategy | 定义箱宽的方式，可选：uniform（等宽）、quantile（默认，等位）、kmeans（聚类） |
from sklearn.preprocessing import KBinsDiscretizer
X = data.loc[:, 'Age'].values.reshape(-1,1)
est1 = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform')
est1.fit_transform(X)
est1.bin_edges_ # 查看分箱边界
est2 = KBinsDiscretizer(n_bins=3, encode='onehot', strategy='uniform')
est2.fit_transform(X).toarray()
est2.bin_edges_ # 分箱边界与est1一致