建模技巧
本文目录
1.数据预处理
2.特征构建
3.特征选择
4.LightGBM模型构建
5.自动调参方法
一.数据预处理
1.1 离群点处理
Tukey Method:
一种利用数据四分位差的检测方法。通过计算特征的 IQR 四分位差，得到 outlier_step=1.5*IQR，如果值大于(上四分位数+outlier_step)或者小于(下四分位数-outlier_step),就判定这个值为离群点。为减小盲目删除样本后带来的信息损失，设定阈值 n，如果一个样本中出现离群点个数大于 n，我们就可以删除这个样本。
from collections import Counter def detect_outliers(df,n,features): outlier_indices=[] #迭代每一个特征 for col in features: #计算四分位数 Q1=np.percentile(df[col],25) Q3=np.percentile(df[col],75) #计算IQR Interquartile range 四分位差 IQR=Q3-Q1 #Outlier Step outlier_step=1.5*IQR #判断每个特征内的离群点 outlier_index=df[(df[col] > Q3+outlier_step) | (df[col] < Q1-outlier_step)].index outlier_indices.extend(outlier_index) #只有当n个以上的特征出现离群现象时，这个样本点才被判断为离群点 outlier_dict=Counter(outlier_indices) #统计样本点被判断为离群的次数,并返回一个字典 outlier_indices=[k for k,v in outlier_dict.items() if v > n] return outlier_indices outlier_index=detect_outliers(train,2,['Age','SibSp','Parch','Fare']) #删除离群点 train=train.drop(outlier_index,axis=0).reset_index(drop=True)
其他方法:
- EDA:箱型图定性分析,pandas的describe函数定量分析
- 分箱操作(连续特征离散化)
- 近似服从正态分布的特征可以用3sigma原则
- 平均值或中位数替代异常点,简单高效,信息的损失较少
- 优先使用树模型，因为在训练树模型时,树模型对离群点的鲁棒性较高,无信息损失,不影响模型训练效果
1.2 缺失值处理
(1)统计量填充:直接填充出现众数，均值，最值等
对于连续变量
若缺失率较低（小于95%）且重要性较低，则根据数据分布的情况进行填充。
- 对于数据近似符合正态分布，用该变量的均值填补缺失。
- 对于数据存在偏态分布的情况，采用中位数进行填补。
#绘制与目标变量相关的特征分布图 def plotContinuousVar(df,col,TARGET): g=sns.kdeplot(df[col][df[TARGET]==0],color='red') g=sns.kdeplot(df[col][df[TARGET]==1],ax=g,color='green') g.set_xlabel(col) g.set_ylabel('Frequency') g=g.legend(['0','1']) plotContinuousVar(train,'Fare','Survived')
如何区别正态分布和偏态分布，正态分布是对称的，而偏态分布一般是不对称的左偏或者右偏
#通过数据可视化发现,Fare票价特征是偏态分布，故采用中位数填充 train['Fare']=train['Fare'].fillna(train['Fare'].median())
对于离散变量:
- 可以直接把缺失值作为一个属性,例如设置为None,后续用one-hot或者label-encodeing处理。
- 如果缺失少，可以用众数填充
#由于缺失值只有2个，所有选用出现次数最多的值填充 train_data['Embarked']=train_data['Embarked'].fillna('S')
(2)模型填充:将需要填充的缺失特征作为label,其他相关特征用作训练特征
from sklearn.ensemble import RandomForestRegressor #使用随机森林填补age缺失值 def set_missing_ages(df): #把已有的数值型特征取出来丢进随机森林中 num_df=df[['Age','Fare','Parch','SibSp','Pclass','Title']] #把乘客分成已知年龄和未知年龄两部分 know_age=num_df[num_df.Age.notnull()].as_matrix() unknow_age=num_df[num_df.Age.isnull()].as_matrix() #y即目标年龄 y=know_age[:,0] #X即特征属性值 X=know_age[:,1:] rfr=RandomForestRegressor(n_estimators=100,random_state=0,n_jobs=-1) rfr.fit(X,y) #用拟合好的模型来预测 y_pre=rfr.predict(unknow_age[:,1:]) #用得到的预测值来填补原缺失数据 df.loc[(df.Age.isnull()),'Age']=y_pre return df train=set_missing_ages(train)
(3)XGBoost(LightGBM)自动填充缺失值
1.3 one-hot编码:处理分类变量
def one_hot_encoder(df, nan_as_category=True): original_columns = list(df.columns) categorical_columns = [col for col in df.columns if df[col].dtype == 'object'] df = pd.get_dummies(df, columns=categorical_columns, dummy_na=nan_as_category) new_columns = [c for c in df.columns if c not in original_columns] return df, new_columns
1.4 log和box-cox转换
log对数转换主要针对线性模型，让偏态分布的特征转换为近似正态分布，满足模型假设条件。
#注明偏斜度 g=sns.distplot(train['Fare'],color='m',label='skewness:%.2f'%(train['Fare'].skew())) g=g.legend(loc='best')
#用log函数来处理Fare分布函数skewed的情况 train['Fare']=train['Fare'].map(lambda i:np.log(i) if i>0 else 0) g=sns.distplot(train['Fare'],color='m',label='skewness:%.2f'%(train['Fare'].skew())) g=g.legend(loc='best')
Box-Cox 转换：Box 和 Cox 下（1964）提出了一种用一个参数λ进行索引的变换族:
相比 log 转换，这个变换族还包括平方变换，平方根变换，倒数变换已经在此之间的变换。就使用案例来说，Box-Cox 变换更加直接，更少遇到计算问题，而且对于预测变量同样有效。
from scipy.special import boxcox1p lam=0.15 dataset[feat]=boxcox1p(dataset[feat],lam)
二.特征构造
特征构建主要依据业务理解，新构建的特征可以加强对label的预测能力。举个例子，现在有个简单的二分类问题，要求使用逻辑回归训练一个身材分类器。输入数据 X 有身高和体重，标签 Y 则是胖或者不胖。根据经验，我们不能仅仅依靠体重来判断一个人是否胖。对于这个任务，一个非常经典的特征构造是，构造 BMI 指数，BMI=体重/身高的平方。通过 BMI 指数，就能更好地帮助我们刻画一个人的身材信息。这里仅仅总结了一些通用构建思路,具体业务需要具体对待。
2.1 多项式特征(Polynomial Features)
示例:对于特征x,y,其衍生的二阶多项式特征包括,x^2,y^2,xy
通过特征的乘积，引入特征与特征之间的交互作用,从而引入非线性
下面代码以Kaggle Home Credit Default Risk数据集为例，实现具有通用性
#将用来交叉的特征 定义为新的dataframe poly_features=dataset[['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3']] from sklearn.preprocessing import PolynomialFeatures poly_transformer=PolynomialFeatures(degree=3) poly_transformer.fit(poly_features) poly_features=poly_transformer.transform(poly_features) print(poly_features.shape) #(355912, 20) #查看衍生的多项式特征 print('Polynomial feature names:\n{}'.format(poly_transformer.get_feature_names( ['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3']))) #Polynomial feature names: #['1', 'EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3', 'EXT_SOURCE_1^2', 'EXT_SOURCE_1 EXT_SOURCE_2',
'EXT_SOURCE_1 EXT_SOURCE_3', 'EXT_SOURCE_2^2', 'EXT_SOURCE_2 EXT_SOURCE_3', 'EXT_SOURCE_3^2', 'EXT_SOURCE_1^3',
'EXT_SOURCE_1^2 EXT_SOURCE_2', 'EXT_SOURCE_1^2 EXT_SOURCE_3', 'EXT_SOURCE_1 EXT_SOURCE_2^2', 'EXT_SOURCE_1 EXT_SOURCE_2 EXT_SOURCE_3',
'EXT_SOURCE_1 EXT_SOURCE_3^2', 'EXT_SOURCE_2^3', 'EXT_SOURCE_2^2 EXT_SOURCE_3', 'EXT_SOURCE_2 EXT_SOURCE_3^2', 'EXT_SOURCE_3^3']
2.2 统计特征
这里用Kaggle Home Credit Default Risk贷款违约预测比赛的数据集作为例子
申请贷款的客户信息表applicationtrain.csv,原始特征122,本文为了便于展示，只选取其中9个特征。同时，比赛还有其余四个辅助表，这里只取其中的信用卡数据表。其中SK_ID_CURR是在applicationtrain.表唯一的，但在credit_card_balance表是不唯一的，所以需要进行聚合。
表一:客户信息表application_train SK_ID_CURR 客户ID TARGET 标签 0/1 NAME_CONTRACT_TYPE 贷款类型(周转或现金) CODE_GENDER 性别 FLAG_OWN_CAR 是否有车 FLAG_OWN_REALTY 是否有房 CNT_CHILDREN 孩子数量 AMT_INCOME_TOTAL 年收入 AMT_CREDIT 贷款金额 表二:信用卡数据表credit_card_balance SK_ID_CURR 客户ID MONTHS_BALANCE 相对于申请日期而言的余额月份(-1是指最新的余额日期) AMT_BALANCE 上一次贷款月余额 ...
针对不同特征进行不同的统计聚合操作
time_agg={ 'CC_PAID_LATE': ['mean', 'sum'], 'CC_PAID_LATE_WITH_TOLERANCE':['mean', 'sum'], 'AMT_CREDIT_LIMIT_ACTUAL':['mean', 'var','median'], 'AMT_LAST_DEBT':['mean','var'], 'DRAWINGS_ATM_RATIO':['mean','var','max','min','median'], 'DRAWINGS_POS_RATIO':['mean','var','max','min','median'], 'RECEIVABLE_PAYMENT_RATIO':['mean','var','max','min','median'], 'AMT_PAYMENT_TOTAL_CURRENT':['mean','var','median'], 'AMT_INST_MIN_REGULARITY':['mean','median'], 'CNT_INSTALMENT_MATURE_CUM':['max'], 'AMT_DRAWINGS_POS_CURRENT':['mean'] } cc_agg = cc.groupby('SK_ID_CURR').agg(time_agg) #重命名 cc_agg.columns = pd.Index(['CC_' + e[0] + '_' + e[1].upper() +'_'+'75' for e in cc_agg.columns.tolist()])
2.3 时间特征:将秒转化为分钟和小时
#时间特征处理 timedelta = pd.to_timedelta(df['Time'], unit='s') df['Minute'] = (timedelta.dt.components.minutes).astype(int) df['Hour'] = (timedelta.dt.components.hours).astype(int)
2.4 频率特征:针对特征值数较多的离散特征，反应特征值频数分布
def frequence_encoding(df, feature): #计算 特征值频数 / 总样本数 freq_dict = dict(df[feature].value_counts() / df.shape[0]) new_feature = feature + '_freq' df[new_feature] = df[feature].map(freq_dict) return df
三.特征选择
特征选择的方法有方差选择，皮尔逊相关系数，互信息，正则化等。由于树模型的广泛使用，基于树模型的特征重要性排序是一种高效常用的方法。然而模型得到的特征重要性存在一定的偏差，这些往往对特征选择产生干扰。这里介绍Kaggle中有人用过的一种特征选择方法-PIMP算法(Permutation Importance)，它的主要思想是修正已有的特征重要性。具体算法描述如下:
1.打乱标签的排序，得到新的训练集，重新训练并评估特征重要性。
2.重复第一步n次，得到每个特征进行多次评估的特征重要性集合，我们称之为thenull importance.
3.计算标签真实排序时，模型训练得到的特征重要性。
4.利用第二步得到的集合，对每个特征计算修正得分。
5.修正规则如下:Corrected_gain_score=100*
(null_importance_gain<np.percentile(actual_imp,25)).sum()/null_importance.size()
def get_feature_importance(data,shuffle,seed=None): #获取有用的特征 删除target和一些id trian_features=[f for f in data if f not in ['TARGET','SK_ID_CURR']] #shuffle y=data['TARGET'].copy() if shuffle: y=data['TARGET'].copy().sample(frac=1.0) #随机抽样 dtrain=lgb.Dataset(data[train_features],y,free_raw_data=False,silent=True) lgb_params={ 'objective':'binary', 'boosting_type':'rf', 'subsample':0.623, 'colsample_bytree':0.7, 'num_leaves':127, 'max_depth':8, 'seed':seed, 'bagging_freq':1, 'n_jobs':4 } clf=lgb.train(params=lgb_params,train_set=dtrain,num_boost_round=200,categorical_feature=categorical_feats) imp_df=pd.DataFrame() imp_df['feature']=list(train_features) imp_df['importance_gain']=clf.feature_importance(importance_type='gain') imp_df['train_score']=roc_auc_score(y,clf.predict(data[train_features])) return imp_df #获取真实目标排序的feature_importance actual_imp_df=get_feature_importance(data=data,shuffle=False) #获取n次打乱target后的feature_importance null_imp_df=pd.DataFrame() nb_runs=30 #打乱运行的次数 for i in range(nb_runs): imp_df=get_feature_importance(data=data,shuffle=True) imp_df['run']=i+1 null_imp_df=pd.concat([null_imp_df,imp_df],axis=0) #计算修正后的feature_scores feature_scores=[] for feature in actual_imp_df['feature'].unique(): f_null_imps_gain=null_imp_df.loc[null_imp_df['feature']==feature,'importance_gain'].values f_act_imps_gain=actual_imp_df.loc[actual_imp_df['feature']==feature,'importance_gain'].values.mean() corrected_gain_score=np.log(1e-10+f_act_imps_gain/(1+np.percentile(f_null_imps_gain,75))) feature_scores.append((feature,corrected_gain_score)) #用不同的阈值来筛选特征 for threshold in [0,10,20,30,40,50,60,70,80,90,95,99]: gain_feats=[feature for feature,score in feature_scores if score>=threshold]
四.LightGBM模型构建
#以Kaggle Home Credit Default Risk数据集为例，代码实现具有通用性 def kfold_lightgbm(df, num_folds, stratified=False, debug=False): train_df = df[df['TARGET'].notnull()] test_df = df[df['TARGET'].isnull()] print("Starting LightGBM. Train shape: {}, test shape: {}".format(train_df.shape, test_df.shape)) del df gc.collect() if stratified: folds = StratifiedKFold(n_splits=num_folds, shuffle=True, random_state=1001) else: folds = KFold(n_splits=num_folds, shuffle=True, random_state=1001) oof_preds = np.zeros(train_df.shape[0]) sub_preds = np.zeros(test_df.shape[0]) feature_importance_df = pd.DataFrame() #删除label或者id型数据 feats = [f for f in train_df.columns if f not in ['TARGET', 'SK_ID_CURR', 'SK_ID_BUREAU', 'SK_ID_PREV', 'index']] #五折交叉验证 for n_fold, (train_idx, valid_idx) in enumerate(folds.split(train_df[feats], train_df['TARGET'])): dtrain = lgb.Dataset(data=train_df[feats].iloc[train_idx], label=train_df['TARGET'].iloc[train_idx], free_raw_data=False, silent=True) dvalid = lgb.Dataset(data=train_df[feats].iloc[valid_idx], label=train_df['TARGET'].iloc[valid_idx], free_raw_data=False, silent=True) # LightGBM parameters found by Bayesian optimization params = { 'objective': 'binary', 'boosting_type': 'gbdt', 'nthread': 4, 'learning_rate': 0.02, # 02, 'num_leaves': 20, 'colsample_bytree': 0.9497036, 'subsample': 0.8715623, 'subsample_freq': 1, 'max_depth': 8, 'reg_alpha': 0.041545473, 'reg_lambda': 0.0735294, 'min_split_gain': 0.0222415, 'min_child_weight': 60, # 39.3259775, 'seed': 0, 'verbose': -1, 'metric': 'auc', } clf = lgb.train( params=params, train_set=dtrain, num_boost_round=13000, valid_sets=[dtrain, dvalid], early_stopping_rounds=200, verbose_eval=False ) oof_preds[valid_idx] = clf.predict(dvalid.data) sub_preds += clf.predict(test_df[feats]) / folds.n_splits fold_importance_df = pd.DataFrame() fold_importance_df["feature"] = feats fold_importance_df["importance"] = clf.feature_importance(importance_type='gain') fold_importance_df["importance"] = clf.feature_importance(importance_type='gain') fold_importance_df["fold"] = n_fold + 1 feature_importance_df = pd.concat([feature_importance_df, fold_importance_df], axis=0) print('Fold %2d AUC : %.6f' % (n_fold + 1, roc_auc_score(dvalid.label, oof_preds[valid_idx]))) del clf, dtrain, dvalid gc.collect() print('Full AUC score %.6f' % roc_auc_score(train_df['TARGET'], oof_preds)) #输出测试集预测结果，同时绘制特征重要性图 if not debug: sub_df = test_df[['SK_ID_CURR']].copy() sub_df['TARGET'] = sub_preds sub_df[['SK_ID_CURR', 'TARGET']].to_csv(submission_file_name, index=False) display_importances(feature_importance_df) feature_importance_df= feature_importance_df.groupby('feature')['importance'].mean().reset_index().rename(index=str,columns={'importance':'importance_mean'}) feature_importance_df.to_csv('feature_importance.csv') print(feature_importance_df.sort_values('importance_mean',ascending=False)[500:]) return feature_importance_df #绘制特征重要性图函数 def display_importances(feature_importance_df_): cols = feature_importance_df_[["feature", "importance"]].groupby("feature").mean().sort_values(by="importance",ascending=False)[:40].index best_features = feature_importance_df_.loc[feature_importance_df_.feature.isin(cols)] plt.figure(figsize=(8, 10)) sns.barplot(x="importance", y="feature", data=best_features.sort_values(by="importance", ascending=False)) plt.title('LightGBM Features (avg over folds)') plt.tight_layout() plt.savefig('lgbm_importances01.png')
五.自动调参方法
5.1 网格搜索:穷举参数的所有组合，选择最优解
from sklearn.tree import DecisionTreeClassifier from sklearn.model_selection import GridSearchCV, cross_val_score, StratifiedKFold, learning_curve kfold = StratifiedKFold(n_splits=10) tree=DecisionTreeClassifier(random_state=0) tree_param_grid={ 'max_depth':[7,8,9,11,12,13,14], 'min_samples_leaf':[2,3,4,5,6,7,8,9], 'min_samples_split':[2,3,4,5,6,7,8,9] } tree_grid_search=GridSearchCV(tree,param_grid=tree_param_grid,cv=kfold,scoring='accuracy',n_jobs=-1) tree_grid_search.fit(X_train,y_train) print('Best parameters:{}'.format(tree_grid_search.best_params_)) #Best parameters:{'max_depth': 7, 'min_samples_leaf': 2, 'min_samples_split': 2} print('Best cv score:{}'.format(tree_grid_search.best_score_)) #Best cv score:0.8149829738933031 print('Accuracy training set:{}'.format(tree_grid_search.score(X_train,y_train))) #Accuracy training set:0.8683314415437003
5.2 贝叶斯优化
相比网格搜索会穷举所有可能结果,贝叶斯调参考虑了之前的参数信息,不断调整当前参数
#feats是df中用于训练的有效特征 def kfold_lightgbm(train_df,feats,params): oof_preds = np.zeros(train_df.shape[0]) for n_fold, (train_idx, valid_idx) in enumerate(folds.split(train_df[feats], train_df['Class'])): dtrain = lgb.Dataset(data=train_df[feats].iloc[train_idx], label=train_df['Class'].iloc[train_idx], free_raw_data=False, silent=True) dvalid = lgb.Dataset(data=train_df[feats].iloc[valid_idx], label=train_df['Class'].iloc[valid_idx], free_raw_data=False, silent=True) clf = lgb.train( params=params, train_set=dtrain, num_boost_round=1000, valid_sets=[dtrain, dvalid], early_stopping_rounds=20, feval=average_precision_score_vali, verbose_eval=False ) oof_preds[valid_idx] = clf.predict(dvalid.data) del clf, dtrain, dvalid gc.collect() return average_precision_score(train_df['Class'], oof_preds) #objective function def lgb_objective(params,n_folds=5): loss = -kfold_lightgbm(params) return {'loss':-loss,'params':params,'status':STATUS_OK} #定义搜索空间 space = { 'objective':'regression', 'boosting_type': 'gbdt', 'subsample':0.8, 'colsample_bytree':hp.uniform('colsample_bytree',0.8,0.9), 'max_depth':7, 'learning_rate':0.01, "lambda_l1":hp.uniform('lambda_l1',0.0,0.2), 'seed':0, } #定义优化算法 tpe_algorithm = tpe.suggest best = fmin(fn = lgb_objective,space = space,algo=tpe_algorithm,max_evals=50) print(best) result=space_eval(space, best) print(space_eval(space, best))
