GR-Lite: Fashion Image Retrieval Model
GR-Lite is a fashion image retrieval model fine-tuned from DINOv3-ViT-L/16. It extracts 1024-dimensional L2-normalized embeddings optimized for fashion product search and retrieval.
GR-Lite achieves state-of-the-art performance on LookBench and other fashion retrieval benchmarks. See the paper for detailed metrics.
| Property | Value |
|---|---|
| Architecture | ViT-L/16 (DINOv2-style) |
| Parameters | 303M |
| Input | 336 x 336 RGB |
| Output | 1024-dim L2-normalized embedding |
| Framework | PyTorch / Transformers |
** Update: The pro version can be accessed via https://apiclaw.io/en/api-docs with /openapi/v2/model/fashion-image-embedding endpoint. **
Quick Start
from transformers import AutoModel
import torch
from PIL import Image
from torchvision import transforms
# Load model
model = AutoModel.from_pretrained("srpone/gr-lite", trust_remote_code=True)
model.eval()
# Preprocess
transform = transforms.Compose([
transforms.Resize((336, 336)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
image = Image.open("your_image.jpg").convert("RGB")
pixel_values = transform(image).unsqueeze(0) # [1, 3, 336, 336]
# Extract embedding
with torch.no_grad():
output = model(pixel_values)
embedding = output.pooler_output # [1, 1024], L2-normalized
print(f"Embedding shape: {embedding.shape}")
Feature Extraction (Batch)
from torch.utils.data import DataLoader, Dataset
class ImageDataset(Dataset):
def __init__(self, image_paths, transform):
self.image_paths = image_paths
self.transform = transform
def __len__(self):
return len(self.image_paths)
def __getitem__(self, idx):
image = Image.open(self.image_paths[idx]).convert("RGB")
return self.transform(image)
# Create dataloader
dataset = ImageDataset(your_image_paths, transform)
loader = DataLoader(dataset, batch_size=64, num_workers=4)
# Extract all embeddings
all_embeddings = []
device = "cuda" if torch.cuda.is_available() else "cpu"
model.to(device)
with torch.no_grad():
for batch in loader:
output = model(batch.to(device))
all_embeddings.append(output.pooler_output.cpu())
embeddings = torch.cat(all_embeddings, dim=0) # [N, 1024]
Image Retrieval
import torch.nn.functional as F
# query_emb: [1, 1024], gallery_embs: [N, 1024]
similarity = query_emb @ gallery_embs.T # cosine similarity (already L2-normalized)
top_k_indices = similarity.argsort(descending=True)[0, :10]
Model Outputs
The model returns a BaseModelOutputWithPooling:
| Field | Shape | Description |
|---|---|---|
pooler_output | [B, 1024] | L2-normalized CLS token embedding (use this for retrieval) |
last_hidden_state | [B, 446, 1024] | Full sequence output (CLS + 4 registers + 441 patches) |
Resources
- Project Site: LookBench
- Paper: LookBench: A Comprehensive Benchmark for Fashion Image Retrieval
- Benchmark Dataset: srpone/look-bench
- Code & Notebooks: look-bench GitHub
Citation
@article{gao2026lookbench,
title={LookBench: A Live and Holistic Open Benchmark for Fashion Image Retrieval},
author={Chao Gao and Siqiao Xue and Jiwen Fu and Tingyi Gu and Shanshan Li and Fan Zhou},
year={2026},
url={https://arxiv.org/abs/2601.14706},
journal={arXiv preprint arXiv:2601.14706},
}