1. परिचय
TensorFlow, एक मल्टीपर्पज़ मशीन लर्निंग फ़्रेमवर्क है. TensorFlow का इस्तेमाल, क्लाउड में मौजूद क्लस्टर में बड़े मॉडल को ट्रेनिंग देने से लेकर आपके फ़ोन जैसे एम्बेड किए गए सिस्टम पर स्थानीय तौर पर मॉडल चलाने के लिए किया जा सकता है.
यह कोडलैब, iOS डिवाइस पर इमेज पहचानने वाले मॉडल को चलाने के लिए, TensorFlow Lite का इस्तेमाल करता है.
आपको इनके बारे में जानकारी मिलेगी
- TFLite कन्वर्टर का इस्तेमाल करके अपने मॉडल को ऑप्टिमाइज़ करने का तरीका.
- TFLite अनुवादक का इस्तेमाल करके पहले से बने iOS ऐप्लिकेशन में इसे चलाने का तरीका.
आपको क्या बनाना होगा
एक सामान्य कैमरा ऐप्लिकेशन, जो फूलों की पहचान करने के लिए TensorFlow इमेज पहचान प्रोग्राम चलाता है.
ज़रूरी शर्तें
अगर यह कोडलैब अपने हार्डवेयर पर किया जा रहा है, तो कृपया पक्का करें कि आपने ये डिवाइस इंस्टॉल किए हों:
- Xcode 10 या उसके बाद का वर्शन
- CocoaPods 1.8.0 या उसके बाद का वर्शन
2. Colab का इस्तेमाल करके, फूल पहचानने वाले को ट्रेनिंग देना
इस कोडलैब में Colaboratory और Xcode इस्तेमाल किए जाएंगे.
Colab खोलें. यह TensorFlow Lite Model Maker का इस्तेमाल करके, क्लासिफ़ायर को ट्रेनिंग देता है, ताकि ट्रांसफ़र लर्निंग का इस्तेमाल करके फूलों की पहचान की जा सके. साथ ही, मोबाइल ऐप्लिकेशन में इस्तेमाल करने के लिए, TFLite मॉडल एक्सपोर्ट किया जा सके.
3. काम करने वाली डायरेक्ट्री को सेटअप करें
Git रिपॉज़िटरी का क्लोन बनाना
नीचे दिया गया कमांड, उस Git रिपॉज़िटरी का क्लोन बनाएगा जिसमें इस कोडलैब के लिए ज़रूरी फ़ाइलें हैं:
git clone https://github.com/tensorflow/examples.git
आपने अभी-अभी जो क्लोन बनाया है उसके Xcode प्रोजेक्ट रूट में cd
. यहां कोडलैब के बाकी बचे हिस्सों के लिए काम किया जा सकता है:
cd examples/lite/examples/image_classification/ios
4. iOS ऐप्लिकेशन सेट अप करना
डिपेंडेंसी इंस्टॉल करें
CocoaPods का इस्तेमाल करके, iOS ऐप्लिकेशन की डिपेंडेंसी इंस्टॉल करें. इनमें TensorFlow Lite शामिल है. इंस्टॉल करने का निर्देश मिलने के बाद, प्रोजेक्ट को Xcode में खोलने के लिए ImageClassification.xcworkspace
खोलें.
pod install --repo-update open ImageClassification.xcworkspace
5. ऐप्लिकेशन को टेस्ट करें
कैमरे का इस्तेमाल करने के लिए, ऐप्लिकेशन को किसी असली डिवाइस पर चलाना ज़रूरी है. ऐसा इसलिए, क्योंकि iOS सिम्युलेटर के पास आपके Mac के कैमरे का ऐक्सेस नहीं होता है. iOS डिवाइस बनाने के लिए, आपको Apple Developer Program में रजिस्टर करना होगा या आपके पास ऐसे डिवाइस का ऐक्सेस होना चाहिए जिसे किसी दूसरे व्यक्ति ने आपके लिए प्रावधान किया है.
अगर आप सिम्युलेटर में इस कोडलैब को चलाना चाहते हैं, तो आपको Safari से खुद सिम्युलेटर में ही पेस्टबोर्ड में इमेज कॉपी करनी होंगी. सिम्युलेटर में इमेज को प्रोसेस करने का तरीका यहां दिया गया है:
- अपनी पसंद के सिम्युलेटर टारगेट के लिए ऐप्लिकेशन बनाएं.
- iOS सिम्युलेटर में, ऐप्लिकेशन को छोटा करने के लिए Cmd+Shift+H दबाएं.
- होम स्क्रीन पर सबसे नीचे मौजूद Safari पर टैप करें और कोई इमेज खोजें.
- 'Google इमेज' के खोज नतीजों में, किसी नतीजे पर टैप करें और इमेज को दबाकर रखें. इसके बाद, पॉप-अप होने वाले डायलॉग बॉक्स में, "कॉपी करें" को चुनें.
- TFL Classify ऐप्लिकेशन पर वापस जाएं. कॉपी की गई इमेज, अनुमान के नतीजों के साथ अपने-आप दिखनी चाहिए. अगर ऐसा नहीं होता है, तो पक्का करें कि आपने इमेज का डेटा कॉपी किया है, न कि इमेज का यूआरएल.
ऐप्लिकेशन बनाएं और इंस्टॉल करें
ऐप्लिकेशन में कोई बदलाव करने से पहले, उस वर्शन को चलाएं जो डेटा स्टोर करने की जगह के साथ भेजा जाता है. सबसे ऊपर बाएं ड्रॉपडाउन मेन्यू से अपना iOS डिवाइस चुनें:
इसके बाद, अपने डिवाइस पर ऐप्लिकेशन बनाने के लिए Cmd+R दबाएं या Xcode में चलाएं बटन दबाएं. आपके डिवाइस पर इंस्टॉल होने के बाद, ऐप्लिकेशन अपने-आप लॉन्च हो जाएगा.
ऐप्लिकेशन का यह वर्शन मानक MobileNet का इस्तेमाल करता है, जिसे 1000 ImageNet श्रेणियों के लिए पहले से ट्रेन किया गया है. यह कुछ ऐसी नज़र आनी चाहिए:
6. कस्टमाइज़ किया गया ऐप्लिकेशन चलाएं
डिफ़ॉल्ट ऐप्लिकेशन सेटअप, इमेज को 1000 ImageNet क्लास में से किसी एक में कैटगरी में बांटता है. इसके लिए, स्टैंडर्ड MobileNet का इस्तेमाल किया जाता है.
अब ऐप्लिकेशन में बदलाव करते हैं, ताकि ऐप्लिकेशन, Colab में ट्रेन की गई अपनी पसंद के मुताबिक इमेज की कैटगरी के लिए, हमारे फिर से ट्रेनिंग दिए गए मॉडल का इस्तेमाल कर सके.
7. अपने मॉडल का इस्तेमाल करने के लिए, ऐप्लिकेशन को बदलें
प्रोजेक्ट में अपनी मॉडल फ़ाइलें जोड़ें
प्रोजेक्ट के मॉडल संसाधन, Xcode प्रोजेक्ट नेविगेटर में ImageClassification > Model
में मौजूद हैं. उन्हें बदलने के लिए, पहले Model
ग्रुप में मौजूद दो फ़ाइलों को मिटाएं. जब आपसे कहा जाए, तब "ट्रैश में ले जाएं" चुनें:
इसके बाद, Colab से डाउनलोड की गई model.tflite
और labels.txt
फ़ाइलों को मॉडल ग्रुप में खींचें और छोड़ें. जब कहा जाए, तब पक्का करें कि Copy items if needed
और Add to targets
, दोनों चुने गए हों.
ऐप्लिकेशन के कोड में बदलाव करना
हमारा ऐप्लिकेशन काम करे, इसके लिए हमें मॉडल लोडिंग लॉजिक के पाथ को अपडेट करना होगा, ताकि हमें उस नए मॉडल पर ले जाया जा सके जिसे हमने जोड़ा है.
ModelDataHandler.swift (Xcode नेविगेटर पाथ: ImageClassification -> ModelDataHandler -> ModelDataHandler.swift) खोलें और लाइन 36 को इसमें बदलें
// before static let modelInfo: FileInfo = (name: "mobilenet_quant_v1_224", extension: "tflite") // after static let modelInfo: FileInfo = (name: "model", extension: "tflite")
सभी बदलावों को सेव करना न भूलें.
8. कस्टमाइज़ किया गया ऐप्लिकेशन चलाएं
अपने डिवाइस पर ऐप्लिकेशन बनाने के लिए Cmd+B दबाएं या Xcode में चलाएं बटन दबाएं. ऐप्लिकेशन लॉन्च होने पर, यह कुछ ऐसा दिखना चाहिए:
स्क्रीनशॉट लेने के लिए, पावर बटन और आवाज़ तेज़ करने वाले बटन को एक साथ दबाकर रखें.
अब फूलों के लिए वेब खोज आज़माएं, कैमरे को कंप्यूटर स्क्रीन की ओर लाएं, और देखें कि क्या उन तस्वीरों को सही कैटगरी में रखा गया है.
इसके अलावा, अपने किसी दोस्त से भी अपनी फ़ोटो खींचकर यह जानने के लिए कहें कि TensorFlower आपके ब्रैंड की कैटगरी है!
9. यह कैसे काम करता है?
अब जब आपका ऐप्लिकेशन चल रहा है, तो आइए TensorFlow Lite के खास कोड पर नज़र डालते हैं.
TensorFlowLiteSwift
यह ऐप्लिकेशन, CocoaPods की मदद से TensorFlowLite Swift लाइब्रेरी का इस्तेमाल करता है. Swift लाइब्रेरी, TFLite C API के ऊपर एक थिन रैपर है. यह TFLite C++ लाइब्रेरी का रैपर है.
मॉड्यूल की Podfile फ़ाइल में नीचे दी गई लाइनें, प्रोजेक्ट में पॉड ग्लोबल CocoaPods की खास जानकारी वाले रिपॉज़िटरी के सबसे नए वर्शन को शामिल करती हैं.
target 'ImageClassification' do
use_frameworks!
# Pods for ImageClassification
pod 'TensorFlowLiteSwift'
end
TensorFlow Lite Swift API का इस्तेमाल करना
TensorFlow Lite के साथ इंटरैक्ट करने वाले सभी कोड ModelDataHandler.swift में हैं.
सेटअप
रुचि का पहला ब्लॉक ModelDataHandler
के लिए शुरू करने वाला है:
/// A failable initializer for `ModelDataHandler`. A new instance is created if the model and
/// labels files are successfully loaded from the app's main bundle. Default `threadCount` is 1.
init?(modelFileInfo: FileInfo, labelsFileInfo: FileInfo, threadCount: Int = 1) {
let modelFilename = modelFileInfo.name
// Construct the path to the model file.
guard let modelPath = Bundle.main.path(
forResource: modelFilename,
ofType: modelFileInfo.extension
) else {
print("Failed to load the model file with name: \(modelFilename).")
return nil
}
// Specify the options for the `Interpreter`.
self.threadCount = threadCount
var options = InterpreterOptions()
options.threadCount = threadCount
do {
// Create the `Interpreter`.
interpreter = try Interpreter(modelPath: modelPath, options: options)
// Allocate memory for the model's input `Tensor`s.
try interpreter.allocateTensors()
} catch let error {
print("Failed to create the interpreter with error: \(error.localizedDescription)")
return nil
}
// Load the classes listed in the labels file.
loadLabels(fileInfo: labelsFileInfo)
}
यहां कुछ लाइनें हैं जिनके बारे में ज़्यादा विस्तार से चर्चा की जानी चाहिए.
नीचे दी गई लाइन, TFLite इंटरप्रेटर बनाती है:
interpreter = try Interpreter(modelPath: modelPath, options: options)
अनुवादक की ज़िम्मेदारी, TensorFlow ग्राफ़ की मदद से, रॉ डेटा इनपुट को भेजना है. हम अनुवादक को डिस्क पर अपने मॉडल का पाथ पास करते हैं और इसके बाद अनुवादक उसे FlatBufferModel के तौर पर लोड करता है.
आखिरी लाइन में लेबल की सूची लोड होती है:
loadLabels(fileInfo: labelsFileInfo)
यह सब कुछ टेक्स्ट फ़ाइल से स्ट्रिंग को मेमोरी में लोड करने के लिए किया जाता है.
मॉडल चलाएं
runModel
तरीका, दिलचस्पी का दूसरा ब्लॉक है. यह इनपुट के तौर पर CVPixelBuffer
लेता है, अनुवादक को चलाता है और ऐप्लिकेशन में प्रिंट करने के लिए टेक्स्ट देता है.
try interpreter.copy(rgbData, toInputAt: 0)
// ...
try interpreter.invoke()
// ...
outputTensor = try interpreter.output(at: 0)
10. अगला चरण?
ज़्यादा जानकारी के लिए यहां कुछ लिंक दिए गए हैं:
- tensorflow.org पर मौजूद सोर्स रिपॉज़िटरी के दस्तावेज़ों से TFLite के बारे में ज़्यादा जानें.
- TFLite के पहले से ट्रेन किए गए कुछ मॉडल आज़माएं. इनमें स्पीच हॉटवर्ड डिटेक्टर और स्मार्ट-जवाब का ऑन-डिवाइस वर्शन शामिल है.
- शुरुआत करने से जुड़े हमारे दस्तावेज़ों की मदद से, TensorFlow के बारे में ज़्यादा जानें.