1. खास जानकारी
इस लैब में, धोखाधड़ी वाले लेन-देन का पता लगाने के लिए मॉडल बनाने और उसे ट्रेन करने के लिए, AI Platform Notebooks का इस्तेमाल किया जाएगा. साथ ही, Explainable AI SDK की मदद से मॉडल के अनुमानों को समझा जाएगा. धोखाधड़ी का पता लगाना, वित्तीय सेवाओं के लिए खास तौर पर तैयार की गई विसंगति का पता लगाने की एक तकनीक है. यह एमएल मॉडल के लिए कुछ दिलचस्प चुनौतियां पेश करती है: स्वाभाविक रूप से असंतुलित डेटासेट और मॉडल के नतीजों के बारे में जानकारी देने की ज़रूरत.
आपको क्या सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- डेटासेट में मौजूद डेटा के बीच अंतर को कम करना
- AI Platform Notebooks में tf.keras की मदद से, धोखाधड़ी का पता लगाने वाला मॉडल बनाना और उसका आकलन करना
- नोटबुक में मौजूद Explainable AI SDK का इस्तेमाल करके यह समझें कि मॉडल ने लेन-देन को धोखाधड़ी के तौर पर क्यों क्लासिफ़ाई किया
- मॉडल को AI Platform पर डिप्लॉय करें और डिप्लॉय किए गए मॉडल के बारे में जानकारी पाएं. साथ ही, पूर्वानुमान और जानकारी पाएं
इस लैब को Google Cloud पर चलाने की कुल लागत करीब 1 डॉलर है.
2. धोखाधड़ी का पता लगाने की सुविधा क्यों ज़रूरी है?
गड़बड़ी की पहचान करने वाली विज़ुअलाइज़ेशन तकनीक के लिए, मशीन लर्निंग का इस्तेमाल किया जा सकता है. ऐसा इसलिए, क्योंकि डेटा में आउटलायर की पहचान करने के लिए, नियमों पर आधारित स्टेटमेंट की सीरीज़ लिखना मुश्किल होता है. धोखाधड़ी का पता लगाना, अनियमितता का पता लगाने की एक तरह की तकनीक है. मशीन लर्निंग के मामले में, इससे दो दिलचस्प चुनौतियां मिलती हैं:
- डेटासेट में बहुत ज़्यादा अंतर होना: गड़बड़ियां, गड़बड़ियां ही होती हैं. इसलिए, इनकी संख्या ज़्यादा नहीं होती. एमएल सबसे अच्छा तब काम करता है, जब डेटासेट संतुलित हों. इसलिए, जब आउटलायर आपके डेटा का 1% से कम हिस्सा बनाते हैं, तो चीज़ें जटिल हो सकती हैं.
- नतीजों के बारे में जानकारी देना ज़रूरी है: अगर आपको धोखाधड़ी वाली गतिविधि का पता लगाना है, तो हो सकता है कि आपको यह जानना हो कि सिस्टम ने किसी गतिविधि को धोखाधड़ी वाली गतिविधि के तौर पर क्यों फ़्लैग किया है. इस काम में, एआई के फ़ैसलों के बारे में जानकारी देने वाले टूल मदद कर सकते हैं.
3. अपना एनवायरमेंट सेट अप करना
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: Cloud AI Platform Models API को चालू करना
Cloud Console में AI Platform Models सेक्शन पर जाएं. अगर यह सुविधा पहले से चालू नहीं है, तो 'चालू करें' पर क्लिक करें.
दूसरा चरण: Compute Engine API चालू करना
Compute Engine पर जाएं. अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. आपको नोटबुक इंस्टेंस बनाने के लिए इसकी ज़रूरत होगी.
तीसरा चरण: AI Platform Notebooks का इंस्टेंस बनाना
Cloud Console के AI Platform Notebooks सेक्शन पर जाएं और नया इंस्टेंस पर क्लिक करें. इसके बाद, TensorFlow Enterprise 2.1 इंस्टेंस टाइप without GPUs चुनें:
डिफ़ॉल्ट विकल्पों का इस्तेमाल करें. इसके बाद, बनाएं पर क्लिक करें. इंस्टेंस बन जाने के बाद, JupyterLab खोलें को चुनें:
इंस्टेंस खोलने के बाद, लॉन्चर से Python 3 नोटबुक चुनें:
चौथा चरण: Python पैकेज इंपोर्ट करना
एक नई सेल बनाएं और उन लाइब्रेरी को इंपोर्ट करें जिनका इस्तेमाल हम इस कोडलैब में करेंगे:
import itertools
import numpy as np
import pandas as pd
import tensorflow as tf
import json
import matplotlib as mpl
import matplotlib.pyplot as plt
import explainable_ai_sdk
from sklearn.utils import shuffle
from sklearn.metrics import confusion_matrix
from sklearn.preprocessing import StandardScaler
from tensorflow import keras
from explainable_ai_sdk.metadata.tf.v2 import SavedModelMetadataBuilder
4. डेटा डाउनलोड और प्रोसेस करना
हम अपने मॉडल को ट्रेन करने के लिए, Kaggle से इस आर्टिफ़िशियल तरीके से जनरेट किए गए डेटासेट का इस्तेमाल करेंगे. ओरिजनल डेटासेट में 63 लाख लाइनें हैं. इनमें से 8, 000 लाइनें धोखाधड़ी वाले लेन-देन की हैं. यह पूरे डेटासेट का सिर्फ़ 0.1% है!
पहला चरण: Kaggle डेटासेट डाउनलोड करें और Pandas की मदद से उसे पढ़ें
हमने Kaggle डेटासेट को Google Cloud Storage में आपके लिए उपलब्ध करा दिया है. इसे डाउनलोड करने के लिए, अपनी Jupyter नोटबुक में यह gsutil कमांड चलाएं:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
इसके बाद, आइए डेटासेट को Pandas DataFrame के तौर पर पढ़ें और उसकी झलक देखें:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
आपको झलक में कुछ ऐसा दिखेगा:
दूसरा चरण: डेटा में मौजूद अंतर को ध्यान में रखना
ऊपर बताया गया है कि फ़िलहाल, डेटासेट में 99.9% ऐसे उदाहरण हैं जिनमें धोखाधड़ी नहीं हुई है. अगर हम डेटा के आधार पर मॉडल को ट्रेन करते हैं, तो हो सकता है कि मॉडल 99.9% सटीक नतीजे दे. ऐसा इसलिए होगा, क्योंकि 99.9% डेटा में धोखाधड़ी के मामले नहीं हैं.
डेटा में अंतर होने की समस्या को हल करने के लिए, कई तरीके अपनाए जा सकते हैं. यहां हम डाउनसैंपलिंग नाम की तकनीक का इस्तेमाल करेंगे. डाउनसैंपलिंग का मतलब है कि ट्रेनिंग में, मेजॉरिटी क्लास के सिर्फ़ कुछ प्रतिशत डेटा का इस्तेमाल करना. इस मामले में, "धोखाधड़ी नहीं" वाली क्लास सबसे ज़्यादा है, क्योंकि यह 99.9% डेटा के लिए ज़िम्मेदार है.
अपने डेटासेट को डाउनसैंपल करने के लिए, हम धोखाधड़ी के सभी ~8 हज़ार उदाहरणों और धोखाधड़ी के मामलों के ~31 हज़ार उदाहरणों का एक रैंडम सैंपल लेंगे. इस तरह, नतीजे के तौर पर मिले डेटासेट में धोखाधड़ी के 25% मामले होंगे. पहले यह .1% था.
सबसे पहले, डेटा को दो डेटाफ़्रेम में बांटें. एक फ़्रॉड के लिए और दूसरा नॉन-फ़्रॉड के लिए. हम इस डेटा का इस्तेमाल बाद में कोडलैब में करेंगे, जब हम अपना मॉडल डिप्लॉय करेंगे:
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
इसके बाद, धोखाधड़ी न करने वाले मामलों का कोई रैंडम सैंपल लें. हम .005% का इस्तेमाल कर रहे हैं, क्योंकि इससे हमें धोखाधड़ी वाले और धोखाधड़ी न करने वाले लेन-देन का 25/75 स्प्लिट मिलेगा. इसके बाद, डेटा को वापस एक साथ रखा जा सकता है और शफ़ल किया जा सकता है. चीज़ों को आसान बनाने के लिए, हम कुछ ऐसे कॉलम भी हटा देंगे जिनका इस्तेमाल ट्रेनिंग के लिए नहीं किया जाएगा:
# Take a random sample of non fraud rows
not_fraud_sample = not_fraud.sample(random_state=2, frac=.005)
# Put it back together and shuffle
df = pd.concat([not_fraud_sample,fraud])
df = shuffle(df, random_state=2)
# Remove a few columns (isFraud is the label column we'll use, not isFlaggedFraud)
df = df.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud'])
# Preview the updated dataset
df.head()
अब हमारे पास ज़्यादा संतुलित डेटासेट है. हालांकि, अगर हमें लगता है कि हमारा मॉडल ~75% सटीकता के साथ काम कर रहा है, तो इस बात की पूरी संभावना है कि वह हर मामले में "धोखाधड़ी नहीं" का अनुमान लगा रहा है.
तीसरा चरण: डेटा को ट्रेनिंग और टेस्ट सेट में बांटना
मॉडल बनाने से पहले, हमें अपने डेटा को अलग-अलग हिस्सों में बांटना होगा. हम 80/20 के अनुपात में ट्रेन-टेस्ट स्प्लिट का इस्तेमाल करेंगे:
train_test_split = int(len(df) * .8)
train_set = df[:train_test_split]
test_set = df[train_test_split:]
train_labels = train_set.pop('isFraud')
test_labels = test_set.pop('isFraud')
*ई. A. लोपेज़-रोज़ास , ए॰ Elmir, and S. एक्सलसन. "PaySim: A financial mobile money simulator for fraud detection". In: The 28th European Modeling and Simulation Symposium-EMSS, Larnaca, Cyprus. 2016
5. tf.keras मॉडल बनाना, उसे ट्रेन करना, और उसका आकलन करना
हम TensorFlow के tf.keras API का इस्तेमाल करके मॉडल बनाएंगे. इस सेक्शन में मौजूद मॉडल कोड, TensorFlow के दस्तावेज़ों में दिए गए इस ट्यूटोरियल पर आधारित है. सबसे पहले, हम डेटा को नॉर्मलाइज़ करेंगे. इसके बाद, हम अपने मॉडल को बनाएंगे और उसे ट्रेन करेंगे. इसके लिए, हम class_weight पैरामीटर का इस्तेमाल करेंगे, ताकि डेटा के बाकी बचे हुए अंतर को ध्यान में रखा जा सके.
पहला चरण: डेटा को सामान्य बनाना
संख्यात्मक डेटा पर किसी मॉडल को ट्रेन करते समय, डेटा को सामान्य बनाना ज़रूरी है. ऐसा खास तौर पर तब करना चाहिए, जब हर कॉलम अलग-अलग रेंज में आता हो. इससे ट्रेनिंग के दौरान, बैटरी के फटने से होने वाले नुकसान को रोका जा सकता है. हम अपने डेटा को इन तरीकों से सामान्य बना सकते हैं:
scaler = StandardScaler()
train_set = scaler.fit_transform(train_set) # Only normalize on the train set
test_set = scaler.transform(test_set)
# clip() ensures all values fall within the range [-5,5]
# useful if any outliers remain after normalizing
train_set = np.clip(train_set, -5, 5)
test_set = np.clip(test_set, -5, 5)
इसके बाद, सामान्य किए गए डेटा की झलक देखते हैं:
train_set
दूसरा चरण: क्लास के वेट तय करना
डेटा को कम करते समय, हमने धोखाधड़ी न करने वाले लेन-देन के सबसेट को बनाए रखा, ताकि हमें उन लेन-देन की जानकारी न खोनी पड़े. यही वजह है कि हमने डेटा को पूरी तरह से संतुलित नहीं किया. डेटासेट अब भी असंतुलित है. साथ ही, हमें धोखाधड़ी वाले लेन-देन की सही पहचान करने की ज़रूरत है. इसलिए, हम चाहते हैं कि हमारा मॉडल, डेटासेट में मौजूद धोखाधड़ी वाले उदाहरणों को ज़्यादा अहमियत दे.
Keras class_weight पैरामीटर की मदद से, हम यह तय कर सकते हैं कि हमें हर क्लास के उदाहरणों को कितना वेट देना है. यह इस बात पर निर्भर करता है कि वे डेटासेट में कितनी बार आते हैं:
weight_for_non_fraud = 1.0 / df['isFraud'].value_counts()[0]
weight_for_fraud = 1.0 / df['isFraud'].value_counts()[1]
class_weight = {0: weight_for_non_fraud, 1: weight_for_fraud}
हम इस वैरिएबल का इस्तेमाल, अगले चरण में अपने मॉडल को ट्रेनिंग देने के लिए करेंगे.
तीसरा चरण: मॉडल को ट्रेन करना और उसका आकलन करना
हम Keras Sequential Model API का इस्तेमाल करके अपना मॉडल बनाएंगे. इससे हम अपने मॉडल को लेयर के स्टैक के तौर पर तय कर सकते हैं. ट्रेनिंग के दौरान, हम कई मेट्रिक ट्रैक करेंगे. इससे हमें यह समझने में मदद मिलेगी कि हमारा मॉडल, हमारे डेटासेट में मौजूद हर क्लास पर कैसा परफ़ॉर्म कर रहा है.
METRICS = [
keras.metrics.TruePositives(name='tp'),
keras.metrics.FalsePositives(name='fp'),
keras.metrics.TrueNegatives(name='tn'),
keras.metrics.FalseNegatives(name='fn'),
keras.metrics.BinaryAccuracy(name='accuracy'),
keras.metrics.Precision(name='precision'),
keras.metrics.Recall(name='recall'),
keras.metrics.AUC(name='auc'),
]
def make_model(metrics = METRICS):
model = keras.Sequential([
keras.layers.Dense(
16, activation='relu',
input_shape=(train_set.shape[-1],)),
keras.layers.Dropout(0.5),
keras.layers.Dense(1, activation='sigmoid'),
])
model.compile(
optimizer=keras.optimizers.Adam(lr=1e-3),
loss=keras.losses.BinaryCrossentropy(),
metrics=metrics)
return model
इसके बाद, हम ट्रेनिंग के दौरान इस्तेमाल करने के लिए कुछ ग्लोबल वैरिएबल और कुछ अर्ली स्टॉपिंग पैरामीटर तय करेंगे.
EPOCHS = 100
BATCH_SIZE = 512
early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_auc',
verbose=1,
patience=10,
mode='max',
restore_best_weights=True)
आखिर में, हम ऊपर बताए गए फ़ंक्शन को कॉल करेंगे, ताकि हमारा मॉडल बन सके:
model = make_model()
model.summary()
हम अपने मॉडल को fit() तरीके से ट्रेन कर सकते हैं. इसके लिए, ऊपर बताए गए पैरामीटर पास करें:
results = model.fit(
train_set,
train_labels,
batch_size=BATCH_SIZE,
epochs=EPOCHS,
callbacks = [early_stopping],
validation_data=(test_set, test_labels),
class_weight=class_weight)
ट्रेनिंग को पूरा होने में कुछ मिनट लगेंगे.
चौथा चरण: मॉडल मेट्रिक को विज़ुअलाइज़ करना
अब हमारे पास एक ट्रेन किया गया मॉडल है. आइए, देखते हैं कि ट्रेनिंग के सभी इपोक में अलग-अलग मेट्रिक को प्लॉट करके, हमारे मॉडल ने कैसा परफ़ॉर्म किया:
mpl.rcParams['figure.figsize'] = (12, 10)
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
def plot_metrics(history):
metrics = ['loss', 'auc', 'precision', 'recall']
for n, metric in enumerate(metrics):
name = metric.replace("_"," ").capitalize()
plt.subplot(2,2,n+1)
plt.plot(history.epoch, history.history[metric], color=colors[0], label='Train')
plt.plot(history.epoch, history.history['val_'+metric],
color=colors[0], linestyle="--", label='Val')
plt.xlabel('Epoch')
plt.ylabel(name)
if metric == 'loss':
plt.ylim([0, plt.ylim()[1]])
elif metric == 'auc':
plt.ylim([0.8,1])
else:
plt.ylim([0,1])
plt.legend()
plot_metrics(results)
आपके ग्राफ़ कुछ इस तरह दिखने चाहिए. हालांकि, ये बिलकुल ऐसे नहीं होंगे:
पांचवां चरण: कन्फ़्यूज़न मैट्रिक्स प्रिंट करना
कंफ़्यूज़न मैट्रिक्स से यह समझने में आसानी होती है कि टेस्ट डेटासेट पर हमारे मॉडल ने कैसा परफ़ॉर्म किया. हर क्लास के लिए, यह हमें टेस्ट के उन उदाहरणों का प्रतिशत दिखाएगा जिनके बारे में हमारे मॉडल ने सही और गलत अनुमान लगाया है. Scikit Learn में, कन्फ़्यूज़न मैट्रिक्स बनाने और उन्हें प्लॉट करने के लिए कुछ यूटिलिटी हैं. हम यहां उनका इस्तेमाल करेंगे.
हमने अपनी नोटबुक की शुरुआत में confusion_matrix यूटिलिटी इंपोर्ट की थी. इसका इस्तेमाल करने के लिए, हम सबसे पहले अपने मॉडल के अनुमानों की सूची बनाएंगे. यहां हम अपने मॉडल से मिली वैल्यू को राउंड करेंगे, ताकि यह सूची, ग्राउंड ट्रुथ लेबल की हमारी सूची से मेल खाए:
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
अब हम इस डेटा को confusion_matrix तरीके में इस्तेमाल करने के लिए तैयार हैं. साथ ही, हम ग्राउंड ट्रुथ लेबल का भी इस्तेमाल करेंगे:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
इससे हमें टेस्ट सेट पर, हमारे मॉडल के सही और गलत अनुमानों की सटीक संख्या पता चलती है. ऊपर बाईं ओर मौजूद संख्या से पता चलता है कि हमारे मॉडल ने टेस्ट सेट के कितने उदाहरणों को सही तरीके से धोखाधड़ी न करने वाले उदाहरणों के तौर पर पहचाना. सबसे नीचे दाईं ओर मौजूद संख्या से पता चलता है कि कितने लेन-देन को धोखाधड़ी के तौर पर सही तरीके से पहचाना गया है. हम इस संख्या पर सबसे ज़्यादा ध्यान देते हैं. यहां देखा जा सकता है कि इसने हर क्लास के लिए, ज़्यादातर सैंपल का सही अनुमान लगाया है.
इसे आसानी से विज़ुअलाइज़ करने के लिए, हमने Scikit Learn के दस्तावेज़ से plot_confusion_matrix फ़ंक्शन को अडॉप्ट किया है. यहां उस फ़ंक्शन के बारे में जानकारी दें:
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize:
cm = np.round(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], 3)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
इसके बाद, अपने मॉडल से मिले डेटा को पास करके प्लॉट बनाएं. यहां हम normalize को True पर सेट कर रहे हैं, ताकि कन्फ़्यूज़न मैट्रिक्स में सही और गलत अनुमानों की संख्या को प्रतिशत के तौर पर दिखाया जा सके:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
आपको कुछ ऐसा दिखेगा (असल संख्याएं अलग-अलग होंगी):
यहां हम देख सकते हैं कि हमारे मॉडल ने टेस्ट सेट में मौजूद 1,594 फ़र्ज़ी लेन-देन में से करीब 85% का सही अनुमान लगाया है. ध्यान दें कि इस लैब में मॉडल की क्वालिटी पर फ़ोकस नहीं किया गया है. अगर आपको प्रोडक्शन में धोखाधड़ी का पता लगाने वाला मॉडल डिप्लॉय करना है, तो आपको धोखाधड़ी वाली क्लास के लिए 85% से ज़्यादा सटीकता चाहिए होगी. इस लैब का मकसद, आपको ऐसे टूल के बारे में बताना है जो असंतुलित डेटासेट पर ट्रेन किए गए मॉडल के बारे में जानकारी देते हैं.
इसके बाद, हम Explainable AI SDK का इस्तेमाल करके यह समझेंगे कि हमारा मॉडल, इन अनुमानों को लगाने के लिए किन सुविधाओं पर भरोसा कर रहा है.
6. Explainable AI SDK का इस्तेमाल करना
Explainable AI SDK, आपके मॉडल के बारे में जानकारी पाने के लिए यूटिलिटी के तरीके उपलब्ध कराता है. यह Tensorflow AI Platform Notebook इंस्टेंस में पहले से इंस्टॉल होता है. ध्यान दें कि हमने इसे अपने लैब की शुरुआत में अपनी नोटबुक में इंपोर्ट किया था. SDK टूल की मदद से, हम अपने मॉडल से नोटबुक इंस्टेंस में फ़ीचर एट्रिब्यूशन पा सकते हैं. इसका मतलब है कि हमें मॉडल का इस्तेमाल करने के लिए, उसे क्लाउड पर डिप्लॉय करने की ज़रूरत नहीं है.
इस सेक्शन में, हम अभी-अभी ट्रेन किए गए मॉडल को TensorFlow SavedModel के तौर पर एक्सपोर्ट करेंगे. इसके बाद, एसडीके को अपनी सेव की गई मॉडल ऐसेट पर ले जाएंगे, ताकि हमें जवाब मिल सकें.
पहला चरण: ट्रेन किए गए मॉडल को एक्सपोर्ट करना
सबसे पहले, अपने मॉडल को नोटबुक इंस्टेंस की डायरेक्ट्री में सेव करें:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
अपनी नोटबुक के बाईं ओर मौजूद साइडबार में फ़ोल्डर व्यू को रीफ़्रेश करने पर, आपको fraud_model/ नाम की एक नई डायरेक्ट्री दिखेगी.
दूसरा चरण: एसडीके की मदद से, जानकारी का मेटाडेटा पाना
इसके बाद, हम Explainable AI SDK को उस डायरेक्ट्री पर पॉइंट करेंगे. ऐसा करने से, मॉडल के बारे में जानकारी पाने के लिए ज़रूरी मेटाडेटा जनरेट होगा. get_metadata() तरीके से, एसडीके आपके मॉडल से मिले मेटाडेटा को दिखाता है. जैसे, इनपुट के नाम:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
व्याख्या करने की सुविधा से, हमें इस सवाल का जवाब देने में मदद मिलती है: "हमारे मॉडल को क्यों लगा कि यह धोखाधड़ी है?"
तीसरा चरण: हमारे मॉडल का बेसलाइन तय करना
टेबल वाले डेटा के लिए, Explainable AI सेवा हर सुविधा के लिए एट्रिब्यूशन वैल्यू दिखाती है. इन वैल्यू से पता चलता है कि किसी सुविधा ने अनुमान पर कितना असर डाला. मान लें कि किसी लेन-देन की वजह से, हमारे मॉडल ने धोखाधड़ी की संभावना को 0.2% बढ़ा दिया. आपको लग रहा होगा कि "0.2% किसके हिसाब से??". अब हम बेसलाइन के कॉन्सेप्ट पर आते हैं.
हमारे मॉडल के लिए बेसलाइन, वह डेटा होता है जिससे तुलना की जाती है. हम अपने मॉडल में हर सुविधा के लिए बेसलाइन वैल्यू चुनते हैं. इसके बाद, बेसलाइन अनुमान वह वैल्यू बन जाती है जिसका अनुमान हमारा मॉडल तब लगाता है, जब सुविधाओं को बेसलाइन पर सेट किया जाता है.
बेसलाइन चुनने का तरीका, अनुमान लगाने से जुड़े उस टास्क पर निर्भर करता है जिसे आपको हल करना है. संख्यात्मक सुविधाओं के लिए, आपके डेटासेट में मौजूद हर सुविधा की मीडियन वैल्यू को बेसलाइन के तौर पर इस्तेमाल करना आम बात है. हालांकि, धोखाधड़ी का पता लगाने के मामले में, हमें ठीक यही नहीं चाहिए. हमारा मुख्य मकसद यह बताना है कि हमारा मॉडल, किसी लेन-देन को धोखाधड़ी के तौर पर कब लेबल करता है. इसका मतलब है कि हमें जिस बेसलाइन केस से तुलना करनी है वह धोखाधड़ी न करने वाले लेन-देन हैं.
इस समस्या को ध्यान में रखते हुए, हम अपने डेटासेट में धोखाधड़ी न करने वाले लेन-देन की मीडियन वैल्यू को बेसलाइन के तौर पर इस्तेमाल करेंगे. ऊपर निकाले गए not_fraud_sample DataFrame का इस्तेमाल करके, हम मीडियन पा सकते हैं. साथ ही, इसे अपने मॉडल के अनुमानित इनपुट से मैच करने के लिए स्केल कर सकते हैं:
not_fraud_sample = not_fraud_sample.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud', 'isFraud'])
baseline = scaler.transform(not_fraud_sample.values)
baseline = np.clip(baseline, -5, 5)
baseline_values = np.median(baseline, axis=0)
ध्यान दें कि हमें बेसलाइन तय करने की ज़रूरत नहीं है. अगर हम ऐसा नहीं करते हैं, तो एसडीके हर इनपुट वैल्यू के लिए 0 को बेसलाइन के तौर पर इस्तेमाल करेगा. धोखाधड़ी का पता लगाने के हमारे इस्तेमाल के उदाहरण में, बेसलाइन तय करना सही है. हम यहां ऐसा करेंगे:
input_name = list(metadata['inputs'])[0]
model_builder.set_numeric_metadata(input_name, input_baselines=[baseline_values.tolist()], index_feature_mapping=df.columns.tolist()[:6])
model_builder.save_metadata(model_dir)
ऊपर दी गई save_metadata() विधि को चलाने से, हमारे मॉडल की डायरेक्ट्री में explanation_metadata.json नाम की एक फ़ाइल बन गई है. अपनी नोटबुक में, fraud_model/ डायरेक्ट्री पर जाएं. इससे आपको पता चलेगा कि फ़ाइल बन गई है. इसमें ऐसा मेटाडेटा होता है जिसका इस्तेमाल एसडीके, सुविधा के एट्रिब्यूशन जनरेट करने के लिए करेगा.
चौथा चरण: मॉडल के बारे में जानकारी पाना
अब हम अलग-अलग उदाहरणों के लिए, सुविधा के एट्रिब्यूशन पाने के लिए तैयार हैं. इसके लिए, हम SDK का इस्तेमाल करके अपने मॉडल का लोकल रेफ़रंस बनाएंगे:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
इसके बाद, आइए एक ऐसे लेन-देन के उदाहरण से अपने मॉडल के बारे में अनुमान और जानकारी पाएं जिसे धोखाधड़ी के तौर पर क्लासिफ़ाई किया जाना चाहिए:
fraud_example = [0.722,0.139,-0.114,-0.258,-0.271,-0.305]
response = local_model.explain([{input_name: fraud_example}])
response[0].visualize_attributions()
इसे चलाने पर, ऐसा विज़ुअलाइज़ेशन बनना चाहिए:
इस उदाहरण में, लेन-देन होने से पहले खाते में मौजूद शुरुआती बैलेंस, धोखाधड़ी का सबसे बड़ा संकेत था. इससे हमारे मॉडल का अनुमान, बेसलाइन से 0.5 से ज़्यादा बढ़ गया. इसके बाद, लेन-देन की रकम, डेस्टिनेशन खाते में बचा हुआ बैलेंस, और चरण सबसे अहम इंडिकेटर थे. डेटासेट में, "स्टेप" समय की एक यूनिट को दिखाता है (एक स्टेप का मतलब एक घंटा है). एट्रिब्यूशन वैल्यू, नेगेटिव भी हो सकती हैं.
विज़ुअलाइज़ेशन के ऊपर प्रिंट की गई "अनुमानित गड़बड़ी" से पता चलता है कि आपको जवाब पर कितना भरोसा करना चाहिए. आम तौर पर, 5% से ज़्यादा की गड़बड़ी का मतलब है कि आपको सुविधा के एट्रिब्यूशन पर भरोसा नहीं करना चाहिए. ध्यान रखें कि आपके जवाब, ट्रेनिंग डेटा और इस्तेमाल किए गए मॉडल के हिसाब से ही बेहतर होंगे. ट्रेनिंग डेटा और मॉडल को बेहतर बनाकर या किसी दूसरे मॉडल बेसलाइन का इस्तेमाल करके, अनुमान में होने वाली गड़बड़ी को कम किया जा सकता है.
स्पष्टीकरण के तरीके में इस्तेमाल किए गए चरणों की संख्या बढ़ाकर, इस गड़बड़ी को कम किया जा सकता है. एसडीके की मदद से इसे बदला जा सकता है. इसके लिए, आपको अपनी व्याख्या के कॉन्फ़िगरेशन में path_count पैरामीटर जोड़ना होगा. अगर आपने कोई वैल्यू नहीं दी है, तो डिफ़ॉल्ट रूप से यह 10 पर सेट होता है:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
इस मॉडल पर, भरोसेमंद एआई की मदद से और भी कई काम किए जा सकते हैं. यहां कुछ आइडिया दिए गए हैं:
- हमारे मॉडल को कई उदाहरण भेजना और एट्रिब्यूशन वैल्यू का औसत निकालना, ताकि यह पता चल सके कि कुछ सुविधाएं ज़्यादा अहम हैं या नहीं. हम इसका इस्तेमाल अपने मॉडल को बेहतर बनाने के लिए कर सकते हैं. साथ ही, उन सुविधाओं को हटा सकते हैं जो ज़रूरी नहीं हैं
- ऐसे फ़ॉल्स पॉज़िटिव का पता लगाना जिन्हें हमारा मॉडल धोखाधड़ी के तौर पर फ़्लैग करता है, लेकिन वे धोखाधड़ी वाले लेन-देन नहीं होते. साथ ही, उनकी एट्रिब्यूशन वैल्यू की जांच करना
- किसी दूसरे बेसलाइन का इस्तेमाल करें और देखें कि इससे एट्रिब्यूशन वैल्यू पर क्या असर पड़ता है
🎉 बधाई हो! 🎉
आपने यह सीखा है कि डेटा में अंतर होने पर, उसका हिसाब कैसे लगाया जाता है. साथ ही, धोखाधड़ी वाले लेन-देन का पता लगाने के लिए, TensorFlow मॉडल को कैसे ट्रेन किया जाता है. इसके अलावा, आपने यह भी सीखा कि Explainable AI SDK का इस्तेमाल करके यह कैसे देखा जाता है कि आपका मॉडल, अनुमान लगाने के लिए किन सुविधाओं पर सबसे ज़्यादा भरोसा कर रहा है. अगर आपको आगे नहीं पढ़ना है, तो यहां रुकें. नोटबुक में SDK टूल का इस्तेमाल करने का मकसद, मॉडल डेवलपमेंट की प्रोसेस को आसान बनाना है. इससे आपको मॉडल डिप्लॉय करने से पहले, उसके बारे में जानकारी मिलती है. ऐसा हो सकता है कि अपनी पसंद का मॉडल बनाने के बाद, आपको बड़े पैमाने पर अनुमान पाने के लिए उसे डिप्लॉय करना पड़े. अगर आपको लगता है कि यह समस्या आपके साथ हो रही है, तो अगले चरण पर जाएं. यह चरण ज़रूरी नहीं है. अगर आपने यह प्रोसेस पूरी कर ली है, तो जगह खाली करें चरण पर जाएं.
7. ज़रूरी नहीं: मॉडल को AI Platform Prediction पर डिप्लॉय करना
इस चरण में, आपको अपने मॉडल को AI Platform Prediction पर डिप्लॉय करने का तरीका बताया जाएगा.
पहला चरण: सेव की गई मॉडल डायरेक्ट्री को Cloud Storage बकेट में कॉपी करें.
हमने एसडीके टूल के जिन चरणों को पहले पूरा किया था उनकी मदद से, आपके पास अपने मॉडल को AI Platform पर डिप्लॉय करने के लिए ज़रूरी सभी चीज़ें मौजूद हैं. डिप्लॉयमेंट के लिए तैयार होने के लिए, आपको अपनी SavedModel ऐसेट और जानकारी देने वाले मेटाडेटा को Cloud Storage बकेट में रखना होगा. इससे Explainable AI सेवा, उन्हें पढ़ सकेगी.
इसके लिए, हम कुछ एनवायरमेंट वैरिएबल तय करेंगे. नीचे दी गई वैल्यू में, अपने Google Cloud प्रोजेक्ट का नाम और उस बकेट का नाम डालें जिसे आपको बनाना है. यह नाम सबसे अलग होना चाहिए.
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
अब हम एक्सपोर्ट की गई TensorFlow मॉडल ऐसेट को सेव करने के लिए, स्टोरेज बकेट बनाने के लिए तैयार हैं. मॉडल को डिप्लॉय करते समय, हम AI Platform को इस बकेट के बारे में बताएंगे.
बकेट बनाने के लिए, अपनी नोटबुक में यह gsutil कमांड चलाएं:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
इसके बाद, अपनी स्थानीय मॉडल डायरेक्ट्री को उस बकेट में कॉपी करें:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
दूसरा चरण: मॉडल को डिप्लॉय करना
इसके बाद, हम कुछ ऐसे वैरिएबल तय करेंगे जिनका इस्तेमाल हम डिप्लॉयमेंट कमांड में करेंगे:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
हम इस gcloud कमांड का इस्तेमाल करके मॉडल बना सकते हैं:
!gcloud ai-platform models create $MODEL --region=us-central1
अब हम gcloud की मदद से, इस मॉडल का पहला वर्शन डिप्लॉय करने के लिए तैयार हैं. वर्शन को डिप्लॉय होने में ~5 से 10 मिनट लगेंगे:
!gcloud beta ai-platform versions create $VERSION \
--model $MODEL \
--origin $model_path \
--runtime-version 2.1 \
--framework TENSORFLOW \
--python-version 3.7 \
--machine-type n1-standard-4 \
--explanation-method 'sampled-shapley' \
--num-paths 10 \
--region=us-central1
origin फ़्लैग में, हम सेव किए गए मॉडल और मेटाडेटा फ़ाइल की Cloud Storage लोकेशन पास करते हैं. फ़िलहाल, Explainable AI में टेबल वाले मॉडल के लिए, दो अलग-अलग तरीकों से जानकारी देने की सुविधा उपलब्ध है. यहां हम सैंपल्ड शैपली का इस्तेमाल कर रहे हैं. num-paths पैरामीटर से, हर इनपुट सुविधा के लिए सैंपल किए गए पाथ की संख्या का पता चलता है. आम तौर पर, मॉडल जितना ज़्यादा जटिल होता है, कन्वर्जेंस तक पहुंचने के लिए उतने ही ज़्यादा अनुमानित चरणों की ज़रूरत होती है.
यह पुष्टि करने के लिए कि आपका मॉडल सही तरीके से डिप्लॉय किया गया है, यह gcloud कमांड चलाएं:
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
राज्य READY होना चाहिए.
तीसरा चरण: डिप्लॉय किए गए मॉडल से अनुमान और उनके बारे में जानकारी पाना
हमारा मुख्य मकसद यह बताना है कि हमारा मॉडल किन मामलों में धोखाधड़ी का अनुमान लगाता है. हम अपने मॉडल को पांच टेस्ट उदाहरण भेजेंगे. ये सभी धोखाधड़ी वाले लेन-देन हैं.
हम अनुमान पाने के लिए, Google Cloud CLI का इस्तेमाल करेंगे. हमारे टेस्ट सेट से धोखाधड़ी के सभी उदाहरणों के इंडेक्स पाने के लिए, यह कोड चलाएं:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
इसके बाद, हम पांच उदाहरणों को उस फ़ॉर्मैट में सेव करेंगे जिसमें हमारा मॉडल काम करता है. साथ ही, उन्हें एक फ़ाइल में लिखेंगे:
num_test_examples = 5
instances = []
for i in range(num_test_examples):
ex = test_set[fraud_indices[i]]
instances.append({input_name: ex.tolist()})
with open('prediction.json', 'a') as outputfile:
json.dump({"instances": instances}, outputfile)
gcloud का इस्तेमाल करके, इन पांच उदाहरणों को हमारे मॉडल को भेजा जा सकता है:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
जवाब के JSON में, आपको इन उदाहरणों में हर सुविधा के लिए एट्रिब्यूशन वैल्यू दिखेंगी. हर उदाहरण के लिए example_score कुंजी में मॉडल का अनुमान शामिल होता है. इस मामले में, किसी खास लेन-देन के फ़र्ज़ी होने की संभावना का प्रतिशत शामिल होता है.
8. साफ़-सफ़ाई सेवा
अगर आपको इस नोटबुक का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल न करने पर इसे बंद कर दें. Cloud Console में Notebooks के यूज़र इंटरफ़ेस (यूआई) में जाकर, नोटबुक चुनें. इसके बाद, बंद करें को चुनें:
अगर आपको इस लैब में बनाए गए सभी संसाधन मिटाने हैं, तो नोटबुक इंस्टेंस को बंद करने के बजाय मिटा दें.
Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, Storage पर जाएं. इसके बाद, मॉडल ऐसेट सेव करने के लिए बनाए गए दोनों बकेट मिटाएं.