Speckle Fingerprint Authentication with TinyML

ISEF Category: Embedded Systems

Subcategory: Optics  ·  Difficulty: Advanced  ·  Setup: University Lab  ·  Time: Full Year

The Hook

Your fingertip can act like a secret code. Shine a laser on it, and the scattered light forms a speckle pattern that can be unique to you. A tiny chip can learn those patterns and guess identity fast enough for embedded security. That makes this project part optics, part machine learning, and part real-world authentication.

What Is It?

Speckle is the grainy pattern you get when coherent light, like laser light, bounces off a rough surface and the reflected waves add up in messy ways. Your fingertip is not smooth at the microscopic level, so it scatters light in a way that can create a repeatable pattern for one person, but a different pattern for someone else. Think of it like a tiny optical fingerprint, except the camera sees light spots instead of ink ridges.

The embedded systems part comes from putting the sensing and classification on a small device, such as a Cortex-M microcontroller. TinyML means a machine learning model small enough to run on low-power hardware. Your job is to see whether the speckle image contains enough identity information, and whether a compact model can recognize it without a big computer.

Why This Is a Good Topic

This makes a strong science fair topic because you can test a clear hypothesis, measure accuracy, and compare design choices. It connects to biometrics, phone security, and low-power edge AI, which are real problems in security and access control. You can learn imaging, classification, model validation, and sensor design in one project, and each part gives you data you can graph and defend.

Research Questions

• How does sensor resolution affect identity classification accuracy for fingertip speckle patterns?
• What is the effect of laser wavelength on the separability of speckle signatures from different users?
• Does cropping the speckle image to different regions change TinyML model accuracy?
• To what extent does the number of training samples per user affect false acceptance and false rejection rates?
• Which image preprocessing method, if any, improves classification of speckle patterns on a Cortex-M device?
• How does model size affect latency, memory use, and accuracy for fingertip biometric recognition?

Basic Materials

• Low-power laser module with stable output.
• Low-resolution camera module or small monochrome sensor.
• Cortex-M microcontroller board.
• Finger position guide or simple mount to keep distance steady.
• Tripod or fixed stand for camera and laser alignment.
• Black matte background or enclosure to reduce stray light.
• Laptop for data collection and model training.
• Tape, clamps, and alignment tools.
• Safety goggles rated for the laser wavelength.
• Spreadsheet software for analysis.

Advanced Materials

• Cortex-M development board with sufficient RAM and flash for TinyML.
• Scientific-grade monochrome sensor or compact camera with manual exposure control.
• Adjustable laser source with known wavelength and power.
• Optical breadboard or rigid alignment platform.
• Neutral density filters for managing exposure.
• Calibrated target or diffuser for alignment checks.
• Compute platform for model development and benchmarking.
• Image capture software with frame export.
• Current meter or power meter for laser stability checks.
• Shielded enclosure to control ambient light.

Software & Tools

• Edge Impulse: Helps you build and test TinyML image models for embedded hardware.
• TensorFlow Lite Micro: Runs small neural networks on Cortex-M boards.
• Python: Organizes image data, trains models, and computes accuracy metrics.
• OpenCV: Handles image cleanup, cropping, and feature inspection.
• ImageJ: Lets you inspect speckle contrast and compare image regions.

Experiment Steps

1. Define the identity task you want to solve, such as classifying a small set of users versus testing one-user authentication.
2. Design a repeatable optical setup so the laser, fingertip, and sensor stay in the same geometry for every trial.
3. Plan your data structure before collecting anything, including how many users, how many repeats, and how you will split training and test data.
4. Decide which image-processing pipeline you will compare, such as raw images versus normalized or cropped images.
5. Build a baseline model first, then test whether a smaller embedded model keeps useful accuracy under memory limits.
6. Choose evaluation metrics that match the security problem, including accuracy, false accept rate, false reject rate, and latency.

Common Pitfalls

• Letting the finger shift between captures, which changes the speckle pattern more than the person does.
• Using automatic camera exposure, which hides real signal differences by stretching brightness differently each time.
• Testing with images from the same session only, which makes the model look better than it will in real use.
• Collecting too few users or too few repeats, which makes identity accuracy meaningless.
• Ignoring ambient light and laser safety, which can add noise and create unsafe conditions.

What Makes This Competitive

A class-level version of this project only shows that a model can separate a few people. A stronger project tests how stable the system stays when you change finger placement, sensor quality, or lighting. You can also compare simple classifiers against TinyML models and report security metrics, not just accuracy. The best version explains where the signal comes from and where the system breaks.

Project Variations

• Test speckle recognition across different finger pressures to see how skin deformation changes the pattern.
• Compare grayscale and downsampled images to find the smallest sensor input that still preserves identity information.
• Study whether the model works better for authentication of one claimed user than for full multi-class identity recognition.

Learn More

• MIT OpenCourseWare: Search for optics, image processing, and embedded machine learning lecture notes and assignments.
• NASA NTRS: Search for speckle imaging and optical sensing reports in the NASA Technical Reports Server.
• PubMed: Search review articles on biometrics, optical coherence, and physiological identification methods.
• IEEE Xplore: Search for journal papers on speckle-based biometrics, fingerprinting, and TinyML on microcontrollers.
• TensorFlow Lite for Microcontrollers: Read the free official documentation and example code for small-device inference.