TinyML: नन्हीं चिप्स पर AIमध्यमपाठ 2757 मिनट का पाठ

माइक्रोकंट्रोलर बनाम कंप्यूटर

एक माइक्रोकंट्रोलर में कुछ किलोबाइट RAM, कोई ऑपरेटिंग सिस्टम नहीं और मिलीवॉट में पावर बजट होता है। जानें कि फ्लैश, RAM और पावर कैसे तय करते हैं कि कौन सा मॉडल फिट हो सकता है।

✦ ट्यूटर से पूछें 🧪 लैब · 20 min 📝 पाठ का टेस्ट

स्पीड

पाठ वीडियो में

60 सेकंड में

माइक्रोकंट्रोलर बनाम कंप्यूटर

1/4

आसान शब्दों में

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

लैपटॉप में कई गीगाबाइट RAM, एक बड़ी डिस्क और एक ऑपरेटिंग सिस्टम होता है जो एक साथ कई प्रोग्राम चलाता है। माइक्रोकंट्रोलर बहुत छोटा होता है। चिप के हिसाब से संख्याएँ काफी बदलती हैं, इसलिए हमेशा अपने बोर्ड की डेटाशीट चेक करें। एक मोटे अंदाज़ के तौर पर:

	लैपटॉप या फ़ोन	आम माइक्रोकंट्रोलर
वर्किंग मेमोरी (RAM)	गीगाबाइट	किलोबाइट से लेकर कुछ सौ किलोबाइट (कुछ में थोड़ी ज़्यादा होती है)
प्रोग्राम और मॉडल के लिए स्टोरेज	सैकड़ों गीगाबाइट	फ़्लैश मेमोरी: कुछ दसियों किलोबाइट से लेकर कुछ मेगाबाइट
ऑपरेटिंग सिस्टम	Windows, Android, Linux, macOS	अक्सर कुछ नहीं: चिप पर सीधे एक प्रोग्राम चलता है, या एक बहुत छोटा रियल-टाइम OS
पावर	वॉट	मिलीवॉट, और स्लीप मोड में इससे भी बहुत कम
मैथ्स	तेज़ फ़्लोटिंग पॉइंट, अक्सर एक GPU	कुछ चिप्स में फ़्लोटिंग-पॉइंट यूनिट होती है, कुछ में नहीं; इंटीजर मैथ्स आमतौर पर कम रिसोर्स लेता है

नोट

शुरुआती लोगों के लिए एक मशहूर बोर्ड, क्लासिक Arduino Uno, में सिर्फ 2 KB RAM होती है। इलेक्ट्रॉनिक्स सीखने के लिए यह बहुत बढ़िया है, लेकिन ज़्यादातर ML के लिए बहुत छोटा है। TinyML बोर्ड आमतौर पर ज़्यादा क्षमता वाले चिप्स इस्तेमाल करते हैं, जैसे कि Arm Cortex-M पर आधारित चिप्स या ESP32 फ़ैमिली। अपने बोर्ड के मौजूदा स्पेसिफिकेशन्स चेक करें।

दो तरह की मेमोरी

फ़्लैश पावर बंद होने पर भी चीज़ों को सुरक्षित रखती है, एक नोटबुक की तरह। आपका प्रोग्राम और मॉडल के वेट्स (weights) यहीं स्टोर होते हैं। फ़्लैश RAM से बड़ी होती है, लेकिन यह भर जाती है।
RAM वर्किंग मेमोरी है, जैसे पढ़ाई करते समय आपकी डेस्क। इसमें इनपुट (उदाहरण के लिए पिछले एक सेकंड का ऑडियो), लेयर्स के बीच मॉडल द्वारा कैलकुलेट की गई संख्याएं (activations), और आपके प्रोग्राम के वेरिएबल्स रहते हैं। TensorFlow Lite for Microcontrollers में मॉडल के लिए इस वर्किंग एरिया को tensor arena कहा जाता है।

चार चरणों में मेमोरी बजट

1
वेट्स का साइज़
वेट्स की संख्या × प्रति वेट बाइट्स। float32 4 बाइट्स लेता है; int8 1 बाइट लेता है।
2
खाली फ़्लैश
कुल फ़्लैश में से बिना मॉडल वाले प्रोग्राम को घटाएं। वेट्स को इसमें फिट होना चाहिए।
3
वर्किंग मेमोरी
इनपुट बफ़र + tensor arena + अन्य वेरिएबल्स। इसे RAM में फिट होना चाहिए।
4
कुछ जगह खाली छोड़ें
कुछ मार्जिन रखें। लाइब्रेरीज़, स्टैक के इस्तेमाल और बाद के फ़ीचर्स के लिए भी जगह चाहिए होती है।

Python: model size at 4 bytes and 1 byte per weightpython

# How big is a model? Weights x bytes per weight.
for params in [10_000, 100_000, 1_000_000, 1_000_000_000]:
    f32_kb = params * 4 / 1024
    i8_kb = params * 1 / 1024
    print(f"{params:>13,} weights: float32 {f32_kb:>12,.0f} KB   int8 {i8_kb:>12,.0f} KB")

आखिरी लाइन पर ध्यान दें: एक अरब वेट्स वाले मॉडल को 1 बाइट प्रति वेट पर भी लगभग एक गीगाबाइट की ज़रूरत होती है। इसीलिए TinyML मॉडल्स को शुरुआत से ही छोटा डिज़ाइन किया जाता है।

कोई ऑपरेटिंग सिस्टम नहीं: क्या बदलता है

"open model.tflite" करने के लिए आमतौर पर कोई फ़ाइल सिस्टम नहीं होता। मॉडल को बाइट्स के ऐरे (array) के रूप में प्रोग्राम में ही कंपाइल किया जाता है।
मेमोरी की योजना अक्सर पहले से बना ली जाती है। कई TinyML रनटाइम प्रोग्राम चलते समय मेमोरी मांगने से बचते हैं, ताकि प्रोग्राम बीच में ही मेमोरी खत्म होने से रुक न जाए।
आप पूरे प्रोग्राम को बोर्ड पर फ़्लैश (अपलोड) करते हैं, फिर सीरियल कनेक्शन, किसी लाइट या छोटे डिस्प्ले के ज़रिए नतीजे देखते हैं।
पावर बचाने के लिए चिप अपना ज़्यादातर समय स्लीप मोड में बिताती है, और किसी टाइमर या सेंसर सिग्नल पर जागती है।

मिलीवॉट में पावर

पावर का मतलब है प्रति सेकंड एनर्जी। बैटरी में एनर्जी की एक तय मात्रा होती है, इसलिए औसत पावर जितनी कम होगी, वह उतनी ही ज़्यादा चलेगी। इसकी ट्रिक है ड्यूटी साइकिलिंग (duty cycling): ज़्यादातर समय स्लीप मोड में रहें, सेंसर पढ़ने और मॉडल चलाने के लिए थोड़ी देर के लिए जागें, फिर वापस सो जाएं। औसत पावर मुख्य रूप से इस बात से तय होती है कि चिप कितनी देर तक जागी रहती है।

असली उदाहरण

पुणे का एक छात्र एक ऐसा बैंड बनाता है जो पहचानता है कि कोई बुजुर्ग व्यक्ति गिर तो नहीं गया। पहला वर्ज़न हर समय मॉडल चलाता है और बैटरी जल्दी खत्म हो जाती है। दूसरा वर्ज़न पहले एक बहुत आसान चेक चलाता है, "क्या हलचल अचानक बदल गई?", और केवल तभी मॉडल चलाता है। मॉडल बहुत कम बार चलता है, और बैटरी काफी ज़्यादा समय तक चलती है।

सावधान रहें

शॉपिंग साइट्स पर स्पेसिफिकेशन्स गलत हो सकते हैं या अलग-अलग बोर्ड वर्ज़न के बीच गड़बड़ हो सकते हैं। किसी संख्या के आधार पर डिज़ाइन करने से पहले, अपने बोर्ड के सही पार्ट के लिए चिप बनाने वाले की डेटाशीट पढ़ें।

और देखें और पढ़ें

लैब

तीन काम करने वाले Python फ़ंक्शन्स जो आपको बताते हैं कि कोई मॉडल किसी उदाहरण बोर्ड पर फिट बैठता है या नहीं।

~20 min

समस्या

शुरुआती कोड 256 KB RAM और 1024 KB फ़्लैश वाले एक उदाहरण बोर्ड का विवरण देता है। फ़र्मवेयर पहले से ही 300 KB फ़्लैश और 60 KB RAM का इस्तेमाल कर रहा है। इन तीन फ़ंक्शन्स को पूरा करें:

model_kb(n_params, bytes_per_weight): KB में वेट्स का साइज़ (1 KB = 1024 बाइट्स)।
audio_buffer_kb(seconds, sample_rate, bytes_per_sample): ऑडियो के एक टुकड़े को रखने के लिए ज़रूरी RAM।
fits(n_params, bytes_per_weight, arena_kb): True केवल तभी जब वेट्स खाली फ़्लैश में फिट हों और arena खाली RAM में फिट हो।

इसे चलाएं और टेबल देखें। कौन से मॉडल float32 के रूप में फिट होते हैं, और कौन से केवल int8 के रूप में? फिर मीडियम मॉडल के arena में ऑडियो बफ़र जोड़ें: क्या यह अभी भी फिट होता है?

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

रन करने के लिए Ctrl + Enter दबाएं

# Memory budget for a microcontroller board.
# These sizes are an example board, not a real product. Check your own board's datasheet.
RAM_KB = 256           # working memory (SRAM)
FLASH_KB = 1024        # storage for the program and the model
PROGRAM_FLASH_KB = 300 # your firmware without the model
OTHER_RAM_KB = 60      # stack, sensor buffers, variables

def model_kb(n_params, bytes_per_weight):
    """Size of the weights in KB (1 KB = 1024 bytes)."""
    raise NotImplementedError("Multiply the number of weights by bytes per weight, then divide by 1024")

def audio_buffer_kb(seconds, sample_rate, bytes_per_sample):
    """RAM needed to hold this much audio, in KB."""
    raise NotImplementedError("samples = seconds * sample_rate; bytes = samples * bytes_per_sample")

def fits(n_params, bytes_per_weight, arena_kb):
    """True only if the weights fit in the FREE flash and the arena fits in the FREE RAM."""
    raise NotImplementedError("Free flash = FLASH_KB - PROGRAM_FLASH_KB; free RAM = RAM_KB - OTHER_RAM_KB")

models = [("small", 50_000, 20), ("medium", 250_000, 60), ("large", 1_000_000, 150)]
for name, params, arena in models:
    for bpw, kind in [(4, "float32"), (1, "int8")]:
        print(f"{name:7} {kind:8} weights {model_kb(params, bpw):8.1f} KB  fits: {fits(params, bpw, arena)}")
print("1 s of 16 kHz, 16-bit audio:", audio_buffer_kb(1, 16000, 2), "KB")

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

model_kb वेट्स को प्रति वेट बाइट्स से गुणा करता है और 1024 से भाग देता है
fits कुल मेमोरी के बजाय खाली फ़्लैश और खाली RAM का उपयोग करता है
सीखने वाला ध्यान देता है कि मीडियम मॉडल केवल int8 के रूप में ही फिट होता है
सीखने वाला चेक करता है कि क्या ऑडियो बफ़र के बाद भी RAM में जगह बचती है

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1आपके मॉडल के वेट्स फ़्लैश में आसानी से फिट हो जाते हैं, लेकिन मॉडल शुरू होते ही बोर्ड क्रैश हो जाता है। आप सबसे पहले क्या चेक करेंगे?दिखाएं

RAM। वेट्स भले ही फ़्लैश में फिट हो जाएं, लेकिन tensor arena, इनपुट बफ़र और बाकी प्रोग्राम, इन सभी को एक ही समय में RAM में फिट होना चाहिए। चेक करें कि आपके रनटाइम के अनुसार arena के असल में कितने साइज़ की ज़रूरत है, स्टैक का साइज़ कितना है, और कोई बड़ा बफ़र जैसे कि ऑडियो तो नहीं है। इनपुट साइज़ घटाएं, छोटा मॉडल इस्तेमाल करें, या दूसरी मेमोरी खाली करें।

Q2100% फ़्लैश और RAM के हिसाब से प्लान बनाना जोखिम भरा क्यों है?दिखाएं

अन्य चीज़ों को भी जगह चाहिए होती है: लाइब्रेरीज़, स्टैक, डीबग कोड और भविष्य के फ़ीचर्स। मेमोरी का कुछ इस्तेमाल सिर्फ कुछ खास पलों में दिखता है, जैसे कि किसी गहरे फ़ंक्शन कॉल के दौरान। जो बोर्ड पूरा भर चुका हो, उसमें बाद में बग्स ठीक करने की जगह नहीं बचती। एक साफ़ मार्जिन रखें और असली बोर्ड पर नापकर देखें।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

हर चीज़ के लिए बस Raspberry Pi का इस्तेमाल क्यों नहीं करते?

Raspberry Pi एक पूरा कंप्यूटर है जो Linux चलाता है। इसे प्रोग्राम करना आसान है और यह बहुत ज़्यादा शक्तिशाली है, लेकिन इसे ज़्यादा पावर चाहिए होती है और बूट होने में समय लगता है। बैटरी से चलने वाले ऐसे सेंसर के लिए जिसे महीनों चलना है, आमतौर पर माइक्रोकंट्रोलर बेहतर विकल्प होता है। मेन पावर से चलने वाले कैमरा प्रोजेक्ट के लिए, Pi आसान हो सकता है।

Tensor arena क्या है?

यह RAM का एक हिस्सा है जिसे आप मॉडल की वर्किंग मेमोरी के लिए अलग रखते हैं: इनपुट, आउटपुट और बीच की वैल्यूज़। आप अपने प्रोग्राम में इसका साइज़ चुनते हैं। बहुत छोटा हुआ तो मॉडल शुरू नहीं हो पाएगा; बहुत बड़ा हुआ तो आपके बाकी कोड के लिए जगह नहीं बचेगी। टूल्स यह बता सकते हैं कि असल में कितनी जगह इस्तेमाल हुई।

क्या मॉडल को RAM में फिट होना चाहिए या फ़्लैश में?

आमतौर पर वेट्स फ़्लैश में रहते हैं और वहीं से पढ़े जाते हैं, और केवल वर्किंग मेमोरी को ही RAM में फिट होना होता है। यह रनटाइम और चिप पर निर्भर करता है, इसलिए अपने टूल के डॉक्स चेक करें।

इंटीजर मैथ्स को प्राथमिकता क्यों दी जाती है?

कई माइक्रोकंट्रोलर फ़्लोटिंग-पॉइंट मैथ्स की तुलना में इंटीजर मैथ्स को तेज़ी से और कम एनर्जी के साथ करते हैं, और कुछ में तो फ़्लोटिंग-पॉइंट यूनिट होती ही नहीं है। कुछ चिप्स में ऐसे खास निर्देश भी होते हैं जो int8 ऑपरेशन्स को तेज़ बना देते हैं। यही एक कारण है कि TinyML में int8 मॉडल्स आम हैं।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें

माइक्रोकंट्रोलर बनाम कंप्यूटर

माइक्रोकंट्रोलर बनाम कंप्यूटर

दो तरह की मेमोरी

चार चरणों में मेमोरी बजट

वेट्स का साइज़

खाली फ़्लैश

वर्किंग मेमोरी

कुछ जगह खाली छोड़ें

कोई ऑपरेटिंग सिस्टम नहीं: क्या बदलता है

मिलीवॉट में पावर

और देखें और पढ़ें

समस्या

प्रैक्टिस लैब

आपका काम तब पूरा होगा जब

कठिन सवाल

अक्सर पूछे जाने वाले सवाल