โครงร่วมของทุกโปรแกรม MicroPython

โครงเดิมที่เราจับมาตั้งแต่ บทเรียน 1.4–1.5 — ชุดบทเรียนนี้ก็เดินตามสี่จังหวะนี้ แค่เนื้อในเป็น "windowing + feature"

"สร้างครั้งเดียว" ยังจริงเสมอ — แท่ง 6 อันสร้างนอกลูป ในลูปแค่เรียก .value() เปลี่ยนความสูง ถ้าสร้างแท่งใหม่ทุกหน้าต่าง จอจะกระพริบและกินหน่วยความจำ

โครงของไฟล์ s10_windowing.py

ทั้งไฟล์อ่านเป็นประโยคเดียว: "เก็บสัญญาณเข้า buffer → พอครบหน้าต่างก็บีบเป็น feature → โชว์เป็นแท่ง → เลื่อนหน้าต่าง → วนต่อ"

ตัวเลขในโค้ด (buf.append, features(...), buf = buf[-WIN:]) คือ 5 จุดที่คุณต้องเติมในไฟล์ฝึก — จำโครงนี้ไว้ เดี๋ยวไล่ทีละส่วน

ไล่โค้ด (1) — เก็บ sample เข้า buffer

ช่องเติมที่ 1: ในลูปเราอ่าน IMU ทีละจุด แล้วต่อท้าย buffer:

for _ in range(HOP):                       # เก็บทีละ HOP จุด
    ax, ay, az, gx, gy, gz = sensors.bmi270.motion()
    # เติม: เก็บ accel แกน Z (az) ต่อท้าย buffer  ->  buf.append(az)
    pass
    time.sleep_ms(DT_MS)                    # 20 ms = 50 Hz

• แทน pass ด้วย buf.append(az) — สัญญาณ (แกน Z) ไหลเข้ามาสะสมใน buf
• sensors.bmi270.motion() คืน 6 ค่า เราหยิบแค่ az มาทำสัญญาณตัวอย่าง
• ถ้าลืมเติม: buf ว่างตลอด หน้าต่างไม่มีวันครบ แท่งไม่ขยับเลย

time.sleep_ms(20) คือสิ่งที่ทำให้อัตราสุ่มเป็น 50 Hz พอดี — อัตราสุ่มต้องตรงกับที่โมเดลคาดหวัง ไม่งั้นความหมายของ "หน้าต่าง 1 วินาที" จะเพี้ยน

ไล่โค้ด (2) — mean และ std

ช่องเติมที่ 2 และ 3: หัวใจของ feature vector อยู่ในฟังก์ชัน features():

def features(win):
    n = len(win)
    # เติม: ค่าเฉลี่ยของหน้าต่าง  ->  mean = sum(win) / n
    mean = 0.0
    # เติม: ส่วนเบี่ยงเบนมาตรฐาน
    #       ->  std = math.sqrt(sum((x - mean) ** 2 for x in win) / n)
    std = 0.0

• ช่องที่ 2: แทนด้วย mean = sum(win) / n — ค่าเฉลี่ยของทั้งหน้าต่าง
• ช่องที่ 3: แทนด้วย std = math.sqrt(sum((x - mean) ** 2 for x in win) / n) — ต้องคำนวณ mean ก่อนเสมอ เพราะ std ใช้ mean
• ถ้าลืมเติม: แท่ง mean/std ค้างที่ศูนย์ ทั้งที่บอร์ดขยับ

สังเกตลำดับ: std พึ่ง mean — ถ้าสลับบรรทัด std จะใช้ mean = 0.0 ผิดทันที นี่คือกับดักที่ต้องระวัง

ไล่โค้ด (3) — band energy

ช่องเติมที่ 4: แบ่งหน้าต่างเป็น 4 ช่วงเวลา แล้ววัดพลังงาน (variance) แต่ละช่วง:

band_e = []
seg = n // BANDS
for b in range(BANDS):
    s = win[b * seg:(b + 1) * seg]         # หนึ่งช่วงเวลา
    m = sum(s) / len(s)
    # เติม: พลังงาน (variance) ของย่านนี้ ต่อท้าย band_e
    #       ->  band_e.append(sum((x - m) ** 2 for x in s) / len(s))
    pass
return [mean, std] + band_e

• แทน pass ด้วย band_e.append(sum((x - m) ** 2 for x in s) / len(s))
• แต่ละรอบวัด variance ของช่วงเวลาหนึ่ง แล้วสะสมเข้า band_e
• ถ้าลืมเติม: band_e ว่าง feature vector เหลือแค่ 2 ตัว (mean, std) แท่ง band0..3 ไม่ขยับ

นี่คือ feature "รูปร่างตามเวลา" — ถ้าเปลี่ยนจากแบ่งเวลาเป็นแบ่งความถี่ (เอา FFT จาก บทเรียน 4.3–4.4 มาจัดย่าน) ก็จะกลายเป็น spectrogram ของเสียงทันที

ไล่โค้ด (4) — เลื่อนหน้าต่าง (ให้ซ้อน)

ช่องเติมที่ 5: หลังคำนวณ feature เสร็จ ต้องเลื่อนหน้าต่างให้ซ้อนกับอันต่อไป:

if len(buf) >= WIN:
    fv = features(buf[-WIN:])              # บีบ WIN จุดท้ายเป็น feature
    ...
    for i, v in enumerate(fv):
        bars[i].value(min(100, int(abs(v) * (2 if i < 2 else 0.02))))
    # เติม: เก็บเฉพาะ WIN จุดท้ายไว้ให้หน้าต่างถัดไปซ้อน 50%  ->  buf = buf[-WIN:]
    pass

• แทน pass ด้วย buf = buf[-WIN:] — ตัด buffer ให้เหลือแค่ WIN จุดท้าย
• รอบหน้าเราจะเติมอีก HOP จุด แล้วหน้าต่างใหม่จะซ้อนกับอันเดิม 50%
• ถ้าลืมเติม: buf โตขึ้นเรื่อย ๆ ไม่มีที่สิ้นสุด → กินหน่วยความจำจนหมด (memory leak)

buf[-WIN:] เป็นสำนวน Python ที่หมายถึง "เอาแค่ WIN ตัวท้าย" — เข้าใจมันแล้วคุณคุมหน้าต่างเลื่อนได้ทั้งหมด

ไล่โค้ด (5) — แสดง feature เป็นแท่ง

ส่วนแสดงผล เอา feature vector มาสเกลให้พอเห็นแล้วตั้งค่าแท่ง (ให้ไว้แล้วในไฟล์ฝึก):

for i, v in enumerate(fv):
    scaled = min(100, int(abs(v) * (2 if i < 2 else 0.02)))
    bars[i].value(scaled)
lcd.console(" fv = [" + ", ".join("%.2f" % v for v in fv) + "]")

• mean/std ค่าน้อย (index < 2) คูณ 2 พอเห็น · band ค่าใหญ่ คูณ 0.02 กันล้นแท่ง
• abs(v) เพราะ mean ติดลบได้ แต่แท่งเริ่มที่ 0
• lcd.console(...) พิมพ์ค่าจริงเป็นข้อความ — ดูตัวเลขเป๊ะ ๆ ควบคู่กับแท่ง

การสเกลนี้เป็นแค่ "ให้เห็นด้วยตา" — ตอนป้อนโมเดลจริง เราจะ normalize อย่างเป็นระบบ (โมดูล 5 (Training)) ไม่ใช่คูณค่าคงที่แบบนี้ แต่หลักการ "ทำให้ทุก feature อยู่สเกลใกล้กัน" เหมือนกัน

ลงมือ (1) — รันบน BENTO Emulator

ไม่มีบอร์ดก็เริ่มได้เลย:

1. เปิด ide.tesaiot.dev (BENTO Emulator) ในเบราว์เซอร์
2. เปิดไฟล์ s10_windowing.py
3. กด Run — จะเห็นแท่ง feature 6 ตัว (mean/std/band0..3) + ตัวนับ windows
4. ใช้ตัวจำลอง IMU: สลับ "วางนิ่ง" กับ "เขย่า" ดูแท่ง std และ band ขยับตาม
5. สังเกต windows: เพิ่มขึ้นทุกครั้งที่บีบ feature ชุดใหม่ (ทุก HOP จุด)

Emulator ใช้ IMU จำลอง แต่ pipeline window→feature เหมือนบอร์ดจริงทุกบรรทัด — ซ้อมที่บ้านได้เต็มที่

หน้าตาจริงบน Emulator

รันแล้วจอจะขึ้นแท่ง feature ทั้ง 6 ตัว ขยับตามสัญญาณ IMU จำลองแบบเรียลไทม์

รันบน BENTO Edge AI Emulator ในเบราว์เซอร์ได้ ไม่ต้องมีบอร์ดก็เห็น feature vector ขยับสด

• แท่งซ้ายสองอันคือ mean / std (สถิติทั้งหน้าต่าง) · สี่อันถัดไปคือ band0..3 (พลังงานต่อช่วงเวลา)
• ลองสลับ "วางนิ่ง" กับ "เขย่า" ในตัวจำลอง แล้วดู std พุ่งขึ้นชัด ๆ

จอนี้คือ MVP ของชุดบทเรียนนี้ตอนรันบน emulator — 6 แท่งเดียวกันจะขึ้นเหมือนกันเมื่อ Program to Device ลงบอร์ดจริง

ลงมือ (2) — รันบนบอร์ด BENTO จริง

บนบอร์ดจริงใช้ IMU จริง:

1. เสียบบอร์ดเข้าคอมด้วยสาย USB
2. เปิด s10_windowing.py ใน BENTO IDE กด Program to Device
3. วางบอร์ดนิ่งบนโต๊ะ — ดู std ต่ำ แท่งแทบไม่ขยับ
4. เขย่าบอร์ดเบา ๆ — std พุ่งขึ้น band ที่ตรงกับจังหวะสั่นสว่างขึ้น
5. ลอง หมุน/เอียง ช้า ๆ — mean เปลี่ยน (ทิศแรงโน้มถ่วงต่อแกน Z เปลี่ยน) แต่ std ยังต่ำ

จุดที่ควรสังเกต: mean กับ std เล่าคนละเรื่อง — mean = ท่าทางคงที่ (เอียงแค่ไหน), std = การเคลื่อนไหว (สั่นแค่ไหน) นี่คือเหตุผลที่เราต้องมีหลาย feature

ลงมือทำ — เติมช่องว่างทั้ง 5 จุด

เปิด s10_windowing.py มี # เติม: วางไว้ 5 จุด:

ขั้นตอน:

1. ไล่หา # เติม: ทีละจุด แทน pass/0.0 ด้วยคำสั่งตามคำใบ้
2. กด Run (Emulator) หรือ Program to Device (บอร์ด)
3. วางนิ่งสลับเขย่า ดูแท่งขยับ ถ้าไม่ขยับ กลับมาเช็ก indent + ลำดับ mean→std

ห้าช่องนี้คือทั้ง pipeline ของ feature front-end — เติมครบเมื่อไร คุณสร้าง "สิ่งที่โมเดลเห็น" ได้ด้วยมือเอง

แหล่งเรียนรู้เพิ่มเติม

อยากเข้าใจ spectrogram / mel filterbank / feature extraction ให้ลึกขึ้น ลองดูของดีเหล่านี้:

วิดีโอ (ภาพสวย เข้าใจง่าย)

• Fourier Transform เชิงภาพ (รากของ FFT/spectrogram) — ช่อง 3Blue1Brown: https://www.youtube.com/@3blue1brown
• Spectrogram & audio feature extraction ด้วย Python — ช่อง Sentdex: https://www.youtube.com/@sentdex
• Simple audio recognition (mel spectrogram เป็น input โมเดล) — TensorFlow docs: https://www.tensorflow.org/tutorials/audio/simple_audio

ภาพ / บทความอ้างอิง

• Spectrogram — บทความ + ภาพตัวอย่าง: https://en.wikipedia.org/wiki/Spectrogram (ที่มา: Wikimedia Commons / Wikipedia, CC BY-SA)
• Mel scale & mel filterbank: https://en.wikipedia.org/wiki/Mel_scale (ที่มา: Wikipedia, CC BY-SA)
• Hann / window function: https://en.wikipedia.org/wiki/Window_function (ที่มา: Wikipedia, CC BY-SA)

วิดีโอ/ภาพภายนอกเป็นของเจ้าของต้นฉบับ ใช้เพื่อการศึกษา อ้างอิงลิงก์ต้นทาง

ชัยชนะที่เห็นได้ + MVP ของชุดบทเรียนนี้

MVP ของบทเรียน 4.5–4.6 (เกณฑ์ผ่านของชุดบทเรียน): คุณสร้าง feature vector จากสัญญาณดิบด้วยมือเอง — ตัดหน้าต่าง (window+hop) แล้วบีบเป็น mean/std/band ที่เปลี่ยนตามการเคลื่อนไหว

• ทำบน Emulator หรือ บอร์ดจริง ก็ได้ (โค้ดชุดเดียวกัน)
• อธิบายได้ว่า window/hop คืออะไร ทำไมต้องซ้อน และ std บอกอะไร

"สร้าง feature ได้" ไม่ใช่แค่ "เห็นแท่งขยับ" — คุณต้องบอกได้ว่าทำไมวางนิ่งแล้ว std ต่ำ และ feature vector นี้จะกลายเป็น dataset ของโมดูล 5 (Training) ยังไง

บันไดช่วยเหลือ — ใบ้ → เริ่มจากโครง → เฉลย → ฉบับเต็ม

ถ้าติด ให้ไต่บันไดนี้ทีละขั้น อย่าเพิ่งกระโดดไปดูเฉลย เพราะของจะเข้าหัวตอนที่คุณพยายามเองก่อน:

• ใบ้ — คำใบ้อยู่ในคอมเมนต์ # เติม: ทั้ง 5 จุดในไฟล์ฝึก + ตารางหน้าที่แล้ว บอกว่าแต่ละช่องเติมอะไร
• เริ่มจากโครง — s10_windowing.py มีโครงครบทั้งไฟล์แล้ว เหลือแค่ 5 บรรทัดให้เติม
• เฉลย — s10_windowing.py เติมครบพร้อมคอมเมนต์อธิบายทุกช่อง (อ่านให้เข้าใจ ปิดไฟล์ แล้วพิมพ์เอง)
• ฉบับเต็ม — s10_windowing_full.py ฉบับขัดเรียบร้อย เพิ่มการเน้นย่านที่แรงสุด + ตัดสิน "นิ่ง/ขยับ" จาก std + อัตราหน้าต่างต่อวินาที

ลองเขียนเองให้สุดก่อนนะ ถ้าติดจริง ๆ ค่อยเปิดเฉลยดูทีละช่อง แล้วกลับมาพิมพ์เอง — เดี๋ยวเราค่อย ๆ แกะไปด้วยกัน

เชื่อมโยงรากฐาน — วันนี้เราแตะอะไรไปบ้าง

การสร้าง feature front-end ด้วยมือ ซ่อนแนวคิด Analysis หลายชั้นที่จะใช้ต่อในโมดูล 5 (Training):

ฝั่ง DSP / Analysis

• Windowing + hop — ตัดสัญญาณต่อเนื่องเป็นหน้าต่างซ้อนกัน (หัวใจของทุก front-end)
• Feature vector — บีบ 50 จุด → 6 ตัวเลข เก็บลักษณะเด่นไว้
• std = variance — เอาแนวคิดจาก บทเรียน 3.1–3.2 มาใช้เป็น feature โดยตรง
• band energy → spectrogram — แบ่งย่าน (เวลา/ความถี่) คือแกนของ mel spectrogram

ฝั่ง MicroPython / โครงโปรแกรม

• buffer + slicing — buf.append / buf[-WIN:] คุมหน้าต่างเลื่อน
• สร้าง widget ครั้งเดียว — แท่ง 6 อันสร้างนอกลูป ในลูปแค่ .value()
• pure Python บน CM33 — feature front-end ไม่ต้องพึ่ง NPU

ทั้งหมดนี้คือ "สิ่งที่โมเดลเห็น" — ชุดบทเรียนถัดไป (บทเรียน 5.1–5.2) เราจะเก็บ feature vector พวกนี้พร้อม label กลายเป็น dataset จริงที่เอาไปฝึกโมเดลได้

ใช้จริงที่ไหน — feature front-end ในโลกจริง

pipeline window→feature ที่เราทำวันนี้ ไม่ใช่ของสมมติ ทุกโมเดล Edge AI จริงมี front-end แบบนี้ก่อนถึงตัวโมเดลเสมอ:

6 โมเดลที่เล่นตั้งแต่บทเรียน 1.1–1.3 ทุกตัวมี feature front-end แบบนี้ซ่อนอยู่ วันนี้เราแค่เปิดฝากล่องมาทำเอง

สะพานสู่ Training — dataset คือชุดของ feature vector

feature vector ที่เราสร้างวันนี้ ไม่ได้จบแค่โชว์บนจอ — มันคือ หน่วยข้อมูลของ dataset ในโมดูล 5 (Training)

• ในบทเรียน 5.1–5.2 เราจะทำแบบวันนี้ แต่ ติด label (เช่น "นิ่ง"/"เขย่า") แล้วเก็บลง CSV
• CSV นั้นคือ dataset ที่ บทเรียน 5.3–5.5 เอาไปฝึกโมเดลใน TensorFlow
• เข้าใจ feature front-end วันนี้ = เข้าใจว่า dataset มาจากไหน ไม่ใช่กล่องดำ

นี่คือเหตุผลที่คอร์สนี้จัด Analysis ไว้ ก่อน Training — คุณต้องรู้ว่า "โมเดลเห็นอะไร" ก่อนจะฝึกมันได้อย่างเข้าใจ

งานทำเอง + สรุปบทเรียน

งานทำเอง (ท้ายบทเรียน):

1. เติม s10_windowing.py ให้ครบทั้ง 5 ช่อง รันได้จริง (Emulator หรือบอร์ด)
2. วางนิ่งกับเขย่า แล้วจดค่า std ทั้งสองกรณี — ต่างกันกี่เท่า? อธิบายว่าทำไม
3. ลองเปลี่ยน HOP เป็น WIN (ไม่ซ้อน) แล้วสังเกตว่าอัตราหน้าต่าง (windows:) เปลี่ยนยังไง และเสี่ยงพลาดอะไร

ใบ้ข้อ 3 — HOP เล็กลง = ได้ feature ถี่ขึ้น (ตอบไว แต่เปลืองแรง) · HOP ใหญ่ = ห่างขึ้น (ประหยัด แต่อาจพลาดเหตุการณ์สั้น)

วันนี้เราได้: เข้าใจว่าโมเดลกิน feature vector ไม่ใช่สัญญาณดิบ · ทำ windowing + hop เอง · บีบหน้าต่างเป็น mean/std/band energy · เห็นว่ามันคือญาติของ mel spectrogram และคือ dataset ของชุดบทเรียนหน้า

ชุดบทเรียนถัดไป (บทเรียน 5.1–5.2 — Training I) เราจะเอา feature front-end นี้ไปเก็บเป็น dataset จริง พร้อม label แล้วเตรียมข้อมูลให้พร้อมฝึกโมเดล เจอกันครับ