Заключение. 
Реализация метода бинарной классификации с использованием нейронных сетей на примере модели кредитного скоринга

Результаты программы. Полученные после выполнения программы результаты, представленные в форме .csv файла с двумя столбцами, с помощью специальной формы на сервисе kaggle сравниваются с эталонными результатами и пользователю виден уровень правдоподобия (соответствие полученных результатов реальным).

Форма для проверки:

https://www.kaggle.com/c/GiveMeSomeCredit/submit.

ROC-кривая (Receiver Operator Characteristic) — кривая, которая чаще всего используется, чтобы представить результат в бинарной классификации в машинном обучении. Эта кривая позволяет оценить пропорцию между долей правильно классифицированных положительных результатов («хороший» заемщик) и долей неправильно классифицированных отрицательных результатов («плохой» заемщик).

Уровень правдоподобия, в свою очередь, представляет собой площадь под ROC-кривой. Он отображает отношение процента объектов из общей выборки, классифицированных верно, и долей объектов, которые классифицировались с ошибкой.

Уровень правдоподобия представленной в работе реализации скоринговой модели составил 0.813 272.

Время работы при:

Таблица 4. Срез таблицы из Приложения 2

27.431 секунд.

Выводы. Подводя итог, банки сталкиваются с широким спектром рисков в своей повседневной деятельности. Основной деятельностью банков является привлечение средств путем выдачи разнообразных кредитов физическим лицам и юридическим клиентам. Следовательно, оценка кредитного риска является одной из основных проблем в банковском секторе. Жизнеспособность банка часто зависит от правильной оценки. Неверная оценка может привести к дефолту по кредитам, что, в свою очередь, может нарушить ликвидность банка и в конечном итоге привести к неплатежеспособности кредитной организации. Поэтому банки придают большое значение разработке современных методологических методов для оценки кредитоспособности.

Разработано универсальное приложение бинарного классификатора, реализующее метод нейронных сетей для решения задачи классификации с типом сети: многослойный персептрон с одним скрытым слоем. Нейронная сеть обучается и на основе обучения делает предсказание по девяти признакам клиента банка.

Эффективность созданного алгоритма составляет 0.813 272, его время работы — 27.431 секунд.

В будущем планируется провести более глубокий анализ подготовки сети для повышения качества и производительности сети. Приложение может быть применено в задачах, где требуется разделить респондентов на два класса. Например, задачи предсказания оттока клиентов, задачи медицинской диагностики, обнаружение спама, прогнозирование спортивных ставок и т. д.

По результатам работы сети с обучающей и проверочной выборками был построен график ошибок:

Рис.4 Ошибки на обучающей и проверочной выборках.

Рис.5 Разница в данных, полученной сетью и исходными.

ПРИЛОЖЕНИЕ 1

Код программы на языке Python:

%matplotlib inline

%config InlineBackend.figure_format = 'retina'

import csv

import pickle

import numpy as np

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

import sys

df1 = pd.read_csv ('cs-training.csv')

df1 = df1.drop ('Unnamed: 0', 1)

df2 = pd.read_csv ('cs-test.csv')

df1.info ()

df1.corr ()

sns.heatmap (df1.corr ());

df1[df1['NumberOfDependents']. apply (np.isnan)]

df1.head ()

quant_features = ['RevolvingUtilizationOfUnsecuredLines', 'NumberOfTime30−59DaysPastDueNotWorse', 'DebtRatio', 'MonthlyIncome', 'NumberOfOpenCreditLinesAndLoans', 'NumberOfTimes90DaysLate', 'NumberRealEstateLoansOrLines', 'NumberOfTime60−89DaysPastDueNotWorse', 'NumberOfDependents']

scaled_features = {}

for each in quant_features:

mean, std = df1[each]. mean (), df1[each]. std ()

min, max = df1[each]. min (), df1[each]. max ()

scaled_features[each] = [min, max]

df1.loc[, each] = (df1[each] - min)/ (max - min)

df1.head ()

nTrain = 60 000

nTest = 6000

nVal = 6000

b = {}

test_data = df1[-nTest:]

data = df1[:-nTest]

target_fields = [' SeriousDlqin2yrs']

features, targets = df1.drop (target_fields, axis=1), df1[target_fields]

test_features, test_targets = test_data.drop (target_fields, axis=1), test_data[target_fields]

train_features, train_targets = features[:nTrain], targets[:nTrain]

val_features, val_targets = features[-nVal:], targets[-nVal:]

class NN (object):

def __init__(self, nInput, nHidden, nOutput, mu):

self.nInput = nInput

self.nHidden = nHidden

self.nOutput = nOutput

# Initialize weights

self.weights_input_to_hidden = np.random.normal (0.0, self.nHidden**-0.5,

(self.nHidden, self.nInput))

self.weights_hidden_to_output = np.random.normal (0.0, self.nOutput**-0.5,

(self.nOutput, self.nHidden))

self.mu = mu

self.actFun = lambda x: 1.0 / (1.0 + np.exp (-x))

def actFun (x):

return 1.0 / (1.0 + np.exp (-x))

def learn (self, inputs_list, targets_list):

inputs = np.array (inputs_list, ndmin=2).T

targets = np.array (targets_list, ndmin=2).T

### Forward pass ###

# Hidden layer

hidden_inputs = np.dot (self.weights_input_to_hidden, inputs)

hidden_outputs = self.actFun (hidden_inputs)

#Output layer

final_inputs = np.dot (self.weights_hidden_to_output, hidden_outputs)

final_outputs = final_inputs

### Backward pass ###

# Output error

output_errors = targets - final_outputs

# Backpropagated error

hidden_errors = np.dot (self.weights_hidden_to_output.T, output_errors)

hidden_grad = hidden_outputs * (1.0 - hidden_outputs)

# Update the weights

self.weights_hidden_to_output += self.mu * np.dot (output_errors, hidden_outputs.T)

self.weights_input_to_hidden += self.mu * np.dot ((hidden_errors * hidden_grad), inputs.T)

def check (self, inputs_list):

# Run a forward pass through the network

inputs = np.array (inputs_list, ndmin=2).T

### forward pass here ###

# Hidden layer

hidden_inputs = np.dot (self.weights_input_to_hidden, inputs)

hidden_outputs = self.actFun (hidden_inputs)

# Output layer

final_inputs = np.dot (self.weights_hidden_to_output, hidden_outputs)

final_outputs = final_inputs

return final_outputs

def error (y_t, y):

return np.mean ((y_t-y)**2)

np.random.seed (42)

nEpochs = 1000

mu = 0.02

nHidden = 10

nOutput = 1

nTuplesPerEpoch = 100

nInputs = train_features.shape[1]

network = NN (nInputs, nHidden, nOutput, mu)

losses = {'train':[], 'validation':[]}

def start (nEpochs):

for e in range (nEpochs):

batch = np.random.choice (train_features.index, size=nTuplesPerEpoch)

for record, target in zip (train_features.ix[batch]. values, train_targets.ix[batch]['age']):

network.learn (record, target)

train_loss = error (network.check (train_features), train_targets['age']. values)

val_loss = error (network.check (val_features), val_targets['age']. values)

sys.stdout.write («Процесс: » + str (100 * e/float (nEpochs))[:4]

+ " % Ошибка обучения: " + str (train_loss)[:10]

+ " Ошибка проверки: " + str (val_loss)[:10])

losses['train']. append (train_loss)

losses['validation']. append (val_loss)

tab = nEpochs, mu, nHidden, nOutput, losses['train'][-1], losses['validation'][-1]

f = open ('info.txt', 'a')

for item in tab:

f.write («%s » % item)

f.write (' ')

f.close

start (nEpochs)

plt.rcParams['figure.figsize'] = (20,8)

plt.plot (losses['train'], label='Train error')

plt.plot (losses['validation'], label='Validation error')

plt.ylim (ymax=0.008)

plt.ylim (ymin=0)

plt.xlim (xmax=900)

plt.legend ()

fig, ax = plt.subplots (figsize=(20,8))

min, max = scaled_features['SeriousDlqin2yrs']

predictions = network.check (test_features) * (max - min) + min

ax.plot (predictions[0], label='Prediction')

ax.plot ((test_targets['SeriousDlqin2yrs'] * (max - min) + min).values, label='Data')

plt.xlim (xmin=10)

plt.xlim (xmax=790)

#plt.xlim (xmin=0)

ax.legend ()

ПРИЛОЖЕНИЕ 2

Таблица моделей: