feat: Add EdgeFace recognition model (#105 )

* refactor: Split recognition models into separate files * feat: Add EdgeFace recognition model * release: Bump version to v3.4.0
docs: Add example images and update MkDocs files (#104 )
2026-05-16 13:47:53 +00:00 · 2026-04-04 20:11:28 +09:00 · 2026-04-04 18:28:27 +09:00 · 2026-04-03 10:10:51 +09:00
56 changed files with 1465 additions and 1762 deletions
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -18,6 +18,13 @@ repos:
      - id: debug-statements
      - id: check-ast

+  # Strip Jupyter notebook outputs
+  - repo: https://github.com/kynan/nbstripout
+    rev: 0.9.1
+    hooks:
+      - id: nbstripout
+        files: ^examples/
+
  # Ruff - Fast Python linter and formatter
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.14.10
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -0,0 +1,6 @@
+<!-- Cursor agent instructions — shared with CLAUDE.md -->
+<!-- See CLAUDE.md for full project instructions for AI coding agents. -->
+
+# AGENTS.md
+
+Please read and follow all instructions in [CLAUDE.md](./CLAUDE.md).
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -0,0 +1,81 @@
+# CLAUDE.md
+
+Project instructions for AI coding agents.
+
+## Project Overview
+
+UniFace is a Python library for face detection, recognition, tracking, landmark analysis, face parsing, gaze estimation, age/gender detection. It uses ONNX Runtime for inference.
+
+## Code Style
+
+- Python 3.10+ with type hints
+- Line length: 120
+- Single quotes for strings, double quotes for docstrings
+- Google-style docstrings
+- Formatter/linter: Ruff (config in `pyproject.toml`)
+- Run `ruff format .` and `ruff check . --fix` before committing
+
+## Commit Messages
+
+Follow [Conventional Commits](https://www.conventionalcommits.org/) with a **capitalized** description:
+
+```
+<type>: <Capitalized short description>
+```
+
+Types: `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `build`, `ci`, `chore`
+
+Examples:
+- `feat: Add gaze estimation model`
+- `fix: Correct bounding box scaling for non-square images`
+- `ci: Add nbstripout pre-commit hook`
+- `docs: Update installation instructions`
+- `refactor: Unify attribute/detector base classes`
+
+## Testing
+
+```bash
+pytest -v --tb=short
+```
+
+Tests live in `tests/`. Run the full suite before submitting changes.
+
+## Pre-commit
+
+Pre-commit hooks handle formatting, linting, security checks, and notebook output stripping. Always run:
+
+```bash
+pre-commit install
+pre-commit run --all-files
+```
+
+## Project Structure
+
+```
+uniface/            # Main package
+  detection/        # Face detection models (SCRFD, RetinaFace, YOLOv5, YOLOv8)
+  recognition/      # Face recognition/verification (AdaFace, ArcFace, EdgeFace, MobileFace, SphereFace)
+  landmark/         # Facial landmark models
+  tracking/         # Object tracking (ByteTrack)
+  parsing/          # Face parsing/segmentation (BiSeNet, XSeg)
+  gaze/             # Gaze estimation
+  headpose/         # Head pose estimation
+  attribute/        # Age, gender, emotion detection
+  spoofing/         # Anti-spoofing (MiniFASNet)
+  privacy/          # Face anonymization
+  stores/           # Vector stores (FAISS)
+  constants.py      # Model weight URLs and checksums
+  model_store.py    # Model download/cache management
+  analyzer.py       # High-level FaceAnalyzer API
+  types.py          # Shared type definitions
+tests/              # Unit tests
+examples/           # Jupyter notebooks (outputs are auto-stripped)
+docs/               # MkDocs documentation
+```
+
+## Key Conventions
+
+- New models: add class in submodule, register weights in `constants.py`, export in `__init__.py`
+- Dependencies: managed in `pyproject.toml`
+- All ONNX models are downloaded on demand with SHA256 verification
+- Do not commit notebook outputs; `nbstripout` pre-commit hook handles this
--- a/README.md
+++ b/README.md
@@ -26,7 +26,7 @@
 ## Features

 - **Face Detection** — RetinaFace, SCRFD, YOLOv5-Face, and YOLOv8-Face with 5-point landmarks
- **Face Recognition** — ArcFace, MobileFace, and SphereFace embeddings
+- **Face Recognition** — AdaFace, ArcFace, EdgeFace, MobileFace, and SphereFace embeddings
 - **Face Tracking** — Multi-object tracking with [BYTETracker](https://github.com/yakhyo/bytetrack-tracker) for persistent IDs across video frames
 - **Facial Landmarks** — 106-point landmark localization module (separate from 5-point detector landmarks)
 - **Face Parsing** — BiSeNet semantic segmentation (19 classes), XSeg face masking
@@ -40,6 +40,36 @@

 ---

+## Visual Examples
+
+<table>
+  <tr>
+    <td align="center"><b>Face Detection</b><br><img src="https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/detection.jpg" width="100%"></td>
+    <td align="center"><b>Gaze Estimation</b><br><img src="https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/gaze.jpg" width="100%"></td>
+  </tr>
+  <tr>
+    <td align="center"><b>Head Pose Estimation</b><br><img src="https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/headpose.jpg" width="100%"></td>
+    <td align="center"><b>Age &amp; Gender</b><br><img src="https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/age_gender.jpg" width="100%"></td>
+  </tr>
+  <tr>
+    <td align="center" colspan="2"><b>Face Verification</b><br><img src="https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/verification.jpg" width="80%"></td>
+  </tr>
+  <tr>
+    <td align="center" colspan="2"><b>106-Point Landmarks</b><br><img src="https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/landmarks.jpg" width="36%"></td>
+  </tr>
+  <tr>
+    <td align="center" colspan="2"><b>Face Parsing</b><br><img src="https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/parsing.jpg" width="80%"></td>
+  </tr>
+  <tr>
+    <td align="center" colspan="2"><b>Face Segmentation</b><br><img src="https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/segmentation.jpg" width="80%"></td>
+  </tr>
+  <tr>
+    <td align="center" colspan="2"><b>Face Anonymization</b><br><img src="https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/anonymization.jpg" width="100%"></td>
+  </tr>
+</table>
+
+---
+
 ## Installation

 **Standard installation**
@@ -212,6 +242,7 @@ https://yakhyo.github.io/uniface/concepts/execution-providers/
 | Recognition | MS1MV2 | MobileFace, SphereFace |
 | Recognition | WebFace600K | ArcFace |
 | Recognition | WebFace4M / 12M | AdaFace |
+| Recognition | MS1MV2 | EdgeFace |
 | Gaze | Gaze360 | MobileGaze |
 | Head Pose | 300W-LP | HeadPose (ResNet, MobileNet) |
 | Parsing | CelebAMask-HQ | BiSeNet |
@@ -243,6 +274,7 @@ If you plan commercial use, verify model license compatibility.
 | Detection | [yolov8-face-onnx-inference](https://github.com/yakhyo/yolov8-face-onnx-inference) | - | YOLOv8-Face ONNX Inference |
 | Tracking | [bytetrack-tracker](https://github.com/yakhyo/bytetrack-tracker) | - | BYTETracker Multi-Object Tracking |
 | Recognition | [face-recognition](https://github.com/yakhyo/face-recognition) | ✓ | MobileFace, SphereFace Training |
+| Recognition | [edgeface-onnx](https://github.com/yakhyo/edgeface-onnx) | - | EdgeFace ONNX Inference |
 | Parsing | [face-parsing](https://github.com/yakhyo/face-parsing) | ✓ | BiSeNet Face Parsing |
 | Parsing | [face-segmentation](https://github.com/yakhyo/face-segmentation) | - | XSeg Face Segmentation |
 | Gaze | [gaze-estimation](https://github.com/yakhyo/gaze-estimation) | ✓ | MobileGaze Training |
--- a/assets/demos/age_gender.jpg
+++ b/assets/demos/age_gender.jpg
--- a/assets/demos/anonymization.jpg
+++ b/assets/demos/anonymization.jpg
--- a/assets/demos/detection.jpg
+++ b/assets/demos/detection.jpg
--- a/assets/demos/gaze.jpg
+++ b/assets/demos/gaze.jpg
--- a/assets/demos/headpose.jpg
+++ b/assets/demos/headpose.jpg
--- a/assets/demos/landmarks.jpg
+++ b/assets/demos/landmarks.jpg
--- a/assets/demos/parsing.jpg
+++ b/assets/demos/parsing.jpg
--- a/assets/demos/segmentation.jpg
+++ b/assets/demos/segmentation.jpg
--- a/assets/demos/src_friends.jpg
+++ b/assets/demos/src_friends.jpg
--- a/assets/demos/src_man1.jpg
+++ b/assets/demos/src_man1.jpg
--- a/assets/demos/src_man2.jpg
+++ b/assets/demos/src_man2.jpg
--- a/assets/demos/src_man3.jpg
+++ b/assets/demos/src_man3.jpg
--- a/assets/demos/src_meeting.jpg
+++ b/assets/demos/src_meeting.jpg
--- a/assets/demos/src_portrait1.jpg
+++ b/assets/demos/src_portrait1.jpg
--- a/assets/demos/verification.jpg
+++ b/assets/demos/verification.jpg
--- a/docs/concepts/overview.md
+++ b/docs/concepts/overview.md
@@ -115,7 +115,7 @@ def detect(self, image: np.ndarray) -> list[Face]:
 ```
 uniface/
 ├── detection/      # Face detection (RetinaFace, SCRFD, YOLOv5Face, YOLOv8Face)
-├── recognition/    # Face recognition (AdaFace, ArcFace, MobileFace, SphereFace)
+├── recognition/    # Face recognition (AdaFace, ArcFace, EdgeFace, MobileFace, SphereFace)
 ├── tracking/       # Multi-object tracking (BYTETracker)
 ├── landmark/       # 106-point landmarks
 ├── attribute/      # Age, gender, emotion, race
--- a/docs/contributing.md
+++ b/docs/contributing.md
@@ -47,6 +47,38 @@ pre-commit run --all-files

 ---

+## Commit Messages
+
+We follow [Conventional Commits](https://www.conventionalcommits.org/):
+
+```
+<type>: <short description>
+```
+
+| Type         | When to use                                      |
+|--------------|--------------------------------------------------|
+| **feat**     | New feature or capability                        |
+| **fix**      | Bug fix                                          |
+| **docs**     | Documentation changes                            |
+| **style**    | Formatting, whitespace (no logic change)         |
+| **refactor** | Code restructuring without changing behavior     |
+| **perf**     | Performance improvement                          |
+| **test**     | Adding or updating tests                         |
+| **build**    | Build system or dependencies                     |
+| **ci**       | CI/CD and pre-commit configuration               |
+| **chore**    | Routine maintenance and tooling                  |
+
+**Examples:**
+
+```
+feat: Add gaze estimation model
+fix: Correct bounding box scaling for non-square images
+ci: Add nbstripout pre-commit hook
+docs: Update installation instructions
+```
+
+---
+
 ## Pull Request Process

 1. Fork the repository
--- a/docs/index.md
+++ b/docs/index.md
@@ -36,7 +36,7 @@ ONNX-optimized detectors (RetinaFace, SCRFD, YOLO) with 5-point landmarks.

 <div class="feature-card" markdown>
 ### :material-account-check: Face Recognition
-AdaFace, ArcFace, MobileFace, and SphereFace embeddings for identity verification.
+AdaFace, ArcFace, EdgeFace, MobileFace, and SphereFace embeddings for identity verification.
 </div>

 <div class="feature-card" markdown>
--- a/docs/models.md
+++ b/docs/models.md
@@ -156,6 +156,24 @@ Face recognition using angular softmax loss.

 ---

+### EdgeFace
+
+Efficient face recognition designed for edge devices, using EdgeNeXt backbone with optional LoRA compression.
+
+| Model Name      | Backbone | Params | MFLOPs | Size  | LFW    | CALFW  | CPLFW  | CFP-FP | AgeDB-30 |
+| --------------- | -------- | ------ | ------ | ----- | ------ | ------ | ------ | ------ | -------- |
+| `XXS` :material-check-circle: | EdgeNeXt | 1.24M  | 94     | ~5 MB | 99.57% | 94.83% | 90.27% | 93.63% | 94.92%   |
+| `XS_GAMMA_06`   | EdgeNeXt | 1.77M  | 154    | ~7 MB | 99.73% | 95.28% | 91.58% | 94.71% | 96.08%   |
+| `S_GAMMA_05`    | EdgeNeXt | 3.65M  | 306    | ~14 MB | 99.78% | 95.55% | 92.48% | 95.74% | 97.03%  |
+| `BASE`          | EdgeNeXt | 18.2M  | 1399   | ~70 MB | 99.83% | 96.07% | 93.75% | 97.01% | 97.60%  |
+
+!!! info "Training Data & Reference"
+    **Paper**: [EdgeFace: Efficient Face Recognition Model for Edge Devices](https://arxiv.org/abs/2307.01838v2) (IEEE T-BIOM 2024)
+
+    **Source**: [github.com/otroshi/edgeface](https://github.com/otroshi/edgeface) | [github.com/yakhyo/edgeface-onnx](https://github.com/yakhyo/edgeface-onnx)
+
+---
+
 ## Facial Landmark Models

 ### 106-Point Landmark Detection
--- a/docs/modules/attributes.md
+++ b/docs/modules/attributes.md
@@ -2,6 +2,11 @@

 Facial attribute analysis for age, gender, race, and emotion detection.

+<figure markdown="span">
+  ![Age & Gender Prediction](https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/age_gender.jpg){ width="100%" }
+  <figcaption>Age and gender prediction with detection bounding boxes</figcaption>
+</figure>
+
 ---

 ## Available Models
--- a/docs/modules/detection.md
+++ b/docs/modules/detection.md
@@ -2,6 +2,11 @@

 Face detection is the first step in any face analysis pipeline. UniFace provides four detection models.

+<figure markdown="span">
+  ![Face Detection](https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/detection.jpg){ width="100%" }
+  <figcaption>SCRFD detection with corner-style bounding boxes and 5-point landmarks</figcaption>
+</figure>
+
 ---

 ## Available Models
--- a/docs/modules/gaze.md
+++ b/docs/modules/gaze.md
@@ -2,6 +2,11 @@

 Gaze estimation predicts where a person is looking (pitch and yaw angles).

+<figure markdown="span">
+  ![Gaze Estimation](https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/gaze.jpg){ width="100%" }
+  <figcaption>Gaze direction arrows with pitch/yaw angle labels</figcaption>
+</figure>
+
 ---

 ## Available Models
--- a/docs/modules/headpose.md
+++ b/docs/modules/headpose.md
@@ -2,6 +2,11 @@

 Head pose estimation predicts the 3D orientation of a person's head (pitch, yaw, and roll angles).

+<figure markdown="span">
+  ![Head Pose Estimation](https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/headpose.jpg){ width="100%" }
+  <figcaption>3D head pose visualization with pitch, yaw, and roll angles</figcaption>
+</figure>
+
 ---

 ## Available Models
--- a/docs/modules/landmarks.md
+++ b/docs/modules/landmarks.md
@@ -2,6 +2,11 @@

 Facial landmark detection provides precise localization of facial features.

+<figure markdown="span">
+  ![106-Point Landmarks](https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/landmarks.jpg){ width="50%" }
+  <figcaption>106-point facial landmark localization</figcaption>
+</figure>
+
 ---

 ## Available Models
--- a/docs/modules/parsing.md
+++ b/docs/modules/parsing.md
@@ -2,6 +2,16 @@

 Face parsing segments faces into semantic components or face regions.

+<figure markdown="span">
+  ![Face Parsing](https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/parsing.jpg){ width="80%" }
+  <figcaption>BiSeNet face parsing with 19 semantic component classes</figcaption>
+</figure>
+
+<figure markdown="span">
+  ![Face Segmentation](https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/segmentation.jpg){ width="80%" }
+  <figcaption>XSeg face region segmentation mask</figcaption>
+</figure>
+
 ---

 ## Available Models
--- a/docs/modules/privacy.md
+++ b/docs/modules/privacy.md
@@ -2,6 +2,11 @@

 Face anonymization protects privacy by blurring or obscuring faces in images and videos.

+<figure markdown="span">
+  ![Face Anonymization](https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/anonymization.jpg){ width="100%" }
+  <figcaption>Five anonymization methods: pixelate, gaussian, blackout, elliptical, and median</figcaption>
+</figure>
+
 ---

 ## Available Methods
--- a/docs/modules/recognition.md
+++ b/docs/modules/recognition.md
@@ -2,6 +2,11 @@

 Face recognition extracts embeddings for identity verification and face search.

+<figure markdown="span">
+  ![Face Verification](https://raw.githubusercontent.com/yakhyo/uniface/main/assets/demos/verification.jpg){ width="80%" }
+  <figcaption>Pairwise face verification with cosine similarity scores</figcaption>
+</figure>
+
 ---

 ## Available Models
@@ -10,6 +15,7 @@ Face recognition extracts embeddings for identity verification and face search.
 |-------|----------|------|---------------|
 | **AdaFace** | IR-18/IR-101 | 92-249 MB | 512 |
 | **ArcFace** | MobileNet/ResNet | 8-166 MB | 512 |
+| **EdgeFace** | EdgeNeXt/LoRA | 5-70 MB | 512 |
 | **MobileFace** | MobileNet V2/V3 | 1-10 MB | 512 |
 | **SphereFace** | Sphere20/36 | 50-92 MB | 512 |

@@ -113,6 +119,64 @@ recognizer = ArcFace(providers=['CPUExecutionProvider'])

 ---

+## EdgeFace
+
+Efficient face recognition designed for edge devices, using an EdgeNeXt backbone with optional LoRA low-rank compression. Competition-winning entry (compact track) at EFaR 2023, IJCB.
+
+### Basic Usage
+
+```python
+from uniface.detection import RetinaFace
+from uniface.recognition import EdgeFace
+
+detector = RetinaFace()
+recognizer = EdgeFace()
+
+# Detect face
+faces = detector.detect(image)
+
+# Extract embedding
+if faces:
+    embedding = recognizer.get_normalized_embedding(image, faces[0].landmarks)
+    print(f"Embedding shape: {embedding.shape}")  # (512,)
+```
+
+### Model Variants
+
+```python
+from uniface.recognition import EdgeFace
+from uniface.constants import EdgeFaceWeights
+
+# Ultra-compact (default)
+recognizer = EdgeFace(model_name=EdgeFaceWeights.XXS)
+
+# Compact with LoRA
+recognizer = EdgeFace(model_name=EdgeFaceWeights.XS_GAMMA_06)
+
+# Small with LoRA
+recognizer = EdgeFace(model_name=EdgeFaceWeights.S_GAMMA_05)
+
+# Full-size
+recognizer = EdgeFace(model_name=EdgeFaceWeights.BASE)
+
+# Force CPU execution
+recognizer = EdgeFace(providers=['CPUExecutionProvider'])
+```
+
+| Variant | Params | MFLOPs | Size | LFW | CALFW | CPLFW | CFP-FP | AgeDB-30 |
+|---------|--------|--------|------|-----|-------|-------|--------|----------|
+| **XXS** :material-check-circle: | 1.24M | 94 | ~5 MB | 99.57% | 94.83% | 90.27% | 93.63% | 94.92% |
+| XS_GAMMA_06 | 1.77M | 154 | ~7 MB | 99.73% | 95.28% | 91.58% | 94.71% | 96.08% |
+| S_GAMMA_05 | 3.65M | 306 | ~14 MB | 99.78% | 95.55% | 92.48% | 95.74% | 97.03% |
+| BASE | 18.2M | 1399 | ~70 MB | 99.83% | 96.07% | 93.75% | 97.01% | 97.60% |
+
+!!! info "Reference"
+    **Paper**: [EdgeFace: Efficient Face Recognition Model for Edge Devices](https://arxiv.org/abs/2307.01838v2) (IEEE T-BIOM 2024)
+
+    **Source**: [github.com/otroshi/edgeface](https://github.com/otroshi/edgeface)
+
+---
+
 ## MobileFace

 Lightweight face recognition models with MobileNet backbones.
@@ -287,9 +351,10 @@ else:
 ```python
 from uniface.recognition import create_recognizer

-# Available methods: 'arcface', 'adaface', 'mobileface', 'sphereface'
+# Available methods: 'arcface', 'adaface', 'edgeface', 'mobileface', 'sphereface'
 recognizer = create_recognizer('arcface')
 recognizer = create_recognizer('adaface')
+recognizer = create_recognizer('edgeface')
 ```

 ---
--- a/examples/01_face_detection.ipynb
+++ b/examples/01_face_detection.ipynb
--- a/examples/02_face_alignment.ipynb
+++ b/examples/02_face_alignment.ipynb
--- a/examples/03_face_verification.ipynb
+++ b/examples/03_face_verification.ipynb
--- a/examples/04_face_search.ipynb
+++ b/examples/04_face_search.ipynb
--- a/examples/05_face_analyzer.ipynb
+++ b/examples/05_face_analyzer.ipynb
--- a/examples/06_face_parsing.ipynb
+++ b/examples/06_face_parsing.ipynb
--- a/examples/07_face_anonymization.ipynb
+++ b/examples/07_face_anonymization.ipynb
--- a/examples/08_gaze_estimation.ipynb
+++ b/examples/08_gaze_estimation.ipynb
--- a/examples/09_face_segmentation.ipynb
+++ b/examples/09_face_segmentation.ipynb
--- a/examples/10_face_vector_store.ipynb
+++ b/examples/10_face_vector_store.ipynb
--- a/examples/11_head_pose_estimation.ipynb
+++ b/examples/11_head_pose_estimation.ipynb
--- a/examples/12_face_recognition.ipynb
+++ b/examples/12_face_recognition.ipynb
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "uniface"
-version = "3.3.0"
+version = "3.4.0"
 description = "UniFace: A Comprehensive Library for Face Detection, Recognition, Tracking, Landmark Analysis, Face Parsing, Gaze Estimation, Age, and Gender Detection"
 readme = "README.md"
 license = "MIT"
--- a/tests/test_factory.py
+++ b/tests/test_factory.py
@@ -91,6 +91,12 @@ def test_create_recognizer_sphereface():
    assert recognizer is not None, 'Failed to create SphereFace recognizer'


+def test_create_recognizer_edgeface():
+    """Test creating an EdgeFace recognizer using factory function."""
+    recognizer = create_recognizer('edgeface')
+    assert recognizer is not None, 'Failed to create EdgeFace recognizer'
+
+
 def test_create_recognizer_invalid_method():
    """
    Test that invalid recognizer method raises an error.
--- a/tests/test_recognition.py
+++ b/tests/test_recognition.py
@@ -8,7 +8,7 @@ from __future__ import annotations
 import numpy as np
 import pytest

-from uniface.recognition import ArcFace, MobileFace, SphereFace
+from uniface.recognition import ArcFace, EdgeFace, MobileFace, SphereFace


@pytest.fixture
@@ -35,6 +35,12 @@ def sphereface_model():
    return SphereFace()


+@pytest.fixture
+def edgeface_model():
+    """Fixture to initialize the EdgeFace model for testing."""
+    return EdgeFace()
+
+
@pytest.fixture
 def mock_aligned_face():
    """
@@ -176,6 +182,45 @@ def test_sphereface_normalized_embedding(sphereface_model, mock_landmarks):
    assert np.isclose(norm, 1.0, atol=1e-5), f'Normalized embedding should have norm 1.0, got {norm}'


+# EdgeFace Tests
+def test_edgeface_initialization(edgeface_model):
+    """Test that the EdgeFace model initializes correctly."""
+    assert edgeface_model is not None, 'EdgeFace model initialization failed.'
+
+
+def test_edgeface_embedding_shape(edgeface_model, mock_aligned_face):
+    """Test that EdgeFace produces embeddings with the correct shape."""
+    embedding = edgeface_model.get_embedding(mock_aligned_face)
+
+    assert embedding.shape[1] == 512, f'Expected 512-dim embedding, got {embedding.shape[1]}'
+    assert embedding.shape[0] == 1, 'Embedding should have batch dimension of 1'
+
+
+def test_edgeface_normalized_embedding(edgeface_model, mock_landmarks):
+    """Test that EdgeFace normalized embeddings have unit length."""
+    mock_image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)
+
+    embedding = edgeface_model.get_normalized_embedding(mock_image, mock_landmarks)
+
+    assert embedding.shape == (512,), f'Expected shape (512,), got {embedding.shape}'
+    norm = np.linalg.norm(embedding)
+    assert np.isclose(norm, 1.0, atol=1e-5), f'Normalized embedding should have norm 1.0, got {norm}'
+
+
+def test_edgeface_embedding_dtype(edgeface_model, mock_aligned_face):
+    """Test that EdgeFace embeddings have the correct data type."""
+    embedding = edgeface_model.get_embedding(mock_aligned_face)
+    assert embedding.dtype == np.float32, f'Expected float32, got {embedding.dtype}'
+
+
+def test_edgeface_consistency(edgeface_model, mock_aligned_face):
+    """Test that the same input produces the same EdgeFace embedding."""
+    embedding1 = edgeface_model.get_embedding(mock_aligned_face)
+    embedding2 = edgeface_model.get_embedding(mock_aligned_face)
+
+    assert np.allclose(embedding1, embedding2), 'Same input should produce same embedding'
+
+
 # Cross-model comparison tests
 def test_different_models_different_embeddings(arcface_model, mobileface_model, mock_aligned_face):
    """
--- a/tools/download_model.py
+++ b/tools/download_model.py
@@ -1,9 +1,11 @@
 import argparse

 from uniface.constants import (
+    AdaFaceWeights,
    AgeGenderWeights,
    ArcFaceWeights,
    DDAMFNWeights,
+    EdgeFaceWeights,
    HeadPoseWeights,
    LandmarkWeights,
    MobileFaceWeights,
@@ -15,9 +17,11 @@ from uniface.model_store import verify_model_weights

 MODEL_TYPES = {
    'retinaface': RetinaFaceWeights,
-    'sphereface': SphereFaceWeights,
-    'mobileface': MobileFaceWeights,
+    'adaface': AdaFaceWeights,
    'arcface': ArcFaceWeights,
+    'edgeface': EdgeFaceWeights,
+    'mobileface': MobileFaceWeights,
+    'sphereface': SphereFaceWeights,
    'scrfd': SCRFDWeights,
    'ddamfn': DDAMFNWeights,
    'agegender': AgeGenderWeights,
--- a/tools/recognize.py
+++ b/tools/recognize.py
@@ -16,16 +16,22 @@ import numpy as np

 from uniface.detection import SCRFD, RetinaFace
 from uniface.face_utils import compute_similarity
-from uniface.recognition import ArcFace, MobileFace, SphereFace
+from uniface.recognition import AdaFace, ArcFace, EdgeFace, MobileFace, SphereFace
+
+RECOGNIZERS = {
+    'arcface': ArcFace,
+    'adaface': AdaFace,
+    'edgeface': EdgeFace,
+    'mobileface': MobileFace,
+    'sphereface': SphereFace,
+}


 def get_recognizer(name: str):
-    if name == 'arcface':
-        return ArcFace()
-    elif name == 'mobileface':
-        return MobileFace()
-    else:
-        return SphereFace()
+    cls = RECOGNIZERS.get(name)
+    if cls is None:
+        raise ValueError(f"Unknown recognizer: '{name}'. Available: {list(RECOGNIZERS)}")
+    return cls()


 def run_inference(detector, recognizer, image_path: str):
@@ -91,7 +97,7 @@ def main():
        '--recognizer',
        type=str,
        default='arcface',
-        choices=['arcface', 'mobileface', 'sphereface'],
+        choices=list(RECOGNIZERS),
    )
    args = parser.parse_args()

--- a/uniface/init.py
+++ b/uniface/init.py
@@ -15,7 +15,7 @@

 This library provides unified APIs for:
 - Face detection (RetinaFace, SCRFD, YOLOv5Face, YOLOv8Face)
- Face recognition (AdaFace, ArcFace, MobileFace, SphereFace)
+- Face recognition (AdaFace, ArcFace, EdgeFace, MobileFace, SphereFace)
 - Face tracking (ByteTrack with Kalman filtering)
 - Facial landmarks (106-point detection)
 - Face parsing (semantic segmentation)
@@ -30,7 +30,7 @@ from __future__ import annotations

 __license__ = 'MIT'
 __author__ = 'Yakhyokhuja Valikhujaev'
-__version__ = '3.3.0'
+__version__ = '3.4.0'

 import contextlib

@@ -53,7 +53,7 @@ from .headpose import HeadPose, create_head_pose_estimator
 from .landmark import Landmark106, create_landmarker
 from .parsing import BiSeNet, XSeg, create_face_parser
 from .privacy import BlurFace
-from .recognition import AdaFace, ArcFace, MobileFace, SphereFace, create_recognizer
+from .recognition import AdaFace, ArcFace, EdgeFace, MobileFace, SphereFace, create_recognizer
 from .spoofing import MiniFASNet, create_spoofer
 from .tracking import BYTETracker
 from .types import AttributeResult, EmotionResult, Face, GazeResult, HeadPoseResult, SpoofingResult
@@ -87,6 +87,7 @@ __all__ = [
    # Recognition models
    'AdaFace',
    'ArcFace',
+    'EdgeFace',
    'MobileFace',
    'SphereFace',
    # Landmark models
--- a/uniface/constants.py
+++ b/uniface/constants.py
@@ -57,6 +57,18 @@ class AdaFaceWeights(str, Enum):
    IR_18  = "adaface_ir_18"
    IR_101 = "adaface_ir_101"

+class EdgeFaceWeights(str, Enum):
+    """
+    EdgeFace: Efficient Face Recognition Model for Edge Devices.
+    Based on EdgeNeXt backbone with optional LoRA low-rank compression.
+    All models output 512-D embeddings from 112x112 aligned face crops.
+    https://github.com/yakhyo/edgeface-onnx
+    """
+    XXS         = "edgeface_xxs"
+    XS_GAMMA_06 = "edgeface_xs_gamma_06"
+    S_GAMMA_05  = "edgeface_s_gamma_05"
+    BASE        = "edgeface_base"
+
 class RetinaFaceWeights(str, Enum):
    """
    Trained on WIDER FACE dataset.
@@ -278,6 +290,24 @@ MODEL_REGISTRY: dict[Enum, ModelInfo] = {
        sha256='f2eb07d03de0af560a82e1214df799fec5e09375d43521e2868f9dc387e5a43e'
    ),

+    # EdgeFace
+    EdgeFaceWeights.XXS: ModelInfo(
+        url='https://github.com/yakhyo/edgeface-onnx/releases/download/weights/edgeface_xxs.onnx',
+        sha256='dc674de4cbc77fa0bf9a82d5149558ab8581d82a2cd3bb60f28fd1a5d3ff8a2f'
+    ),
+    EdgeFaceWeights.XS_GAMMA_06: ModelInfo(
+        url='https://github.com/yakhyo/edgeface-onnx/releases/download/weights/edgeface_xs_gamma_06.onnx',
+        sha256='9206e2eb13a2761d7b5b76e13016d4b9acd3fa3535a9a09939f3adacd139a5ff'
+    ),
+    EdgeFaceWeights.S_GAMMA_05: ModelInfo(
+        url='https://github.com/yakhyo/edgeface-onnx/releases/download/weights/edgeface_s_gamma_05.onnx',
+        sha256='b850767cf791bda585600b5c4c7d7432b2f998ccd862caae34ef1afa967d2e54'
+    ),
+    EdgeFaceWeights.BASE: ModelInfo(
+        url='https://github.com/yakhyo/edgeface-onnx/releases/download/weights/edgeface_base.onnx',
+        sha256='b56942f072c67385f44734b9458b0ccc4a2226888a113f77e0c802ad0c77b4c3'
+    ),
+
    # SCRFD
    SCRFDWeights.SCRFD_10G_KPS: ModelInfo(
        url='https://github.com/yakhyo/uniface/releases/download/weights/scrfd_10g_kps.onnx',
--- a/uniface/recognition/init.py
+++ b/uniface/recognition/init.py
@@ -4,8 +4,11 @@


 from .adaface import AdaFace
+from .arcface import ArcFace
 from .base import BaseRecognizer
-from .models import ArcFace, MobileFace, SphereFace
+from .edgeface import EdgeFace
+from .mobileface import MobileFace
+from .sphereface import SphereFace


 def create_recognizer(method: str = 'arcface', **kwargs) -> BaseRecognizer:
@@ -18,7 +21,7 @@ def create_recognizer(method: str = 'arcface', **kwargs) -> BaseRecognizer:

    Args:
        method (str): The recognition method to use.
-            Options: 'arcface' (default), 'adaface', 'mobileface', 'sphereface'.
+            Options: 'arcface' (default), 'adaface', 'edgeface', 'mobileface', 'sphereface'.
        **kwargs: Model-specific parameters passed to the recognizer's constructor.
            For example, `model_name` can be used to select a specific
            pre-trained weight from the available enums (e.g., `ArcFaceWeights.MNET`).
@@ -43,6 +46,10 @@ def create_recognizer(method: str = 'arcface', **kwargs) -> BaseRecognizer:

        >>> # Create a SphereFace recognizer
        >>> recognizer = create_recognizer('sphereface')
+
+        >>> # Create an EdgeFace recognizer
+        >>> from uniface.constants import EdgeFaceWeights
+        >>> recognizer = create_recognizer('edgeface', model_name=EdgeFaceWeights.XXS)
    """
    method = method.lower()

@@ -50,13 +57,15 @@ def create_recognizer(method: str = 'arcface', **kwargs) -> BaseRecognizer:
        return ArcFace(**kwargs)
    elif method == 'adaface':
        return AdaFace(**kwargs)
+    elif method == 'edgeface':
+        return EdgeFace(**kwargs)
    elif method == 'mobileface':
        return MobileFace(**kwargs)
    elif method == 'sphereface':
        return SphereFace(**kwargs)
    else:
-        available = ['arcface', 'adaface', 'mobileface', 'sphereface']
+        available = ['arcface', 'adaface', 'edgeface', 'mobileface', 'sphereface']
        raise ValueError(f"Unsupported method: '{method}'. Available: {available}")


-__all__ = ['AdaFace', 'ArcFace', 'BaseRecognizer', 'MobileFace', 'SphereFace', 'create_recognizer']
+__all__ = ['AdaFace', 'ArcFace', 'BaseRecognizer', 'EdgeFace', 'MobileFace', 'SphereFace', 'create_recognizer']
--- a/uniface/recognition/arcface.py
+++ b/uniface/recognition/arcface.py
@@ -0,0 +1,49 @@
+# Copyright 2025-2026 Yakhyokhuja Valikhujaev
+# Author: Yakhyokhuja Valikhujaev
+# GitHub: https://github.com/yakhyo
+
+from __future__ import annotations
+
+from uniface.constants import ArcFaceWeights
+from uniface.model_store import verify_model_weights
+
+from .base import BaseRecognizer, PreprocessConfig
+
+__all__ = ['ArcFace']
+
+
+class ArcFace(BaseRecognizer):
+    """ArcFace model for robust face recognition.
+
+    This class provides a concrete implementation of the BaseRecognizer,
+    pre-configured for ArcFace models. It handles the loading of specific
+    ArcFace weights and sets up the appropriate default preprocessing.
+
+    Args:
+        model_name (ArcFaceWeights): The specific ArcFace model variant to use.
+            Defaults to `ArcFaceWeights.MNET`.
+        preprocessing (Optional[PreprocessConfig]): An optional custom preprocessing
+            configuration. If None, a default config for ArcFace is used.
+        providers (list[str] | None): ONNX Runtime execution providers. If None, auto-detects
+            the best available provider. Example: ['CPUExecutionProvider'] to force CPU.
+
+    Example:
+        >>> from uniface.recognition import ArcFace
+        >>> recognizer = ArcFace()
+        >>> # embedding = recognizer.get_normalized_embedding(image, landmarks)
+
+    Reference:
+        https://arxiv.org/abs/1801.07698
+        https://github.com/yakhyo/face-reidentification
+    """
+
+    def __init__(
+        self,
+        model_name: ArcFaceWeights = ArcFaceWeights.MNET,
+        preprocessing: PreprocessConfig | None = None,
+        providers: list[str] | None = None,
+    ) -> None:
+        if preprocessing is None:
+            preprocessing = PreprocessConfig(input_mean=127.5, input_std=127.5, input_size=(112, 112))
+        model_path = verify_model_weights(model_name)
+        super().__init__(model_path=model_path, preprocessing=preprocessing, providers=providers)
--- a/uniface/recognition/edgeface.py
+++ b/uniface/recognition/edgeface.py
@@ -0,0 +1,57 @@
+# Copyright 2025-2026 Yakhyokhuja Valikhujaev
+# Author: Yakhyokhuja Valikhujaev
+# GitHub: https://github.com/yakhyo
+
+from __future__ import annotations
+
+from uniface.constants import EdgeFaceWeights
+from uniface.model_store import verify_model_weights
+
+from .base import BaseRecognizer, PreprocessConfig
+
+__all__ = ['EdgeFace']
+
+
+class EdgeFace(BaseRecognizer):
+    """EdgeFace: Efficient Face Recognition Model for Edge Devices.
+
+    EdgeFace uses an EdgeNeXt backbone with optional LoRA low-rank
+    compression, offering a strong accuracy-efficiency trade-off for
+    deployment on resource-constrained hardware. Competition-winning
+    entry (compact track) at EFaR 2023, IJCB.
+
+    All variants output 512-D embeddings from 112x112 aligned face crops.
+
+    Args:
+        model_name (EdgeFaceWeights): The specific EdgeFace model variant to use.
+            - XXS: Ultra-compact (1.24M params, ~5 MB)
+            - XS_GAMMA_06: Compact with LoRA (1.77M params, ~7 MB)
+            - S_GAMMA_05: Small with LoRA (3.65M params, ~14 MB)
+            - BASE: Full-size model (18.2M params, ~70 MB)
+            Defaults to `EdgeFaceWeights.XXS`.
+        preprocessing (Optional[PreprocessConfig]): An optional custom preprocessing
+            configuration. If None, a default config for EdgeFace is used.
+        providers (list[str] | None): ONNX Runtime execution providers. If None, auto-detects
+            the best available provider. Example: ['CPUExecutionProvider'] to force CPU.
+
+    Example:
+        >>> from uniface.recognition import EdgeFace
+        >>> recognizer = EdgeFace()
+        >>> # embedding = recognizer.get_normalized_embedding(image, landmarks)
+
+    Reference:
+        https://arxiv.org/abs/2307.01838v2
+        https://github.com/otroshi/edgeface
+        https://github.com/yakhyo/edgeface-onnx
+    """
+
+    def __init__(
+        self,
+        model_name: EdgeFaceWeights = EdgeFaceWeights.XXS,
+        preprocessing: PreprocessConfig | None = None,
+        providers: list[str] | None = None,
+    ) -> None:
+        if preprocessing is None:
+            preprocessing = PreprocessConfig(input_mean=127.5, input_std=127.5, input_size=(112, 112))
+        model_path = verify_model_weights(model_name)
+        super().__init__(model_path=model_path, preprocessing=preprocessing, providers=providers)
--- a/uniface/recognition/mobileface.py
+++ b/uniface/recognition/mobileface.py
@@ -0,0 +1,49 @@
+# Copyright 2025-2026 Yakhyokhuja Valikhujaev
+# Author: Yakhyokhuja Valikhujaev
+# GitHub: https://github.com/yakhyo
+
+from __future__ import annotations
+
+from uniface.constants import MobileFaceWeights
+from uniface.model_store import verify_model_weights
+
+from .base import BaseRecognizer, PreprocessConfig
+
+__all__ = ['MobileFace']
+
+
+class MobileFace(BaseRecognizer):
+    """Lightweight MobileFaceNet model for fast face recognition.
+
+    This class provides a concrete implementation of the BaseRecognizer,
+    pre-configured for MobileFaceNet models. It is optimized for speed,
+    making it suitable for edge devices.
+
+    Args:
+        model_name (MobileFaceWeights): The specific MobileFaceNet model variant to use.
+            Defaults to `MobileFaceWeights.MNET_V2`.
+        preprocessing (Optional[PreprocessConfig]): An optional custom preprocessing
+            configuration. If None, a default config for MobileFaceNet is used.
+        providers (list[str] | None): ONNX Runtime execution providers. If None, auto-detects
+            the best available provider. Example: ['CPUExecutionProvider'] to force CPU.
+
+    Example:
+        >>> from uniface.recognition import MobileFace
+        >>> recognizer = MobileFace()
+        >>> # embedding = recognizer.get_normalized_embedding(image, landmarks)
+
+    Reference:
+        https://arxiv.org/abs/1804.07573
+        https://github.com/yakhyo/face-recognition
+    """
+
+    def __init__(
+        self,
+        model_name: MobileFaceWeights = MobileFaceWeights.MNET_V2,
+        preprocessing: PreprocessConfig | None = None,
+        providers: list[str] | None = None,
+    ) -> None:
+        if preprocessing is None:
+            preprocessing = PreprocessConfig(input_mean=127.5, input_std=127.5, input_size=(112, 112))
+        model_path = verify_model_weights(model_name)
+        super().__init__(model_path=model_path, preprocessing=preprocessing, providers=providers)
--- a/uniface/recognition/models.py
+++ b/uniface/recognition/models.py
@@ -1,112 +0,0 @@
-# Copyright 2025-2026 Yakhyokhuja Valikhujaev
-# Author: Yakhyokhuja Valikhujaev
-# GitHub: https://github.com/yakhyo
-
-from __future__ import annotations
-
-from uniface.constants import ArcFaceWeights, MobileFaceWeights, SphereFaceWeights
-from uniface.model_store import verify_model_weights
-
-from .base import BaseRecognizer, PreprocessConfig
-
-__all__ = ['ArcFace', 'MobileFace', 'SphereFace']
-
-
-class ArcFace(BaseRecognizer):
-    """ArcFace model for robust face recognition.
-
-    This class provides a concrete implementation of the BaseRecognizer,
-    pre-configured for ArcFace models. It handles the loading of specific
-    ArcFace weights and sets up the appropriate default preprocessing.
-
-    Args:
-        model_name (ArcFaceWeights): The specific ArcFace model variant to use.
-            Defaults to `ArcFaceWeights.MNET`.
-        preprocessing (Optional[PreprocessConfig]): An optional custom preprocessing
-            configuration. If None, a default config for ArcFace is used.
-        providers (list[str] | None): ONNX Runtime execution providers. If None, auto-detects
-            the best available provider. Example: ['CPUExecutionProvider'] to force CPU.
-
-    Example:
-        >>> from uniface.recognition import ArcFace
-        >>> recognizer = ArcFace()
-        >>> # embedding = recognizer.get_normalized_embedding(image, landmarks)
-    """
-
-    def __init__(
-        self,
-        model_name: ArcFaceWeights = ArcFaceWeights.MNET,
-        preprocessing: PreprocessConfig | None = None,
-        providers: list[str] | None = None,
-    ) -> None:
-        if preprocessing is None:
-            preprocessing = PreprocessConfig(input_mean=127.5, input_std=127.5, input_size=(112, 112))
-        model_path = verify_model_weights(model_name)
-        super().__init__(model_path=model_path, preprocessing=preprocessing, providers=providers)
-
-
-class MobileFace(BaseRecognizer):
-    """Lightweight MobileFaceNet model for fast face recognition.
-
-    This class provides a concrete implementation of the BaseRecognizer,
-    pre-configured for MobileFaceNet models. It is optimized for speed,
-    making it suitable for edge devices.
-
-    Args:
-        model_name (MobileFaceWeights): The specific MobileFaceNet model variant to use.
-            Defaults to `MobileFaceWeights.MNET_V2`.
-        preprocessing (Optional[PreprocessConfig]): An optional custom preprocessing
-            configuration. If None, a default config for MobileFaceNet is used.
-        providers (list[str] | None): ONNX Runtime execution providers. If None, auto-detects
-            the best available provider. Example: ['CPUExecutionProvider'] to force CPU.
-
-    Example:
-        >>> from uniface.recognition import MobileFace
-        >>> recognizer = MobileFace()
-        >>> # embedding = recognizer.get_normalized_embedding(image, landmarks)
-    """
-
-    def __init__(
-        self,
-        model_name: MobileFaceWeights = MobileFaceWeights.MNET_V2,
-        preprocessing: PreprocessConfig | None = None,
-        providers: list[str] | None = None,
-    ) -> None:
-        if preprocessing is None:
-            preprocessing = PreprocessConfig(input_mean=127.5, input_std=127.5, input_size=(112, 112))
-        model_path = verify_model_weights(model_name)
-        super().__init__(model_path=model_path, preprocessing=preprocessing, providers=providers)
-
-
-class SphereFace(BaseRecognizer):
-    """SphereFace model using angular margin for face recognition.
-
-    This class provides a concrete implementation of the BaseRecognizer,
-    pre-configured for SphereFace models, which were among the first to
-    introduce angular margin loss functions.
-
-    Args:
-        model_name (SphereFaceWeights): The specific SphereFace model variant to use.
-            Defaults to `SphereFaceWeights.SPHERE20`.
-        preprocessing (Optional[PreprocessConfig]): An optional custom preprocessing
-            configuration. If None, a default config for SphereFace is used.
-        providers (list[str] | None): ONNX Runtime execution providers. If None, auto-detects
-            the best available provider. Example: ['CPUExecutionProvider'] to force CPU.
-
-    Example:
-        >>> from uniface.recognition import SphereFace
-        >>> recognizer = SphereFace()
-        >>> # embedding = recognizer.get_normalized_embedding(image, landmarks)
-    """
-
-    def __init__(
-        self,
-        model_name: SphereFaceWeights = SphereFaceWeights.SPHERE20,
-        preprocessing: PreprocessConfig | None = None,
-        providers: list[str] | None = None,
-    ) -> None:
-        if preprocessing is None:
-            preprocessing = PreprocessConfig(input_mean=127.5, input_std=127.5, input_size=(112, 112))
-
-        model_path = verify_model_weights(model_name)
-        super().__init__(model_path=model_path, preprocessing=preprocessing, providers=providers)
--- a/uniface/recognition/sphereface.py
+++ b/uniface/recognition/sphereface.py
@@ -0,0 +1,50 @@
+# Copyright 2025-2026 Yakhyokhuja Valikhujaev
+# Author: Yakhyokhuja Valikhujaev
+# GitHub: https://github.com/yakhyo
+
+from __future__ import annotations
+
+from uniface.constants import SphereFaceWeights
+from uniface.model_store import verify_model_weights
+
+from .base import BaseRecognizer, PreprocessConfig
+
+__all__ = ['SphereFace']
+
+
+class SphereFace(BaseRecognizer):
+    """SphereFace model using angular margin for face recognition.
+
+    This class provides a concrete implementation of the BaseRecognizer,
+    pre-configured for SphereFace models, which were among the first to
+    introduce angular margin loss functions.
+
+    Args:
+        model_name (SphereFaceWeights): The specific SphereFace model variant to use.
+            Defaults to `SphereFaceWeights.SPHERE20`.
+        preprocessing (Optional[PreprocessConfig]): An optional custom preprocessing
+            configuration. If None, a default config for SphereFace is used.
+        providers (list[str] | None): ONNX Runtime execution providers. If None, auto-detects
+            the best available provider. Example: ['CPUExecutionProvider'] to force CPU.
+
+    Example:
+        >>> from uniface.recognition import SphereFace
+        >>> recognizer = SphereFace()
+        >>> # embedding = recognizer.get_normalized_embedding(image, landmarks)
+
+    Reference:
+        https://arxiv.org/abs/1704.08063
+        https://github.com/yakhyo/face-recognition
+    """
+
+    def __init__(
+        self,
+        model_name: SphereFaceWeights = SphereFaceWeights.SPHERE20,
+        preprocessing: PreprocessConfig | None = None,
+        providers: list[str] | None = None,
+    ) -> None:
+        if preprocessing is None:
+            preprocessing = PreprocessConfig(input_mean=127.5, input_std=127.5, input_size=(112, 112))
+
+        model_path = verify_model_weights(model_name)
+        super().__init__(model_path=model_path, preprocessing=preprocessing, providers=providers)