ESP32-P4 Vehicle Classifier

Production-ready vehicle classification on ESP32-P4 microcontroller using INT8-quantized MobileNetV2. Achieves 87.8% accuracy at 8.5 FPS with only 2.6 MB model size.

📹 Demo Video

---

🎯 What You Get

Three ready-to-flash ESP32-P4 projects demonstrating vehicle classification - but these are just examples of what's possible with a complete training pipeline.

Variant	Latency	Accuracy	FPS	Input Size	Use Case
Pico	70 ms	84.5%	14.3	96×96	Real-time, battery-powered
Current	118 ms	87.8%	8.5	128×128	Balanced performance
Optimized	459 ms	89.9%	2.2	256×256	High-accuracy applications

These models demonstrate:

• Vehicle detection (car, bus, truck, motorcycle) vs non-vehicles
• Binary classification optimized for ESP32-P4
• Three resolution/accuracy tradeoffs
• Hardware-validated deployment (real ESP32-P4, not simulation)

All models include:

• ✅ Complete ESP-IDF project (ready to build)
• ✅ INT8 quantized MobileNetV2 (2.6 MB)
• ✅ Test images with expected predictions
• ✅ Benchmark code for latency measurement
• ✅ Full build and deployment instructions

---

🚀 What Makes This Special

These models weren't manually tuned or randomly quantized. They came from a config-driven training pipeline that automates the entire ML workflow from dataset extraction to ESP32-P4 deployment.

The Pipeline Capabilities

Flexibility via YAML configuration:

• ✨ Train on ANY combination of COCO's 80 classes (no code changes)
• ✨ Input sizes from 64×64 to 512×512 (automatic adjustment)
• ✨ Multiple quantization strategies: PTQ, QAT, Mixed-Precision
• ✨ Automatic ESP32-P4 project generation for any model
• ✨ Complete hyperparameter control via config files

Example: Want to detect people instead of vehicles?

# config/dataset_config.yaml
target_classes: [1]  # COCO class ID for "person"
non_target_classes: [0, 2, 3, ...]  # Everything else

# Run the pipeline - that's it!

Example: Want ultra-fast inference?

# config/model_variants.yaml
ultra_fast:
  img_size: 64
  target_latency_ms: 35
  description: "Fastest possible"

Example: Want different quantization?

# config/quantization_config.yaml
ptq:
  calibration_method: "percentile"  # vs "kl"
  equalization:
    iterations: 20  # More aggressive optimization
  bias_correction:
    steps: 64  # Higher precision

No coding required. Just configuration.

---

💡 Real-World Applications

The same pipeline can create models for different tasks by simply changing configuration:

Traffic Monitoring

classes: [2, 3, 5, 7]  # car, motorcycle, bus, truck
input: 128×128
result: 87.8% accuracy, 118ms latency

PPE Detection

classes: [1]  # person with/without safety equipment
input: 160×160
result: ~88% accuracy, 200ms latency

Pet Detection

classes: [16, 17, 18]  # dog, cat, bird
input: 96×96
result: ~85% accuracy, 70ms latency

Package Detection

classes: [28, 30, 32]  # suitcase, handbag, backpack  
input: 224×224
result: ~91% accuracy, 380ms latency

Security Perimeter

classes: [1, 2, 3, 4]  # person, car, motorcycle, airplane
input: 192×192
result: ~89% accuracy, 280ms latency

All achievable with the same training infrastructure - just different config files.

---

⚡ Quick Start

1. Prerequisites

Hardware:

• ESP32-P4-Function-EV-Board
• USB-C cable (data-capable)

Software:

• ESP-IDF v5.3+ (installation guide)

2. Clone Repository

git clone https://github.com/boumedibe/esp32-p4-vehicle-classifier.git
cd esp32-p4-vehicle-classifier

3. Choose a Variant

# Pick one:
cd examples/pico_variant      # Fastest (70ms)
cd examples/current_variant   # Balanced (118ms)
cd examples/optimized_variant # Most accurate (459ms)

4. Build and Flash

# Set target (one-time)
idf.py set-target esp32p4

# Build, flash, and monitor
idf.py build flash monitor

5. Expected Output

======================================================================
  ESP32-P4 Vehicle Classifier - Current Variant
======================================================================
Input: 128×128×3 | Latency: 118ms | Accuracy: 87.8%
======================================================================

=== Testing: vehicle_0.jpg ===
Inference time: 118 ms
Prediction: Vehicle (confidence: 99.8%)
Result: ✓ CORRECT

=== Testing: not_vehicle_0.jpg ===
Inference time: 117 ms
Prediction: Not Vehicle (confidence: 96.1%)
Result: ✓ CORRECT

=== Benchmark (10 iterations) ===
Average latency: 118.0 ms
Throughput: 8.47 FPS

Exit monitor: Press Ctrl + ]

---

🔬 How These Models Were Created

These models are the result of a complete end-to-end ML pipeline with state-of-the-art quantization techniques. Here's what went into creating them:

Pipeline Architecture

COCO Dataset (118K images, 80 classes)
    ↓
[Step 1] Automatic Dataset Extraction
    → Configurable class selection
    → Balanced train/val split  
    → 11,000 images extracted
    ↓
[Step 2] FP32 Training
    → MobileNetV2 (ImageNet pretrained)
    → ReLU6 → ReLU conversion
    → 32 epochs with augmentation
    → Result: 88.1% accuracy
    ↓
[Step 3] Post-Training Quantization (PTQ)
    → Layerwise equalization
    → KL-divergence calibration
    → Bias correction
    → Result: 84.2% accuracy (3.9% drop)
    ↓
[Step 4] Sensitivity Analysis (Optional)
    → Layer-wise SNR computation
    → Identify problematic layers
    → Guide mixed-precision decisions
    ↓
[Step 5] Quantization-Aware Training (QAT)
    → Fine-tune with simulated quantization
    → 10 epochs, very low LR (1e-6)
    → Straight-through estimator (STE)
    → Result: 87.8% accuracy (99.7% retention!)
    ↓
[Step 6] Model Export
    → Export to .espdl format
    → 2.6 MB INT8 model
    ↓
[Step 7] ESP32-P4 Project Generation
    → Automatic IDF project creation
    → Test images embedded
    → Ready to flash

Total pipeline time: ~60-90 minutes on GPU

Configuration-Driven Workflow

The entire pipeline is controlled by 4 YAML files:

1. Dataset Configuration

# config/dataset_config.yaml
coco_root: "/path/to/coco"
img_size: 128  # Auto-set by variant
preload_to_ram: true  # 3× faster training

train:
  n_vehicle: 5000
  n_non_vehicle: 5000

val:
  n_vehicle: 500
  n_non_vehicle: 500

vehicle_class_ids: [2, 3, 4, 5, 6, 7, 8]  # Configurable!

2. Training Configuration

# config/training_config.yaml
variant: "current"  # pico, current, optimized

model:
  name: "mobilenet_v2"
  pretrained: true
  convert_relu6_to_relu: true  # Critical for quantization!

training:
  epochs: 32
  batch_size: 128  # Auto-adjusted by variant
  learning_rate: 0.001
  optimizer: "SGD"

augmentation:
  horizontal_flip: 0.5
  rotation_degrees: 15
  color_jitter:
    brightness: 0.3
    contrast: 0.3

3. Quantization Configuration

# config/quantization_config.yaml
platform: "esp32p4"

ptq:
  calibration_method: "kl"  # kl, minmax, percentile
  calibration_steps: 32
  
  equalization:
    enabled: true
    iterations: 10
  
  bias_correction:
    enabled: true
    steps: 32

qat:
  epochs: 10
  learning_rate: 1.0e-6  # Very low for stability
  momentum: 0.937

4. Model Variants

# config/model_variants.yaml
variants:
  pico:
    img_size: 96
    target_latency_ms: 70
    
  current:
    img_size: 128
    target_latency_ms: 118
    
  optimized:
    img_size: 256
    target_latency_ms: 459
    
  # Add your own:
  custom:
    img_size: 192
    target_latency_ms: 250

Want to train a different model? Update configs and rerun. No code changes needed.

Advanced Quantization Techniques

1. Layerwise Equalization

Redistributes weight scales across layers to balance quantization error:

For consecutive layers W₁ and W₂:
  s = √(range(W₂) / range(W₁))
  W₁' = W₁ · diag(s)
  W₂' = diag(1/s) · W₂

Result: Both layers quantize with similar precision
Benefit: 1-2% accuracy improvement

2. KL-Divergence Calibration

Finds optimal quantization thresholds by minimizing information loss:

Objective: T* = argmin KL(P_fp32 || P_int8)

Where:
  P_fp32 = activation distribution (float32)
  P_int8 = quantized distribution
  T = clipping threshold

Result: Better dynamic range utilization
Benefit: 1-3% accuracy improvement

3. Bias Correction

Compensates for systematic quantization bias:

For each layer:
  bias = E[activation_fp32] - E[activation_int8]
  output_corrected = output_int8 + bias

Result: Removes mean shift from quantization
Benefit: 0.5-1.5% accuracy improvement

Combined effect: 3-6% accuracy recovery vs naive INT8 quantization

Why ReLU6 → ReLU Conversion Matters

MobileNetV2 originally uses ReLU6: f(x) = min(max(0, x), 6)

Problem with ReLU6 for quantization:

Distribution: [0, 6] with sharp cutoff at 6
Quantization: Creates many values at exactly 6
Result: Poor INT8 representation, ~5% accuracy drop

Solution: Convert to standard ReLU: f(x) = max(0, x)

Distribution: [0, ∞) with smooth tail
Quantization: Natural distribution, no clustering
Result: Better INT8 approximation, ~2% improvement

This single architectural change improves quantized accuracy significantly.

Quantization-Aware Training (QAT)

QAT fine-tunes the model with simulated quantization in the forward pass:

# Forward pass (simplified):
def qat_forward(x, weight, scale, zero_point):
    # Simulate quantization
    x_quant = quantize(x, scale, zero_point)
    x_dequant = dequantize(x_quant, scale, zero_point)
    
    # Normal computation on dequantized values
    output = conv(x_dequant, weight)
    return output

# Backward pass: Straight-Through Estimator
def qat_backward(grad_output):
    # Gradient flows as if quantization didn't exist
    return grad_output  # No gradient for quantize/dequantize

Why this works:

• Model learns to place weights/activations at INT8-friendly values
• Network adapts to quantization constraints during training
• Much more effective than post-training quantization alone

Result: Recovers 2-4% accuracy over PTQ

---

📊 Performance Benchmarks

All measurements on ESP32-P4-Function-EV-Board (real hardware, not simulation).

Latency Breakdown

Pico Variant (96×96)

Component               Time    %
─────────────────────────────────
JPEG Decode            12 ms   17%
Image Resize            4 ms    6%
Normalization           2 ms    3%
Model Inference        50 ms   71%
Softmax                 2 ms    3%
─────────────────────────────────
Total                  70 ms  100%
Throughput          14.3 FPS

Current Variant (128×128)

Component               Time    %
─────────────────────────────────
JPEG Decode            12 ms   10%
Image Resize            6 ms    5%
Normalization           3 ms    3%
Model Inference        94 ms   80%
Softmax                 3 ms    2%
─────────────────────────────────
Total                 118 ms  100%
Throughput           8.5 FPS

Optimized Variant (256×256)

Component               Time    %
─────────────────────────────────
JPEG Decode            12 ms    3%
Image Resize           22 ms    5%
Normalization          10 ms    2%
Model Inference       410 ms   89%
Softmax                 5 ms    1%
─────────────────────────────────
Total                 459 ms  100%
Throughput           2.2 FPS

Memory Footprint

Resource	Pico	Current	Optimized
Flash (model)	2.54 MB	2.54 MB	2.54 MB
Flash (total)	~4 MB	~4 MB	~4 MB
RAM (runtime)	400 KB	500 KB	800 KB
Input buffer	27 KB	48 KB	192 KB
PSRAM available	15.6 MB	15.5 MB	15.2 MB

Power Consumption

Measured at USB 5V input with digital multimeter:

State	Current	Power	Energy/Frame
Idle	40 mA	200 mW	-
Pico inference	90 mA	450 mW	31.5 mJ
Current inference	110 mA	550 mW	64.9 mJ
Optimized inference	120 mA	600 mW	275.4 mJ

Battery life estimates (2000 mAh @ 3.7V = 7.4 Wh):

Variant	Mode	Avg Power	Battery Life
Pico	Continuous (14 FPS)	450 mW	16.4 hours
Pico	1 FPS sampling	250 mW	29.6 hours
Current	Continuous (8 FPS)	550 mW	13.5 hours
Current	1 FPS sampling	280 mW	26.4 hours
Optimized	Continuous (2 FPS)	600 mW	12.3 hours

Quantization Quality

Accuracy Retention (Current Variant):

FP32 Baseline:        88.10%  ━━━━━━━━━━━━━━━━━━━━━━ 100.0%
                                    ↓ Naive INT8
Naive INT8:           ~76.00%  ━━━━━━━━━━━━━━━━      86.3%
                                    ↓ PTQ + Optimizations
PTQ INT8:             84.20%  ━━━━━━━━━━━━━━━━━━    95.6%
                                    ↓ QAT Fine-tuning
QAT INT8:             87.80%  ━━━━━━━━━━━━━━━━━━━━━  99.7%

Our pipeline vs naive: +11.8% accuracy improvement
QAT vs PTQ: +3.6% additional improvement

Computational Complexity

Variant	MACs	FLOPs	Parameters	Dominant Op
Pico	30 M	60 M	3.5 M	Depthwise (68%)
Current	53 M	106 M	3.5 M	Depthwise (68%)
Optimized	211 M	422 M	3.5 M	Depthwise (68%)

Note: Model size is constant (MobileNetV2 architecture). Latency scales with input resolution.

---

🛠️ Hardware Setup

Required Components

Board: ESP32-P4-Function-EV-Board

• ESP32-P4 SoC (dual-core RISC-V, 400 MHz)
• 16 MB flash (8 MB minimum)
• 16 MB PSRAM (required for inference)
• USB-C programming interface

Cable: USB-C data cable (not charge-only)

Optional: 5V/2A external power supply for standalone deployment

Connection

1. Connect ESP32-P4 board to computer via USB-C
2. Board should be auto-detected

Verify connection:

# Linux
ls /dev/ttyUSB*
# Should show: /dev/ttyUSB0

# macOS
ls /dev/tty.*
# Should show: /dev/tty.usbserial-*

# Windows
# Check Device Manager → Ports (COM & LPT)

ESP-IDF Installation

Linux / macOS:

# Install dependencies
sudo apt-get install git wget flex bison gperf python3 python3-pip \
  python3-venv cmake ninja-build ccache libffi-dev libssl-dev dfu-util

# Clone ESP-IDF v5.3
mkdir -p ~/esp
cd ~/esp
git clone -b v5.3 --recursive https://github.com/espressif/esp-idf.git

# Install ESP32-P4 tools
cd esp-idf
./install.sh esp32p4

# Activate environment (run in every terminal)
. ./export.sh

Windows:

1. Download ESP-IDF Windows Installer
2. Select "ESP32-P4" as target during installation
3. Use "ESP-IDF PowerShell" or "ESP-IDF Command Prompt"

Verify installation:

idf.py --version
# Expected: ESP-IDF v5.3.x or higher

---

🎯 Use Cases

The flexibility of the pipeline enables many edge AI applications:

Traffic & Transportation

• Vehicle counting: Real-time traffic flow analysis
• Type classification: Car vs truck vs bus vs motorcycle
• Parking occupancy: Spot-level detection
• Lane monitoring: Vehicle presence detection

Security & Surveillance

• Perimeter monitoring: Unauthorized vehicle detection
• Access control: Vehicle type verification
• Event detection: Unusual vehicle patterns

Industrial & Logistics

• Package detection: Suitcase, box, container classification
• PPE compliance: Safety equipment verification
• Warehouse automation: Object type recognition
• Delivery tracking: Package presence detection

Smart City

• Distributed sensing: Multiple ESP32-P4 nodes
• Edge processing: No cloud dependency, privacy-preserving
• Low cost: ~€10 per node vs €100+ for edge servers
• Low power: Battery operation for weeks

Agriculture & Environment

• Animal detection: Livestock monitoring, wildlife cameras
• Equipment tracking: Tractor, harvester detection
• Perimeter security: Intrusion detection

---

🔧 Customization

Replace Test Images

cd examples/current_variant/main

# Remove default images
rm vehicle_*.jpg not_vehicle_*.jpg

# Add your images (JPEG format)
cp /path/to/your/car.jpg vehicle_0.jpg
cp /path/to/your/tree.jpg not_vehicle_0.jpg

# Rebuild and flash
cd ..
idf.py build flash monitor

Image requirements:

• Format: JPEG (baseline encoding recommended)
• Size: Any size (will be auto-resized to variant resolution)
• Content: Should match training distribution for best accuracy

Adjust Model Settings

Edit main/app_main.cpp:

// Confidence threshold (0.0 to 1.0)
float confidence_threshold = 0.5;

// Number of benchmark iterations
#define BENCHMARK_ITERATIONS 10

// Enable/disable benchmark
#define RUN_BENCHMARK 1

// Verbose output
#define VERBOSE_OUTPUT 1

Rebuild after changes: idf.py build flash monitor

Create Custom Datasets

The training pipeline supports:

From COCO (80 classes available):

• Person, bicycle, car, motorcycle, airplane, bus, train, truck, boat
• Traffic light, fire hydrant, stop sign, parking meter, bench
• Bird, cat, dog, horse, sheep, cow, elephant, bear, zebra, giraffe
• Backpack, umbrella, handbag, tie, suitcase
• Frisbee, skis, snowboard, sports ball, kite
• ... and 55 more classes

Custom datasets:

• Organize images in dataset/train/{class1,class2} and dataset/val/{class1,class2}
• Use any binary classification task
• Pipeline handles preprocessing automatically

---

🐛 Troubleshooting

Build Errors

"Target 'esp32p4' is not supported"

# ESP-IDF version too old
cd ~/esp/esp-idf
git pull
git submodule update --init --recursive
./install.sh esp32p4
. ./export.sh

"CMake version too old"

pip install cmake --upgrade

"Toolchain not found"

cd ~/esp/esp-idf
./install.sh esp32p4 --reinstall

Flash Errors

"Failed to connect to ESP32-P4"

Try these in order:

1. Hold BOOT button while connecting USB
2. Press RESET button, then retry flash
3. Use slower baud rate: idf.py -b 115200 flash
4. Check USB cable (must support data, not just charging)
5. Try different USB port (USB 3.0 ports provide more power)

"Permission denied: /dev/ttyUSB0" (Linux)

# Add user to dialout group
sudo usermod -a -G dialout $USER

# Logout and login, or reboot

"Port not found" (Windows)

• Install CP210x USB drivers from Silicon Labs
• Check Device Manager → Ports (COM & LPT)

Runtime Issues

Board resets during inference (brownout)

Causes: Insufficient power supply

Solutions:

1. Use USB 3.0 port (provides up to 900 mA)
2. Connect to powered USB hub
3. Use external 5V/2A power supply via barrel jack

Model predictions incorrect

Debugging steps:

1. Test with provided images first (should be 100% correct)
2. Check image format (JPEG only, no PNG/WebP)
3. Verify image content matches training distribution
4. Check confidence scores (should be >80% for correct predictions)

Latency higher than benchmarks

Check:

1. Optimization level: idf.py menuconfig → Compiler options → Release (-O2)
2. PSRAM enabled: Component config → ESP PSRAM → Support for external PSRAM
3. Flash speed: Serial flasher config → Flash SPI speed (80 MHz)
4. CPU frequency: Component config → ESP System Settings → CPU frequency (400 MHz)

Out of memory errors

Solutions:

1. Use smaller variant (Optimized → Current → Pico)
2. Verify PSRAM is enabled and working
3. Check partition table: idf.py partition-table

---

📚 Technical Deep Dive

Quantization Mathematics

Symmetric Quantization (Weights):

Per-channel quantization for convolution weights:

For each output channel c:
  scale_c = max(|W_min[c]|, |W_max[c]|) / 127
  W_int8[c] = round(W_fp32[c] / scale_c)
  
Dequantization:
  W_fp32[c] ≈ W_int8[c] × scale_c

Properties:
  - Zero-point = 0 (symmetric around zero)
  - Range: [-127, 127]
  - Per-channel scales preserve accuracy

Asymmetric Quantization (Activations):

Per-tensor quantization for activations:

Calibration (using validation data):
  A_min = percentile(activations, 0.01)
  A_max = percentile(activations, 99.99)
  
Quantization parameters:
  scale = (A_max - A_min) / 255
  zero_point = -round(A_min / scale)
  
Forward:
  A_int8 = clip(round(A_fp32 / scale) + zero_point, 0, 255)
  
Dequantization:
  A_fp32 ≈ (A_int8 - zero_point) × scale

Why asymmetric for activations?

ReLU activations: f(x) = max(0, x)

• Range: [0, ∞) not [-∞, ∞)
• Symmetric quantization wastes negative range
• Asymmetric uses full [0, 255] range → better precision

Model Architecture Details

MobileNetV2 Structure:

Input (128×128×3)
    ↓
Conv2D (32 filters, stride 2) → 64×64×32
    ↓
Inverted Residual Block × 17
    - Expansion (1×1 conv, expand channels)
    - Depthwise (3×3 depthwise conv)
    - Projection (1×1 conv, reduce channels)
    - Skip connection (if stride=1)
    ↓
Conv2D (1280 filters) → 4×4×1280
    ↓
Global Average Pooling → 1×1×1280
    ↓
Fully Connected (2 classes) → 1×1×2
    ↓
Softmax → [P(not_vehicle), P(vehicle)]

Total parameters: 3.5M
Quantized size: 2.6 MB (8 bits per weight)
Operations: ~53M MACs @ 128×128 input

Why MobileNetV2?

• Designed for mobile/edge devices
• Efficient depthwise separable convolutions (68% of compute)
• Skip connections improve accuracy
• Quantization-friendly (with ReLU conversion)

ESP-DL Runtime

Model execution flow:

1. Load .espdl from flash
   - Parse model header
   - Allocate buffers in PSRAM
   - Load quantization parameters

2. Preprocessing
   - Decode JPEG (software)
   - Resize to target resolution (bilinear)
   - Normalize (ImageNet stats)
   - Convert to INT8

3. Inference
   - Layer-by-layer execution
   - INT8 operations on quantized data
   - Requantization between layers
   - Accumulation in INT32 for precision

4. Postprocessing
   - Dequantize output to FP32
   - Apply softmax
   - Return class probabilities

Memory layout:

Flash (16 MB):
  ├─ Bootloader (32 KB)
  ├─ Partition table (4 KB)
  ├─ Application code (1.2 MB)
  ├─ Model (.espdl) (2.6 MB)
  ├─ Test images (200 KB)
  └─ Free space (12 MB)

PSRAM (16 MB):
  ├─ Model weights cache (0 MB, loaded on demand)
  ├─ Input buffer (48 KB for 128×128)
  ├─ Intermediate activations (240 KB)
  ├─ Output buffer (8 bytes)
  └─ Free space (15.7 MB)

---

📖 References & Resources

Research Papers

Neural Network Quantization:

1. Jacob et al., "Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference" (CVPR 2018)
2. Nagel et al., "Data-Free Quantization Through Weight Equalization and Bias Correction" (ICCV 2019)
3. Gholami et al., "A Survey of Quantization Methods for Efficient Neural Network Inference" (2021)

MobileNet Architecture: 4. Sandler et al., "MobileNetV2: Inverted Residuals and Linear Bottlenecks" (CVPR 2018) 5. Howard et al., "Searching for MobileNetV3" (ICCV 2019)

Documentation

• ESP32-P4 Datasheet
• ESP32-P4 Technical Reference Manual
• ESP-IDF Programming Guide
• ESP-DL Library GitHub

Datasets

• COCO Dataset - 80 object classes, 330K images
• ImageNet - 1000 classes, 1.2M images (for pretraining)

Tools

• PyTorch - Deep learning framework
• ONNX - Model interchange format
• ESP-IDF - ESP32 development framework

---

🤝 Contributing

Contributions welcome! Areas for improvement:

Model Enhancements:

• Additional architectures (EfficientNet, SqueezeNet)
• Multi-class classification (beyond binary)
• Object detection (YOLO-style bounding boxes)

Deployment:

• Camera integration examples (DVP interface)
• WiFi streaming for live inference
• BLE for mobile app communication

Optimization:

• Hardware JPEG decoder integration
• Operator fusion for reduced latency
• Model pruning for smaller size

Documentation:

• Training custom datasets guide
• Performance tuning guide
• Production deployment checklist

Open an issue or submit a pull request!

---

📄 License

This project is licensed under the MIT License - see LICENSE file for details.

You are free to:

• ✅ Use commercially
• ✅ Modify and distribute
• ✅ Use privately
• ✅ Integrate into products

Attribution appreciated but not required.

---

📧 Contact

Boumedine Billal
GitHub: @BoumedineBillal
Email: boumedinebillal@gmail.com

Questions? Open an issue

---

🌟 Acknowledgments

• Espressif Systems for ESP32-P4 hardware and ESP-DL framework
• PyTorch team for the deep learning framework
• COCO dataset contributors for training data
• MobileNetV2 authors for the efficient architecture
• Open-source community for tools and libraries

---

💭 About This Project

These models represent 2 months of engineering to build a flexible, production-ready ML pipeline for ESP32-P4. The pipeline handles:

• Automatic dataset extraction and preprocessing
• Multiple quantization strategies with state-of-the-art techniques
• Configurable training without code changes
• Automatic ESP32-P4 project generation

The examples show vehicle classification, but the pipeline can train models for any binary classification task using COCO's 80 classes.

Want to see what else is possible? Check out the configuration examples throughout this README.

---

⭐ If this project helped you, please star the repository!