बैंकिंग में डेटा साइंस: फ्रॉड डिटेक्शन

• बैंकिंग में डेटा साइंस का उपयोग मामला: फ्रॉड का पता लगाना 
• डेटासेट तैयार करना
• डेटासेट में फ्रॉड की गणना
• डेटा को पुनर्संतुलित करने के लिए SMOTE का उपयोग
• लॉजिस्टिक रिग्रेशन लागू करना 
• निष्कर्ष

बैंकिंग उन भाग्यशाली क्षेत्रों में से एक है जहाँ इतिहास से ही बहुत-सा संरचित डेटा एकत्र किया जाता रहा है, और यह उन पहले क्षेत्रों में भी है जहाँ डेटा साइंस तकनीकों को अपनाया गया।

बैंकिंग में डेटा साइंस का उपयोग कैसे होता है? आजकल इस क्षेत्र में डेटा सबसे मूल्यवान संपत्ति बन चुका है। प्रतिस्पर्धियों के साथ कदम मिलाने, अधिक ग्राहकों को आकर्षित करने, मौजूदा ग्राहकों की निष्ठा बढ़ाने, अधिक सक्षम डेटा-आधारित निर्णय लेने, व्यापार को सशक्त करने, परिचालन क्षमता बढ़ाने, मौजूदा सेवाओं/उत्पादों में सुधार करने और नए आरंभ करने, सुरक्षा को सुदृढ़ करने और अंततः अधिक राजस्व अर्जित करने के लिए डेटा साइंस जरूरी हो गया है। यह आश्चर्य की बात नहीं कि डेटा साइंस नौकरियों की अधिकांश मांग बैंकिंग से आती है।

डेटा साइंस बैंकिंग उद्योग को अनेक कार्य सफलतापूर्वक करने में सक्षम बनाता है, जैसे: 

• निवेश जोखिम विश्लेषण
• कस्टमर लाइफटाइम वैल्यू का पूर्वानुमान
• ग्राहक वर्गीकरण (सेगमेंटेशन)
• ग्राहक चर्न दर का पूर्वानुमान
• व्यक्तिगत मार्केटिंग
• ग्राहक की भावनात्मक प्रवृत्ति (सेंटिमेंट) का विश्लेषण
• वर्चुअल असिस्टेंट और चैटबॉट

आगे हम बैंकिंग में डेटा साइंस के सबसे सामान्य उपयोग मामलों में से एक पर करीब से नज़र डालेंगे।

बैंकिंग में डेटा साइंस का उपयोग मामला: फ्रॉड का पता लगाना 

धोखाधड़ी संबंधी गतिविधियाँ केवल बैंकिंग में ही नहीं, बल्कि सरकार, बीमा, सार्वजनिक क्षेत्र, बिक्री और स्वास्थ्य सेवा जैसे कई अन्य क्षेत्रों में भी एक चुनौतीपूर्ण समस्या हैं। कोई भी व्यवसाय जो बड़ी संख्या में ऑनलाइन लेनदेन करता है, वह धोखाधड़ी के महत्वपूर्ण जोखिम का सामना करता है। वित्तीय अपराध विभिन्न रूप ले सकते हैं, जैसे क्रेडिट कार्ड पर फर्जी लेनदेन, नकली बैंक चेक, कर चोरी, मनी लॉन्ड्रिंग, साइबर हमले, ग्राहक खाते की चोरी, सिंथेटिक पहचान, फर्जी आवेदन और घोटाले।

फ्रॉड डिटेक्शन उन सक्रिय उपायों का समूह है जिनका उद्देश्य धोखाधड़ी गतिविधियों और वित्तीय नुकसान की पहचान करना और उन्हें रोकना है। इसकी मुख्य विश्लेषणात्मक तकनीकों को दो समूहों में बाँटा जा सकता है:

• सांख्यिकीय: सांख्यिकीय पैरामीटर की गणना, रिग्रेशन, प्रायिकता वितरण, डेटा मिलान
• कृत्रिम बुद्धिमत्ता (AI): डेटा माइनिंग, मशीन लर्निंग, डीप लर्निंग

मशीन लर्निंग, फ्रॉड डिटेक्शन की एक अहम नींव है। इसके टूलकिट में दो दृष्टिकोण होते हैं:

• सुपरवाइज़्ड विधियाँ: k-नजदीकी पड़ोसी, लॉजिस्टिक रिग्रेशन, सपोर्ट वेक्टर मशीन, डिसीजन ट्री, रैंडम फॉरेस्ट, टाइम-सीरीज़ विश्लेषण, न्यूरल नेटवर्क आदि
• अनसुपरवाइज़्ड विधियाँ: क्लस्टर विश्लेषण, लिंक विश्लेषण, सेल्फ-ऑर्गनाइज़िंग मैप्स, प्रिंसिपल कंपोनेंट विश्लेषण, विसंगति (एनोमली) की पहचान आदि

फ्रॉड डिटेक्शन के लिए कोई सार्वभौमिक और विश्वसनीय मशीन लर्निंग एल्गोरिद्म नहीं है। वास्तविक दुनिया के उपयोग मामलों में सामान्यतः कई तकनीकों या उनके संयोजनों का परीक्षण किया जाता है, मॉडल की भविष्यवाणी-सटीकता मापी जाती है और फिर सर्वश्रेष्ठ दृष्टिकोण चुना जाता है।

फ्रॉड डिटेक्शन सिस्टम के सामने मुख्य चुनौती यह है कि वे लगातार बदलते फ्रॉड पैटर्न और धोखेबाज़ों की तरकीबों के अनुरूप तेजी से ढल सकें और नई तथा अधिक जटिल योजनाओं का समय रहते भंडाफोड़ कर सकें। फ्रॉड के मामले हमेशा अल्पसंख्यक में होते हैं और वास्तविक लेनदेन के बीच बखूबी छिपे रहते हैं।

डेटासेट तैयार करना

आइए Python प्रोग्रामिंग भाषा का उपयोग करके क्रेडिट कार्ड फ्रॉड डिटेक्शन के एक मशीन लर्निंग इम्प्लीमेंटेशन का अन्वेषण करें। हम creditcard_data डेटासेट पर काम करेंगे, जो Kaggle के Credit Card Fraud Detection डेटासेट का संशोधित नमूना है। मूल डेटा सितंबर 2013 में दो दिनों के दौरान यूरोपीय कार्डधारकों के स्वामित्व वाले क्रेडिट कार्डों पर किए गए लेनदेन का प्रतिनिधित्व करता है।

आइए डेटा आयात करें और उस पर एक त्वरित नज़र डालें:

import pandas as pd

creditcard_data = pd.read_csv('creditcard_data.csv', index_col=0)
print(creditcard_data.info())
print('\n')
pd.options.display.max_columns = len(creditcard_data)
print(creditcard_data.head(3))

<class 'pandas.core.frame.DataFrame'>
Int64Index: 5050 entries, 0 to 5049
Data columns (total 30 columns):
#   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
0   V1      5050 non-null   float64
1   V2      5050 non-null   float64
2   V3      5050 non-null   float64
3   V4      5050 non-null   float64
4   V5      5050 non-null   float64
5   V6      5050 non-null   float64
6   V7      5050 non-null   float64
7   V8      5050 non-null   float64
8   V9      5050 non-null   float64
9   V10     5050 non-null   float64
10  V11     5050 non-null   float64
11  V12     5050 non-null   float64
12  V13     5050 non-null   float64
13  V14     5050 non-null   float64
14  V15     5050 non-null   float64
15  V16     5050 non-null   float64
16  V17     5050 non-null   float64
17  V18     5050 non-null   float64
18  V19     5050 non-null   float64
19  V20     5050 non-null   float64
20  V21     5050 non-null   float64
21  V22     5050 non-null   float64
22  V23     5050 non-null   float64
23  V24     5050 non-null   float64
24  V25     5050 non-null   float64
25  V26     5050 non-null   float64
26  V27     5050 non-null   float64
27  V28     5050 non-null   float64
28  Amount  5050 non-null   float64
29  Class   5050 non-null   int64 
dtypes: float64(29), int64(1)
memory usage: 1.2 MB


        V1        V2        V3        V4        V5        V6        V7  \
0  1.725265 -1.337256 -1.012687 -0.361656 -1.431611 -1.098681 -0.842274  
1  0.683254 -1.681875  0.533349 -0.326064 -1.455603  0.101832 -0.520590  
2  1.067973 -0.656667  1.029738  0.253899 -1.172715  0.073232 -0.745771  

        V8        V9       V10       V11       V12       V13       V14  \
0 -0.026594 -0.032409  0.215113  1.618952 -0.654046 -1.442665 -1.546538  
1  0.114036 -0.601760  0.444011  1.521570  0.499202 -0.127849 -0.237253  
2  0.249803  1.383057 -0.483771 -0.782780  0.005242 -1.273288 -0.269260  

        V15       V16       V17       V18       V19       V20       V21  \
0 -0.230008  1.785539  1.419793  0.071666  0.233031  0.275911  0.414524  
1 -0.752351  0.667190  0.724785 -1.736615  0.702088  0.638186  0.116898  
2  0.091287 -0.347973  0.495328 -0.925949  0.099138 -0.083859 -0.189315  

        V22       V23       V24       V25       V26       V27       V28  \
0  0.793434  0.028887  0.419421 -0.367529 -0.155634 -0.015768  0.010790  
1 -0.304605 -0.125547  0.244848  0.069163 -0.460712 -0.017068  0.063542  
2 -0.426743  0.079539  0.129692  0.002778  0.970498 -0.035056  0.017313  

  Amount  Class 
0  189.00      0 
1  315.17      0 
2   59.98      0 

डेटासेट में निम्नलिखित चर (वैरिएबल) शामिल हैं:

• संख्यात्मक रूप से एन्कोड किए गए V1 से V28, जो PCA ट्रांसफॉर्मेशन से प्राप्त प्रिंसिपल कंपोनेंट हैं। गोपनीयता कारणों से मूल फीचर्स के बारे में पृष्ठभूमि जानकारी उपलब्ध नहीं कराई गई।
• Amount वैरिएबल लेनदेन की राशि दर्शाती है।
• Class वैरिएबल बताती है कि लेनदेन फ्रॉड था (1) या नहीं (0)।

स्वभावतः, किसी भी लेनदेन सूची में फ्रॉड की घटनाएँ सौभाग्य से अत्यल्प होती हैं। हालांकि, मशीन लर्निंग एल्गोरिद्म सामान्यतः तब बेहतर काम करते हैं जब डेटासेट में विभिन्न श्रेणियाँ कमोबेश समान अनुपात में मौजूद हों। अन्यथा सीखने के लिए डेटा बहुत कम होता है। इसे क्लास असंतुलन (class imbalance) की समस्या कहते हैं।

डेटासेट में फ्रॉड की गणना

आइए हमारे डेटासेट में कुल लेनदेन पर धोखाधड़ी वाले लेनदेन का प्रतिशत निकालें:

round(creditcard_data['Class'].value_counts()*100/len(creditcard_data)).convert_dtypes()

0    99
1     1
Name: Class, dtype: Int64

और फ्रॉड बनाम नॉन-फ्रॉड डेटा बिंदुओं को दर्शाने के लिए एक प्लॉट बनाएँ:

import matplotlib.pyplot as plt
import numpy as np

def prep_data(df):
    X = df.iloc[:, 1:28]
    X = np.array(X).astype(float)
    y = df.iloc[:, 29]
    y = np.array(y).astype(float)
    return X, y

def plot_data(X, y):
    plt.scatter(X[y==0, 0], X[y==0, 1], label='Class #0', alpha=0.5, linewidth=0.15)
    plt.scatter(X[y==1, 0], X[y==1, 1], label='Class #1', alpha=0.5, linewidth=0.15, c='r')
    plt.legend()
    return plt.show()

X, y = prep_data(creditcard_data)

plot_data(X, y)

डेटा को पुनर्संतुलित करने के लिए SMOTE का उपयोग 

अब हम पुष्टि कर सकते हैं कि धोखाधड़ी लेनदेन का अनुपात बहुत कम है और हमारे पास क्लास असंतुलन की समस्या है। इसे ठीक करने के लिए हम synthetic minority oversampling technique (SMOTE) का उपयोग करके अपने डेटा को पुनर्संतुलित कर सकते हैं। रैंडम ओवरसैंपलिंग के विपरीत, SMOTE कुछ अधिक उन्नत है क्योंकि यह केवल ऑब्ज़र्वेशनों की हूबहू प्रतिलिपियाँ नहीं बनाता। इसके बजाय, यह फ्रॉड मामलों के निकटतम पड़ोसियों की विशेषताओं का उपयोग करके नए, सिंथेटिक नमूने बनाता है जो अल्पसंख्यक श्रेणी में मौजूदा ऑब्ज़र्वेशनों से काफी मिलते-जुलते हैं। आइए अपने क्रेडिट कार्ड डेटा पर SMOTE लागू करें:

from imblearn.over_sampling import SMOTE

method = SMOTE()
X_resampled, y_resampled = method.fit_resample(X, y)
plot_data(X_resampled, y_resampled)

जैसा कि हम देख सकते हैं, SMOTE का उपयोग करने से अचानक अल्पसंख्यक श्रेणी के अधिक ऑब्ज़र्वेशन मिल जाते हैं। इस दृष्टिकोण के परिणामों को और स्पष्ट देखने के लिए, हम इन्हें मूल डेटा से तुलना करेंगे:

def compare_plot(X, y, X_resampled, y_resampled, method):
    f, (ax1, ax2) = plt.subplots(1, 2)
    c0 = ax1.scatter(X[y==0, 0], X[y==0, 1], label='Class #0',alpha=0.5)
    c1 = ax1.scatter(X[y==1, 0], X[y==1, 1], label='Class #1',alpha=0.5, c='r')
    ax1.set_title('Original set')
    ax2.scatter(X_resampled[y_resampled==0, 0], X_resampled[y_resampled==0, 1], label='Class #0', alpha=.5)
    ax2.scatter(X_resampled[y_resampled==1, 0], X_resampled[y_resampled==1, 1], label='Class #1', alpha=.5,c='r')
    ax2.set_title(method)
    plt.figlegend((c0, c1), ('Class #0', 'Class #1'), loc='lower center', ncol=2, labelspacing=0.)
    plt.tight_layout(pad=3)
    return plt.show()

print(f'Original set:\n'
      f'{pd.value_counts(pd.Series(y))}\n\n'
      f'SMOTE:\n'
      f'{pd.value_counts(pd.Series(y_resampled))}\n')

compare_plot(X, y, X_resampled, y_resampled, method='SMOTE')

Original set:
0.0    5000
1.0      50
dtype: int64


SMOTE:
0.0    5000
1.0    5000
dtype: int64

इस प्रकार, SMOTE विधि ने हमारे डेटा को पूरी तरह संतुलित कर दिया है, और अब अल्पसंख्यक श्रेणी का आकार बहुसंख्यक श्रेणी के बराबर है।

हम जल्द ही SMOTE के व्यावहारिक उपयोग पर लौटेंगे, लेकिन फिलहाल, मूल डेटा पर वापस आते हैं और फ्रॉड मामलों की पहचान करने की कोशिश करते हैं। पारंपरिक तरीके से हमें फ्रॉड पकड़ने के लिए कुछ नियम बनाने पड़ेंगे। ऐसे नियम, उदाहरण के लिए, असामान्य स्थानों पर लेनदेन या संदिग्ध रूप से बार-बार होने वाले लेनदेन से संबंधित हो सकते हैं। विचार यह है कि सामान्य आँकड़ों, अक्सर औसत मानों, के आधार पर थ्रेशोल्ड तय किए जाएँ और उन थ्रेशोल्ड को हमारे फीचर्स पर लागू करके फ्रॉड का पता लगाया जाए।

print(creditcard_data.groupby('Class').mean().round(3)[['V1', 'V3']])

        V1     V3
Class             
0      0.035  0.037
1     -4.985 -7.294

हमारे विशेष मामले में, आइए निम्न शर्तें लागू करें: V1 < -3 और V3 < -5। फिर, इस दृष्टिकोण के प्रदर्शन का अनुमान लगाने के लिए, हम चिन्हित (फ्लैग की गई) फ्रॉड घटनाओं की वास्तविक घटनाओं से तुलना करेंगे:

creditcard_data['flag_as_fraud'] = np.where(np.logical_and(creditcard_data['V1']<-3, creditcard_data['V3']<-5), 1, 0)
print(pd.crosstab(creditcard_data['Class'], creditcard_data['flag_as_fraud'], rownames=['Actual Fraud'], colnames=['Flagged Fraud']))

Flagged Fraud     0   1
Actual Fraud          
0              4984  16
1                28  22

लॉजिस्टिक रिग्रेशन लागू करना 

हमने 50 में से 22 फ्रॉड मामलों का पता लगाया, लेकिन अन्य 28 नहीं पकड़ पाए, और 16 फॉल्स पॉजिटिव मिले। देखें कि क्या मशीन लर्निंग तकनीकें इन परिणामों को मात दे सकती हैं।

अब हम अपने क्रेडिट कार्ड डेटा पर एक सरल लॉजिस्टिक रिग्रेशन वर्गीकरण एल्गोरिद्म लागू करेंगे ताकि धोखाधड़ी की पहचान की जा सके, और फिर परिणामों को कन्फ्यूज़न मैट्रिक्स पर विज़ुअलाइज़ करेंगे:

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

lr = LogisticRegression()
lr.fit(X_train, y_train)
predictions = lr.predict(X_test)
print(pd.crosstab(y_test, predictions, rownames=['Actual Fraud'], colnames=['Flagged Fraud']))

Flagged Fraud   0.0  1.0
Actual Fraud           
0.0            1504    1
1.0             1      9

यह ध्यान देने योग्य है कि यहाँ कन्फ्यूज़न मैट्रिक्स में देखने के लिए हमारे पास कम ऑब्ज़र्वेशन हैं, क्योंकि हम केवल टेस्ट सेट पर मॉडल के परिणामों की गणना कर रहे हैं, यानी पूरे डेटासेट का केवल 30%।

हमने फ्रॉड मामलों का अधिक प्रतिशत पकड़ा: 90% (10 में से 9), जबकि पहले 44% (50 में से 22) था। पहले की तुलना में फॉल्स पॉजिटिव भी काफी कम मिले—यह सुधार है।

अब वापस पहले चर्चा की गई क्लास असंतुलन समस्या पर आते हैं और देखते हैं कि क्या हम लॉजिस्टिक रिग्रेशन मॉडल को SMOTE रिसैंपलिंग विधि के साथ जोड़कर भविष्यवाणी के परिणामों को और बेहतर बना सकते हैं। इसे कुशलतापूर्वक और एक साथ करने के लिए, हमें एक पाइपलाइन परिभाषित करनी होगी और उसे अपने डेटा पर चलाना होगा:

from imblearn.pipeline import Pipeline

# Defining which resampling method and which ML model to use in the pipeline
resampling = SMOTE()
lr = LogisticRegression()

pipeline = Pipeline([('SMOTE', resampling), ('Logistic Regression', lr)])
pipeline.fit(X_train, y_train)
predictions = pipeline.predict(X_test)
print(pd.crosstab(y_test, predictions, rownames=['Actual Fraud'], colnames=['Flagged Fraud']))

Flagged Fraud   0.0  1.0
Actual Fraud           
0.0            1496    9
1.0               1    9

जैसा कि हम देख सकते हैं, हमारे मामले में SMOTE से कोई सुधार नहीं हुआ: हमने अब भी 90% फ्रॉड घटनाएँ पकड़ीं और ऊपर से फॉल्स पॉजिटिव की संख्या थोड़ा बढ़ गई। इसका कारण यह है कि रिसैंपलिंग हर मामले में बेहतर परिणाम नहीं देती। जब फ्रॉड मामले डेटा में बहुत फैले हुए हों, तो उनके निकटतम पड़ोसी जरूरी नहीं कि फ्रॉड ही हों, इसलिए SMOTE पक्षपात (बायस) ला सकता है।

निष्कर्ष 

आगे बढ़ने के लिए, लॉजिस्टिक रिग्रेशन मॉडल की सटीकता बढ़ाने हेतु हम एल्गोरिद्म के कुछ पैरामीटर्स को ट्यून कर सकते हैं। केवल डेटासेट को दो भागों में बाँटने के बजाय K-fold क्रॉस-वैलिडेशन पर भी विचार किया जा सकता है। अंत में, हम अन्य मशीन लर्निंग एल्गोरिद्म (जैसे डिसीजन ट्री या रैंडम फॉरेस्ट) आज़मा सकते हैं और देख सकते हैं कि क्या वे बेहतर नतीजे देते हैं। 

यदि आप फ्रॉड डिटेक्शन मॉडल के सैद्धांतिक और तकनीकी पहलुओं के बारे में और जानना चाहते हैं, तो Fraud Detection in Python कोर्स की सामग्रियाँ देखें।