स्पैम टिप्पणी करने वाली मशीन लर्निंग का मॉडल बनाना

1. शुरू करने से पहले

इस कोडलैब में, आपको TensorFlow और TensorFlow Lite Model Maker का इस्तेमाल करके बनाए गए कोड की समीक्षा करनी होगी. इस कोड का इस्तेमाल, स्पैम टिप्पणी पर आधारित डेटासेट का इस्तेमाल करके मॉडल बनाने के लिए किया गया है. ओरिजनल डेटा, Kaggle पर उपलब्ध है. इसे एक ही CSV फ़ाइल में इकट्ठा किया गया है. साथ ही, इसमें मौजूद खराब टेक्स्ट, मार्कअप, दोहराए गए शब्दों वगैरह को हटाकर इसे ठीक किया गया है. इससे टेक्स्ट के बजाय मॉडल पर फ़ोकस करना आसान हो जाएगा.

यहां वह कोड दिया गया है जिसकी आपको समीक्षा करनी है. हालांकि, हमारा सुझाव है कि आप Google Colab में कोड के साथ-साथ निर्देशों का पालन करें.

ज़रूरी शर्तें

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

आपको क्या सीखने को मिलेगा

  • Google Colab का इस्तेमाल करके TensorFlow Lite Model Maker को इंस्टॉल करने का तरीका
  • क्लाउड सर्वर से अपने डिवाइस पर डेटा डाउनलोड करने का तरीका
  • डेटा लोडर का इस्तेमाल कैसे करें
  • मॉडल बनाने का तरीका

आपको किन चीज़ों की ज़रूरत होगी

2. TensorFlow Lite Model Maker इंस्टॉल करना

Colab खोलें. नोटबुक की पहली सेल में, आपके लिए TensorFlow Lite Model Maker इंस्टॉल किया जाएगा:

!pip install -q tflite-model-maker

जब यह प्रोसेस पूरी हो जाए, तब अगली सेल पर जाएं.

3. कोड इंपोर्ट करना

अगली सेल में, कई इंपोर्ट हैं जिनका इस्तेमाल नोटबुक में मौजूद कोड को करना होगा:

import numpy as np
import os
from tflite_model_maker import configs
from tflite_model_maker import ExportFormat
from tflite_model_maker import model_spec
from tflite_model_maker import text_classifier
from tflite_model_maker.text_classifier import DataLoader

import tensorflow as tf
assert tf.__version__.startswith('2')
tf.get_logger().setLevel('ERROR')

इससे यह भी पता चलेगा कि आपके सिस्टम में TensorFlow 2.x चल रहा है या नहीं. Model Maker का इस्तेमाल करने के लिए, यह ज़रूरी है.

4. डेटा डाउनलोड करें

इसके बाद, क्लाउड सर्वर से डेटा को अपने डिवाइस पर डाउनलोड करें. साथ ही, data_file को लोकल फ़ाइल पर सेट करें:

data_file = tf.keras.utils.get_file(fname='comment-spam.csv', 
  origin='https://storage.googleapis.com/laurencemoroney-blog.appspot.com/lmblog_comments.csv', 
  extract=False)

Model Maker, इस तरह की सामान्य CSV फ़ाइलों से मॉडल को ट्रेन कर सकता है. आपको बस यह बताना होगा कि किन कॉलम में टेक्स्ट और किन कॉलम में लेबल मौजूद हैं. कोडलैब में आगे बताया गया है कि ऐसा कैसे किया जाता है.

5. पहले से सीखी गई एंबेडिंग

आम तौर पर, Model Maker का इस्तेमाल करते समय, मॉडल को नए सिरे से नहीं बनाया जाता. मौजूदा मॉडल का इस्तेमाल किया जाता है. हालांकि, इन्हें अपनी ज़रूरतों के हिसाब से बनाया जा सकता है.

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

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

Model Maker में, पहले से सीखी गई कई एम्बेडिंग उपलब्ध होती हैं. इनका इस्तेमाल किया जा सकता है. हालांकि, average_word_vec का इस्तेमाल करना सबसे आसान और तेज़ है.

यहां कोड दिया गया है:

spec = model_spec.get('average_word_vec')
spec.num_words = 2000
spec.seq_len = 20
spec.wordvec_dim = 7

num_words पैरामीटर

आपको यह भी बताना होगा कि मॉडल को कितने शब्दों का इस्तेमाल करना है.

आपको लग सकता है कि "जितना ज़्यादा, उतना बेहतर" सिद्धांत सही है. हालांकि, आम तौर पर हर शब्द के इस्तेमाल की फ़्रीक्वेंसी के आधार पर, सही संख्या तय की जाती है. अगर पूरे कॉर्पस में मौजूद हर शब्द का इस्तेमाल किया जाता है, तो मॉडल उन शब्दों के बारे में सीखने और उनकी दिशा तय करने की कोशिश कर सकता है जिनका इस्तेमाल सिर्फ़ एक बार किया गया है. आपको किसी भी टेक्स्ट कॉर्पस में ऐसे कई शब्द मिलेंगे जिनका इस्तेमाल सिर्फ़ एक या दो बार किया जाता है. आम तौर पर, उन्हें अपने मॉडल में इस्तेमाल करना फ़ायदेमंद नहीं होता, क्योंकि इनसे कुल भावना पर बहुत कम असर पड़ता है. num_words पैरामीटर का इस्तेमाल करके, अपने मॉडल को शब्दों की उस संख्या के हिसाब से ट्यून किया जा सकता है जो आपको चाहिए.

यहां कम संख्या डालने पर, छोटा और तेज़ी से काम करने वाला मॉडल मिल सकता है. हालांकि, यह कम सटीक हो सकता है, क्योंकि यह कम शब्दों को पहचानता है. यहां ज़्यादा संख्या होने पर, मॉडल बड़ा और धीमा होगा. बैलेंस बनाना सबसे ज़रूरी है!

wordvec_dim पैरामीटर

wordved_dim पैरामीटर, हर शब्द के लिए वेक्टर के तौर पर इस्तेमाल किए जाने वाले डाइमेंशन की संख्या है. रिसर्च के आधार पर यह सामान्य नियम तय किया गया है कि यह शब्दों की संख्या का चौथा मूल होता है. उदाहरण के लिए, अगर 2,000 शब्दों का इस्तेमाल किया जा रहा है, तो शुरुआत में 7 का इस्तेमाल करना सही रहेगा. अगर शब्दों की संख्या में बदलाव किया जाता है, तो इसे भी बदला जा सकता है.

seq_len पैरामीटर

इनपुट वैल्यू के मामले में, मॉडल आम तौर पर बहुत सटीक होते हैं. किसी भाषा मॉडल के लिए, इसका मतलब है कि भाषा मॉडल, किसी खास लंबाई के वाक्यों को क्लासिफ़ाई कर सकता है. यह seq_len पैरामीटर या सीक्वेंस की अवधि से तय होता है.

शब्दों को संख्याओं (या टोकन) में बदलने पर, कोई वाक्य इन टोकन का क्रम बन जाता है. इसलिए, इस मामले में आपके मॉडल को 20 टोकन वाले वाक्यों को क्लासिफ़ाई करने और उनकी पहचान करने के लिए ट्रेन किया जाएगा. अगर वाक्य इससे ज़्यादा लंबा है, तो उसे छोटा कर दिया जाएगा. अगर यह छोटा है, तो इसे पैड किया जाएगा. आपको कॉर्पस में एक खास <PAD> टोकन दिखेगा, जिसका इस्तेमाल इसके लिए किया जाएगा.

6. डेटा लोडर का इस्तेमाल करना

आपने पहले CSV फ़ाइल डाउनलोड की थी. अब इस डेटा को ट्रेनिंग डेटा में बदलने के लिए, डेटा लोडर का इस्तेमाल करें. इससे मॉडल इस डेटा को पहचान पाएगा:

data = DataLoader.from_csv(
    filename=data_file,
    text_column='commenttext',
    label_column='spam',
    model_spec=spec,
    delimiter=',',
    shuffle=True,
    is_training=True)

train_data, test_data = data.split(0.9)

अगर CSV फ़ाइल को किसी एडिटर में खोला जाता है, तो आपको दिखेगा कि हर लाइन में सिर्फ़ दो वैल्यू हैं. इनके बारे में फ़ाइल की पहली लाइन में टेक्स्ट के साथ बताया गया है. आम तौर पर, इसके बाद हर एंट्री को एक कॉलम माना जाता है.

आपको दिखेगा कि पहले कॉलम के लिए डिस्क्रिप्टर commenttext है. साथ ही, हर लाइन की पहली एंट्री, टिप्पणी का टेक्स्ट है. इसी तरह, दूसरी कॉलम के लिए डिस्क्रिप्टर spam है. आपको दिखेगा कि हर लाइन की दूसरी एंट्री True या False, है. इससे यह पता चलता है कि उस टेक्स्ट को टिप्पणी वाला स्पैम माना जाता है या नहीं. अन्य प्रॉपर्टी, पहले से बनाए गए model_spec को सेट करती हैं. साथ ही, डेलिमिटर वर्ण को भी सेट करती हैं. इस मामले में, डेलिमिटर वर्ण कॉमा है, क्योंकि फ़ाइल को कॉमा लगाकर अलग किया गया है. आपको इस डेटा का इस्तेमाल मॉडल को ट्रेनिंग देने के लिए करना है. इसलिए, is_Training को True पर सेट किया गया है.

आपको मॉडल की टेस्टिंग के लिए, डेटा का कुछ हिस्सा अलग रखना होगा. डेटा को दो हिस्सों में बांटें. 90% डेटा का इस्तेमाल ट्रेनिंग के लिए करें और बाकी 10% का इस्तेमाल टेस्टिंग/आकलन के लिए करें. हम यह पक्का करना चाहते हैं कि टेस्टिंग के लिए डेटा को रैंडम तरीके से चुना जाए. साथ ही, यह डेटासेट के ‘बॉटम' 10% में शामिल न हो. इसलिए, डेटा को रैंडम बनाने के लिए, डेटा लोड करते समय shuffle=True का इस्तेमाल करें.

7. मॉडल बनाना

अगली सेल का इस्तेमाल सिर्फ़ मॉडल बनाने के लिए किया जाता है. इसमें कोड की सिर्फ़ एक लाइन होती है:

# Build the model
model = text_classifier.create(train_data, model_spec=spec, epochs=50, 
                               validation_data=test_data)

इससे Model Maker की मदद से, टेक्स्ट क्लासिफ़ायर मॉडल बनाया जाता है. इसमें आपको ट्रेनिंग के लिए इस्तेमाल किया जाने वाला डेटा (चौथे चरण में सेट अप किया गया), मॉडल की खास जानकारी (चौथे चरण में सेट अप की गई), और इपॉक की संख्या तय करनी होती है. इस मामले में, यह संख्या 50 है.

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

b94b00f0b155db3d.png

इसके बाद, यह इस बदलाव के नतीजों का आकलन करेगा. साथ ही, अनुमान को बेहतर बनाने के लिए ऑप्टिमाइज़ेशन कोड चलाएगा. इसके बाद, यह फिर से कोशिश करेगा. यह एक इपॉक है. इसलिए, epochs=50 तय करने पर, यह "लूप" 50 बार चलेगा.

85f1d21c0b64d654.png

50वें युग तक पहुंचने पर, मॉडल ज़्यादा सटीक नतीजे देगा. इस मामले में, 99% दिखाया जा रहा है!

दाईं ओर, आपको पुष्टि के सटीक होने की जानकारी देने वाले आंकड़े दिखेंगे. आम तौर पर, ये ट्रेनिंग की सटीकता से थोड़े कम होते हैं. ऐसा इसलिए, क्योंकि इनसे पता चलता है कि मॉडल, ऐसे डेटा को कैसे कैटगरी में बांटता है जिसे उसने पहले ‘नहीं देखा' है. यह उस 10% टेस्ट डेटा का इस्तेमाल करता है जिसे हमने पहले अलग रखा था.

5be7967ec70e4302.png

8. मॉडल एक्सपोर्ट करना

ट्रेनिंग पूरी होने के बाद, मॉडल को एक्सपोर्ट किया जा सकता है.

TensorFlow, मॉडल को अपने फ़ॉर्मैट में ट्रेन करता है. इसे मोबाइल ऐप्लिकेशन में इस्तेमाल करने के लिए, TFLITE फ़ॉर्मैट में बदलना होता है. Model Maker, इस प्रोसेस को आपके लिए आसान बना देता है.

मॉडल को एक्सपोर्ट करने के लिए, डायरेक्ट्री तय करें:

model.export(export_dir='/mm_spam')

उस डायरेक्ट्री में, आपको model.tflite फ़ाइल दिखेगी. डाउनलोड करें. आपको इसकी ज़रूरत अगले कोडलैब में पड़ेगी. वहां आपको इसे अपने Android ऐप्लिकेशन में जोड़ना होगा!

iOS से जुड़ी बातें

आपने अभी जो .tflite मॉडल एक्सपोर्ट किया है वह Android के लिए अच्छी तरह से काम करता है. ऐसा इसलिए, क्योंकि मॉडल के बारे में मेटाडेटा इसमें एम्बेड किया गया है. साथ ही, Android Studio उस मेटाडेटा को पढ़ सकता है.

यह मेटाडेटा बहुत ज़रूरी है, क्योंकि इसमें टोकन की एक डिक्शनरी शामिल होती है. इसमें शब्दों को मॉडल के हिसाब से दिखाया जाता है. क्या आपको याद है कि शब्दों को टोकन में बदला जाता है और फिर इन टोकन को उनके भाव के हिसाब से वेक्टर दिए जाते हैं? आपके मोबाइल ऐप्लिकेशन को इन टोकन के बारे में पता होना चाहिए. उदाहरण के लिए, अगर "dog" को 42 के तौर पर टोकन में बदला गया है और आपके उपयोगकर्ता किसी वाक्य में "dog" टाइप करते हैं, तो आपके ऐप्लिकेशन को "dog" को 42 में बदलना होगा, ताकि मॉडल इसे समझ सके. Android डेवलपर के तौर पर, आपके पास ‘TensorFlow Lite Task Library' होगी. इससे इस सुविधा का इस्तेमाल करना आसान हो जाता है. हालांकि, iOS पर आपको शब्दावली को प्रोसेस करना होगा. इसलिए, आपको इसे उपलब्ध कराना होगा. मॉडल बनाने वाला व्यक्ति, export_format पैरामीटर तय करके इसे आपके लिए एक्सपोर्ट कर सकता है. इसलिए, अपने मॉडल के लिए लेबल और शब्दावली पाने के लिए, इसका इस्तेमाल किया जा सकता है:

model.export(export_dir='/mm_spam/', 
             export_format=[ExportFormat.LABEL, ExportFormat.VOCAB])

9. बधाई हो

इस कोडलैब में, मॉडल बनाने और उसे एक्सपोर्ट करने के लिए Python कोड के बारे में बताया गया है. इसके बाद, आपके पास .tflite फ़ाइल होगी.

अगले कोडलैब में, आपको इस मॉडल का इस्तेमाल करने के लिए अपने Android ऐप्लिकेशन में बदलाव करने का तरीका बताया जाएगा. इससे स्पैम टिप्पणियों को कैटगरी में बांटना शुरू किया जा सकेगा.