1. खास जानकारी
इस लैब में, आपको सीधे तौर पर BigQuery डेटासेट को इनजेस्ट करना होगा. साथ ही, Google Cloud AI Platform पर TensorFlow Enterprise की मदद से, धोखाधड़ी का पता लगाने वाले मॉडल को ट्रेन करना होगा.
आपको क्या सीखने को मिलेगा
आपको, इनके बारे में जानकारी मिलेगी:
- BigQuery पर डेटा का विश्लेषण करना
- TensorFlow Enterprise में BigQuery कनेक्टर का इस्तेमाल करके डेटा इंपोर्ट करना
- असमान डेटासेट की मदद से धोखाधड़ी का पता लगाने के लिए, डीप लर्निंग मॉडल बनाना
2. BigQuery में डेटा का विश्लेषण करना
इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.
पहला चरण: BigQuery के सार्वजनिक डेटासेट को ऐक्सेस करना
Google Cloud Console में BigQuery के सार्वजनिक डेटासेट ऐक्सेस करने के लिए, इस लिंक पर जाएं.
नीचे बाएं कोने में मौजूद संसाधन ट्री में, आपको डेटासेट की सूची दिखेगी. जब तक आपको ml-datasets न मिल जाए, तब तक उपलब्ध डेटासेट में नेविगेट करें. इसके बाद, इसमें मौजूद ulb-fraud-detection टेबल चुनें:
डेटासेट के बारे में ज़्यादा जानने के लिए, हर टैब पर क्लिक करें:
- स्कीमा टैब में डेटा टाइप के बारे में बताया गया है.
- जानकारी टैब में बताया गया है कि यह एक असंतुलित डेटासेट है. इसमें 2,84,407 लेन-देन हैं, जिनमें से 492 धोखाधड़ी वाले हैं.
- झलक टैब में, डेटासेट के रिकॉर्ड दिखते हैं.
दूसरा चरण: टेबल से क्वेरी करना
'जानकारी' टैब से हमें डेटा के बारे में यह जानकारी मिलती है:
- समय, डेटासेट में मौजूद पहले लेन-देन और चुने गए लेन-देन के बीच का समय होता है. इसे सेकंड में मापा जाता है.
- V1-V28 ऐसे कॉलम हैं जिन्हें डाइमेंशनैलिटी रिडक्शन की तकनीक का इस्तेमाल करके बदला गया है. इस तकनीक को PCA कहा जाता है. इससे डेटा को पहचान छिपाकर इस्तेमाल किया जा सकता है.
- रकम, लेन-देन की रकम होती है.
क्वेरी चलाने के लिए, क्वेरी टेबल पर क्लिक करके ज़्यादा जानें:
सभी कॉलम देखने के लिए, स्टेटमेंट को अपडेट करके उसमें * जोड़ें. इसके बाद, चलाएं पर क्लिक करें.
SELECT * FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection` LIMIT 1000
तीसरा चरण: डेटा का विश्लेषण करना
BigQuery में कई सांख्यिकीय फ़ंक्शन उपलब्ध हैं. आइए, एक नज़र डालते हैं कि डेटा, टारगेट वैरिएबल क्लास से कैसे जुड़ा है.
SELECT CORR(Time,Class) as TimeCorr, CORR(V1,Class) as V1Corr, CORR(V2,Class) as V2Corr, CORR(Amount,Class) as AmountCorr FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
कोरिलेशन की वैल्यू -1 (नेगेटिव कोरिलेशन) से लेकर 1 (पॉज़िटिव कोरिलेशन) तक होती है. 0 का मतलब है कि दोनों के बीच कोई संबंध नहीं है.
ध्यान दें कि V1 और V2 का हमारे टारगेट वैरिएबल से थोड़ा-बहुत संबंध है. इनकी वैल्यू क्रमशः -0.1 और .1 है.
हमें समय के साथ ज़्यादा बदलाव नहीं दिख रहा है. थोड़ा नेगेटिव कोरिलेशन से पता चल सकता है कि डेटासेट में समय के साथ धोखाधड़ी वाले लेन-देन कम हो रहे हैं.
राशि का कोरिलेशन और भी कम है. इससे पता चलता है कि ज़्यादा राशि वाले लेन-देन में धोखाधड़ी होने की संभावना बहुत कम होती है.
चौथा चरण: फ़ीचर स्केलिंग के लिए औसत वैल्यू का हिसाब लगाना
सुविधा की वैल्यू को सामान्य करने से, न्यूरल नेटवर्क को तेज़ी से कन्वर्ज करने में मदद मिल सकती है. वैल्यू को 0 के आस-पास रखने के लिए, स्टैंडर्ड डेविएशन को 1 पर सेट किया जाता है. नीचे दी गई क्वेरी से औसत वैल्यू वापस मिलेंगी. नतीजे को सेव करने की ज़रूरत नहीं है, क्योंकि बाद में हमारे पास इसके लिए कोड स्निपेट होगा.
आपको यह भी दिखेगा कि क्वेरी में एक दिलचस्प WHERE क्लॉज़ शामिल है. हम इसके बारे में अगले सेक्शन में बताएंगे. इसमें हम ट्रेनिंग और टेस्ट सेट के बीच डेटा को बांटने के तरीके के बारे में जानकारी देंगे.
SELECT
AVG(Time), AVG(V1), AVG(V2), AVG(V3), AVG(V4), AVG(V5), AVG(V6), AVG(V7), AVG(V8),
AVG(V9), AVG(V10),AVG(V11), AVG(V12), AVG(V13), AVG(V14), AVG(V15), AVG(V16),
AVG(V17), AVG(V18), AVG(V19), AVG(V20), AVG(V21), AVG(V22), AVG(V23), AVG(V24),
AVG(V25), AVG(V26), AVG(V27),AVG(V28), AVG(Amount)
FROM
`bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE
MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),
SAFE_CAST(Amount AS STRING)))),10) < 8
पांचवां चरण: डेटा को अलग-अलग हिस्सों में बांटना
मशीन लर्निंग मॉडल बनाने के लिए, आम तौर पर तीन डेटा सेट का इस्तेमाल किया जाता है:
- ट्रेनिंग: इसका इस्तेमाल, पैरामीटर को बार-बार अडजस्ट करके मॉडल बनाने के लिए किया जाता है
- पुष्टि करना: इसका इस्तेमाल यह आकलन करने के लिए किया जाता है कि मॉडल ओवरफ़िटिंग कर रहा है या नहीं. इसके लिए, ट्रेनिंग प्रोसेस के दौरान स्वतंत्र डेटा की पुष्टि की जाती है
- जांच: इसका इस्तेमाल मॉडल बनाने के बाद, यह आकलन करने के लिए किया जाता है कि मॉडल कितना सटीक है
इस कोडलैब में, हम 80/10/10 के हिसाब से डेटा को ट्रेन/पुष्टि/टेस्ट के लिए बांटेंगे.
हम हर डेटासेट को BigQuery में उसकी टेबल में रखेंगे. सबसे पहले, BigQuery में "डेटासेट" बनाएं. यह एक कंटेनर होता है, जिसमें मिलती-जुलती टेबल होती हैं. अपना प्रोजेक्ट चुनने के बाद, डेटासेट बनाएं को चुनें.
इसके बाद, ट्रेन, पुष्टि, और टेस्ट टेबल को शामिल करने के लिए, tfe_codelab नाम का डेटासेट बनाएं.
अब हम ट्रेन, टेस्ट, और पुष्टि करने के लिए तीन क्वेरी चलाएंगे. साथ ही, डेटा को नए tfe_codelab डेटासेट में सेव करेंगे.
क्वेरी एडिटर में, ट्रेनिंग डेटा जनरेट करने के लिए क्वेरी चलाएं:
SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) < 8
क्वेरी पूरी होने के बाद, नतीजों को BigQuery टेबल में सेव करें.
अभी बनाए गए tfe_codelab डेटासेट में, टेबल का नाम ulb_fraud_detection_train रखें और डेटा सेव करें.
WHERE क्लॉज़, कुछ कॉलम पर हैश का हिसाब लगाकर डेटा को पहले बांटता है. इसके बाद, यह उन लाइनों को चुनता है जिनमें हैश को 10 से भाग देने पर, शेषफल 80 से कम होता है. इससे हमें 80% डेटा मिलता है.
अब हम पुष्टि करने और जांच करने वाले सेट के लिए, इसी प्रोसेस को दोहराएंगे. इसके लिए, हम ऐसी मिलती-जुलती क्वेरी का इस्तेमाल करेंगे जो हर सेट के लिए 10% डेटा चुनती हैं.
पुष्टि करना
SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) = 8
इस क्वेरी के नतीजों को ulb_fraud_detection_val नाम की टेबल में सेव करें.
टेस्ट
SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) = 9
इस क्वेरी के नतीजों को ulb_fraud_detection_test नाम की टेबल में सेव करो.
3. Notebook का एनवायरमेंट सेट अप करना
अब जब हमने डेटा के बारे में कुछ जानकारी हासिल कर ली है, तो चलिए अब मॉडल डेवलपमेंट एनवायरमेंट सेट अप करते हैं.
पहला चरण: एपीआई चालू करना
BigQuery कनेक्टर, BigQuery Storage API का इस्तेमाल करता है. कंसोल में BigQuery Storage API खोजें. अगर यह एपीआई फ़िलहाल बंद है, तो इसे चालू करें.
दूसरा चरण: AI Platform Notebooks का इंस्टेंस बनाना
Cloud Console के AI Platform Notebooks सेक्शन पर जाएं और नया इंस्टेंस पर क्लिक करें. इसके बाद, GPU के बिना TensorFlow Enterprise 1.x का सबसे नया इंस्टेंस टाइप चुनें:
डिफ़ॉल्ट विकल्पों का इस्तेमाल करें. इसके बाद, बनाएं पर क्लिक करें. इंस्टेंस बन जाने के बाद, JupyterLab खोलें को चुनें:
इसके बाद, JupyterLab में Python 3 नोटबुक बनाएं:
4. BigQuery से रिकॉर्ड इनजेस्ट करना
पहला चरण: Python पैकेज इंपोर्ट करना
अपनी नोटबुक की पहली सेल में, यहां दिए गए इंपोर्ट जोड़ें और सेल को चलाएं. इसे चलाने के लिए, सबसे ऊपर मौजूद मेन्यू में जाकर राइट ऐरो बटन दबाएं या command-enter दबाएं:
import tensorflow as tf
import tensorflow.keras as keras
import tensorflow.keras.layers as layers
from tensorflow_io.bigquery import BigQueryClient
import functools
tf.enable_eager_execution()
दूसरा चरण: कॉन्स्टेंट तय करना
अब हम प्रोजेक्ट में इस्तेमाल करने के लिए, कुछ कॉन्स्टेंट तय करेंगे. GCP_PROJECT_ID को उस असल प्रोजेक्ट आईडी से बदलें जिसका इस्तेमाल किया जा रहा है. नई सेल बनाते समय, उन्हें तुरंत चलाएं.
GCP_PROJECT_ID = '<YOUR_PROJECT_ID>'
DATASET_GCP_PROJECT_ID = GCP_PROJECT_ID # A copy of the data is saved in the user project
DATASET_ID = 'tfe_codelab'
TRAIN_TABLE_ID = 'ulb_fraud_detection_train'
VAL_TABLE_ID = 'ulb_fraud_detection_val'
TEST_TABLE_ID = 'ulb_fraud_detection_test'
FEATURES = ['Time','V1','V2','V3','V4','V5','V6','V7','V8','V9','V10','V11','V12','V13','V14','V15','V16','V17','V18','V19','V20','V21','V22','V23','V24','V25','V26','V27','V28','Amount']
LABEL='Class'
DTYPES=[tf.float64] * len(FEATURES) + [tf.int64]
तीसरा चरण: हेल्पर फ़ंक्शन तय करना
अब, कुछ फ़ंक्शन तय करते हैं. read_session(), BigQuery टेबल से डेटा पढ़ता है. extract_labels() एक हेल्पर फ़ंक्शन है. यह लेबल कॉलम को बाकी कॉलम से अलग करता है, ताकि डेटासेट बाद में keras.model_fit() के लिए ज़रूरी फ़ॉर्मैट में हो.
client = BigQueryClient()
def read_session(TABLE_ID):
return client.read_session(
"projects/" + GCP_PROJECT_ID, DATASET_GCP_PROJECT_ID, TABLE_ID, DATASET_ID,
FEATURES + [LABEL], DTYPES, requested_streams=2
)
def extract_labels(input_dict):
features = dict(input_dict)
label = tf.cast(features.pop(LABEL), tf.float64)
return (features, label)
चौथा चरण: डेटा शामिल करना
आखिर में, हर डेटासेट बनाते हैं. इसके बाद, ट्रेनिंग डेटासेट से पहला बैच प्रिंट करते हैं. ध्यान दें कि हमने BATCH_SIZE को 32 पर सेट किया है. यह एक अहम पैरामीटर है, जो ट्रेनिंग की स्पीड और सटीक होने पर असर डालेगा.
BATCH_SIZE = 32
raw_train_data = read_session(TRAIN_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
raw_val_data = read_session(VAL_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
raw_test_data = read_session(TEST_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
next(iter(raw_train_data)) # Print first batch
5. मॉडल बनाना
पहला चरण: डेटा को पहले से प्रोसेस करना
आइए, डेटासेट में मौजूद हर फ़ीचर के लिए फ़ीचर कॉलम बनाएं. इस डेटासेट में, सभी कॉलम numeric_column टाइप के हैं.हालांकि, कई अन्य कॉलम टाइप भी होते हैं. जैसे, categorical_column.
जैसा कि हमने पहले बताया था, हम डेटा को ज़ीरो के आस-पास भी नॉर्मलाइज़ करेंगे, ताकि नेटवर्क तेज़ी से कन्वर्ज हो सके. हमने इस कैलकुलेशन में इस्तेमाल होने वाली हर सुविधा के लिए, पहले से ही मतलब तय कर लिए हैं.
MEANS = [94816.7387536405, 0.0011219465482001268, -0.0021445914636999603, -0.002317402958335562,
-0.002525792169927835, -0.002136576923287782, -3.7586818983702984, 8.135919975738768E-4,
-0.0015535579268265718, 0.001436137140461279, -0.0012193712736681508, -4.5364970422902533E-4,
-4.6175444671576083E-4, 9.92177789685366E-4, 0.002366229151475428, 6.710217226762278E-4,
0.0010325807119864225, 2.557260815835395E-4, -2.0804190062322664E-4, -5.057391100818653E-4,
-3.452114767842334E-6, 1.0145936326270006E-4, 3.839214074518535E-4, 2.2061197469126577E-4,
-1.5601580596677608E-4, -8.235017846415852E-4, -7.298316615408554E-4, -6.898459943652376E-5,
4.724125688297753E-5, 88.73235686453587]
def norm_data(mean, data):
data = tf.cast(data, tf.float32) * 1/(2*mean)
return tf.reshape(data, [-1, 1])
numeric_columns = []
for i, feature in enumerate(FEATURES):
num_col = tf.feature_column.numeric_column(feature, normalizer_fn=functools.partial(norm_data, MEANS[i]))
numeric_columns.append(num_col)
numeric_columns
दूसरा चरण: मॉडल बनाना
अब हम मॉडल बनाने के लिए तैयार हैं. हम अभी बनाए गए कॉलम को नेटवर्क में शामिल करेंगे. इसके बाद, हम मॉडल को कंपाइल करेंगे. हम प्रेसिज़न/रिकॉल एयूसी मेट्रिक को शामिल कर रहे हैं. यह असमान डेटासेट के लिए फ़ायदेमंद है.
model = keras.Sequential([
tf.keras.layers.DenseFeatures(numeric_columns),
layers.Dense(64, activation='relu'),
layers.Dense(64, activation='relu'),
layers.Dense(1, activation='sigmoid')
])
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy', tf.keras.metrics.AUC(curve='PR')])
तीसरा चरण: मॉडल को ट्रेन करना
असमान डेटा को मैनेज करने के लिए कई तकनीकें उपलब्ध हैं. इनमें ओवरसैंपलिंग (माइनॉरिटी क्लास में नया डेटा जनरेट करना) और अंडरसैंपलिंग (मेजोरिटी क्लास में डेटा कम करना) शामिल हैं.
इस कोडलैब के लिए, हम ऐसी तकनीक का इस्तेमाल करेंगे जो माइनॉरिटी क्लास को गलत तरीके से क्लासिफ़ाई करने पर, नुकसान को ज़्यादा अहमियत देती है. ट्रेनिंग के दौरान, हम class_weight पैरामीटर तय करेंगे और "1" (धोखाधड़ी) को ज़्यादा अहमियत देंगे, क्योंकि यह बहुत कम होता है.
इस लैब में, हम तीन इपॉक (डेटा से गुज़रने वाले पास) का इस्तेमाल करेंगे, ताकि ट्रेनिंग तेज़ी से हो सके. असल दुनिया के उदाहरण में, हम इसे तब तक चलाना चाहेंगे, जब तक कि पुष्टि करने वाले सेट की सटीकता में बढ़ोतरी न हो जाए.
CLASS_WEIGHT = {
0: 1,
1: 100
}
EPOCHS = 3
train_data = raw_train_data.shuffle(10000)
val_data = raw_val_data
test_data = raw_test_data
model.fit(train_data, validation_data=val_data, class_weight=CLASS_WEIGHT, epochs=EPOCHS)
चौथा चरण: मॉडल का आकलन करना
evaluate() फ़ंक्शन को ऐसे टेस्ट डेटा पर लागू किया जा सकता है जिसे मॉडल ने कभी नहीं देखा है, ताकि ऑब्जेक्टिव असेसमेंट किया जा सके. अच्छी बात यह है कि हमने सिर्फ़ इसके लिए टेस्ट डेटा अलग से रखा है!
model.evaluate(test_data)
पांचवां चरण: एक्सप्लोरेशन
इस लैब में, हमने यह दिखाया है कि BigQuery से सीधे तौर पर TensorFlow Keras मॉडल में बड़े डेटा सेट को कैसे शामिल किया जाता है. हमने मॉडल बनाने के सभी चरणों के बारे में भी बताया है. आखिर में, हमने यह भी जाना कि क्लासिफ़िकेशन से जुड़ी समस्याओं को कैसे हल किया जाए.
डेटासेट में मौजूद डेटा के बीच अंतर को कम करने के लिए, अलग-अलग आर्किटेक्चर और तरीकों का इस्तेमाल करें. इससे आपको यह पता चलेगा कि क्या मॉडल की परफ़ॉर्मेंस को बेहतर बनाया जा सकता है!
6. साफ़-सफ़ाई सेवा
अगर आपको इस नोटबुक का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल न करने पर इसे बंद कर दें. Cloud Console में Notebooks के यूज़र इंटरफ़ेस (यूआई) में जाकर, नोटबुक चुनें. इसके बाद, बंद करें को चुनें:
अगर आपको इस लैब में बनाए गए सभी संसाधन मिटाने हैं, तो नोटबुक इंस्टेंस को रोकने के बजाय, उसे मिटाएं.
Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, Storage पर जाएं. इसके बाद, मॉडल ऐसेट सेव करने के लिए बनाए गए दोनों बकेट मिटाएं.