sjdtree/model_wrappers/model_loader.py

import argparse
import os
import sys
sys.path.append("./lumina_mgpt/")
sys.path.append("./")
import numpy as np

import gc
from PIL import Image
import torch

from transformers import ChameleonProcessor
# from transformers import ChameleonForConditionalGeneration
from anole.modeling_chameleon import ChameleonForConditionalGeneration

from transformers import AutoTokenizer, AutoModel, AutoImageProcessor, AutoModelForCausalLM
from transformers.generation.configuration_utils import GenerationConfig
from transformers.generation import LogitsProcessorList, PrefixConstrainedLogitsProcessor, UnbatchedClassifierFreeGuidanceLogitsProcessor

from lumina_mgpt.inference_solver import FlexARInferenceSolver
from scheduler.jacobi_iteration_lumina_mgpt import renew_pipeline_sampler
from scheduler.jacobi_iteration_anhole import renew_pipeline_sampler as renew_pipeline_sampler_anhole
from scheduler.jacobi_iteration_emu3 import renew_solver as renew_solver_emu3

import time

def load_lumina_mgpt(
    cache_dir = "./ckpts",
    model_name = "Alpha-VLLM/Lumina-mGPT-7B-768",
    target_size = 768,
    seed = 1,
    max_num_new_tokens = 16,
    multi_token_init_scheme = 'random',
    guidance_scale = 7.0,
    device = "cpu",
    **kwargs,
):
    model_path = model_name

    inference_solver = FlexARInferenceSolver(
        model_path=model_path,
        precision="bf16",
        target_size=target_size,
        cache_dir=cache_dir,
        device = device,
    )
    

    print(inference_solver.__class__)
    inference_solver = renew_pipeline_sampler(
        inference_solver,
        jacobi_loop_interval_l = 1,
        jacobi_loop_interval_r = (target_size // 16)**2 + target_size // 16 - 10,
        max_num_new_tokens = max_num_new_tokens,
        guidance_scale = guidance_scale,
        seed = seed,
        multi_token_init_scheme = multi_token_init_scheme,
        do_cfg = True,
        **kwargs,
    )

    return inference_solver

def load_anole(
    cache_dir = "./ckpts",
    model_name = "leloy/Anole-7b-v0.1-hf",
    target_size = 512,
    seed = 1,
    max_num_new_tokens = 16,
    multi_token_init_scheme = 'random',
    guidance_scale = 7.0,
    device = "cpu",
    dtype = torch.bfloat16,
    image_top_k = 2000,
    text_top_k = 10,
    prefix_token_sampler_scheme = 'speculative_jacobi',
    **kwargs,
):

    processor = ChameleonProcessor.from_pretrained(
        model_name,
        cache_dir=cache_dir,
        torch_dtype=dtype,
    )
    model = ChameleonForConditionalGeneration.from_pretrained(
        model_name,
        device_map="auto",
        cache_dir=cache_dir,
        torch_dtype=dtype,
    )
    model = renew_pipeline_sampler_anhole(
        model,
        processor,
        jacobi_loop_interval_l = 1,
        jacobi_loop_interval_r = (target_size // 16)**2 + target_size // 16 - 10,
        max_num_new_tokens = max_num_new_tokens,
        guidance_scale = guidance_scale,
        seed = seed,
        multi_token_init_scheme = multi_token_init_scheme,
        do_cfg=  True,
        image_top_k=image_top_k, 
        text_top_k=text_top_k,
        prefix_token_sampler_scheme = prefix_token_sampler_scheme,
        **kwargs,
    )

    inference_solver = dict(
        processor=processor,
        model=model,
    )
    
    return inference_solver

def load_emu3(
    cache_dir = "./ckpts",
    model_name = "BAAI/Emu3-Gen",
    target_size = 720,
    seed = 1,
    max_num_new_tokens = 16,
    multi_token_init_scheme = 'random',
    guidance_scale = 7.0,
    device = "cpu",
    dtype = torch.bfloat16,
    image_top_k = 2048,
    text_top_k = 10,
    prefix_token_sampler_scheme = 'speculative_jacobi',
    **kwargs,
):
    from emu3.mllm.processing_emu3 import Emu3Processor

    EMU_HUB = model_name
    VQ_HUB = "BAAI/Emu3-VisionTokenizer"

    model_name = EMU_HUB.split("/")[-1]
    model = AutoModelForCausalLM.from_pretrained(
        EMU_HUB,
        device_map=device,
        torch_dtype=dtype,
        attn_implementation="sdpa", # "sdpa" # "flash_attention_2"
        trust_remote_code=True,
        cache_dir = cache_dir,
    )
    tokenizer = AutoTokenizer.from_pretrained(EMU_HUB, trust_remote_code=True, cache_dir=cache_dir,)
    image_processor = AutoImageProcessor.from_pretrained(VQ_HUB, trust_remote_code=True, cache_dir=cache_dir,)
    image_tokenizer = AutoModel.from_pretrained(VQ_HUB, device_map=device, trust_remote_code=True, cache_dir=cache_dir,).eval()

    image_tokenizer = image_tokenizer.to(dtype)
    processor = Emu3Processor(image_processor, image_tokenizer, tokenizer)

    classifier_free_guidance = guidance_scale

    kwargs = dict(
        mode='G',
        ratio="1:1",
        image_area=model.config.image_area,
        return_tensors="pt",
    )
    GENERATION_CONFIG = GenerationConfig(
        use_cache=True,
        eos_token_id=model.config.eos_token_id,
        pad_token_id=model.config.pad_token_id,
        max_new_tokens=40960,
        do_sample=True,
        top_k=image_top_k,
    )

    h, w = target_size // 8, target_size // 8

    constrained_fn = processor.build_prefix_constrained_fn(h, w)

    model, logits_processor = renew_solver_emu3(
        model, processor, 
        h = h, w = w,
        jacobi_loop_interval_l = 1,
        jacobi_loop_interval_r = h * (w+1) - 1, 
        max_num_new_tokens = max_num_new_tokens,
        guidance_scale = guidance_scale,
        seed = seed,
        multi_token_init_scheme = multi_token_init_scheme,
        do_cfg=  True,
        image_top_k=image_top_k, 
        text_top_k=text_top_k,
        prefix_token_sampler_scheme = prefix_token_sampler_scheme,
        **kwargs,
    )

    inference_solver = dict(
        processor=processor,
        model=model,
        GENERATION_CONFIG=GENERATION_CONFIG,
        logits_processor=logits_processor,
    )
    
    return inference_solver

def load_llamagen(
    cache_dir = "./ckpts",
    model_name = "llamagen", 
    target_size = 512,
    seed = 1,
    max_num_new_tokens = 16, 
    multi_token_init_scheme = 'random',
    guidance_scale = 7.5,
    device = "cpu",
    dtype = torch.bfloat16,
    image_top_k = 1000,
    text_top_k = 10,
    prefix_token_sampler_scheme = 'speculative_jacobi',
    vq_params=dict(
        vq_model="VQ-16",
        codebook_size=16384,
        codebook_embed_dim=8,
        vq_ckpt = "llamagen/vq_ds16_t2i.pt",
        downsample_size=16,
    ),
    backbone_params=dict(
        gpt_model = 'GPT-XL',
        cls_token_num = 120,
        gpt_type = 't2i',
        t5_path = 'llamagen/t5-ckpt',
        t5_model_type = 'flan-t5-xl',
        t5_feature_max_len = 120,
        no_left_padding = False,
    ),
    is_compile = False,
    image_top_p = 1.0,
    temperature = 1.0,
    **kwargs,
):
    from llamagen.tokenizer.tokenizer_image.vq_model import VQ_models
    from llamagen.language.t5 import T5Embedder
    from llamagen.llamagen import GPT_models
    from llamagen.llamagen_solver import LlamaGenSolver, renew_llamagen
    from scheduler.jacobi_iteration_lumina_mgpt import renew_sampler

    vq_ckpt = vq_params['vq_ckpt']
    vq_ckpt = os.path.join(cache_dir, vq_ckpt)
    if target_size == 256:
        gpt_ckpt = "llamagen/t2i_XL_stage1_256.pt"
    else:
        gpt_ckpt = "llamagen/t2i_XL_stage2_512.pt"

    gpt_ckpt = os.path.join(cache_dir, gpt_ckpt)
    t5_path = backbone_params['t5_path']
    t5_path = os.path.join(cache_dir, t5_path)

    codebook_embed_dim = vq_params['codebook_embed_dim']
    # create and load model
    vq_model = VQ_models[ vq_params['vq_model'] ](
        codebook_size= vq_params['codebook_size'],
        codebook_embed_dim= codebook_embed_dim,
    )
    vq_model.to(device)
    vq_model.eval()
    checkpoint = torch.load( vq_ckpt, map_location="cpu")
    vq_model.load_state_dict(checkpoint["model"])
    del checkpoint
    print(f"image tokenizer is loaded")

    # create and load gpt model
    precision = dtype
    latent_size = target_size // vq_params['downsample_size']
    gpt_model = GPT_models[ backbone_params['gpt_model'] ](
        block_size=latent_size ** 2,
        cls_token_num= backbone_params['cls_token_num'],
        model_type= backbone_params['gpt_type'],
    ).to(device=device, dtype=precision)

    print(gpt_model.__class__)

    jacobi_param_dict = dict(
        jacobi_loop_interval_l = 1,
        jacobi_loop_interval_r = latent_size**2 - max_num_new_tokens - 2, 
        max_num_new_tokens = max_num_new_tokens,
        guidance_scale = guidance_scale,
        seed = seed,
        multi_token_init_scheme = multi_token_init_scheme,
        do_cfg=  True,
        image_top_k=image_top_k, 
        prefix_token_sampler_scheme = prefix_token_sampler_scheme,
        **kwargs,
    )

    gpt_model.__class__ = renew_llamagen(gpt_model.__class__)
    gpt_model._init_new_params(**jacobi_param_dict)
    gpt_model.__class__ = renew_sampler(gpt_model.__class__)
    gpt_model._init_new_params(**jacobi_param_dict)

    checkpoint = torch.load( gpt_ckpt , map_location="cpu")
 
    if "model" in checkpoint:  # ddp
        model_weight = checkpoint["model"]
    elif "module" in checkpoint: # deepspeed
        model_weight = checkpoint["module"]
    elif "state_dict" in checkpoint:
        model_weight = checkpoint["state_dict"]
    else:
        raise Exception("please check model weight")
    gpt_model.load_state_dict(model_weight, strict=False)
    gpt_model.eval()
    del checkpoint
    print(f"gpt model is loaded")

    if is_compile:
        print(f"compiling the model...")
        gpt_model = torch.compile(
            gpt_model,
            mode="reduce-overhead",
            fullgraph=True
        ) # requires PyTorch 2.0 (optional)
    else:
        print(f"no need to compile model in demo") 
    
    if not os.path.exists(t5_path):
        os.makedirs(t5_path)

    assert os.path.exists(t5_path), f"t5 model path {t5_path} does not exist"
    t5_model = T5Embedder(
        device=device, 
        local_cache=True, 
        cache_dir=t5_path, 
        dir_or_name= backbone_params['t5_model_type'],
        torch_dtype=precision,
        model_max_length= backbone_params['t5_feature_max_len'],
    )

    model = LlamaGenSolver(
        model = gpt_model,
        image_top_k=image_top_k,
        image_top_p=image_top_p,
    )

    inference_solver = dict(
        model=model,
        gpt_model=gpt_model,
        t5_model = t5_model,
        vq_model = vq_model,
        vq_params = vq_params,
        backbone_params = backbone_params,
        latent_size = latent_size,
        guidance_scale = guidance_scale,
        temperature = temperature,
        image_top_k=image_top_k,
        image_top_p=image_top_p,
    )
    
    return inference_solver

def load_pretrained_model(
    model_name = "Alpha-VLLM/Lumina-mGPT-7B-768", **kwargs,
):
    if ('lumina-mgpt' in model_name.lower()):
        return load_lumina_mgpt(model_name=model_name, **kwargs)
    elif ('anole' in model_name.lower()):
        return load_anole(model_name=model_name, **kwargs)
    elif ('llamagen' in model_name.lower()):
        return load_llamagen(model_name=model_name, **kwargs)
    elif ('emu3' in model_name.lower()):
        return load_emu3(model_name=model_name, **kwargs)
    else:
        raise NotImplementedError


def get_lumina_mgpt_forward_func(
    inference_solver, 
    guidance_scale=7.0, 
    image_top_k=2000,
    max_gen_len=8192,
    temperature=1.0,
    target_size=768,
    **kwargs,
):

    def sample_fn(prompts):
        prompts = f"Generate an image of {target_size}x{target_size} according to the following prompt:\n" + prompts

        generated = inference_solver.generate(
            images=[],
            qas=[[prompts, None]],
            max_gen_len=max_gen_len,
            temperature=temperature,
            logits_processor=inference_solver.create_logits_processor(cfg=guidance_scale, image_top_k=image_top_k),
        )
        a1, new_image = generated[0], generated[1][0]

        result_image = inference_solver.create_image_grid([new_image], 1, 1)
        return result_image
    
    return sample_fn

def get_anole_forward_func(
    inference_solver, 
    **kwargs,
):
    processor = inference_solver['processor']
    model = inference_solver['model']

    def sample_fn(prompts):

        return_accl = kwargs.get("return_accl", False)
        # Prepare a prompt
        prompt = "Generate an image of " + prompts

        # Preprocess the prompt
        inputs = processor(prompt, padding=True, return_tensors="pt").to(model.device, dtype=model.dtype)

        if not return_accl:
            generate_ids = model.generate(
                **inputs,
                multimodal_generation_mode="image-only",
                max_new_tokens=1026,
                do_sample=True,
                return_accl=return_accl
            )
        else:
            # Result(input_ids=input_ids, loop_num=gen_loop_num, token_gen_len = cur_len - init_len,time_forward=t)
            result = model.generate(
                **inputs,
                multimodal_generation_mode="image-only",
                max_new_tokens=1026,
                do_sample=True,
                return_accl=return_accl
            )
            generate_ids = result.input_ids

        # Only keep the tokens from the response
        response_ids = generate_ids[:, inputs["input_ids"].shape[-1]:] #torch.Size([1, 1034])

        # Decode the generated image tokens
        pixel_values = model.decode_image_tokens(response_ids[:, 1:-1])
        pixel_values = pixel_values.to(torch.float32)
        # Ensure detachment and move tensor to CPU.
        detached_chw_tensor = pixel_values.detach().cpu()

        # Normalize tensor to [0, 1] range from [-1, 1] range.
        normalized_chw_tensor = (
            torch.clamp(detached_chw_tensor, -1.0, 1.0) + 1.0
        ) / 2.0

        # Save the image
        hwc_array = normalized_chw_tensor[0].permute(1, 2, 0).cpu().numpy()
        image_array_uint8 = (hwc_array * 255).astype(np.uint8)
        result_image = Image.fromarray(image_array_uint8)

        # Convert image to RGB if it is not already.
        if result_image.mode != "RGB":
            result_image = result_image.convert("RGB")

        if not return_accl:
            return result_image
        else:
            return result_image, result

    return sample_fn


def get_emu3_forward_func(
    inference_solver, 
    not_decoded_imgs=False,
    **kwargs,
):
    processor = inference_solver['processor']
    model = inference_solver['model']
    GENERATION_CONFIG = inference_solver['GENERATION_CONFIG']
    logits_processor = inference_solver['logits_processor']

    def sample_fn(prompts):

        POSITIVE_PROMPT = " masterpiece, film grained, best quality."
        NEGATIVE_PROMPT = "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry."

        prompt = prompts
        prompt += POSITIVE_PROMPT

        pos_inputs = processor(text=prompt, **kwargs)
        neg_inputs = processor(text=NEGATIVE_PROMPT, **kwargs)

        device = model.device

        pos_input_ids = pos_inputs.input_ids
        neg_input_ids = neg_inputs.input_ids

        if not isinstance(pos_input_ids, torch.Tensor):
            pos_input_ids = torch.tensor(pos_input_ids).to(device)
            neg_input_ids = torch.tensor(neg_input_ids).to(device)
        else:
            pos_input_ids = pos_input_ids.to(device)
            neg_input_ids = neg_input_ids.to(device)

        model_inputs = model.prepare_batch_cfg_model_inputs(
            pos_input_ids, 
            neg_input_ids=neg_input_ids, 
            attention_mask=None,
        )
        pos_input_ids = model_inputs['pos_input_ids']
        attention_mask = model_inputs['attention_mask']


        outputs = model.generate(
            pos_input_ids,
            GENERATION_CONFIG,
            logits_processor=logits_processor, 
            attention_mask=attention_mask,
            neg_input_ids=neg_input_ids,
        )
        outputs = outputs[0]

        if not_decoded_imgs:
            result = outputs
        else:

            with torch.no_grad():
                mm_list = processor.decode(outputs)

            result_images = []
            for idx, im in enumerate(mm_list):
                if not isinstance(im, Image.Image):
                    continue

                result_images.append(im)
            
            result = result_images[-1]

        return result

    return sample_fn

def get_llamagen_forward_func(
    inference_solver, 
    **kwargs,
):
    from llamagen.llamagen_solver import generate as llamagen_original_generate
    model = inference_solver['model']
    gpt_model = inference_solver['gpt_model']
    t5_model = inference_solver['t5_model']
    vq_model = inference_solver['vq_model']
    latent_size = inference_solver['latent_size']
    vq_params = inference_solver['vq_params']
    backbone_params = inference_solver['backbone_params']
    guidance_scale = inference_solver['guidance_scale']
    temperature = inference_solver['temperature']
    image_top_k = inference_solver['image_top_k']
    image_top_p = inference_solver['image_top_p']

    codebook_embed_dim = vq_params['codebook_embed_dim']
    no_left_padding = backbone_params['no_left_padding']

    def sample_fn(prompts):

        prompts = [
            prompts, #"A blue Porsche 356 parked in front of a yellow brick wall.",
        ]

        caption_embs, emb_masks = t5_model.get_text_embeddings(prompts)

        if not no_left_padding:
            print(f"processing left-padding...")    
            # a naive way to implement left-padding
            new_emb_masks = torch.flip(emb_masks, dims=[-1])
            new_caption_embs = []
            for idx, (caption_emb, emb_mask) in enumerate(zip(caption_embs, emb_masks)):
                valid_num = int(emb_mask.sum().item())
                print(f'  prompt {idx} token len: {valid_num}')
                new_caption_emb = torch.cat([caption_emb[valid_num:], caption_emb[:valid_num]])
                new_caption_embs.append(new_caption_emb)
            new_caption_embs = torch.stack(new_caption_embs)
        else:
            new_caption_embs, new_emb_masks = caption_embs, emb_masks
        c_indices = new_caption_embs * new_emb_masks[:,:, None]
        c_emb_masks = new_emb_masks

        qzshape = [len(c_indices), codebook_embed_dim, latent_size, latent_size]

        index_sample = llamagen_original_generate(
            gpt_model,
            c_indices, latent_size ** 2, 
            c_emb_masks, 
            cfg_scale= guidance_scale,
            temperature= temperature, top_k= image_top_k,
            top_p= image_top_p, sample_logits=True, 
        )
        samples = vq_model.decode_code(index_sample, qzshape)
        
        images = samples
        images = images.clamp(min=-1, max=1)
        images = (images - images.min()) / (images.max() - images.min()) * 255
        images = images[0].permute(1, 2, 0).cpu().numpy()
        result_image = Image.fromarray((images ).astype("uint8"))

        return result_image

    return sample_fn

def get_forward_func(model_name, model, **kwargs):
    if ('lumina-mgpt' in model_name.lower()):
        return get_lumina_mgpt_forward_func(model, **kwargs)
    elif ('anole' in model_name.lower()):
        return get_anole_forward_func(model, **kwargs)
    elif ('llamagen' in model_name.lower()):
        return get_llamagen_forward_func(model, **kwargs)
    elif ('emu3' in model_name.lower()):
        return get_emu3_forward_func(model, **kwargs)
    else:
        raise NotImplementedError