用户贷款风险预测—特征提取

本次竞赛提供的数据源一共有五个，依次做特征提取

一、信用卡账单特征提取

1、基本思路：将数据分成时间已知时间未知两部分，时间已知中再分成放款前的数据和放款后的数据，放款前放款后的再分成去重的数据和不去重数据，最终对数据做sum，count，mean，max，min，median，std等指标

#处理数据函数
def 信用卡账单特征提取(data,feature,name):
    '''
    1、传入的数据data
    2、用于合并输出的feature
    3、用于更改命名的name
    '''
    columns_list = ['上期账单金额','上期还款金额','信用卡额度','本期账单余额','本期账单最低还款额','消费笔数',
                    '本期账单金额','调整金额','循环利息','可用余额','预借现金额度','还款状态']
    for math_methor in ['sum','mean','max','count','min','std','var']:
        temp = data.groupby('用户ID',as_index=False)[columns_list].agg(math_methor)
        temp.columns = ['用户ID'] + [name + x + math_methor for x in temp.columns[1:]]
        feature = pd.merge(feature,temp,how='left')
    return feature

时间已知放款前未去重 = 训练信用卡账单表[训练信用卡账单表['时间']>0 & (训练信用卡账单表['时间'] <= 训练信用卡账单表['放款时间'])]
时间已知放款前已去重 = 训练信用卡账单表[训练信用卡账单表['时间']>0 & (训练信用卡账单表['时间'] <= 训练信用卡账单表['放款时间'])].groupby(['用户ID','时间','银行ID'],as_index = False).max()
时间已知放款后未去重 = 训练信用卡账单表[训练信用卡账单表['时间']>0 & (训练信用卡账单表['时间'] <  训练信用卡账单表['放款时间'])]
时间已知放款后已去重 = 训练信用卡账单表[训练信用卡账单表['时间']>0 & (训练信用卡账单表['时间'] <  训练信用卡账单表['放款时间'])].groupby(['用户ID','时间','银行ID'],as_index = False).max()
时间未知未去重 = 训练信用卡账单表[训练信用卡账单表['时间']==0]
时间未知已去重 = 训练信用卡账单表[训练信用卡账单表['时间']==0].groupby(['用户ID','时间','银行ID'],as_index = False).max()
所有数据未去重 = 训练信用卡账单表
所有数据已去重 = 训练信用卡账单表.groupby(['用户ID','时间','银行ID'],as_index = False).max()

feature = 训练放款时间表
feature = 信用卡账单特征提取(时间已知放款前未去重,feature,name = '时间已知放款前未去重')
feature = 信用卡账单特征提取(时间已知放款前已去重,feature,name = '时间已知放款前已去重')
feature = 信用卡账单特征提取(时间已知放款后未去重,feature,name = '时间已知放款后未去重')
feature = 信用卡账单特征提取(时间已知放款后已去重,feature,name = '时间已知放款后已去重')
feature = 信用卡账单特征提取(时间未知未去重,feature,name = '时间未知未去重')
feature = 信用卡账单特征提取(时间未知已去重,feature,name = '时间未知已去重')
feature = 信用卡账单特征提取(所有数据未去重,feature,name = '所有数据未去重')
feature = 信用卡账单特征提取(所有数据已去重,feature,name = '所有数据已去重')

feature.to_csv('信用卡账单特征1.csv')

通过上面的处理，一共得到了674个特征

2、统计上期账单金额和上期还款金额的累计总额，和为零或者为负的个数

def 账单还款金额(data,col,feature):
    temp = data.groupby('用户ID',as_index = False)[col]
    x1 = temp.apply(lambda x : x.where(x<0).count())
    x2 = temp.apply(lambda x : x.where (x==0).count())
    x3 = temp.agg({col+'sum':np.sum})
    x3[col+'小于零'] = x1
    x3[col+'等于零'] = x2
    feature = pd.merge(feature,x3,how='left')
    return feature

feature1 = 训练放款时间表
放款前数据 = 训练信用卡账单表[训练信用卡账单表['时间'] <= 训练信用卡账单表['放款时间']]
feature1 = 账单还款金额(放款前数据,'上期账单金额',feature1)
feature1 = 账单还款金额(放款前数据,'上期还款金额',feature1)
feature1['放款前账单差额'] =  feature1['上期账单金额sum'] - feature1['上期还款金额sum']
feature1.shape

feature2 = 训练放款时间表
放款后数据 = 训练信用卡账单表[训练信用卡账单表['时间'] >  训练信用卡账单表['放款时间']]
feature2 = 账单还款金额(放款后数据,'上期账单金额',feature2)
feature2 = 账单还款金额(放款后数据,'上期还款金额',feature2)
feature2['放款前账单差额'] =  feature2['上期账单金额sum'] - feature2['上期还款金额sum']
feature2.shape

feature = pd.merge(feature1,feature2,on=['用户ID','放款时间'],suffixes=('放款前','放款后'))
feature.head()

3、统计放款前放款后的账单总额，最大值等信息

#删除上期账单和上期还款金额小于0的数据
d = 训练信用卡账单表
d1 = d[d['上期账单金额']<=0].index.tolist()
d.drop(d1,axis=0,inplace=True)
d2 = d[d['上期还款金额']<=0].index.tolist()
d.drop(d2,axis=0,inplace=True)
d.shape

#放款前数据提取特征
data = d[d['时间'] <= d['放款时间']]
gb = data.groupby(['用户ID','时间','银行ID'],as_index=False)
x1 = gb['上期账单金额'].agg({'放款前该银行上期账单金额总额':np.sum,'放款前该银行上期账单金额最大值':np.max})
x2 = gb['上期还款金额'].agg({'放款前该银行上期还款金额总额':np.sum,'放款前该银行上期还款金额最大值':np.max})
x3 = gb['循环利息'].agg({'放款前循环利息最大值':np.max})
x4 = gb['消费笔数'].agg({'放款前消费笔数最大值':np.max})

gb1 = x1.groupby('用户ID',as_index=False)
gb2 = x2.groupby('用户ID',as_index=False)
gb3 = x3.groupby('用户ID',as_index=False)
gb4 = x4.groupby('用户ID',as_index=False)

x11 = gb1['放款前该银行上期账单金额总额'].agg({'放款前该银行上期账单金额汇总':np.sum,'放款前该银行上期账单金额计数':np.size})
x12 = gb1['放款前该银行上期账单金额最大值'].agg({'放款前该银行上期账单金额最大值汇总':np.sum})

x21 = gb2['放款前该银行上期还款金额总额'].agg({'放款前该银行上期还款金额汇总':np.sum,'放款前该银行上期还款金额计数':np.size})
x22 = gb2['放款前该银行上期还款金额最大值'].agg({'放款前该银行上期还款金额最大值汇总':np.sum})

x31 = gb3['放款前循环利息最大值'].agg({'放款前循环利息最大值汇总':np.sum})
x41 = gb4['放款前消费笔数最大值'].agg({'放款前消费笔数最大值汇总':np.sum})

feature = pd.merge(feature,x11,on='用户ID',how='left')
feature = pd.merge(feature,x12,on='用户ID',how='left')
feature = pd.merge(feature,x21,on='用户ID',how='left')
feature = pd.merge(feature,x22,on='用户ID',how='left')
feature = pd.merge(feature,x31,on='用户ID',how='left')


#放款后数据提取特征
data = d[d['时间'] > d['放款时间']]
gb = data.groupby(['用户ID','时间','银行ID'],as_index=False)
x1 = gb['上期账单金额'].agg({'放款后该银行上期账单金额总额':np.sum,'放款后该银行上期账单金额最大值':np.max})
x2 = gb['上期还款金额'].agg({'放款后该银行上期还款金额总额':np.sum,'放款后该银行上期还款金额最大值':np.max})
x3 = gb['循环利息'].agg({'放款后循环利息最大值':np.max})
x4 = gb['消费笔数'].agg({'放款后消费笔数最大值':np.max})

gb1 = x1.groupby('用户ID',as_index=False)
gb2 = x2.groupby('用户ID',as_index=False)
gb3 = x3.groupby('用户ID',as_index=False)
gb4 = x4.groupby('用户ID',as_index=False)

x11 = gb1['放款后该银行上期账单金额总额'].agg({'放款后该银行上期账单金额汇总':np.sum,'放款后该银行上期账单金额计数':np.size})
x12 = gb1['放款后该银行上期账单金额最大值'].agg({'放款后该银行上期账单金额最大值汇总':np.sum})

x21 = gb2['放款后该银行上期还款金额总额'].agg({'放款后该银行上期还款金额汇总':np.sum,'放款后该银行上期还款金额计数':np.size})
x22 = gb2['放款后该银行上期还款金额最大值'].agg({'放款后该银行上期还款金额最大值汇总':np.sum})

x31 = gb3['放款后循环利息最大值'].agg({'放款后循环利息最大值汇总':np.sum})
x41 = gb4['放款后消费笔数最大值'].agg({'放款后消费笔数最大值汇总':np.sum})

feature = pd.merge(feature,x11,on='用户ID',how='left')
feature = pd.merge(feature,x12,on='用户ID',how='left')
feature = pd.merge(feature,x21,on='用户ID',how='left')
feature = pd.merge(feature,x22,on='用户ID',how='left')
feature = pd.merge(feature,x31,on='用户ID',how='left')
feature = pd.merge(feature,x41,on='用户ID',how='left')

 4、总体的爆卡次数和持卡数特征

#刷爆次数
d = 训练信用卡账单表
gb = d[d['信用卡额度']<d['本期账单余额']].groupby('用户ID',as_index=False)
x1 = gb['时间'].apply(lambda x : np.unique(x).size)
x2 = gb['时间'].agg({'爆卡次数':np.size})
x2['去重爆卡次数'] = x1
feature = pd.merge(feature,x2,on='用户ID',how='left')
#银行持卡数
gb = d.groupby('用户ID',as_index=False)
x1 = gb['银行ID'].apply(lambda x : np.unique(x).size)
x2 = gb['银行ID'].agg({'持卡数':np.size})
x2['去重持卡数'] = x1
feature = pd.merge(feature,x2,on='用户ID',how='left')

 

5、参考老段子特征

#参考老段子的特征
d=训练信用卡账单表

#老段子的特征...神了个奇
t1=d[(d['时间']>d['放款时间'])].groupby("用户ID",as_index=False)
t2=d[(d['时间']>d['放款时间']+1)].groupby("用户ID",as_index=False)
t3=d[(d['时间']>d['放款时间']+2)].groupby("用户ID",as_index=False)

x=t1['时间'].apply(lambda x:np.unique(x).size)
x1=t1['时间'].agg({'老段子特征1' : 'count'})
x1['x1']=x

x=t2['时间'].apply(lambda x:np.unique(x).size)
x2=t2['时间'].agg({'老段子特征2' : 'count'})
x2['x2']=x

x=t3['时间'].apply(lambda x:np.unique(x).size)
x3=t3['时间'].agg({'老段子特征3' : 'count'})
x3['x3']=x

t=feature[['用户ID']]
t=pd.merge(t,x1,how='left',on = "用户ID")
t=pd.merge(t,x2,how='left',on = "用户ID")
t=pd.merge(t,x3,how='left',on = "用户ID")
t=t[['用户ID','x1','x2','x3','老段子特征1','老段子特征2','老段子特征3']]

feature=pd.merge(feature, t,how='left', on = "用户ID")

feature['老段子特征x']=(feature['x1']+1)*(feature['x2']+1)*(feature['x3']+1)

 

最后信用卡账单的特征全部结束，一共输出674+42个特征

 

二、银行流水记录特征提取

训练银行流水记录表 = pd.read_csv('train/bank_detail_train.txt',names = ['用户ID','时间戳','交易类型','交易金额','工资收入标记'])
训练银行流水记录表['时间戳'] = 训练银行流水记录表['时间戳']//86400
训练放款时间表 = pd.read_csv('train/loan_time_train.txt',names=['用户ID','放款时间'])
训练放款时间表['放款时间'] = 训练放款时间表['放款时间'] //86400
训练放款时间表.head()
训练银行流水记录表 = pd.merge(训练银行流水记录表,训练放款时间表,on='用户ID')
训练银行流水记录表.head()

#
feature = 训练放款时间表
d = 训练银行流水记录表
#==========================放款前==========================
gb1 = d[(d['时间戳'] <= d['放款时间']) &d['交易类型']==0].groupby('用户ID',as_index=False)     #收入
gb2 = d[(d['时间戳'] <= d['放款时间']) &d['交易类型']==1].groupby('用户ID',as_index=False)     #支出
gb3 = d[(d['时间戳'] <= d['放款时间']) &d['工资收入标记']==1].groupby('用户ID',as_index=False)     #工资收入

x1 = gb1['交易金额'].agg({'放款前收入计数':np.size,'放款前收入总和':np.sum})
x2 = gb2['交易金额'].agg({'放款前支出计数':np.size,'放款前支出总和':np.sum})
x3 = gb3['交易金额'].agg({'放款前工资收入计数':np.size,'放款前工资收入求和':np.sum})

feature = pd.merge(feature,x1,on='用户ID',how='left')
feature = pd.merge(feature,x2,on='用户ID',how='left')
feature = pd.merge(feature,x3,on='用户ID',how='left')

feature['放款前收入计数差值'] = feature['放款前收入计数'] - feature['放款前支出计数']
feature['放款前收入总数差值'] = feature['放款前收入总和'] - feature['放款前支出总和']
feature['放款前非工资收入计数差值'] = feature['放款前收入计数'] - feature['放款前工资收入计数']
feature['放款前非工资收入总数差值'] = feature['放款前收入总和'] - feature['放款前工资收入求和']
feature['放款前收入笔数乘以差值'] = feature['放款前收入计数'] * feature['放款前收入计数差值']
feature['放款前收入总数乘以差值'] = feature['放款前收入总和'] * feature['放款前收入总数差值']

#==========================放款后==========================
gb1 = d[(d['时间戳'] > d['放款时间']) &d['交易类型']==0].groupby('用户ID',as_index=False)     #收入
gb2 = d[(d['时间戳'] > d['放款时间']) &d['交易类型']==1].groupby('用户ID',as_index=False)     #支出
gb3 = d[(d['时间戳'] > d['放款时间']) &d['工资收入标记']==1].groupby('用户ID',as_index=False)     #工资收入

x1 = gb1['交易金额'].agg({'放款后收入计数':np.size,'放款后收入总和':np.sum})
x2 = gb2['交易金额'].agg({'放款后支出计数':np.size,'放款后支出总和':np.sum})
x3 = gb3['交易金额'].agg({'放款后工资收入计数':np.size,'放款后工资收入求和':np.sum})

feature = pd.merge(feature,x1,on='用户ID',how='left')
feature = pd.merge(feature,x2,on='用户ID',how='left')
feature = pd.merge(feature,x3,on='用户ID',how='left')

feature['放款后收入计数差值'] = feature['放款后收入计数'] - feature['放款后支出计数']
feature['放款后收入总数差值'] = feature['放款后收入总和'] - feature['放款后支出总和']
feature['放款后非工资收入计数差值'] = feature['放款后收入计数'] - feature['放款后工资收入计数']
feature['放款后非工资收入总数差值'] = feature['放款后收入总和'] - feature['放款后工资收入求和']
feature['放款后收入笔数乘以差值'] = feature['放款后收入计数'] * feature['放款后收入计数差值']
feature['放款后收入总数乘以差值'] = feature['放款后收入总和'] * feature['放款后收入总数差值']

 一共输出26个特征

 

三、用户浏览行为

用户浏览行为表 = pd.read_csv('train/browse_history_train.txt',names=['用户ID','时间','浏览行为','浏览子行为'])
用户浏览行为表['时间'] = 用户浏览行为表['时间']//86400
用户浏览行为表.head()
训练放款时间表 = pd.read_csv('train/loan_time_train.txt',names=['用户ID','放款时间'])
训练放款时间表['放款时间'] = 训练放款时间表['放款时间'] //86400
训练放款时间表.head()
用户浏览行为表 = pd.merge(用户浏览行为表,训练放款时间表,on='用户ID')
d = 用户浏览行为表
feature = 训练放款时间表
训练放款时间表.head()
d.head()

#==========================放款前=============================
d = d[d['时间'] <= d['放款时间']]
feature = 训练放款时间表
gb = d.groupby('用户ID',as_index=False)
x1 = gb['浏览行为'].agg({'浏览行为sum':np.sum,'浏览行为mean':np.mean,
                     '浏览行为max':np.max,'浏览行为min':np.min,'浏览行为std':np.std,'浏览行为median':np.median})
x2 = gb['浏览子行为'].agg({'浏览子行为sum':np.sum,'浏览子行为mean':np.mean,
                     '浏览子行为max':np.max,'浏览子行为min':np.min,'浏览子行为std':np.std,'浏览子行为median':np.median})
xx = gb['浏览子行为'].apply(lambda x : np.unique(x).size)
x3 = gb['浏览子行为'].agg({'浏览子行为数':np.size})
x3['浏览子行为去重数'] = xx

feature = pd.merge(feature,x1,on='用户ID',how='left')
feature = pd.merge(feature,x2,on='用户ID',how='left')
feature = pd.merge(feature,x3,on='用户ID',how='left')
feature.shape

temp = pd.get_dummies(d,columns=['浏览子行为'])
temp.head()
gb = temp.groupby('用户ID',as_index=False)
x1 = gb['浏览子行为_1'].agg({'浏览子行为_1sum':np.sum})
x2 = gb['浏览子行为_2'].agg({'浏览子行为_2sum':np.sum})
x3 = gb['浏览子行为_3'].agg({'浏览子行为_3sum':np.sum})
x4 = gb['浏览子行为_4'].agg({'浏览子行为_4sum':np.sum})
x5 = gb['浏览子行为_5'].agg({'浏览子行为_5sum':np.sum})
x6 = gb['浏览子行为_6'].agg({'浏览子行为_6sum':np.sum})
x7 = gb['浏览子行为_7'].agg({'浏览子行为_7sum':np.sum})
x8 = gb['浏览子行为_8'].agg({'浏览子行为_8sum':np.sum})
x9 = gb['浏览子行为_9'].agg({'浏览子行为_9sum':np.sum})
x10 = gb['浏览子行为_10'].agg({'浏览子行为_10sum':np.sum})
x11 = gb['浏览子行为_11'].agg({'浏览子行为_11sum':np.sum})

feature = pd.merge(feature,x1,on='用户ID',how='left')
feature = pd.merge(feature,x2,on='用户ID',how='left')
feature = pd.merge(feature,x3,on='用户ID',how='left')
feature = pd.merge(feature,x4,on='用户ID',how='left')
feature = pd.merge(feature,x5,on='用户ID',how='left')
feature = pd.merge(feature,x6,on='用户ID',how='left')
feature = pd.merge(feature,x7,on='用户ID',how='left')
feature = pd.merge(feature,x8,on='用户ID',how='left')
feature = pd.merge(feature,x9,on='用户ID',how='left')
feature = pd.merge(feature,x10,on='用户ID',how='left')
feature = pd.merge(feature,x11,on='用户ID',how='left')
feature1 = feature
feature1.shape

 

#==========================放款后=============================
d = 用户浏览行为表
feature = 训练放款时间表
d = d[d['时间'] > d['放款时间']]
gb = d.groupby('用户ID',as_index=False)
x1 = gb['浏览行为'].agg({'浏览行为sum':np.sum,'浏览行为mean':np.mean,
                     '浏览行为max':np.max,'浏览行为min':np.min,'浏览行为std':np.std,'浏览行为median':np.median})
x2 = gb['浏览子行为'].agg({'浏览子行为sum':np.sum,'浏览子行为mean':np.mean,
                     '浏览子行为max':np.max,'浏览子行为min':np.min,'浏览子行为std':np.std,'浏览子行为median':np.median})
xx = gb['浏览子行为'].apply(lambda x : np.unique(x).size)
x3 = gb['浏览子行为'].agg({'浏览子行为数':np.size})
x3['浏览子行为去重数'] = xx

feature = pd.merge(feature,x1,on='用户ID',how='left')
feature = pd.merge(feature,x2,on='用户ID',how='left')
feature = pd.merge(feature,x3,on='用户ID',how='left')
feature.shape

temp = pd.get_dummies(d,columns=['浏览子行为'])
temp.head()
gb = temp.groupby('用户ID',as_index=False)
x1 = gb['浏览子行为_1'].agg({'浏览子行为_1sum':np.sum})
x2 = gb['浏览子行为_2'].agg({'浏览子行为_2sum':np.sum})
x3 = gb['浏览子行为_3'].agg({'浏览子行为_3sum':np.sum})
x4 = gb['浏览子行为_4'].agg({'浏览子行为_4sum':np.sum})
x5 = gb['浏览子行为_5'].agg({'浏览子行为_5sum':np.sum})
x6 = gb['浏览子行为_6'].agg({'浏览子行为_6sum':np.sum})
x7 = gb['浏览子行为_7'].agg({'浏览子行为_7sum':np.sum})
x8 = gb['浏览子行为_8'].agg({'浏览子行为_8sum':np.sum})
x9 = gb['浏览子行为_9'].agg({'浏览子行为_9sum':np.sum})
x10 = gb['浏览子行为_10'].agg({'浏览子行为_10sum':np.sum})
x11 = gb['浏览子行为_11'].agg({'浏览子行为_11sum':np.sum})

feature = pd.merge(feature,x1,on='用户ID',how='left')
feature = pd.merge(feature,x2,on='用户ID',how='left')
feature = pd.merge(feature,x3,on='用户ID',how='left')
feature = pd.merge(feature,x4,on='用户ID',how='left')
feature = pd.merge(feature,x5,on='用户ID',how='left')
feature = pd.merge(feature,x6,on='用户ID',how='left')
feature = pd.merge(feature,x7,on='用户ID',how='left')
feature = pd.merge(feature,x8,on='用户ID',how='left')
feature = pd.merge(feature,x9,on='用户ID',how='left')
feature = pd.merge(feature,x10,on='用户ID',how='left')
feature = pd.merge(feature,x11,on='用户ID',how='left')

feature2 = feature
feature1.shape

 

最终得到53个特征，并输出

 

以上都是针对训练数据所做的处理，同样在测试数据上也要做想同的处理，这里就不展示了