Model reference · open weights

LVFace

Embeddings bytedance-research Image embed 1 build Open weights 32k dl/mo

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.

  • LVFace is a face recognition model developed by bytedance-research that uses a Large Vision Transformer architecture for image feature extraction.
  • It is designed to perform progressive optimization of the face clustering space and supports inference in both ONNX and PyTorch formats.
  • The model is released under the MIT license and is available in multiple sizes, including LVFace-T, LVFace-S, LVFace-B, and LVFace-L.

Summary of the bytedance-research/LVFace model card, 2026-10-01

What it is

Released bybytedance-research
Released2025-08-10
VRAM1.9 GB for the weights

What it runs on

Memory and cards for LVFace (BF16)

1.9 GBweights, file size
1.1 GBruntime overhead
CardRunsMemory
RTX 3060 12 GBfits11.6 GB
RTX 4060 Ti 16 GBfits15.4 GB
RTX 3090 24 GBfits23.4 GB
RTX 4090 24 GBfits23.4 GB
RTX 5090 32 GBfits31.0 GB
L40S 48 GBfits44.0 GB
A100 80 GBfits78.2 GB
H100 80 GBfits78.1 GB
RTX PRO 6000 Blackwell 96 GBfits93.8 GB
DGX Spark (GB10) 128 GB unifiedfits107 GB
H200 141 GBfits138 GB
B200 180 GBfits176 GB

From the model card

What bytedance-research says about LVFace

Read 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.

News

  • 🔥🔥🔥 We have released the training weights of LVFace. Please click here to download it. (August, 2025 UTC)
  • 🎉🎉🎉 LVFace has been recommended as ICCV Highlight. (July, 2025 UTC)
  • 🎉🎉🎉 LVFace is accepted by ICCV 2025. (July, 2025 UTC)
  • 🔥🔥🔥 We have updated the arXiv report of LVFace. Please click here to view it. (March, 2025 UTC)
  • 🎉🎉🎉 LVFace secured 1st place in the ICCV 2021 Masked Face Recognition (MFR)-Ongoing Challenge (academic track). (December, 2024 UTC)

Requirements

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

Datasets

Test datasets for inference validation can be downloaded from the following sources:

LVFace Pretrained Models

Pretrained model weights for inference are available below in both ONNX and PyTorch (.pt) formats:

Training DataModelIJB-C(1e-6)IJB-C(1e-5)IJB-C(1e-4)IJB-B(1e-4)Download
Glint360KLVFace-T88.5395.6396.6795.41HuggingFace
Glint360KLVFace-S90.0696.5297.3196.14HuggingFace
Glint360KLVFace-B90.0697.0097.7096.51HuggingFace
Glint360KLVFace-L89.5197.0297.6696.51HuggingFace
WebFace42MLVFace-B----come soon

Step-by-Step Usage Guide

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.

Model Evaluation

Evaluation Steps

  1. Modify the test dataset path (e.g., IJB-C, IJB-B) in the corresponding evaluation script (eval_ijbc.py).
  2. Run the evaluation with pretrained model weights using the commands below:

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 &

License

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).

Citation

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}
}

Acknowledgments

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

How embedding models work

Your textsentence / documentEncodermaps meaningVectorlist of numbersAn embedding model turns text into a vector, so similar meanings sit close together, which is the basis of search and RAG.
© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms