Методы машинного обучения для обнаружения мошенничества с кредитными картами

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

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

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

В этом посте будут рассмотрены 4 наиболее часто используемых метода машинного обучения для обнаружения мошенничества. К ним относятся:

• Случайный лес
• CatBoost
• Глубокая нейронная сеть (DNN)
• Изолированный лес

Мы погрузимся в основы создания этих моделей в Python и сравним их эффективность друг с другом. Давайте начнем!

Настраивать

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

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Activation
from sklearn.metrics import roc_curve
from sklearn.metrics import auc
import matplotlib as mpl
import matplotlib.pyplot as plt
#configure plot size and colors 
mpl.rcParams['figure.figsize'] = (10, 10)
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']

Для оценки производительности модели будет использоваться характеристика оператора приемника (ROC) с использованием sklearn roc_curve и auc. Это поможет нам понять, как наши модели работают с точки зрения прогнозирования истинных и ложных срабатываний. Как правило, учреждения хотят иметь высокий процент истинных положительных результатов при низком фиксированном уровне ложных срабатываний. Таким образом, кривые ROC - эффективный способ измерения эффективности классификатора мошенничества.

Подготовка данных

Чтобы оценить различные методы машинного обучения для обнаружения мошенничества, мы будем использовать набор данных Обнаружение мошенничества с кредитными картами, который общедоступен на Kaggle (https://www.kaggle.com/mlg-ulb/creditcardfraud). Этот набор данных содержит несколько транзакций по кредитным картам от держателей карт из Европы в 2013 году. Многие из функций, обнаруженных в этом наборе данных, преобразованы с помощью PCA из-за того, что исходный набор данных содержит конфиденциальную личную информацию (PII).

Каждая транзакция помечается как мошенничество или Not Fraud в столбце «Класс». Если посмотреть на процентное соотношение классов, становится ясно, что лишь малая часть транзакций является мошеннической (00,17%). Это затрудняет обучение классификатора из-за большого дисбаланса в классе.

#load data
df = pd.read_csv('creditcard.csv')
#drop NULL values
df = df.dropna()
#drop Time column (contains limited useful information)
df = df.drop('Time', axis = 1)
#group data by Class
groups = df.groupby('Class')
fraud = (groups.get_group(1).shape[0] / df.shape[0]) * 100
non_fraud = (groups.get_group(0).shape[0] / df.shape[0]) * 100
#print class percentage
print('Percent Fraud: ' + str(fraud) + '%')
print('Percent Not Fraud ' + str(non_fraud) + '%')

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

df_size = df.shape[0]
test_size = int(df_size * .3)
train_size = df_size - test_size
train_df = df.head(train_size)
test_df = df.tail(test_size)
X_train = train_df.drop('Class', axis = 1)
Y_train = train_df['Class']
X_test = test_df.drop('Class', axis = 1)
Y_test = test_df['Class']

Наконец, мы применим стандартный масштабатор ко всем нашим функциям, чтобы они имели среднее значение 0 и стандартное отклонение 1. Это поможет нашим моделям более эффективно обучаться.

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

for feat in X_train.columns.values:
    ss = StandardScaler()
    X_train[feat] = ss.fit_transform(X_train[feat].values.reshape(-1,1))
    X_test[feat] = ss.transform(X_test[feat].values.reshape(-1,1))

Теперь, когда у нас есть данные, пора приступить к построению моделей!

Метод 1: случайный лес

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

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

#create Random Forest Model
rf = RandomForestClassifier()
#fit to training data
rf.fit(X_train, Y_train)
#get class probabilities
probabilities = clf.predict_proba(X_test)
y_pred_rf = probabilities[:,1]

Затем давайте посчитаем некоторые базовые показатели производительности. Мы рассчитаем частоту ложных срабатываний (FPR), истинно положительных результатов (TPR) и площадь под кривой ROC.

fpr_rf, tpr_rf, thresholds_rf = roc_curve(Y_test, y_pred_rf)
auc_rf = auc(fpr_rf, tpr_rf)

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

plt.plot(100*fpr_rf, 100*tpr_rf, label= 'Random Forest (area = {:.3f})'.format(auc_rf), linewidth=2, color = colors[0])
plt.xlabel('False positives [%]')
plt.ylabel('True positives [%]')
plt.xlim([0,30])
plt.ylim([60,100])
plt.grid(True)
ax = plt.gca()
ax.set_aspect('equal')
plt.title('Random Forest Model Performance')
plt.legend(loc='best')

Выглядит неплохо! Случайный лес оказался хорошим методом машинного обучения для обнаружения мошенничества. Он имеет стабильно высокий уровень истинных положительных результатов (TPR) при различных уровнях ложноположительных результатов (FPR).

Давайте взглянем на еще несколько моделей и посмотрим, как они будут сравниваться.

Метод 2: CatBoost

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

Давайте инициируем модель CatBoost по умолчанию и подгоним ее к нашим обучающим данным. Затем давайте получим вероятности классов для нашего тестового набора.

#create CatBoost Model
clf = CatBoostClassifier()
#fit to our data
clf.fit(X_train, Y_train)
#generate class probabilities
y_pred = clf.predict(X_test, prediction_type='RawFormulaVal')

Теперь давайте проведем некоторую оценку и посмотрим, как работает наша модель.

На первый взгляд кажется, что CatBoost уже опроверг алгоритм случайного леса, получив значение AUC, равное .978. Это значительный рост по сравнению с нашим случайным лесом, у которого только значение AUC составляло 0,928.

Метод 3: глубокая нейронная сеть (DNN)

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

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

#Design and compile model
DNN = Sequential()
DNN.add(Input(shape=(X_train.shape[1],)))
DNN.add(Dense(100, activation='relu'))
DNN.add(Dropout(0.5))
DNN.add(Dense(100, activation='relu'))
DNN.add(Dropout(0.5))
DNN.add(Dense(10, activation='relu'))
DNN.add(Dense(1, activation='sigmoid'))
DNN.compile(loss='binary_crossentropy', optimizer='adam', metrics = keras.metrics.AUC(name='auc'))
#fit model
DNN.fit(X_train, Y_train, epochs=10)
#generate class probabilities
y_pred_DNN = DNN.predict(X_test).ravel()

После подбора нашей модели и генерации вероятностей прогнозов давайте посмотрим, насколько хорошо работает наша DNN.

Выдающийся! Похоже, что и CatBoost, и наша DNN пока наши лучшие модели.

Метод 4: Изолированный лес

Последний метод, который мы попробуем использовать, - это Isolation Forest (или «iForest»); Это совершенно другой подход к обнаружению мошенничества, чем наши предыдущие методы. До сих пор мы рассматривали только методы контролируемого обучения, в которых модели обучаются на основе данных с меткой истинности. Между тем, Isolation Forest - это метод неконтролируемого обучения, что означает, что он не требует какой-либо метки истины для прогнозирования и учится только на основе шаблонов, которые он находит в обучающих данных.

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

Isolation Forest - это древовидный алгоритм, используемый для обнаружения аномалий. Алгоритм работает с использованием деревьев решений для выделения выбросов из данных. Теоретически наша группа мошенников должна в основном состоять из точек данных, которые не соответствуют нормам по сравнению с остальными нашими транзакциями. Таким образом, это идеальное решение для выявления мошенничества, когда у нас нет никаких ярлыков.

Давайте реализуем наш iForest на Python. Обратите внимание, что нам не нужен «Y_train», поскольку наша модель не нуждается в маркировке истинности для обучения.

#create iforest model
iforest = IsolationForest()
#fit to data
iforest.fit(X_train)
#generate class probabilities
y_pred_iforest = - iforest.decision_function(X_test)

Наконец, давайте посмотрим, как это работает.

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

Вывод

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

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

Репозиторий Github со всем кодом / визуальными элементами здесь: https://github.com/ryankemmer/CreditCardFraudDetection