Belajar Embedded Engineer - Embedded AI / TinyML

#Pendahuluan

Di episode 1 kalian mendengar tren 2026: embedded AI / TinyML adalah track tercepat di industri embedded. Kini saatnya membuktikan — dan menaklukkan tantangannya. AI di MCU terdengar mustahil: model neural network biasanya butuh gigabyte RAM, sementara MCU kalian punya ratusan kilobyte. Tapi dengan teknik yang tepat — quantization, pruning, model kecil — MCU bisa menjalankan deteksi suara, gesture, anomali getaran, dan klasifikasi sensor secara real-time.

Mengapa menjalankan AI di perangkat (edge inference) alih-alih mengirim data ke cloud? Privasi (data tidak keluar perangkat), latensi (respon instan tanpa jaringan), daya (kirim hasil kecil, bukan data mentah besar), dan biaya (tidak bayar bandwidth tiap detik). Episode ini membangun fondasi TinyML: alur kerja, quantization, memilih model, dan deployment.

#Alur Kerja TinyML: Dari Data ke Perangkat

Poin kunci: pelatihan terjadi di PC/cloud, inference di perangkat. Kalian tidak melatih di MCU — kalian melatih model besar, lalu mengecilkannya sampai muat. Perangkat hanya melakukan forward pass: membaca input, menjalankan jaringan, mengeluarkan prediksi.

#Quantization: Rahasia Utama TinyML

Model float (32-bit) terlalu besar untuk MCU. Quantization mengubah bobot model dari float 32-bit menjadi integer 8-bit:

Dampaknya dramatis: model int8 4x lebih kecil dari float, dan inference-nya lebih cepat di banyak MCU yang punya hardware int8 (misal Cortex-M dengan DSP/SIMD). Presisi yang hilang biasanya kecil — untuk klasifikasi suara atau deteksi anomali, int8 hampir tak terasa.

Ada dua jenis quantization:

• Post-training quantization — latih float, lalu konversi. Simpel, kehilangan presisi kecil.
• Quantization-aware training — latih dengan simulasi kuantisasi sejak awal. Lebih akurat, butuh pelatihan ulang.

Untuk pemula: mulai dari post-training quantization; naik ke quantization-aware training hanya jika akurasi turun terlalu jauh.

#Memilih Model yang Muat di MCU

Tidak semua model bisa masuk MCU — dan tidak semua harus. Kunci pemilihannya:

Aturan praktis: mulai dari masalah terkecil yang berguna. Deteksi kata "hai device", klasifikasi getaran motor sehat/rusak, atau deteksi orang jatuh — semua muat di MCU modern. Menurut ukuran RAM: model int8 dengan ~100K parameter (100 KB) adalah kisaran nyaman untuk MCU 256 KB RAM.

#Inference di Edge: Contoh Nyata

Deployment nyata dengan TensorFlow Lite Micro (TFLM) di board — alurnya:

1. Latih & quantize model → file .tflite.
2. Konversi ke C array (xxd -i model.tflite > model_data.c).
3. Tulis interpreter di firmware:

#include "tensorflow/lite/micro/micro_interpreter.h"
 
static const unsigned char model_data[] = { 0x08, 0x00, ... }; /* TFLM model */
 
void run_inference(const float* input) {
    tflite::MicroInterpreter interpreter(model_data, ops_resolver, arena, arena_size);
    interpreter.AllocateTensors();
 
    float* in = interpreter.input(0)->data.f;
    memcpy(in, input, INPUT_SIZE * sizeof(float));   /* isi input sensor */
    interpreter.Invoke();                             /* forward pass */
 
    float* out = interpreter.output(0)->data.f;
    int pred = argmax(out, OUTPUT_SIZE);              /* ambil kelas tertinggi */
    if (pred == WAKE_WORD) activate_device();
}

Bagian yang paling sering mengecoh: arena memory — interpreter butuh arena (tensor scratch) yang dialokasikan dari RAM statis; ukurannya bisa 10-100 KB tergantung model. Overflow arena = inference crash. Kalian menguji ukuran arena dengan menghitung output interpreter.arena_used_bytes() setelah AllocateTensors.

#Data Lebih Penting dari Model

Kebohongan terbesar pembelajaran mesin: "model yang bagus adalah segalanya". Di TinyML, data adalah segalanya:

1. Kumpulkan data dari dunia nyata — suara ruangan kalian, getaran motor kalian, bukan dataset contoh dari internet.
2. Lebih banyak variasi lebih baik — gangguan suara, posisi sensor berbeda, kondisi berbeda.
3. Label harus konsisten — data salah label = model belajar hal yang salah.
4. Augmentasi — geser, tambah noise, ubah kecepatan (untuk suara) — memberi variasi murah.

Aturan praktis umum: model kecil butuh data lebih berkualitas daripada model besar — karena tidak ada parameter "banyak" untuk menutupi data buruk.

#Common Pitfalls

1. Model terlalu besar untuk RAM — hitung arena dulu; mulai dari model kecil.
2. Data hanya dari lab — model mati di lapangan; kumpulkan data dari kondisi nyata.
3. Quantization asal-asalan — akurasi hancur; pakai quantization-aware training bila perlu.
4. Menunggu inference blocking — inference butuh waktu (ms-s); jadwalkan dengan benar, jangan blokir ISR.
5. Lupa mikrokontroller bukan GPU — ukur waktu inference dengan timer; optimasi ke target.

#Penutup

Inti yang harus dibawa pulang:

• TinyML = train di PC, infer di perangkat — model int8 yang muat di KB RAM.
• Quantization (int8) mengecilkan model 4x dan mempercepat inference — teknik inti TinyML.
• Mulai dari masalah terkecil yang berguna: wake word, klasifikasi sensor, deteksi anomali.
• Data nyata lebih berharga daripada model canggih — kumpulkan variasi dari dunia kalian.
• Ukur arena RAM dan waktu inference — resource MCU adalah batas desain, bukan keterlaluan.

Di episode 22 selanjutnya kita masuk ke matematika firmware: DSP & signal processing — filter, FFT, dan pemrosesan real-time. Kalian akan melihat bahwa AI di episode 21 berjalan di atas fondasi matematika yang sama. Sampai jumpa di episode 22!