Кредитный скоринг - это задача классификации: по имеющимся данным, нужно получить функцию, наиболее правильно разделяющую клиентов на «хороших» и «плохих». Для разрешения этой проблемы производится выборка клиентов банковского учреждения, называемая «обучающей» выборкой. Данные в выборке разделяется на два класса: «хорошие» и «плохие» заемщики. Под «плохими» заемщиками подразумеваются клиенты, у которых есть задержка по очередной выплате за 90 дней.

Наиболее распространенными методами являются регрессионные методы.

Во-первых, это линейная множественная (или многофакторная) регрессия:

Где - вектор весовых коэффициентов, - вектор характеристик клиента, а - вероятность оплаты кредита вовремя. Если переменная равняется единице, то это означает, что клиент оплатил кредит вовремя, а если же , то у клиента был дефолт. Под дефолтом понимается наличие просрочки более 90 дней.

Очень часто прибегают к использованию логистической регрессии, т.к. в линейной множественной регрессии слева в уравнении находится вероятность, чьи значения от 0 до 1, а в правой части переменные могут принимать любые значения:

Кроме того, преимущество логистической регрессии еще и в возможности разделения заемщиков как на два класса («хороший» и «плохой»), так и на несколько классов. Например, на 5 групп риска. Однако, в таком случае, необходимы более сложные расчеты для вектора весов , но современная компьютерная база позволяет проводить такие расчеты. Поэтому в данный момент логистическая регрессия лидирует в скоринговых системах.

Ещё одним, достаточно распространенным, методом являются нейронные сети. Это мощный инструмент моделирования для обнаружения и воспроизведения сложных (нелинейных) зависимостей. Этот метод воспроизводит способность биологических нервных систем учиться и исправлять ошибки, имитируя работу низкоуровневой структуры мозга.

Каждая единица нейронной сети (нейрон) является обрабатывающим элементом с заданной единичной функцией. Соединения между нейронами создают сеть, которая позволяет вам определять корреляцию между отдельными данными. Этот алгоритм использует все переменные, автоматически оценивает вклад каждого признака в результаты, учитывая их интерференцию, которая позволяет вам найти сложную нетривиальную зависимость. Можно корректировать веса каждого нейронного дендрита, когда вы вычисляете значение ошибки сигнала для каждого нейрона.

Дерево принятий решений - ещё один метод, применяемый для прогнозирования платежеспособности заемщиков. Это - структура данных, в процессе обхода которой в каждом узле в зависимости от проверяемого условия принимается определенное решение - перемещение по той или иной ветке дерева от корня к «листьевым» (конечным) вершинам. Каждая ветвь дерева решений представляет собой возможное решение, а в «листьевых» вершинах находятся искомые значения.

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

Иногда используют генетический алгоритм, это метод многомерной оптимизации, применяемый для решения задач оптимизации и математического моделирования с использованием подходов, которые аналогичны естественным процессам отбора в природе. Алгоритм представляет собой разновидность вычислений эволюционного характера, благодаря которым решаются оптимизационные задачи, при этом используя методы естественной эволюции (мутации, кроссинговер, отбор, наследование). Основная идея данного алгоритма заключается в большом акценте на использование оператора «скрещивания». В алгоритме происходит три поэтапных процесса: скрещивание, селекция и формирование нового поколения. Если результат после трех шагов не устраивает, то этапы алгоритма будут повторяться до тех пор, пока количество циклов не будет максимумом, определенным заранее или время на мутацию будет исчерпано.

2. ПОСТРОЕНИЕ СКОРИНГОВОЙ МОДЕЛИ

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

С помощью библиотеки pandas можно посмотреть информацию о нашем data frame:

<class 'pandas.core.frame.DataFrame'>

RangeIndex: 150000 entries, 0 to 149999

Data columns (total 11 columns):

SeriousDlqin2yrs 150000 non-null int64

RevolvingUtilizationOfUnsecuredLines 150000 non-null float64

age 150000 non-null int64

NumberOfTime30-59DaysPastDueNotWorse 150000 non-null int64

DebtRatio 150000 non-null float64

MonthlyIncome 120269 non-null float64

NumberOfOpenCreditLinesAndLoans 150000 non-null int64

NumberOfTimes90DaysLate 150000 non-null int64

NumberRealEstateLoansOrLines 150000 non-null int64

NumberOfTime60-89DaysPastDueNotWorse 150000 non-null int64

NumberOfDependents 146076 non-null object

dtypes: float64(4), int64(7)

memory usage: 12.6 MB

Как можно заметить, в данных присутствуют пропуски. В частности, в столбцах MonthlyIncome и NumberOfDependents. Пропуски в NumberOfDependents вероятнее всего связаны с тем, что заемщик при заполнении анкеты под незаполнением имел в виду отсутствие иждивенцев, поэтому их можно заменить нулями. А вот пропуски в MonthlyIncome могут говорить как о безработности заемщика, так и о каких-либо других причинах, которые неясны, поэтому желательно удалить все данные с пропусками в столбце MonthlyIncome.

2.5 Проверка корреляций

При построении скоринговой модели важным моментом является проверка линейной зависимости между количественными переменными. Линейная зависимость между переменными, характеризующими задержку в выплате кредита (типа NumberOfTimeXDaysPastDueNotWorse, где вместо X - число дней просрочки) вполне очевидна, но необходимо проверить есть ли другие зависимости.

Для этого построим матрицу корреляций. Её размер будет 11x11, на строках и столбцах будут названия признаков, а на их пересечениях - коэффициент корреляции, на главной диагонали будут единицы. Для наглядности построим HeatMap этой матрицы с помощью библиотеки seaplot.

Рис.1 HeatMap матрицы корреляций

Как и предполагалось, переменные, характеризующие задержку в выплате кредита, сильно коррелируют между собой (коэффициенты около 0.98).

Но кроме них коррелируют, но уже не так сильно, переменные NumberRealEstateLoansOrLines и NumberOfOpenCreditLinesAndLoans (коэффициент - 0.43).

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

2.6 Предобработка входных данных

Нормировка числовых параметров производилась по следующему правилу:

3. ОПИСАНИЕ РЕАЛИЗАЦИИ

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

Каждая единица нейронной сети (нейрон) является обрабатывающим элементом с заданной единичной функцией. Соединения между нейронами создают сеть, которая позволяет вам определять корреляцию между отдельными данными. Этот алгоритм использует все переменные, автоматически оценивает вклад каждого признака в результаты, учитывая их интерференцию, которая позволяет вам найти сложную нетривиальную зависимость.

Можно корректировать веса каждого нейронного дендрита, когда вы вычисляете значение ошибки сигнала для каждого нейрона.

Чаще всего нейронные сети (НС) являются самым эффективным методом классификации именно за счёт того, что фактически порождают множество моделей регрессии, которые, как было сказано раньше, используются наиболее часто для решения задачи классификации статистическими методами.

Как правило, выделяются три основных вида нейросетей:

? Полносвязные (на рисунке 1, а).

? Многослойные (на рисунке 1, б).

? Слабосвязные, с локальными связями (на рисунке 1, в).

Рис.2 Типы нейронных сетей

3.1 Структура сети

В работе нейронная сеть имеет структуру многослойного персептрона с одним скрытым слоем.

Рис.3 Структура нейронной сети.

Нейронная сеть состоит из входного вектора с размерностью 8, одного скрытого слоя с 6-ю нейронами и выходного значения. Входной вектор умножается на матрицу весовых коэффициентов , где H = 6 - число нейронов на скрытом слое, M = 8 - размерность входного вектора. Далее произведения на каждом нейроне складываются и подаются в функцию активации, в качестве которой выступает сигмоидальная функция:

.

Далее полученные значения умножаются на вектор весовых коэффициентов и складываются. Результат является выходом сети.

3.2 Процедура обучения сети

Набор данных был поделен на обучающую выборку (60000 значений), проверочную (6000) и тестовую (6000). Для обучения сети используется метод обратного распространения ошибки.

Обучение происходит в течение 2000 итераций (эпох). На каждой итерации случайным образом выбираются 100 наборов из обучающей выборки и каждый набор подается на вход сети.

Перед первой итерацией значения весовых коэффициентов инициализируются малыми случайными значениями. Далее на каждой итерации данные значения корректируются в соответствии со следующими правилами:

Где ,

Корректировки весов матрицы :

где - истинное значение, - выход сети,

Обоснование:

Корректировки весов матрицы :

Обоснование:

3.3 Тестирование

После обучения на каждой итерации производится подсчет ошибки на выборке по формуле наименьших квадратов:

здесь - истинное значение, - ответ сети.

Рис.3 Обучение нейронной сети, подсчет ошибки на каждой итерации

Полный код данной реализации на языке программирования Python (Python 3.6, Jupiter Notebook) приведен в Приложении 1.

ЗАКЛЮЧЕНИЕ

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

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

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

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

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

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

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

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

Составило 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 = 60000

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("\rПроцесс: " + 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('\n')

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

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

СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ