अपने इमेज क्लासिफ़ायर के लिए एक कस्टम मॉडल बनाएं

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

पिछले कोडलैब में, आपने Android और iOS के लिए एक ऐप्लिकेशन बनाया था. इसमें इमेज लेबलिंग के बुनियादी मॉडल का इस्तेमाल किया गया था. यह मॉडल, इमेज की सैकड़ों क्लास को पहचानता है. इसने एक फूल की तस्वीर को सामान्य तौर पर पहचाना. इसमें पंखुड़ियां, फूल, पौधा, और आसमान दिख रहा है.

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

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

इस लर्निंग पाथ में मौजूद पिछला कोडलैब.

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

TensorFlow Lite Model Maker का इस्तेमाल करके, इमेज क्लासिफ़ायर कस्टम मॉडल को ट्रेन करने का तरीका.

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

इसके लिए किसी खास हार्डवेयर की ज़रूरत नहीं होती. ब्राउज़र में Google Colab का इस्तेमाल करके, सभी काम किए जा सकते हैं.

2. शुरू करें

साथ-साथ काम करने के लिए, सभी कोड आपके लिए तैयार किए गए हैं. इन्हें Google Colab का इस्तेमाल करके लागू किया जा सकता है. इसके लिए, यहां जाएं. अगर आपके पास Google Colab का ऐक्सेस नहीं है, तो repo को क्लोन किया जा सकता है. इसके बाद, ImageClassificationMobile->colab डायरेक्ट्री में मौजूद CustomImageClassifierModel.ipynb नाम की नोटबुक का इस्तेमाल किया जा सकता है.

अगर आपके पास किसी खास तरह के फूलों के कई उदाहरण हैं, तो TensorFlow Lite Model maker की मदद से, मॉडल को उन्हें पहचानने की ट्रेनिंग देना आपके लिए आसान होगा.

ऐसा करने का सबसे आसान तरीका यह है कि इमेज वाली .zip या .tgz फ़ाइल बनाई जाए. इसमें इमेज को डायरेक्ट्री के हिसाब से क्रम में लगाया जाता है. उदाहरण के लिए, अगर आपको डेज़ी, डैंडेलियन, गुलाब, सूरजमुखी, और ट्यूलिप की इमेज इस्तेमाल करनी हैं, तो उन्हें इस तरह की डायरेक्ट्री में व्यवस्थित किया जा सकता है:

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

इस लैब में यह मान लिया जाएगा कि मॉडल को ट्रेन करने के लिए, Google Colab का इस्तेमाल किया जा रहा है. Colab को colab.research.google.com पर ऐक्सेस किया जा सकता है. अगर किसी दूसरे एनवायरमेंट का इस्तेमाल किया जा रहा है, तो आपको कई डिपेंडेंसी इंस्टॉल करनी पड़ सकती हैं. इनमें TensorFlow भी शामिल है.

3. डिपेंडेंसी इंस्टॉल और इंपोर्ट करना

TensorFlow Lite Model Maker इंस्टॉल करें. इसके लिए, pip install का इस्तेमाल करें. आखिर में मौजूद &> /dev/null सिर्फ़ आउटपुट को छिपाता है. Model Maker, ऐसा बहुत सारा कॉन्टेंट जनरेट करता है जो तुरंत काम का नहीं होता. इसे बंद कर दिया गया है, ताकि आप अपने काम पर फ़ोकस कर सकें.

# Install Model maker
!pip install -q tflite-model-maker &> /dev/null

इसके बाद, आपको उन लाइब्रेरी को इंपोर्ट करना होगा जिनका आपको इस्तेमाल करना है. साथ ही, यह पक्का करना होगा कि TensorFlow 2.x का इस्तेमाल किया जा रहा हो:

# Imports and check that we are using TF2.x
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 image_classifier
from tflite_model_maker.image_classifier import DataLoader

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

अब एनवायरमेंट तैयार है. इसलिए, अब मॉडल बनाना शुरू करें!

4. डेटा डाउनलोड करना और उसे तैयार करना

अगर आपकी इमेज फ़ोल्डर में व्यवस्थित की गई हैं और उन फ़ोल्डर को ज़िप किया गया है, तो ज़िप फ़ाइल डाउनलोड करके उसे अनज़िप करने पर, आपको इमेज के लेबल अपने-आप मिल जाएंगे. ये लेबल, इमेज के फ़ोल्डर के हिसाब से मिलेंगे. इस डायरेक्ट्री को data_path के तौर पर रेफ़र किया जाएगा.

data_path = tf.keras.utils.get_file(
      'flower_photos',
      'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
      untar=True)

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

मशीन लर्निंग की मदद से मॉडल को ट्रेनिंग देने का एक अहम हिस्सा यह है कि ट्रेनिंग के लिए, अपने पूरे डेटा का इस्तेमाल न किया जाए. मॉडल को ऐसे डेटा के साथ टेस्ट करने के लिए, कुछ डेटा को अलग रखें जिसे मॉडल ने पहले नहीं देखा है. ImageClassifierDataLoader से मिले डेटासेट के स्प्लिट तरीके का इस्तेमाल करके, ऐसा आसानी से किया जा सकता है. इसमें 0.9 पास करने पर, आपको 90% डेटा ट्रेनिंग डेटा के तौर पर और 10% डेटा टेस्ट डेटा के तौर पर मिलेगा:

data = DataLoader.from_folder(data_path)
train_data, test_data = data.split(0.9)

डेटा तैयार हो जाने के बाद, इसका इस्तेमाल करके मॉडल बनाया जा सकता है.

5. इमेज क्लासिफ़ायर मॉडल बनाना

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

model = image_classifier.create(train_data)

इसे चलाने पर, आपको कुछ ऐसा आउटपुट दिखेगा:

Model: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
hub_keras_layer_v1v2_2 (HubK (None, 1280)              3413024
_________________________________________________________________
dropout_2 (Dropout)          (None, 1280)              0
_________________________________________________________________
dense_2 (Dense)              (None, 5)                 6405
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________
None
Epoch 1/5
103/103 [===] - 15s 129ms/step - loss: 1.1169 - accuracy: 0.6181

Epoch 2/5
103/103 [===] - 13s 126ms/step - loss: 0.6595 - accuracy: 0.8911

Epoch 3/5
103/103 [===] - 13s 127ms/step - loss: 0.6239 - accuracy: 0.9133

Epoch 4/5
103/103 [===] - 13s 128ms/step - loss: 0.5994 - accuracy: 0.9287

Epoch 5/5
103/103 [===] - 13s 126ms/step - loss: 0.5836 - accuracy: 0.9385

पहले हिस्से में, आपके मॉडल का आर्किटेक्चर दिखाया गया है. Model Maker, पर्दे के पीछे जो काम करता है उसे ट्रांसफ़र लर्निंग कहा जाता है. इसमें पहले से ट्रेन किए गए मॉडल का इस्तेमाल शुरुआती पॉइंट के तौर पर किया जाता है. साथ ही, यह मॉडल सिर्फ़ उन चीज़ों को लेता है जो उसने इमेज बनाने के बारे में सीखी हैं. इसके बाद, उन्हें इन पांच फूलों को समझने के लिए इस्तेमाल करता है. इसे पहली लाइन में देखा जा सकता है. इसमें लिखा है:

hub_keras_layer_v1v2_2 (HubK (None, 1280)              3413024

इसमें मुख्य शब्द ‘Hub' है, जिससे हमें पता चलता है कि यह मॉडल TensorFlow Hub से आया है. डिफ़ॉल्ट रूप से, TensorFlow Lite Model Maker, ‘MobileNet' नाम के मॉडल का इस्तेमाल करता है. इसे 1,000 तरह की इमेज की पहचान करने के लिए डिज़ाइन किया गया है. यहां यह लॉजिक काम करता है कि 1, 000 क्लास के बीच अंतर करने के लिए, यह जिस तरीके का इस्तेमाल करता है उसे फिर से इस्तेमाल किया जा सकता है. एक ही ‘विशेषता' को फूलों की हमारी पांच क्लास में मैप किया जा सकता है. इसलिए, उन्हें शुरू से सीखने की ज़रूरत नहीं है.

मॉडल को पांच इपॉक से गुज़ारा गया. इपॉक, ट्रेनिंग का एक पूरा साइकल होता है. इसमें न्यूरल नेटवर्क, इमेज को उनके लेबल से मैच करने की कोशिश करता है. पांच इपॉक पूरे होने तक, ट्रेनिंग डेटा पर इसकी सटीकता 93.85% थी. इसमें करीब एक मिनट लगा. पांच क्लास होने की वजह से, रैंडम अनुमान 20% सटीक होगा. इसलिए, यह एक अच्छी प्रोग्रेस है! (यह ‘लॉस' नंबर की भी जानकारी देता है, लेकिन फ़िलहाल इसे नज़रअंदाज़ किया जा सकता है.)

आपने डेटा को ट्रेनिंग और टेस्ट डेटा में बांटा था, ताकि यह पता चल सके कि नेटवर्क, ऐसे डेटा पर कैसा परफ़ॉर्म करता है जिसे उसने पहले नहीं देखा है. इससे यह बेहतर तरीके से पता चलता है कि model.evaluate का इस्तेमाल करके, असल दुनिया में नेटवर्क कैसा परफ़ॉर्म कर सकता है. इसके लिए, टेस्ट डेटा का इस्तेमाल करें:

loss, accuracy = model.evaluate(test_data)

इससे कुछ इस तरह का आउटपुट मिलेगा:

12/12 [===] - 5s 115ms/step - loss: 0.6622 - accuracy: 0.8801

यहां सटीक जानकारी दी गई है. यह 88.01% है. इसलिए, असल दुनिया में डिफ़ॉल्ट मॉडल का इस्तेमाल करने पर, इस लेवल की सटीक जानकारी मिलने की उम्मीद की जा सकती है. डिफ़ॉल्ट मॉडल को ट्रेनिंग देने में आपको सिर्फ़ एक मिनट लगा. इसलिए, यह नतीजे काफ़ी अच्छे हैं. बेशक, मॉडल को बेहतर बनाने के लिए कई बदलाव किए जा सकते हैं. यह अपने-आप में एक विज्ञान है!

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

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

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

model.export(export_dir='/mm_flowers')

अगर इसे Google Colab में चलाया जा रहा है, तो स्क्रीन पर बाईं ओर मौजूद फ़ोल्डर आइकॉन पर क्लिक करके मॉडल देखा जा सकता है:

यहां आपको मौजूदा डायरेक्ट्री की सूची दिखेगी. किसी डायरेक्ट्री को "ऊपर" ले जाने के लिए, बताए गए बटन का इस्तेमाल करें:

आपने अपने कोड में, mm_flowers डायरेक्ट्री में एक्सपोर्ट करने के लिए कहा है. इसे खोलें. आपको ‘model.tflite' नाम की एक फ़ाइल दिखेगी. यह आपका ट्रेन किया गया मॉडल है.

फ़ाइल चुनें. इसके बाद, आपको दाईं ओर तीन बिंदु दिखेंगे. कॉन्टेक्स्ट मेन्यू पाने के लिए, इन पर क्लिक करें. इसके बाद, मॉडल को डाउनलोड किया जा सकता है.

कुछ समय बाद, आपका मॉडल डाउनलोड फ़ोल्डर में डाउनलोड हो जाएगा.

7. बधाई हो

अब इसे अपने मोबाइल ऐप्लिकेशन में इंटिग्रेट किया जा सकता है! अगले लैब में आपको यह करना होगा.