DrawBridgeAPI/utils/llm_captions.py

import asyncio
import base64
import warnings
warnings.simplefilter(action='ignore', category=UserWarning)
from torch import nn
from io import BytesIO
from transformers import AutoModel, AutoProcessor, AutoTokenizer, PreTrainedTokenizer, PreTrainedTokenizerFast, \
    AutoModelForCausalLM
import torch
import torch.amp.autocast_mode
from PIL import Image
import numpy as np
from io import BytesIO

from ..base_config import init_instance , setup_logger
from ..locales import _

llm_logger = setup_logger('[LLM-Caption]')

class JoyPipeline:
    def __init__(self):
        self.clip_model = None
        self.clip_processor = None
        self.tokenizer = None
        self.text_model = None
        self.image_adapter = None
        self.parent = None

    def clearCache(self):
        self.clip_model = None
        self.clip_processor = None
        self.tokenizer = None
        self.text_model = None
        self.image_adapter = None


class ImageAdapter(nn.Module):
    def __init__(self, input_features: int, output_features: int):
        super().__init__()
        self.linear1 = nn.Linear(input_features, output_features)
        self.activation = nn.GELU()
        self.linear2 = nn.Linear(output_features, output_features)

    def forward(self, vision_outputs: torch.Tensor):
        x = self.linear1(vision_outputs)
        x = self.activation(x)
        x = self.linear2(x)
        return x


class Joy_caption_load:

    def __init__(self):
        self.model = None
        self.pipeline = JoyPipeline()
        self.pipeline.parent = self
        self.config = init_instance.config
        pass

    def loadCheckPoint(self):
        # 清除一波
        if self.pipeline != None:
            self.pipeline.clearCache()

            # clip
        model_id = self.config.server_settings['llm_caption']['clip']

        model = AutoModel.from_pretrained(model_id)
        clip_processor = AutoProcessor.from_pretrained(model_id)
        clip_model = AutoModel.from_pretrained(
            model_id,
            trust_remote_code=True
        )

        clip_model = clip_model.vision_model
        clip_model.eval()
        clip_model.requires_grad_(False)
        clip_model.to("cuda")

        # LLM
        model_path_llm = self.config.server_settings['llm_caption']['llm']
        tokenizer = AutoTokenizer.from_pretrained(model_path_llm, use_fast=False)
        assert isinstance(tokenizer, PreTrainedTokenizer) or isinstance(tokenizer,
                                                                        PreTrainedTokenizerFast), f"Tokenizer is of type {type(tokenizer)}"

        text_model = AutoModelForCausalLM.from_pretrained(model_path_llm, device_map="auto", trust_remote_code=True)
        text_model.eval()

        # Image Adapte

        image_adapter = ImageAdapter(clip_model.config.hidden_size,
                                     text_model.config.hidden_size)  # ImageAdapter(clip_model.config.hidden_size, 4096)
        image_adapter.load_state_dict(torch.load(self.config.server_settings['llm_caption']['image_adapter'], map_location="cpu", weights_only=True))
        adjusted_adapter = image_adapter  # AdjustedImageAdapter(image_adapter, text_model.config.hidden_size)
        adjusted_adapter.eval()
        adjusted_adapter.to("cuda")

        self.pipeline.clip_model = clip_model
        self.pipeline.clip_processor = clip_processor
        self.pipeline.tokenizer = tokenizer
        self.pipeline.text_model = text_model
        self.pipeline.image_adapter = adjusted_adapter

    def clearCache(self):
        if self.pipeline != None:
            self.pipeline.clearCache()

    def gen(self, model):
        if self.model == None or self.model != model or self.pipeline == None:
            self.model = model
            self.loadCheckPoint()
        return (self.pipeline,)


class Joy_caption:

    def __init__(self):
        pass

    @staticmethod
    def tensor2pil(t_image: torch.Tensor) -> Image:
        return Image.fromarray(np.clip(255.0 * t_image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))

    def gen(
            self,
            joy_pipeline=JoyPipeline,
            image=Image,
            prompt="A descriptive caption for this image",
            max_new_tokens=300,
            temperature=0.5,
            cache=False
    ):

        if joy_pipeline.clip_processor == None:
            joy_pipeline.parent.loadCheckPoint()

        clip_processor = joy_pipeline.clip_processor
        tokenizer = joy_pipeline.tokenizer
        clip_model = joy_pipeline.clip_model
        image_adapter = joy_pipeline.image_adapter
        text_model = joy_pipeline.text_model

        input_image = image

        # Preprocess image
        pImge = clip_processor(images=input_image, return_tensors='pt').pixel_values
        pImge = pImge.to('cuda')

        # Tokenize the prompt
        prompt = tokenizer.encode(prompt, return_tensors='pt', padding=False, truncation=False,
                                  add_special_tokens=False)
        # Embed image
        with torch.amp.autocast_mode.autocast('cuda', enabled=True):
            vision_outputs = clip_model(pixel_values=pImge, output_hidden_states=True)
            image_features = vision_outputs.hidden_states[-2]
            embedded_images = image_adapter(image_features)
            embedded_images = embedded_images.to('cuda')

        # Embed prompt
        prompt_embeds = text_model.model.embed_tokens(prompt.to('cuda'))
        assert prompt_embeds.shape == (1, prompt.shape[1],
                                       text_model.config.hidden_size), f"Prompt shape is {prompt_embeds.shape}, expected {(1, prompt.shape[1], text_model.config.hidden_size)}"
        embedded_bos = text_model.model.embed_tokens(
            torch.tensor([[tokenizer.bos_token_id]], device=text_model.device, dtype=torch.int64))

        # Construct prompts
        inputs_embeds = torch.cat([
            embedded_bos.expand(embedded_images.shape[0], -1, -1),
            embedded_images.to(dtype=embedded_bos.dtype),
            prompt_embeds.expand(embedded_images.shape[0], -1, -1),
        ], dim=1)

        input_ids = torch.cat([
            torch.tensor([[tokenizer.bos_token_id]], dtype=torch.long),
            torch.zeros((1, embedded_images.shape[1]), dtype=torch.long),
            prompt,
        ], dim=1).to('cuda')
        attention_mask = torch.ones_like(input_ids)

        generate_ids = text_model.generate(input_ids, inputs_embeds=inputs_embeds, attention_mask=attention_mask,
                                           max_new_tokens=max_new_tokens, do_sample=True, top_k=10,
                                           temperature=temperature, suppress_tokens=None)

        # Trim off the prompt
        generate_ids = generate_ids[:, input_ids.shape[1]:]
        if generate_ids[0][-1] == tokenizer.eos_token_id:
            generate_ids = generate_ids[:, :-1]

        caption = tokenizer.batch_decode(generate_ids, skip_special_tokens=False, clean_up_tokenization_spaces=False)[0]
        r = caption.strip()

        if cache == False:
            joy_pipeline.parent.clearCache()

        return (r,)


class JoyCaptionHandler:
    def __init__(self, config):
        self.config = config
        self.pipeline, self.joy_caption = self._initialize()

    def _initialize(self):
        llm_logger.info(_("Loading LLM"))
        joy_caption_load = Joy_caption_load()
        model_path = self.config.server_settings['llm_caption']['llm']
        pipeline, = joy_caption_load.gen(model_path)
        joy_caption = Joy_caption()
        llm_logger.info(_("LLM loading completed, waiting for command"))
        return pipeline, joy_caption

    async def get_caption(self, image, ntags=[]):
        if image.startswith(b"data:image/png;base64,"):
            image = image.replace("data:image/png;base64,", "")
        image = Image.open(BytesIO(base64.b64decode(image))).convert(mode="RGB")

        extra_ = f"do not describe {','.join(ntags)} if it exist" if ntags else ''
        loop = asyncio.get_event_loop()

        caption = await loop.run_in_executor(
            None,
            self.joy_caption.gen,
            self.pipeline,
            image,
            f"A descriptive caption for this image, do not describe a signature or text in the image,{extra_}",
            300,
            0.5,
            True
        )

        return caption[0]


config = init_instance.config
if config.server_settings['llm_caption']['enable']:
    joy_caption_handler = JoyCaptionHandler(config)