数据分析业务场景|用户画像

for col in log_features:data[col] = data[col].map(lambda x: np.log(x))

4. 特征工程

def get_count(df,column,feature):df[&＃39;idx&＃39;] = range(len(df))temp = df.groupby(column)[&＃39;userr_id&＃39;].agg([(feature,&＃39;count&＃39;)]).reset_index()df = df.merge(temp)df = df.sort_values(&＃39;idx&＃39;).drop(&＃39;idx&＃39;,axis=1).reset_index(drop=True)return dfdata[&＃39;age&＃39;] = data[&＃39;age&＃39;].apply(lambda x:np.nan if (x > 100) | (x == 0) else x)
data[&＃39;all_fee-average_consumption_value&＃39;] = data[&＃39;all_fee&＃39;] - data[&＃39;average_consumption_value&＃39;]
data = get_count(data,&＃39;all_fee&＃39;,&＃39;count_all_fee&＃39;)
...
data[&＃39;user_network_age_diff&＃39;] = data.apply(lambda x: x.user_network_age % 12,axis=1)

构建训练集和测试集

train = data[:train.shape[0]]
test = data[train.shape[0]:]

5. 特征选择：方差选择法

删除方差低于某一阈值的特征（因为它们可能包含很少信息），选择一个方差高于给定阈值的特征子集

方差阈值是手动选择的，所以必须自己判断选择一个好的阈值，如果没有太大把握就把阈值设置得小一点。不同数据尺度或者单位的数据可能对应的方差尺度也不一样，在设置阈值的时候要慎重

from sklearn.feature_selection import VarianceThreshold
#threshold传入参数格式为：最小容忍比例 * (1 - 最小容忍比例)
#这里的容忍比例就是当离散样本中最多的那一类数量占全体数量的上限
#0.8*(1-0.8)：对所有变量中最大比例样本对应的比例大于等于80%的变量予以剔除
#初始化低方差特征选择模型
sel = VarianceThreshold(threshold=0.8*(1-0.8))
sel.fit_transform(data)

6. 构建模型

在结构化比赛中，机器学习常用的模型有lightgbm，xgboost，catboost等模型，算法速度快且能够容纳缺失值，stacking通过结合多个各有所长的子学习器，提升了整体的预测能力。一个基本的理论假设是，不同的子模型在不同数据上有不同的表达能力，我们可以结合它们擅长的部分，得到一个在各方面都很准确的模型

调参过程：以XGBoost为例

调参思路：逐个或逐类参数调整，避免所有参数一起调整导致模型复杂度过高。因此，调参过程分多步进行，每次调整相同类型的参数。

模型调参过程会输出每个组合的平均得分值，根据GridSearchCV参数指定使用roc_auc为评分指标，进行cv=5的5折交叉验证，返回的平均得分即为5折交叉验证auc值的平均值，调用调参函数进行调参，根据设定会打印调参信息并画图辅助判断

&＃39;&＃39;&＃39;
sklearn提供了调参利器：sklearn.model_selection.GridSearchCV，对估计器的指定参数值进行穷举搜索
estimator：学习器
param_grid：待调整的参数，字典形式
scoring：评估标准(&＃39;roc_auc&＃39;,&＃39;accuracy&＃39;,&＃39;f1&＃39;等)
cv：确定交叉验证分割策略，默认5折交叉验证，也可使用分层k折，重复k折等
&＃39;&＃39;&＃39;
class sklearn.model_selection.GridSearchCV(estimator,param_grid,scoring=None,cv=None)

①设置初始参数值，并选择较高的学习率，设置在0.05~0.3，这样可以减少迭代用时，获得最佳学习器个数（用xgboost.cv函数获取）

&＃39;&＃39;&＃39;
params：dict，学习器的参数
dtrain：DMatrix，训练集，DMatrix是xgboost使用的一种内部数据结构，它对内存效率和训练速度进行了优化
num_boost_round：int，学习器的个数
folds，metrics：同gridsearchcv的cv参数，scoring参数
early_stopping_rounds：int，停止迭代轮数，比如等于50，则表示如果精度在某一轮后五十轮仍未提升，则停止迭代
&＃39;&＃39;&＃39;
xgboost.cv(params,dtrain,num_boost_round=10,nfold=3,stratified=False,folds=None,early_stopping_rounds=None)

②然后对max_depth，min_child_weight，gamma，subsample，colsample_bytree这些参数进行调整

先调整max_depth和min_child_weight，这两个参数对输出结果影响很大，首先将它们设置为较大的数，然后通过迭代的方式不断修正，缩小范围：GridSearchCV

然后基于上面确定好的最优值来调整gamma值

max_depth：[3,5,6,7,9,12,15,17,25]

min_child_weight：[1,3,5,7]

gamma：[0.005~0.1,0.3,0.5,0.7,0.9,1]

subsample：[0.6,0.7,0.8,0.9,1]

colsample_bytree：[0.6,0.7,0.8,0.9,1]

③调整正则化参数lambda，alpha

用的比较少，主要是为了减少模型复杂度和提高运行速度，适当减少过拟合

alpha：[0,0.01~0.1,1]

lambda：[0,0.1,0.5,1]

④降低学习率，较多学习器，使用xgboost.cv获取最佳学习器个数，继续调整参数

eta：[0.01,0.015,0.025,0.05,0.1]

xgb_param = {&＃39;eta&＃39;:0.01,&＃39;max_depth&＃39;:6,&＃39;subsample&＃39;:0.8,&＃39;colsample_bytree&＃39;:0.7,&＃39;objective&＃39;:&＃39;reg:linear&＃39;,&＃39;eval_metric&＃39;:&＃39;rmse&＃39;,&＃39;silent&＃39;:True,&＃39;nthread&＃39;:4,&＃39;n_estimators&＃39;:20000,&＃39;gamma&＃39;:0.2,&＃39;min_child_weight&＃39;:25,&＃39;num_threads&＃39;:8,&＃39;alpha&＃39;:0.18,&＃39;lambda&＃39;:0.23,&＃39;colsample_bylevel&＃39;:0.8,} gsearch = GridSearchCV(xgb_param,param_grid=parameters,scoring=&＃39;accuracy&＃39;,cv=3)
gsearch.fit(train_x,train_y)
best_parameters = gsearch.best_estimator_.get_params()
for param_name in sorted(parameters.keys()):print("\t%s:%r" % (param_name,best_parameters[param_name]))&＃39;&＃39;&＃39;
eta:学习率，可以缩减每一步的权重值，使得模型更加健壮，典型值一般设置为0.01~0.2
max_depth:值越大，树越复杂，可以用来控制过拟合，典型值是3~10
subsample:采样率，训练实例的子样本比率，将其设置为0.5意味着xgboost将在种植树木之前随机抽样一般的训练数据。这将防止过度安装。每一次提升迭代中都会进行一次子采样
colsample_bytree:构造每棵树时，列采样率，一般是特征采样率；用于列的子采样的参数，用来控制每棵树随机采样的列数的占比，有利于满足多样性要求，避免过拟合
objective:指定学习目标是分类，多分类还是回归
eval_metric:评估方法，主要用来验证数据，根据一个学习目标会默认分配一个评估指标
silent:设置模型是否有logo打印
gamma:在树的叶子节点上进行进一步分区所需的最小损失下降的大小，一般来说需要根据损失函数来调整，gamma越大，算法越保守
min_child_weight:如果树分区步骤导致叶节点的实例权重之和小于min_child_weight,构建过程将放弃进一步的分区，最小子权重越大，模型越保守；定义了一个子集所有观察值的最小权重和，可以用来减少过拟合，但是过高的值也会导致欠拟合，因此可以通过cv来调整
alpha:L1关于权重的正则化项，主要是用在数据维度很高的情况下，可以提高运行速度，增加该值将使模型更加保守
lambda:关于权重的L2正则化项，用的很少，增加该值将使模型更加保守
learning_rate:一般这时候要调小学习率来测试，学习率越小训练速度越慢，模型可靠性越高，但并非越小越好
colsample_bylevel:每执行一次分裂，列采样率，一般很少用&＃39;&＃39;&＃39;

7. 交叉验证

首先将全部样本划分成k个大小相等的样本子集

依次遍历这k个子集，每次把当前子集作为验证集，其余所有样本作为训练集，进行模型的训练和评估

将上一步对可能的 k 种选择重复进行，这样就训练了k个模型，每个模型都在相应的测试集上计算测试误差，得到了k个测试误差

最后把k次测试误差的平均值得到一个交叉验证误差作为最终的评估指标

folds_1 = Kfold(n_split=5,shuffle=True,random_state=2022)
oof_xgb = np.zeros(len(train))
prediction_xgb = np.zeros(len(test))for fold_,(trn_idx,val_idx) in enumerate(fold_1.split(X_train,y_train):trn_data = xgb.DMatrix(X_train[trn_idx],y_train[trn_idx])val_data = xgb.DMatrix(X_train[val_idx],y_train[val_idx])watchlist = [(trn_data,&＃39;train&＃39;),(val_data,&＃39;valid&＃39;)]clf = xgb.train(dtrain=trn_data,num_boost_round=20000,evals=watchlist,early_stopping_round=200,verbose_eval=100,params=xgb_params)oof_xgb[val_idx] = clf.predict(xgb.DMatrix(X_train[val)idx]),ntree_limit=clf.best_ntree_limit)predictions_xgb += clf.predict(xgb.DMatrix(X_test),ntree_limit=clf.best_ntree_limit)/fold_1.n_split

8. 模型融合：stacking

两层堆叠，在不同模型预测结果的基础上再加一层模型，进行再训练，从而得到模型最终的预测

stacking结合了多个不同种类的学习器进行训练，能够有效地降低方差，结合了多层进行训练，从而降低偏差

stacking算法分为2层，第一层是用不同的算法形成n个弱分类器，同时产生一个与原数据集大小相同的新数据集，利用这个新数据集和一个新算法构成第二层的分类器

注意点

①第一层基模型最好是强模型，而第二层的基模型可以放一个简单的分类器，防止过拟合

②第一层基模型的个数不能太小，因为一层模型个数等于第二层分类器的特征维度，当然这个值也不是越多越好

③第一层的基模型必须准而不同，如果有一个性能很差的模型出现在第一层，将会严重影响整个模型融合的效果

有时这样对于如果训练集和测试集分布不那么一致的情况下是有一点问题的，其问题在于用初始模型训练的标签再利用真实标签进行再训练，会导致一定的模型过拟合，这样或许模型在测试集上的泛化能力或效果会有一定的下降

那么，如何降低再训练的过拟合性呢？

①次级模型尽量选择简单的线性模型

②利用 k 折交叉验证

stacking配合GridSearchCV实现超参数的调整，如果想要更好地搜索参数，可以使用贝叶斯搜索参数或者随机参数搜索法对参数进行搜索

train_stack = np.vstack([oof_lgb,oof_lgb1,oof_xgb,oof_cat]).transpose()
test_stack = np.vstack([predictions_lgb,predictions_lgb1,predictions_xgb,predictions_cat]).transpose()
#StratifiedKFold用法类似Kfold，但它是分层采样，确保训练集，测试集中各类别样本的比例与原始数据相同
folds_stack = StratifiedKFold(n_splits=10,shuffle=True,random_state=8888)
oof_stack = np.zeros(train_stack.shape[0])
predictiOns= np.zeros(test_stack.shape[0])#对于每个模型，使用交叉验证的方法来训练初级学习器，并且得到次级训练集
for fold_,(trn_idx,val_idx) in enumerate(folds_stack.split(train_stack,y_train)):trn_data,trn_y = train_stack[trn_idx],y_train[trn_idx]val_data,val_y = train_stack[val_idx],y_train[val_idx]stacking = HuberRegressor(epsilon=1.03,alpha=1e-5)#使用次级训练集来训练次级学习器#在fit方法中，我们已经将训练出来的初级学习器和次级学习器保存下来了 stacking.fit(trn_data,trn_y)oof_stack[val_idx] = stacking.predict(val_data)#predict的时候只需要用这些学习器构造次级预测数据集并且进行预测就可以了predictions += stacking.predict(test_stack) / folds_stack.n_splitsprint("stacking MAE score:{:<8.8f}".format(mean_absolute_error(oof_stack,y_train)))
print("stacking CV score:{:<8.8f}".format(1/(mean_absolute_error(oof_stack,y_train)+1)))result[&＃39;score&＃39;] = predictions