इस पेज का अनुवाद Cloud Translation API से किया गया है.

Cloud AI Platform की मदद से, धोखाधड़ी का पता लगाने वाले मॉडल के बारे में जानकारी

1. खास जानकारी

इस लैब में, आपको AI Platform Notebooks का इस्तेमाल किया जाएगा. इसकी मदद से, आपको धोखाधड़ी वाले लेन-देन की पहचान करने के लिए, मॉडल बनाने और उसे ट्रेनिंग देने का विकल्प मिलेगा. साथ ही, Explainable AI SDK की मदद से, मॉडल के अनुमानों को समझा जाएगा. धोखाधड़ी की पहचान, खास तौर पर वित्तीय सेवाओं के लिए की जाने वाली गड़बड़ी की पहचान है. इससे एमएल मॉडल के लिए कुछ दिलचस्प चुनौतियां सामने आ जाती हैं. जैसे, डेटासेट में असंतुलित होना और किसी मॉडल के नतीजों को समझाने की ज़रूरत.

आपने क्या सीखा

आपको, इनके बारे में जानकारी मिलेगी:

असंतुलित डेटासेट मैनेज करना
AI Platform Notebooks में tf.keras की मदद से धोखाधड़ी का पता लगाने वाला मॉडल बनाएं और उसका आकलन करें
यह समझने के लिए कि इस मॉडल ने लेन-देन को धोखाधड़ी वाला क्यों बताया है, notebook में पूरी जानकारी देने वाले एआई SDK टूल का इस्तेमाल करें
मॉडल को एआई प्लैटफ़ॉर्म पर पूरी जानकारी के साथ डिप्लॉय करें. साथ ही, डिप्लॉय किए गए मॉडल के बारे में अनुमान और जानकारी पाएं

Google Cloud पर इस लैब को चलाने की कुल लागत करीब $1 है.

2. धोखाधड़ी का पता क्यों लगाना?

गड़बड़ी की पहचान करना मशीन लर्निंग के लिए अच्छा विकल्प हो सकता है, क्योंकि डेटा में आउटलायर की पहचान करने के लिए, नियम-आधारित स्टेटमेंट की सीरीज़ लिखना अक्सर मुश्किल होता है. धोखाधड़ी का पता लगाना, एक तरह की गड़बड़ी का पता लगाने की सुविधा है. इससे मशीन लर्निंग के मामले में दो दिलचस्प चुनौतियां सामने आती हैं:

बहुत असंतुलित डेटासेट: ऐसा इसलिए है, क्योंकि अनियमितताएं ही अनियमितताएं होती हैं, इसलिए उनमें ज़्यादा डेटा नहीं होता. एमएल सबसे अच्छी तरह तब काम करता है, जब डेटासेट संतुलित हो. इसलिए, जब आउटलायर आपके डेटा का 1% से कम हिस्सा बनाते हैं, तो चीज़ें मुश्किल हो सकती हैं.
नतीजों की पूरी जानकारी देने की ज़रूरत है: अगर आप धोखाधड़ी वाली गतिविधि के बारे में जानना चाहते हैं, तो हो सकता है कि आप यह जानना चाहें कि किसी सिस्टम ने धोखाधड़ी वाली गतिविधि की शिकायत क्यों की, न कि सिर्फ़ धोखाधड़ी करने के लिए. इसमें, ज़्यादा जानकारी देने वाले टूल आपकी मदद कर सकते हैं.

3. अपना एनवायरमेंट सेट अप करें

इस कोडलैब को चलाने के लिए, आपके पास Google Cloud Platform का ऐसा प्रोजेक्ट होना चाहिए जिसमें बिलिंग की सुविधा चालू हो. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.

पहला चरण: Cloud AI Platform मॉडल API को चालू करना

अपने Cloud Console के एआई प्लैटफ़ॉर्म मॉडल सेक्शन पर जाएं और अगर यह पहले से चालू नहीं है, तो 'चालू करें' पर क्लिक करें.

दूसरा चरण: Compute Engine API चालू करना

Compute Engine पर जाएं और अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें. आपको अपना notebook इंस्टेंस बनाने के लिए इसकी ज़रूरत होगी.

तीसरा चरण: AI Platform Notebooks का इंस्टेंस बनाना

अपने Cloud Console के AI Platform Notebooks सेक्शन पर जाएं और नया इंस्टेंस पर क्लिक करें. इसके बाद, बिना जीपीयू के TensorFlow Enterprise 2.1 इंस्टेंस टाइप चुनें:

डिफ़ॉल्ट विकल्पों का इस्तेमाल करें और फिर बनाएं पर क्लिक करें. इंस्टेंस बनाने के बाद, 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 हज़ार में धोखाधड़ी वाले लेन-देन हैं - जो पूरे डेटासेट का सिर्फ़ 0.1% है!

हम सिंथेटिक डेटासेट का इस्तेमाल क्यों कर रहे हैं? वित्तीय डेटासेट आसानी से नहीं मिल पाते, खास तौर पर धोखाधड़ी का पता लगाने के लिए. आम तौर पर, इनमें व्यक्तिगत पहचान से जुड़ी जानकारी होती है. इसलिए, यह ज़रूरी है कि उपयोगकर्ताओं की पहचान पूरी तरह से छिपाई जाए. इसमें सुविधा के नाम भी शामिल हैं. सिंथेटिक डेटासेट के साथ, हमें इनमें से किसी भी चीज़ के बारे में चिंता करने की ज़रूरत नहीं है. Kaggle का PaySim डेटासेट, इस फ़ील्ड में चल रही काफ़ी रिसर्च पर आधारित है.*

पहला चरण: Kaggle डेटासेट डाउनलोड करना और Pandas के साथ पढ़ना

हमने आपके लिए Google Cloud Storage में Kaggle डेटासेट उपलब्ध कराया है. आप अपनी Jupyter notebook में नीचे दिया गया 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 हज़ार के रैंडम सैंपल लेंगे. इस तरह, डेटासेट में पहले के .1% की तुलना में 25% धोखाधड़ी के मामले होंगे.

सबसे पहले, डेटा को दो DataFrames में बांटें. पहला, धोखाधड़ी के लिए और दूसरा बिना धोखाधड़ी के लिए. हम बाद में कोडलैब में इसका इस्तेमाल, अपने मॉडल को डिप्लॉय करते समय करेंगे:

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')

*ई॰ ए॰ लोपेज़-रोजस, एस॰ एल्मीर और एक्सलसन. "PaySim: धोखाधड़ी का पता लगाने के लिए एक फ़ाइनेंशियल मोबाइल मनी सिम्युलेटर". इसमें: 28वीं यूरोपियन मॉडलिंग ऐंड सिम्युलेशन सिंपोज़ियम-ईएमएसएस, लर्नाका, साइप्रस. 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 के सिक्वेंशल मॉडल एपीआई का इस्तेमाल करके बनाएंगे. इससे हमें अपने मॉडल को लेयर के स्टैक के रूप में तय करने में मदद मिलेगी. हमारी ट्रेनिंग के दौरान, हम कई तरह की मेट्रिक को ट्रैक करते हैं. इनसे हमें यह समझने में मदद मिलती है कि हमारे डेटासेट की हर क्लास में मॉडल कैसा परफ़ॉर्म कर रहा है.

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 में भ्रम की स्थिति वाले मैट्रिक्स बनाने और प्लॉट करने के लिए कुछ सुविधाएं उपलब्ध हैं. इनका इस्तेमाल हम यहां करेंगे.

अपनी notebook की शुरुआत में हमने 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)

यह हमें हमारे टेस्ट सेट पर, हमारे मॉडल के सही और गलत अनुमानों की कुल संख्या दिखाती है. ऊपर बाईं ओर दी गई संख्या से पता चलता है कि हमारे टेस्ट सेट से ऐसे कितने उदाहरण हैं जिनका अनुमान हमारे मॉडल ने धोखाधड़ी से नहीं लिया है. सबसे नीचे दाईं ओर मौजूद संख्या से पता चलता है कि कितने लोगों के धोखाधड़ी वाले होने का अनुमान सही था (हम इस संख्या पर ध्यान देते हैं). आप देख सकते हैं कि इसने हर क्लास के लिए, ज़्यादातर सैंपल के बारे में सही अनुमान लगाया है.

इसे आसानी से विज़ुअलाइज़ करने के लिए, हमने स्किट जानें दस्तावेज़ के 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% से ज़्यादा सटीक जानकारी चाहिए. इस लैब का मकसद, आपको असंतुलित डेटासेट की मदद से तैयार किए गए मॉडल को समझाने के लिए टूल उपलब्ध कराना है.

इसके बाद, हम जानकारी देने वाले एआई SDK टूल का इस्तेमाल करके यह पता करेंगे कि हमारा मॉडल किन सुविधाओं का इस्तेमाल करके ये अनुमान लगा रहा है.

6. जानकारी देने वाले एआई SDK टूल का इस्तेमाल करना

पूरी जानकारी देने वाले एआई SDK टूल की मदद से, अपने मॉडल की जानकारी पाने के लिए कई तरीके इस्तेमाल किए जा सकते हैं. यह Tensorflow AI Platform Notebook के इंस्टेंस में पहले से इंस्टॉल होता है. ध्यान दें कि हमने इसे अपनी लैब की शुरुआत में, notebook में इंपोर्ट किया था. SDK टूल की मदद से, हम अपने मॉडल से नोटबुक इंस्टेंस में फ़ीचर एट्रिब्यूशन हासिल कर सकते हैं. इसका मतलब है कि हमें इस मॉडल का इस्तेमाल करने के लिए, अपने मॉडल को क्लाउड पर डिप्लॉय नहीं करना होगा.

इस सेक्शन में, उस मॉडल को एक्सपोर्ट किया जाएगा जिसे हमने अभी-अभी TensorFlow के तौर पर तैयार किया है. इसके बाद, हम उस मॉडल को एक्सप्लेनेशंस पाने के लिए, SDK टूल को सेव की गई मॉडल ऐसेट की मदद से एक्सपोर्ट करेंगे.

पहला चरण: ट्रेन किए गए मॉडल को एक्सपोर्ट करना

सबसे पहले, अपने मॉडल को notebook के इंस्टेंस में डायरेक्ट्री में सेव करें:

model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)

अगर आप अपनी notebook के बाएं साइडबार में फ़ोल्डर व्यू को रीफ़्रेश करते हैं, तो आपको fraud_model/ बनाई गई नाम की नई डायरेक्ट्री दिखेगी.

दूसरा चरण: SDK टूल की मदद से जानकारी देने वाला मेटाडेटा पाना

इसके बाद, हम उस डायरेक्ट्री में ज़्यादा जानकारी देने वाले एआई SDK टूल के बारे में बात करेंगे. ऐसा करने से, मॉडल एक्सप्लेनेशंस पाने के लिए ज़रूरी मेटाडेटा जनरेट होगा. get_metadata() वाला तरीका, आपके मॉडल से SDK टूल का मेटाडेटा दिखाता है. जैसे, इनपुट के नाम:

model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)

ज़्यादा जानकारी देने से, हमें इस सवाल का जवाब पाने में मदद मिलती है: "हमारे मॉडल को यह धोखाधड़ी क्यों लगा?"

तीसरा चरण: हमारे मॉडल की बेसलाइन तय करना

टेबल फ़ॉर्मैट वाले डेटा के लिए, एक्सप्लेनेबल एआई (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)

ध्यान दें कि हमें बेसलाइन तय करने की ज़रूरत नहीं है. अगर हम ऐसा नहीं करते हैं, तो SDK टूल हर इनपुट वैल्यू के लिए बेसलाइन के तौर पर 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 नाम की डायरेक्ट्री में एक फ़ाइल बन गई है. अपनी नोटबुक में, search_model/ डायरेक्ट्री पर जाकर पुष्टि करें कि फ़ाइल बन गई है. इसमें ऐसा मेटाडेटा शामिल है जिसका इस्तेमाल SDK टूल, सुविधा के एट्रिब्यूशन जनरेट करने के लिए करेगा.

चौथा चरण: मॉडल एक्सप्लेनेशंस पाना

अब हम अलग-अलग उदाहरणों के साथ फ़ीचर एट्रिब्यूशन दिखाने के लिए तैयार हैं. ऐसा करने के लिए, हम पहले 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 मॉडल को ट्रेनिंग देने, और जानकारी देने वाले एआई SDK टूल की मदद से यह पता लगाने के बारे में सीखा है कि आपका मॉडल अलग-अलग अनुमान लगाने के लिए किन सुविधाओं का सबसे ज़्यादा इस्तेमाल करता है. अगर आप चाहें, तो यहां रुक सकते हैं. नोटबुक में SDK टूल का इस्तेमाल करने का मकसद, मॉडल को डिप्लॉय करने से पहले एक्सप्लेनेशंस का ऐक्सेस देकर, मॉडल डेवलपमेंट की प्रोसेस को आसान बनाना है. अपनी पसंद के मुताबिक मॉडल बना लेने के बाद, हो सकता है कि आप बड़े पैमाने पर अनुमान पाने के लिए उसे डिप्लॉय करना चाहें. अगर आपको भी ऐसा लगता है, तो अगले वैकल्पिक चरण पर जाएं. अगर आपका काम हो गया है, तो सीधे क्लीनअप चरण पर जाएं.

7. ज़रूरी नहीं: मॉडल को AI Platform अनुमान में डिप्लॉय करें

इस चरण में, आपको AI Platform के अनुमान पर अपने मॉडल को डिप्लॉय करने का तरीका पता चलेगा.

पहला चरण: सेव की गई मॉडल डायरेक्ट्री को Cloud Storage बकेट में कॉपी करें.

SDK टूल के जो चरण हमने पहले चलाए हैं उनमें आपके पास वह सब कुछ है जिसकी मदद से अपने मॉडल को AI Platform पर डिप्लॉय किया जा सकता है. डिप्लॉयमेंट के लिए तैयार रहने के लिए, आपको अपनी सेव की गई मॉडल ऐसेट और जानकारी देने वाले मेटाडेटा को Cloud Storage बकेट में रखना होगा. इस बकेट को ज़्यादा जानकारी देने वाली एआई सेवा को ऐक्सेस कर सकती है.

इसके लिए, हम कुछ एनवायरमेंट वैरिएबल तय करेंगे. नीचे दी गई वैल्यू में, अपने 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 लोकेशन को पास करते हैं. फ़िलहाल, टेबल फ़ॉर्मैट वाले मॉडल में एक्सप्लेनेबल एआई के दो अलग-अलग तरीके उपलब्ध हैं. हम सैंपल किए गए Shapley का इस्तेमाल कर रहे हैं. num-paths पैरामीटर से हर इनपुट सुविधा के लिए, सैंपल के तौर पर इस्तेमाल किए गए पाथ की संख्या के बारे में पता चलता है. आम तौर पर, यह मॉडल जितना मुश्किल होता है सही कन्वर्ज़न तक पहुंचने के लिए, अनुमान के उतने ही ज़्यादा चरणों की ज़रूरत होती है.

अपने मॉडल के सही तरीके से डिप्लॉय होने की पुष्टि करने के लिए, यहां दिया गया gcloud कमांड चलाएं:

!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1

राज्य READY होना चाहिए.

तीसरा चरण: डिप्लॉय किए गए मॉडल के बारे में अनुमान और जानकारी पाना

जानकारी देने के मकसद से, हम उन मामलों को बेहतर तरीके से पेश करते हैं जहां हमारा मॉडल धोखाधड़ी का अनुमान लगाता है. हम अपने मॉडल को टेस्ट के ऐसे पांच उदाहरण भेजेंगे जो धोखाधड़ी वाले लेन-देन हैं.

हम पूर्वानुमान पाने के लिए Google Cloud सीएलआई का इस्तेमाल करेंगे. हमारे टेस्ट सेट से, धोखाधड़ी वाले सभी उदाहरणों की जानकारी पाने के लिए, नीचे दिया गया कोड चलाएं:

fraud_indices = []

for i,val in enumerate(test_labels):
    if val == 1:
        fraud_indices.append(i)

इसके बाद, हम 5 उदाहरणों को उस फ़ॉर्मैट में सेव करेंगे जिस फ़ॉर्मैट में हमारा मॉडल उम्मीद करता है और फिर उन्हें किसी फ़ाइल में लिखेंगे:

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. साफ़-सफ़ाई सेवा

अगर आपको इस notebook का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल में न होने पर इसे बंद कर दें. अपने Cloud Console में Notebook के यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें और फिर बंद करें चुनें:

यदि आप इस लैब में बनाए गए सभी संसाधनों को हटाना चाहते हैं, तो इसे रोकने के बजाय बस नोटबुक इंस्टेंस को हटाएं.

अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, 'स्टोरेज' पर जाएं और अपने मॉडल ऐसेट को स्टोर करने के लिए बनाए गए दोनों बकेट मिटाएं.