Datasets:
Download evaluation/embedding.py from leequeue/MIPR: direct link, hf CLI and curl.
- Browser
- Download file 4.55 kB
-
https://huggingface.co/datasets/leequeue/MIPR/resolve/main/evaluation/embedding.py
- Command line
-
hf download hf://datasets/leequeue/MIPR/evaluation/embedding.py
-
curl -L -o embedding.py https://huggingface.co/datasets/leequeue/MIPR/resolve/main/evaluation/embedding.py
4.55 kB
| """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() | |