金融风控-->客户流失预警模型-->神经网络建模

上一篇博文中，我们对金融数据建立了GBDT模型。这篇博文将利用深度学习框架pytorch对金融数据建立一个人工神经网络模型。

有关人工神经网络的详细介绍请看我的另外一篇博文人工神经网络。

人工神经网络数据预处理：

不能有缺失值

移除常量型特征（即这个特征的最大值和最小值相等）

不能接受非数值形式的输入,字符型变量需要编码:

One hot编码

Dummy编码

浓度编码

变量归一化/标准化





人工神经网络中的参数设置：

输入层节点个数

隐藏层层数

隐藏层节点个数

隐藏层联接状态

激活函数

损失函数

学习速率

迭代次数

模型的效果

AUC score,超过0.7为佳,越大说明效果越好

调参时,可以选择AUC最高的一组参数



下面是代码部分，这里我们只用一个隐藏层，只调了隐藏层神经元个数，dropOut这两个参数。其他参数调优类似。

#coding:utf-8
import pandas as pd
import numpy
import torch
from torch.autograd import Variable
import torch.nn.functional as F
import torch.nn as nn
from sklearn import metrics
import torch.utils.data as Data
from sklearn.model_selection import train_test_split
import operator

modelData = pd.read_csv('modelData.csv', header = 0)
allFeatures = list(modelData.columns)
#remove the class label and cust id from features
allFeatures.remove('CUST_ID')
allFeatures.remove('CHURN_CUST_IND')
modelData2 = modelData.copy()

#normalize the features using max-min to convert the values into [0,1] interval
def MaxMinNorm(df,col):
ma, mi = max(df[col]), min(df[col])
rangeVal = ma - mi
if rangeVal == 0:
print col
df[col] = df[col].map(lambda x:(x-mi)*1.0/rangeVal)

for numFeatures in allFeatures:
MaxMinNorm(modelData2, numFeatures)

#we need to remove columns of 'TELEBANK_ALL_TX_NUM', 'RATIO_21' since they are constants
allFeatures.remove('TELEBANK_ALL_TX_NUM')
allFeatures.remove('RATIO_21')

x_train, x_test, y_train, y_test = train_test_split(modelData2[allFeatures],modelData2['CHURN_CUST_IND'], test_size=0.4,random_state=9)

train_x=x_train.values
train_y=y_train.values

tensor_x=torch.from_numpy(train_x)
tensor_y=torch.from_numpy(train_y)

torch_dataset=torch.utils.data.TensorDataset(data_tensor=tensor_x,target_tensor=tensor_y)

Batch_size=1500
train_loader=torch.utils.data.DataLoader(
dataset=torch_dataset,
batch_size=Batch_size,
shuffle=True,
num_workers=2,
)

x=Variable(torch.from_numpy(train_x)).type(torch.FloatTensor)
y=Variable(torch.from_numpy(train_y)).type(torch.LongTensor)

test_x=x_test.values
V_test_x=Variable(torch.from_numpy(test_x)).type(torch.FloatTensor)
test_y=y_test.values

class Net(torch.nn.Module):
def __init__(self,n_feature,n_hidden,n_output,drop_out):
super(Net,self).__init__()
self.hidden=torch.nn.Linear(n_feature,n_hidden)
torch.nn.Dropout(drop_out)
self.predict=torch.nn.Linear(n_hidden,n_output)

def forward(self, x):
x=F.relu(self.hidden(x))
x=self.predict(x)
return x

## 只有一个隐藏层，这里挑选一个在auc上效果最好的隐藏层的神经元个数
hidden_units_selection={}

for hidden_units in range(10,101,10):

net=Net(n_feature=174,n_hidden=800,n_output=2,drop_out=0.5)
optimizer=torch.optim.Adam(net.parameters(),lr=0.01)
##loss_func=nn.CrossEntropyLoss(weight=torch.FloatTensor([1,35]))
loss_func=nn.CrossEntropyLoss()
for epoch in range(200):
for step,(b_x,b_y) in enumerate(train_loader):
batch_x=Variable(b_x).type(torch.FloatTensor)
batch_y=Variable(b_y).type(torch.LongTensor)
out=net(batch_x)
loss=loss_func(out,batch_y)

optimizer.zero_grad()
loss.backward()
optimizer.step()

if epoch%5==0:
##F.softmax(out)得出二维的概率值，表示每个样本在０类，１类上概率值，是个Variabel类型
# 1表示在列这个维度上得出每行的最大值，返回最大值和在这个行上的位置index local
pred = net(V_test_x)
## 将Variabel 类型转成numpy类型
clf_pred_proba=F.softmax(pred).data.numpy()
## 取每个样本为类别１的概率
pred_proba=[i[1] for i in clf_pred_proba]
auc_score=metrics.roc_auc_score(test_y,pred_proba)
print('Epoch: ', epoch, '| roc_auc_score: %.4f' % auc_score)

pred = net(V_test_x)
clf_pred_proba=F.softmax(pred).data.numpy()
pred_proba=[i[1] for i in clf_pred_proba]
auc_score=metrics.roc_auc_score(test_y,pred_proba)
hidden_units_selection[hidden_units]=auc_score

best_hidden_units=max(hidden_units_selection.iteritems(),key=operator.itemgetter(1))[0]

## 只有一个隐藏层，这里挑选一个在auc上效果最好的dropOut

drop_out_selection={}

for drop_out in numpy.linspace(0,0.99,100):
net=Net(n_feature=174,n_hidden=best_hidden_units,n_output=2,drop_out=drop_out)
optimizer=torch.optim.Adam(net.parameters(),lr=0.01)
##loss_func=nn.CrossEntropyLoss(weight=torch.FloatTensor([1,35]))
loss_func=nn.CrossEntropyLoss()
for epoch in range(200):
for step,(b_x,b_y) in enumerate(train_loader):
batch_x=Variable(b_x).type(torch.FloatTensor)
batch_y=Variable(b_y).type(torch.LongTensor)
out=net(batch_x)
loss=loss_func(out,batch_y)

optimizer.zero_grad()
loss.backward()
optimizer.step()

if epoch%5==0:
pred = net(V_test_x)
clf_pred_proba=F.softmax(pred).data.numpy()
pred_proba=[i[1] for i in clf_pred_proba]
auc_score=metrics.roc_auc_score(test_y,pred_proba)
print('Epoch: ', epoch, '| roc_auc_score: %.4f' % auc_score)

pred = net(V_test_x)
clf_pred_proba=F.softmax(pred).data.numpy()
pred_proba=[i[1] for i in clf_pred_proba]
auc_score=metrics.roc_auc_score(test_y,pred_proba)
drop_out_selection[drop_out]=auc_score

best_drop_out=max(drop_out_selection.iteritems(),key=operator.itemgetter(1))[0]