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

एक छोटा मॉडल ट्रेन करना

हर विंडो को कुछ काम के नंबरों में बदलें, जैसे कि mean और energy, और एक छोटा क्लासिफायर ट्रेन करें। फिर held-out डेटा पर ईमानदारी से उसकी जांच करें।

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

स्पीड

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

60 सेकंड में

एक छोटा मॉडल ट्रेन करना

1/4

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

डॉक्टर को यह जांचने के लिए आपका पूरा वीडियो देखने की ज़रूरत नहीं होती कि आपको बुखार है या नहीं। बस एक नंबर—आपका तापमान—ही बहुत कुछ बता देता है। Features भी ऐसे ही होते हैं: कुछ चुनिंदा नंबर जो सेंसर डेटा के पूरे एक सेकंड का निचोड़ दे देते हैं, ताकि एक छोटा मॉडल तेज़ी से फ़ैसला ले सके।

3 axes पर 50 रीडिंग्स की एक विंडो का मतलब है 150 नंबर। एक छोटी चिप इन सभी का इस्तेमाल कर सकती है, लेकिन छोटे इनपुट का मतलब है एक छोटा और तेज़ मॉडल। इसलिए हम अक्सर पहले हर विंडो के लिए कुछ features निकालते हैं।

दो आसान और असरदार features

Feature	इसे कैसे निकालें	यह क्या बताता है
Mean (हर axis का)	विंडो की रीडिंग्स का औसत (average)	गुरुत्वाकर्षण किस तरफ है, यानी डिवाइस कैसे झुका हुआ है या रखा है
Energy (हर axis की)	(reading − mean)² का औसत, जिसे variance भी कहते हैं	डिवाइस कितना हिल-डुल रहा है या कांप रहा है
अन्य चीजें जो आप जोड़ सकते हैं	Minimum, maximum, प्रति सेकंड peaks, frequency features	किसी रिदम की स्पीड, झटके से लगी चोटें (sharp hits), कदम

Python: mean and energy for a still window and a walking windowpython

import numpy as np

rng = np.random.default_rng(1)
t = np.arange(50) / 50
still = np.column_stack([rng.normal(0, 0.02, 50), rng.normal(0, 0.02, 50), 1 + rng.normal(0, 0.02, 50)])
walk = still.copy()
walk[:, 2] += 0.3 * np.sin(2 * np.pi * 1.8 * t)

def features(window):
    mean = window.mean(axis=0)                     # where gravity points
    energy = ((window - mean) ** 2).mean(axis=0)   # how much it moves
    return np.concatenate([mean, energy])

np.set_printoptions(precision=4, suppress=True)
print("still:  ", features(still))
print("walking:", features(walk))

Means लगभग एक जैसे हैं, क्योंकि दोनों विंडो में gravity z पर है। z की energy बहुत अलग है, क्योंकि चलने पर ऊपर-नीचे हलचल होती है। कोई भी एक नंबर अकेले हर क्लास को अलग नहीं कर सकता, लेकिन दोनों मिलकर अक्सर ऐसा कर लेते हैं।

एक छोटा क्लासिफायर चुनना

मॉडल	यह एक छोटी चिप के लिए क्यों सही है	इन बातों का ध्यान रखें
डिसिजन ट्री (कम depth वाला)	सिर्फ़ कुछ तुलनाएं; पढ़ने और C में लिखने में आसान	ज़्यादा गहरे (deep) ट्री ओवरफ़िट हो जाते हैं
लॉजिस्टिक्स रिग्रेशन (Logistic regression)	प्रति क्लास प्रति फीचर एक वेट (weight); बहुत छोटा	सिर्फ़ सीधी बाउंड्री बनाता है
छोटा न्यूरल नेटवर्क	ज़्यादा जटिल पैटर्न सीखता है; TinyML runtimes द्वारा अच्छी तरह सपोर्ट किया जाता है	ज़्यादा डेटा और सावधानी की ज़रूरत होती है

इस ट्रैक में हम इन विचारों के लिए Python में scikit-learn का इस्तेमाल करते हैं। कई TinyML टूल्स दूसरी लाइब्रेरीज़ के साथ छोटे न्यूरल नेटवर्क ट्रेन करते हैं और फिर उन्हें चिप के लिए कन्वर्ट करते हैं। स्टेप्स वही रहते हैं: features इनपुट करें, लेबल्स आउटपुट पाएं, और held-out डेटा पर टेस्ट करें।

ईमानदार टेस्टिंग

1
ट्रेनिंग से पहले डेटा बांटें
दूसरे लोगों या सेशन्स का एक टेस्ट सेट अलग रखें, और ट्यूनिंग करते समय उसे बिल्कुल न देखें।
2
ट्रेनिंग सेट पर ट्रेन करें
सिर्फ़ ट्रेनिंग डेटा (या अलग वैलिडेशन सेट) का इस्तेमाल करके मॉडल को फ़िट करें और सेटिंग्स चुनें।
3
एक बार टेस्ट करें
अलग रखे गए (held-out) टेस्ट सेट पर एक्यूरेसी मापें।
4
Confusion matrix को समझें
देखें कि कौन-सी क्लासेस आपस में गड़बड़ा रही हैं। इससे पता चलता है कि कौन-सा डेटा या features जोड़ने की ज़रूरत है।

नोट

लैब्स में साफ़-सुथरे, बनावटी डेटा का इस्तेमाल होता है, इसलिए स्कोर बहुत ज़्यादा आते हैं। असली लोगों का असली डेटा ज़्यादा उलझा हुआ (messy) होता है। अगर कोई मॉडल आपके पहले ही रियल टेस्ट में लगभग परफेक्ट स्कोर लाता है, तो यह जश्न मनाने की नहीं, बल्कि ट्रेनिंग और टेस्ट डेटा के बीच लीक चेक करने की वजह है।

सावधान रहें

सिर्फ़ एक्यूरेसी ही कमियों को छिपा सकती है। अगर 95% विंडो "still" (स्थिर) हैं, तो जो मॉडल हमेशा "still" ही बताता है, उसे 95% स्कोर मिल जाएगा पर वह बिल्कुल बेकार होगा। हर क्लास को देखें, और उन गलतियों पर ध्यान दें जो आपके इस्तेमाल के लिए मायने रखती हैं।

असली उदाहरण

कोयंबटूर में एक कॉलेज टीम एक ऐसा बैंड बनाती है जो काम के चक्र गिनने के लिए बुनकर के हाथों की हलचल और आराम के बीच फ़र्क बताता है। पहला मॉडल उनकी अपनी रिकॉर्डिंग्स पर बहुत अच्छी एक्यूरेसी दिखाता है। लेकिन नए बुनकरों पर यह अक्सर फेल हो जाता है। इसका समाधान कोई बड़ा मॉडल नहीं था: उन्होंने और लोगों का डेटा रिकॉर्ड किया और हलचल की रिदम के लिए एक फीचर जोड़ा।

इसे आज़माएं। लैब में, पहले सिर्फ़ mean को ही फीचर के तौर पर इस्तेमाल करें। Confusion matrix में कौन-सी क्लासेस आपस में गड़बड़ा रही हैं? फिर energy जोड़ें और तुलना करें।

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

scikit-learn: decision treesscikit-learn · reading

लैब

एक ऐसा feature फ़ंक्शन जिससे एक छोटा डिसिजन ट्री held-out डेटा पर 90% या उससे ज़्यादा हासिल कर सके।

~25 min

समस्या

स्टार्टर कोड चार क्लासेस के लिए एक्सेलरोमीटर की बनावटी विंडो बनाता है: flat, tilted, walking और shaking। ट्रेनिंग और टेस्ट डेटा अलग-अलग random seeds से आते हैं, इसलिए टेस्ट विंडो नई हैं।

features(window) लिखें। यह (50, 3) शेप की एक विंडो लेता है और नंबरों की एक छोटी लिस्ट (2 से 12 के बीच) लौटाता है।
पहले सिर्फ़ हर axis के mean से शुरुआत करें। इसे चलाएं और confusion matrix को पढ़ें। कौन-सी क्लासेस आपस में गड़बड़ा रही हैं?
हर axis की energy जोड़ें: (reading − mean)² का mean। इसे फिर से चलाएं।
90% या उससे ज़्यादा held-out एक्यूरेसी का लक्ष्य रखें। हर feature क्या नया जोड़ता है, इस पर एक वाक्य लिखें।

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

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

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

import numpy as np

CLASSES = ["flat", "tilted", "walking", "shaking"]
RATE = 50      # samples per second
SIZE = 50      # one window = 1 second

def make_window(label, rng):
    t = np.arange(SIZE) / RATE
    w = rng.normal(0, 0.02, (SIZE, 3))          # small sensor noise
    if label == "flat":
        w[:, 2] += 1.0                           # gravity on z
    elif label == "tilted":
        w[:, 0] += 0.7; w[:, 2] += 0.7           # gravity split between x and z
    elif label == "walking":
        f = rng.uniform(1.6, 2.2)                # steps per second
        p = rng.uniform(0, 2 * np.pi)
        w[:, 2] += 1.0 + 0.3 * np.sin(2 * np.pi * f * t + p)
        w[:, 0] += 0.1 * np.sin(np.pi * f * t + p)
    else:  # shaking
        f = rng.uniform(5, 7)
        p = rng.uniform(0, 2 * np.pi)
        w[:, 2] += 1.0
        w[:, :] += rng.uniform(0.6, 1.0) * np.sin(2 * np.pi * f * t + p)[:, None] * rng.uniform(0.5, 1, 3)
    return w

def make_dataset(n_per_class, seed):
    rng = np.random.default_rng(seed)
    X, y = [], []
    for label in CLASSES:
        for _ in range(n_per_class):
            X.append(make_window(label, rng)); y.append(label)
    return np.array(X), np.array(y)

def features(window):
    """Turn one window (50 x 3) into a short list of numbers.
    Ideas: the mean of each axis (which way gravity points),
    and the energy of each axis (how much it moves around its mean)."""
    raise NotImplementedError("Return, for example, 3 means + 3 energies")

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, confusion_matrix

X_train, y_train = make_dataset(40, seed=1)   # data to learn from
X_test, y_test = make_dataset(40, seed=2)     # held-out data, never used for training

F_train = np.array([features(w) for w in X_train])
F_test = np.array([features(w) for w in X_test])
print("features per window:", F_train.shape[1])

model = DecisionTreeClassifier(max_depth=4, random_state=0)
model.fit(F_train, y_train)
pred = model.predict(F_test)
print("held-out accuracy:", round(accuracy_score(y_test, pred), 3))
print(confusion_matrix(y_test, pred, labels=CLASSES))

आउटपुट

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

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

features एक विंडो के लिए नंबरों की एक छोटी लिस्ट लौटाता है
सिर्फ़ mean वाला वर्ज़न उन क्लासेस को आपस में मिला देता है जिनका झुकाव (tilt) एक जैसा होता है
Energy जोड़ने से स्थिर (still) क्लासेस और हिलने-डुलने वाली क्लासेस अलग हो जाती हैं
नए डेटा पर held-out एक्यूरेसी 90% या उससे ज़्यादा है

कठिन सवाल

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

Q1सिर्फ़ mean वाला मॉडल "flat" को "walking" और "shaking" के साथ गड़बड़ा देता है। ऐसा क्यों होता है, और energy इसे कैसे ठीक करती है?दिखाएं

तीनों में ग्रेविटी मुख्य रूप से z axis पर होती है, इसलिए उनकी औसत रीडिंग्स एक जैसी होती हैं। जो चीज़ अलग है, वह है हलचल: flat में शायद ही कोई बदलाव होता है, walking में ऊपर-नीचे गति होती है, shaking में सभी axes पर बहुत ज़्यादा हलचल होती है। Energy यह मापती है कि रीडिंग्स अपने mean के इर्द-गिर्द कितनी बदलती हैं, इसलिए यह उन्हें अलग कर देती है। flat और tilted में फ़र्क बताने के लिए mean अब भी ज़रूरी है।

Q2आपके features Python में काम करते हैं, लेकिन बोर्ड पर मॉडल हर चीज़ के लिए "shaking" का ही अनुमान लगाता है। आप क्या चेक करेंगे?दिखाएं

एक ही रिकॉर्ड की गई विंडो के लिए बोर्ड और Python में feature नंबरों की तुलना करें। आम वजहें: अलग यूनिट (g के बजाय raw सेंसर काउंट्स), अलग axis क्रम, अलग विंडो लंबाई या सैंपलिंग रेट, या स्केलिंग का कोई छूटा हुआ स्टेप। मॉडल को बिल्कुल उसी तरह के नंबर मिलने चाहिए जिन पर उसे ट्रेन किया गया था।

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

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

कच्ची (raw) विंडो को सीधे न्यूरल नेटवर्क में क्यों नहीं डाल देते?

आप ऐसा कर सकते हैं, और कई TinyML प्रोजेक्ट्स ऐसा करते भी हैं, खासकर छोटे convolutional networks के साथ। लेकिन इसके लिए ज़्यादा डेटा और बड़े मॉडल की ज़रूरत होती है। Features एक अच्छा पहला कदम हैं: छोटे, तेज़ और समझने में आसान। पहले features आज़माएं, फिर तुलना करें।

क्या मुझे चिप पर features निकालने चाहिए?

हाँ, बोर्ड पर भी ठीक उसी तरह वही features निकाले जाने चाहिए जैसे ट्रेनिंग में निकाले गए थे। अगर आपका Python कोड और आपका C कोड "energy" को अलग-अलग तरीके से निकालते हैं, तो मॉडल को ऐसे इनपुट्स मिलेंगे जो उसने कभी देखे ही नहीं थे। दोनों को एक ही विंडो पर टेस्ट करें और नंबरों की तुलना करें।

Confusion matrix क्या होता है?

एक टेबल जिसमें हर पंक्ति (row) में असली क्लास और हर कॉलम में अनुमानित (predicted) क्लास होती है। विकर्ण (diagonal) पर मौजूद नंबर सही होते हैं; बाकी सब दिखाते हैं कि किस क्लास को गलती से क्या समझ लिया गया।

मुझे कैसे पता चलेगा कि मेरा मॉडल ओवरफ़िट हो रहा है?

अगर ट्रेनिंग एक्यूरेसी held-out एक्यूरेसी से बहुत ज़्यादा है, तो मॉडल ने ट्रेनिंग डेटा की ऐसी बारीकियाँ सीख ली हैं जो नए डेटा पर काम नहीं करतीं। एक छोटा मॉडल इस्तेमाल करें (उदाहरण के लिए कम depth वाला ट्री), ज़्यादा विविध डेटा लें या कम features का इस्तेमाल करें।

पाठ का टेस्ट

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

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

एक छोटा मॉडल ट्रेन करना

एक छोटा मॉडल ट्रेन करना

दो आसान और असरदार features

एक छोटा क्लासिफायर चुनना

ईमानदार टेस्टिंग

ट्रेनिंग से पहले डेटा बांटें

ट्रेनिंग सेट पर ट्रेन करें

एक बार टेस्ट करें

Confusion matrix को समझें

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

समस्या

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

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

कठिन सवाल

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