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

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

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

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

यह कोडलैब, मॉडल बनाने के तरीके से जुड़ी खास जानकारी नहीं देता है. इसके बजाय, आपको TensorFlow Lite Model Maker में मौजूद उन एपीआई के बारे में बताया जाएगा जो इस काम को आसान बनाते हैं.

अगर आपको कस्टम विज़न मॉडल बनाने की बुनियादी जानकारी चाहिए, तो "मशीन लर्निंग फ़ाउंडेशन" सीरीज़ देखें YouTube पर.

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

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

आपको क्या बनाना और सीखना होगा

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

आपको इनकी ज़रूरत होगी

• किसी खास हार्डवेयर की ज़रूरत नहीं है – ब्राउज़र में Google Colab का इस्तेमाल करके, सब कुछ पूरा किया जा सकता है.

2. शुरू करें

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

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

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

उसे ज़िप करें और सर्वर पर होस्ट करें और आप उसके साथ मॉडल को प्रशिक्षण दे सकेंगे. आप उस लैब का इस्तेमाल करेंगे जिसे इस लैब के बाकी बचे हिस्सों में आपके लिए तैयार किया गया है.

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

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

1. TensorFlow Lite Model Maker इंस्टॉल करें. पिप इंस्टॉल की मदद से ऐसा किया जा सकता है. &> /dev/null at the end just suppresses the output. Model Maker बहुत सी ऐसी सामग्री का आउटपुट देता है जो तुरंत प्रासंगिक नहीं है. इस वजह से, अब टास्क पर फ़ोकस नहीं किया जा सकता.

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

2. इसके बाद, आपको उन लाइब्रेरी को इंपोर्ट करना होगा जिनका इस्तेमाल आपको करना है. साथ ही, यह पक्का करें कि 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

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

hub_keras_layer_v1v2_2 (HubK (None, 1280)              3413024

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

TensorFlow हब के बारे में ज़्यादा जानने के लिए tfhub.dev पर जाएं

ट्रांसफ़र लर्निंग की प्रोसेस के बारे में ज़्यादा जानने के लिए, यहां जाएं: https://www.tensorflow.org/js/tutorials/transfer/what_is_transfer_learning

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

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

loss, accuracy = model.evaluate(test_data)

इसका आउटपुट कुछ ऐसा होगा:

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

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

अगर आपको इसके अलावा, मॉडल बनाने के अपने हुनर को भी बेहतर बनाना है, तो coursera पर https://www.coursera.org/professional-certificates/tensorflow-in-practice पर मौजूद TensorFlow प्रोफ़ेशनल डेवलपर सर्टिफ़िकेट कोर्स देखें या "कोडर के लिए एआई और मशीन लर्निंग" की किताबें देखें लॉरेंस मोरोनी या "स्किट-लर्न, Keras, और TensorFlow के साथ हैंड्स-ऑन मशीन लर्निंग" ऑरेलियन गेरॉन की ओर से.

6. मॉडल निर्यात करें

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

कोड यहाँ है:

model.export(export_dir='/mm_flowers')

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

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

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

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

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

7. बधाई हो

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