Model reference · open weights
LVFace is an open-weight embedding model from bytedance-research. LVFace (BF16) weighs 1.9 GB; the smallest configuration that runs it is RTX 3060 12 GB.
Summary of the bytedance-research/LVFace model card, 2026-10-01
What it is
| Released by | bytedance-research |
|---|---|
| Released | 2025-08-10 |
| VRAM | 1.9 GB for the weights |
What it runs on
| Card | Runs | Memory |
|---|---|---|
| RTX 3060 12 GB | fits | 11.6 GB |
| RTX 4060 Ti 16 GB | fits | 15.4 GB |
| RTX 3090 24 GB | fits | 23.4 GB |
| RTX 4090 24 GB | fits | 23.4 GB |
| RTX 5090 32 GB | fits | 31.0 GB |
| L40S 48 GB | fits | 44.0 GB |
| A100 80 GB | fits | 78.2 GB |
| H100 80 GB | fits | 78.1 GB |
| RTX PRO 6000 Blackwell 96 GB | fits | 93.8 GB |
| DGX Spark (GB10) 128 GB unified | fits | 107 GB |
| H200 141 GB | fits | 138 GB |
| B200 180 GB | fits | 176 GB |
From the model card
src="https://img.shields.io/badge/HuggingFace-Model-yellow?logo=huggingface&logoColor=yellow" alt="Model" /> src="https://img.shields.io/badge/Code-GitHub-orange?logo=github&logoColor=white" alt="Code" /> src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License" />
This is the official PyTorch implementation for the inference of LVFace. Drawing inspiration from the massive data support, multi-stage training paradigm, and Transformer architecture of large-model technology, this method, based on Large Vision Transformer, has carried out progressive optimization of the face clustering space through multiple stages on massive datasets.
All required dependencies are listed in requirements.txt:
onnxruntime-gpu==1.19.2
torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124
scikit-image
insightface
numpy==1.23
Install all dependencies with a single command: pip install -r requirements.txt
Test datasets for inference validation can be downloaded from the following sources:
Pretrained model weights for inference are available below in both ONNX and PyTorch (.pt) formats:
| Training Data | Model | IJB-C(1e-6) | IJB-C(1e-5) | IJB-C(1e-4) | IJB-B(1e-4) | Download |
|---|---|---|---|---|---|---|
| Glint360K | LVFace-T | 88.53 | 95.63 | 96.67 | 95.41 | HuggingFace |
| Glint360K | LVFace-S | 90.06 | 96.52 | 97.31 | 96.14 | HuggingFace |
| Glint360K | LVFace-B | 90.06 | 97.00 | 97.70 | 96.51 | HuggingFace |
| Glint360K | LVFace-L | 89.51 | 97.02 | 97.66 | 96.51 | HuggingFace |
| WebFace42M | LVFace-B | - | - | - | - | come soon |
1. Installation & Environment Setup
First, clone the repository and navigate to the project directory:
# Clone the LVFace repository
git clone https://github.com/bytedance/LVFace.git
# Enter the project directory
cd LVFace
Then install all required dependencies using the provided requirements.txt:
# Install dependencies
pip install -r requirements.txt
2. Download Pretrained Models
Download the ONNX-format pretrained weights from the LVFace Pretrained Models section, then place them in a directory (e.g., ./LVFace_model/).
3. Run Inference
Execute the inference_onnx.py script to perform feature extraction and similarity calculation. A complete workflow example:
## Initialize the inferencer from inference_onnx.py
inferencer = LVFaceONNXInferencer(
model_path="./models/vit_b_dp005_mask_005.onnx", # Path to your ONNX model
use_gpu=True # Set to False for CPU-only inference
)
## Extract feature from local image
feat1 = inferencer.infer_from_image("path/to/image1.jpg")
## Extract feature from URL
feat2 = inferencer.infer_from_url("https://example.com/image1.jpg")
## Calculate cosine similarity
similarity = inferencer.calculate_similarity(feat1, feat2)
print(f"Similarity score: {similarity:.6f}") # Output example: 0.892345
Note: The LVFaceONNXInferencer class is defined in inference_onnx.py, which handles ONNX model loading, image preprocessing, feature extraction, and similarity calculation in a unified interface. Ensure the model path and image paths are correctly specified before running.
Evaluation Steps
eval_ijbc.py).Evaluation Commands
python eval_ijbc.py \
--model-prefix path/to/LVFace-B_Glint360K.pt \
--result-dir results \
--network vit_b_dp005_mask_005 > LVFace-B_Glint360K.log 2>&1 &
The code of LVFace is released under the MIT License. There is no limitation for both academic and commercial usage. The models downloaded from our repo follow the above license policy (which is for non-commercial research purposes only).
If you find this work useful, please cite our paper and give us a star ⭐:
@inproceedings{you2025lvface,
title={{LVFace}: Progressive Cluster Optimization for Large Vision Models in Face Recognition},
author={You, Jinghan and Li, Shanglin and Sun, Yuanrui and Wei, Jiangchuan and Guo, Mingyu and Feng, Chao and Ran, Jiao},
booktitle={ICCV},
year={2025}
}
We sincerely thank Professor Jiankang Deng for his valuable guidance and insights throug
Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.
How it works