"""Encode original query image+text and product image+title with Qwen3-VL-Embedding. Writes query_ids.json, candidate_ids.json and matching *_embeds.npy arrays. The chat format and pooling follow the Qwen reference implementation: https://github.com/QwenLM/Qwen3-VL-Embedding This entry point is specific to that architecture, not a generic HF encoder. """ import argparse import json from pathlib import Path import utils as data def message(image, text, instruction): return [ {"role": "system", "content": [{"type": "text", "text": instruction}]}, {"role": "user", "content": [ {"type": "image", "image": image, "min_pixels": 4 * 32 * 32, "max_pixels": 1800 * 32 * 32}, {"type": "text", "text": text}]}, ] def build_inputs(root, corpus, instruction): queries = data.load_queries(root) q = [message(data.query_image_path(root, x['image_url']), x['query'], instruction) for x in queries] c = [message(data.product_image_path(root, x['pict_url']), x['title'], instruction) for x in corpus.values()] return q, [str(x['idx']) for x in queries], c, list(corpus) def encode(messages, model, processor, device, batch_size, max_length): import numpy as np import torch from qwen_vl_utils import process_vision_info embeds = [] for start in range(0, len(messages), batch_size): batch = messages[start:start + batch_size] text = processor.apply_chat_template(batch, tokenize=False, add_generation_prompt=True) images, _ = process_vision_info(batch, image_patch_size=16) inputs = processor(text=text, images=images, padding=True, do_resize=False, return_tensors='pt') if inputs['input_ids'].shape[1] > max_length: raise ValueError(f"Input exceeds --max-length {max_length}; refusing silent truncation") inputs = inputs.to(device) with torch.inference_mode(): hidden = model(**inputs).last_hidden_state mask = inputs['attention_mask'] last = mask.shape[1] - 1 - mask.flip(dims=[1]).argmax(dim=1) pooled = hidden[torch.arange(hidden.shape[0], device=hidden.device), last] pooled = torch.nn.functional.normalize(pooled.float(), dim=-1) embeds.append(pooled.cpu().numpy()) print(f' [{min(start + batch_size, len(messages))}/{len(messages)}]', flush=True) return np.concatenate(embeds) def main(): p = argparse.ArgumentParser(description=__doc__) p.add_argument('--model', default='Qwen/Qwen3-VL-Embedding-8B') p.add_argument('--out', required=True) p.add_argument('--data', default=None) p.add_argument('--batch-size', type=int, default=8) p.add_argument('--device', default=None) p.add_argument('--max-length', type=int, default=8192) p.add_argument('--instruction', default="Represent the user's input.") args = p.parse_args() if args.batch_size <= 0 or args.max_length <= 0: p.error('batch-size and max-length must be positive') import numpy as np import torch from transformers import Qwen3VLModel, Qwen3VLPreTrainedModel, Qwen3VLProcessor # The released embedding checkpoint stores backbone weights under model.*. class EmbeddingModel(Qwen3VLPreTrainedModel): _checkpoint_conversion_mapping = {} def __init__(self, config): super().__init__(config) self.model = Qwen3VLModel(config) self.post_init() def forward(self, **inputs): return self.model(**inputs) device = args.device or ('cuda' if torch.cuda.is_available() else 'cpu') dtype = torch.bfloat16 if device.startswith('cuda') else torch.float32 model = EmbeddingModel.from_pretrained(args.model, torch_dtype=dtype).to(device).eval() processor = Qwen3VLProcessor.from_pretrained(args.model, padding_side='right') root = data.data_root(args.data) q, qids, c, cids = build_inputs(root, data.load_corpus(root), args.instruction) out = Path(args.out) out.mkdir(parents=True, exist_ok=True) for name, messages, ids in [('query', q, qids), ('candidate', c, cids)]: print(f'encoding {len(ids)} {name} items...', flush=True) vectors = encode(messages, model, processor, device, args.batch_size, args.max_length) np.save(out / f'{name}_embeds.npy', vectors) (out / f'{name}_ids.json').write_text(json.dumps(ids)) print(f'saved embeddings -> {out}') if __name__ == '__main__': main()