TinyFaceNet Smallplain 300K

Compact face embedding encoder trained from scratch with the available original 1M v2 training recipe. 299,119 training parameters; 231,781 deployed encoder parameters. The Hub auto-count may show about 239K stored floating-point values because it also counts batch-normalization buffers; the trainable encoder count is 231,781. Produces a 128-dimensional embedding from an aligned 112 x 112 BGR face crop. No text or spoken-language task is supported.

This release contains encoder weights, executable architecture, sanitized evaluation results and reproducible speed/metric scripts. No personal images, real identity names, identity mapping, enrollment embeddings, centroids or classification weights are included. Name1 through Name9 are anonymous report labels. The encoder needs a separately supplied, consented enrollment gallery to name anyone. Removing identity metadata is not a formal differential-privacy guarantee for trained weights.

Comparison with the published 1M models

Reference: TinyFaceNet-1M. Both downloaded v1/v2 public safetensors were tensor-by-tensor identical to the stripped local encoders used here.

LFW uses all 6,000 official pairs, standard 10 contiguous folds, 600 pairs per fold. For each fold the cosine threshold is selected on the other 5,400 pairs, on a grid [-1, 1) with step .002. No model fitting on LFW. Existing five-point buffalo_l aligned funneled crops were used; no failed detections or discarded pairs. Standard deviation is across folds, not a confidence interval. Source pair/cache/checkpoint hashes and every fold result are provided in results/lfw_*.json.

Color-order correction: training uses BGR. The old published LFW numbers used RGB input (62.6% v1 / 63.6% v2). Both pipelines were rerun on every model; compare BGR with BGR, or RGB with RGB. Smallplain's BGR gain over 1M v2 is only 0.38 percentage points / 23 pairs; this does not establish general superiority. Under legacy RGB Smallplain is slightly below 1M v2. Teacher training overlap with LFW was not audited.

Anonymous per-member accuracy

All private scores use the same 59 unmodified crops, nearest saved training centroid and argmax without rejection. The date holdout was reused every epoch for checkpoint selection and is not an untouched final test. Three identities have no holdout examples. Smallplain: 47/49 family, 7/10 background, 54/59 overall. Similarities are not calibrated probabilities. No identity gallery is published, so private-set evaluation cannot be reproduced from public files alone.

Speed

Measured on 13th Gen Intel(R) Core(TM) i7-1360P, 12 physical / 16 logical cores, Windows 11, PyTorch 2.12.0+cpu, CPU FP32. Preallocated synthetic input, eval + inference_mode, embedding plus L2 normalization; excludes face detection, crop alignment, I/O and gallery matching. Five shuffled model-order rounds with 10 warmup calls per model per round; 400 measured calls for batch 1 and 100 for batch 16. Median/p95 are batch latency, not end-to-end camera FPS.

At 4 threads, batch 1: Smallplain 7.18 ms vs 1M v2 10.73 ms (1.49x faster, 33.1% lower latency). Batch 16: 29.38 vs 77.57 ms (2.64x throughput). Thread count, CPU load and power/thermal state affect results. The one-thread v1 rounds varied substantially (6.23 to 15.12 ms mean); raw round means are preserved, and this is a single-machine benchmark, not a universal speed guarantee.

Raspberry Pi 4 Model B (4 GB), ONNX Runtime

Measured 2026-10-12 on Raspberry Pi 4 Model B Rev 1.4 (4 GB, Cortex-A72 @ 1.8 GHz), Raspberry Pi OS Bookworm (Debian 12, aarch64, kernel 6.12), Python 3.11, ONNX Runtime 1.31.0 CPU FP32, opset-17 exports of the same checkpoints (ONNX output verified against PyTorch to < 3e-6 max abs diff). Per model and thread count: 10 warmup calls then 50 measured single-image calls; preallocated synthetic input; same exclusions as above (no detection, alignment, I/O or gallery matching). The board was running its normal resident services during measurement (about 2.6 GB RAM in use), so these are realistic in-service numbers rather than idle-machine bests; SoC temperature 52 °C, no throttling observed. At 4 threads Smallplain runs a single face in 29.2 ms (about 34 fps), 2.3x faster than 1M v2 on this board.

Raspberry Pi 5 Model B (8 GB), ONNX Runtime

Measured 2026-10-12 on Raspberry Pi 5 Model B Rev 1.0 (8 GB, Cortex-A76 @ 2.4 GHz), Raspberry Pi OS Bookworm (aarch64), Python 3.11, ONNX Runtime 1.31.0 CPU FP32, identical method to the Pi 4 run above. Unlike the Pi 4 run this board was near idle (about 0.6 GB RAM in use); SoC temperature 44 °C, no throttling. At 4 threads Smallplain embeds a single face in 4.48 ms (about 223 fps), 1.9x faster than 1M v2 and roughly 6.5x faster than the same model on the in-service Pi 4.

Microcontrollers (RP2040)

Smallplain does not fit a Raspberry Pi Pico / RP2040 (264 KB SRAM), even fully INT8-quantized. The INT8 weights (~223 KB) fit the 2 MB flash, but the activation memory does not: the largest intermediate tensor is 135 KB and must coexist with the 37.6 KB input, so a TensorFlow Lite Micro tensor arena of roughly 230 KB would be needed (estimated from a measured ~58 KB TFLM arena overhead for a smaller model of the same operator mix on the same chip), against roughly 235 KB realistically available after stack, USB stdio and runtime globals. This is an arithmetic bound from a real on-device calibration run, not a guess; the smaller model used for calibration ran INT8 inference on an RP2040 at 133 MHz in about 1.09 s/face with 171 KB of arena. For microcontroller deployment a sub-128K-parameter architecture at reduced input resolution is required; this model targets Raspberry Pi 4/5-class CPUs and up.

Loading and use

pip install torch safetensors huggingface_hub numpy opencv-python
hf download sraivante/TinyFaceNet-300K-Smallplain --local-dir smallplain_model

Run from the downloaded directory (or add it to Python's module path):

import cv2, torch
import torch.nn.functional as F
from safetensors.torch import load_file
from model import TinyFaceNet
model = TinyFaceNet().eval()
model.load_state_dict(load_file('model.safetensors'), strict=True)
crop = cv2.imread('your_aligned_crop.png')  # BGR, already five-point aligned
assert crop is not None and crop.shape == (112, 112, 3)
x = torch.from_numpy(crop).permute(2,0,1).unsqueeze(0).float()/127.5-1
with torch.inference_mode():
    embedding = F.normalize(model(x), dim=1)

Detection/alignment and enrollment are separate tasks. Do not apply an RGB conversion to this BGR input. Cosine similarity thresholds need validation on the intended data. No liveness, spoof-resistance or reliable unknown-person rejection is established.

Download badges use the Hub's server-side statistics. The full-repository download above includes config.json, the default query file used for download counting. Counts are not unique-user counts, and cached loads need no new server request. See Hub download statistics. Matching 1M task/architecture/edge tags are retained; ONNX and INT8 tags are omitted because this release contains FP32 PyTorch/safetensors only. Raspberry Pi 4 FP32 latency has been measured directly (see Speed); other Raspberry Pi variants remain untested.

Training, snapshot and provenance

Versioned data provenance contains metadata only. Source archive SHA-256 c5e748126ec8b5a1548444ce748ca984149367a35fe11e181a432fb2657a86c5; saved split SHA-256 a0a8a755fd5c63009e8b00c6715db3f40fd358bce90c1659104e1c46d693b21c. 1,852 original training crops (1,252 family + 600 background), 59 holdout crops (49 + 10). Private images, labels, original filenames, teacher vectors and split row lists are deliberately withheld. This model has no precomputed remix expansion; augmentation happens online.

Width .715, seed 0, 40 epochs, batch 128, CPU 10 threads. AdamW max LR .002, weight decay .0005; OneCycleLR with 10% warmup. Inverse-square-root class-frequency replacement sampling, 1,852 draws/epoch. Random flip/affine/brightness/gamma/contrast/noise/grayscale/blur/cutout. Cross entropy with .1 label smoothing plus twice cosine distillation loss to existing 512-dimensional InsightFace buffalo_l targets. Initialization was random; teacher targets remain pretrained supervision. Highest family holdout accuracy selects the checkpoint, latest tie; selected epoch 40. Training epochs totaled 681.7 seconds. Exact-image train/holdout overlap check passed.

The manifest identifies the actual saved Smallplain source/split and reference-code hashes. It records the available historical recipe, not an asserted missing original 1M git revision. Training cannot be rerun exactly without the excluded private dataset and teacher assets.

License, credit and limits

Apache License 2.0 covers the author's original release contributions. Copyright (c) 2026 sraivante applies only to original material and original dataset selection/arrangement; it does not claim third-party photographs or model assets. Private data is not being distributed under this release.

Third-party terms remain separate: InsightFace code is MIT, but its pretrained model zoo (including the teacher/alignment assets used here) is offered for non-commercial research. See official model zoo terms. Those assets/targets are not included. This release does not grant rights to third-party assets or establish commercial clearance for this distilled model. LFW images and identity lists are not redistributed; obtain benchmark inputs from their original source subject to applicable terms.

Small, family-specific training data, possible label noise, reused private holdout, one seed and one speed-test machine limit conclusions. Public LFW performance is modest (73.60%); this is an experimental compact encoder, not validated for security-critical identification.