eval_example/visual_embedding_model.py

import requests
from typing import List, Optional, cast, TypeVar
from abc import ABC, abstractmethod

import torch
import torch.nn.functional as F
from torch import Tensor
from torch.utils.data import DataLoader

from tqdm import tqdm
from PIL import Image

from datasets import Dataset 
from torch.utils.data import Dataset as TorchDataset

from transformers import AutoProcessor, PaliGemmaForConditionalGeneration, Qwen2VLForConditionalGeneration
from qwen_vl_utils import process_vision_info

T = TypeVar("T")
class ListDataset(TorchDataset[T]):
    def __init__(self, elements: List[T]):
        self.elements = elements

    def __len__(self) -> int:
        return len(self.elements)

    def __getitem__(self, idx: int) -> T:
        return self.elements[idx]

def get_torch_device(device: str = "auto") -> str:
    """
    Returns the device (string) to be used by PyTorch.

    `device` arg defaults to "auto" which will use:
    - "cuda:0" if available
    - else "mps" if available
    - else "cpu".
    """

    if device == "auto":
        if torch.cuda.is_available():
            device = "cuda"
        elif torch.backends.mps.is_available():  # for Apple Silicon
            device = "mps"
        else:
            device = "cpu"

    return device

class ImageConverter():

    def __init__(self,image_corpus, images_mapping):
        self.image_corpus = image_corpus
        self.images_mapping = images_mapping

    def transform_func(self, example):
        if 'image' in example:
            if isinstance(example['image'], str):
                example['image'] = self.image_corpus[self.images_mapping[example['image']]]
            if isinstance(example['image'], list):
                converted_images = []
                for el in example['image']:
                    converted_images.append(self.image_corpus[self.images_mapping[el]]['image'].convert("RGB"))
                example['image'] = converted_images         
        return(example)

class CustomRetriever(ABC):
    """
    Custom model (dense embeddings).
    """

    def __init__(self, model_name_or_path, device: str = "auto"):
        super().__init__()
        self.device = get_torch_device(device)
        self.min_pixels=1*28*28
        self.max_pixels=2560*28*28
        self.processor = AutoProcessor.from_pretrained(model_name_or_path, min_pixels=self.min_pixels, max_pixels=self.max_pixels)
        self.processor.padding_side = "left"
        self.document_prefix = "What is shown in this image?"
        self.query_prefix = "Query:"
        self.pooling = "last"

    @property
    def use_visual_embedding(self) -> bool:
        return True

    @abstractmethod
    def process_images(self, images: List[Image.Image], **kwargs):
        pass

    @abstractmethod
    def process_queries(self, queries: List[str], **kwargs):
        pass
    
    def forward_queries(self, queries, batch_size: int, **kwargs) -> List[torch.Tensor]:
        dataloader = DataLoader(
            dataset=ListDataset[str](queries),
            batch_size=batch_size,
            shuffle=False,
            collate_fn=self.process_queries,
            num_workers=32
        )

        qs = []
        for batch_query in tqdm(dataloader, desc="Forward pass queries..."):
            with torch.no_grad():
                with torch.autocast(device_type="cuda"):
                    batch_query = {k: v.to(self.device) for k, v in batch_query.items()}
                    embeddings_query = self.model(**batch_query, output_hidden_states=True).hidden_states[-1]
                    
                    embeds = self.pool(
                    last_hidden_states=embeddings_query,
                    attention_mask=batch_query["attention_mask"],
                    pool_type=self.pooling,
                    )
                    embeds = F.normalize(embeds, dim=-1)
            
            qs.append(embeds.contiguous())


        return torch.cat(qs, dim=0).cpu()

    def forward_documents(self, documents: List[str], batch_size: int, **kwargs) -> List[torch.Tensor]:
        dataset = Dataset.from_dict({"image": documents})
        if self.imageconverter:
            dataset.set_transform(self.imageconverter.transform_func)
        dataloader = DataLoader(
            dataset=dataset,
            batch_size=batch_size,
            shuffle=False,
            collate_fn=self.process_images,
            num_workers=32
        )

        ds = []
        for batch_doc in tqdm(dataloader, desc="Forward pass documents..."):
            with torch.no_grad():
                with torch.autocast(device_type="cuda"):
                    batch_doc = {k: v.to(self.device) for k, v in batch_doc.items()}
                    embeddings_doc = self.model(**batch_doc, output_hidden_states=True).hidden_states[-1]
                    embeds = self.pool(
                    last_hidden_states=embeddings_doc,
                    attention_mask=batch_doc["attention_mask"],
                    pool_type=self.pooling,
                    )
                    embeds = F.normalize(embeds, dim=-1)
            
            ds.append(embeds.contiguous())

        return torch.cat(ds, dim=0).cpu()

    def pool(self, last_hidden_states: Tensor,
         attention_mask: Tensor,
         pool_type: str) -> Tensor:
        last_hidden = last_hidden_states.masked_fill(~attention_mask[..., None].bool(), 0.0)

        if pool_type == "avg":
            emb = last_hidden.sum(dim=1) / attention_mask.sum(dim=1)[..., None]
        elif pool_type == "weighted_avg":
            emb = last_hidden.sum(dim=1)
        elif pool_type == "cls":
            emb = last_hidden[:, 0]
        elif pool_type == "last":
            left_padding = (attention_mask[:, -1].sum() == attention_mask.shape[0])
            if left_padding:
                emb = last_hidden[:, -1]
            else:
                sequence_lengths = attention_mask.sum(dim=1) - 1
                batch_size = last_hidden.shape[0]
                emb = last_hidden[torch.arange(batch_size, device=last_hidden.device), sequence_lengths]
        else:
            raise ValueError(f"pool_type {pool_type} not supported")

        return emb

class DSERetriever(CustomRetriever):
    def __init__(self, model_name_or_path, device: str = "auto", images=None):
        super().__init__(model_name_or_path, device)
        model = Qwen2VLForConditionalGeneration.from_pretrained(
            model_name_or_path, 
            attn_implementation="flash_attention_2",
            torch_dtype=torch.bfloat16,
            device_map='cuda'
        ).eval()
        model.padding_side = "left"
        self.model = model
        self.q_max_length=512
        self.p_max_length=10240
        self.set_resize = False
        self.resized_height=760 
        self.resized_width=760
        self.imageconverter = None
        if images:
            images_mapping = {}
            for i,e in enumerate(images['file_name']):
                images_mapping[e] = i
            self.imageconverter = ImageConverter(image_corpus=images, images_mapping=images_mapping)

    def process_images(self,  documents, **kwargs):
        if isinstance(documents, dict):
            images = documents["image"]
            assert len(texts) == len(images)
        elif isinstance(documents, list):
            images = [pair['image'] for pair in documents ]
        else:
            raise ValueError("The documents need to be a dict or list of dicts")
        
        input_texts = []
        doc_messages = []
        doc_texts = [self.document_prefix] * len(images)
        for doc_text, doc_image in zip(doc_texts, images):
            message = [
                {
                    'role': 'user',
                    'content': [
                        {'type': 'image', 'image': doc_image, 'resized_height': self.resized_height , 'resized_width': self.resized_width} if self.set_resize else {'type': 'image', 'image': doc_image},
                        {'type': 'text', 'text': 'What is shown in this image?'}
                    ]
                }
            ]
            doc_messages.append(message)
            doc_text = self.processor.apply_chat_template(message, tokenize=False, add_generation_prompt=True) + "<|endoftext|>"
            input_texts.append(doc_text)

        images, videos = process_vision_info(doc_messages)
        doc_batch_dict = self.processor(
            text=input_texts, 
            images=images, 
            videos=videos, 
            truncation=True,
            max_length=self.p_max_length,
            padding='longest',
            return_tensors='pt'
        )
        return doc_batch_dict

    def process_queries(self, queries: List[str], **kwargs):
        query_messages = []
        for query in queries:
            message = [
                {
                    'role': 'user',
                    'content': [
                        {'type': 'image', 'image': Image.new('RGB', (28, 28)), 'resized_height':1 , 'resized_width':1}, # need a dummy image
                        {'type': 'text', 'text': f'Query: {query}'},
                    ]
                }
            ]
            query_messages.append(message)
        query_texts = [
            x + "<|endoftext|>" for x in self.processor.apply_chat_template(query_messages, tokenize=False, add_generation_prompt=True)
        ] 
        images, videos = process_vision_info(query_messages)
        query_batch_dict = self.processor(
            text=query_texts, 
            images=images, 
            videos=videos, 
            padding='longest',
            return_tensors='pt'
        )
        return query_batch_dict

    def encode_queries(
        self, 
        queries: List[str], 
        batch_size: int = 16, 
        **kwargs
    ):
        return self.forward_queries(queries, batch_size=batch_size)
    
    def encode_corpus(
        self, 
        corpus, 
        batch_size: int = 16, 
        **kwargs
    ):
        
        return self.forward_documents([el['image_id'] for el in corpus], batch_size=batch_size)