风险控制（Risk Control)，简称风控，是互联网金融的核心。

一、基础知识

1.1 A/B/C卡

  • A卡（Application score card）即申请评分模型（贷款前），用于预测申请时点（申请信用卡、申请贷款）未来一定时间内逾期的概率。
  • B卡（Behavior score card）即行为评分模型（贷款中），用于预测使用时点（获得贷款、信用卡的使用期间）未来一定时间内逾期的概率。
  • C卡（Collection score card）即催收评分模型（贷款后），用于预测进入催收阶段后，未来一定时间内还款的概率。

1.2 信贷业务


        信贷业务，是通过放款收回本金，获得利息的，进而赢得利润。



        有贷款的哥们，贷款平台对其未来还款能力进行预测，将资金优先借贷给有大概率偿还的用户。

1.3 评分卡

        评分卡是以分数的形式来衡量风险几率的一种手段，是对未来一段时间内违约/逾期/失联概率的预测。 有一个明确的正区间，分数越高越安全，有反欺诈评分卡，申请评分卡，行为评分卡，催收评分卡。

        评分卡的特性：稳定性，区分性，预测能力，和逾期概率等价。

1.4 信贷风险与控制

信贷领域有两类风险：



        信用风险，是还款能力和还款意愿在贷款后出现的风险。由于一些不可抗力使用户经济和思想状态发生变化。可以通过风险定价策略等手段可控。



        欺诈风险，贷款目的不正当，没有还款计划。可控性差。

风险管控由两大类系统组成：信用评分系统，欺诈检测系统。



1.5 互联网金融风控体系

与传统人工信审相比，人工智能风控，可批量，迅速，准确地处理贷款申请。解放在中小额贷款的劳动力。

风控系统架构 风控系统原理_建模


二、工业建模

2.1 基本定义


在风控场景下遇到的问题，通常都会转化为二分类问题，并将响应变量作为负样本。比如：

  • 信用评分模型，预测用户是否会逾期。 负样本：逾期用户。
  • 营销模型，预测用户被营销是否会贷款。负样本：贷款用户。
  • 失联模型，预测用户是否会失联。负样本：失联用户。

        信贷评分系统中，负样本标签： 逾期超过15天的客户。正样本标签： 未逾期+逾期少于5天的客户。从分布角度来讲，二分类问题一般会假设样本服从二项分布。如果保留5-15天内逾期的用户（灰样本），会让正负样本的实际界限很模糊，去掉中间样本，使样本分布更趋于二项分布，对模型的训练更加有利。不过其中灰样本也会作为测试集，确保模型在训练结束后，对该部分样本也有区分能力。

2.2 数据样本



样本选取时，满足原则：

  • 代表性，样本必须能代表总体。
  • 充分性，样本集数量满足一定要求，少样本无法满足统计的显著性。评分卡建模通常炫耀正负样本不少于1500个。神经网络需要样本量在50万个以上，否则很难保证稳定性。
  • 时效性，样本的观测期与实际应用的时间节点越近越好。然而很多平台，很难保证样本都处于稳定的较近期时间点上。此时可以通过迁移学习（transfer learning）对样本挑选或者对变量进行映射，使得早期样本与近期样本有相似的数据分布。
  • 排除性。不满足当前场景贷款需要的用户不应该作为样本，比如判定为欺诈的用户不应该放在当前样本集中。

        样本大时，做欠采样（subsampling）。负样本一般较少，因此通常只对正样本做欠采样。方法有三种方法：

  • 随机欠采样，正样本的比例随机抽。
  • 分层抽样，保证抽样后，训练，验证，测试的正负样本比例相同。
  • 等比例抽样，正负样本之间的比例进行抽样。



2.3 建模的具体流程：


  1. 业务抽象为分类或回归问题。
  2. 定义标签
  3. 选取合适的样本，匹配出全部信息作为特征。
  4. 特征工程+模型训练+模型评价+模型调优。
  5. 输出模型报告。
  6. 上线+监控


三、规则建模

规则模型和人工智能模型。本小节首先通过规则模型来简单了解一下建模的流程，后面所有的章节也会围绕着人工智能建模展开。

#!/usr/bin/env python
# coding: utf-8

# In[4]:


import pandas as pd
import numpy as np
import os
# os.environ["PATH"] += os.pathsep + 'C:/Program Files (x86)/Graphviz2.38/bin/'

# In[5]:


path = './'

data = pd.read_excel(path + 'oil_data_for_tree.xlsx')
data.head()

# In[6]:


set(data.class_new)

# In[7]:


data.shape

# org_lst 不需要做特殊变换，直接去重  
# agg_lst 数值型变量做聚合  
# dstc_lst 文本型变量做cnt  

# In[8]:


org_lst = ['uid','create_dt','oil_actv_dt','class_new','bad_ind']
agg_lst = ['oil_amount','discount_amount','sale_amount','amount','pay_amount','coupon_amount','payment_coupon_amount']
dstc_lst = ['channel_code','oil_code','scene','source_app','call_source']

# 数据重组

# In[9]:


df = data[org_lst].copy()
df[agg_lst] = data[agg_lst].copy()
df[dstc_lst] = data[dstc_lst].copy()
df.head()

# 看一下缺失情况

# In[10]:


df.isna().sum()

# 看一下基础变量的describe

# In[11]:


df.describe()

# 对creat_dt做补全，用oil_actv_dt来填补，并且截取6个月的数据。  
# 构造变量的时候不能直接对历史所有数据做累加。  
# 否则随着时间推移，变量分布会有很大的变化。

# In[12]:


df2 = df.sort_values(['uid','create_dt'],ascending = False)
df2.head()

# In[13]:


def time_isna(x,y):
    if str(x) == 'NaT':
        x = y
    else:
        x = x
    return x
df2['create_dt'] = df2.apply(lambda x: time_isna(x.create_dt,x.oil_actv_dt),axis = 1)
df2['dtn'] = (df2.oil_actv_dt - df2.create_dt).apply(lambda x :x.days)
df = df2[df2['dtn']<180]
df.head()

# 对org_list变量求历史贷款天数的最大间隔，并且去重

# In[23]:


base = df[org_lst]
base['dtn'] = df['dtn']
base = base.sort_values(['uid','create_dt'],ascending = False)
base.tail(30)

# In[21]:


base.shape

# 重复uid，保留日期最近的uid。

# In[24]:


base = base.drop_duplicates(['uid'],keep = 'first')
base.tail(30)

# In[18]:


base.shape

# In[26]:


agg_lst

# In[27]:


df.head()

# 做变量衍生

# In[28]:


gn = pd.DataFrame()
for i in agg_lst:
    tp = pd.DataFrame(df.groupby('uid').apply(lambda df:len(df[i])).reset_index())
    tp.columns = ['uid',i + '_cnt']
    if gn.empty == True:
        gn = tp
    else:
        gn = pd.merge(gn,tp,on = 'uid',how = 'left')
    tp = pd.DataFrame(df.groupby('uid').apply(lambda df:np.where(df[i]>0,1,0).sum()).reset_index())
    tp.columns = ['uid',i + '_num']
    if gn.empty == True:
        gn = tp
    else:
        gn = pd.merge(gn,tp,on = 'uid',how = 'left')
    tp = pd.DataFrame(df.groupby('uid').apply(lambda df:np.nansum(df[i])).reset_index())
    tp.columns = ['uid',i + '_tot']
    if gn.empty == True:
        gn = tp
    else:
        gn = pd.merge(gn,tp,on = 'uid',how = 'left')
    tp = pd.DataFrame(df.groupby('uid').apply(lambda df:np.nanmean(df[i])).reset_index())
    tp.columns = ['uid',i + '_avg']
    if gn.empty == True:
        gn = tp
    else:
        gn = pd.merge(gn,tp,on = 'uid',how = 'left')
    tp = pd.DataFrame(df.groupby('uid').apply(lambda df:np.nanmax(df[i])).reset_index())
    tp.columns = ['uid',i + '_max']
    if gn.empty == True:
        gn = tp
    else:
        gn = pd.merge(gn,tp,on = 'uid',how = 'left')
    tp = pd.DataFrame(df.groupby('uid').apply(lambda df:np.nanmin(df[i])).reset_index())
    tp.columns = ['uid',i + '_min']
    if gn.empty == True:
        gn = tp
    else:
        gn = pd.merge(gn,tp,on = 'uid',how = 'left')
    tp = pd.DataFrame(df.groupby('uid').apply(lambda df:np.nanvar(df[i])).reset_index())
    tp.columns = ['uid',i + '_var']
    if gn.empty == True:
        gn = tp
    else:
        gn = pd.merge(gn,tp,on = 'uid',how = 'left')
    tp = pd.DataFrame(df.groupby('uid').apply(lambda df:np.nanmax(df[i]) -np.nanmin(df[i]) ).reset_index())
    tp.columns = ['uid',i + '_var']
    if gn.empty == True:
        gn = tp
    else:
        gn = pd.merge(gn,tp,on = 'uid',how = 'left')
    tp = pd.DataFrame(df.groupby('uid').apply(lambda df:np.nanmean(df[i])/max(np.nanvar(df[i]),1)).reset_index())
    tp.columns = ['uid',i + '_var']
    if gn.empty == True:
        gn = tp
    else:
        gn = pd.merge(gn,tp,on = 'uid',how = 'left')

# In[29]:


gn.head()

# 对dstc_lst变量求distinct个数

# In[30]:


gc = pd.DataFrame()
for i in dstc_lst:
    tp = pd.DataFrame(df.groupby('uid').apply(lambda df: len(set(df[i]))).reset_index())
    tp.columns = ['uid',i + '_dstc']
    if gc.empty == True:
        gc = tp
    else:
        gc = pd.merge(gc,tp,on = 'uid',how = 'left')
gc.head()

# In[33]:


gc.shape,gn.shape, base.shape

# 将变量组合在一起

# In[34]:


fn = pd.merge(base,gn,on= 'uid')
fn = pd.merge(fn,gc,on= 'uid') 
fn.shape

# In[35]:


fn = fn.fillna(0)

# In[36]:


fn.head(100)

# 训练决策树模型

# In[37]:


x = fn.drop(['uid','oil_actv_dt','create_dt','bad_ind','class_new'],axis = 1)
y = fn.bad_ind.copy()
from sklearn import tree

dtree = tree.DecisionTreeRegressor(max_depth = 2,min_samples_leaf = 500,min_samples_split = 5000)
dtree = dtree.fit(x,y)

# 输出决策树图像，并作出决策

# In[38]:


import pydotplus 
from IPython.display import Image
from sklearn.externals.six import StringIO

with open(path + "dt.dot", "w") as f:
    tree.export_graphviz(dtree, out_file=f)
dot_data = StringIO()
tree.export_graphviz(dtree, out_file=dot_data,
                         feature_names=x.columns,
                         class_names=['bad_ind'],
                         filled=True, rounded=True,
                         special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue()) 
Image(graph.create_png())

# value = badrate

# In[39]:


sum(fn.bad_ind),len(fn.bad_ind), sum(fn.bad_ind)/len(fn.bad_ind)

       其中数据和代码源于GitHub - CourteousWood/Risk_control中introduction，最后画出来的图像为：

风控系统架构 风控系统原理_风控_02

        如果画图失败，centos可以采用下面三行解决。


sudo yum -y install graphviz
python3 -m pip install graphviz -i https://pypi.douban.com/simple/
python3 -m pip install pydotplus -i https://pypi.douban.com/simple/


        表中value计算的是叶节点中正负样本标签的均值，在二分类中，均值 等价于  标签为1的样本在总样本的比例。可以看到样本被两个特征划分为三个群体，负样本占比逐渐减少，分别为0.074,0.03，0.012。

dff1 = fn.loc[(fn.pay_amount_tot>240387.5)&(fn.amount_cnt>=3.5)].copy()  
dff1['level'] = 'past_A'  
dff2 = fn.loc[(fn.pay_amount_tot>240387.55)&(fn.amount_cnt<=3.5)].copy()  
dff2['level'] = 'past_B'  
dff3 = fn.loc[fn.pay_amount_tot<=240387.5].copy()  
dff3['level'] = 'past_C'

        通过简单的分群，对三个群体分别采用不同的策略去处理，大大减少业务损失。