मॉडल बनाएं और उन्हें बदलें

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

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

मॉडल बनाने और उसे बदलने के पूरे प्रोसेस का उदाहरण देखने के लिए, Hello World उदाहरण देखें.

मॉडल कन्वर्ज़न

ट्रेन किए गए TensorFlow मॉडल को माइक्रोकंट्रोलर पर चलाने के लिए, आपको LiteRT converter Python API का इस्तेमाल करना चाहिए. इससे मॉडल, FlatBuffer में बदल जाएगा. साथ ही, मॉडल का साइज़ कम हो जाएगा और LiteRT ऑपरेशंस का इस्तेमाल करने के लिए इसमें बदलाव किया जाएगा.

मॉडल का साइज़ कम करने के लिए, आपको पोस्ट-ट्रेनिंग क्वांटाइज़ेशन का इस्तेमाल करना चाहिए.

C ऐरे में बदलना

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

नीचे दिया गया यूनिक्स कमांड, एक सी सोर्स फ़ाइल जनरेट करेगा. इसमें LiteRT मॉडल को char ऐरे के तौर पर शामिल किया जाएगा:

xxd -i converted_model.tflite > model_data.cc

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

unsigned char converted_model_tflite[] = {
  0x18, 0x00, 0x00, 0x00, 0x54, 0x46, 0x4c, 0x33, 0x00, 0x00, 0x0e, 0x00,
  // <Lines omitted>
};
unsigned int converted_model_tflite_len = 18200;

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

अपने प्रोग्राम में मॉडल को शामिल करने और उसका इस्तेमाल करने के तरीके का उदाहरण देखने के लिए, Hello World उदाहरण में hello_world_test.cc देखें.

मॉडल का आर्किटेक्चर और ट्रेनिंग

माइक्रोकंट्रोलर पर इस्तेमाल करने के लिए मॉडल डिज़ाइन करते समय, मॉडल के साइज़, वर्कलोड, और इस्तेमाल की जाने वाली कार्रवाइयों के बारे में ध्यान रखना ज़रूरी है.

मॉडल का साइज़

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

छोटा मॉडल बनाने के लिए, अपने आर्किटेक्चर में कम और छोटी लेयर इस्तेमाल की जा सकती हैं. हालांकि, छोटे मॉडल में अंडरफ़िटिंग की समस्या होने की संभावना ज़्यादा होती है. इसका मतलब है कि कई समस्याओं के लिए, सबसे बड़े मॉडल का इस्तेमाल करना सही होता है. हालांकि, यह मॉडल मेमोरी में फ़िट होना चाहिए. हालांकि, बड़े मॉडल का इस्तेमाल करने से, प्रोसेसर पर काम का बोझ भी बढ़ जाएगा.

वर्कलोड

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

कार्रवाई से जुड़ी सहायता

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

फ़ाइल में, इस्तेमाल की जा सकने वाली कार्रवाइयां देखी जा सकती हैं micro_mutable_ops_resolver.h