Введение и обзор проблемы:

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

Хотя Home Credit в настоящее время использует различные статистические методы и методы машинного обучения, чтобы делать эти прогнозы, они бросают вызов Kagglers, чтобы помочь им раскрыть весь потенциал своих данных. Это гарантирует, что клиенты, способные погасить кредит, не будут отклонены, а кредиты будут предоставлены с основной суммой, сроком погашения и календарем погашения, которые позволят их клиентам добиться успеха.

Постановка задачи:

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

Цели и ограничения реального мира/бизнеса:

1. Нет строгих ограничений по задержке.

Учитывая данные заявки на кредит, нам не нужно предсказывать, собирается ли заявитель погасить кредит в миллисекундах или секундах. Мы можем занять пару минут, чтобы предсказать. Даже 1 час должно хватить. Поскольку у нас нет строгого ограничения задержки, мы можем использовать модели Ensemble, такие как Random forest, Xgboost и т. д.

2. Предсказать вероятность способности каждого претендента погасить кредит.

Предположим, что есть два заявителя A, B, у которых значения вероятности погашения кредита составляют 0,6 и 0,9, поскольку общий порог, рассматриваемый каждой моделью машинного обучения, равен 0,5. Оба заявителя помечены как «погашающие кредит». Но заявитель B с большей вероятностью погасит кредит по сравнению с заявителем A. Если мы прогнозируем вероятности, мы можем установить пороговое значение, например 0,8 или 0,9, исходя из бизнес-требований.

3. Цена неправильной классификации очень высока.

Скажем, для заявителя А наша модель помечена как «Погашение кредита». Таким образом, организация санкционировала кредит для этого заявителя. Но заявитель по каким-то причинам не в состоянии оплатить кредит. Этот тип сценариев является потерей для организации. Следовательно, мы должны придумать модель, которая может максимально уменьшить количество ошибочных классификаций.

4. Интерпретируемость отчасти важна.

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

Метрика производительности:

В этой задаче данные несбалансированы. Поэтому мы не можем использовать точность в качестве метрики ошибки. Когда данные несбалансированы, мы можем использовать логарифмическую потерю, F1-оценку и AUC. Здесь мы придерживаемся AUC, который может обрабатывать несбалансированные наборы данных.

Описание и обзор данных:

Существует 7 различных источников данных:

  • application_train/application_test: основные обучающие данные с информацией о каждой кредитной заявке в Home Credit. Каждый кредит имеет свою строку и идентифицируется функцией SK_ID_CURR. Данные заявки на обучение поставляются с TARGET, указывающим 0: кредит был погашен или 1: кредит не был погашен. Здесь мы будем использовать только данные обучения.
  • бюро: в этом наборе данных он состоит из данных о предыдущих кредитах клиента в других финансовых учреждениях. Каждый предыдущий кредит имеет свою строку в бюро, но один кредит в данных заявки может иметь несколько предыдущих кредитов.
  • бюро_баланс: состоит из ежемесячных данных о предыдущих кредитах в бюро. Каждая строка представляет собой один месяц предыдущего кредита, а один предыдущий кредит может иметь несколько строк, по одной на каждый месяц длины кредита.
  • previous_application: данные о предыдущих заявках на кредиты в Home Credit клиентов, у которых есть кредиты в данных заявки. Каждый текущий кредит в данных приложения может иметь несколько предыдущих кредитов. Каждое предыдущее приложение имеет одну строку и определяется функцией SK_ID_PREV.
  • POS_CASH_BALANCE: содержит ежемесячные данные о предыдущих торговых точках или кредитах наличными, которые клиенты имели в Home Credit. Каждая строка представляет собой один месяц предыдущей торговой точки или ссуды наличными, а одна предыдущая ссуда может иметь много строк.
  • credit_card_balance: Ежемесячные данные о предыдущих кредитных картах, которые клиенты использовали в Home Credit. Каждая строка представляет собой баланс кредитной карты за один месяц, а одна кредитная карта может иметь много строк.
  • installments_payment: данные истории платежей по предыдущим кредитам в Хоум Кредит. Существует одна строка для каждого сделанного платежа и одна строка для каждого пропущенного платежа.

Сопоставление с проблемой машинного обучения:

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

Источник данных:

Мы можем получить полные данные, необходимые для этой проблемы, по ссылке: https://www.kaggle.com/c/home-credit-default-risk/data.

Исследовательский анализ данных:

%matplotlib inline
import warnings
warnings.filterwarnings («игнорировать»)

импортировать sqlite3
импортировать pandas как pd
импортировать numpy как np
импортировать nltk
импортировать строку
импортировать matplotlib.pyplot как plt
импортировать seaborn как sns
из sklearn.feature_extraction.text импортировать TfidfTransformer
из sklearn.feature_extraction.text импортировать TfidfVectorizer

из sklearn.feature_extraction.text импортировать CountVectorizer
из sklearn.metrics импортировать путаницу_матрицу
из sklearn импортировать метрики
из sklearn.metrics импортировать roc_curve, auc
из nltk.stem.porter импортировать PorterStemmer

import re
# Учебник по регулярным выражениям Python: https://pymotw.com/2/re/
import string
from nltk.corpus import стоп-слова
from nltk. импорт ствола PorterStemmer
из nltk.stem.wordnet импорт WordNetLemmatizer

из gensim.models импортировать Word2Vec
из gensim.models импортировать KeyedVectors
импортировать pickle

из tqdm import tqdm
import os

from plotly import plotly
import plotly.offline as offline
import plotly.graph_objs as go
offline.init_notebook_mode()
from collections import Counter
from sklearn.linear_model import Логистическая регрессия

application_data = pd.read_csv('application_train.csv')
Bureau_data = pd.read_csv('bureau.csv')
Bureau_balance_data = pd.read_csv('bureau_balance.csv')
credit_card_balance_data = pd.read_csv('credit_card_balance.csv')
HomeCredit_columns_description_data = pd.read_csv('HomeCredit_columns_description.csv',encoding = 'unicode_escape')
installments_payments_data = pd.read_csv('installments_payments.csv')
POS_CASH_balance_data = pd.read_csv('POS_CASH_balance.csv')
previous_application_data = pd.read_csv('previous_application.csv')
application_test_data = pd.read_csv('application_test.csv')
sample_submission_data = pd.read_csv('sample_submission.csv')

print("Данные поезда приложения:",application_data.shape)
print(" — — — — — — — — — — — — — — — — — — — — — — — — — »)< br /> print("Бюро данных:",bureau_data.shape)
print(" — — — — — — — — — — — — — — — — — — — — — — — — — — ” )
print("Бюро Баланс данных:", bureau_balance_data.shape)
print(" — — — — — — — — — — — — — — — — — — — — — — — — — — »)
print("Данные баланса кредитной карты:",credit_card_balance_data.shape)
print(" — — — — — — — — — — — — — — — — — — — — — — — — — — »)
print («Данные описания домашнего кредита:», HomeCredit_columns_description_data.shape)
print(“ — — — — — — — — — — — — — — — — — — — — — — — — — — — »)
print («Данные платежа в рассрочку:», installments_payments_data.shape)
print(“ — — — — — — — — — — — — — — — — — — — — — — — — — — »)
print («Данные об остатке денежных средств на кассе:», POS_CASH_balance_data.shape)
print (« — — — — — — — — — — — — — — — — — — — — — — — — — — — »)
print(«Данные предыдущего приложения: », предыдущее_приложение_data.shape)
print(“ — — — — — — — — — — — — — — — — — — — — — — — — — — »)
print(“Приложение Тестовые данные:",application_test_data.shape)
print(" — — — — — — — — — — — — — — — — — — — — — — — — — — »)
print («Данные отправки образца:», sample_submission_data.shape)

EDA для прикладных данных

График процента пользователей, способных погасить кредит

y_value_counts = application_data['ЦЕЛЬ'].value_counts()

print("Количество проблемных кредитов ", y_value_counts[1], ", (", (y_value_counts[1]/(y_value_counts[1]+y_value_counts[0]))*100,"%)")

print("Количество кредитов, у которых нет проблем ", y_value_counts[0], ", (", (y_value_counts[0]/(y_value_counts[1]+y_value_counts[0]))*100,"%)")

рис, топор = plt.subplots (figsize = (6, 6), subplot_kw = dict (аспект = «равный»))

recipe = ["С проблемой", "Без проблемы"]

данные = [y_value_counts[1], y_value_counts[0]]

клинья, тексты = ax.pie (данные, клинья = dict (ширина = 0,5), начальный угол = -40)

bbox_props = dict (boxstyle = «квадрат, pad = 0,3, fc = «w», ec = «k», lw = 0,72)

kw = dict(xycoords='данные', textcoords='данные', arrowprops=dict(arrowstyle="-"),

bbox=bbox_props, zorder=0, va=”центр”)

для i, p в перечислении (клиньях):

угол = (p.theta2 — p.theta1)/2. + п.тета1

y = np.sin(np.deg2rad(ang))

х = np.cos (np.deg2rad (анг))

горизонтальное выравнивание = {-1: «вправо», 1: «влево»} [int (np.sign (x))]

стиль соединения = «угол, угол A = 0, угол B = {}». формат (анг)

kw["arrowprops"].update({"connectionstyle": connectionstyle})

ax.annotate (рецепт [i], xy = (x, y), xytext = (1,35 * np.sign (x), 1,4 * y),

горизонтальное выравнивание = горизонтальное выравнивание, ** кВт)

ax.set_title («Круговая диаграмма кредитов»)

plt.show()

Вывод: Целевой переменной является несбалансированность, при этом у большинства кредитов целевое значение равно 0, что указывает на то, что у физических лиц не было проблем с оплатой взносов в данный момент времени. Около 91% кредитов не имеют проблем, в то время как только 9% от общего числа кредитов в этом наборе данных связаны с заявителями, имеющими проблемы с погашением кредита / внесением платежей.

Участок для NAME_CONTRACT_TYPE

y_value_counts = application_data['NAME_CONTRACT_TYPE'].value_counts()
print("Вращение", y_value_counts[1], ", (", (y_value_counts[1]/(y_value_counts[1]+y_value_counts[0])) *100, "%)")
print("Кредит наличными", y_value_counts[0], ", (", (y_value_counts[0]/(y_value_counts[1]+y_value_counts[0]))*100, ”%)”)

fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(aspect=”equal”))
recipe = [«Револьверный», «Кредит наличными»]

данные = [y_value_counts[1], y_value_counts[0]]

клинья, тексты = ax.pie (данные, клинья = dict (ширина = 0,5), начальный угол = -40)

bbox_props = dict(boxstyle=”квадрат,pad=0,3, fc=”w”, ec=”k”, lw=0,72)
kw = dict(xycoords='data', textcoords='data', arrowprops =dict(arrowstyle=”-”),
bbox=bbox_props, zorder=0, va=”center”)

для i, p в enumerate(клиньях):
ang = (p.theta2 — p.theta1)/2. + p.theta1
y = np.sin(np.deg2rad(ang))
x = np.cos(np.deg2rad(ang))
horizontalalignment = {-1: «right ", 1: "left"}[int(np.sign(x))]
connectionstyle = "angle,angleA=0,angleB={}".format(ang)
kw["arrowprops ”].update({“connectionstyle”: connectionstyle})
ax.annotate(recipe[i], xy=(x, y), xytext=(1.35*np.sign(x), 1.4*y) ,
horizontalalignment=horizontalalignment, **кВт)

ax.set_title («Круговая диаграмма кредитов»)

plt.show()

Вывод: около 90% кредитов являются кредитами наличными, в то время как только 10% от общего числа кредитов в этом наборе данных являются возобновляемыми кредитами.

Сюжет для Пола, который берет кредит

y_value_counts = application_data['CODE_GENDER'].value_counts()
print("Мужской", y_value_counts[1], ", (", (y_value_counts[1]/(y_value_counts[1]+y_value_counts[0])) *100, "%)")
print("Женщина ", y_value_counts[0], ", (", (y_value_counts[0]/(y_value_counts[1]+y_value_counts[0]))*100," %)")

fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(aspect=”equal”))
recipe = [“Мужской”, “Женский”]

данные = [y_value_counts[1], y_value_counts[0]]

клинья, тексты = ax.pie (данные, клинья = dict (ширина = 0,5), начальный угол = -40)

bbox_props = dict(boxstyle=”квадрат,pad=0,3, fc=”w”, ec=”k”, lw=0,72)
kw = dict(xycoords='data', textcoords='data', arrowprops =dict(arrowstyle=”-”),
bbox=bbox_props, zorder=0, va=”center”)

для i, p в enumerate(клиньях):
ang = (p.theta2 — p.theta1)/2. + p.theta1
y = np.sin(np.deg2rad(ang))
x = np.cos(np.deg2rad(ang))
horizontalalignment = {-1: «right ", 1: "left"}[int(np.sign(x))]
connectionstyle = "angle,angleA=0,angleB={}".format(ang)
kw["arrowprops ”].update({“connectionstyle”: connectionstyle})
ax.annotate(recipe[i], xy=(x, y), xytext=(1.35*np.sign(x), 1.4*y) ,
horizontalalignment=horizontalalignment, **кВт)

ax.set_title («Круговая диаграмма пола»)

plt.show()

Вывод: около 65% кредитов было взято женщинами, а 35% от общего числа кредитов в этом наборе данных было взято мужчинами.

Распределение для детей

t = application_data["CNT_CHILDREN"].value_counts()
t1 = pd.DataFrame()
t1['x'] = t.index
t1['y'] = t. ценности

plt.figure(figsize=(12,5));
plt.title("Распределение количества детей у заявителей");
ax = sns.barplot(data=t1, x=”x” , y=”y”, color=”#f975ae”);
ax.spines['right'].set_visible(False);
ax.spines['top'].set_visible(False) ;

ax.set_ylabel('');
ax.set_xlabel('');

Вывод: у большинства из них нет детей или есть 1 или 2 ребенка.

Распределение по семейному статусу

t = application_data["NAME_FAMILY_STATUS"].value_counts()
t1 = pd.DataFrame()
t1['x'] = t.index
t1['y'] = t. ценности

plt.figure(figsize=(12,5));
plt.title("Распределение семейного статуса");
ax = sns.barplot(data=t1, x="x", y= ”y”, color=”#f975ae”);
ax.spines['right'].set_visible(False);
ax.spines['top'].set_visible(False);

ax.set_ylabel('');
ax.set_xlabel('');

Вывод: Большинство из тех, кто взял кредит, женаты.

Распределение для Amt_Credit

plt.figure(figsize=(12,5))
plt.title("Распределение AMT_CREDIT")
ax = sns.distplot(application_data["AMT_CREDIT"])

Распределение AMT_GOODS_PRICE

plt.figure(figsize=(12,5))
plt.title("Распределение A

MT_GOODS_PRICE")
ax = sns.distplot(application_data["AMT_GOODS_PRICE"].dropna())

EDA для данных бюро

Функция для получения категориальных признаков для подготовки данных

# функция для получения категориальных признаков
def _get_categorical_features(df):
feats = [col for col in list(df.columns) if df[col].dtype == 'object']
ответные подвиги

# функция для факторизации категориальных признаков
def _factorize_categoricals(df, Cats):
for col в Cats:
df[col], _ = pd.factorize(df[col])
вернуть ДФ

# функция для создания фиктивных переменных категориальных признаков
def _get_dummies(df, Cats):
для col в Cats:
df = pd.concat([df, pd.get_dummies(df[col ], prefix=col)], axis=1)
return df

Заполнение нулевых значений нулем

x_train.fillna(0, inplace=True)
x_val.fillna(0, inplace=True)
testX.fillna(0, inplace=True)

Применение моделей машинного обучения

Модель 1: KNN с настройкой гиперпараметров

из sklearn.neighbors импортировать KNeighborsClassifier
из sklearn.coding импортировать CalibratedClassifierCV
из sklearn.metrics импортировать точность_оценки
fpr_val_knn = dict()
tpr_val_knn = dict()
roc_auc_val_knn = дикт()

fpr_train_knn = dict()
tpr_train_knn = dict()
roc_auc_train_knn = dict()
alpha = [5, 15, 31, 51, 99]
для i в альфе:< br />
clf = KNeighborsClassifier(n_neighbors=i)
clf.fit(x_train, y_train)
pred_train = clf.predict_proba(x_train)[:,1]
fpr_train_knn[ i], tpr_train_knn[i], thresholds = metrics.roc_curve(y_train, pred_train, pos_label=1)
roc_auc_train_knn[i] = metrics.auc(fpr_train_knn[i], tpr_train_knn[i])
< br /> pred_val = clf.predict_proba(x_val)[:,1]
fpr_val_knn[i], tpr_val_knn[i], thresholds = metrics.roc_curve(y_val, pred_val, pos_label=1)
roc_auc_val_knn[ i] = metrics.auc(fpr_val_knn[i], tpr_val_knn[i])

#Построение графика между гиперпараметром и ROC-кривой
из matplotlib.pyplot import *
t=[]
roc_auc_train_array_knn=[]
roc_auc_val_array_knn=[]
alpha = [ 5, 15, 31, 51, 99]
для i в альфа-версии:
t.append(i)
roc_auc_train_array_knn.append(roc_auc_train_knn[i])
roc_auc_val_array_knn.append( roc_auc_val_knn[i])


plt.xlabel('Гиперпараметр')
plt.ylabel('Площадь под ROC-кривой')

plot(t, roc_auc_train_array_knn, 'r-')
plot(t, roc_auc_val_array_knn, 'b-')
plt.title('Гиперпараметр и кривая ROC')
plt.plot(t , roc_auc_train_array_knn, label = «Обучающие данные»)
plt.plot(t, roc_auc_val_array_knn, label = «CV Data»)
plt.legend()
show()

На приведенном выше графике k=99 представляет собой точку, в которой разница между AUC поезда и AUC cv меньше. Итак, мы будем обучать модель при k=99.

clf = KNeighborsClassifier(n_neighbors=99)
clf.fit(x_train, y_train)
pred_val_log_knn = clf.predict_proba(testX)[:,1]

#Вместе с построением ROC-кривой необходимо распечатать матрицу путаницы с предсказанными и исходными метками точек тестовых данных
plt.figure()
lw = 2
plt.plot(fpr_train_knn[99 ], tpr_train_knn[99], color='darkorange',
lw=lw, label='Кривая ROC для поезда (площадь = %0,2f)' % roc_auc_train_knn[99])
plt.plot( fpr_val_knn[99], tpr_val_knn[99], color='red',
lw=lw, label='ROC-кривая для проверки (площадь = %0,2f)' % roc_auc_val_knn[99])
plt .plot([0, 1], [0, 1], color='navy', lw=lw, linestyle=' — ')
plt.xlim([0.0, 1.0])
plt .ylim([0,0, 1,05])
plt.xlabel('Коэффициент ложных срабатываний')
plt.ylabel('Коэффициент истинных срабатываний')
plt.title('Пример рабочей характеристики приемника ')
plt.legend(loc="нижний правый")
plt.show()

Вывод: KNN при k = 99 получает AUC 0,61 по данным CV.

Модель 2: логистическая регрессия с настройкой гиперпараметров

из sklearn.linear_model импортировать LogisticRegression
из sklearn.linear_model импортировать SGDClassifier
из sklearn.coding импортировать CalibratedClassifierCV
из sklearn.metrics импортировать точность_оценки
fpr_val_log = dict()
tpr_val_log = dict()
roc_auc_val_log = dict()

fpr_train_log = dict()
tpr_train_log = dict()
roc_auc_train_log = dict()
alpha = [10 ** x для x в диапазоне (-4, 4)]
для я в альфа-канале:

clf = SGDClassifier (альфа = i, штраф = 'l2', loss = 'log', random_state = 42)
clf.fit (x_train, y_train)
pred_train_log = clf.predict_proba(x_train)[:,1]
fpr_train_log[i], tpr_train_log[i], thresholds = metrics.roc_curve(y_train, pred_train_log, pos_label=1)
roc_auc_train_log[i ] = metrics.auc(fpr_train_log[i], tpr_train_log[i])

pred_val_log = clf.predict_proba(x_val)[:,1]
fpr_val_log[i], tpr_val_log[i] , пороги = metrics.roc_curve(y_val, pred_val_log, pos_label=1)
roc_auc_val_log[i] = metrics.auc(fpr_val_log[i], tpr_val_log[i])

#Построение графика между гиперпараметром и ROC-кривой
из matplotlib.pyplot import *
t=[]
roc_auc_train_array=[]
roc_auc_val_array=[]
alpha = [ 10 ** x для x в диапазоне (-4, 4)]
для i в альфа-канале:
t.append(i)
roc_auc_train_array.append(roc_auc_train_log[i])
> roc_auc_val_array.append(roc_auc_val_log[i])


plt.xlabel('Гиперпараметр')
plt.ylabel('Площадь под ROC-кривой')

plot(t, roc_auc_train_array, 'r-')
plot(t, roc_auc_val_array, 'b-')
plt.title('Гиперпараметр и кривая ROC')
plt.plot(t , roc_auc_train_array, label = «Обучающие данные»)
plt.plot(t, roc_auc_val_array, label = «CV Data»)
plt.legend()
show()

При альфа = 1000 мы получаем AUC данных о поездах, а также данные перекрестной проверки, как высокие, так и высокие.

clf = SGDClassifier(class_weight='balanced', alpha=1000, Penal='l2', loss='log', random_state=42)
clf.fit(x_train, y_train)
pred_val_log = clf. прогноз_вероятность (тестX) [:, 1]

#Вместе с построением ROC-кривой необходимо распечатать матрицу путаницы с предсказанными и исходными метками точек тестовых данных
plt.figure()
lw = 2
plt.plot(fpr_train_log[1000 ], tpr_train_log[1000], color='darkorange',
lw=lw, label='Кривая ROC для поезда (площадь = %0,2f)' % roc_auc_train_log[1000])
plt.plot( fpr_val_log[1000], tpr_val_log[1000], color='red',
lw=lw, label='ROC-кривая для проверки (площадь = %0,2f)' % roc_auc_val_log[1000])
plt .plot([0, 1], [0, 1], color='navy', lw=lw, linestyle=' — ')
plt.xlim([0.0, 1.0])
plt .ylim([0,0, 1,05])
plt.xlabel('Коэффициент ложных срабатываний')
plt.ylabel('Коэффициент истинных срабатываний')
plt.title('Пример рабочей характеристики приемника ')
plt.legend(loc="нижний правый")
plt.show()

Вывод: AUC = 0,64 для логистической регрессии.

Модель 3: SVM с настройкой гиперпараметров

из sklearn.linear_model импортировать LogisticRegression
из sklearn.linear_model импортировать SGDClassifier
из sklearn.coding импортировать CalibratedClassifierCV
из sklearn.metrics импортировать точность_оценки
fpr_val_svm = dict()
tpr_val_svm = dict()
roc_auc_val_svm = dict()

fpr_train_svm = dict()
tpr_train_svm = dict()
roc_auc_train_svm = dict()
alpha = [10 ** x для x в диапазоне (-4, 4)]
для я в альфе:

clf = SGDClassifier (class_weight = 'сбалансированный', alpha = i, штраф = 'l2', loss = 'шарнир', random_state = 42)
clf.fit( x_train, y_train)
sig_clf = CalibratedClassifierCV(base_estimator=clf, method='sigmoid',cv='prefit')
sig_clf.fit(x_train, y_train)
pred_train = sig_clf.predict_proba( x_train)[:,1]
fpr_train_svm[i], tpr_train_svm[i], thresholds = metrics.roc_curve(y_train, pred_train, pos_label=1)
roc_auc_train_svm[i] = metrics.auc(fpr_train_svm[ i], tpr_train_svm[i])

pred_val = sig_clf.predict_proba(x_val)[:,1]
fpr_val_svm[i], tpr_val_svm[i], thresholds = metrics.roc_curve(y_val , pred_val, pos_label=1)
roc_auc_val_svm[i] = metrics.auc(fpr_val_svm[i], tpr_val_svm[i])

#Построение графика между гиперпараметром и кривой ROC
из matplotlib.pyplot import *
t=[]
roc_auc_train_array_svm=[]
roc_auc_val_array_svm=[]
alpha = [ 10 ** x для x в диапазоне (-4, 4)]
для i в альфа-канале:
t.append(i)
roc_auc_train_array_svm.append(roc_auc_train_svm[i])
> roc_auc_val_array_svm.append(roc_auc_val_svm[i])


plt.xlabel('Гиперпараметр')
plt.ylabel('Площадь под ROC-кривой')

plot(t, roc_auc_train_array_svm, 'r-')
plot(t, roc_auc_val_array_svm, 'b-')
plt.title('Гиперпараметр и кривая ROC')
plt.plot(t , roc_auc_train_array_svm, label = «Обучающие данные»)
plt.plot(t, roc_auc_val_array_svm, label = «CV Data»)
plt.legend()
show()

При альфа = 1000 мы получаем AUC данных о поездах, а также данные перекрестной проверки, как высокие, так и высокие.

clf = SGDClassifier(class_weight='сбалансированный', alpha=1000, Penal='l2', loss='шарнир', random_state=42)
clf.fit(x_train, y_train)
sig_clf = CalibratedClassifierCV( base_estimator=clf, method='sigmoid',cv='prefit')
sig_clf.fit(x_train, y_train)
pred_val_log_svm = sig_clf.predict_proba(testX)[:,1]

#Вместе с построением ROC-кривой необходимо распечатать матрицу путаницы с предсказанными и исходными метками точек тестовых данных
plt.figure()
lw = 2
plt.plot(fpr_train_svm[1000 ], tpr_train_svm[1000], color='darkorange',
lw=lw, label='Кривая ROC для поезда (площадь = %0.2f)' % roc_auc_train_svm[1000])
plt.plot( fpr_val_svm[1000], tpr_val_svm[1000], color='red',
lw=lw, label='ROC-кривая для проверки (площадь = %0,2f)' % roc_auc_val_svm[1000])
plt .plot([0, 1], [0, 1], color='navy', lw=lw, linestyle=' — ')
plt.xlim([0.0, 1.0])
plt .ylim([0,0, 1,05])
plt.xlabel('Коэффициент ложных срабатываний')
plt.ylabel('Коэффициент истинных срабатываний')
plt.title('Пример рабочей характеристики приемника ')
plt.legend(loc="нижний правый")
plt.show()

Вывод: AUC = 0,64 для SVM.

Модель 4: наивный байесовский алгоритм с настройкой гиперпараметров

из sklearn.linear_model импортировать LogisticRegression
из sklearn.linear_model импортировать SGDClassifier
из sklearn.calibration импортировать CalibratedClassifierCV
из sklearn.metrics импортировать точность_оценки
из sklearn.naive_bayes импортировать GaussianNB
fpr_val_nb = dict()
tpr_val_nb = dict()
roc_auc_val_nb = dict()

fpr_train_nb = dict()
tpr_train_nb = dict()
roc_auc_train_nb = dict()
alpha = [10 ** x для x в диапазоне (-10, 1)]
для i в альфа-канале:

clf = GaussianNB(var_smoothing=i)
clf.fit(x_train, y_train)
sig_clf = CalibratedClassifierCV(base_estimator=clf, method='sigmoid', cv='prefit')
sig_clf.fit(x_train, y_train)
pred_train = sig_clf.predict_proba(x_train)[:,1]
fpr_train_nb[i], tpr_train_nb[i], пороги = metrics.roc_curve(y_train, pred_train, pos_label=1)
roc_auc_train_nb[i] = metrics.auc(fpr_train_nb[i], tpr_train_nb[i])

pred_val = sig_clf.predict_proba( x_val)[:,1]
fpr_val_nb[i], tpr_val_nb[i], пороги = metrics.roc_curve(y_val, pred_val, pos_label=1)
roc_auc_val_nb[i] = metrics.auc(fpr_val_nb[ i], tpr_val_nb[i])

#Построение графика между гиперпараметром и кривой ROC
из matplotlib.pyplot import *
t=[]
roc_auc_train_array_nb=[]
roc_auc_val_array_nb=[]
alpha = [ 10 ** x для x в диапазоне (-10, 1)]
для i в альфа-канале:
t.append(i)
roc_auc_train_array_nb.append(roc_auc_train_nb[i])
> roc_auc_val_array_nb.append(roc_auc_val_nb[i])


plt.xlabel('Гиперпараметр')
plt.ylabel('Площадь под ROC-кривой')

plot(t, roc_auc_train_array_nb, 'r-')
plot(t, roc_auc_val_array_nb, 'b-')
plt.title('Гиперпараметр и кривая ROC')
plt.plot(t , roc_auc_train_array_nb, label = «Обучающие данные»)
plt.plot(t, roc_auc_val_array_nb, label = «CV Data»)
plt.legend()
show()

clf = GaussianNB(var_smoothing=1e-10)
clf.fit(x_train, y_train)
sig_clf = CalibratedClassifierCV(base_estimator=clf, method='sigmoid',cv='prefit')
sig_clf.fit(x_train, y_train)
pred_val_log_nb = sig_clf.predict_proba(testX)[:,1]

#Вместе с построением ROC-кривой необходимо распечатать матрицу путаницы с предсказанными и исходными метками точек тестовых данных
plt.figure()
lw = 2
plt.plot(fpr_train_nb[1e -10], tpr_train_nb[1e-10], color='darkorange',
lw=lw, label='Кривая ROC для поезда (площадь = %0,2f)' % roc_auc_train_nb[1e-10])
plt.plot(fpr_val_nb[1e-10], tpr_val_nb[1e-10], color='red',
lw=lw, label='ROC-кривая для проверки (площадь = %0.2f)' % roc_auc_val_nb[1e-10])
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle=' — ')
plt.xlim ([0,0, 1,0])
plt.ylim([0,0, 1,05])
plt.xlabel('Коэффициент ложных срабатываний')
plt.ylabel('Коэффициент истинных срабатываний')< br /> plt.title('Пример рабочих характеристик приемника')
plt.legend(loc="нижний правый")
plt.show()

Вывод: AUC = 0,62 для гауссовского наивного байеса.

Модель 5: дерево решений с настройкой гиперпараметров для max_depth=10

fpr_val_dt = dict()
tpr_val_dt = dict()
roc_auc_val_dt_5 = dict()
roc_auc_val_dt_10=dict()

fpr_train_dt = dict()
tpr_train_dt = dict()
roc_auc_train_dt_5 = dict()
roc_auc_train_dt_10 = dict()
alpha = [100,200,500,1000,2000]
max_depth = [5, 10]
для i в альфа-канале:
print("для альфа-канала =", i)
print("для max_depth =10")
clf = DecisionTreeClassifier( max_depth=i,min_samples_split=10)
clf.fit(x_train, y_train)
pred_train = clf.predict_proba(x_train)[:,1]
fpr_train_dt[i], tpr_train_dt[i] , пороги = metrics.roc_curve(y_train, pred_train, pos_label=1)
roc_auc_train_dt_10[i] = metrics.auc(fpr_train_dt[i], tpr_train_dt[i])

pred_val = clf.predict_proba(x_val)[:,1]
fpr_val_dt[i], tpr_val_dt[i], thresholds = metrics.roc_curve(y_val, pred_val, pos_label=1)
roc_auc_val_dt_10[i] = metrics.auc(fpr_val_dt[i], tpr_val_dt[i])

#Построение графика между гиперпараметром и ROC-кривой
из matplotlib.pyplot import *
t=[]
roc_auc_train_array_dt=[]
roc_auc_val_array_dt=[]
alpha = [ 100 200 500 1000 2000]
для i в альфа-версии:
t.append(i)
roc_auc_train_array_dt.append(roc_auc_train_dt_10[i])
roc_auc_val_array_dt.append(roc_auc_val_dt_10[i] )


plt.xlabel('Гиперпараметр')
plt.ylabel('Площадь под ROC-кривой')

plot(t, roc_auc_train_array_dt, 'r-')
plot(t, roc_auc_val_array_dt, 'b-')
plt.title('Гиперпараметр и кривая ROC')
plt.plot(t , roc_auc_train_array_dt, label = «Обучающие данные»)
plt.plot(t, roc_auc_val_array_dt, label = «CV Data»)
plt.legend()
show()

clf = DecisionTreeClassifier(max_depth=100,min_samples_split=10)
clf.fit(x_train, y_train)
pred_val_log_dt = clf.predict_proba(testX)[:,1]

#Вместе с построением ROC-кривой необходимо распечатать матрицу путаницы с предсказанными и исходными метками точек тестовых данных
plt.figure()
lw = 2
plt.plot(fpr_train_dt[100 ], tpr_train_dt[100], color='darkorange',
lw=lw, label='Кривая ROC для поезда (площадь = %0.2f)' % roc_auc_train_dt_10[100])
plt.plot( fpr_val_dt[100], tpr_val_dt[100], color='red',
lw=lw, label='ROC-кривая для проверки (площадь = %0,2f)' % roc_auc_val_dt_10[100])
plt .plot([0, 1], [0, 1], color='navy', lw=lw, linestyle=' — ')
plt.xlim([0.0, 1.0])
plt .ylim([0,0, 1,05])
plt.xlabel('Коэффициент ложных срабатываний')
plt.ylabel('Коэффициент истинных срабатываний')
plt.title('Пример рабочей характеристики приемника ')
plt.legend(loc="нижний правый")
plt.show()

Вывод: AUC = 0,55 при max_depth = 100 и min_samples_split = 10 для дерева решений.

Модель 6: случайный лес с настройкой гиперпараметров

fpr_val_rf = dict()
tpr_val_rf = dict()
roc_auc_val_rf_5 = dict()
roc_auc_val_rf_10 = dict()

fpr_train_rf = dict()
tpr_train_rf = dict()
roc_auc_train_rf_5 = dict()
roc_auc_train_rf_10 = dict()
alpha = [100,200,500,1000,2000]
max_depth = [5, 10]
для i в альфа:

print("для альфа =", i)
print("для max_depth =10")
clf = RandomForestClassifier(n_estimators=i, критерий='gini', max_depth=10, random_state=42, n_jobs=-1)
clf.fit(x_train, y_train)
pred_train = clf.predict_proba(x_train )[:,1]
fpr_train_rf[i], tpr_train_rf[i], пороги = metrics.roc_curve(y_train, pred_train, pos_label=1)
roc_auc_train_rf_10[i] = metrics.auc(fpr_train_rf[i ], tpr_train_rf[i])

pred_val = clf.predict_proba(x_val)[:,1]
fpr_val_rf[i], tpr_val_rf[i], thresholds = metrics.roc_curve(y_val, pred_val, pos_label=1)
roc_auc_val_rf_10[i] = metrics.auc(fpr_val_rf[i], tpr_val_rf[i])

#Построение графика между гиперпараметром и ROC-кривой
из matplotlib.pyplot import *
t=[]
roc_auc_train_array_rf=[]
roc_auc_val_array_rf=[]
alpha = [ 100 200 500 1000 2000]
для i в альфа-версии:
t.append(i)
roc_auc_train_array_rf.append(roc_auc_train_rf_10[i])
roc_auc_val_array_rf.append(roc_auc_val_rf_10[i] )


plt.xlabel('Гиперпараметр')
plt.ylabel('Площадь под ROC-кривой')

plot(t, roc_auc_train_array_rf, 'r-')
plot(t, roc_auc_val_array_rf, 'b-')
plt.title('Гиперпараметр и кривая ROC')
plt.plot(t , roc_auc_train_array_rf, label = «Обучающие данные»)
plt.plot(t, roc_auc_val_array_rf, label = «CV Data»)
plt.legend()
show()

clf = RandomForestClassifier(n_estimators=100,max_depth=10)
clf.fit(x_train, y_train)
pred_val_log_rf = clf.predict_proba(testX)[:,1]

#Вместе с построением ROC-кривой необходимо распечатать матрицу путаницы с предсказанными и исходными метками точек тестовых данных
plt.figure()
lw = 2
plt.plot(fpr_train_rf[100 ], tpr_train_rf[100], color='darkorange',
lw=lw, label='Кривая ROC для поезда (площадь = %0,2f)' % roc_auc_train_rf_10[100])
plt.plot( fpr_val_rf[100], tpr_val_rf[100], color='red',
lw=lw, label='ROC-кривая для проверки (площадь = %0,2f)' % roc_auc_val_rf_10[100])
plt .plot([0, 1], [0, 1], color='navy', lw=lw, linestyle=' — ')
plt.xlim([0.0, 1.0])
plt .ylim([0,0, 1,05])
plt.xlabel('Коэффициент ложных срабатываний')
plt.ylabel('Коэффициент истинных срабатываний')
plt.title('Пример рабочей характеристики приемника ')
plt.legend(loc="нижний правый")
plt.show()

Вывод: AUC = 0,74 для n_estimators = 100 и max_depth = 10 в случайном лесу.

Модель 7 a: XGBoost с настройкой гиперпараметров max_depth=5

из sklearn.linear_model импортировать LogisticRegression
из sklearn.linear_model импортировать SGDClassifier
из sklearn.calibration импортировать CalibratedClassifierCV
из sklearn.metrics импортировать точность_оценки
из xgboost импортировать XGBClassifier
fpr_val_xgb = dict()
tpr_val_xgb = dict()
roc_auc_val_xgb_5 = dict()

fpr_train_xgb = dict()
tpr_train_xgb = dict()
roc_auc_train_xgb_5 = dict()

alpha = [100,200,500,1000,2000]
max_depth = [5, 10]
для i в альфа:

clf = XGBClassifier(n_estimators=i, max_depth=5, n_jobs =-1)
clf.fit(x_train, y_train)
pred_train = clf.predict_proba(x_train)[:,1]
fpr_train_xgb[i], tpr_train_xgb[i], пороги = метрики .roc_curve(y_train, pred_train, pos_label=1)
roc_auc_train_xgb_5[i] = metrics.auc(fpr_train_xgb[i], tpr_train_xgb[i])

pred_val = clf.predict_proba(x_val) [:,1]
fpr_val_xgb[i], tpr_val_xgb[i], пороги = metrics.roc_curve(y_val, pred_val, pos_label=1)
roc_auc_val_xgb_5[i] = metrics.auc(fpr_val_xgb[i] , tpr_val_xgb[i])

#Построение графика между гиперпараметром и кривой ROC
из matplotlib.pyplot import *
t=[]
roc_auc_train_array_xgb=[]
roc_auc_val_array_xgb=[]
alpha = [ 100 200 500 1000 2000]
для i в альфа-версии:
t.append(i)
roc_auc_train_array_xgb.append(roc_auc_train_xgb_5[i])
roc_auc_val_array_xgb.append(roc_auc_val_xgb_5[i] )


plt.xlabel('Гиперпараметр')
plt.ylabel('Площадь под ROC-кривой')

plot(t, roc_auc_train_array_xgb, 'r-')
plot(t, roc_auc_val_array_xgb, 'b-')
plt.title('Гиперпараметр и кривая ROC')
plt.plot(t , roc_auc_train_array_xgb, label = «Обучающие данные»)
plt.plot(t, roc_auc_val_array_xgb, label = «CV Data»)
plt.legend()
show()

Модель 7 b: XGBoost с настройкой гиперпараметров max_depth=10

fpr_val_xgb = dict()
tpr_val_xgb = dict()

roc_auc_val_xgb_10 = дикт()

fpr_train_xgb = dict()
tpr_train_xgb = dict()

roc_auc_train_xgb_10 = dict()
alpha = [100,200,500,1000,2000]
max_depth = [5, 10]
for i in alpha:

print("for alpha =", i)
print("for max_depth = 5")
clf = XGBClassifier(n_estimators=i, max_depth=10, n_jobs=-1)
clf.fit(x_train, y_train)
pred_train = clf.predict_proba(x_train)[:,1]
fpr_train_xgb[i], tpr_train_xgb[i], thresholds = metrics.roc_curve(y_train, pred_train, pos_label=1)
> roc_auc_train_xgb_10[i] = metrics.auc(fpr_train_xgb[i], tpr_train_xgb[i])

pred_val = clf.predict_proba(x_val)[:,1]
fpr_val_xgb[i], tpr_val_xgb[i], пороги = metrics.roc_curve(y_val, pred_val, pos_label=1)
roc_auc_val_xgb_10[i] = metrics.auc(fpr_val_xgb[i], tpr_val_xgb[i])

#Построение графика между гиперпараметром и кривой ROC
из matplotlib.pyplot import *
t=[]
roc_auc_train_array_xgb=[]
roc_auc_val_array_xgb=[]
alpha = [ 100 200 500 1000 2000]
для i в альфа-версии:
t.append(i)
roc_auc_train_array_xgb.append(roc_auc_train_xgb_10[i])
roc_auc_val_array_xgb.append(roc_auc_val_xgb_10[i] )


plt.xlabel('Гиперпараметр')
plt.ylabel('Площадь под ROC-кривой')

plot(t, roc_auc_train_array_xgb, 'r-')
plot(t, roc_auc_val_array_xgb, 'b-')
plt.title('Гиперпараметр и кривая ROC')
plt.plot(t , roc_auc_train_array_xgb, label = «Обучающие данные»)
plt.plot(t, roc_auc_val_array_xgb, label = «CV Data»)
plt.legend()
show()

clf = XGBClassifier(n_estimators=100,max_depth=5)
clf.fit(x_train, y_train)
pred_val_log_xgb = clf.predict_proba(testX)[:,1]

Вывод: лучший AUC=0,77 при n_estimators=100 и max_depth=5 для XGBoost.

Модель 8 a:GBDT с настройкой гиперпараметров с max_depth=5

из sklearn.linear_model импортировать LogisticRegression
из sklearn.linear_model импортировать SGDClassifier
из sklearn.caulication импортировать CalibratedClassifierCV
из sklearn.metrics импортировать точность_оценки
из sklearn.ensemble импортировать GradientBoostingClassifier
fpr_val_gbc = dict()
tpr_val_gbc = dict()
roc_auc_val_gbc_5 = dict()

fpr_train_gbc = dict()
tpr_train_gbc = dict()
roc_auc_train_gbc_5 = dict()

alpha = [100,200,500,1000,2000]
max_depth = [5, 10]
for i in alpha:

print("for alpha =", i)
> print("for max_depth = 5")
clf = GradientBoostingClassifier(n_estimators=i, max_depth=5)
clf.fit(x_train, y_train)
pred_train = clf.predict_proba(x_train) [:,1]
fpr_train_gbc[i], tpr_train_gbc[i], пороги = metrics.roc_curve(y_train, pred_train, pos_label=1)
roc_auc_train_gbc_5[i] = metrics.auc(fpr_train_gbc[i] , tpr_train_gbc[i])

pred_val = clf.predict_proba(x_val)[:,1]
fpr_val_gbc[i], tpr_val_gbc[i], thresholds = metrics.roc_curve(y_val, pred_val , pos_label=1)
roc_auc_val_gbc_5[i] = metrics.auc(fpr_val_gbc[i], tpr_val_gbc[i])

#Построение графика между гиперпараметром и кривой ROC
из matplotlib.pyplot import *
t=[]
roc_auc_train_array_gbc=[]
roc_auc_val_array_gbc=[]
alpha = [ 100 200 500 1000 2000]
для i в альфа-версии:
t.append(i)
roc_auc_train_array_gbc.append(roc_auc_train_gbc_5[i])
roc_auc_val_array_gbc.append(roc_auc_val_gbc_5[i] )


plt.xlabel('Гиперпараметр')
plt.ylabel('Площадь под ROC-кривой')

plot(t, roc_auc_train_array_gbc, 'r-')
plot(t, roc_auc_val_array_gbc, 'b-')
plt.title('Гиперпараметр и кривая ROC')
plt.plot(t , roc_auc_train_array_gbc, label = «Обучающие данные»)
plt.plot(t, roc_auc_val_array_gbc, label = «CV Data»)
plt.legend()
show()

Модель 8 b:GBDT с настройкой гиперпараметров с max_depth=10

fpr_val_gbc = dict()
tpr_val_gbc = dict()

roc_auc_val_gbc_10 = дикт()

fpr_train_gbc = dict()
tpr_train_gbc = dict()

roc_auc_train_gbc_10 = dict()
alpha = [100 200 500]
max_depth = [5, 10]
for i in alpha:

print("for alpha =", i)
print("for max_depth = 10")
clf = GradientBoostingClassifier(n_estimators=i, max_depth=10)
clf.fit(x_train, y_train)
pred_train = clf .predict_proba(x_train)[:,1]
fpr_train_gbc[i], tpr_train_gbc[i], пороги = metrics.roc_curve(y_train, pred_train, pos_label=1)
roc_auc_train_gbc_10[i] = metrics.auc (fpr_train_gbc[i], tpr_train_gbc[i])

pred_val = clf.predict_proba(x_val)[:,1]
fpr_val_gbc[i], tpr_val_gbc[i], пороги = показатели. roc_curve(y_val, pred_val, pos_label=1)
roc_auc_val_gbc_10[i] = metrics.auc(fpr_val_gbc[i], tpr_val_gbc[i])

#Построение графика между гиперпараметром и кривой ROC
из matplotlib.pyplot import *
t=[]
roc_auc_train_array_gbc=[]
roc_auc_val_array_gbc=[]
alpha = [ 100 200 500]
для i в альфа-версии:
t.append(i)
roc_auc_train_array_gbc.append(roc_auc_train_gbc_10[i])
roc_auc_val_array_gbc.append(roc_auc_val_gbc_10[i])
>

plt.xlabel('Гиперпараметр')
plt.ylabel('Площадь под ROC-кривой')

plot(t, roc_auc_train_array_gbc, 'r-')
plot(t, roc_auc_val_array_gbc, 'b-')
plt.title('Гиперпараметр и кривая ROC')
plt.plot(t , roc_auc_train_array_gbc, label = «Обучающие данные»)
plt.plot(t, roc_auc_val_array_gbc, label = «CV Data»)
plt.legend()
show()

clf = GradientBoostingClassifier(n_estimators=100,max_depth=5)
clf.fit(x_train, y_train)
pred_val_log_xgb = clf.predict_proba(testX)[:,1]

Вывод: лучший показатель AUC=0,77 при n_estimators=100 и max_depth=5 для GBDT.

Модель 9: LightGBM

lgb_train = lgb.Dataset(data=x_train, label=y_train)
lgb_eval = lgb.Dataset(data=x_val, label=y_val)

params = {'task': 'train', 'boosting_type': 'gbdt', 'objective': 'binary', 'metric': 'auc',
'learning_rate': 0,01, 'num_leaves': 48 , 'num_iteration': 5000, 'verbose': 0,
'colsample_bytree':.8, 'subsample':.9, 'max_depth':7, 'reg_alpha':.1, 'reg_lambda':.1 ,
'min_split_gain':.01, 'min_child_weight':1}
model_2 = lgb.train(params, lgb_train, valid_sets=lgb_eval, Early_stopping_rounds=150, verbose_eval=200)

Вывод: получение AUC=0,7787 с помощью LightGBM.

Сохранение модели

preds = model_2.predict(testX)
sub_lgb = pd.DataFrame()
sub_lgb['SK_ID_CURR'] = test_id
sub_lgb['TARGET'] = preds
sub_lgb.to_csv ("LIGHT_GBM_2.csv", index=False)

Использованная литература:

https://www.kaggle.com/c/home-credit-default-risk

https://www.youtube.com/watch?v=OAl6eAyP-yo

https://medium.com/@praveenkotha/home-credit-default-risk-end-to-end-machine-learning-project-1871f52e3ef2

https://www.appliedaicourse.com/