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

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

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

मॉडल बनाने और उसे बदलने के शुरू से अंत तक चलाए जा सकने वाले उदाहरण के लिए, नमस्ते दुनिया का उदाहरण देखें.

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

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

सबसे छोटे मॉडल साइज़ को पाने के लिए, आपको ट्रेनिंग के बाद संख्या बढ़ाने की सुविधा का इस्तेमाल करना चाहिए.

C अरे में बदलें

कई माइक्रोकंट्रोलर प्लैटफ़ॉर्म में मूल फ़ाइल सिस्टम का समर्थन नहीं होता. अपने प्रोग्राम से किसी मॉडल को इस्तेमाल करने का सबसे आसान तरीका है कि उसे सी कैटगरी के तौर पर शामिल करें और अपने प्रोग्राम में कंपाइल करें.

यह यूनिक्स कमांड एक सी सोर्स फ़ाइल जनरेट करेगा, जिसमें TensorFlow Lite मॉडल, 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_test.cc देखें.

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

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

मॉडल का आकार

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

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

वर्कलोड

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

ऑपरेशन सपोर्ट

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

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