"""Six multimodal reranker adapters: score and reorder the same top-50 candidate pool.""" import argparse import json import math from pathlib import Path import utils as data from evaluate import validate_run import torch import torch.nn.functional as F SYSTEM_PROMPT = ( 'Judge whether the Document meets the requirements based on the Query and ' 'the Instruct provided. Note that the answer can only be "yes" or "no".' ) DEFAULT_INSTRUCTION = ( "Given a search query containing a reference product image and the user's " "need, retrieve relevant products that can satisfy the user's need." ) def build_qwen_messages(instruction, q_text, q_img, d_text, d_img, image_kwargs=None): img_kw = image_kwargs or {} content = [ {"type": "text", "text": ": " + instruction}, {"type": "text", "text": ":"}, ] if q_img: content.append({"type": "image", "image": "file://" + q_img, **img_kw}) if q_text: content.append({"type": "text", "text": q_text}) content.append({"type": "text", "text": "\n:"}) if d_img: content.append({"type": "image", "image": "file://" + d_img, **img_kw}) if d_text: content.append({"type": "text", "text": d_text}) return [ {"role": "system", "content": [{"type": "text", "text": SYSTEM_PROMPT}]}, {"role": "user", "content": content}, ] class BaseReranker: def __init__(self, model_path, instruction=DEFAULT_INSTRUCTION, batch_size=4): self.model_path = model_path self.instruction = instruction self.batch_size = batch_size def score_pairs(self, pairs): """pairs: list of {"query_text","query_image","doc_text","doc_image"}. Returns list of float scores, same order.""" scores = [] for s in range(0, len(pairs), self.batch_size): scores.extend(self._score_batch(pairs[s : s + self.batch_size])) return scores def _score_batch(self, batch): raise NotImplementedError class _QwenVLYesNo(BaseReranker): """Qwen2-VL / Qwen2.5-VL / Qwen3-VL instruct models: P(yes) from the last-token yes/no logits (Eq. 3 in the paper).""" model_cls_name = None image_patch_size = 14 pixel_factor = 28 # min/max pixels unit: patch_size * merge_size per_image_pixels = False # True -> pass min/max pixels via content dict def __init__(self, model_path, instruction=DEFAULT_INSTRUCTION, batch_size=4, max_image_tokens=1280): super().__init__(model_path, instruction, batch_size) import transformers from transformers import AutoProcessor cls = getattr(transformers, self.model_cls_name) f = self.pixel_factor self.min_pixels = 4 * f * f self.max_pixels = max_image_tokens * f * f self.processor = AutoProcessor.from_pretrained( self.model_path, padding_side="left", min_pixels=self.min_pixels, max_pixels=self.max_pixels, trust_remote_code=True, ) self.model = cls.from_pretrained( self.model_path, dtype=torch.bfloat16, attn_implementation="sdpa", trust_remote_code=True, ).cuda().eval() vocab = self.processor.tokenizer.get_vocab() self.yes_id = vocab["yes"] self.no_id = vocab["no"] def _image_kwargs(self): if self.per_image_pixels: return {"min_pixels": self.min_pixels, "max_pixels": self.max_pixels} return {} @torch.no_grad() def _score_batch(self, batch): from qwen_vl_utils import process_vision_info msgs = [ build_qwen_messages( self.instruction, p["query_text"], p["query_image"], p["doc_text"], p["doc_image"], image_kwargs=self._image_kwargs(), ) for p in batch ] texts = [ self.processor.apply_chat_template(m, tokenize=False, add_generation_prompt=True) for m in msgs ] images, _ = process_vision_info(msgs, image_patch_size=self.image_patch_size) kwargs = {} if self.per_image_pixels: # images already resized by process_vision_info (official reranker flow) kwargs["do_resize"] = False inputs = self.processor( text=texts, images=images, padding=True, return_tensors="pt", **kwargs ) inputs = {k: v.cuda() if hasattr(v, "cuda") else v for k, v in inputs.items()} logits = self.model(**inputs).logits[:, -1, :] pair_logits = logits[:, [self.no_id, self.yes_id]].float() return F.softmax(pair_logits, dim=-1)[:, 1].cpu().tolist() class LycheeRerankMM(_QwenVLYesNo): """vec-ai/lychee-rerank-mm (Qwen2.5-VL base), official README flow.""" model_cls_name = "Qwen2_5_VLForConditionalGeneration" image_patch_size = 14 pixel_factor = 28 per_image_pixels = False class Qwen3VLInstruct(_QwenVLYesNo): """Qwen/Qwen3-VL-8B-Instruct used as a yes/no reranker.""" model_cls_name = "Qwen3VLForConditionalGeneration" image_patch_size = 16 pixel_factor = 32 per_image_pixels = False class Qwen2VLInstruct(_QwenVLYesNo): """Qwen/Qwen2-VL-7B-Instruct used as a yes/no reranker.""" model_cls_name = "Qwen2VLForConditionalGeneration" image_patch_size = 14 pixel_factor = 28 per_image_pixels = False class Qwen3VLReranker(_QwenVLYesNo): """Qwen/Qwen3-VL-Reranker-8B, official script flow (Eq. 4 in the paper): sigmoid over the last hidden state projected by (w_yes - w_no).""" model_cls_name = "Qwen3VLForConditionalGeneration" image_patch_size = 16 pixel_factor = 32 per_image_pixels = True def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) lm_head = self.model.lm_head.weight.data w_diff = (lm_head[self.yes_id] - lm_head[self.no_id]).float() self.score_linear = torch.nn.Linear(w_diff.size(0), 1, bias=False) with torch.no_grad(): self.score_linear.weight[0] = w_diff self.score_linear = self.score_linear.cuda().to(self.model.dtype) self.inner = self.model.model @torch.no_grad() def _score_batch(self, batch): from qwen_vl_utils import process_vision_info msgs = [ build_qwen_messages( self.instruction, p["query_text"], p["query_image"], p["doc_text"], p["doc_image"], image_kwargs=self._image_kwargs(), ) for p in batch ] texts = [ self.processor.apply_chat_template(m, tokenize=False, add_generation_prompt=True) for m in msgs ] images, _ = process_vision_info(msgs, image_patch_size=self.image_patch_size) inputs = self.processor( text=texts, images=images, padding=True, return_tensors="pt", do_resize=False, ) inputs = {k: v.cuda() if hasattr(v, "cuda") else v for k, v in inputs.items()} hidden = self.inner(**inputs).last_hidden_state[:, -1] scores = torch.sigmoid(self.score_linear(hidden).float().squeeze(-1)) return scores.cpu().tolist() # ---------------- InternVL3.5 ---------------- IMAGENET_MEAN = (0.485, 0.456, 0.406) IMAGENET_STD = (0.229, 0.224, 0.225) INTERNVL_IMAGE_SIZE = 448 def _find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size): best_ratio_diff = float("inf") best_ratio = (1, 1) area = width * height for ratio in target_ratios: target_aspect_ratio = ratio[0] / ratio[1] ratio_diff = abs(aspect_ratio - target_aspect_ratio) if ratio_diff < best_ratio_diff: best_ratio_diff = ratio_diff best_ratio = ratio elif ratio_diff == best_ratio_diff: if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]: best_ratio = ratio return best_ratio def _dynamic_preprocess(image, min_num=1, max_num=6, image_size=448, use_thumbnail=True): orig_width, orig_height = image.size aspect_ratio = orig_width / orig_height target_ratios = set( (i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if i * j <= max_num and i * j >= min_num ) target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1]) target_aspect_ratio = _find_closest_aspect_ratio( aspect_ratio, target_ratios, orig_width, orig_height, image_size ) target_width = image_size * target_aspect_ratio[0] target_height = image_size * target_aspect_ratio[1] blocks = target_aspect_ratio[0] * target_aspect_ratio[1] resized_img = image.resize((target_width, target_height)) processed_images = [] for i in range(blocks): box = ( (i % (target_width // image_size)) * image_size, (i // (target_width // image_size)) * image_size, ((i % (target_width // image_size)) + 1) * image_size, ((i // (target_width // image_size)) + 1) * image_size, ) processed_images.append(resized_img.crop(box)) if use_thumbnail and len(processed_images) != 1: processed_images.append(image.resize((image_size, image_size))) return processed_images class InternVLYesNo(BaseReranker): """OpenGVLab/InternVL3_5-8B-Instruct: P(yes) from last-token logits.""" def __init__(self, model_path, instruction=DEFAULT_INSTRUCTION, batch_size=4, max_num_tiles=6): super().__init__(model_path, instruction, batch_size) import numpy as np from PIL import Image from transformers import AutoModel, AutoTokenizer self.max_num_tiles = max_num_tiles mean = torch.tensor(IMAGENET_MEAN).view(3, 1, 1) std = torch.tensor(IMAGENET_STD).view(3, 1, 1) def transform(img): img = img.convert("RGB").resize( (INTERNVL_IMAGE_SIZE, INTERNVL_IMAGE_SIZE), Image.BICUBIC) arr = np.asarray(img, dtype=np.float32) / 255.0 t = torch.from_numpy(arr).permute(2, 0, 1) return (t - mean) / std self.transform = transform self.tokenizer = AutoTokenizer.from_pretrained( model_path, trust_remote_code=True) self.tokenizer.padding_side = "left" if self.tokenizer.pad_token is None: self.tokenizer.pad_token = self.tokenizer.eos_token self.model = AutoModel.from_pretrained( model_path, torch_dtype=torch.bfloat16, trust_remote_code=True, use_flash_attn=False, ).cuda().eval() self.img_context_token = "" self.model.img_context_token_id = self.tokenizer.convert_tokens_to_ids( self.img_context_token) vocab = self.tokenizer.get_vocab() self.yes_id = vocab["yes"] self.no_id = vocab["no"] self.num_image_token = self.model.num_image_token def _load_tiles(self, path): from PIL import Image image = Image.open(path).convert("RGB") tiles = _dynamic_preprocess( image, min_num=1, max_num=self.max_num_tiles, image_size=INTERNVL_IMAGE_SIZE, use_thumbnail=True, ) return [self.transform(t) for t in tiles] def _build_sample(self, pair): """Returns (input_ids, pixel_values list) for one query-doc pair.""" user_parts = [": " + self.instruction, ":"] n_q = n_d = 0 q_tiles, d_tiles = [], [] if pair["query_image"]: q_tiles = self._load_tiles(pair["query_image"]) n_q = len(q_tiles) user_parts.append("") if pair["query_text"]: user_parts.append(pair["query_text"]) user_parts.append("\n:") if pair["doc_image"]: d_tiles = self._load_tiles(pair["doc_image"]) n_d = len(d_tiles) user_parts.append("") if pair["doc_text"]: user_parts.append(pair["doc_text"]) user_text = "\n".join(user_parts) messages = [ {"role": "system", "content": SYSTEM_PROMPT}, {"role": "user", "content": user_text}, ] prompt = self.tokenizer.apply_chat_template( messages, tokenize=False, add_generation_prompt=True) for n in (n_q, n_d): if n: image_tokens = ( "" + self.img_context_token * (self.num_image_token * n) + "" ) prompt = prompt.replace("", image_tokens, 1) assert "" not in prompt input_ids = self.tokenizer(prompt, return_tensors="pt").input_ids[0] return input_ids, q_tiles + d_tiles @torch.no_grad() def _score_batch(self, batch): ids_list, tiles_list = [], [] for p in batch: ids, tiles = self._build_sample(p) ids_list.append(ids) tiles_list.append(tiles) enc = self.tokenizer.pad( {"input_ids": ids_list}, padding=True, return_tensors="pt") input_ids = enc.input_ids.cuda() attention_mask = enc.attention_mask.cuda() all_tiles = [t for tiles in tiles_list for t in tiles] if all_tiles: pixel_values = torch.stack(all_tiles).to( dtype=torch.bfloat16, device="cuda") image_flags = torch.ones( pixel_values.size(0), 1, dtype=torch.long, device="cuda") else: pixel_values = torch.zeros( (1, 3, INTERNVL_IMAGE_SIZE, INTERNVL_IMAGE_SIZE), dtype=torch.bfloat16, device="cuda") image_flags = torch.zeros(1, 1, dtype=torch.long, device="cuda") logits = self.model( pixel_values=pixel_values, input_ids=input_ids, attention_mask=attention_mask, image_flags=image_flags, ).logits[:, -1, :] pair_logits = logits[:, [self.no_id, self.yes_id]].float() return F.softmax(pair_logits, dim=-1)[:, 1].cpu().tolist() class LlavaYesNo(BaseReranker): """llava-hf/llava-1.5-7b-hf: P(yes) from last-token logits. Single-image-trained model used with two images; weak-baseline contrast.""" def __init__(self, model_path, instruction=DEFAULT_INSTRUCTION, batch_size=8, **_ignored): super().__init__(model_path, instruction, batch_size) from transformers import AutoProcessor, LlavaForConditionalGeneration self.processor = AutoProcessor.from_pretrained( model_path, padding_side="left") self.model = LlavaForConditionalGeneration.from_pretrained( model_path, dtype=torch.float16, attn_implementation="sdpa", ).cuda().eval() vocab = self.processor.tokenizer.get_vocab() # after "ASSISTANT:" the next token carries a leading space (▁) self.yes_ids = [vocab[t] for t in ("▁yes", "▁Yes", "yes", "Yes") if t in vocab] self.no_ids = [vocab[t] for t in ("▁no", "▁No", "no", "No") if t in vocab] def _build_messages(self, pair, n_images): content = [{"type": "text", "text": ": " + self.instruction}, {"type": "text", "text": ":"}] if pair["query_image"]: content.append({"type": "image"}) if pair["query_text"]: content.append({"type": "text", "text": pair["query_text"]}) content.append({"type": "text", "text": "\n:"}) if pair["doc_image"]: content.append({"type": "image"}) if pair["doc_text"]: content.append({"type": "text", "text": pair["doc_text"]}) return [ {"role": "system", "content": [{"type": "text", "text": SYSTEM_PROMPT}]}, {"role": "user", "content": content}, ] @torch.no_grad() def _score_batch(self, batch): from PIL import Image texts, images = [], [] for p in batch: msgs = self._build_messages(p, 0) texts.append(self.processor.apply_chat_template( msgs, tokenize=False, add_generation_prompt=True)) for key in ("query_image", "doc_image"): if p[key]: images.append(Image.open(p[key]).convert("RGB")) inputs = self.processor( text=texts, images=images or None, padding=True, return_tensors="pt") inputs = {k: v.cuda() if hasattr(v, "cuda") else v for k, v in inputs.items()} logits = self.model(**inputs).logits[:, -1, :].float() probs = F.softmax(logits, dim=-1) p_yes = probs[:, self.yes_ids].sum(-1) p_no = probs[:, self.no_ids].sum(-1) return (p_yes / (p_yes + p_no + 1e-12)).cpu().tolist() RERANKERS = { "qwen3_vl_reranker_8b": ("Qwen/Qwen3-VL-Reranker-8B", Qwen3VLReranker), "qwen3_vl_8b_instruct": ("Qwen/Qwen3-VL-8B-Instruct", Qwen3VLInstruct), "internvl3_5_8b": ("OpenGVLab/InternVL3_5-8B-Instruct", InternVLYesNo), "lychee_rerank_mm": ("vec-ai/lychee-rerank-mm", LycheeRerankMM), "llava_1_5_7b": ("llava-hf/llava-1.5-7b-hf", LlavaYesNo), "qwen2_vl_7b_instruct": ("Qwen/Qwen2-VL-7B-Instruct", Qwen2VLInstruct), } def get_reranker(tag, model_path=None, batch_size=4): model_id, cls = RERANKERS[tag] return cls(model_path or model_id, batch_size=batch_size) def rerank(baseline, queries, corpus, root, model): query_map = {str(row["idx"]): row for row in queries} baseline = validate_run(baseline, query_map, corpus) if any(len(row["ranked"]) != 50 for row in baseline): raise ValueError("Reranking requires 50 candidates per query") output = [] for row in baseline: query = query_map[row["qid"]] query_image = data.query_image_path(root, query["image_url"]) pairs = [] for hit in row["ranked"]: product = corpus[hit["did"]] pairs.append({"query_text": query["query"], "query_image": query_image, "doc_text": product["title"], "doc_image": data.product_image_path(root, product["pict_url"])}) scores = model.score_pairs(pairs) if len(scores) != len(pairs) or not all(math.isfinite(score) for score in scores): raise ValueError(f"Incomplete or invalid scores for {row['qid']}") ranked = [{"did": hit["did"], "score": float(score)} for hit, score in zip(row["ranked"], scores)] output.append({"qid": row["qid"], "ranked": sorted(ranked, key=lambda hit: -hit["score"])}) return output def main(): p = argparse.ArgumentParser(description=__doc__) p.add_argument("--model", required=True, choices=RERANKERS) p.add_argument("--model-path", default=None, help="Optional local model weights") p.add_argument("--baseline", default=None) p.add_argument("--data", default=None) p.add_argument("--output", required=True) p.add_argument("--batch-size", type=int, default=4) args = p.parse_args() if args.batch_size <= 0: p.error("batch-size must be positive") root = data.data_root(args.data) path = Path(args.baseline) if args.baseline else root / "baseline/qwen3_vl_embedding_8b_top50.json" baseline = json.loads(path.read_text()) model = get_reranker(args.model, args.model_path, args.batch_size) run = rerank(baseline, data.load_queries(root), data.load_corpus(root), root, model) out = Path(args.output) out.parent.mkdir(parents=True, exist_ok=True) out.write_text(json.dumps(run)) print(f"Saved {len(run)} query rankings to {out}") if __name__ == "__main__": main()