Why TinyML Dominates Project Reviews
Most computer science and electronics student projects that claim to use "AI" simply upload camera frames to an external API (like OpenAI or AWS) over Wi-Fi, waiting 2 seconds for a JSON response.
College review committees in autonomous universities and VTU routinely penalize this approach: it fails immediately when the college campus Wi-Fi drops, it requires paid third-party cloud credits, and it demonstrates zero hardware-level engineering.
TinyML (Tiny Machine Learning) takes the opposite approach: you compress and compile the neural network model directly into C++ arrays flashed onto the microcontroller’s flash memory. When powered on with a battery, the chip classifies sensor patterns or camera frames in under 80 milliseconds completely offline.
The 4-Stage Edge AI Pipeline
Building a verified TinyML prototype requires a strict engineering pipeline:
1. Data Acquisition: Logging raw accelerometer, microphone, or image data with labeled classes (e.g. Healthy Motor vs. Bearing Fault).
2. Feature Extraction (DSP): Converting time-series raw data into frequency domain spectograms (MFE/MFCC) or normalized pixel arrays to reduce input dimensionality.
3. Model Training & Validation: Training a lightweight Convolutional Neural Network (CNN) or Dense network in Python / Edge Impulse Studio.
4. Model Quantization & Compilation: Converting 32-bit floating-point weights into 8-bit integers (INT8) using TensorFlow Lite for Microcontrollers (TFLM).
Real-World Dataset Collection on Microcontrollers
The quality of your college capstone depends entirely on your dataset. Never use clean synthetic datasets downloaded from Kaggle—examiners easily detect them. Instead, collect at least 300 to 500 samples directly using the target sensor connected to your prototype.
For example, in an industrial motor predictive maintenance project, log 3-axis vibration data from an ADXL345 at 200 Hz while the motor runs normally, with an off-center weight, and with artificial bearing looseness.
INT8 Quantization & Memory Budgeting
An ESP32-S3 has 512KB of internal SRAM. A standard floating-point MobileNet model requires 15MB of RAM—it simply will not fit.
By applying INT8 post-training quantization, we map continuous 32-bit floats (-1.0 to +1.0) into discrete 8-bit signed integers (-128 to +127). The model size shrinks from 1.2MB down to ~280KB, fitting comfortably within the microcontroller SRAM arena with sufficient headroom for the frame buffer.
| Metric | Standard Float32 Model | Quantized INT8 Micro Model |
|---|---|---|
| Model Size on Flash | 1,420 KB | 294 KB (79% reduction) |
| SRAM Working Arena | 850 KB (Exceeds MCU) | 142 KB (Fits comfortably) |
| Inference Latency | 410 ms | 78 ms (ESP-NN Accelerated) |
| Classification Accuracy | 96.2% | 95.1% (Negligible loss) |
Crucial Viva Questions on TinyML
External examiners frequently probe students on these exact mathematical concepts:
• "What is the difference between training and inference?" -> Answer: "Training requires backpropagation, gradient descent, and heavy floating-point matrix multiplications done offline on a PC/Colab. Inference is the forward-pass execution of pre-computed INT8 weights running locally on the ESP32."
• "How do you evaluate false positives?" -> Answer: "We generate a Confusion Matrix and calculate Precision, Recall, and F1-Score across held-out test data, which we have documented in Chapter 4 of our project report."