File size: 4,522 Bytes
0cbed7c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | """
Model loading utilities for Qwen-VL evaluation
"""
import sys
import os
import torch
from transformers import AutoProcessor, Qwen2VLForConditionalGeneration
from pathlib import Path
# Add the Qwen2-VL-Finetune src to path for imports
sys.path.append("/weka/royg/vsg_train/Qwen2-VL-Finetune/src")
from config import MODELS
class QwenVLModelLoader:
"""Load and manage Qwen-VL models for evaluation"""
def __init__(self, model_variant: str, device: str = "auto"):
self.model_variant = model_variant
self.device = device
self.model_config = MODELS[model_variant]
self.model = None
self.processor = None
def load_model(self):
"""Load the specified model variant"""
model_path = self.model_config["path"]
if not os.path.exists(model_path):
raise FileNotFoundError(f"Model path not found: {model_path}")
print(f"Loading {self.model_variant} model from {model_path}")
# Load processor - use base model processor for consistency
base_model_name = "Qwen/Qwen2.5-VL-3B-Instruct"
self.processor = AutoProcessor.from_pretrained(base_model_name)
# Load fine-tuned model
self.model = Qwen2VLForConditionalGeneration.from_pretrained(
model_path,
torch_dtype=torch.bfloat16,
device_map="auto" if self.device == "auto" else None,
trust_remote_code=True
)
if self.device != "auto":
self.model = self.model.to(self.device)
self.model.eval()
print(f"Successfully loaded {self.model_variant} model")
def generate_response(self, messages, max_new_tokens=1024, temperature=0.1):
"""Generate response from the model"""
if self.model is None or self.processor is None:
raise RuntimeError("Model not loaded. Call load_model() first.")
# Prepare inputs
text = self.processor.apply_chat_template(
messages, tokenize=False, add_generation_prompt=True
)
# Process inputs
inputs = self.processor(
text=[text],
images=messages[0].get("content", [{}])[0].get("image") if "image" in str(messages) else None,
videos=messages[0].get("content", [{}])[0].get("video") if "video" in str(messages) else None,
padding=True,
return_tensors="pt"
)
# Move to device
if self.device != "auto":
inputs = {k: v.to(self.device) if isinstance(v, torch.Tensor) else v
for k, v in inputs.items()}
# Generate
with torch.no_grad():
generated_ids = self.model.generate(
**inputs,
max_new_tokens=max_new_tokens,
temperature=temperature,
do_sample=temperature > 0,
pad_token_id=self.processor.tokenizer.eos_token_id
)
# Decode response
generated_ids_trimmed = [
out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
]
response = self.processor.batch_decode(
generated_ids_trimmed,
skip_special_tokens=True,
clean_up_tokenization_spaces=False
)[0]
return response
def unload_model(self):
"""Free model memory"""
if self.model is not None:
del self.model
self.model = None
if self.processor is not None:
del self.processor
self.processor = None
torch.cuda.empty_cache()
def load_all_models(device="auto"):
"""Load all three model variants"""
models = {}
for variant in MODELS.keys():
loader = QwenVLModelLoader(variant, device)
loader.load_model()
models[variant] = loader
return models
def get_model_prompt_template(model_variant: str):
"""Get the appropriate prompt template for model variant"""
from config import VSG_PROMPT_TEMPLATE, VSG_PROMPT_NO_ID, VSG_PROMPT_SPECIAL_TOKENS
if model_variant == "with_id":
return VSG_PROMPT_TEMPLATE
elif model_variant == "without_id":
return VSG_PROMPT_NO_ID
elif model_variant == "special_tokens":
return VSG_PROMPT_SPECIAL_TOKENS
else:
raise ValueError(f"Unknown model variant: {model_variant}") |