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

TensorFlow Lite Model Maker की मदद से, स्पैम टिप्पणी का पता लगाने वाले मॉडल को ट्रेन करना

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

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

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

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

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

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

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

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

Colab का ऐक्सेस

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 का इस्तेमाल करने के लिए, TensorFlow 2.x का इस्तेमाल करना ज़रूरी है.

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

इसके बाद, Colab सर्वर से अपने डिवाइस पर डेटा डाउनलोड करें. साथ ही, 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 है.

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

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

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

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

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

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

model.export(export_dire='/mm_spam_savedmodel', export_format=[ExportFormat.LABEL, ExportFormat.VOCAB, ExportFormat.SAVED_MODEL])

/mm_spam_savedmodel के पूरे फ़ोल्डर को कंप्रेस करें और जनरेट की गई mm_spam_savedmodel.zip फ़ाइल डाउनलोड करें. इसकी ज़रूरत आपको अगले कोडलैब में पड़ेगी.

# Rename the SavedModel subfolder to a version number
!mv /mm_spam_savedmodel/saved_model /mm_spam_savedmodel/123
!zip -r mm_spam_savedmodel.zip /mm_spam_savedmodel/

9. बधाई हो

इस कोडलैब में, मॉडल बनाने और उसे एक्सपोर्ट करने के लिए Python कोड के बारे में बताया गया है. अब आपके पास SavedModel है. साथ ही, इसके आखिर में लेबल और शब्दावली है. अगले कोडलैब में, इस मॉडल का इस्तेमाल करने का तरीका बताया गया है. इससे स्पैम टिप्पणियों को कैटगरी में बांटा जा सकता है.