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

iOS पर TensorFlow Lite की मदद से, फूलों की पहचान करें

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 आपके ब्रैंड की कैटगरी $\\uf339$ $\\uf33b$ $\\uf337$ है!

अगर आपका ऐप्लिकेशन बन जाता है और ठीक से काम करता है, लेकिन हर चीज़ को शार्क के तौर पर लेबल करना शुरू कर देता है, तो हो सकता है कि आप labels.txt फ़ाइल को बदलना भूल गए हों या Xcode ने आपके बदलाव को बदल दिया हो. नई लेबल फ़ाइल के कॉन्टेंट को मैन्युअल तरीके से Xcode की labels.txt फ़ाइल में चिपकाकर, इस समस्या को ठीक किया जा सकता है. पक्का करें कि आपकी नतीजा labels.txt फ़ाइल कुछ ऐसी दिख रही हो:

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 के लिए शुरू करने वाला है:

ModelDataHandler.swift

/// 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 इंटरप्रेटर बनाती है:

ModelDataHandler.swift

interpreter = try Interpreter(modelPath: modelPath, options: options)

अनुवादक की ज़िम्मेदारी, TensorFlow ग्राफ़ की मदद से, रॉ डेटा इनपुट को भेजना है. हम अनुवादक को डिस्क पर अपने मॉडल का पाथ पास करते हैं और इसके बाद अनुवादक उसे FlatBufferModel के तौर पर लोड करता है.

आखिरी लाइन में लेबल की सूची लोड होती है:

loadLabels(fileInfo: labelsFileInfo)

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

मॉडल चलाएं

runModel तरीका, दिलचस्पी का दूसरा ब्लॉक है. यह इनपुट के तौर पर CVPixelBuffer लेता है, अनुवादक को चलाता है और ऐप्लिकेशन में प्रिंट करने के लिए टेक्स्ट देता है.

ModelDataHandler.swift

try interpreter.copy(rgbData, toInputAt: 0)
// ...
try interpreter.invoke()
// ...
outputTensor = try interpreter.output(at: 0)

10. अगला चरण?

ज़्यादा जानकारी के लिए यहां कुछ लिंक दिए गए हैं:

tensorflow.org पर मौजूद सोर्स रिपॉज़िटरी के दस्तावेज़ों से TFLite के बारे में ज़्यादा जानें.
TFLite के पहले से ट्रेन किए गए कुछ मॉडल आज़माएं. इनमें स्पीच हॉटवर्ड डिटेक्टर और स्मार्ट-जवाब का ऑन-डिवाइस वर्शन शामिल है.
शुरुआत करने से जुड़े हमारे दस्तावेज़ों की मदद से, TensorFlow के बारे में ज़्यादा जानें.