पायथन में धोखाधड़ी का पता लगाना

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

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

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

उदाहरण

import pandas as pd
# पैंडास का उपयोग करके creditcard.csv लोड करें
datainput = pd.read_csv('E:\\creditcard.csv')
# https://www.kaggle.com/mlg-ulb/creditcardfraud
# शीर्ष 5 रिकॉर्ड प्रिंट करें
print(datainput[0:5], "\n")
# डेटासेट का पूरा आकार प्रिंट करें
print("Shape of Complete Data Set")
print(datainput.shape, "\n")

आउटपुट

उपरोक्त कोड चलाने से हमें निम्न परिणाम मिलता है -

   Time         V1         V2         V3 ...        V27        V28  Amount  Class
0   0.0 -1.359807 -0.072781  2.536347 ...   0.133558  -0.021053  149.62      0
1   0.0  1.191857  0.266151  0.166480 ...  -0.008983   0.014724    2.69      0
2   1.0 -1.358354 -1.340163  1.773209 ...  -0.055353  -0.059752  378.66      0
3   1.0 -0.966272 -0.185226  1.792993 ...   0.062723   0.061458  123.50      0
4   2.0 -1.158233  0.877737  1.548718 ...   0.219422   0.215153   69.99      0
[5 rows x 31 columns]
Shape of Complete Data Set
(284807, 31)

डेटा में असंतुलन की जांच

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

उदाहरण

import pandas as pd
# पैंडास का उपयोग करके creditcard.csv लोड करें
datainput = pd.read_csv('E:\\creditcard.csv')
false = datainput[datainput['Class'] == 1]
true = datainput[datainput['Class'] == 0]
n = len(false) / float(len(true))
print(n)
print('False Detection Cases: {}'.format(len(datainput[datainput['Class'] == 1])))
print('True Detection Cases: {}'.format(len(datainput[datainput['Class'] == 0])), "\n")

आउटपुट

उपरोक्त कोड चलाने से हमें निम्न परिणाम मिलता है -

0.0017304750013189597
False Detection Cases: 492
True Detection Cases: 284315

लेनदेन प्रकारों का विवरण

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

उदाहरण

import pandas as pd
# पैंडास का उपयोग करके creditcard.csv लोड करें
datainput = pd.read_csv('E:\\creditcard.csv')
# डेटा में असंतुलन चेक करें
false = datainput[datainput['Class'] == 1]
true = datainput[datainput['Class'] == 0]
# धोखाधड़ी का पता लगाने के केस
print("False Detection Cases")
print("----------------------")
print(false.Amount.describe(), "\n")
# वास्तविक पहचान के केस
print("True Detection Cases")
print("----------------------")
print(true.Amount.describe(), "\n")

आउटपुट

उपरोक्त कोड चलाने से हमें निम्न परिणाम मिलता है -

False Detection Cases
----------------------
count    492.000000
mean     122.211321
std      256.683288
min        0.000000
25%        1.000000
50%        9.250000
75%      105.890000
max     2125.870000
Name: Amount, dtype: float64
True Detection Cases
----------------------
count    284315.000000
mean       88.291022
std       250.105092
min         0.000000
25%         5.650000
50%        22.000000
75%        77.050000
max      25691.160000
Name: Amount, dtype: float64

फीचर्स और लेबल अलग करना

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

उदाहरण

import pandas as pd
# पैंडास का उपयोग करके creditcard.csv लोड करें
datainput = pd.read_csv('E:\\creditcard.csv')
# फीचर्स (X) और लेबल (y) अलग करना
# सभी पंक्तियों के लिए अंतिम कॉलम को छोड़कर सभी कॉलम चुनें
X = datainput.iloc[:, :-1].values
# सभी पंक्तियों का अंतिम कॉलम चुनें
Y = datainput.iloc[:, -1].values
print(X.shape)
print(Y.shape)

आउटपुट

उपरोक्त कोड चलाने से हमें निम्न परिणाम मिलता है -

(284807, 30)
(284807,)

मॉडल प्रशिक्षित करना

अब हम डेटासेट को दो भागों में विभाजित करते हैं। एक प्रशिक्षण के लिए और दूसरा परीक्षण के लिए। test_size पैरामीटर का उपयोग यह तय करने के लिए किया जाता है कि डेटासेट का कितना प्रतिशत केवल परीक्षण के लिए उपयोग किया जाएगा। यह अभ्यास हमें बनाए जा रहे मॉडल पर विश्वास हासिल करने में मदद करेगा।

उदाहरण

import pandas as pd
from sklearn.model_selection import train_test_split
# पैंडास का उपयोग करके creditcard.csv लोड करें
datainput = pd.read_csv('E:\\creditcard.csv')
# फीचर्स (X) और लेबल (y) अलग करना
X = datainput.iloc[:, :-1].values
Y = datainput.iloc[:, -1].values
# train_test_split मेथड
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)

निर्णय वृक्ष वर्गीकरण लागू करना

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

उदाहरण

import pandas as pd
from sklearn import metrics
from sklearn.model_selection import train_test_split
# पैंडास का उपयोग करके creditcard.csv लोड करें
datainput = pd.read_csv('E:\\creditcard.csv')
# फीचर्स (X) और लेबल (y) अलग करना
X = datainput.iloc[:, :-1].values
Y = datainput.iloc[:, -1].values
# train_test_split मेथड
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)
# DecisionTreeClassifier
from sklearn.tree import DecisionTreeClassifier
classifier = DecisionTreeClassifier(max_depth=4)
classifier.fit(X_train, Y_train)
predicted = classifier.predict(X_test)
print("\npredicted values :\n", predicted)
# सटीकता
DT = metrics.accuracy_score(Y_test, predicted) * 100
print("\nThe accuracy score using the DecisionTreeClassifier : ", DT)

आउटपुट

उपरोक्त कोड चलाने से हमें निम्न परिणाम मिलता है -

predicted values :
[0 0 0 ... 0 0 0]
The accuracy score using the DecisionTreeClassifier : 99.9367999719111

मूल्यांकन पैरामीटर्स ढूंढना

एक बार जब उपरोक्त चरण में सटीकता स्तर स्वीकार्य हो जाता है तो हम मॉडल के आगे मूल्यांकन के लिए विभिन्न पैरामीटर्स ढूंढते हैं। हम सटीकता, रिकॉल वैल्यू और F-स्कोर का उपयोग अपने पैरामीटर्स के रूप में करते हैं। सटीकता पुनर्प्राप्त इंस्टेंसेस में प्रासंगिक इंस्टेंसेस का अंश है, जबकि रिकॉल वास्तव में पुनर्प्राप्त प्रासंगिक इंस्टेंसेस की कुल मात्रा का अंश है। F-स्कोर एक ही संख्या में सटीकता और रिकॉल दोनों चिंताओं को संतुलित करने वाला एकल स्कोर प्रदान करता है।

उदाहरण

import pandas as pd
from sklearn import metrics
from sklearn.model_selection import train_test_split
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
# पैंडास का उपयोग करके creditcard.csv लोड करें
datainput = pd.read_csv('E:\\creditcard.csv')
# फीचर्स (X) और लेबल (y) अलग करना
X = datainput.iloc[:, :-1].values
Y = datainput.iloc[:, -1].values
# train_test_split मेथड
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)
# DecisionTreeClassifier
from sklearn.tree import DecisionTreeClassifier
classifier = DecisionTreeClassifier(max_depth=4)
classifier.fit(X_train, Y_train)
predicted = classifier.predict(X_test)
print("\npredicted values :\n", predicted)
# सटीकता
DT = metrics.accuracy_score(Y_test, predicted) * 100
print("\nThe accuracy score using the DecisionTreeClassifier : ", DT)
# सटीकता
print('precision')
# Precision = TP / (TP + FP)
precision = precision_score(Y_test, predicted, pos_label=1)
print(precision_score(Y_test, predicted, pos_label=1))
# रिकॉल
print('recall')
# Recall = TP / (TP + FN)
recall = recall_score(Y_test, predicted, pos_label=1)
print(recall_score(Y_test, predicted, pos_label=1))
# F1-स्कोर
print('f-Score')
# F-स्कोर सटीकता और रिकॉल दोनों को ध्यान में रखते हुए सटीकता निर्धारित करने की एक सांख्यिकीय विधि है।
fscore = f1_score(Y_test, predicted, pos_label=1)
print(f1_score(Y_test, predicted, pos_label=1))

आउटपुट

उपरोक्त कोड चलाने से हमें निम्न परिणाम मिलता है -

The accuracy score using the DecisionTreeClassifier : 99.9403110845827
precision
0.810126582278481
recall
0.7710843373493976
f-Score
0.7901234567901234