Data Mining Pipeline（数据挖掘实践指南--特征发现，处理与评估）

–数据和特征决定了机器学习的上限，而模型和算法只是逼近这个上限。

故特征工程和数据清洗十分重要。本文以竞赛为目标，以完成实践的数据挖掘任务为导向，需要运用到一系列的处理方法。算法是数据挖掘之魂，但魂魄需要寄托在数据的实体，以及通过与现实的比对和交互后，不断提升自己的内魂。这一块的每一个小点都可以引申出很多的东西，所以先做一个大概，用以备忘，持续更新。

数据挖掘的一般过程：
最好的模型效果是我们的终极目标，而想要得到最好的效果，在搭建模型前的数据探索最为重要，包括模型前的探索与建模后的探索两方面。

• 建模前：了解数据的性质以及干净程度，大小，缺失值分布，训练集与测试集的分布差异等，这些可以为数据预处理带来非常大的参考。
• 建模后：在完成了初步的模型搭建后，往往还是需要通过对数据的理解（如了解目前模型哪些数据做的好，哪些数据做的不好）来不断的调整既有模型，挖掘可能遗漏掉的细节，提升性能。

（1）数据采集
数据采集是最基本也很耗时间的工作。比如对于具体的工程事件，需要考虑采集哪些类型的数据？需要哪些属性？需要多少数据支撑？然后再实际去采集这些数据，离线采集？在线获取？是否是实时数据？

（2）数据预处理
基于最后期望的目标结果，对于当前的数据，如何处理当前的数据类型，比如如何处理有序变量？如何处理无序变量？数据可信吗？有缺失值吗？应该正则化吗？离群值，噪音点怎么处理？特征工程？偏差检测？样本过滤？等等等等，数据清洗将会耗去大量的时间。其中主要的分析手段和顺序如下：

• 全局分析：包括数据的大小，整体数据的缺失情况等；通过全局的分析可以了解到数据的整体情况，决定初步采用什么样的算法；
• 单变量分析：包括每个变量的分布，缺失情况等；通过单变量分析，可以进一步的了解每个变量的分布情况，是否有无用的变量(例如全部缺失的列)，是否出现了某些分布奇怪的变量等.
• 多变量分析：包括特征变量与特征变量之间的分析以及特征变量与标签之间的分析等；通过多变量分析，很多时候可以直接找到一些比较强的特征，此外变量之间的关系也可以用来做一些简单的特征筛选。
• 训练集与测试集的分布分析：寻找差异大的变量，这些差异大的变量往往是导致线下和线上差异的核心因素，这有利于设计线下的验证方法。

（3）解释模型结果和调整模型
根据数据，选用合适的模型，然后不断的根据结果微调模型，改进模型。或是在发现某些问题后，再返回第二步，重做第三步。不断的评估模型以完成最好的结果。

• 模型特征重要性分析：LGB/XGB等的importance、LR、SVM的coeff等；特征重要性可以结合业务理解，有些奇怪的特征在模型中起着关键的作用，这些可以帮助我们更好地理解我们的业务；
• 模型分割方式分析：可视化模型的预测，包括LGB的每一颗数等；这些可以很好的理解现有的模型，同时模型的分割方式是否符合常理也可以结合业务知识一起分析；
• 模型结果分析：这个在回归问题就是看预测的结果的分布；分类一般看混淆矩阵等。要去寻找模型做的不好的地方，从而更好的修正模型。

观察数据的分布
观察方法：可视化，发现数据分布的特点、数据与lable之间的联系，数据属性间的关系。
解决方法：

• 1.使用matplotlib和seaborn进行画图
• 2.比较常用的图表有：查看目标变量的分布。当分布不平衡时，根据评分标准和具体模型的使用不同，可能会严重影响性能。
• 3.对连续型数值变量，可以用箱型图来直观地查看它的分布。
• 4.对于坐标类数据（时间分布型等），可以用散点图来查看它们的分布趋势和是否有离群点的存在。
• 5.对于分类问题，将数据根据label (目标结果) 的不同着不同的颜色绘制出来，这对特征的构造很有帮助。绘制变量之间两两的分布和相关度图表。
• • 先单变量分析基本情况。观察样本数量，训练集数量，是否有时间特征，是否存在周期性，特征含义，特征类型 (int，float，time)，特征的缺失情况 (注意有时候可能有些是空的有些是NAN符号等)，特征的均值方差情况。
• • 结合label进行分析，是否强相关，不相关的原因。（统计图，离散图）有必要的话，可以对lable的分布进行专门的分析。
• • 再多变量进行相关性分析等，看是否存在依赖性。

如何处理缺失数据?
产生原因：数据无法获取，被遗漏，属性不可用，或者不重要等。
解决方法：

• 1.删除缺失行。从而得到一个完备的信息表。以数据量来换取信息的完备，会造成资源的大量浪费，而且丢弃了大量隐藏信息，甚至是某些很重要的信息

• 2.人工填写。特殊全局常量值，平均值，寻找最相似的对象补齐，K近邻平均补齐，回归，EM，寻找属性间的关系（决策树），所有的可能值填充。

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]])
Imputer(axis=0, copy=True, missing_values='NaN', strategy='mean', verbose=0)
X = [[np.nan, 2], [6, np.nan], [7, 6]]
print(imp.transform(X))    

• 3.不处理。贝叶斯网络和神经网络等都可以不用太过在意这个问题。

如何处理异常值数据？
观察方法：异常值的观察可以利用箱型图和散点图。
解决方法：

• 1.不处理，如LightGBM和XGBoost，这类对异常值不敏感的算法来说不太需要处理；
• 2.把异常值的处理用缺失值的处理的思路来处理，比如mean、median进行填补；
• 3.通过分箱进行泛化处理，在风控系统中，使用lr的时候很常用的处理手段；
• 4.很多可能是业务异常的问题，所以可以结合业务和实际的情况进行处理，比如用户保密填充为-999，还有种是错误的导入导致的；

如何处理稀疏数据？
流型降维，数据平滑，或者使用embedding方法进行映射。

import scipy.sparse as sp
X = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
imp = Imputer(missing_values=0, strategy='mean', axis=0)#Imputer也支持稀疏矩阵
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. ]]

但是这里的缺失值被编码为0，被隐性地储存在了矩阵中。当缺失值个数比观察值多很多的时候，这个形式才比较适用。

如何处理数据不平衡？

• 过采样。对小样本加噪声，对大样本下采样，使两者数目接近再学习。但是过采样可能会对采样过的少样本过拟合，影响模型的泛化能力
• 欠采样。去除大样本的部分数量，使两者数目接近再学习。不太好的是，下采样/欠采样会造成信息损失，导致模型欠拟合
• 加权。如AdaBoost或SVM。不过它存在权重的选择问题咯
• 半监督数据增强。这种方法一般可以比较处理上以上几种方法的问题
• 设置阈值。将正负样本的数据比作为阈值也加入到算法决策中
• 采用对数据不平衡不敏感的算法
• 改变评价标准，如使用AUC/ROC
• 采用集成学习或者考虑数据的先验分布

如何具体的完成数据预处理任务？
目标：准确性，完整性，一致性，时效性，可信性，可解释性。
经过对数据的观察，异常值、缺失值的寻找，理论上还需要完成：

• 数据清洗：处理缺失值，光滑噪音数据，识别离群点，错误点，修正逻辑。【多用聚类和异常点检测】
• 数据集成：多个数据源可能对同一属性有不同的名字而造成的冗余，冲突值，重复项等。
• 数据规约：降维，数据压缩，数量规约，以简化数据集。
• 数据变换：规范化，数据离散化，概念分层，粒度，数据类型变换，属性构造。【不平衡采用采样法或者权重法】

对数据处理的具体方法有：

• 归一化：对数据集进行区间缩放，缩放到[0,1]的区间内，把有单位的数据转化为没有单位的数据，即统一数据的衡量标准，消除单位的影响。可以提高迭代求解的收敛速度和精度，如下图的梯度下降。
  

from sklearn import preprocessing#使用preprocessing
import numpy as np
X = [[ 1., -1.,  2.],
      [ 2.,  0.,  0.],
      [ 0.,  1., -1.]]
X_normalized = preprocessing.normalize(X, norm='l2')
print(X_normalized)

normalizer = preprocessing.Normalizer().fit(X)  #以便之后对测试集进行相同的转换
normalizer.transform([[-1.,  1., 0.]]) 

输出为：

array(
[[ 0.40824829, -0.40824829, 0.81649658],
[ 1. , 0. , 0. ],
[ 0. , 0.70710678, -0.70710678]])
array([[-0.70710678, 0.70710678, 0. ]])

• 标准化：标准化是在不改变原数据分布的前提下，将数据按比例缩放，使之落入一个限定的区间，使数据的不同度量之间具有可比性，即更关注度量的分布形态。如有：【但是实际上这样通常忽略分布的具体形态，数据转换仅指，减去每个特征的平均值，再除以他们的标准差。】
• • 1.z-score标准化：这是最常见的特征预处理方式，基本所有的线性模型在拟合的时候都会做 z-score标准化。具体的方法是求出样本特征x的均值mean和标准差std，然后用（x-mean)/std来代替原特征。这样特征就变成了均值为0，方差为1了。在sklearn中，我们可以用StandardScaler来做z-score标准化。当然，如果是用pandas做数据预处理，可以自己在数据框里面减去均值，再除以方差，自己做z-score标准化。 优点是简单缺点是在正太分布是效果才最好，存在在异常值时无法保证平衡的特征尺度，以及需要知道数据的平均值和方差（在实际中很难得到）。
• • 2.max-min标准化：也称为离差标准化，预处理后使特征值映射到[0,1]之间。具体的方法是求出样本特征x的最大值max和最小值min，然后用(x-min)/(max-min)来代替原特征。如果我们希望将数据映射到任意一个区间[a,b]，而不是[0,1]，那么也很简单。用(x-min)(b-a)/(max-min)+a来代替原特征即可。在sklearn中，我们可以用MinMaxScaler来做max-min标准化。这种方法的问题就是如果测试集或者预测数据里的特征有小于min，或者大于max的数据，会导致max和min发生变化，需要重新计算。所以实际算法中， 除非你对特征的取值区间有需求，否则max-min标准化没有 z-score标准化好用。同样它对异常值也十分敏感。
• • 3.L1/L2范数标准化：通常情况下，范数标准化首选L2范数标准化。在sklearn中，我们可以用Normalizer来做L1/L2范数标准化。

from sklearn import preprocessing #使用preprocessing
import numpy as np
X = np.array([[ 1., -1.,  2.],
               [ 2.,  0.,  0.],
               [ 0.,  1., -1.]])
X_scaled = preprocessing.scale(X)
print(X_scaled)       
print(X_scaled.mean(axis=0))          
print(X_scaled.std(axis=0))

scaler = preprocessing.StandardScaler().fit(X) #计算训练集的平均值和标准差，以便之后对测试集进行相同的转换。
print(scaler.transform([[-1.,  1., 0.]]) )

输出结果为：

array(
[[ 0. , -1.22474487, 1.33630621],
[ 1.22474487, 0. , -0.26726124],
[-1.22474487, 1.22474487, -1.06904497]])

调整后的数据平均值为0，方差为1。

array([ 0., 0., 0.])
array([ 1., 1., 1.])
array([[-2.44948974, 1.22474487, -0.26726124]])

----->标准化与归一化的异同？
相同点：都能解决由于量纲不同造成的误差；都是线性变换，都可以理解为对于X按照比例压缩再平移。
不同点：归一化为了压缩到[0,1]，标准化调整整体的整体分布；归一化与最大最小值有关，标准化与均值方差有关。标准化的输出无[0,1]的限制。

----->标准化与归一化的应用场景？
在分类，聚类，降维时，如SVM，KNN，PCA，先使用Z-score标准化一下会更好。
不涉及距离，协方差，不服从正太分布的时候，可以用归一化方法。如将RGB变成灰度图且范围在【0，255】。
树不需要归一化。因为数值缩放对建树没有任何的影响，所以综上一般设计到模型的参数和基于距离，数值的计算时一般都需要归一化。
选用：建议先使用标准化。有其他需要时再考虑归一化或者其他复杂的方法。

• 离散化：把连续的数值型特征进行分段，将落在每一个分段内的数据赋予一个新的统一的符号或数值。可采用相等步长或相等频率等方式进行离散化。
  ----->离散化的优点？
  离散的特征增减都容易，模型迭代快；稀疏内积运算快，方便存储；离散化后鲁棒性强（如对于大于10的范围为A，那么对于异常数据1000000也是没有问题的）；会将缺失值作为独立的一类。
• 二值化：将数值型数据转换为0和1两个值，例如通过设定一个阈值，当特征的值大于该阈值时，转换为1，小于或等于该阈值时转换为0。二值化的目的在于简化数据，有些时候还可以消除数据中的“杂音”，例如图像数据。

from sklearn import preprocessing#使用preprocessing
import numpy as np
X = [[ 1., -1.,  2.],
      [ 2.,  0.,  0.],
      [ 0.,  1., -1.]]
binarizer = preprocessing.Binarizer().fit(X) 
binarizer.transform(X)

binarizer = preprocessing.Binarizer(threshold=1.1)#默认阈值为0
binarizer.transform(X)

修改阈值可以看到：

array(
[[ 1., 0., 1.],
[ 1., 0., 0.],
[ 0., 1., 0.]])
array(
[[ 0., 0., 1.],
[ 1., 0., 0.],
[ 0., 0., 0.]])

• 独热哑编码：One-Hot Encoding，其作用是将特征进行量化。特别是使非偏序关系的变量取值不具有偏序性，即大家到圆点都是等距的，这样会让特征之间的距离计算更加合理。缺点是特征空间会变得非常大，一般会PCA降维或者使用一些嵌入方法。

from sklearn import preprocessing #使用preprocessing
import numpy as np
enc = preprocessing.OneHotEncoder()
enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])  
enc.transform([[0, 1, 3]]).toarray()#自动提取

enc = preprocessing.OneHotEncoder(n_values=[2, 3, 4])#防止丢失值，明确设置value。如此处特征分别有2，3，4个值
enc.fit([[1, 2, 3], [0, 2, 0]])
enc.transform([[1, 0, 0]]).toarray()

#组合数据
x=np.hstack((x1,x2,...))
#如果数据稀疏
x=np.sparse.hstack((x1,x2...))

array([[ 1., 0., 0., 1., 0., 0., 0., 0., 1.]])
array([[ 0., 1., 1., 0., 0., 1., 0., 0., 0.]])

必要的统计变换
主要是利用统计或数学变换来减轻数据分布倾斜的负面影响，使原本密集的区间的值尽可能的分散，或者原本分散的区间的值尽量的聚合。

• log变换，$y=log(x)$，实现：np.log()。它的主要作用在于帮助稳定方差（对于一些连续性数值方差不稳定，用来“平滑”一下），始终保持分布接近于正态分布并使得数据与分布的平均值无关。
• Box-Cox变换，公式的详细推导：Box-Cox。用于连续的响应变量不满足正态分布的情况。Box-Cox变换可以明显地改善数据的正态性、对称性和方差相等性，对许多实际数据都是有效的。

import scipy.stats as spstats
# 由于公式中的前提条件非负，所以首先需要移除非零值
D = np.array(data)
D_clean = income[~np.isnan(D)]
# λ为0时，退化成log。这里先最大似然下最佳值
l, opt_lambda = spstats.boxcox(D_clean)
# 再进行Box-Cox变换
BC = spstats.boxcox(D,lmbda=opt_lambda)

如何进行特征选择？
除了对数据本身的理解和清洗外，特征属性的组合方式对结果同样十分重要。特别是1、并不是所有属性都重要，在实际中往往有大量的属性无用；2、属性间可能存在依赖和重复关系；3、怎样的特征属性组合更好。

首先是对特征的理解方法：

• PCA：寻找表示数据分布的最优子空间，将原始数据降维，并提取不相关的部分。
• LDA：寻找可分性判据最大的子空间。使得降维后类内散度最小，类间散度最大
• ICA：将原始数据降维并提取出相互独立的属性，ICA理论的目标就是通过X求得一个分离矩阵W，使得W作用在X上所获得的信号Y是独立源S的最优逼近。ICA相比与PCA更能刻画变量的随机统计特性，且能抑制高斯噪声。
• CCA，找到两组基，使得两组数据在这两组基上的投影相关性最大，用来描述两个高维变量之间的线性关系
• 互信息法，衡量特征与类别直接的信息量。频率低则互信息得分高，所以倾向于“低频”特征。
• 信息增益法，去除和保留特征前后信息的增加与否，以判断特征的重要程度。
• 卡方检验法，利用统计学中的“假设检验”思想，先假设特征与类别不相关，再计算检验值偏离阈值的大小，偏离越大越有信息否定原假设，即特征与结果的关联度很高。

#PCA
from sklearn.decomposition import PCA
pca=PCA(n_components=2)
x_trans=pca.fit_transform(x)

#SVD
from  sklearn.decomposition import TruncatedSVD
svd=TruncatedSVD(n_features=2)
x_trans=svd.fit_transform(x)

#卡方检验其相关性
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
from sklearn.datasets import load_iris

iris = load_iris()
model = SelectKBest(chi2, k=2)#选择k个最佳特征
model.fit_transform(iris.data, iris.target)#输入特征和标签，选择出k个特征
print(model.scores_)
print(model.pvalues_)#p-values

#皮尔森相关系数
from scipy.stats import pearsonr
model2 = SelectKBest(lambda X, Y: tuple(map(tuple,array(list(map(lambda x:pearsonr(x, Y), X.T))).T)), k=3)#输入特征矩阵和目标向量
model.fit_transform(iris.data, iris.target)

特征组合方法：

• 包裹式：把最终机器学习模型的表现作为特征选择的重要依据，一步步筛选特征（每次增加对模型最有用的或删除最无用的特征）。目前比较常用的一种包裹式特征选择法为递归特征消除法，其原理是使用一个基模型（如：随机森林、逻辑回归等）进行多轮训练，每轮训练结束后，消除若干权值系数较低的特征，再基于新的特征集进行新的一轮训练。
• 过滤式：不依赖具体的机器学习模型，而是先对数据集进行特征选择（每次增加最有信息量的特征或删除最少的），然后再进行模型的训练。常用的过滤式特征选择方法有Pearson相关系数法、方差选择法、假设检验、互信息法等。
• 嵌入式：与包裹式特征选择法最大的不同是，嵌入式方法是将特征选择过程与模型的训练过程结合为一体。
  常用的嵌入式特征选择方法有基于正则化项的特征选择法（如：Lasso）和基于树模型的特征选择法（如：GBDT）。
  高级特征运用加减乘除处理。

#过滤式
from sklearn.feature_selection import VarianceThreshold
 X = [[0, 0, 1], [0, 1, 0], [1, 0, 0], [0, 1, 1], [0, 1, 0], [0, 1, 1]]
model = VarianceThreshold(threshold=(.8 * (1 - .8))) #选择方差大于某个数的特征。
model.fit_transform(X)

#包裹式
from sklearn.feature_selection import RFE
from sklearn.svm import LinearSVC  #选择svm作为评定算法
from sklearn.datasets import load_iris 

iris=load_iris()
x=iris.data
y=iris.target
estimator=LinearSVC()
model=RFE(estimator=estimator,n_features_to_select=2) #选择2个特征
model.fit(x,y)
print(model.n_features_)   #被选出的特征的数量
print(model.support_ )     #被选择特征的mask
print(model.ranking_)      #特征排名，其中被选出特征的排名为1


from sklearn.feature_selection import SelectFromModel
print(x.shape)#(150, 4)
lsvc = LinearSVC(C=0.01, penalty="l1", dual=False).fit(x, y) 
model = SelectFromModel(lsvc, prefit=True)
x_new = model.transform(x)
print(x_new.shape)#(150,3)

#或者使用随机森林
from sklearn.ensemble import RandomForestClassifier
#xgboost
import xgboost as xgb
#对于稀疏数据，很有名的方法是chi2
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2

数据压缩–三大降维法则：
目的：1、可以降低维度、2、图形化做展示；3、对非线性数据的处理方法

• 主成分分析，寻找最佳维度。
• 自编码器，在压缩和解压缩的往复中，除了能过降低维度，还能发现到数据间更深层次的关系。
• t-SNE，适合处理流型数据。
  
  @@@PCA是一种线性算法。 它不能解释特征之间的复杂多项式关系。而t-SNE是基于在邻域图上随机游走的概率分布，可以在数据中找到其局部结构关系，最先出现在流型学习中，算法核心在于它的“距离”度量，即它将数据点之间的相似度转换为概率，以KL散度做评价标准。

import numpy as np
from sklearn.manifold import TSNE
X = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 1]])#简单的三维数据
tsne = TSNE(n_components=2)
tsne.fit_transform(X)
print(tsne.embedding_)

from time import time
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.ticker import NullFormatter
from sklearn import manifold, datasets

n_points = 1000
X, color = datasets.samples_generator.make_s_curve(n_points, random_state=0)
n_neighbors = 10
n_components = 2

ax = fig.add_subplot(211, projection='3d')
ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=color, cmap=plt.cm.Spectral)
ax.view_init(4, -72)  # 自定义3D显示视角

t0 = time()
tsne = manifold.TSNE(n_components=n_components, init='pca', random_state=0)#使用TSNE
Y = tsne.fit_transform(X) 
t1 = time()#计算时间，可以看到号称最好降维技术的TNSE在使用时的最大弊病
print("t-SNE: %.2g sec" % (t1 - t0))  
ax = fig.add_subplot(2, 1, 2)
plt.scatter(Y[:, 0], Y[:, 1], c=color, cmap=plt.cm.Spectral)
plt.title("t-SNE (%.2g sec)" % (t1 - t0))
ax.xaxis.set_major_formatter(NullFormatter()) # 设置标签显示为空
ax.yaxis.set_major_formatter(NullFormatter())

plt.show()

@@@PCA 和 t-SNE 是方法，而自编码器则是一系列的方法（中间层可以自由任我们设置与控制，如神经网络）。

如何评估模型？
通过评估模型来验证结果。

分离数据需要变成train、valid、test，特别是validation data是用来检验模型的表现，以避免模型过拟合（只适合于训练集分布）。万能的sklearn当然可以做到这一点：

#分类问题用
from sklearn.cross_validation import StartifiedKfold
#回归问题用
from sklean.cross_validation import Kfold

• 性能度量：
  正确率，错误率，查全率，查准率，F1
  方差，误差，R平均值。
  ROC曲线
  AUC(ROC曲线下面积)
  Lift(提升)和Gain(增益)
  K-S图
  基尼系数
  
  
  单单凭借准确率有时很难评判模型结果，特别是在正负样例不平衡、甚至差距很大的时候accuracy的评价指标就远远不够了。
  

#快速得到混淆矩阵
from sklearn.metrics import confusion_matrix,classification_report
y_pred=model.predict(X_test)
print(confusion_matrix(y_test,y_pred))
print(classification_report(y_test,y_pred))

最后介绍一个快速高维数据可视化工具 watson: https://www.ibm.com/cloud/watson-studio

比赛技巧

• lable smoothing。在数据不够的情况下用one-hot分类，很容易过拟合。而且交叉熵会倾向把正确和错误之间的差距分得越大越好，但实际上很多类之间是相似的，smoothing就是把hard lable变成soft lable。
• topk-loss。取batch里面topk大的loss均值做回传，可以滤掉一些esay sample，让hard sample发挥作用。
• weighted loss。不同的类别给不同的分类难度的权重，如类别2比较难设大一点，类别1简单就少一点。
• dual pooling。concat max和avg pooling，综合起局部和全局，实践上效果似乎没有那么好。
• margin-based softmax。增加类间的margin，得到更有区分度的feature。
• 多标签分类，分割可以用lovasz loss优化。
• TTA（test time augmentaion），将有效的增强方法多融合再input进去
• 多尺度融合，Ensemble

发现一个trick合集：
https://github.com/Pysamlam/Tips-of-Feature-engineering