1. खास जानकारी
इस लैब में, आपको Google Cloud AI Platform पर सीधे तौर पर BigQuery डेटासेट का डेटा डालना होगा. साथ ही, 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 तकनीक का इस्तेमाल करके बदला गया है. इस तकनीक से डेटा की पहचान ज़ाहिर नहीं होती है.
- रकम लेन-देन की रकम होती है.
क्वेरी चलाने के लिए, क्वेरी टेबल पर क्लिक करके, इसे और करीब से देखते हैं:
सभी कॉलम देखने के लिए * को जोड़ने के लिए, स्टेटमेंट को अपडेट करें और Run पर क्लिक करें.
SELECT * FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection` LIMIT 1000
तीसरा चरण: डेटा का विश्लेषण करना
BigQuery कई आंकड़े फ़ंक्शन उपलब्ध कराता है. आइए देखते हैं कि डेटा, टारगेट वैरिएबल Class के साथ कैसे जुड़ा है.
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 सेक्शन पर जाएं और नया इंस्टेंस पर क्लिक करें. इसके बाद, बिना जीपीयू के 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() एक हेल्पर फ़ंक्शन है, जो लेबल कॉलम को बाकी कॉलम से अलग करता है, ताकि डेटासेट बाद में extract_labels() के ज़रिए उम्मीद के मुताबिक फ़ॉर्मैट में हो.
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)
चौथा चरण: डेटा डालें
आखिर में, हर डेटासेट बनाएं और फिर ट्रेनिंग डेटासेट से पहला बैच प्रिंट करें. ध्यान दें कि हमने 32 का BATCH_SIZE तय किया है. यह एक अहम पैरामीटर है, जिससे ट्रेनिंग की स्पीड और सटीक होने पर असर पड़ता है.
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. बिल्ड मॉडल
पहला चरण: डेटा पहले से प्रोसेस करना
डेटासेट की हर सुविधा के लिए, फ़ीचर कॉलम बनाएं. इस खास डेटासेट में, सभी कॉलम num_column टाइप के हैं. हालांकि, अन्य कॉलम भी मौजूद हैं, जैसे कि CATEGORYcal_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
दूसरा चरण: मॉडल बनाना
अब हम मॉडल बनाने के लिए तैयार हैं. हम नेटवर्क में अभी-अभी बनाए गए कॉलम फ़ीड करेंगे. इसके बाद, हम मॉडल को कंपाइल करेंगे. हम प्रिसिजन/रीकॉल AUC मेट्रिक शामिल कर रहे हैं, जो असंतुलित डेटासेट के लिए फ़ायदेमंद है.
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')])
तीसरा चरण: मॉडल को ट्रेनिंग देना
असंतुलित डेटा को कई तरीकों से मैनेज किया जा सकता है. जैसे, ज़रूरत से ज़्यादा डेटा इकट्ठा करना (अल्पसंख्यक वर्ग में नया डेटा जनरेट करना) और अंडरसैंपलिंग (ज़्यादातर क्लास के डेटा को कम करना).
इस कोडलैब के लिए, एक ऐसी तकनीक का इस्तेमाल किया जाता है जो माइनरिटी क्लास को गलत कैटगरी में बांटने पर, नुकसान की भरपाई करती है. ट्रेनिंग और वज़न "1" के दौरान हम class_weight पैरामीटर तय करेंगे (धोखाधड़ी) ज़्यादा होती है, क्योंकि यह बहुत कम प्रचलित है.
हम इस लैब में तीन epoch का इस्तेमाल करेंगे, ताकि ट्रेनिंग ज़्यादा जल्दी हो सके. इस लैब में, डेटा को पास किया गया है. असल दुनिया में, हम इसे उस सीमा तक चलाना चाहेंगे जहां आने वाले समय में दिखने वाले स्टॉप से पुष्टि करने की सुविधा का ज़्यादा सटीक तरीके से इस्तेमाल किया जा सके.
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)
चरण 4: मॉडल का आकलन करना
मूल्यांकन() फ़ंक्शन का इस्तेमाल ऐसे डेटा की जांच के लिए किया जा सकता है जिसे मॉडल ने कभी भी मकसद का आकलन करने के लिए नहीं देखा है. अच्छी बात यह है कि हमने इसके लिए टेस्ट डेटा अलग रखा है!
model.evaluate(test_data)
पांचवां चरण: एक्सप्लोरेशन (विश्लेषण का तरीका)
इस लैब में, हमने BigQuery से एक बड़े डेटा सेट को सीधे TensorFlow Keras मॉडल में डालने का तरीका दिखाया. इसके अलावा, हम मॉडल बनाने के सभी चरणों को भी देख चुके हैं. आखिर में, हमने असंतुलित वर्गीकरण से जुड़ी समस्याओं के समाधान के बारे में कुछ सीखा.
असंतुलित डेटासेट को इस्तेमाल करने के अलग-अलग आर्किटेक्चर और तरीकों को बेझिझक देखें और देखें कि क्या आप इसे ज़्यादा सटीक बना सकते हैं!
6. साफ़-सफ़ाई सेवा
अगर आपको इस notebook का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल में न होने पर इसे बंद कर दें. अपने Cloud Console में Notebook के यूज़र इंटरफ़ेस (यूआई) से, नोटबुक चुनें और फिर बंद करें चुनें:
अगर आप इस लैब में बनाए गए सभी संसाधनों को मिटाना चाहते हैं, तो notebook के इंस्टेंस को रोकने के बजाय सिर्फ़ मिटाएं.
अपने Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, 'स्टोरेज' पर जाएं और अपने मॉडल ऐसेट को स्टोर करने के लिए बनाए गए दोनों बकेट मिटाएं.