建模技巧

本文目录

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:
{}'.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))