风控——利用决策树挖掘策略规则

风控:利用决策树挖掘策略规则

1 风控规则的分类

在讲解规则挖掘的方法前，先介绍下风控规则的分类

1.1 从数据和业务角度可分为:

• 准入规则：例如对申请人的年龄的限制，一般根据监管政策或产品要求来制定。
• 黑名单类规则：包含内部黑名单和外部三方黑名单，黑名单里又可细分成逾期，法院，高限，诈骗等类别。
• 反欺诈类规则：针对个人欺诈和团伙欺诈，一般根据设备指纹信息，通讯录，地址定位信息对欺诈行为做甄别。
• 校验类规则：三要素一致性校验，在网状态的校验，联系人号码状态校验等。
• 多头共债类规则：衡量借款人因多头借贷导致违约的风险，依赖第三方数据。
• 逾期类规则：自有平台和外部的逾期行为，能直接反映借款人的信用情况。
• 评分类规则：通过模型将弱的变量合成一个强变量分数，从评分种类可分为反欺诈分，信用分，支付分，消费分等。

1.2 从规则的严格程度可分为:

• 硬规则：也叫严拒规则，这种规则拒绝的都是高风险人群，一般阈值确定下来就不再做变更，上述的黑名单规则，反欺诈规则，校验类规则都属于这个类别。
• 软规则：可以灵活调整规则拒绝的阈值，用的数据一般都是连续型的数值变量，这种变量具有一定的排序性，例如信用分越低，违约风险越高。上述的多头共债逾期类规则，评分规则都可归类于此。

1.3 从规则变量的使用数目可分为:

• 单变量规则，也称简单规则，即规则只用到了一个变量。例如“是否命中失信被执行人”，业务逻辑比较简单。
• 多变量规则，也称复杂规则或组合规则，即规则用到了两个及以上的变量，通过变量之间的交叉组合或者权重加和来提高预测坏用户的精准度，例如“信用分<=400 且多头借贷数大于3次"。

2 常用的规则挖掘方法

2.1 基于政策或专家经验

基于政策的规则，我们根据监管要求，或者业务产品要求直接制定即可。

基于专家经验来挖掘规则，适用于两种场景：

• 一是风控冷启动阶段，这时候无贷后样本可用，我们可以基于历史过往经验，或者参考同行业制定一些规则，例如设备反欺诈，关联风险规则。
• 二是挖掘一些硬规则时可直接根据经验来定，比如校验类规则中，三要素匹配不一致，这类用户可能是通过买号，借号来进行申请，存在很大的欺诈风险，即使其中有些误杀，我们也应该果断的拒绝这类人群。另外根据市场环境变化，我们可基于经验做一些前瞻性的规则，像之前疫情开始爆发时，很多人的还款能力受到影响，就要及时上一些多头共债规则来提前控制风险。

2.2 基于决策树挖掘规则

2.2.1 策略挖掘自动化技术

通过机器学习或者其他方式进行策略的自动挖掘是对专家经验、数据驱动挖掘的有效补充。但是在时间实践过程中也有一些需要注意的问题：

• 有偏性：有Y标签的样本是之前策略通过的样本，在分布上不等于初始进件的样本
• 可解释性：不能出现违反业务认知的规则
• 无冗余规则：反例：例如第1条规则：收入负债比超过80%拒绝。… ，第5条规则：收入负债比超过90%拒绝
• 规则的自洽性：反例：例如第3条规则：学历本科以下拒绝。…，第7条规则：初中学历以上拒绝
• 规则的复杂度：即不能过拟合，反例：10条字段挖掘出1000条规则。该规则即在训练集上表现很好，但是在测试集上的效果很差。

2.2.2 决策树概要

决策树是一种生成树形规则的机器学习算法，基于一堆样本和一个分类结果，通过学习这些样本得到一个决策树，这个决策树能够对新的数据给出正确的分类，决策树可以实现自动化的挖掘大批量的策略组合。

在众多的算法中，决策树整体分类准确率不高，但是部分叶子节点的准确率却可以很高，因此我们可以提取决策树的叶子规则，并筛选准确率比较高的叶子节点，作为风控策略挖掘手段，替代人工或者辅助人工，大大提高策略发现的效率。

决策树挖掘规则的优点在于，可根据信息增益，基尼系数等指标自动进行样本划分，且可对多个变量进行组合，大大减少工作量，我们可根据下面几个参数来控制树生成的逻辑：

• max_depth: 最大树深，深度越大，产生的叶子节点越多，一般挖掘规则时设置成2-3即可-
• min_samples_leaf: 叶子节点的最小样本量或最小占比，一般占比可设置成5%–10%
• min_samples_split: 父节点在分裂时需要的最小样本量或最小占比，一般设置成5%–10%

不过需要注意的是，

• 分裂时完全依赖于基尼系数等指标，缺乏业务含义，且不考虑变量本身的排序性，容易导致分出来的结果在业务上不可解释
• 决策树容易过拟合，需要验证在跨时间维度上是否稳定
• 相比于画格子方法，决策树是自动分裂，这样就不容易手工进行调整

关于决策树实现原理和机制，网上已有较多的资料进行讲解，本篇不再进行赘述。本文主要介绍如何利用决策树算法挖掘有效规则，实现风控策略自动化。

3 利用决策树挖掘规则案例一

3.1 数据说明

测试数据集包含：个人基本信息、个人住房公积金缴存、贷款等数据信息，来预测用户是否会逾期还款。数据集包含40000带标签训练集样本，共有19个基本特征，无缺失值。

标签：label是否逾期（是 = 1，否 = 0）。

特征：包含以下19个特征，对应名称和含义如下：

特征名	类型	特征含义
id	String	主键
XINGBIE	int	性别
CSNY	int	出生年月
HYZK	int	婚姻状况
ZHIYE	int	职业
ZHICHEN	int	职称
ZHIWU	int	职务
XUELI	int	学历
DWJJLX	int	单位经济类型
DWSSHY	int	单位所属行业
GRJCJS	float	个人缴存基数
GRZHZT	int	个人账户状态
GRZHYE	float	个人账户余额
GRZHSNJZYE	float	个人账户上年结转余额
GRZHDNGJYE	float	个人账户当年归集余额
GRYICE	float	个人月缴存额
DWYICE	float	单位月缴存额
DKFFE	int	贷款发放额
DKYE	float	贷款余额
DKLL	float	贷款利率
label	int	是否逾期 (0代表没逾期1代表逾期)

3.2 读取数据并构建决策树

import pandas as pd
import numpy  as np
pd.set_option('display.max_columns', None)#显示所有的列
train = pd.read_csv('train.csv').fillna(-1)

# 构建训练集
X = train.loc[:,'XINGBIE':'DKLL']
Y = train['label']

# 构造决策树
from sklearn import tree
clf = tree.DecisionTreeClassifier(
     max_depth=3,
     min_samples_leaf=50
     )
clf = clf.fit(X, Y)

3.2 决策树可视化

决策树可视化的方案比较多，主要有sklearn中的plot_tree接口、graphv可视化、dtreeviz可视化， 这里我们都写出来作为对比。对决策树进行可视化，能够帮助我们自己充分理解决策树的生成过程，如果是风控，对数据结果的可解释性也提供帮助。

3.2.1 利用plot_tree对决策树进行可视化

# 接口自带的
tree.plot_tree(clf)
plt.show()

#缺点是颜色单调，不易直观理解,不推荐

3.2.2 利用graphviz对决策树进行可视化

import graphviz 
dot_data = tree.export_graphviz(
                     clf, 
                     out_file=None, 
                     feature_names=X.columns,  
                     class_names=['good','bad'],  
                     filled=True, rounded=True,  
                     special_characters=True)  
graph = graphviz.Source(dot_data)  
graph

生成的决策树解释

• samples：节点中观察的数量，比如根节点40000，表示数据集总共有4万个样本

• 有多少种类别，整棵树的叶子就有多少种颜色，比如我们这里有2个类别，颜色对应是黄、绿、Gini指数越小，该节点颜色越深，也就是纯度越高。

• value表示当前节点2种类别的样本有多少，比如下面第一棵树的根节点，value = [37243,2757]，表示有37243个好样本，2757坏样本

• class表示当前那个类别的样本最多，比如下面最右边的一棵树的根节点，class = bad，可以看到当前节点它的坏样本数是最多的。

• gini：节点的基尼不纯度。当沿着树向下移动时，平均加权的基尼不纯度必须降低。

3.2.3 利用dtreeviz对决策树进行可视化

dtreeviz是美观且容易理解，是一款非常优秀的决策是可视化包。

from dtreeviz.trees import dtreeviz
testX = X.iloc[77,:]
viz = dtreeviz(clf,X,Y,
                feature_names=np.array(X.columns),
                class_names={0:'good',1:'bad'},
                X = testX)             

viz.view()  # 会在web 端显示

可视化结果已网页的方式生成，决策流程、数值分布、决策结果非常直观。

如果将树的深度增加至5层，生成的结果会更加复杂：

from sklearn import tree
clf = tree.DecisionTreeClassifier(
     max_depth=5,
     min_samples_leaf=50
     )
clf = clf.fit(X, Y)
  from dtreeviz.trees import dtreeviz
  testX = X.iloc[77,:]
  viz = dtreeviz(clf,X,Y,
                 feature_names=np.array(X.columns),
                 class_names={0:'good',1:'bad'},
                 X = testX)             
  viz.view()

也可以横向展示:

viz = dtreeviz(clf,X,Y,
               orientation ='LR',  # left-right orientation
               feature_names=np.array(X.columns),
               class_names={0:'good',1:'bad'},
               X = testX)       
viz.view()

截取部分显示如下：

如果只想可视化预测路径，则需要设置参数 show_just_path=True

有了决策树的可视化，可以直观地转换每条策略了。但是人为分析效率还是比较低，因此需要更高效的方式，对数据决策树上的信息进行提取，直接得到规则。

3.3 决策树规则提取

3.3.1 决策树的生成结构分析

提取规则之前，我们需要理解决策树的存储结构，探究sklearn中的决策树是如何设计和实现的。以分类决策树为例，首先看下决策树都内置了哪些属性和接口：通过dir属性查看一颗初始的决策树都包含了哪些属性（这里过滤掉了以"_"开头的属性，因为一般是内置私有属性），得到结果如下：

from sklearn.datasets import load_iris
from sklearn import tree
iris = load_iris()
clf = tree.DecisionTreeClassifier()
clf = clf.fit(iris.data, iris.target)
clf.classes_
[x for x in dir(clf) if not x.startswith('_')]

结果如下：

['apply',
 'capacity',
 'children_left',
 'children_right',
 'compute_feature_importances',
 'compute_partial_dependence',
 'decision_path',
 'feature',
 'impurity',
 'max_depth',
 'max_n_classes',
 'n_classes',
 'n_features',
 'n_leaves',
 'n_node_samples',
 'n_outputs',
 'node_count',
 'predict',
 'threshold',
 'value',
 'weighted_n_node_samples']

本文的重点是探究决策树中是如何保存训练后的"那颗树"，我们进一步用鸢尾花数据集对决策树进行训练一下，而后再次调用dir函数，看看增加了哪些属性和接口：

from sklearn import tree
X,y = load_iris(return_X_y=True)
dt =  tree.DecisionTreeClassifier(max_depth=2).fit(X,y)
set(dir(dt)).difference(dir(tree.DecisionTreeClassifier()))

结果如下：

{‘classes_’, ‘max_features_’, ‘n_classes_’, ‘n_features_’, ‘n_outputs_’, ‘tree_’}

通过集合的差集，很明显看出训练前后的决策树主要是增加了6个属性（都是属性，而非函数功能），其中通过属性名字也很容易推断其含义：

• classes_：分类标签的取值，即y的唯一值集合
• max_features_：最大特征数
• n_classes_：类别数，如2分类或多分类等，即classes_属性中的长度
• n_features_in_：输入特征数量，等价于老版sklearn中的n_features_，现已弃用，并推荐n_features_in_
• n_outputs：多输出的个数，即决策树不仅可以用于实现单一的分类问题，还可同时实现多个分类问题，例如给定一组人物特征，用于同时判断其是男/女、胖/瘦和高矮，这是3个分类问题，即3输出（需要区别理解多分类和多输出任务）
• tree_：这个tree_就是本文的重点，是在决策树训练之后新增的属性集，其中存储了决策树是如何存储的。

我们对这个tree_属性做进一步探究，首先打印该tree_属性发现，这是一个Tree对象，并给出了在sklearn中的文件路径：

 dt.tree_

结果显示：

我们可以通过help方法查看Tree类的介绍：

import sklearn

help(sklearn.tree._tree.Tree)

内部接口文档写的很清晰了：

基于数组表示的二分类决策树，进一步地，在这个二叉树中，数组的第i个元素代表了决策树的第i个节点的信息，节点0表示决策树的根节点。那么每个节点又都蕴含了什么信息呢？我们注意到上述文档中列出了节点的文件名：_tree.pxd，查看其中，很容易发现节点的定义如下：

• left_child：size类型（无符号整型），代表了当前节点的左子节点的索引
• right_child：类似于left_child
• feature：size类型，代表了当前节点用于分裂的特征索引，即在训练集中用第几列特征进行分裂
• threshold：double类型，代表了当前节点选用相应特征时的分裂阈值，一般是≤该阈值时进入左子节点，否则进入右子节点
• n_node_samples：size类型，代表了训练时落入到该节点的样本总数。显然，父节点的n_node_samples将等于其左右子节点的n_node_samples之和

至此，决策树中单个节点的属性定义和实现基本推断完毕，那么整个决策树又是如何将所有节点串起来的呢？,再次查看训练后决策树的tree_属性，看看它都哪些接口，仍然过滤掉内置私有属性，得到如下结果：

决策树结构探索

[x for x in dir(clf.tree_) if not x.startswith('_')]
['apply','capacity', 'children_left','children_right',
 'compute_feature_importances','compute_partial_dependence',
 'decision_path','feature',
 'impurity','max_depth',
 'max_n_classes','n_classes',
 'n_features','n_leaves',
 'n_node_samples','n_outputs','node_count',
 'predict','threshold',
 'value', 'weighted_n_node_samples']

为了进一步理解各属性中的数据是如何存储的，我们仍以鸢尾花数据集为例，训练一个max_depth=2的决策树（根节点对应depth=0），并查看如下取值：

clf.tree_.children_left
clf.tree_.children_right
clf.tree_.feature
clf.tree_.capacity
clf.tree_.threshold
clf.tree_.value
clf.tree_.impurity
clf.tree_.decision_path

from sklearn import tree
X,y = load_iris(return_X_y=True)
dt =  tree.DecisionTreeClassifier(max_depth=2).fit(X,y)
tree = dt.tree_

print('tree.node_count',tree.node_count)
print('tree.n_leaves',tree.n_leaves)
print('tree.children_left',tree.children_left)
print('tree.children_right',tree.children_right)
print('tree.feature',tree.feature)
print('tree.threshold',tree.threshold)

# 输出结果
'''
tree.node_count 5
tree.n_leaves 3
tree.children_left [ 1 -1  3 -1 -1]
tree.children_right [ 2 -1  4 -1 -1]
tree.feature [ 3 -2  3 -2 -2]
tree.threshold [ 0.80000001 -2.          1.75       -2.         -2.        ]

tree.value [[[50. 50. 50.]]

 [[50.  0.  0.]]

 [[ 0. 50. 50.]]

 [[ 0. 49.  5.]]

 [[ 0.  1. 45.]]]
'''

X,y = load_iris(return_X_y=True)
y[X[:,3]<=0.8]

# 输出结果
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0])

通过children_left和children_right两个属性的子节点对应关系，按照根-左-右的顺序，即：前序遍历。

3.3.2 老方法提取决策树规则

X = train.loc[:,'XINGBIE':'DKLL']
Y = train['label']

# 训练一个决策树，这里限制了最大深度和最小样本树

from sklearn import tree
clf = tree.DecisionTreeClassifier(
     max_depth=3,
     min_samples_leaf=50
     )
clf = clf.fit(X, Y)

# 决策树规则提取-老方法

from sklearn.tree import _tree
def tree_to_code(tree, feature_names):
    tree_ = tree.tree_
    feature_name = [
        feature_names[i] if i != _tree.TREE_UNDEFINED else "undefined!"
        for i in tree_.feature
    ]
    print ("def tree({}):".format(", ".join(feature_names)))

    def recurse(node, depth):
        indent = "  " * depth
        if tree_.feature[node] != _tree.TREE_UNDEFINED:
            name = feature_name[node]
            threshold = tree_.threshold[node]
            print("{}if {} <= {}:".format(indent, name, threshold))
            recurse(tree_.children_left[node], depth + 1)
            print("{}else:  # if {} > {}".format(indent, name, threshold))
            recurse(tree_.children_right[node], depth + 1)
        else:
            print("{}return {}".format(indent, tree_.value[node]))

    recurse(0, 1)

tree_to_code(clf,X.columns)

结果如下：

可以看到，老方法提取策略的结果需要人为拆解。

3.3.3 新方法提取决策树规则(利用函数提取规则)

from sklearn.tree import _tree

def Get_Rules(clf,X):
    n_nodes = clf.tree_.node_count
    children_left = clf.tree_.children_left
    children_right = clf.tree_.children_right
    feature = clf.tree_.feature
    threshold = clf.tree_.threshold
    value = clf.tree_.value

    node_depth = np.zeros(shape=n_nodes, dtype=np.int64)
    is_leaves  = np.zeros(shape=n_nodes, dtype=bool)
    stack = [(0, 0)]

    while len(stack) > 0:

        node_id, depth = stack.pop()
        node_depth[node_id] = depth

        is_split_node = children_left[node_id] != children_right[node_id]

        if is_split_node:
            stack.append((children_left[node_id],  depth+1))
            stack.append((children_right[node_id], depth+1))
        else:
            is_leaves[node_id] = True  
    feature_name = [
            X.columns[i] if i != _tree.TREE_UNDEFINED else "undefined!"
            for i in clf.tree_.feature]

    ways  = []
    depth = []
    feat = []
    nodes = []
    rules = []
    for i in range(n_nodes):   
        if  is_leaves[i]: 
            while depth[-1] >= node_depth[i]:
                depth.pop()
                ways.pop()    
                feat.pop()
                nodes.pop()
            if children_left[i-1]==i:#当前节点是上一个节点的左节点，则是小于
                a='{f}<={th}'.format(f=feat[-1],th=round(threshold[nodes[-1]],4))
                ways[-1]=a              
                last =' & '.join(ways)+':'+str(value[i][0][0])+':'+str(value[i][0][1])
                rules.append(last)
            else:
                a='{f}>{th}'.format(f=feat[-1],th=round(threshold[nodes[-1]],4))
                ways[-1]=a
                last = ' & '.join(ways)+':'+str(value[i][0][0])+':'+str(value[i][0][1])
                rules.append(last)

        else: #不是叶子节点 入栈
            if i==0:
                ways.append(round(threshold[i],4))
                depth.append(node_depth[i])
                feat.append(feature_name[i])
                nodes.append(i)             
            else: 
                while depth[-1] >= node_depth[i]:
                    depth.pop()
                    ways.pop()
                    feat.pop()
                    nodes.pop()
                if i==children_left[nodes[-1]]:
                    w='{f}<={th}'.format(f=feat[-1],th=round(threshold[nodes[-1]],4))
                else:
                    w='{f}>{th}'.format(f=feat[-1],th=round(threshold[nodes[-1]],4))              
                ways[-1] = w  
                ways.append(round(threshold[i],4))
                depth.append(node_depth[i]) 
                feat.append(feature_name[i])
                nodes.append(i)
    return rules

import pandas as pd
import numpy  as np
pd.set_option('display.max_columns', None)#显示所有的列
train = pd.read_csv('train.csv').fillna(-1)

X = train.loc[:,'XINGBIE':'DKLL']
Y = train['label']

from sklearn import tree
#训练一个决策树，对规则进行提取
clf = tree.DecisionTreeClassifier(max_depth=10,min_samples_leaf=50)
clf = clf.fit(X, Y)
Rules = Get_Rules(clf,X)

# 查看前5条规则
Rules[0:5]

输出结果：

['GRZHZT<=1.5 & DWSSHY<=14.5 & DWJJLX<=177.0 & DWJJLX<=115.0 & DKYE<=111236.2852 & DWSSHY<=4.5 & GRYJCE<=663.54 & DKYE<=67419.1094:45.0:8.0',
 'GRZHZT<=1.5 & DWSSHY<=14.5 & DWJJLX<=177.0 & DWJJLX<=115.0 & DKYE<=111236.2852 & DWSSHY<=4.5 & GRYJCE<=663.54 & DKYE>67419.1094:61.0:3.0',
 'GRZHZT<=1.5 & DWSSHY<=14.5 & DWJJLX<=177.0 & DWJJLX<=115.0 & DKYE<=111236.2852 & DWSSHY<=4.5 & GRYJCE>663.54 & GRZHYE<=45622.4883 & DKYE<=1825.5625:63.0:2.0',
 'GRZHZT<=1.5 & DWSSHY<=14.5 & DWJJLX<=177.0 & DWJJLX<=115.0 & DKYE<=111236.2852 & DWSSHY<=4.5 & GRYJCE>663.54 & GRZHYE<=45622.4883 & DKYE>1825.5625:188.0:0.0',
 'GRZHZT<=1.5 & DWSSHY<=14.5 & DWJJLX<=177.0 & DWJJLX<=115.0 & DKYE<=111236.2852 & DWSSHY<=4.5 & GRYJCE>663.54 & GRZHYE>45622.4883:46.0:4.0']

第一条后面的45.0:8.0，指的是样本标签的0:1比例，利用原始数据进行核验：

cond1 = (train['GRZHZT']<=1.5) & (train['DWSSHY']<=14.5) & (train['DWJJLX']<=177.0) & (train['DWJJLX']<=115.0) & (train['DKYE']<=111236.2852) & (train['DWSSHY']<=4.5) & (train['DWYJCE']<=663.54) & (train['DKYE']<=67419.1094)
train[cond1]['label'].value_counts()

结果输出：

0 45

1 8

Name: label, dtype: int64

最后，可以导出成表格的形式，更加清晰，提取rate较高的组合规则：

提高树的深度再看看，max_depth=15，可以看到规则数变成了521条，规模更大。

clf = tree.DecisionTreeClassifier(max_depth=15,min_samples_leaf=20)
clf = clf.fit(X, Y)
Rules = Get_Rules(clf,X)

# 查看规则数量
print(len(Rules))

# 遍历所有规则
for i in Rules:
    print(i)

4 参考文献

【1】https://chowdera.com/2022/220/202208080350119845.html

【2】https://mp.weixin.qq.com/s/Mj_3v2Xh7B7AnSkRP2TyJg