Built at ExecuTorch Hackathon — IoT Track

On-device self-correcting runtime for deployed vision models

# Self-correcting QC on the edge: sealed detector on the NPU, judged and retrained on the board **Team Edgeble** (Akhil Beeram, Aharone Routu, Buji Mamidipalli, Rithwik Beeram, Jagan Teki) **Track:** IoT, Arduino VENTUNO Q (Qualcomm Dragonwing IQ8 / QCS8275, Hexagon V75) **Repo:** https://github.com/edgeble/self-correction-qc-executorch (Apache-2.0) ## The problem A vision model on a production line is right on the day it is installed and wrong the day the lighting changes. A battery-terminal checker that reads good batteries as mismatched stops the line, and the fix today is a human, a laptop and a retrain somewhere else. We show the runtime correcting itself on the device: on the spot at the decision point, and over time by retraining the model's head on the board. ## What we built - **Our own model.** A YOLO11n detector trained on our 9 V battery data (four classes: positive, negative, and the two mismatch cases), exported with ExecuTorch 1.5.1 and the Qualcomm QNN backend as a sealed int8 `.pte` for the Hexagon NPU. ExecuTorch did not list this chip; we patched the chipset tables and found the QNN runtime that the board accepts. - **A rig.** A rotating ring with a stepper motor, a USB camera and three light strips on Modbus/RS485, so the lighting failure can be produced on demand. - **edgeble-infer**, our C/C++ inference engine, hosts the sealed program: camera, tracking, the gate that turns detections into GO/NG, the HDMI and browser view, and the hooks where the correction layer plugs in. ExecuTorch is the model runtime inside it, not a replacement for it. - **The judge.** At the decision point every terminal crop is compared, with the same frozen backbone the detector runs (a second sealed `.pte` on the NPU, 256-d), against a bank of examples the line confirmed in good light. A clear match flips the label in about 15 ms; an unclear one abstains. The model never judges itself. - **On-device retrain.** The trainable head of the same network is retrained on the board from the corrected frames, in minutes, checked for learning and forgetting, and hot-swapped with the old head kept for rollback. The sealed front on the NPU never changes. ## What we measured on the Q (2026-10-18) - Sealed inference: 9.5 ms per frame, 30 fps, ~7% NPU, one CPU core, 259 MB. - Judge on the recorded mixed clip, same frames, same binary, two panes started together: model as installed 16 NG / 33 GO; with the judge 10 NG / 39 GO. Six false positives corrected, zero genuine mismatches lost. 77 verdicts: 46 confirmed, 22 abstained, 9 flips, 6 to 109 ms each. - On-device head retrain: end to end on the board (7.6 min for 930 frames); the recipe has not yet removed the lighting false positives on this model, and the README says so with the logs. ## Why ExecuTorch One PyTorch model, two sealed programs on the same NPU (detector and embedder), the trainable head exported as a separate program with its weights in a `.ptd` the device can rewrite, and a C++ runtime small enough to live inside our own engine. Correct now, fix forever, nothing leaves the device. ## Honest limits The judge's bank is built from the line's own good-light run; a new room needs that run first, until then the judge abstains. The self-correction architecture is Edgeble's, patent pending (India filed, US in progress); the procedure and the retrain recipe are not in the repository, the results, logs and code around them are.