Add files using upload-large-folder tool

autoregressive/sample/sample_c2i.py

@@ -0,0 +1,151 @@
+# Modified from:
+#   DiT:  https://github.com/facebookresearch/DiT/blob/main/sample.py
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+torch.set_float32_matmul_precision('high')
+setattr(torch.nn.Linear, 'reset_parameters', lambda self: None)
+setattr(torch.nn.LayerNorm, 'reset_parameters', lambda self: None)
+from torchvision.utils import save_image
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+
+from PIL import Image
+import time
+import argparse
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from autoregressive.models.gpt import GPT_models
+from autoregressive.models.generate import generate
+from functools import partial
+import torch.nn.functional as F
+import numpy as np
+import cv2
+
+
+def main(args):
+    # Setup PyTorch:
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    torch.set_grad_enabled(False)
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.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 = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.precision]
+    latent_size = args.image_size // args.downsample_size
+    gpt_model = GPT_models[args.gpt_model](
+        vocab_size=args.codebook_size,
+        block_size=latent_size ** 2,
+        num_classes=args.num_classes,
+        cls_token_num=args.cls_token_num,
+        model_type=args.gpt_type,
+        condition_token_num=args.condition_token_nums,
+        image_size=args.image_size
+    ).to(device=device, dtype=precision)      
+    
+    _, file_extension = os.path.splitext(args.gpt_ckpt)
+    if file_extension.lower() == '.safetensors':
+        from safetensors.torch import load_file
+        model_weight = load_file(args.gpt_ckpt)
+        gpt_model.load_state_dict(model_weight, strict=False)
+        gpt_model.eval()
+    else:
+        checkpoint = torch.load(args.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 args.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") 
+
+    condition_null = None
+    if args.condition_type == 'canny':
+        sample_list = [650, 2312, 15000, 48850]  # canny
+    elif args.condition_type == 'depth':
+        sample_list = [101, 4351, 10601, 48901]
+
+    class_labels = [np.load(f"condition/example/c2i/{args.condition_type}/{i}.npy")[0] for i in sample_list]
+    condition_imgs = [np.array(Image.open((f"condition/example/c2i/{args.condition_type}/{i}.png")))[None,None,...] for i in sample_list]
+    condition_imgs = torch.from_numpy(np.concatenate(condition_imgs, axis=0)).to(device).to(torch.float32)/255
+    condition_imgs = 2*(condition_imgs-0.5)
+    print(condition_imgs.shape)
+    c_indices = torch.tensor(class_labels, device=device)
+    qzshape = [len(class_labels), args.codebook_embed_dim, latent_size, latent_size]
+    t1 = time.time()
+
+    index_sample = generate(
+        gpt_model, c_indices, latent_size ** 2, condition=condition_imgs.repeat(1,3,1,1).to(precision), condition_null=condition_null, condition_token_nums=args.condition_token_nums,
+        cfg_scale=args.cfg_scale, cfg_interval=args.cfg_interval,
+        temperature=args.temperature, top_k=args.top_k,
+        top_p=args.top_p, sample_logits=True, 
+        )
+
+    sampling_time = time.time() - t1
+    print(f"gpt sampling takes about {sampling_time:.2f} seconds.")    
+    
+    t2 = time.time()
+    samples = vq_model.decode_code(index_sample, qzshape) # output value is between [-1, 1]
+    decoder_time = time.time() - t2
+    print(f"decoder takes about {decoder_time:.2f} seconds.")
+    # Save and display images:
+    condition_imgs = condition_imgs.repeat(1,3,1,1)
+    samples = torch.cat((condition_imgs[:4], samples[:4]),dim=0)
+    save_image(samples, f"sample/example/sample_{args.gpt_type}_{args.condition_type}.png", nrow=4, normalize=True, value_range=(-1, 1))
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-B")
+    parser.add_argument("--gpt-ckpt", type=str, default=None)
+    parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="c2i", help="class-conditional or text-conditional")
+    parser.add_argument("--from-fsdp", action='store_true')
+    parser.add_argument("--cls-token-num", type=int, default=1, help="max token number of condition input")
+    parser.add_argument("--precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    parser.add_argument("--compile", action='store_true', default=False)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512], default=256)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--num-classes", type=int, default=1000)
+    parser.add_argument("--cfg-scale", type=float, default=4.0)
+    parser.add_argument("--cfg-interval", type=float, default=-1)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--top-k", type=int, default=2000,help="top-k value to sample with")
+    parser.add_argument("--temperature", type=float, default=1.0, help="temperature value to sample with")
+    parser.add_argument("--top-p", type=float, default=1.0, help="top-p value to sample with")
+    parser.add_argument("--condition-token-nums", type=int, default=0)
+    parser.add_argument("--condition-type", type=str, default='canny', choices=['canny', 'depth'])
+    args = parser.parse_args()
+    main(args)

autoregressive/sample/sample_t2i.py

@@ -0,0 +1,225 @@
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+torch.set_float32_matmul_precision('high')
+setattr(torch.nn.Linear, 'reset_parameters', lambda self: None)     # disable default parameter init for faster speed
+setattr(torch.nn.LayerNorm, 'reset_parameters', lambda self: None)  # disable default parameter init for faster speed
+from torchvision.utils import save_image
+
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+import time
+import argparse
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from language.t5 import T5Embedder
+from autoregressive.models.gpt import GPT_models
+from autoregressive.models.gpt_t2i import GPT_models
+from autoregressive.models.generate import generate
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+from dataset.t2i_control import build_t2i_control_code
+from accelerate import Accelerator
+from dataset.build import build_dataset
+from pathlib import Path
+from accelerate.utils import ProjectConfiguration, set_seed
+import torch.nn.functional as F
+from condition.canny import CannyDetector
+from condition.hed import HEDdetector
+import numpy as np
+from PIL import Image
+from condition.lineart import LineArt
+import cv2
+from transformers import DPTImageProcessor, DPTForDepthEstimation
+def main(args):
+    # Setup PyTorch:
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    torch.set_grad_enabled(False)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.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 = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.precision]
+    latent_size = args.image_size // args.downsample_size
+    gpt_model = GPT_models[args.gpt_model](
+        block_size=latent_size ** 2,
+        cls_token_num=args.cls_token_num,
+        model_type=args.gpt_type,
+        condition_type=args.condition_type,
+        adapter_size=args.adapter_size,
+    ).to(device=device, dtype=precision)
+
+    _, file_extension = os.path.splitext(args.gpt_ckpt)
+    if file_extension.lower() == '.safetensors':
+        from safetensors.torch import load_file
+        model_weight = load_file(args.gpt_ckpt)
+        gpt_model.load_state_dict(model_weight, strict=False)
+        gpt_model.eval()
+    else:
+        checkpoint = torch.load(args.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 args.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") 
+    
+    assert os.path.exists(args.t5_path)
+    t5_model = T5Embedder(
+        device=device, 
+        local_cache=True, 
+        cache_dir=args.t5_path, 
+        dir_or_name=args.t5_model_type,
+        torch_dtype=precision,
+        model_max_length=args.t5_feature_max_len,
+    )
+    
+
+    if args.condition_type == 'canny':
+        get_control = CannyDetector()
+    elif args.condition_type == 'hed':
+        get_control = HEDdetector().to(device).eval()
+    elif args.condition_type == 'lineart':
+        get_control = LineArt()
+        get_control.load_state_dict(torch.load('condition/ckpts/model.pth', map_location=torch.device('cpu')))
+        get_control.to(device)
+    elif args.condition_type == 'depth':
+        processor = DPTImageProcessor.from_pretrained("condition/ckpts/dpt_large")
+        model = DPTForDepthEstimation.from_pretrained("condition/ckpts/dpt_large").to(device)
+    with torch.no_grad():
+        
+        condition_path = args.condition_path
+        if args.condition_type == 'seg':
+            condition_img = torch.from_numpy(np.array(Image.open(condition_path)))
+            condition_img = condition_img.permute(2,0,1).unsqueeze(0).repeat(2,1,1,1)
+        elif args.condition_type == 'canny':
+            condition_img = get_control(np.array(Image.open(condition_path)))
+            condition_img = torch.from_numpy(condition_img[None,None,...]).repeat(2,3,1,1)
+        elif args.condition_type == 'hed':
+            condition_img = get_control(torch.from_numpy(np.array(Image.open(condition_path))).permute(2,0,1).unsqueeze(0).to(device))
+            condition_img = condition_img.unsqueeze(1).repeat(2,3,1,1)
+        elif args.condition_type == 'lineart':
+            condition_img = get_control(torch.from_numpy(np.array(Image.open(condition_path))).permute(2,0,1).unsqueeze(0).to(device).float())
+            condition_img = 1 - condition_img
+            condition_img = condition_img.repeat(2,3,1,1) * 255
+        elif args.condition_type == 'depth':
+            images = Image.open(condition_path)
+            inputs = processor(images=images, return_tensors="pt", size=(512,512)).to(device)
+            outputs = model(**inputs)
+            condition_img = outputs.predicted_depth
+            condition_img = condition_img.unsqueeze(0).repeat(2,3,1,1)
+            condition_img = (condition_img * 255 / condition_img.max())
+        # 所有加载的条件图像都会进行归一化处理，
+        condition_img = condition_img.to(device)
+        condition_img = 2*(condition_img/255 - 0.5)#使得图像值在 [-1, 1] 范围内，以便与生成模型的输入匹配。
+        prompts = [args.prompt if args.prompt is not None else "a high-quality image"]
+        prompts = prompts * 2
+        # 通过 T5Embedder 模型来获取文本提示（prompt）的嵌入向量 caption_embs
+        caption_embs, emb_masks = t5_model.get_text_embeddings(prompts)
+
+        if not args.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), args.codebook_embed_dim, args.image_H//args.downsample_size, args.image_W//args.downsample_size]
+        t1 = time.time()
+        # generate() 函数使用这些输入（文本token：c_indices和图像条件）来生成对应的 图像 token
+        index_sample = generate(
+            gpt_model, c_indices, (args.image_H//args.downsample_size)*(args.image_W//args.downsample_size),#latent_size ** 2, 
+            c_emb_masks, condition=condition_img.to(precision),
+            cfg_scale=args.cfg_scale,
+            temperature=args.temperature, top_k=args.top_k,
+            top_p=args.top_p, sample_logits=True, 
+            control_strength=args.control_strength,
+            )
+        sampling_time = time.time() - t1
+        print(f"Full sampling takes about {sampling_time:.2f} seconds.")    
+        
+        t2 = time.time()
+        print(index_sample.shape)
+        # 生成的图像 token（index_sample）会通过 vq_model.decode_code() 解码成实际的图像样本
+        samples = vq_model.decode_code(index_sample, qzshape) # output value is between [-1, 1]
+        decoder_time = time.time() - t2
+        print(f"decoder takes about {decoder_time:.2f} seconds.")
+
+        samples = torch.cat((condition_img[0:1], samples), dim=0)
+        save_image(samples, f"sample/example/sample_t2i_{args.condition_type}.png", nrow=4, normalize=True, value_range=(-1, 1))
+        print(f"image is saved to sample/example/sample_t2i_{args.condition_type}.png")
+        print(prompts)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--t5-path", type=str, default='checkpoints/t5-ckpt')
+    parser.add_argument("--t5-model-type", type=str, default='flan-t5-xl')
+    parser.add_argument("--t5-feature-max-len", type=int, default=120)
+    parser.add_argument("--t5-feature-dim", type=int, default=2048)
+    parser.add_argument("--no-left-padding", action='store_true', default=False)
+    parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL")
+    parser.add_argument("--gpt-ckpt", type=str, default=None)
+    parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="t2i", help="class->image or text->image")  
+    parser.add_argument("--cls-token-num", type=int, default=120, help="max token number of condition input")
+    parser.add_argument("--precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    parser.add_argument("--compile", action='store_true', default=False)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--image-size", type=int, choices=[256, 320, 384, 400, 448, 512, 576, 640, 704, 768], default=768)
+    parser.add_argument("--image-H", type=int, default=512)
+    parser.add_argument("--image-W", type=int, default=512)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--cfg-scale", type=float, default=4)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--top-k", type=int, default=2000, help="top-k value to sample with")
+    parser.add_argument("--temperature", type=float, default=1.0, help="temperature value to sample with")
+    parser.add_argument("--top-p", type=float, default=1.0, help="top-p value to sample with")
+
+    parser.add_argument("--mixed-precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    parser.add_argument("--condition-type", type=str, choices=['seg', 'canny', 'hed', 'lineart', 'depth', 'canny_base'], default="canny")
+    parser.add_argument("--prompt", type=str, default='a high-quality image')
+    parser.add_argument("--condition-path", type=str, default='condition/example/t2i/multigen/landscape.png')
+    parser.add_argument("--adapter-size", type=str, default='small')
+
+    parser.add_argument("--control-strength", type=float, default=1.0)
+    args = parser.parse_args()
+    main(args)

autoregressive/sample/sample_t2i_MR.py

@@ -0,0 +1,238 @@
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+torch.set_float32_matmul_precision('high')
+setattr(torch.nn.Linear, 'reset_parameters', lambda self: None)     # disable default parameter init for faster speed
+setattr(torch.nn.LayerNorm, 'reset_parameters', lambda self: None)  # disable default parameter init for faster speed
+from torchvision.utils import save_image
+
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+import time
+import argparse
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from language.t5 import T5Embedder
+from autoregressive.models.gpt import GPT_models
+from autoregressive.models.gpt_t2i import GPT_models
+from autoregressive.models.generate import generate
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+from dataset.t2i_control import build_t2i_control_code
+from accelerate import Accelerator
+from dataset.build import build_dataset
+from pathlib import Path
+from accelerate.utils import ProjectConfiguration, set_seed
+import torch.nn.functional as F
+from condition.canny import CannyDetector
+from condition.hed import HEDdetector
+import numpy as np
+from PIL import Image
+from condition.lineart import LineArt
+import cv2
+from transformers import DPTImageProcessor, DPTForDepthEstimation
+from condition.midas.depth import MidasDetector
+
+
+def resize_image_to_16_multiple(image_path, condition_type='seg'):
+    image = Image.open(image_path)
+    width, height = image.size
+    
+    if condition_type == 'depth':  # The depth model requires a side length that is a multiple of 32
+        new_width = (width + 31) // 32 * 32
+        new_height = (height + 31) // 32 * 32
+    else:
+        new_width = (width + 15) // 16 * 16
+        new_height = (height + 15) // 16 * 16
+
+    resized_image = image.resize((new_width, new_height))
+    return resized_image
+
+def main(args):
+    # Setup PyTorch:
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    torch.set_grad_enabled(False)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.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 = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.precision]
+    latent_size = args.image_size // args.downsample_size
+    gpt_model = GPT_models[args.gpt_model](
+        block_size=latent_size ** 2,
+        cls_token_num=args.cls_token_num,
+        model_type=args.gpt_type,
+        condition_type=args.condition_type,
+    ).to(device=device, dtype=precision)
+
+    _, file_extension = os.path.splitext(args.gpt_ckpt)
+    if file_extension.lower() == '.safetensors':
+        from safetensors.torch import load_file
+        model_weight = load_file(args.gpt_ckpt)
+        gpt_model.load_state_dict(model_weight, strict=False)
+        gpt_model.eval()
+    else:
+        checkpoint = torch.load(args.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 args.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") 
+    
+    assert os.path.exists(args.t5_path)
+    t5_model = T5Embedder(
+        device=device, 
+        local_cache=True, 
+        cache_dir=args.t5_path, 
+        dir_or_name=args.t5_model_type,
+        torch_dtype=precision,
+        model_max_length=args.t5_feature_max_len,
+    )
+    
+
+    if args.condition_type == 'canny':
+        get_control = CannyDetector()
+    elif args.condition_type == 'hed':
+        get_control = HEDdetector().to(device).eval()
+    elif args.condition_type == 'lineart':
+        get_control = LineArt()
+        get_control.load_state_dict(torch.load('condition/ckpts/model.pth', map_location=torch.device('cpu')))
+        get_control.to(device)
+    elif args.condition_type == 'depth':
+        processor = DPTImageProcessor.from_pretrained("condition/ckpts/dpt_large")
+        model_large = DPTForDepthEstimation.from_pretrained("condition/ckpts/dpt_large").to(device)
+        model = MidasDetector(device=device)
+    with torch.no_grad():
+        
+        condition_img = resize_image_to_16_multiple(args.condition_path, args.condition_type)
+        W, H = condition_img.size
+        print(H,W)
+        if args.condition_type == 'seg':
+            condition_img = torch.from_numpy(np.array(condition_img))
+            condition_img = condition_img.permute(2,0,1).unsqueeze(0).repeat(2,1,1,1)
+        elif args.condition_type == 'canny':
+            condition_img = get_control(np.array(condition_img))
+            condition_img = torch.from_numpy(condition_img[None,None,...]).repeat(2,3,1,1)
+        elif args.condition_type == 'hed':
+            condition_img = get_control(torch.from_numpy(np.array(condition_img)).permute(2,0,1).unsqueeze(0).to(device))
+            condition_img = condition_img.unsqueeze(1).repeat(2,3,1,1)
+        elif args.condition_type == 'lineart':
+            condition_img = get_control(torch.from_numpy(np.array(condition_img)).permute(2,0,1).unsqueeze(0).to(device).float())
+            condition_img = condition_img.repeat(2,3,1,1) * 255
+        elif args.condition_type == 'depth':
+            images = condition_img
+            if H == W:
+                inputs = processor(images=images, return_tensors="pt", size=(H,W)).to(device)
+                outputs = model_large(**inputs)
+                condition_img = outputs.predicted_depth
+                condition_img = (condition_img * 255 / condition_img.max())
+            else:
+                condition_img = torch.from_numpy(model(torch.from_numpy(np.array(condition_img)).to(device))).unsqueeze(0)
+            condition_img = condition_img.unsqueeze(0).repeat(2,3,1,1)
+        condition_img = condition_img.to(device)
+        condition_img = 2*(condition_img/255 - 0.5)
+        prompts = [args.prompt if args.prompt is not None else "a high-quality image"]
+        prompts = prompts * 2
+        caption_embs, emb_masks = t5_model.get_text_embeddings(prompts)
+
+        if not args.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), args.codebook_embed_dim, H//args.downsample_size, W//args.downsample_size]
+        t1 = time.time()
+        index_sample = generate(
+            gpt_model, c_indices, (H//args.downsample_size)*(W//args.downsample_size),#latent_size ** 2, 
+            c_emb_masks, condition=condition_img.to(precision),
+            cfg_scale=args.cfg_scale,
+            temperature=args.temperature, top_k=args.top_k,
+            top_p=args.top_p, sample_logits=True, 
+            )
+        sampling_time = time.time() - t1
+        print(f"Full sampling takes about {sampling_time:.2f} seconds.")    
+        
+        t2 = time.time()
+        print(index_sample.shape)
+        samples = vq_model.decode_code(index_sample, qzshape) # output value is between [-1, 1]
+        decoder_time = time.time() - t2
+        print(f"decoder takes about {decoder_time:.2f} seconds.")
+
+        samples = torch.cat((condition_img[0:1], samples), dim=0)
+        save_image(samples, f"sample/example/sample_t2i_MR_{args.condition_type}.png", nrow=4, normalize=True, value_range=(-1, 1))
+        print(f"image is saved to sample/example/sample_t2i_MR_{args.condition_type}.png")
+        print(prompts)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--t5-path", type=str, default='checkpoints/t5-ckpt')
+    parser.add_argument("--t5-model-type", type=str, default='flan-t5-xl')
+    parser.add_argument("--t5-feature-max-len", type=int, default=120)
+    parser.add_argument("--t5-feature-dim", type=int, default=2048)
+    parser.add_argument("--no-left-padding", action='store_true', default=False)
+    parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL")
+    parser.add_argument("--gpt-ckpt", type=str, default=None)
+    parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="t2i", help="class->image or text->image")  
+    parser.add_argument("--cls-token-num", type=int, default=120, help="max token number of condition input")
+    parser.add_argument("--precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    parser.add_argument("--compile", action='store_true', default=False)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--image-size", type=int, choices=[256, 320, 384, 400, 448, 512, 576, 640, 704, 768], default=768)
+    parser.add_argument("--image-H", type=int, default=512)
+    parser.add_argument("--image-W", type=int, default=512)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--cfg-scale", type=float, default=4)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--top-k", type=int, default=2000, help="top-k value to sample with")
+    parser.add_argument("--temperature", type=float, default=1.0, help="temperature value to sample with")
+    parser.add_argument("--top-p", type=float, default=1.0, help="top-p value to sample with")
+
+    parser.add_argument("--mixed-precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    parser.add_argument("--condition-type", type=str, choices=['seg', 'canny', 'hed', 'lineart', 'depth'], default="canny")
+    parser.add_argument("--prompt", type=str, default='a high-quality image')
+    parser.add_argument("--condition-path", type=str, default='condition/example/t2i/multigen/landscape.png')
+    args = parser.parse_args()
+    main(args)

autoregressive/serve/README.md

@@ -0,0 +1,58 @@
+## serving by vLLM
+
+### Install
+```
+pip install vllm==0.4.1
+```
+
+### Comparison (A100)
+
+Method | params | baseline(s) | vllm(s) | speed-up ratio 
+--- |:---:|:---:|:---:|:---:
+[GPT-B](./fake_json/GPT-B.json)    | 111M | 7.80    | 2.39      |  326 %
+[GPT-L](./fake_json/GPT-L.json)    | 343M | 13.72   | 3.48      |  380 %
+[GPT-XL](./fake_json/GPT-XL.json)  | 775M | 19.76   | 4.84      |  408 %
+[GPT-XXL](./fake_json/GPT-XXL.json)| 1.4B | 26.38   | 6.36      |  414 %
+[GPT-3B](./fake_json/GPT-3B.json)  | 3.1B | 14.73   | 6.26      |  235 %
+
+```
+### GPT-B
+# 7.80 seconds
+python3 autoregressive/sample/sample_c2i.py --vq-ckpt ./pretrained_models/vq_ds16_c2i.pt --gpt-ckpt ./pretrained_models/c2i_B_384.pt --image-size 384
+
+# 2.39 seconds
+python3 autoregressive/serve/sample_c2i.py --vq-ckpt ./pretrained_models/vq_ds16_c2i.pt --gpt-ckpt ./pretrained_models/c2i_B_384.pt --image-size 384
+
+
+### GPT-L
+# 13.72 seconds
+python3 autoregressive/sample/sample_c2i.py --vq-ckpt ./pretrained_models/vq_ds16_c2i.pt --gpt-ckpt ./pretrained_models/c2i_L_384.pt --gpt-model GPT-L --image-size 384
+
+# 3.48 seconds
+python3 autoregressive/serve/sample_c2i.py --vq-ckpt ./pretrained_models/vq_ds16_c2i.pt --gpt-ckpt ./pretrained_models/c2i_L_384.pt --gpt-model GPT-L --image-size 384
+
+
+### GPT-XL
+# 19.76 seconds
+python3 autoregressive/sample/sample_c2i.py --vq-ckpt ./pretrained_models/vq_ds16_c2i.pt --gpt-ckpt ./pretrained_models/c2i_XL_384.pt --gpt-model GPT-XL --image-size 384
+
+# 4.84 seconds
+python3 autoregressive/serve/sample_c2i.py --vq-ckpt ./pretrained_models/vq_ds16_c2i.pt --gpt-ckpt ./pretrained_models/c2i_XL_384.pt --gpt-model GPT-XL --image-size 384
+
+
+### GPT-XXL
+# 26.38 seconds
+python3 autoregressive/sample/sample_c2i.py --vq-ckpt ./pretrained_models/vq_ds16_c2i.pt --gpt-ckpt ./pretrained_models/c2i_XXL_384.pt --from-fsdp --gpt-model GPT-XXL --image-size 384
+
+# 6.36 seconds
+python3 autoregressive/serve/sample_c2i.py --vq-ckpt ./pretrained_models/vq_ds16_c2i.pt --gpt-ckpt ./pretrained_models/c2i_XXL_384.pt --from-fsdp --gpt-model GPT-XXL --image-size 384
+
+
+### GPT-3B
+# 14.73 seconds
+python3 autoregressive/sample/sample_c2i.py --vq-ckpt ./pretrained_models/vq_ds16_c2i.pt --gpt-ckpt ./pretrained_models/c2i_3B_384.pt --from-fsdp --gpt-model GPT-3B --image-size 384
+
+# 6.26 seconds
+python3 autoregressive/serve/sample_c2i.py --vq-ckpt ./pretrained_models/vq_ds16_c2i.pt --gpt-ckpt ./pretrained_models/c2i_3B_384.pt --from-fsdp --gpt-model GPT-3B --image-size 384
+
+```

autoregressive/serve/fake_json/GPT-3B.json

@@ -0,0 +1,28 @@
+{
+  "_name_or_path": "facebook/opt-125m",
+  "activation_dropout": 0.0,
+  "activation_function": "relu",
+  "architectures": [
+    "OPTForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "bos_token_id": 2,
+  "do_layer_norm_before": true,
+  "dropout": 0.1,
+  "eos_token_id": 2,
+  "ffn_dim": 3072,
+  "hidden_size": 3584,
+  "init_std": 0.02,
+  "layerdrop": 0.0,
+  "max_position_embeddings": 2048,
+  "model_type": "opt",
+  "num_attention_heads": 32,
+  "num_hidden_layers": 24,
+  "pad_token_id": 1,
+  "prefix": "</s>",
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.21.0.dev0",
+  "use_cache": true,
+  "vocab_size": 16384,
+  "word_embed_proj_dim": 768
+}

autoregressive/serve/fake_json/GPT-B.json

@@ -0,0 +1,28 @@
+{
+  "_name_or_path": "facebook/opt-125m",
+  "activation_dropout": 0.0,
+  "activation_function": "relu",
+  "architectures": [
+    "OPTForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "bos_token_id": 2,
+  "do_layer_norm_before": true,
+  "dropout": 0.1,
+  "eos_token_id": 2,
+  "ffn_dim": 3072,
+  "hidden_size": 768,
+  "init_std": 0.02,
+  "layerdrop": 0.0,
+  "max_position_embeddings": 2048,
+  "model_type": "opt",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 1,
+  "prefix": "</s>",
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.21.0.dev0",
+  "use_cache": true,
+  "vocab_size": 16384,
+  "word_embed_proj_dim": 768
+}

autoregressive/serve/fake_json/GPT-L.json

@@ -0,0 +1,28 @@
+{
+  "_name_or_path": "facebook/opt-125m",
+  "activation_dropout": 0.0,
+  "activation_function": "relu",
+  "architectures": [
+    "OPTForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "bos_token_id": 2,
+  "do_layer_norm_before": true,
+  "dropout": 0.1,
+  "eos_token_id": 2,
+  "ffn_dim": 3072,
+  "hidden_size": 1024,
+  "init_std": 0.02,
+  "layerdrop": 0.0,
+  "max_position_embeddings": 2048,
+  "model_type": "opt",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 24,
+  "pad_token_id": 1,
+  "prefix": "</s>",
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.21.0.dev0",
+  "use_cache": true,
+  "vocab_size": 16384,
+  "word_embed_proj_dim": 768
+}

autoregressive/serve/fake_json/GPT-XL.json

@@ -0,0 +1,28 @@
+{
+  "_name_or_path": "facebook/opt-125m",
+  "activation_dropout": 0.0,
+  "activation_function": "relu",
+  "architectures": [
+    "OPTForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "bos_token_id": 2,
+  "do_layer_norm_before": true,
+  "dropout": 0.1,
+  "eos_token_id": 2,
+  "ffn_dim": 3072,
+  "hidden_size": 1280,
+  "init_std": 0.02,
+  "layerdrop": 0.0,
+  "max_position_embeddings": 2048,
+  "model_type": "opt",
+  "num_attention_heads": 20,
+  "num_hidden_layers": 36,
+  "pad_token_id": 1,
+  "prefix": "</s>",
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.21.0.dev0",
+  "use_cache": true,
+  "vocab_size": 16384,
+  "word_embed_proj_dim": 768
+}

autoregressive/serve/fake_json/GPT-XXL.json

@@ -0,0 +1,28 @@
+{
+  "_name_or_path": "facebook/opt-125m",
+  "activation_dropout": 0.0,
+  "activation_function": "relu",
+  "architectures": [
+    "OPTForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "bos_token_id": 2,
+  "do_layer_norm_before": true,
+  "dropout": 0.1,
+  "eos_token_id": 2,
+  "ffn_dim": 3072,
+  "hidden_size": 1536,
+  "init_std": 0.02,
+  "layerdrop": 0.0,
+  "max_position_embeddings": 2048,
+  "model_type": "opt",
+  "num_attention_heads": 24,
+  "num_hidden_layers": 48,
+  "pad_token_id": 1,
+  "prefix": "</s>",
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.21.0.dev0",
+  "use_cache": true,
+  "vocab_size": 16384,
+  "word_embed_proj_dim": 768
+}

autoregressive/serve/gpt_model.py

@@ -0,0 +1,419 @@
+from dataclasses import dataclass
+from typing import Optional, List
+
+import torch
+import torch.nn as nn
+
+from vllm.model_executor.layers.layernorm import RMSNorm
+from vllm.model_executor.layers.activation import SiluAndMul
+from vllm.model_executor.sampling_metadata import SamplingMetadata
+from vllm.sequence import SamplerOutput
+
+from vllm.attention import AttentionMetadata
+from vllm.attention import Attention as pagedAttention
+
+from vllm.model_executor.layers.logits_processor import LogitsProcessor
+from autoregressive.serve.sampler import Sampler
+
+def find_multiple(n: int, k: int):
+    if n % k == 0:
+        return n
+    return n + k - (n % k)
+
+@dataclass
+class ModelArgs:
+    dim: int = 4096
+    n_layer: int = 32
+    n_head: int = 32
+    n_kv_head: Optional[int] = None
+    multiple_of: int = 256  # make SwiGLU hidden layer size multiple of large power of 2
+    ffn_dim_multiplier: Optional[float] = None
+    rope_base: float = 10000
+    norm_eps: float = 1e-5
+    initializer_range: float = 0.02
+    
+    num_classes: int = 1000
+    class_dropout_prob: float = 0.1
+    model_type: str = 'c2i'
+    cfg_scale: float = 4.0
+
+    vocab_size: int = 16384
+    cls_token_num: int = 1
+    block_size: int = 256
+    max_batch_size: int = 32
+    max_seq_len: int = 2048
+
+
+#################################################################################
+#                      Embedding Layers for Class Labels                        #
+#################################################################################
+class LabelEmbedder(nn.Module):
+    """
+    Embeds class labels into vector representations. Also handles label dropout for classifier-free guidance.
+    """
+    def __init__(self, num_classes, hidden_size, dropout_prob):
+        super().__init__()
+        use_cfg_embedding = dropout_prob > 0
+        self.embedding_table = nn.Embedding(num_classes + use_cfg_embedding, hidden_size)
+        self.num_classes = num_classes
+        self.dropout_prob = dropout_prob
+
+    # def token_drop(self, labels, force_drop_ids=None):
+    #     """
+    #     Drops labels to enable classifier-free guidance.
+    #     """
+    #     if force_drop_ids is None:
+    #         drop_ids = torch.rand(labels.shape[0], device=labels.device) < self.dropout_prob
+    #     else:
+    #         drop_ids = force_drop_ids == 1
+    #     labels = torch.where(drop_ids, self.num_classes, labels)
+    #     return labels
+
+    # def forward(self, labels, train, force_drop_ids=None):
+    def forward(self, labels):
+        # use_dropout = self.dropout_prob > 0
+        # if (train and use_dropout) or (force_drop_ids is not None):
+        #     labels = self.token_drop(labels, force_drop_ids)
+        embeddings = self.embedding_table(labels)
+        return embeddings
+
+
+#################################################################################
+#                                  GPT Model                                    #
+#################################################################################
+# class RMSNorm(torch.nn.Module):
+#     def __init__(self, dim: int, eps: float = 1e-5):
+#         super().__init__()
+#         self.eps = eps
+#         self.weight = nn.Parameter(torch.ones(dim))
+
+#     def _norm(self, x):
+#         return x * torch.rsqrt(torch.mean(x * x, dim=-1, keepdim=True) + self.eps)
+
+#     def forward(self, x):
+#         output = self._norm(x.float()).type_as(x)
+#         return output * self.weight
+
+
+class FeedForward(nn.Module):
+    def __init__(self, config: ModelArgs):
+        super().__init__()
+        hidden_dim = 4 * config.dim
+        hidden_dim = int(2 * hidden_dim / 3)
+        # custom dim factor multiplier
+        if config.ffn_dim_multiplier is not None:
+            hidden_dim = int(config.ffn_dim_multiplier * hidden_dim)
+        hidden_dim = find_multiple(hidden_dim, config.multiple_of)
+
+        # self.w1 = nn.Linear(config.dim, hidden_dim, bias=False)
+        # self.w3 = nn.Linear(config.dim, hidden_dim, bias=False)
+        self.w_merged = nn.Linear(config.dim, hidden_dim * 2, bias=False)
+        self.act_fn = SiluAndMul()
+
+        self.w2 = nn.Linear(hidden_dim, config.dim, bias=False)
+        # self.ffn_dropout = nn.Dropout(config.ffn_dropout_p)
+
+    # def forward(self, x):
+    #     return self.ffn_dropout(self.w2(F.silu(self.w1(x)) * self.w3(x)))
+
+    def forward(self, x):
+        x = self.w_merged(x)
+        x = self.act_fn(x)
+        x = self.w2(x)
+        # return self.ffn_dropout(x)
+        return x
+
+
+class Attention(nn.Module):
+    def __init__(self, config: ModelArgs):
+        super().__init__()
+        assert config.dim % config.n_head == 0
+        self.dim = config.dim
+        self.head_dim = config.dim // config.n_head
+        self.n_head = config.n_head
+        self.n_kv_head = config.n_kv_head if config.n_kv_head is not None else config.n_head
+        total_kv_dim = (self.n_head + 2 * self.n_kv_head) * self.head_dim
+
+        # key, query, value projections for all heads, but in a batch
+        self.wqkv = nn.Linear(config.dim, total_kv_dim, bias=False)
+        self.wo = nn.Linear(config.dim, config.dim, bias=False)
+
+        # pagedAttention
+        if config.dim // config.n_head == 100:
+            self.attn = None  # for this case, we need to overwrite the attn in AttentionMonkeyPatch
+        else:
+            self.attn = pagedAttention(self.n_head, self.head_dim, self.head_dim**-0.5, num_kv_heads=self.n_kv_head)
+
+        # 2d rotary pos embedding
+        grid_size = int(config.block_size ** 0.5)
+        assert grid_size * grid_size == config.block_size
+        freqs_cis = precompute_freqs_cis_2d(grid_size, config.dim // config.n_head, config.rope_base, config.cls_token_num)
+        self.register_buffer('freqs_cis', freqs_cis)
+
+
+    def forward(
+        self, 
+        x: torch.Tensor,
+        positions: torch.Tensor, 
+        kv_cache: torch.Tensor,
+        attn_metadata: AttentionMetadata,
+    ):  
+        kv_size = self.n_kv_head * self.head_dim
+        xq, xk, xv = self.wqkv(x).split([self.dim, kv_size, kv_size], dim=-1)
+
+        xq = xq.view(*xq.shape[:-1], 1, self.n_head, self.head_dim)
+        xk = xk.view(*xk.shape[:-1], 1, self.n_kv_head, self.head_dim)
+        freqs_cis = self.freqs_cis[positions].unsqueeze(1)        
+        xq = apply_rotary_emb_bs(xq, freqs_cis)
+        xk = apply_rotary_emb_bs(xk, freqs_cis)
+        xq = xq.flatten(1)
+        xk = xk.flatten(1)
+
+        output = self.attn(xq, xk, xv, kv_cache, attn_metadata)
+        output = self.wo(output)
+        
+        return output
+
+
+class AttentionMonkeyPatch(Attention):
+    """
+    Note:
+    In vllm, PagedAttention supports head sizes [64, 80, 96, 112, 128, 256].
+    However, LlamaGen-3B model has head size 100 (for some historical reasons).
+    Here we hack Attnetion to enable vllm support head size 100.
+    """
+    def __init__(self, config: ModelArgs):
+        super().__init__(config)
+        # overwrite PagedAttention
+        # hard-coded 112 for LlamaGen-3B model
+        self.attn = pagedAttention(self.n_head, 112, 100**-0.5, num_kv_heads=self.n_kv_head)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        positions: torch.Tensor,
+        kv_cache: torch.Tensor,
+        attn_metadata: AttentionMetadata,
+    ):
+        kv_size = self.n_kv_head * self.head_dim
+        xq, xk, xv = self.wqkv(x).split([self.dim, kv_size, kv_size], dim=-1)
+
+        xq = xq.view(*xq.shape[:-1], 1, self.n_head, self.head_dim)
+        xk = xk.view(*xk.shape[:-1], 1, self.n_kv_head, self.head_dim)
+        freqs_cis = self.freqs_cis[positions].unsqueeze(1)
+        xq = apply_rotary_emb_bs(xq, freqs_cis)
+        xk = apply_rotary_emb_bs(xk, freqs_cis)
+        xq = xq.flatten(1)
+        xk = xk.flatten(1)
+        ############ padding to 112 to make vllm happy ############
+        zero_pad = torch.zeros(xq.shape[0], self.n_head, 112 - 100, device=xq.device, dtype=xq.dtype)
+        xq = xq.reshape(xq.shape[0], self.n_head, self.head_dim)
+        xk = xk.reshape(xk.shape[0], self.n_kv_head, self.head_dim)
+        xv = xv.reshape(xv.shape[0], self.n_kv_head, self.head_dim)
+        xq = torch.concat([xq, zero_pad], dim=-1).flatten(1)
+        xk = torch.concat([xk, zero_pad], dim=-1).flatten(1)
+        xv = torch.concat([xv, zero_pad], dim=-1).flatten(1)
+
+        output = self.attn(xq, xk, xv, kv_cache, attn_metadata)
+        ############ de-padding to 100 ############
+        output = output.reshape(output.shape[0], self.n_head, 112)
+        output = output[..., :100].flatten(1)
+
+        output = self.wo(output)
+
+        return output
+
+
+class TransformerBlock(nn.Module):
+    def __init__(self, config: ModelArgs):
+        super().__init__()
+        if config.dim // config.n_head == 100:
+            self.attention = AttentionMonkeyPatch(config)
+        else:
+            self.attention = Attention(config)
+        self.feed_forward = FeedForward(config)
+        self.attention_norm = RMSNorm(config.dim, eps=config.norm_eps)
+        self.ffn_norm = RMSNorm(config.dim, eps=config.norm_eps)
+
+    def forward(self, x: torch.Tensor, positions: torch.Tensor, kv_cache: torch.Tensor, attn_metadata: AttentionMetadata):
+        h = x + self.attention(self.attention_norm(x), positions, kv_cache, attn_metadata)
+        out = h + self.feed_forward(self.ffn_norm(h))
+        return out
+        
+
+class Transformer(nn.Module):
+    def __init__(self, config: ModelArgs):
+        super().__init__()
+        self.config = config
+        self.vocab_size = config.vocab_size
+        self.n_layer = config.n_layer
+        self.block_size = config.block_size
+        self.num_classes = config.num_classes
+        self.model_type = config.model_type
+        self.cls_token_num = config.cls_token_num
+        self.cfg_scale = config.cfg_scale
+        if self.model_type == 'c2i':
+            self.cls_embedding = LabelEmbedder(config.num_classes, config.dim, config.class_dropout_prob)
+        else:
+            raise Exception("vllm only supports c2i now, please check model type")
+        self.tok_embeddings = nn.Embedding(config.vocab_size, config.dim)
+
+        self.layers = torch.nn.ModuleList()
+        for layer_id in range(config.n_layer):
+            self.layers.append(TransformerBlock(config))
+
+        # output layer
+        self.norm = RMSNorm(config.dim, eps=config.norm_eps)
+        self.output = nn.Linear(config.dim, config.vocab_size, bias=False)
+
+        self.logits_processor = LogitsProcessor(config.vocab_size)
+
+        self.sampler = Sampler(config.cfg_scale)
+
+    def forward(
+        self, 
+        input_ids: torch.Tensor=None,
+        positions: torch.Tensor=None,
+        kv_caches: List[torch.Tensor]=None,
+        attn_metadata: AttentionMetadata=None,
+    ):
+        # if positions.max() == 0: # prefill in inference
+        #     token_embeddings = self.cls_embedding(input_ids)
+        # else: # decode_n_tokens(kv cache) in inference
+        #     token_embeddings = self.tok_embeddings(input_ids)
+        cond_ids = torch.clamp(input_ids, max=self.num_classes)
+        token_embeddings = self.cls_embedding(cond_ids) * (positions.max() == 0) + \
+            self.tok_embeddings(input_ids) * (positions.max() != 0)
+
+        hh = token_embeddings
+        # transformer blocks
+        for layer_id, layer in enumerate(self.layers):
+            hh = layer(hh, positions, kv_caches[layer_id], attn_metadata)
+        
+        # output layers
+        hh = self.norm(hh)
+        return hh
+
+    def compute_logits(self, hidden_states: torch.Tensor,
+                       sampling_metadata: SamplingMetadata) -> torch.Tensor:
+        logits = self.logits_processor(self.output.weight, hidden_states, sampling_metadata)
+        return logits
+
+    def sample(
+        self,
+        logits: torch.Tensor,
+        sampling_metadata: SamplingMetadata,
+    ) -> Optional[SamplerOutput]:
+        next_tokens = self.sampler(logits, sampling_metadata)
+        return next_tokens
+        
+
+    def custom_load_state_dict(self, model_weights):
+        model_weights = model_weights.copy()
+        for layer_id in range(len(self.layers)):
+            branch1 = f'layers.{layer_id}.feed_forward.w1.weight'
+            branch3 = f'layers.{layer_id}.feed_forward.w3.weight'
+            branch_merged = f'layers.{layer_id}.feed_forward.w_merged.weight'
+            model_weights[branch_merged] = torch.cat(
+                [model_weights[branch1], model_weights[branch3]], dim=0
+            )
+            model_weights.pop(branch1)
+            model_weights.pop(branch3)
+
+        if 'freqs_cis' in model_weights:
+            model_weights.pop('freqs_cis')
+        
+        self.load_state_dict(model_weights, strict=False)
+
+
+
+#################################################################################
+#                      Rotary Positional Embedding Functions                    #
+#################################################################################
+# https://github.com/pytorch-labs/gpt-fast/blob/main/model.py 
+def precompute_freqs_cis(seq_len: int, n_elem: int, base: int = 10000, cls_token_num=120):
+    freqs = 1.0 / (base ** (torch.arange(0, n_elem, 2)[: (n_elem // 2)].float() / n_elem))
+    t = torch.arange(seq_len, device=freqs.device)
+    freqs = torch.outer(t, freqs) # (seq_len, head_dim // 2)
+    freqs_cis = torch.polar(torch.ones_like(freqs), freqs)
+    cache = torch.stack([freqs_cis.real, freqs_cis.imag], dim=-1) # (cls_token_num+seq_len, head_dim // 2, 2)
+    cond_cache = torch.cat([torch.zeros(cls_token_num, n_elem // 2, 2), cache]) # (cls_token_num+seq_len, head_dim // 2, 2)
+    return cond_cache 
+
+
+def precompute_freqs_cis_2d(grid_size: int, n_elem: int, base: int = 10000, cls_token_num=120):
+    # split the dimension into half, one for x and one for y
+    half_dim = n_elem // 2
+    freqs = 1.0 / (base ** (torch.arange(0, half_dim, 2)[: (half_dim // 2)].float() / half_dim))
+    t = torch.arange(grid_size, device=freqs.device)
+    freqs = torch.outer(t, freqs) # (grid_size, head_dim // 2)
+    freqs_grid = torch.concat([
+        freqs[:, None, :].expand(-1, grid_size, -1),
+        freqs[None, :, :].expand(grid_size, -1, -1),
+    ], dim=-1)  # (grid_size, grid_size, head_dim // 2)
+    cache_grid = torch.stack([torch.cos(freqs_grid), torch.sin(freqs_grid)], dim=-1) # (grid_size, grid_size, head_dim // 2, 2)
+    cache = cache_grid.flatten(0, 1)
+    cond_cache = torch.cat([torch.zeros(cls_token_num, n_elem // 2, 2), cache]) # (cls_token_num+grid_size**2, head_dim // 2, 2)
+    return cond_cache 
+
+
+def apply_rotary_emb(x: torch.Tensor, freqs_cis: torch.Tensor):
+    # x: (bs, seq_len, n_head, head_dim)
+    # freqs_cis (seq_len, head_dim // 2, 2)
+    xshaped = x.float().reshape(*x.shape[:-1], -1, 2) # (bs, seq_len, n_head, head_dim//2, 2)
+    freqs_cis = freqs_cis.view(1, xshaped.size(1), 1, xshaped.size(3), 2) # (1, seq_len, 1, head_dim//2, 2)
+    x_out2 = torch.stack([
+            xshaped[..., 0] * freqs_cis[..., 0] - xshaped[..., 1] * freqs_cis[..., 1],
+            xshaped[..., 1] * freqs_cis[..., 0] + xshaped[..., 0] * freqs_cis[..., 1],
+    ], dim=-1)
+    x_out2 = x_out2.flatten(3)
+    return x_out2.type_as(x)
+
+
+def apply_rotary_emb_bs(x: torch.Tensor, freqs_cis: torch.Tensor):
+    # x: (bs, seq_len, n_head, head_dim)
+    # freqs_cis (seq_len, head_dim // 2, 2)
+    xshaped = x.float().reshape(*x.shape[:-1], -1, 2) # (bs, seq_len, n_head, head_dim//2, 2)
+    freqs_cis = freqs_cis.view(xshaped.size(0), xshaped.size(1), 1, xshaped.size(3), 2) # (bs, seq_len, 1, head_dim//2, 2)
+    x_out2 = torch.stack([
+            xshaped[..., 0] * freqs_cis[..., 0] - xshaped[..., 1] * freqs_cis[..., 1],
+            xshaped[..., 1] * freqs_cis[..., 0] + xshaped[..., 0] * freqs_cis[..., 1],
+    ], dim=-1)
+    x_out2 = x_out2.flatten(3)
+    return x_out2.type_as(x)
+
+
+#################################################################################
+#                                GPT Configs                                    #
+#################################################################################
+### text-conditional
+def GPT_7B(**kwargs):
+    return Transformer(ModelArgs(n_layer=32, n_head=32, dim=4096, **kwargs)) # 6.6B
+
+def GPT_3B(**kwargs):
+    return Transformer(ModelArgs(n_layer=24, n_head=32, dim=3200, **kwargs)) # 3.1B
+
+def GPT_1B(**kwargs):
+    return Transformer(ModelArgs(n_layer=22, n_head=32, dim=2048, **kwargs)) # 1.2B
+
+### class-conditional
+def GPT_XXXL(**kwargs):
+    return Transformer(ModelArgs(n_layer=48, n_head=40, dim=2560, **kwargs)) # 3.9B
+
+def GPT_XXL(**kwargs):
+    return Transformer(ModelArgs(n_layer=48, n_head=24, dim=1536, **kwargs)) # 1.4B
+
+def GPT_XL(**kwargs):
+    return Transformer(ModelArgs(n_layer=36, n_head=20, dim=1280, **kwargs)) # 775M
+
+def GPT_L(**kwargs):
+    return Transformer(ModelArgs(n_layer=24, n_head=16, dim=1024, **kwargs)) # 343M
+
+def GPT_B(**kwargs):
+    return Transformer(ModelArgs(n_layer=12, n_head=12, dim=768, **kwargs)) # 111M
+        
+
+GPT_models = {
+    'GPT-B': GPT_B, 'GPT-L': GPT_L, 'GPT-XL': GPT_XL, 'GPT-XXL': GPT_XXL, 'GPT-XXXL': GPT_XXXL,
+    'GPT-1B': GPT_1B, 'GPT-3B': GPT_3B, 'GPT-7B': GPT_7B, 
+}

autoregressive/serve/gpu_executor.py

@@ -0,0 +1,201 @@
+from typing import Dict, List, Set, Tuple, Optional, Set
+import argparse
+
+from vllm.config import (CacheConfig, DeviceConfig, LoadConfig, LoRAConfig,
+                         ModelConfig, ParallelConfig, SchedulerConfig,
+                         SpeculativeConfig, VisionLanguageConfig)
+from vllm.executor.executor_base import ExecutorAsyncBase, ExecutorBase
+from vllm.logger import init_logger
+from vllm.lora.request import LoRARequest
+from vllm.sequence import SamplerOutput, SequenceGroupMetadata
+from vllm.utils import (get_distributed_init_method, get_ip, get_open_port,
+                        make_async)
+
+logger = init_logger(__name__)
+
+
+class GPUExecutor(ExecutorBase):
+    def __init__(
+        self,
+        args: argparse.ArgumentParser,
+        model_config: ModelConfig,
+        cache_config: CacheConfig,
+        parallel_config: ParallelConfig,
+        scheduler_config: SchedulerConfig,
+        device_config: DeviceConfig,
+        load_config: LoadConfig,
+        lora_config: Optional[LoRAConfig],
+        vision_language_config: Optional[VisionLanguageConfig],
+        speculative_config: Optional[SpeculativeConfig],
+    ) -> None:
+        self.args = args
+        self.model_config = model_config
+        self.cache_config = cache_config
+        self.lora_config = lora_config
+        self.load_config = load_config
+        self.parallel_config = parallel_config
+        self.scheduler_config = scheduler_config
+        self.device_config = device_config
+        self.vision_language_config = vision_language_config
+        self.speculative_config = speculative_config
+
+        self._init_executor()
+
+    def _init_executor(self) -> None:
+        """Initialize the worker and load the model.
+
+        If speculative decoding is enabled, we instead create the speculative
+        worker.
+        """
+        if self.speculative_config is None:
+            self._init_non_spec_worker()
+        else:
+            self._init_spec_worker()
+
+    def _init_non_spec_worker(self):
+        # Lazy import the Worker to avoid importing torch.cuda/xformers
+        # before CUDA_VISIBLE_DEVICES is set in the Worker
+        # from vllm.worker.worker import Worker
+        from autoregressive.serve.worker import Worker
+
+        assert self.parallel_config.world_size == 1, (
+            "GPUExecutor only supports single GPU.")
+
+        distributed_init_method = get_distributed_init_method(
+            get_ip(), get_open_port())
+        self.driver_worker = Worker(
+            model_config=self.model_config,
+            parallel_config=self.parallel_config,
+            scheduler_config=self.scheduler_config,
+            device_config=self.device_config,
+            cache_config=self.cache_config,
+            load_config=self.load_config,
+            local_rank=0,
+            rank=0,
+            distributed_init_method=distributed_init_method,
+            lora_config=self.lora_config,
+            vision_language_config=self.vision_language_config,
+            is_driver_worker=True,
+        )
+        self.driver_worker.init_device()
+        self.driver_worker.load_model(self.args)
+
+    def _init_spec_worker(self):
+        """Initialize a SpecDecodeWorker, using a draft model for proposals.
+        """
+        assert self.speculative_config is not None
+
+        from vllm.spec_decode.multi_step_worker import MultiStepWorker
+        from vllm.spec_decode.spec_decode_worker import SpecDecodeWorker
+        from vllm.worker.worker import Worker
+
+        distributed_init_method = get_distributed_init_method(
+            get_ip(), get_open_port())
+
+        target_worker = Worker(
+            model_config=self.model_config,
+            parallel_config=self.parallel_config,
+            scheduler_config=self.scheduler_config,
+            device_config=self.device_config,
+            cache_config=self.cache_config,
+            load_config=self.load_config,
+            local_rank=0,
+            rank=0,
+            distributed_init_method=distributed_init_method,
+            lora_config=self.lora_config,
+            vision_language_config=self.vision_language_config,
+            is_driver_worker=True,
+        )
+
+        draft_worker = MultiStepWorker(
+            model_config=self.speculative_config.draft_model_config,
+            parallel_config=self.speculative_config.draft_parallel_config,
+            scheduler_config=self.scheduler_config,
+            device_config=self.device_config,
+            cache_config=self.cache_config,
+            load_config=self.load_config,
+            local_rank=0,
+            rank=0,
+            distributed_init_method=distributed_init_method,
+            lora_config=self.lora_config,
+            vision_language_config=self.vision_language_config,
+            is_driver_worker=True,
+        )
+
+        spec_decode_worker = SpecDecodeWorker.from_workers(
+            proposer_worker=draft_worker, scorer_worker=target_worker)
+
+        assert self.parallel_config.world_size == 1, (
+            "GPUExecutor only supports single GPU.")
+
+        self.driver_worker = spec_decode_worker
+
+        # Load model handled in spec decode worker.
+        self.driver_worker.init_device()
+
+    def determine_num_available_blocks(self) -> Tuple[int, int]:
+        """Determine the number of available KV blocks by invoking the
+        underlying worker.
+        """
+        return self.driver_worker.determine_num_available_blocks()
+
+    def initialize_cache(self, num_gpu_blocks: int, num_cpu_blocks) -> None:
+        """Initialize the KV cache by invoking the underlying worker.
+        """
+        # NOTE: This is logged in the executor because there can be >1 worker
+        # with other executors. We could log in the engine level, but work
+        # remains to abstract away the device for non-GPU configurations.
+        logger.info(f"# GPU blocks: {num_gpu_blocks}, "
+                    f"# CPU blocks: {num_cpu_blocks}")
+
+        self.driver_worker.initialize_cache(num_gpu_blocks, num_cpu_blocks)
+
+    def execute_model(
+        self,
+        seq_group_metadata_list: List[SequenceGroupMetadata],
+        blocks_to_swap_in: Dict[int, int],
+        blocks_to_swap_out: Dict[int, int],
+        blocks_to_copy: Dict[int, List[int]],
+        num_lookahead_slots: int,
+    ) -> List[SamplerOutput]:
+        output = self.driver_worker.execute_model(
+            seq_group_metadata_list=seq_group_metadata_list,
+            blocks_to_swap_in=blocks_to_swap_in,
+            blocks_to_swap_out=blocks_to_swap_out,
+            blocks_to_copy=blocks_to_copy,
+            num_lookahead_slots=num_lookahead_slots,
+        )
+        return output
+
+    def add_lora(self, lora_request: LoRARequest) -> bool:
+        assert lora_request.lora_int_id > 0, "lora_id must be greater than 0."
+        return self.driver_worker.add_lora(lora_request)
+
+    def remove_lora(self, lora_id: int) -> bool:
+        assert lora_id > 0, "lora_id must be greater than 0."
+        return self.driver_worker.remove_lora(lora_id)
+
+    def list_loras(self) -> Set[int]:
+        return self.driver_worker.list_loras()
+
+    def check_health(self) -> None:
+        # GPUExecutor will always be healthy as long as
+        # it's running.
+        return
+
+
+class GPUExecutorAsync(GPUExecutor, ExecutorAsyncBase):
+
+    async def execute_model_async(
+        self,
+        seq_group_metadata_list: List[SequenceGroupMetadata],
+        blocks_to_swap_in: Dict[int, int],
+        blocks_to_swap_out: Dict[int, int],
+        blocks_to_copy: Dict[int, List[int]],
+    ) -> SamplerOutput:
+        output = await make_async(self.driver_worker.execute_model)(
+            seq_group_metadata_list=seq_group_metadata_list,
+            blocks_to_swap_in=blocks_to_swap_in,
+            blocks_to_swap_out=blocks_to_swap_out,
+            blocks_to_copy=blocks_to_copy)
+        return output

autoregressive/serve/llm_engine.py

@@ -0,0 +1,671 @@
+# Modified from:
+#   vLLM:    https://github.com/vllm-project/vllm/blob/main/vllm/engine/llm_engine.py
+import time
+from typing import Iterable, List, Optional, Type, Union
+import argparse
+
+from transformers import GenerationConfig, PreTrainedTokenizer
+
+import vllm
+from vllm.config import (CacheConfig, DecodingConfig, DeviceConfig, LoadConfig,
+                         LoRAConfig, ModelConfig, ParallelConfig,
+                         SchedulerConfig, SpeculativeConfig,
+                         VisionLanguageConfig)
+from vllm.core.scheduler import Scheduler, SchedulerOutputs
+from vllm.engine.arg_utils import EngineArgs
+from vllm.engine.metrics import StatLogger, Stats
+from vllm.engine.output_processor.interfaces import (
+    SequenceGroupOutputProcessor)
+from vllm.engine.output_processor.stop_checker import StopChecker
+from vllm.engine.output_processor.util import create_output_by_sequence_group
+from vllm.engine.ray_utils import initialize_ray_cluster
+from vllm.executor.executor_base import ExecutorBase
+from vllm.logger import init_logger
+from vllm.lora.request import LoRARequest
+from vllm.outputs import RequestOutput
+from vllm.sampling_params import SamplingParams
+from vllm.sequence import (MultiModalData, SamplerOutput, Sequence,
+                           SequenceGroup)
+from vllm.transformers_utils.detokenizer import Detokenizer
+from vllm.transformers_utils.tokenizer_group import (BaseTokenizerGroup,
+                                                     get_tokenizer_group)
+from vllm.usage.usage_lib import (UsageContext, is_usage_stats_enabled,
+                                  usage_message)
+from vllm.utils import Counter
+
+logger = init_logger(__name__)
+_LOCAL_LOGGING_INTERVAL_SEC = 5
+
+
+def _load_generation_config_dict(model_config: ModelConfig):
+    try:
+        return GenerationConfig.from_pretrained(
+            model_config.model,
+            revision=model_config.revision,
+        ).to_diff_dict()
+    except OSError:
+        # Not found.
+        return {}
+
+
+class LLMEngine:
+    """An LLM engine that receives requests and generates texts.
+
+    This is the main class for the vLLM engine. It receives requests
+    from clients and generates texts from the LLM. It includes a tokenizer, a
+    language model (possibly distributed across multiple GPUs), and GPU memory
+    space allocated for intermediate states (aka KV cache). This class utilizes
+    iteration-level scheduling and efficient memory management to maximize the
+    serving throughput.
+
+    The `LLM` class wraps this class for offline batched inference and the
+    `AsyncLLMEngine` class wraps this class for online serving.
+
+    NOTE: The config arguments are derived from the `EngineArgs` class. For the
+    comprehensive list of arguments, see `EngineArgs`.
+
+    Args:
+        model_config: The configuration related to the LLM model.
+        cache_config: The configuration related to the KV cache memory
+            management.
+        parallel_config: The configuration related to distributed execution.
+        scheduler_config: The configuration related to the request scheduler.
+        device_config: The configuration related to the device.
+        lora_config (Optional): The configuration related to serving multi-LoRA.
+        vision_language_config (Optional): The configuration related to vision
+            language models.
+        speculative_config (Optional): The configuration related to speculative
+            decoding.
+        executor_class: The model executor class for managing distributed
+            execution.
+        log_stats: Whether to log statistics.
+        usage_context: Specified entry point, used for usage info collection
+    """
+
+    def __init__(
+        self,
+        args: argparse.ArgumentParser,
+        model_config: ModelConfig,
+        cache_config: CacheConfig,
+        parallel_config: ParallelConfig,
+        scheduler_config: SchedulerConfig,
+        device_config: DeviceConfig,
+        load_config: LoadConfig,
+        lora_config: Optional[LoRAConfig],
+        vision_language_config: Optional[VisionLanguageConfig],
+        speculative_config: Optional[SpeculativeConfig],
+        decoding_config: Optional[DecodingConfig],
+        executor_class: Type[ExecutorBase],
+        log_stats: bool,
+        usage_context: UsageContext = UsageContext.ENGINE_CONTEXT,
+    ) -> None:
+        logger.info(
+            f"Initializing an LLM engine (v{vllm.__version__}) with config: "
+            f"model={model_config.model!r}, "
+            f"speculative_config={speculative_config!r}, "
+            f"tokenizer={model_config.tokenizer!r}, "
+            f"skip_tokenizer_init={model_config.skip_tokenizer_init}, "
+            f"tokenizer_mode={model_config.tokenizer_mode}, "
+            f"revision={model_config.revision}, "
+            f"tokenizer_revision={model_config.tokenizer_revision}, "
+            f"trust_remote_code={model_config.trust_remote_code}, "
+            f"dtype={model_config.dtype}, "
+            f"max_seq_len={model_config.max_model_len}, "
+            f"download_dir={load_config.download_dir!r}, "
+            f"load_format={load_config.load_format}, "
+            f"tensor_parallel_size={parallel_config.tensor_parallel_size}, "
+            f"disable_custom_all_reduce="
+            f"{parallel_config.disable_custom_all_reduce}, "
+            f"quantization={model_config.quantization}, "
+            f"enforce_eager={model_config.enforce_eager}, "
+            f"kv_cache_dtype={cache_config.cache_dtype}, "
+            f"quantization_param_path={model_config.quantization_param_path}, "
+            f"device_config={device_config.device}, "
+            f"decoding_config={decoding_config!r}, "
+            f"seed={model_config.seed})")
+        # TODO(woosuk): Print more configs in debug mode.
+
+        self.model_config = model_config
+        self.cache_config = cache_config
+        self.lora_config = lora_config
+        self.vision_language_config = vision_language_config
+        self.parallel_config = parallel_config
+        self.scheduler_config = scheduler_config
+        self.device_config = device_config
+        self.speculative_config = speculative_config
+        self.load_config = load_config
+        self.decoding_config = decoding_config or DecodingConfig()
+        self.log_stats = log_stats
+
+        if not self.model_config.skip_tokenizer_init:
+            self.tokenizer: BaseTokenizerGroup
+            self._init_tokenizer()
+            self.detokenizer = Detokenizer(self.tokenizer)
+        else:
+            self.detokenizer = None
+            self.tokenizer = None
+
+        self.seq_counter = Counter()
+        self.generation_config_fields = _load_generation_config_dict(
+            model_config)
+
+        self.model_executor = executor_class(
+            args=args,
+            model_config=model_config,
+            cache_config=cache_config,
+            parallel_config=parallel_config,
+            scheduler_config=scheduler_config,
+            device_config=device_config,
+            lora_config=lora_config,
+            vision_language_config=vision_language_config,
+            speculative_config=speculative_config,
+            load_config=load_config,
+        )
+
+        self._initialize_kv_caches()
+
+        # If usage stat is enabled, collect relevant info.
+        if is_usage_stats_enabled():
+            from vllm.model_executor.model_loader import (
+                get_architecture_class_name)
+            usage_message.report_usage(
+                get_architecture_class_name(model_config),
+                usage_context,
+                extra_kvs={
+                    # Common configuration
+                    "dtype":
+                    str(model_config.dtype),
+                    "tensor_parallel_size":
+                    parallel_config.tensor_parallel_size,
+                    "block_size":
+                    cache_config.block_size,
+                    "gpu_memory_utilization":
+                    cache_config.gpu_memory_utilization,
+
+                    # Quantization
+                    "quantization":
+                    model_config.quantization,
+                    "kv_cache_dtype":
+                    cache_config.cache_dtype,
+
+                    # Feature flags
+                    "enable_lora":
+                    bool(lora_config),
+                    "enable_prefix_caching":
+                    cache_config.enable_prefix_caching,
+                    "enforce_eager":
+                    model_config.enforce_eager,
+                    "disable_custom_all_reduce":
+                    parallel_config.disable_custom_all_reduce,
+                })
+
+        if self.tokenizer:
+            # Ping the tokenizer to ensure liveness if it runs in a
+            # different process.
+            self.tokenizer.ping()
+
+        # Create the scheduler.
+        # NOTE: the cache_config here have been updated with the numbers of
+        # GPU and CPU blocks, which are profiled in the distributed executor.
+        self.scheduler = Scheduler(scheduler_config, cache_config, lora_config)
+
+        # Metric Logging.
+        if self.log_stats:
+            self.stat_logger = StatLogger(
+                local_interval=_LOCAL_LOGGING_INTERVAL_SEC,
+                labels=dict(model_name=model_config.model))
+            self.stat_logger.info("cache_config", self.cache_config)
+
+        # Create sequence output processor, e.g. for beam search or
+        # speculative decoding.
+        self.output_processor = (
+            SequenceGroupOutputProcessor.create_output_processor(
+                self.scheduler_config,
+                self.detokenizer,
+                self.scheduler,
+                self.seq_counter,
+                self.get_tokenizer_for_seq,
+                stop_checker=StopChecker(
+                    self.scheduler_config.max_model_len,
+                    self.get_tokenizer_for_seq,
+                ),
+            ))
+
+    def _initialize_kv_caches(self) -> None:
+        """Initialize the KV cache in the worker(s).
+
+        The workers will determine the number of blocks in both the GPU cache
+        and the swap CPU cache.
+        """
+        num_gpu_blocks, num_cpu_blocks = (
+            self.model_executor.determine_num_available_blocks())
+
+        if self.cache_config.num_gpu_blocks_override is not None:
+            num_gpu_blocks_override = self.cache_config.num_gpu_blocks_override
+            logger.info(f"Overriding {num_gpu_blocks=} with "
+                        f"{num_gpu_blocks_override=}")
+            num_gpu_blocks = num_gpu_blocks_override
+
+        self.cache_config.num_gpu_blocks = num_gpu_blocks
+        self.cache_config.num_cpu_blocks = num_cpu_blocks
+
+        self.model_executor.initialize_cache(num_gpu_blocks, num_cpu_blocks)
+
+    @classmethod
+    def from_engine_args(
+        cls,
+        engine_args: EngineArgs,
+        usage_context: UsageContext = UsageContext.ENGINE_CONTEXT,
+        args: argparse.ArgumentParser = None,
+    ) -> "LLMEngine":
+        """Creates an LLM engine from the engine arguments."""
+        # Create the engine configs.
+        engine_config = engine_args.create_engine_config()
+
+        # Initialize the cluster and specify the executor class.
+        if engine_config.device_config.device_type == "neuron":
+            from vllm.executor.neuron_executor import NeuronExecutor
+            executor_class = NeuronExecutor
+        elif engine_config.device_config.device_type == "cpu":
+            from vllm.executor.cpu_executor import CPUExecutor
+            executor_class = CPUExecutor
+        elif engine_config.parallel_config.worker_use_ray:
+            initialize_ray_cluster(engine_config.parallel_config)
+            from vllm.executor.ray_gpu_executor import RayGPUExecutor
+            executor_class = RayGPUExecutor
+        else:
+            assert engine_config.parallel_config.world_size == 1, (
+                "Ray is required if parallel_config.world_size > 1.")
+            # from vllm.executor.gpu_executor import GPUExecutor
+            from autoregressive.serve.gpu_executor import GPUExecutor
+            executor_class = GPUExecutor
+
+        # Create the LLM engine.
+        engine = cls(
+            **engine_config.to_dict(),
+            executor_class=executor_class,
+            log_stats=not engine_args.disable_log_stats,
+            usage_context=usage_context,
+            args=args,
+        )
+        return engine
+
+    def __reduce__(self):
+        # This is to ensure that the LLMEngine is not referenced in
+        # the closure used to initialize Ray worker actors
+        raise RuntimeError("LLMEngine should not be pickled!")
+
+    def get_tokenizer(self) -> "PreTrainedTokenizer":
+        return self.tokenizer.get_lora_tokenizer(None)
+
+    def get_tokenizer_for_seq(self,
+                              sequence: Sequence) -> "PreTrainedTokenizer":
+        return self.tokenizer.get_lora_tokenizer(sequence.lora_request)
+
+    def _init_tokenizer(self, **tokenizer_init_kwargs):
+        init_kwargs = dict(
+            tokenizer_id=self.model_config.tokenizer,
+            enable_lora=bool(self.lora_config),
+            max_num_seqs=self.scheduler_config.max_num_seqs,
+            max_input_length=None,
+            tokenizer_mode=self.model_config.tokenizer_mode,
+            trust_remote_code=self.model_config.trust_remote_code,
+            revision=self.model_config.tokenizer_revision)
+        init_kwargs.update(tokenizer_init_kwargs)
+        self.tokenizer = get_tokenizer_group(
+            self.parallel_config.tokenizer_pool_config, **init_kwargs)
+
+    def _verify_args(self) -> None:
+        self.model_config.verify_with_parallel_config(self.parallel_config)
+        self.cache_config.verify_with_parallel_config(self.parallel_config)
+        if self.lora_config:
+            self.lora_config.verify_with_model_config(self.model_config)
+            self.lora_config.verify_with_scheduler_config(
+                self.scheduler_config)
+
+    def encode_request(
+        self,
+        request_id: str,  # pylint: disable=unused-argument
+        prompt: Optional[str],
+        prompt_token_ids: Optional[List[int]] = None,
+        lora_request: Optional[LoRARequest] = None,
+    ):
+        if prompt_token_ids is None:
+            assert prompt is not None
+            prompt_token_ids = self.tokenizer.encode(request_id=request_id,
+                                                     prompt=prompt,
+                                                     lora_request=lora_request)
+        return prompt_token_ids
+
+    def add_request(
+        self,
+        request_id: str,
+        prompt: Optional[str],
+        sampling_params: SamplingParams,
+        prompt_token_ids: Optional[List[int]] = None,
+        arrival_time: Optional[float] = None,
+        lora_request: Optional[LoRARequest] = None,
+        multi_modal_data: Optional[MultiModalData] = None,
+    ) -> None:
+        """Add a request to the engine's request pool.
+
+        The request is added to the request pool and will be processed by the
+        scheduler as `engine.step()` is called. The exact scheduling policy is
+        determined by the scheduler.
+
+        Args:
+            request_id: The unique ID of the request.
+            prompt: The prompt string. Can be None if prompt_token_ids is
+                provided.
+            sampling_params: The sampling parameters for text generation.
+            prompt_token_ids: The token IDs of the prompt. If None, we
+                use the tokenizer to convert the prompts to token IDs.
+            arrival_time: The arrival time of the request. If None, we use
+                the current monotonic time.
+            multi_modal_data: Multi modal data per request.
+
+        Details:
+            - Set arrival_time to the current time if it is None.
+            - Set prompt_token_ids to the encoded prompt if it is None.
+            - Create `best_of` number of :class:`~vllm.Sequence` objects.
+            - Create a :class:`~vllm.SequenceGroup` object
+              from the list of :class:`~vllm.Sequence`.
+            - Add the :class:`~vllm.SequenceGroup` object to the scheduler.
+
+        Example:
+            >>> # initialize engine
+            >>> engine = LLMEngine.from_engine_args(engine_args)
+            >>> # set request arguments
+            >>> example_prompt = "Who is the president of the United States?"
+            >>> sampling_params = SamplingParams(temperature=0.0)
+            >>> request_id = 0
+            >>>
+            >>> # add the request to the engine
+            >>> engine.add_request(
+            >>>    str(request_id),
+            >>>    example_prompt,
+            >>>    SamplingParams(temperature=0.0))
+            >>> # continue the request processing
+            >>> ...
+        """
+        if lora_request is not None and not self.lora_config:
+            raise ValueError(f"Got lora_request {lora_request} but LoRA is "
+                             "not enabled!")
+        max_logprobs = self.get_model_config().max_logprobs
+        if (sampling_params.logprobs
+                and sampling_params.logprobs > max_logprobs) or (
+                    sampling_params.prompt_logprobs
+                    and sampling_params.prompt_logprobs > max_logprobs):
+            raise ValueError(f"Cannot request more than "
+                             f"{max_logprobs} logprobs.")
+        if arrival_time is None:
+            arrival_time = time.time()
+        prompt_token_ids = self.encode_request(
+            request_id=request_id,
+            prompt=prompt,
+            prompt_token_ids=prompt_token_ids,
+            lora_request=lora_request)
+
+        # Create the sequences.
+        block_size = self.cache_config.block_size
+        seq_id = next(self.seq_counter)
+        eos_token_id = None
+        if self.tokenizer:
+            eos_token_id = self.tokenizer.get_lora_tokenizer(
+                lora_request).eos_token_id
+        else:
+            logger.warning("Use None for EOS token id because tokenizer is "
+                           "not initialized")
+        seq = Sequence(seq_id, prompt, prompt_token_ids, block_size,
+                       eos_token_id, lora_request)
+        
+        # Defensive copy of SamplingParams, which are used by the sampler,
+        # this doesn't deep-copy LogitsProcessor objects
+        sampling_params = sampling_params.clone()
+        # Add the eos token id into the sampling_params to support min_tokens
+        # processing
+        if seq.eos_token_id is not None:
+            sampling_params.all_stop_token_ids.add(seq.eos_token_id)
+        sampling_params.update_from_generation_config(
+            self.generation_config_fields)
+
+        # Create the sequence group.
+        seq_group = SequenceGroup(request_id, [seq], sampling_params,
+                                  arrival_time, lora_request, multi_modal_data)
+
+        # Add the sequence group to the scheduler.
+        self.scheduler.add_seq_group(seq_group)
+
+    def abort_request(self, request_id: Union[str, Iterable[str]]) -> None:
+        """Aborts a request(s) with the given ID.
+
+        Args:
+            request_id: The ID(s) of the request to abort.
+
+        Details:
+            - Refer to the
+              :meth:`~vllm.core.scheduler.Scheduler.abort_seq_group`
+              from class :class:`~vllm.core.scheduler.Scheduler`.
+
+        Example:
+            >>> # initialize engine and add a request with request_id
+            >>> request_id = str(0)
+            >>> # abort the request
+            >>> engine.abort_request(request_id)
+        """
+        self.scheduler.abort_seq_group(request_id)
+
+    def get_model_config(self) -> ModelConfig:
+        """Gets the model configuration."""
+        return self.model_config
+
+    def get_num_unfinished_requests(self) -> int:
+        """Gets the number of unfinished requests."""
+        return self.scheduler.get_num_unfinished_seq_groups()
+
+    def has_unfinished_requests(self) -> bool:
+        """Returns True if there are unfinished requests."""
+        return self.scheduler.has_unfinished_seqs()
+
+    def _process_model_outputs(
+            self, output: List[SamplerOutput],
+            scheduled_seq_groups: List[SequenceGroup],
+            ignored_seq_groups: List[SequenceGroup]) -> List[RequestOutput]:
+        """Apply the model output to the sequences in the scheduled seq groups.
+
+        Returns RequestOutputs that can be returned to the client.
+        """
+        now = time.time()
+
+        # Organize outputs by [sequence group][step] instead of
+        # [step][sequence group].
+        output_by_sequence_group = create_output_by_sequence_group(
+            sampler_outputs=output, num_seq_groups=len(scheduled_seq_groups))
+
+        # Update the scheduled sequence groups with the model outputs.
+        for scheduled_seq_group, outputs in zip(scheduled_seq_groups,
+                                                output_by_sequence_group):
+            seq_group = scheduled_seq_group.seq_group
+            seq_group.update_num_computed_tokens(
+                scheduled_seq_group.token_chunk_size)
+            # If uncomputed tokens > 0, it means prefill is chunked.
+            # We don't need to process outputs in that case.
+            if seq_group.get_num_uncomputed_tokens() == 0:
+                self.output_processor.process_outputs(seq_group, outputs)
+
+        # Free the finished sequence groups.
+        self.scheduler.free_finished_seq_groups()
+
+        # Create the outputs.
+        request_outputs: List[RequestOutput] = []
+        for scheduled_seq_group in scheduled_seq_groups:
+            seq_group = scheduled_seq_group.seq_group
+            seq_group.maybe_set_first_token_time(now)
+            request_output = RequestOutput.from_seq_group(seq_group)
+            request_outputs.append(request_output)
+        for seq_group in ignored_seq_groups:
+            request_output = RequestOutput.from_seq_group(seq_group)
+            request_outputs.append(request_output)
+        return request_outputs
+
+    def step(self) -> List[RequestOutput]:
+        """Performs one decoding iteration and returns newly generated results.
+
+        .. figure:: https://i.imgur.com/sv2HssD.png
+            :alt: Overview of the step function
+            :align: center
+
+            Overview of the step function.
+
+        Details:
+            - Step 1: Schedules the sequences to be executed in the next
+              iteration and the token blocks to be swapped in/out/copy.
+
+                - Depending on the scheduling policy,
+                  sequences may be `preempted/reordered`.
+                - A Sequence Group (SG) refer to a group of sequences
+                  that are generated from the same prompt.
+
+            - Step 2: Calls the distributed executor to execute the model.
+            - Step 3: Processes the model output. This mainly includes:
+
+                - Decodes the relevant outputs.
+                - Updates the scheduled sequence groups with model outputs
+                  based on its `sampling parameters` (`use_beam_search` or not).
+                - Frees the finished sequence groups.
+
+            - Finally, it creates and returns the newly generated results.
+
+        Example:
+            >>> # Please see the example/ folder for more detailed examples.
+            >>>
+            >>> # initialize engine and request arguments
+            >>> engine = LLMEngine.from_engine_args(engine_args)
+            >>> example_inputs = [(0, "What is LLM?",
+            >>>    SamplingParams(temperature=0.0))]
+            >>>
+            >>> # Start the engine with an event loop
+            >>> while True:
+            >>>     if example_inputs:
+            >>>         req_id, prompt, sampling_params = example_inputs.pop(0)
+            >>>         engine.add_request(str(req_id), prompt, sampling_params)
+            >>>
+            >>>     # continue the request processing
+            >>>     request_outputs = engine.step()
+            >>>     for request_output in request_outputs:
+            >>>         if request_output.finished:
+            >>>             # return or show the request output
+            >>>
+            >>>     if not (engine.has_unfinished_requests() or example_inputs):
+            >>>         break
+        """
+        seq_group_metadata_list, scheduler_outputs = self.scheduler.schedule()
+        if not scheduler_outputs.is_empty():
+            output = self.model_executor.execute_model(
+                seq_group_metadata_list=seq_group_metadata_list,
+                blocks_to_swap_in=scheduler_outputs.blocks_to_swap_in,
+                blocks_to_swap_out=scheduler_outputs.blocks_to_swap_out,
+                blocks_to_copy=scheduler_outputs.blocks_to_copy,
+                num_lookahead_slots=scheduler_outputs.num_lookahead_slots)
+        else:
+            output = []
+
+        request_outputs = self._process_model_outputs(
+            output, scheduler_outputs.scheduled_seq_groups,
+            scheduler_outputs.ignored_seq_groups)
+
+        # Log stats.
+        if self.log_stats:
+            self.stat_logger.log(self._get_stats(scheduler_outputs))
+
+        return request_outputs
+
+    def do_log_stats(self) -> None:
+        """Forced log when no requests active."""
+        if self.log_stats:
+            self.stat_logger.log(self._get_stats(scheduler_outputs=None))
+
+    def _get_stats(self,
+                   scheduler_outputs: Optional[SchedulerOutputs]) -> Stats:
+        """Get Stats to be Logged to Prometheus."""
+        now = time.time()
+
+        # KV Cache Usage in %.
+        num_total_gpu = self.cache_config.num_gpu_blocks
+        num_free_gpu = self.scheduler.block_manager.get_num_free_gpu_blocks()
+        gpu_cache_usage = 1.0 - (num_free_gpu / num_total_gpu)
+
+        num_total_cpu = self.cache_config.num_cpu_blocks
+        cpu_cache_usage = 0.
+        if num_total_cpu > 0:
+            num_free_cpu = self.scheduler.block_manager.get_num_free_cpu_blocks(
+            )
+            cpu_cache_usage = 1.0 - (num_free_cpu / num_total_cpu)
+
+        # Scheduler State
+        num_running = len(self.scheduler.running)
+        num_swapped = len(self.scheduler.swapped)
+        num_waiting = len(self.scheduler.waiting)
+
+        # Iteration stats if we have scheduler output.
+        num_prompt_tokens = 0
+        num_generation_tokens = 0
+        time_to_first_tokens = []
+        time_per_output_tokens = []
+        time_e2e_requests = []
+        if scheduler_outputs is not None:
+            prompt_run = scheduler_outputs.num_prefill_groups > 0
+
+            # Number of Tokens.
+            if prompt_run:
+                num_prompt_tokens = sum(
+                    len(scheduled_seq_group.seq_group.prompt_token_ids)
+                    for scheduled_seq_group in
+                    scheduler_outputs.scheduled_seq_groups)
+                num_generation_tokens = sum(
+                    scheduled_seq_group.seq_group.num_seqs()
+                    for scheduled_seq_group in
+                    scheduler_outputs.scheduled_seq_groups)
+            else:
+                num_generation_tokens = scheduler_outputs.num_batched_tokens
+
+            # Latency Timings.
+            time_last_iters = []
+            for scheduled_seq_group in scheduler_outputs.scheduled_seq_groups:
+                seq_group = scheduled_seq_group.seq_group
+                # Time since last token.
+                # (n.b. updates seq_group.metrics.last_token_time)
+                time_last_iters.append(seq_group.get_last_latency(now))
+                # Time since arrival for all finished requests.
+                if seq_group.is_finished():
+                    time_e2e_requests.append(now -
+                                             seq_group.metrics.arrival_time)
+
+            time_to_first_tokens = time_last_iters if prompt_run else []
+            time_per_output_tokens = [] if prompt_run else time_last_iters
+
+        return Stats(
+            now=now,
+            num_running=num_running,
+            num_swapped=num_swapped,
+            num_waiting=num_waiting,
+            gpu_cache_usage=gpu_cache_usage,
+            cpu_cache_usage=cpu_cache_usage,
+            num_prompt_tokens=num_prompt_tokens,
+            num_generation_tokens=num_generation_tokens,
+            time_to_first_tokens=time_to_first_tokens,
+            time_per_output_tokens=time_per_output_tokens,
+            time_e2e_requests=time_e2e_requests,
+        )
+
+    def add_lora(self, lora_request: LoRARequest) -> bool:
+        return self.model_executor.add_lora(lora_request)
+
+    def remove_lora(self, lora_id: int) -> bool:
+        return self.model_executor.remove_lora(lora_id)
+
+    def list_loras(self) -> List[int]:
+        return self.model_executor.list_loras()
+
+    def check_health(self) -> None:
+        self.model_executor.check_health()

autoregressive/serve/model_runner.py

@@ -0,0 +1,1232 @@
+import contextlib
+import time
+from enum import IntEnum
+from typing import Dict, List, NamedTuple, Optional, Set, Tuple
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+from vllm.attention import (AttentionMetadata, AttentionMetadataPerStage,
+                            get_attn_backend)
+from vllm.config import (DeviceConfig, LoadConfig, LoRAConfig, ModelConfig,
+                         ParallelConfig, SchedulerConfig, VisionLanguageConfig)
+from vllm.distributed import broadcast_tensor_dict, with_pynccl_for_all_reduce
+from vllm.distributed.device_communicators import (custom_all_reduce,
+                                                   pynccl_utils)
+from vllm.logger import init_logger
+from vllm.lora.layers import LoRAMapping
+from vllm.lora.request import LoRARequest
+from vllm.lora.worker_manager import LRUCacheWorkerLoRAManager
+from vllm.model_executor import SamplingMetadata
+from vllm.model_executor.model_loader import get_model
+from vllm.sampling_params import SamplingParams, SamplingType
+from vllm.sequence import (MultiModalData, SamplerOutput, SequenceData,
+                           SequenceGroupMetadata)
+from vllm.utils import (CudaMemoryProfiler, async_tensor_h2d, is_hip,
+                        is_pin_memory_available, make_tensor_with_pad,
+                        maybe_expand_dim)
+from autoregressive.serve.gpt_model import GPT_models
+
+logger = init_logger(__name__)
+
+_PAD_SLOT_ID = -1
+LORA_WARMUP_RANK = 8
+_BATCH_SIZE_ALIGNMENT = 8
+# Capture graphs for token size 1, 2, 4, 8, 16, 24, 32, 40, ..., 256.
+# NOTE: _get_graph_batch_size needs to be updated if this list is changed.
+_BATCH_SIZES_TO_CAPTURE = [1, 2, 4] + [
+    _BATCH_SIZE_ALIGNMENT * i for i in range(1, 33)
+]
+
+
+class PreparePromptMetadata(NamedTuple):
+    input_tokens: List[int]
+    input_positions: List[int]
+    attn_metadata: Optional[AttentionMetadataPerStage]
+    prompt_lens: List[int]
+    subquery_lens: List[int]
+    lora_index_mapping: List[int]
+    lora_prompt_mapping: List[int]
+    lora_requests: Set[LoRARequest]
+    multi_modal_input: Optional[torch.Tensor]
+    slot_mapping: List[int]
+
+    @classmethod
+    def empty(cls):
+        return PreparePromptMetadata(
+            input_tokens=[],
+            input_positions=[],
+            attn_metadata=None,
+            prompt_lens=[],
+            subquery_lens=[],
+            lora_index_mapping=[],
+            lora_prompt_mapping=[],
+            lora_requests=set(),
+            multi_modal_input=None,
+            slot_mapping=[],
+        )
+
+
+class PrepareDecodeMetadata(NamedTuple):
+    input_tokens: List[int]
+    input_positions: List[int]
+    attn_metadata: Optional[AttentionMetadata]
+    lora_index_mapping: List[int]
+    lora_prompt_mapping: List[int]
+    lora_requests: Set[LoRARequest]
+    slot_mapping: List[int]
+
+    @classmethod
+    def empty(cls):
+        return PrepareDecodeMetadata(
+            input_tokens=[],
+            input_positions=[],
+            attn_metadata=None,
+            lora_index_mapping=[],
+            lora_prompt_mapping=[],
+            lora_requests=set(),
+            slot_mapping=[],
+        )
+
+
+# How batches are constructed.
+class BatchType(IntEnum):
+    # Every batch is prefill.
+    PREFILL = 0
+    # Every batch is decode.
+    DECODE = 1
+    # Batch is a mixture of prefill and decode.
+    MIXED = 2
+
+
+class ModelRunner:
+
+    def __init__(
+        self,
+        model_config: ModelConfig,
+        parallel_config: ParallelConfig,
+        scheduler_config: SchedulerConfig,
+        device_config: DeviceConfig,
+        load_config: LoadConfig,
+        lora_config: Optional[LoRAConfig],
+        kv_cache_dtype: Optional[str] = "auto",
+        is_driver_worker: bool = False,
+        vision_language_config: Optional[VisionLanguageConfig] = None,
+    ):
+        self.model_config = model_config
+        self.parallel_config = parallel_config
+        self.scheduler_config = scheduler_config
+        self.lora_config = lora_config
+        self.load_config = load_config
+        self.is_driver_worker = is_driver_worker
+
+        # model_config can be None in tests/samplers/test_sampler.py.
+        # FIXME(woosuk): This is a hack to make the tests work. Refactor this.
+        self.sliding_window = (model_config.get_sliding_window()
+                               if model_config is not None else None)
+        self.device_config = (device_config
+                              if device_config is not None else DeviceConfig())
+        self.device = self.device_config.device
+
+        # Set after load_model.
+        self.lora_manager: LRUCacheWorkerLoRAManager = None
+
+        self.graph_runners: Dict[int, CUDAGraphRunner] = {}
+        self.graph_memory_pool: Optional[Tuple[
+            int, int]] = None  # Set during graph capture.
+
+        self.max_context_len_to_capture = (
+            self.model_config.max_context_len_to_capture
+            if self.model_config is not None else 0)
+
+        self.pin_memory = is_pin_memory_available()
+        self.kv_cache_dtype = kv_cache_dtype
+        self.vision_language_config = vision_language_config
+
+        self.attn_backend = get_attn_backend(
+            self.model_config.dtype if model_config is not None else None)
+
+        # Lazy initialization
+        self.model: torch.nn.Module  # Set after load_model
+        self.block_size: int  # Set after initial profiling.
+        # When using CUDA graph, the input block tables must be padded to
+        # max_context_len_to_capture. However, creating the block table in
+        # Python can be expensive. To optimize this, we cache the block table
+        # in numpy and only copy the actual input content at every iteration.
+        # The shape of the cached block table will be
+        # (max batch size to capture, max context len to capture / block size).
+        self.graph_block_tables: torch.Tensor  # Set after initial profiling.
+
+    def load_model(self, args) -> None:
+        with CudaMemoryProfiler() as m:
+            # self.model = get_model(
+            #     model_config=self.model_config,
+            #     device_config=self.device_config,
+            #     load_config=self.load_config,
+            #     lora_config=self.lora_config,
+            #     vision_language_config=self.vision_language_config,
+            #     parallel_config=self.parallel_config,
+            #     scheduler_config=self.scheduler_config,
+            # )
+            precision = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.precision]
+            latent_size = args.image_size // args.downsample_size            
+            gpt_model = GPT_models[args.gpt_model](
+                vocab_size=args.codebook_size,
+                block_size=latent_size ** 2,
+                num_classes=args.num_classes,
+                cls_token_num=args.cls_token_num,
+                model_type=args.gpt_type,
+                cfg_scale=args.cfg_scale,
+            ).to(device='cuda', dtype=precision) # TODO: make device configurable
+
+            checkpoint = torch.load(args.gpt_ckpt, map_location="cpu")
+            if args.from_fsdp: # fspd
+                model_weight = checkpoint
+            elif "model" in checkpoint:  # ddp
+                model_weight = checkpoint["model"]
+            elif "state_dict" in checkpoint:
+                model_weight = checkpoint["state_dict"]
+            else:
+                raise Exception("please check model weight, maybe add --from-fsdp to run command")
+            gpt_model.custom_load_state_dict(model_weight)
+            gpt_model.eval()
+            del checkpoint
+            self.model = gpt_model
+
+        self.model_memory_usage = m.consumed_memory
+        logger.info(f"Loading model weights took "
+                    f"{self.model_memory_usage / float(2**30):.4f} GB")
+
+        if self.lora_config:
+            assert hasattr(self.model, "supported_lora_modules"
+                           ) and self.model.supported_lora_modules, (
+                               "Model does not support LoRA")
+            assert hasattr(
+                self.model,
+                "embedding_modules"), "Model does not have embedding_modules"
+            assert hasattr(self.model, "embedding_padding_modules"
+                           ), "Model does not have embedding_padding_modules"
+            self.lora_manager = LRUCacheWorkerLoRAManager(
+                self.scheduler_config.max_num_seqs,
+                self.scheduler_config.max_num_batched_tokens, self.vocab_size,
+                self.lora_config, self.device, self.model.embedding_modules,
+                self.model.embedding_padding_modules)
+            self.model = self.lora_manager.create_lora_manager(self.model)
+
+        if self.kv_cache_dtype == "fp8" and is_hip():
+            # Currently scaled KV cache is only enabled on ROCm
+            if self.model_config.quantization_param_path is not None:
+                if callable(getattr(self.model, "load_kv_cache_scales", None)):
+                    self.model.load_kv_cache_scales(
+                        self.model_config.quantization_param_path)
+                else:
+                    raise RuntimeError("Using FP8 KV cache and scaling "
+                                       "factors provided but model "
+                                       f"{self.model.__class__} does not "
+                                       "support loading scaling factors.")
+            else:
+                logger.warn("Using FP8 KV cache but no scaling factors "
+                            "provided. Defaulting to scaling factors of 1.0. "
+                            "This may lead to less accurate results!")
+        elif self.model_config.quantization_param_path is not None:
+            logger.warn("KV cache scaling factors provided, "
+                        "but the KV cache data type is not FP8. "
+                        "KV cache scaling factors will not be used.")
+
+    def set_block_size(self, block_size: int) -> None:
+        self.block_size = block_size
+
+        self.graph_block_tables = np.zeros(
+            (max(_BATCH_SIZES_TO_CAPTURE), self.get_max_block_per_batch()),
+            dtype=np.int32)
+
+    def get_max_block_per_batch(self) -> int:
+        block_size = self.block_size
+        return (self.max_context_len_to_capture + block_size - 1) // block_size
+
+    def _prepare_prompt(
+        self,
+        seq_group_metadata_list: List[SequenceGroupMetadata],
+    ) -> PreparePromptMetadata:
+        input_tokens: List[int] = []
+        input_positions: List[int] = []
+        slot_mapping: List[int] = []
+        lora_index_mapping: List[int] = []
+        lora_prompt_mapping: List[int] = []
+        lora_requests: Set[LoRARequest] = set()
+
+        prompt_lens: List[int] = []
+        context_lens: List[int] = []
+        subquery_lens: List[int] = []
+        prefix_block_tables: List[List[int]] = []
+        multi_modal_input_list: List[torch.Tensor] = []
+
+        if len(seq_group_metadata_list) == 0:
+            return PreparePromptMetadata.empty()
+
+        for seq_group_metadata in seq_group_metadata_list:
+            assert seq_group_metadata.is_prompt
+            seq_ids = list(seq_group_metadata.seq_data.keys())
+            assert len(seq_ids) == 1
+            seq_id = seq_ids[0]
+
+            computed_block_nums = seq_group_metadata.computed_block_nums
+            if (self.scheduler_config is not None
+                    and self.scheduler_config.chunked_prefill_enabled
+                    and not (computed_block_nums is None
+                             or computed_block_nums == [])):
+                raise RuntimeError(
+                    "chunked prefill cannot be used with prefix caching "
+                    "now.")
+
+            token_chunk_size = seq_group_metadata.token_chunk_size
+            seq_data = seq_group_metadata.seq_data[seq_id]
+            computed_len = seq_data.get_num_computed_tokens()
+            # We should use get_len here because in case of preemption
+            # it contains output tokens.
+            prefill_end = min(seq_data.get_len(),
+                              computed_len + token_chunk_size)
+            prompt_tokens = seq_data.get_token_ids()[computed_len:prefill_end]
+            prompt_len = prefill_end
+            prompt_lens.append(prompt_len)
+
+            # NOTE: This only works for oooooooxxx style attention.
+            if computed_block_nums is not None and len(
+                    computed_block_nums) > 0 and self.sliding_window is None:
+                # Prefix is not supported with sliding_window
+                computed_len = len(computed_block_nums) * self.block_size
+                prompt_tokens = prompt_tokens[computed_len:]
+                prefix_block_tables.append(computed_block_nums)
+            elif self.scheduler_config.chunked_prefill_enabled:
+                if seq_group_metadata.block_tables is not None:
+                    # Prefill has chunked before.
+                    block_table = seq_group_metadata.block_tables[seq_id]
+                    prefix_block_tables.append(block_table)
+                else:
+                    # The first prefill.
+                    prefix_block_tables.append([])
+            else:
+                prefix_block_tables.append([])
+                # Right now, prefill start is always 0. However, this
+                # assumption can be changed once chunked prefill is introduced.
+                assert computed_len == 0
+
+            # actual prompt lens
+            context_lens.append(computed_len)
+            subquery_lens.append(prompt_len - computed_len)
+
+            input_tokens.extend(prompt_tokens)
+            # NOTE(woosuk): Here we assume that the first token in the prompt
+            # is always the first token in the sequence.
+            input_positions.extend(list(range(computed_len, prefill_end)))
+            lora_id = seq_group_metadata.lora_int_id
+
+            if lora_id > 0:
+                lora_requests.add(seq_group_metadata.lora_request)
+
+            lora_index_mapping += [lora_id] * (prompt_len - computed_len)
+            lora_prompt_mapping.extend(
+                [lora_id] *
+                (prompt_len - computed_len
+                 if seq_group_metadata.sampling_params.prompt_logprobs else 1))
+
+            if seq_group_metadata.multi_modal_data:
+                multi_modal_input_list.append(
+                    seq_group_metadata.multi_modal_data.data)
+
+            if seq_group_metadata.block_tables is None:
+                # During memory profiling, the block tables are not initialized
+                # yet. In this case, we just use a dummy slot mapping.
+                slot_mapping.extend([_PAD_SLOT_ID] * prompt_len)
+                continue
+
+            # Compute the slot mapping.
+            block_table = seq_group_metadata.block_tables[seq_id]
+            # Mask the [0, start_idx) tokens of the prompt with _PAD_SLOT_ID,
+            # where start_idx is max(0, prompt_len - sliding_window).
+            # For example, if the prompt len is 10, sliding window is 8, and
+            # block size is 4, the first two tokens are masked and the slot
+            # mapping will be [-1, -1, 2, 3, 4, 5, 6, 7, 0, 1].
+            start_idx = 0
+            if self.sliding_window is not None:
+                assert computed_len == 0, (
+                    "Prefix caching is currently not supported with "
+                    "sliding window attention")
+                start_idx = max(0, prompt_len - self.sliding_window)
+
+            for i in range(computed_len, prefill_end):
+                if i < start_idx:
+                    slot_mapping.append(_PAD_SLOT_ID)
+                    continue
+
+                block_number = block_table[i // self.block_size]
+                block_offset = i % self.block_size
+                slot = block_number * self.block_size + block_offset
+                slot_mapping.append(slot)
+
+        max_subquery_len = max(subquery_lens)
+        max_prompt_len = max(prompt_lens)
+        assert max_subquery_len > 0
+
+        context_lens_tensor = torch.tensor(context_lens,
+                                           dtype=torch.int,
+                                           device=self.device)
+
+        if multi_modal_input_list:
+            assert self.vision_language_config, (
+                "Multi-modal inputs are only supported by "
+                "vision language models.")
+            multi_modal_input = torch.cat(multi_modal_input_list,
+                                          dim=0).to(self.device)
+        else:
+            multi_modal_input = None
+
+        # Prepare prefix block tables
+        max_prompt_block_table_len = max(len(t) for t in prefix_block_tables)
+        block_tables = make_tensor_with_pad(
+            prefix_block_tables,
+            max_len=max_prompt_block_table_len,
+            pad=0,
+            dtype=torch.int,
+            device=self.device,
+        )
+
+        # Query length can be shorter than key (i.e., prompt) when prefill
+        # is chunked or prefix cached.
+        subquery_lens_tensor = torch.tensor(subquery_lens,
+                                            dtype=torch.long,
+                                            device=self.device)
+        subquery_start_loc = torch.zeros(subquery_lens_tensor.shape[0] + 1,
+                                         dtype=torch.int32,
+                                         device=self.device)
+
+        prompt_lens_tensor = torch.tensor(prompt_lens,
+                                          dtype=torch.long,
+                                          device=self.device)
+        seq_start_loc = torch.zeros(prompt_lens_tensor.shape[0] + 1,
+                                    dtype=torch.int32,
+                                    device=self.device)
+
+        torch.cumsum(subquery_lens_tensor,
+                     dim=0,
+                     dtype=subquery_start_loc.dtype,
+                     out=subquery_start_loc[1:])
+
+        torch.cumsum(prompt_lens_tensor,
+                     dim=0,
+                     dtype=seq_start_loc.dtype,
+                     out=seq_start_loc[1:])
+
+        attn_metadata = self.attn_backend.make_metadata(
+            is_prompt=True,
+            prompt_lens=prompt_lens,
+            prompt_lens_tensor=prompt_lens_tensor,
+            max_subquery_len=max_subquery_len,
+            max_context_len=None,
+            max_prompt_len=max_prompt_len,
+            subquery_start_loc=subquery_start_loc,
+            seq_start_loc=seq_start_loc,
+            context_lens=context_lens_tensor,
+            block_tables=block_tables,
+            use_cuda_graph=False,
+        )
+
+        return PreparePromptMetadata(
+            input_tokens=input_tokens,
+            input_positions=input_positions,
+            attn_metadata=attn_metadata,
+            prompt_lens=prompt_lens,
+            subquery_lens=subquery_lens,
+            lora_index_mapping=lora_index_mapping,
+            lora_prompt_mapping=lora_prompt_mapping,
+            lora_requests=lora_requests,
+            multi_modal_input=multi_modal_input,
+            slot_mapping=slot_mapping,
+        )
+
+    def _prepare_decode(
+        self,
+        seq_group_metadata_list: List[SequenceGroupMetadata],
+    ) -> PrepareDecodeMetadata:
+        input_tokens: List[int] = []
+        input_positions: List[int] = []
+        slot_mapping: List[int] = []
+        context_lens: List[int] = []
+        block_tables: List[List[int]] = []
+        lora_index_mapping: List[int] = []
+        lora_prompt_mapping: List[int] = []
+        lora_requests: Set[LoRARequest] = set()
+
+        if len(seq_group_metadata_list) == 0:
+            return PrepareDecodeMetadata.empty()
+
+        for seq_group_metadata in seq_group_metadata_list:
+            assert not seq_group_metadata.is_prompt
+            assert seq_group_metadata.token_chunk_size == 1
+
+            seq_ids = list(seq_group_metadata.seq_data.keys())
+            lora_id = seq_group_metadata.lora_int_id
+
+            if lora_id > 0:
+                lora_requests.add(seq_group_metadata.lora_request)
+
+            for seq_id in seq_ids:
+                seq_data = seq_group_metadata.seq_data[seq_id]
+                generation_token = seq_data.get_last_token_id()
+                input_tokens.append(generation_token)
+
+                seq_len = seq_data.get_len()
+                position = seq_len - 1
+                input_positions.append(position)
+
+                context_len = seq_len if self.sliding_window is None else min(
+                    seq_len, self.sliding_window)
+                context_lens.append(context_len)
+
+                block_table = seq_group_metadata.block_tables[seq_id]
+                block_number = block_table[position // self.block_size]
+                block_offset = position % self.block_size
+                slot = block_number * self.block_size + block_offset
+                slot_mapping.append(slot)
+                lora_index_mapping.append(lora_id)
+                lora_prompt_mapping.append(lora_id)
+
+                if self.sliding_window is not None:
+                    sliding_window_blocks = (self.sliding_window //
+                                             self.block_size)
+                    block_table = block_table[-sliding_window_blocks:]
+                block_tables.append(block_table)
+
+        # vLLM uses cuda graph only for decoding requests.
+        # See `capture_model` API for more details.
+        # For decoding requests, batch_size == input_tokens.
+        batch_size = len(input_tokens)
+        max_context_len = max(context_lens)
+        use_captured_graph = (
+            not self.model_config.enforce_eager
+            and batch_size <= _BATCH_SIZES_TO_CAPTURE[-1]
+            and max_context_len <= self.max_context_len_to_capture)
+        if use_captured_graph:
+            graph_batch_size = _get_graph_batch_size(batch_size)
+            assert graph_batch_size >= batch_size
+            for _ in range(graph_batch_size - batch_size):
+                input_tokens.append(0)
+                input_positions.append(0)
+                slot_mapping.append(_PAD_SLOT_ID)
+                context_lens.append(1)
+                block_tables.append([])
+                lora_index_mapping.append(0)
+            batch_size = graph_batch_size
+
+        context_lens_tensor = torch.tensor(context_lens,
+                                           dtype=torch.int,
+                                           device=self.device)
+
+        if use_captured_graph:
+            # When using cuda-graph all these tensors should be
+            # padded.
+            assert context_lens_tensor.shape[0] == len(input_tokens)
+            assert context_lens_tensor.shape[0] == len(input_positions)
+            assert context_lens_tensor.shape[0] == len(slot_mapping)
+
+            # The shape of graph_block_tables is
+            # [max batch size, max context len // block size].
+            input_block_tables = self.graph_block_tables[:batch_size]
+            for i, block_table in enumerate(block_tables):
+                if block_table:
+                    input_block_tables[i, :len(block_table)] = block_table
+            block_tables = torch.tensor(input_block_tables, device=self.device)
+        else:
+            max_block_table_len = max(
+                len(block_table) for block_table in block_tables)
+            block_tables = make_tensor_with_pad(
+                block_tables,
+                max_len=max_block_table_len,
+                pad=0,
+                dtype=torch.int,
+                device=self.device,
+            )
+
+        attn_metadata = self.attn_backend.make_metadata(
+            is_prompt=False,
+            prompt_lens=None,
+            prompt_lens_tensor=None,
+            max_subquery_len=None,
+            max_context_len=max_context_len,
+            max_prompt_len=None,
+            subquery_start_loc=None,
+            seq_start_loc=None,
+            context_lens=context_lens_tensor,
+            block_tables=block_tables,
+            use_cuda_graph=use_captured_graph,
+        )
+        return PrepareDecodeMetadata(
+            input_tokens=input_tokens,
+            input_positions=input_positions,
+            attn_metadata=attn_metadata,
+            lora_index_mapping=lora_index_mapping,
+            lora_prompt_mapping=lora_prompt_mapping,
+            lora_requests=lora_requests,
+            slot_mapping=slot_mapping,
+        )
+
+    def _prepare_sample(
+        self,
+        seq_group_metadata_list: List[SequenceGroupMetadata],
+        prompt_lens: List[int],
+        subquery_lens: Optional[List[int]],
+    ) -> SamplingMetadata:
+        seq_groups: List[Tuple[List[int], SamplingParams]] = []
+        selected_token_indices: List[int] = []
+        generators: List[torch.Generator] = []
+        selected_token_start_idx = 0
+        categorized_sample_indices: Dict[SamplingType,
+                                         List[Tuple[int, int]]] = {
+                                             t: []
+                                             for t in SamplingType
+                                         }
+        categorized_sample_indices_start_idx = 0
+        categorized_sampled_token_indices_start_idx = 0
+
+        for i, seq_group_metadata in enumerate(seq_group_metadata_list):
+            seq_ids = list(seq_group_metadata.seq_data.keys())
+            sampling_params = seq_group_metadata.sampling_params
+            seq_groups.append((seq_ids, sampling_params))
+
+            if seq_group_metadata.is_prompt:
+                assert len(seq_ids) == 1
+                assert subquery_lens is not None
+                subquery_len = subquery_lens[i]
+                if sampling_params.prompt_logprobs is not None:
+                    # NOTE: prompt token positions do not need sample, skip
+                    categorized_sample_indices_start_idx += subquery_len - 1
+
+                categorized_sample_indices[
+                    sampling_params.sampling_type].append(
+                        (categorized_sample_indices_start_idx,
+                         categorized_sampled_token_indices_start_idx))
+                categorized_sample_indices_start_idx += 1
+                categorized_sampled_token_indices_start_idx += 1
+
+                if sampling_params.prompt_logprobs is not None:
+                    selected_token_indices.extend(
+                        range(selected_token_start_idx,
+                              selected_token_start_idx + subquery_len - 1))
+                selected_token_indices.append(selected_token_start_idx +
+                                              subquery_len - 1)
+                selected_token_start_idx += subquery_len
+
+                if sampling_params.seed is not None:
+                    seq_group_metadata.state.generator = torch.Generator(
+                        device=self.device).manual_seed(sampling_params.seed)
+            else:
+                num_seqs = len(seq_ids)
+                selected_token_indices.extend(
+                    range(selected_token_start_idx,
+                          selected_token_start_idx + num_seqs))
+                selected_token_start_idx += num_seqs
+
+                categorized_sample_indices[
+                    sampling_params.sampling_type].extend(
+                        list(
+                            zip(
+                                range(
+                                    categorized_sample_indices_start_idx,
+                                    categorized_sample_indices_start_idx +
+                                    num_seqs),
+                                range(
+                                    categorized_sampled_token_indices_start_idx,
+                                    categorized_sampled_token_indices_start_idx
+                                    + num_seqs))))
+                categorized_sample_indices_start_idx += num_seqs
+                categorized_sampled_token_indices_start_idx += num_seqs
+
+            if sampling_params.seed is not None:
+                generators.append(seq_group_metadata.state.generator)
+
+        selected_token_indices = async_tensor_h2d(selected_token_indices,
+                                                  dtype=torch.long,
+                                                  target_device=self.device,
+                                                  pin_memory=self.pin_memory)
+
+        categorized_sample_indices = {
+            t: maybe_expand_dim(
+                async_tensor_h2d(seq_ids,
+                                 dtype=torch.int,
+                                 target_device=self.device,
+                                 pin_memory=self.pin_memory), 2, 2)
+            for t, seq_ids in categorized_sample_indices.items()
+        }
+
+        seq_data: Dict[int, SequenceData] = {}
+        for seq_group_metadata in seq_group_metadata_list:
+            seq_data.update(seq_group_metadata.seq_data)
+
+        sampling_metadata = SamplingMetadata(
+            seq_groups=seq_groups,
+            seq_data=seq_data,
+            prompt_lens=prompt_lens,
+            selected_token_indices=selected_token_indices,
+            categorized_sample_indices=categorized_sample_indices,
+            generators=generators,
+        )
+        return sampling_metadata
+
+    def prepare_input_tensors(
+        self,
+        seq_group_metadata_list: List[SequenceGroupMetadata],
+    ) -> Tuple[torch.Tensor, torch.Tensor, AttentionMetadata, SamplingMetadata,
+               Set[LoRARequest], LoRAMapping, torch.Tensor]:
+        if self.is_driver_worker:
+            prefill_reqs = []
+            decode_reqs = []
+            for seq_group_meta in seq_group_metadata_list:
+                if seq_group_meta.is_prompt:
+                    prefill_reqs.append(seq_group_meta)
+                else:
+                    decode_reqs.append(seq_group_meta)
+
+            # Prepare input tensors.
+            (
+                input_tokens,
+                input_positions,
+                prefill_attn_metadata,
+                prompt_lens,
+                subquery_lens,
+                lora_index_mapping,
+                lora_prompt_mapping,
+                lora_requests,
+                multi_modal_input,
+                slot_mapping,
+            ) = self._prepare_prompt(prefill_reqs)
+            (
+                decode_input_tokens,
+                decode_input_positions,
+                decode_attn_metadata,
+                decode_lora_index_mapping,
+                decode_lora_prompt_mapping,
+                decode_lora_requests,
+                decode_slot_mapping,
+            ) = self._prepare_decode(decode_reqs)
+            sampling_metadata = self._prepare_sample(seq_group_metadata_list,
+                                                     prompt_lens,
+                                                     subquery_lens)
+
+            if not self.scheduler_config.chunked_prefill_enabled:
+                assert (len(prefill_reqs) and len(decode_reqs)) == 0
+
+            num_prefills = len(prompt_lens)
+            num_prefill_tokens = len(input_tokens)
+            num_decode_tokens = len(decode_input_tokens)
+
+            # Coalesce tensors. Note that attn_metadata is currently not
+            # coalesced for simplicity.
+            input_tokens.extend(decode_input_tokens)
+            input_positions.extend(decode_input_positions)
+            slot_mapping.extend(decode_slot_mapping)
+            lora_index_mapping.extend(decode_lora_index_mapping)
+            lora_prompt_mapping.extend(decode_lora_prompt_mapping)
+            lora_requests.update(decode_lora_requests)
+
+            input_tokens = torch.tensor(input_tokens,
+                                        dtype=torch.long,
+                                        device=self.device)
+            input_positions = torch.tensor(input_positions,
+                                           dtype=torch.long,
+                                           device=self.device)
+            slot_mapping = torch.tensor(slot_mapping,
+                                        dtype=torch.long,
+                                        device=self.device)
+
+            if self.lora_config:
+                lora_mapping = LoRAMapping(
+                    lora_index_mapping,
+                    lora_prompt_mapping,
+                )
+            else:
+                lora_mapping = None
+
+            # Broadcast the metadata.
+            # If batch contains both prefill and decode, it sends 2 broadcasts.
+            # If it only contains 1 type, it triggers a single broadcast.
+            if (prefill_attn_metadata is not None
+                    and decode_attn_metadata is not None):
+                batch_type = BatchType.MIXED
+            elif prefill_attn_metadata is not None:
+                batch_type = BatchType.PREFILL
+            else:
+                batch_type = BatchType.DECODE
+
+            metadata_dict = {
+                "input_tokens": input_tokens,
+                "input_positions": input_positions,
+                "selected_token_indices":
+                sampling_metadata.selected_token_indices,
+                "lora_requests": lora_requests,
+                "lora_mapping": lora_mapping,
+                "multi_modal_input": multi_modal_input,
+                "num_prefill_tokens": num_prefill_tokens,
+                "num_decode_tokens": num_decode_tokens,
+                "slot_mapping": slot_mapping,
+                "num_prefills": num_prefills,
+                "batch_type": batch_type,
+            }
+            if prefill_attn_metadata is not None:
+                metadata_dict.update(prefill_attn_metadata.asdict_zerocopy())
+            else:
+                assert decode_attn_metadata is not None
+                metadata_dict.update(decode_attn_metadata.asdict_zerocopy())
+            broadcast_tensor_dict(metadata_dict, src=0)
+
+            # Broadcast decode attn metadata for mixed batch type.
+            # The additional broadcast costs 300us overhead on 4 A10 GPUs.
+            # We can potentially reduce the overhead by coelescing tensors.
+            if batch_type == BatchType.MIXED:
+                assert decode_attn_metadata is not None
+                metadata_dict = decode_attn_metadata.asdict_zerocopy()
+                broadcast_tensor_dict(metadata_dict, src=0)
+        else:
+            metadata_dict = broadcast_tensor_dict(src=0)
+            input_tokens = metadata_dict.pop("input_tokens")
+            input_positions = metadata_dict.pop("input_positions")
+            slot_mapping = metadata_dict.pop("slot_mapping")
+            num_prefills = metadata_dict.pop("num_prefills")
+            selected_token_indices = metadata_dict.pop(
+                "selected_token_indices")
+            lora_mapping = metadata_dict.pop("lora_mapping")
+            lora_requests = metadata_dict.pop("lora_requests")
+            multi_modal_input = metadata_dict.pop("multi_modal_input")
+            num_prefill_tokens = metadata_dict.pop("num_prefill_tokens")
+            num_decode_tokens = metadata_dict.pop("num_decode_tokens")
+            batch_type = metadata_dict.pop("batch_type")
+
+            # Create an attention metadata.
+            prefill_attn_metadata = None
+            decode_attn_metadata = None
+            if batch_type == BatchType.PREFILL or batch_type == BatchType.MIXED:
+                prefill_attn_metadata = self.attn_backend.make_metadata(
+                    **metadata_dict)
+            else:
+                decode_attn_metadata = self.attn_backend.make_metadata(
+                    **metadata_dict)
+            sampling_metadata = SamplingMetadata(
+                seq_groups=None,
+                seq_data=None,
+                prompt_lens=None,
+                selected_token_indices=selected_token_indices,
+                categorized_sample_indices=None,
+                generators=None,
+                perform_sampling=False,
+            )
+
+            # if it is a mixed batch, decode attn_metadata is broadcasted
+            # separately.
+            if batch_type == BatchType.MIXED:
+                metadata_dict = broadcast_tensor_dict(src=0)
+                decode_attn_metadata = self.attn_backend.make_metadata(
+                    **metadata_dict)
+
+        attn_metadata = AttentionMetadata(
+            num_prefills=num_prefills,
+            slot_mapping=slot_mapping,
+            num_prefill_tokens=num_prefill_tokens,
+            num_decode_tokens=num_decode_tokens,
+            prefill_metadata=prefill_attn_metadata,
+            decode_metadata=decode_attn_metadata,
+            kv_cache_dtype=self.kv_cache_dtype,
+        )
+
+        return (input_tokens, input_positions, attn_metadata,
+                sampling_metadata, lora_requests, lora_mapping,
+                multi_modal_input)
+
+    @torch.inference_mode()
+    def execute_model(
+        self,
+        seq_group_metadata_list: List[SequenceGroupMetadata],
+        kv_caches: List[torch.Tensor],
+    ) -> Optional[SamplerOutput]:
+        (input_tokens, input_positions, attn_metadata, sampling_metadata,
+         lora_requests, lora_mapping, multi_modal_input
+         ) = self.prepare_input_tensors(seq_group_metadata_list)
+        if self.lora_config:
+            self.set_active_loras(lora_requests, lora_mapping)
+
+        # Currently cuda graph is only supported by the decode phase.
+        prefill_meta = attn_metadata.prefill_metadata
+        decode_meta = attn_metadata.decode_metadata
+        if prefill_meta is None and decode_meta.use_cuda_graph:
+            graph_batch_size = input_tokens.shape[0]
+            model_executable = self.graph_runners[graph_batch_size]
+        else:
+            model_executable = self.model
+        execute_model_kwargs = {
+            "input_ids": input_tokens,
+            "positions": input_positions,
+            "kv_caches": kv_caches,
+            "attn_metadata": attn_metadata,
+        }
+        if self.vision_language_config:
+            execute_model_kwargs.update({"image_input": multi_modal_input})
+        hidden_states = model_executable(**execute_model_kwargs)
+
+        # Compute the logits.
+        logits = self.model.compute_logits(hidden_states, sampling_metadata)
+
+        # Only perform sampling in the driver worker.
+        if not sampling_metadata.perform_sampling:
+            return None
+
+        # Sample the next token.
+        output = self.model.sample(
+            logits=logits,
+            sampling_metadata=sampling_metadata,
+        )
+        return output
+
+    @torch.inference_mode()
+    def profile_run(self) -> None:
+        # Enable top-k sampling to reflect the accurate memory usage.
+        sampling_params = SamplingParams(top_p=0.99, top_k=self.vocab_size - 1)
+        max_num_batched_tokens = self.scheduler_config.max_num_batched_tokens
+        max_num_seqs = self.scheduler_config.max_num_seqs
+
+        # This represents the maximum number of different requests
+        # that will have unique loras, an therefore the max amount of memory
+        # consumption create dummy lora request copies from the lora request
+        # passed in, which contains a lora from the lora warmup path.
+        dummy_lora_requests = []
+        dummy_lora_requests_per_seq = []
+        if self.lora_config:
+            for idx in range(self.lora_config.max_loras):
+                lora_id = idx + 1
+                dummy_lora_request = LoRARequest(
+                    lora_name=f"warmup_{lora_id}",
+                    lora_int_id=lora_id,
+                    lora_local_path="/not/a/real/path",
+                )
+                self.lora_manager.add_dummy_lora(dummy_lora_request,
+                                                 rank=LORA_WARMUP_RANK)
+                dummy_lora_requests.append(dummy_lora_request)
+            dummy_lora_requests_per_seq = [
+                dummy_lora_requests[idx % len(dummy_lora_requests)]
+                for idx in range(max_num_seqs)
+            ]
+
+        # Profile memory usage with max_num_sequences sequences and the total
+        # number of tokens equal to max_num_batched_tokens.
+        seqs: List[SequenceGroupMetadata] = []
+        # Additional GPU memory may be needed for vision encoding, which needs
+        # to be accounted for when calculating the GPU blocks for
+        # vLLM blocker manager.
+        # To exercise the worst scenario for GPU memory consumption,
+        # the number of seqs (batch_size) is chosen to maximize the number
+        # of images processed.
+        if self.vision_language_config:
+            max_num_seqs = min(
+                max_num_seqs,
+                int(max_num_batched_tokens /
+                    self.vision_language_config.image_feature_size))
+        for group_id in range(max_num_seqs):
+            seq_len = (max_num_batched_tokens // max_num_seqs +
+                       (group_id < max_num_batched_tokens % max_num_seqs))
+            seq_data, fake_multi_modal_input = _prepare_fake_inputs(
+                seq_len, self.vision_language_config)
+            seq = SequenceGroupMetadata(
+                request_id=str(group_id),
+                is_prompt=True,
+                seq_data={group_id: seq_data},
+                sampling_params=sampling_params,
+                block_tables=None,
+                lora_request=dummy_lora_requests_per_seq[group_id]
+                if dummy_lora_requests_per_seq else None,
+                multi_modal_data=fake_multi_modal_input,
+            )
+            seqs.append(seq)
+
+        # Run the model with the dummy inputs.
+        num_layers = self.model_config.get_num_layers(self.parallel_config)
+        kv_caches = [None] * num_layers
+        self.execute_model(seqs, kv_caches)
+        torch.cuda.synchronize()
+        return
+
+    def remove_all_loras(self) -> bool:
+        if not self.lora_manager:
+            raise RuntimeError("LoRA is not enabled.")
+        return self.lora_manager.remove_all_loras()
+
+    def set_active_loras(self, lora_requests: Set[LoRARequest],
+                         lora_mapping: LoRAMapping) -> None:
+        if not self.lora_manager:
+            raise RuntimeError("LoRA is not enabled.")
+        self.lora_manager.set_active_loras(lora_requests, lora_mapping)
+
+    def add_lora(self, lora_request: LoRARequest) -> bool:
+        if not self.lora_manager:
+            raise RuntimeError("LoRA is not enabled.")
+        return self.lora_manager.add_lora(lora_request)
+
+    def remove_lora(self, lora_id: int) -> bool:
+        if not self.lora_manager:
+            raise RuntimeError("LoRA is not enabled.")
+        return self.lora_manager.remove_lora(lora_id)
+
+    def list_loras(self) -> Set[int]:
+        if not self.lora_manager:
+            raise RuntimeError("LoRA is not enabled.")
+        return self.lora_manager.list_loras()
+
+    @torch.inference_mode()
+    def capture_model(self, kv_caches: List[torch.Tensor]) -> None:
+        """Cuda graph capture a model.
+
+        Note that CUDA graph's performance gain is negligible if number
+        of batched tokens are larger than 200. And since CUDA graph
+        requires fixed sized tensors, supporting large/variable batch
+        size requires high GPU memory overhead. Thus, vLLM only captures
+        decoding requests. Mixed batch (chunked prefill + decoding) or
+        prefill requests are not captured.
+
+        Since it is used for decoding-only, it assumes there's only 1 token
+        per sequence in the batch.
+        """
+        # NOTE(woosuk): This is a hack to ensure that the NCCL backend is never
+        # deleted before the CUDA graphs.
+        self.pynccl_backend = pynccl_utils.get_nccl_backend()
+
+        assert not self.model_config.enforce_eager
+        logger.info("Capturing the model for CUDA graphs. This may lead to "
+                    "unexpected consequences if the model is not static. To "
+                    "run the model in eager mode, set 'enforce_eager=True' or "
+                    "use '--enforce-eager' in the CLI.")
+        logger.info("CUDA graphs can take additional 1~3 GiB memory per GPU. "
+                    "If you are running out of memory, consider decreasing "
+                    "`gpu_memory_utilization` or enforcing eager mode. "
+                    "You can also reduce the `max_num_seqs` as needed "
+                    "to decrease memory usage.")
+        start_time = time.perf_counter()
+
+        # Prepare dummy inputs. These will be reused for all batch sizes.
+        max_batch_size = max(_BATCH_SIZES_TO_CAPTURE)
+        input_tokens = torch.zeros(max_batch_size, dtype=torch.long).cuda()
+        input_positions = torch.zeros(max_batch_size, dtype=torch.long).cuda()
+        slot_mapping = torch.empty(max_batch_size, dtype=torch.long).cuda()
+        slot_mapping.fill_(_PAD_SLOT_ID)
+        context_lens = torch.ones(max_batch_size, dtype=torch.int32).cuda()
+        block_tables = torch.from_numpy(self.graph_block_tables).cuda()
+
+        graph_batch_size = _get_graph_batch_size(
+            self.scheduler_config.max_num_seqs)
+        batch_size_capture_list = [
+            bs for bs in _BATCH_SIZES_TO_CAPTURE if bs <= graph_batch_size
+        ]
+
+        # NOTE(woosuk): There are 3 backends for all-reduce: custom all-reduce
+        # kernel, pynccl, and PyTorch NCCL. When using CUDA graph, we use
+        # either custom all-reduce kernel or pynccl. When not using CUDA
+        # graph, we use either custom all-reduce kernel or PyTorch NCCL.
+        # We always prioritize using custom all-reduce kernel but fall back
+        # to PyTorch or pynccl if it is disabled or not supported.
+        with custom_all_reduce.capture():
+            # NOTE: Capturing the largest batch size first may help reduce the
+            # memory usage of CUDA graph.
+            for batch_size in reversed(batch_size_capture_list):
+                # Create dummy attn_metadata.
+                decode_metadata = self.attn_backend.make_metadata(
+                    is_prompt=False,
+                    prompt_lens=None,
+                    prompt_lens_tensor=None,
+                    max_subquery_len=None,
+                    max_context_len=self.max_context_len_to_capture,
+                    max_prompt_len=None,
+                    subquery_start_loc=None,
+                    seq_start_loc=None,
+                    context_lens=context_lens[:batch_size],
+                    block_tables=block_tables[:batch_size],
+                    use_cuda_graph=True,
+                )
+                attn_metadata = AttentionMetadata(
+                    num_prefills=0,
+                    num_prefill_tokens=0,
+                    num_decode_tokens=batch_size,
+                    slot_mapping=slot_mapping[:batch_size],
+                    prefill_metadata=None,
+                    decode_metadata=decode_metadata,
+                    kv_cache_dtype=self.kv_cache_dtype,
+                )
+
+                if self.lora_config:
+                    lora_mapping = LoRAMapping(
+                        [0] * batch_size,
+                        [0] * batch_size,
+                    )
+                    self.set_active_loras(set(), lora_mapping)
+
+                graph_runner = CUDAGraphRunner(self.model)
+                graph_runner.capture(
+                    input_tokens[:batch_size],
+                    input_positions[:batch_size],
+                    kv_caches,
+                    attn_metadata,
+                    memory_pool=self.graph_memory_pool,
+                )
+                self.graph_memory_pool = graph_runner.graph.pool()
+                self.graph_runners[batch_size] = graph_runner
+
+        end_time = time.perf_counter()
+        elapsed_time = end_time - start_time
+        # This usually takes < 10 seconds.
+        logger.info(f"Graph capturing finished in {elapsed_time:.0f} secs.")
+
+    def __del__(self) -> None:
+        # Delete the CUDA graphs before deleting the pynccl communicator.
+        # NOTE(woosuk): This is necessary because otherwise deadlocks can
+        # happen.
+        # FIXME(woosuk): This is a bit hacky. Find a more robust solution.
+        # TODO(youkaichao): when we get enough user feedback that pynccl is
+        # more stable than cupy, we can remove this, e.g. in v0.4.1.
+        self.graph_runners.clear()
+        self.pynccl_backend = None
+
+    @property
+    def vocab_size(self) -> int:
+        return self.model_config.get_vocab_size()
+
+
+class CUDAGraphRunner:
+
+    def __init__(self, model: nn.Module):
+        self.model = model
+        self.input_buffers: Dict[str, torch.Tensor] = {}
+        self.output_buffers: Dict[str, torch.Tensor] = {}
+
+        self._graph: Optional[torch.cuda.CUDAGraph] = None
+
+    @property
+    def graph(self):
+        assert self._graph is not None
+        return self._graph
+
+    def capture(
+        self,
+        input_ids: torch.Tensor,
+        positions: torch.Tensor,
+        kv_caches: List[torch.Tensor],
+        attn_metadata: AttentionMetadata,
+        memory_pool,
+        **kwargs,
+    ) -> None:
+        assert self._graph is None
+        # Run the model once without capturing the graph.
+        # This is to make sure that the captured graph does not include the
+        # kernel launches for initial benchmarking (e.g., Triton autotune).
+        with _maybe_pynccl():
+            self.model(
+                input_ids,
+                positions,
+                kv_caches,
+                attn_metadata,
+                **kwargs,
+            )
+        torch.cuda.synchronize()
+
+        # Capture the graph.
+        # NOTE(woosuk): Python 3.8 does not support multi-line with statements.
+        # https://stackoverflow.com/questions/31039022/python-multi-line-with-statement
+        self._graph = torch.cuda.CUDAGraph()
+        with torch.cuda.graph(self._graph, pool=memory_pool):  # noqa: SIM117
+            with _maybe_pynccl():
+                hidden_states = self.model(
+                    input_ids,
+                    positions,
+                    kv_caches,
+                    attn_metadata,
+                    **kwargs,
+                )
+        torch.cuda.synchronize()
+
+        # Save the input and output buffers.
+        self.input_buffers = {
+            "input_ids": input_ids,
+            "positions": positions,
+            "kv_caches": kv_caches,
+            "slot_mapping": attn_metadata.slot_mapping,
+            "context_lens": attn_metadata.decode_metadata.context_lens,
+            "block_tables": attn_metadata.decode_metadata.block_tables,
+        }
+        self.output_buffers = {"hidden_states": hidden_states}
+        return
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        positions: torch.Tensor,
+        kv_caches: List[torch.Tensor],
+        attn_metadata: AttentionMetadata,
+        **kwargs,
+    ) -> torch.Tensor:
+        # KV caches are fixed tensors, so we don't need to copy them.
+        del kv_caches
+
+        # Copy the input tensors to the input buffers.
+        self.input_buffers["input_ids"].copy_(input_ids, non_blocking=True)
+        self.input_buffers["positions"].copy_(positions, non_blocking=True)
+        self.input_buffers["slot_mapping"].copy_(attn_metadata.slot_mapping,
+                                                 non_blocking=True)
+        self.input_buffers["context_lens"].copy_(
+            attn_metadata.decode_metadata.context_lens, non_blocking=True)
+        self.input_buffers["block_tables"].copy_(
+            attn_metadata.decode_metadata.block_tables, non_blocking=True)
+        # Run the graph.
+        self.graph.replay()
+
+        # Return the output tensor.
+        return self.output_buffers["hidden_states"]
+
+    def __call__(self, *args, **kwargs):
+        return self.forward(*args, **kwargs)
+
+
+@contextlib.contextmanager
+def _maybe_pynccl():
+    if pynccl_utils.is_initialized(
+    ) and not custom_all_reduce.is_initialized():
+        with with_pynccl_for_all_reduce():
+            yield
+    else:
+        yield
+
+
+def _get_graph_batch_size(batch_size: int) -> int:
+    """Returns the padded batch size given actual batch size.
+
+    Batch sizes are 1, 2, 4, _BATCH_SIZE_ALIGNMENT,
+    2*_BATCH_SIZE_ALIGNMENT, 3*_BATCH_SIZE_ALIGNMENT...
+    """
+    if batch_size <= 2:
+        return batch_size
+    elif batch_size <= 4:
+        return 4
+    else:
+        return ((batch_size + _BATCH_SIZE_ALIGNMENT - 1) //
+                _BATCH_SIZE_ALIGNMENT * _BATCH_SIZE_ALIGNMENT)
+
+
+def _prepare_fake_inputs(
+        seq_len: int, vision_language_config: Optional[VisionLanguageConfig]):
+    """Prepare fake inputs for profile run."""
+    if vision_language_config:
+        prompt_tokens = [
+            vision_language_config.image_token_id
+        ] * vision_language_config.image_feature_size + [0] * (
+            seq_len - vision_language_config.image_feature_size)
+        fake_image_input = MultiModalData(
+            type=MultiModalData.Type.IMAGE,
+            data=torch.zeros(vision_language_config.image_input_shape,
+                             dtype=torch.float16))
+    else:
+        prompt_tokens = [0] * seq_len
+        fake_image_input = None
+    return SequenceData(prompt_tokens), fake_image_input

autoregressive/serve/sample_c2i.py

@@ -0,0 +1,98 @@
+import time
+import argparse
+import torch
+from torchvision.utils import save_image
+import sys
+sys.path.append('/data/zongmingli/LlamaGen')
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from autoregressive.serve.gpt_model import GPT_models
+from autoregressive.serve.llm import LLM 
+from vllm import SamplingParams
+
+
+def main(args):
+    # Setup PyTorch:
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    torch.set_grad_enabled(False)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.vq_ckpt, map_location="cpu")
+    vq_model.load_state_dict(checkpoint["model"])
+    del checkpoint
+    print(f"image tokenizer is loaded")
+
+    # Labels to condition the model with (feel free to change):
+    class_labels = [207, 360, 387, 974, 88, 979, 417, 279]
+    latent_size = args.image_size // args.downsample_size
+    qzshape = [len(class_labels), args.codebook_embed_dim, latent_size, latent_size]
+    prompt_token_ids = [[cind] for cind in class_labels]
+    if args.cfg_scale > 1.0:
+        prompt_token_ids.extend([[args.num_classes] for _ in range(len(prompt_token_ids))])
+    # Create an LLM.
+    llm = LLM(
+        args=args, 
+        model='autoregressive/serve/fake_json/{}.json'.format(args.gpt_model), 
+        gpu_memory_utilization=0.9, 
+        skip_tokenizer_init=True)
+    print(f"gpt model is loaded")
+
+    # Create a sampling params object.
+    sampling_params = SamplingParams(
+        temperature=args.temperature, top_p=args.top_p, top_k=args.top_k, 
+        max_tokens=latent_size ** 2)
+
+    # Generate texts from the prompts. The output is a list of RequestOutput objects
+    # that contain the prompt, generated text, and other information.
+    t1 = time.time()
+    outputs = llm.generate(
+        prompt_token_ids=prompt_token_ids,
+        sampling_params=sampling_params,
+        use_tqdm=False)
+    sampling_time = time.time() - t1
+    print(f"gpt sampling takes about {sampling_time:.2f} seconds.") 
+
+    # decode to image
+    index_sample = torch.tensor([output.outputs[0].token_ids for output in outputs], device=device)
+    if args.cfg_scale > 1.0:
+        index_sample = index_sample[:len(class_labels)]
+    t2 = time.time()
+    samples = vq_model.decode_code(index_sample, qzshape) # output value is between [-1, 1]
+    decoder_time = time.time() - t2
+    print(f"decoder takes about {decoder_time:.2f} seconds.")
+
+    # Save and display images:
+    save_image(samples, "sample_{}_vllm.png".format(args.gpt_type), nrow=4, normalize=True, value_range=(-1, 1))
+    print(f"image is saved to sample_{args.gpt_type}_vllm.png")
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-B")
+    parser.add_argument("--gpt-ckpt", type=str, required=True, help="ckpt path for gpt model")
+    parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="c2i", help="class-conditional or text-conditional")
+    parser.add_argument("--from-fsdp", action='store_true')
+    parser.add_argument("--cls-token-num", type=int, default=1, help="max token number of condition input")
+    parser.add_argument("--precision", type=str, default='bf16', choices=["none", "fp16", "bf16"])
+    parser.add_argument("--compile", action='store_true', default=False)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, required=True, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512], default=384)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--num-classes", type=int, default=1000)
+    parser.add_argument("--cfg-scale", type=float, default=4.0)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--top-k", type=int, default=2000,help="top-k value to sample with")
+    parser.add_argument("--temperature", type=float, default=1.0, help="temperature value to sample with")
+    parser.add_argument("--top-p", type=float, default=1.0, help="top-p value to sample with")
+    args = parser.parse_args()
+    main(args)

autoregressive/serve/sampler.py

@@ -0,0 +1,868 @@
+"""A layer that samples the next tokens from the model's outputs."""
+import itertools
+from typing import Dict, List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+
+from vllm.model_executor.layers.ops.sample import sample as sample_triton
+from vllm.model_executor.sampling_metadata import (SamplingMetadata,
+                                                   SamplingTensors)
+from vllm.sampling_params import SamplingParams, SamplingType
+from vllm.sequence import (Logprob, PromptLogprobs, SampleLogprobs,
+                           SamplerOutput, SequenceData, SequenceGroupOutput,
+                           SequenceOutput)
+
+
+class Sampler(nn.Module):
+    """Samples the next tokens from the model's outputs.
+
+    This layer does the following:
+    1. Discard the hidden states that are not used for sampling (i.e., all
+        tokens except the final one in each prompt).
+    2. Compute the logits for the next tokens.
+    3. Apply presence, frequency and repetition penalties.
+    4. Apply temperature scaling.
+    5. Apply top-p and top-k truncation.
+    6. Sample the next tokens.
+    Here, each sequence group within the batch can have different sampling
+    parameters (e.g., sampling method, temperature, top-p, top-k, etc.).
+
+    The structure of the logits tensor is coupled with the seq_groups in
+    sampling_metadata. Typically, each sequence in each seq_group has one row in
+    logits for the next token to be sampled; however, for a seq_group with a
+    prompt request with the prompt_logprobs sampling parameter, there are rows
+    in logits for each token in the input prompt.
+    """
+
+    def __init__(self, cfg_scale=1.0):
+        super().__init__()
+        self.cfg_scale = cfg_scale
+        # Whether or not the SamplerOutput should have on-device tensors
+        # containing the sampled token ids and probabilities. This is used by
+        # speculative decoding.
+        self.include_gpu_probs_tensor = False
+
+    def forward(
+        self,
+        logits: torch.Tensor,
+        sampling_metadata: SamplingMetadata,
+    ) -> Optional[SamplerOutput]:
+        assert logits is not None
+        _, vocab_size = logits.shape
+
+        if self.cfg_scale > 1.0:
+            logits_combined = logits
+            cond_logits, uncond_logits = torch.split(logits_combined, len(logits_combined) // 2, dim=0)
+            logits = uncond_logits + (cond_logits - uncond_logits) * self.cfg_scale
+            logits = torch.cat([logits, logits], dim=0)
+        
+        # Apply min_tokens penalty which sets stop tokens to -inf if min_tokens
+        # have not been generated yet
+        logits = _apply_min_tokens_penalty(logits, sampling_metadata)
+
+        # Prepare sampling tensors with pinned memory to avoid blocking.
+        (sampling_tensors, do_penalties, do_top_p_top_k,
+         do_min_p) = SamplingTensors.from_sampling_metadata(
+             sampling_metadata, vocab_size, logits.device, logits.dtype)
+
+        # Apply presence and frequency penalties.
+        if do_penalties:
+            logits = _apply_penalties(logits, sampling_tensors.prompt_tokens,
+                                      sampling_tensors.output_tokens,
+                                      sampling_tensors.presence_penalties,
+                                      sampling_tensors.frequency_penalties,
+                                      sampling_tensors.repetition_penalties)
+
+        # Apply temperature scaling.
+        # Use in-place division to avoid creating a new tensor.
+        logits.div_(sampling_tensors.temperatures.unsqueeze_(dim=1))
+
+        if do_top_p_top_k:
+            logits = _apply_top_k_top_p(logits, sampling_tensors.top_ps,
+                                        sampling_tensors.top_ks)
+
+        if do_min_p:
+            logits = _apply_min_p(logits, sampling_tensors.min_ps)
+
+        # We use float32 for probabilities and log probabilities.
+        # Compute the probabilities.
+        probs = torch.softmax(logits, dim=-1, dtype=torch.float)
+        # Compute the log probabilities.
+        # Use log_softmax to ensure numerical stability.
+        logprobs = torch.log_softmax(logits, dim=-1, dtype=torch.float)
+
+        # Sample the next tokens.
+        sample_results, maybe_sampled_tokens_tensor = _sample(
+            probs,
+            logprobs,
+            sampling_metadata,
+            sampling_tensors,
+            include_gpu_probs_tensor=self.include_gpu_probs_tensor,
+            modify_greedy_probs=self._should_modify_greedy_probs_inplace,
+        )
+
+        
+        if self.cfg_scale > 1.0:
+            cond_result = sample_results[:len(sample_results) // 2]
+            sample_results = cond_result + cond_result
+
+
+        if self.include_gpu_probs_tensor:
+            assert maybe_sampled_tokens_tensor is not None
+            sampled_tokens_tensor = maybe_sampled_tokens_tensor
+            on_device_tensors = (probs, sampled_tokens_tensor)
+        else:
+            on_device_tensors = None
+
+        # Get the logprobs query results.
+        prompt_logprobs, sample_logprobs = _get_logprobs(
+            logprobs, sampling_metadata, sample_results)
+        return _build_sampler_output(sample_results,
+                                     sampling_metadata,
+                                     prompt_logprobs,
+                                     sample_logprobs,
+                                     on_device_tensors=on_device_tensors)
+
+    @property
+    def _should_modify_greedy_probs_inplace(self) -> bool:
+        """Whether or not the sampler should modify the probability distribution
+        of greedily-sampled tokens such that multinomial sampling would sample
+        the greedily-sampled token.
+
+        In other words, if True then we set the probability of the greedily-
+        sampled token to 1.
+
+        This is used by speculative decoding, which requires that the sampling
+        method be encoded into the probability distribution.
+        """
+        # Modify greedy probs if include_gpu_probs_tensor is set.
+        return self.include_gpu_probs_tensor
+
+
+def _get_bin_counts_and_mask(
+    tokens: torch.Tensor,
+    vocab_size: int,
+    num_seqs: int,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    # Compute the bin counts for the tokens.
+    # vocab_size + 1 for padding.
+    bin_counts = torch.zeros((num_seqs, vocab_size + 1),
+                             dtype=torch.long,
+                             device=tokens.device)
+    bin_counts.scatter_add_(1, tokens, torch.ones_like(tokens))
+    bin_counts = bin_counts[:, :vocab_size]
+    mask = bin_counts > 0
+
+    return bin_counts, mask
+
+
+def _apply_min_tokens_penalty(
+    logits: torch.Tensor,
+    sampling_metadata: SamplingMetadata,
+) -> torch.Tensor:
+    # list of indices in logits that will be set to -inf
+    logits_to_penalize = []
+    start_idx = 0
+    for i, seq_group in enumerate(sampling_metadata.seq_groups):
+        seq_ids, sampling_params = seq_group
+
+        # handle prompt_logprobs by skipping rows in logits added for the prompt
+        # tokens (prompt logprobs are not penalized)
+        if (i < sampling_metadata.num_prompts
+                and sampling_params.prompt_logprobs is not None):
+            assert len(seq_ids) == 1
+            start_idx += sampling_metadata.prompt_lens[i] - 1
+
+        min_tokens = sampling_params.min_tokens
+        if min_tokens > 0:
+            seqs_to_penalize = []
+            for i, seq_id in enumerate(seq_ids):
+                seq_data = sampling_metadata.seq_data[seq_id]
+                if len(seq_data.output_token_ids) < min_tokens:
+                    seqs_to_penalize.append(i)
+
+            if seqs_to_penalize:
+                # convert to the index into logits
+                seqs_to_penalize = [start_idx + i for i in seqs_to_penalize]
+                # use set() to remove any duplicates
+                token_ids_to_penalize = set(sampling_params.stop_token_ids +
+                                            [sampling_params.eos_token_id])
+                # itertools.product pairs each seq index with every token id
+                logits_to_penalize.extend(
+                    itertools.product(seqs_to_penalize, token_ids_to_penalize))
+
+        start_idx += len(seq_ids)
+
+    if logits_to_penalize:
+        # use zip and * to group indices along each dimension
+        # eg. [ (1,2), (1,3), (5,6) ] -> ( (1,1,5), (2,3,6) )
+        logits[tuple(zip(*logits_to_penalize))] = -float("inf")
+
+    # verifies that no rows in logits were missed unexpectedly
+    assert start_idx == logits.shape[0]
+    return logits
+
+
+def _apply_penalties(logits: torch.Tensor, prompt_tokens_tensor: torch.Tensor,
+                     output_tokens_tensor: torch.Tensor,
+                     presence_penalties: torch.Tensor,
+                     frequency_penalties: torch.Tensor,
+                     repetition_penalties: torch.Tensor) -> torch.Tensor:
+    num_seqs, vocab_size = logits.shape
+    _, prompt_mask = _get_bin_counts_and_mask(prompt_tokens_tensor, vocab_size,
+                                              num_seqs)
+    output_bin_counts, output_mask = _get_bin_counts_and_mask(
+        output_tokens_tensor, vocab_size, num_seqs)
+
+    repetition_penalties = repetition_penalties[:, None].repeat(1, vocab_size)
+    repetition_penalties[~(prompt_mask | output_mask)] = 1.0
+    logits = torch.where(logits > 0, logits / repetition_penalties,
+                         logits * repetition_penalties)
+
+    # We follow the definition in OpenAI API.
+    # Refer to https://platform.openai.com/docs/api-reference/parameter-details
+    logits -= frequency_penalties.unsqueeze_(dim=1) * output_bin_counts
+    logits -= presence_penalties.unsqueeze_(dim=1) * output_mask
+    return logits
+
+
+def _apply_top_k_top_p(
+    logits: torch.Tensor,
+    p: torch.Tensor,
+    k: torch.Tensor,
+) -> torch.Tensor:
+    logits_sort, logits_idx = logits.sort(dim=-1, descending=False)
+
+    # Apply top-k.
+    top_k_mask = logits_sort.size(1) - k.to(torch.long)
+    # Get all the top_k values.
+    top_k_mask = logits_sort.gather(1, top_k_mask.unsqueeze(dim=1))
+    top_k_mask = logits_sort < top_k_mask
+    logits_sort.masked_fill_(top_k_mask, -float("inf"))
+
+    # Apply top-p.
+    probs_sort = logits_sort.softmax(dim=-1)
+    probs_sum = probs_sort.cumsum(dim=-1)
+    top_p_mask = probs_sum <= 1 - p.unsqueeze(dim=1)
+    # at least one
+    top_p_mask[:, -1] = False
+    logits_sort.masked_fill_(top_p_mask, -float("inf"))
+
+    # Re-sort the probabilities.
+    src = torch.arange(logits_idx.shape[-1],
+                       device=logits_idx.device).expand_as(logits_idx)
+    logits_idx_inv = torch.empty_like(logits_idx).scatter_(dim=-1,
+                                                           index=logits_idx,
+                                                           src=src)
+    logits = torch.gather(logits_sort, dim=-1, index=logits_idx_inv)
+    return logits
+
+
+def _apply_min_p(
+    logits: torch.Tensor,
+    min_p: torch.Tensor,
+) -> torch.Tensor:
+    """
+    Adapted from
+    https://github.com/oobabooga/text-generation-webui/blob/3146124ec01f02c8fb1650a6517cf1b60b537aaf/modules/sampler_hijack.py#L16C17-L16C17
+    """
+    probs = torch.softmax(logits, dim=-1)
+    top_probs, _ = probs.max(dim=-1, keepdim=True)
+    scaled_min_p = min_p.unsqueeze_(dim=1) * top_probs
+    tokens_to_remove = probs < scaled_min_p
+    logits = logits.masked_fill_(tokens_to_remove, -float("inf"))
+
+    return logits
+
+
+def _greedy_sample(
+    selected_seq_groups: List[Tuple[List[int], SamplingParams]],
+    samples: torch.Tensor,
+) -> List[Tuple[List[int], List[int]]]:
+    samples = samples.tolist()
+    sample_idx = 0
+    results = []
+    for seq_group in selected_seq_groups:
+        seq_ids, _ = seq_group
+        num_parent_seqs = len(seq_ids)
+        assert num_parent_seqs == 1, (
+            "Greedy sampling should have only one seq.")
+        parent_ids = list(range(num_parent_seqs))
+        next_token_ids = [samples[sample_idx]]
+        results.append((next_token_ids, parent_ids))
+        sample_idx += num_parent_seqs
+    return results
+
+
+def _random_sample(
+    selected_seq_groups: List[Tuple[List[int], SamplingParams]],
+    is_prompts: List[bool],
+    random_samples: torch.Tensor,
+) -> List[Tuple[List[int], List[int]]]:
+    # Find the maximum best_of value of the prompt phase requests.
+    random_samples = random_samples.cpu()
+    sample_idx = 0
+    results = []
+    for seq_group, is_prompt in zip(selected_seq_groups, is_prompts):
+        seq_ids, sampling_params = seq_group
+        num_parent_seqs = len(seq_ids)
+        if is_prompt:
+            # Prompt phase.
+            parent_ids = [0] * sampling_params.best_of
+            next_token_ids = random_samples[
+                sample_idx, :sampling_params.best_of].tolist()
+        else:
+            # Generation phase.
+            parent_ids = list(range(num_parent_seqs))
+            next_token_ids = random_samples[sample_idx:sample_idx +
+                                            num_parent_seqs, 0].tolist()
+        results.append((next_token_ids, parent_ids))
+        sample_idx += num_parent_seqs
+    return results
+
+
+def _beam_search_sample(
+    selected_seq_groups: List[Tuple[List[int], SamplingParams]],
+    is_prompts: List[bool],
+    seq_data: Dict[int, SequenceData],
+    logprobs: torch.Tensor,
+) -> List[Tuple[List[int], List[int]]]:
+    # We sample 2 * beam_width candidates to make sure that with high
+    # probability we can get `beam_width` candidates in addition to
+    # the finished sequences for the next iteration. See
+    # https://github.com/tensorflow/tensor2tensor/blob/bafdc1b67730430d38d6ab802cbd51f9d053ba2e/tensor2tensor/utils/beam_search.py#L557-L563
+    # for details. See also HF reference:
+    # https://github.com/huggingface/transformers/blob/a4dd53d88e4852f023332d284ff07a01afcd5681/src/transformers/generation/utils.py#L3063-L3065
+    #
+    # NOTE: Beam search is not vectorized, so its speed can be slower than
+    # other sampling methods.
+    sample_idx = 0
+    results = []
+    for seq_group, is_prompt in zip(selected_seq_groups, is_prompts):
+        seq_ids, sampling_params = seq_group
+        num_parent_seqs = len(seq_ids)
+        beam_width = sampling_params.best_of
+        seq_group_logprobs = logprobs[sample_idx:sample_idx + num_parent_seqs]
+        if is_prompt:
+            # Prompt phase.
+            assert num_parent_seqs == 1, (
+                "Prompt input should have only one seq.")
+            parent_ids = [0] * (2 * beam_width)
+            _, next_token_ids = torch.topk(seq_group_logprobs[0],
+                                           2 * beam_width)
+            next_token_ids = next_token_ids.tolist()
+        else:
+            # Generation phase.
+            cumulative_logprobs = [
+                seq_data[seq_id].cumulative_logprob for seq_id in seq_ids
+            ]
+            cumulative_logprobs = torch.tensor(
+                cumulative_logprobs,
+                dtype=torch.float,
+                device=seq_group_logprobs.device)
+            seq_group_logprobs = (seq_group_logprobs +
+                                  cumulative_logprobs.unsqueeze(dim=1))
+            _, topk_ids = torch.topk(seq_group_logprobs.flatten(),
+                                     2 * beam_width)
+            topk_ids = topk_ids.tolist()
+            vocab_size = seq_group_logprobs.size(-1)
+            parent_ids = [i // vocab_size for i in topk_ids]
+            next_token_ids = [i % vocab_size for i in topk_ids]
+        results.append((next_token_ids, parent_ids))
+        sample_idx += num_parent_seqs
+    assert sample_idx == logprobs.size(0)
+    return results
+
+
+# torch.multinomial forces a GPU<->CPU sync.
+# Therefore, we use an optimized implementation instead.
+# Note that we always sample with replacement.
+# probs will be modified in place, but this is fine, as we pass
+# in a copy already.
+def _multinomial(
+    probs: torch.Tensor,
+    num_samples: int,
+    seq_groups: Optional[List[Tuple[List[int], SamplingParams]]] = None,
+    generators: Optional[List[torch.Generator]] = None,
+) -> torch.Tensor:
+    if num_samples > 1:
+        # This is equivalent to torch.repeat_interleaved (which also
+        # forces a GPU<->CPU sync).
+        # This allows us to do sampling with replacement by creating
+        # num_samples copies of each row in the tensor, and then
+        # batch sampling the resulting tensor.
+        probs = probs[:, None, :].expand(probs.shape[0], num_samples,
+                                         probs.shape[1]).contiguous().view(
+                                             -1, probs.shape[1])
+    q = torch.empty_like(probs)
+    if seq_groups is None:
+        q.exponential_()
+    else:
+        sample_idx = 0
+        for (seq_ids, _), generator in zip(seq_groups, generators):
+            next_sample_idx = sample_idx + len(seq_ids) * num_samples
+            q[sample_idx:next_sample_idx].exponential_(generator=generator)
+            sample_idx = next_sample_idx
+    return probs.div_(q).argmax(dim=1).view(-1, num_samples)
+
+
+def _sample_with_torch(
+    probs: torch.Tensor,
+    logprobs: torch.Tensor,
+    sampling_metadata: SamplingMetadata,
+    include_gpu_probs_tensor: bool,
+    modify_greedy_probs: bool,
+) -> Tuple[List[Tuple[List[int], List[int]]], Optional[torch.Tensor]]:
+    categorized_seq_group_ids = {t: [] for t in SamplingType}
+    categorized_sample_indices = sampling_metadata.categorized_sample_indices
+    for i, seq_group in enumerate(sampling_metadata.seq_groups):
+        _, sampling_params = seq_group
+        sampling_type = sampling_params.sampling_type
+        categorized_seq_group_ids[sampling_type].append(i)
+
+    sample_results_dict: Dict[int, Tuple[List[int], List[int]]] = {}
+    sample_metadata = {}
+    multinomial_samples = {}
+
+    # Create output tensor for sampled token ids.
+    if include_gpu_probs_tensor:
+        sampled_token_ids_tensor = torch.empty(logprobs.shape[0],
+                                               1,
+                                               dtype=torch.long,
+                                               device=logprobs.device)
+    else:
+        sampled_token_ids_tensor = None
+
+    # Counterintiutively, having two loops here is actually faster.
+    # The first loop can run without waiting on GPU<->CPU sync.
+    for sampling_type in SamplingType:
+        sample_indices = categorized_sample_indices[sampling_type][:, 0]
+        num_tokens = len(sample_indices)
+        if num_tokens == 0:
+            continue
+        seq_group_ids = categorized_seq_group_ids[sampling_type]
+        seq_groups = [sampling_metadata.seq_groups[i] for i in seq_group_ids]
+        is_prompts = [i < sampling_metadata.num_prompts for i in seq_group_ids]
+        sample_metadata[sampling_type] = (seq_group_ids, seq_groups,
+                                          is_prompts, sample_indices)
+        long_sample_indices = sample_indices.long()
+
+        if sampling_type == SamplingType.GREEDY:
+            greedy_samples = torch.argmax(logprobs[long_sample_indices],
+                                          dim=-1)
+
+            if include_gpu_probs_tensor:
+                # Store sampled tokens in output tensor.
+                sampled_token_ids_tensor[
+                    long_sample_indices] = greedy_samples.unsqueeze(-1)
+
+            if modify_greedy_probs:
+                # If required, modify the probabilities such that sampling from
+                # the modified distribution would always sample the argmax
+                # token id.
+                _modify_greedy_probs_inplace(logprobs, probs,
+                                             long_sample_indices,
+                                             greedy_samples)
+
+        elif sampling_type in (SamplingType.RANDOM, SamplingType.RANDOM_SEED):
+            max_best_of_in_batch = 1
+            for seq_group, is_prompt in zip(seq_groups, is_prompts):
+                if is_prompt:
+                    _, sampling_params = seq_group
+                    max_best_of_in_batch = max(max_best_of_in_batch,
+                                               sampling_params.best_of)
+            seeded_args = {} if sampling_type == SamplingType.RANDOM else {
+                "seq_groups": seq_groups,
+                "generators": sampling_metadata.generators,
+            }
+
+            multinomial_samples[sampling_type] = _multinomial(
+                probs[long_sample_indices], max_best_of_in_batch,
+                **seeded_args)
+
+            if include_gpu_probs_tensor:
+                # Store sampled tokens in output tensor.
+                sampled_token_ids_tensor[
+                    long_sample_indices] = multinomial_samples[sampling_type]
+
+        elif sampling_type == SamplingType.BEAM:
+            beam_search_logprobs = logprobs[sample_indices]
+        else:
+            raise ValueError(f"Unsupported sampling type: {sampling_type}")
+
+    # GPU<->CPU sync happens in the loop below.
+    # This also converts the sample output to Python objects.
+
+    for sampling_type in SamplingType:
+        if sampling_type not in sample_metadata:
+            continue
+        seq_group_ids, seq_groups, is_prompts, sample_indices = sample_metadata[
+            sampling_type]
+        if sampling_type == SamplingType.GREEDY:
+            sample_results = _greedy_sample(seq_groups, greedy_samples)
+        elif sampling_type in (SamplingType.RANDOM, SamplingType.RANDOM_SEED):
+            sample_results = _random_sample(seq_groups, is_prompts,
+                                            multinomial_samples[sampling_type])
+        elif sampling_type == SamplingType.BEAM:
+            sample_results = _beam_search_sample(seq_groups, is_prompts,
+                                                 sampling_metadata.seq_data,
+                                                 beam_search_logprobs)
+        sample_results_dict.update(zip(seq_group_ids, sample_results))
+
+    sample_results = [
+        sample_results_dict[i]
+        for i in range(len(sampling_metadata.seq_groups))
+    ]
+    return sample_results, sampled_token_ids_tensor
+
+
+def _sample_with_triton_kernel(
+    probs: torch.Tensor,
+    logprobs: torch.Tensor,
+    sampling_metadata: SamplingMetadata,
+    sampling_tensors: SamplingTensors,
+) -> List[Tuple[List[int], List[int]]]:
+    categorized_seq_group_ids = {t: [] for t in SamplingType}
+    categorized_sample_indices = sampling_metadata.categorized_sample_indices
+    for i, seq_group in enumerate(sampling_metadata.seq_groups):
+        _, sampling_params = seq_group
+        sampling_type = sampling_params.sampling_type
+        categorized_seq_group_ids[sampling_type].append(i)
+
+    sample_results_dict: Dict[int, Tuple[List[int], List[int]]] = {}
+    sample_metadata = {}
+    max_best_of_in_batch = 1
+
+    # Counterintiutively, having two loops here is actually faster.
+    # The first loop can run without waiting on GPU<->CPU sync.
+    for sampling_type in SamplingType:
+        sample_indices = categorized_sample_indices[sampling_type][:, 0]
+        sampled_token_indices = categorized_sample_indices[sampling_type][:, 1]
+        num_tokens = len(sample_indices)
+        if num_tokens == 0:
+            continue
+        seq_group_ids = categorized_seq_group_ids[sampling_type]
+        seq_groups = [sampling_metadata.seq_groups[i] for i in seq_group_ids]
+        is_prompts = [i < sampling_metadata.num_prompts for i in seq_group_ids]
+        sample_metadata[sampling_type] = (seq_group_ids, seq_groups,
+                                          is_prompts, sample_indices,
+                                          sampled_token_indices)
+        if sampling_type in (SamplingType.GREEDY, SamplingType.RANDOM,
+                             SamplingType.RANDOM_SEED):
+            for seq_group, is_prompt in zip(seq_groups, is_prompts):
+                if is_prompt:
+                    _, sampling_params = seq_group
+                    max_best_of_in_batch = max(max_best_of_in_batch,
+                                               sampling_params.best_of)
+        elif sampling_type == SamplingType.BEAM:
+            beam_search_logprobs = logprobs[sample_indices]
+        else:
+            raise ValueError(f"Unsupported sampling type: {sampling_type}")
+
+    sampled_tokens, _, _ = sample_triton(
+        probs=probs,
+        seeds=sampling_tensors.sampling_seeds,
+        max_best_of=max_best_of_in_batch,
+        sample_indices=sampling_tensors.sample_indices,
+        logprobs=logprobs,
+        # don't save logprobs because we have logic for that below
+        # TODO: use this instead of the CPU-based logic below
+        save_logprobs=False,
+    )
+
+    # GPU<->CPU sync happens in the loop below.
+
+    for sampling_type in SamplingType:
+        if sampling_type not in sample_metadata:
+            continue
+        (seq_group_ids, seq_groups, is_prompts, sample_indices,
+         sampled_token_indices) = sample_metadata[sampling_type]
+        if sampling_type == SamplingType.GREEDY:
+            sample_results = _greedy_sample(
+                seq_groups, sampled_tokens[sampled_token_indices][:, 0])
+        elif sampling_type in (SamplingType.RANDOM, SamplingType.RANDOM_SEED):
+            sample_results = _random_sample(
+                seq_groups, is_prompts, sampled_tokens[sampled_token_indices])
+        elif sampling_type == SamplingType.BEAM:
+            sample_results = _beam_search_sample(seq_groups, is_prompts,
+                                                 sampling_metadata.seq_data,
+                                                 beam_search_logprobs)
+        sample_results_dict.update(zip(seq_group_ids, sample_results))
+
+    sample_results = [
+        sample_results_dict[i]
+        for i in range(len(sampling_metadata.seq_groups))
+    ]
+    return sample_results
+
+
+def _sample(
+    probs: torch.Tensor, logprobs: torch.Tensor,
+    sampling_metadata: SamplingMetadata, sampling_tensors: SamplingTensors,
+    include_gpu_probs_tensor: bool, modify_greedy_probs: bool
+) -> Tuple[List[Tuple[List[int], List[int]]], Optional[torch.Tensor]]:
+    return _sample_with_torch(
+        probs,
+        logprobs,
+        sampling_metadata,
+        include_gpu_probs_tensor=include_gpu_probs_tensor,
+        modify_greedy_probs=modify_greedy_probs,
+    )
+
+    # TODO: Enable once Triton kernel & associated code is faster.
+    # return _sample_with_triton_kernel(probs, logprobs, sampling_metadata,
+    #                                   sampling_tensors)
+
+
+def _get_ranks(x: torch.Tensor, indices: torch.Tensor) -> torch.Tensor:
+    """
+    This function calculates the ranks of the chosen tokens in a logprob tensor.
+
+    Args:
+        x (torch.Tensor): 2D logprob tensor of shape (N, M)
+                        where N is the no. of tokens and M is the vocab dim.
+        indices (torch.Tensor): List of chosen token indices.
+
+    Returns:
+        torch.Tensor: 1D tensor of shape (N,) where N is the no. of tokens.
+                    Each element in the returned tensor represents the rank 
+                    of the chosen token in the input logprob tensor.
+    """
+    vals = x[torch.arange(0, len(x), device=x.device, dtype=indices.dtype),
+             indices]
+    return (x > vals[:, None]).long().sum(1).add_(1)
+
+
+def _get_logprobs(
+    logprobs: torch.Tensor,
+    sampling_metadata: SamplingMetadata,
+    sample_results: List[Tuple[List[int], List[int]]],
+) -> Tuple[List[Optional[List[Optional[Dict[int, float]]]]], List[List[Dict[
+        int, float]]]]:
+    # Prepare query indices
+    batched_logprobs_query_seq_indices: List[int] = []
+    batched_logprobs_query_token_indices: List[int] = []
+    # at least get one logprob for each token
+    largest_num_logprobs = 1
+    sample_idx = 0
+    for i, (seq_group, sample_result) in enumerate(
+            zip(sampling_metadata.seq_groups, sample_results)):
+        seq_ids, sampling_params = seq_group
+        next_token_ids, parent_ids = sample_result
+        num_parent_seqs = len(seq_ids)
+        if (i < sampling_metadata.num_prompts
+                and sampling_params.prompt_logprobs is not None):
+            largest_num_logprobs = max(largest_num_logprobs,
+                                       sampling_params.prompt_logprobs)
+            prompt_len = sampling_metadata.prompt_lens[i]
+            prompt_tokens = sampling_metadata.seq_data[
+                seq_ids[0]].prompt_token_ids
+            batched_logprobs_query_seq_indices.extend(
+                sample_idx + j for j in range(prompt_len - 1))
+            batched_logprobs_query_token_indices.extend(
+                token_id for token_id in prompt_tokens[1:])
+            sample_idx += prompt_len - 1
+        batched_logprobs_query_seq_indices.extend(
+            [sample_idx + parent_id for parent_id in parent_ids])
+        batched_logprobs_query_token_indices.extend(next_token_ids)
+        if sampling_params.logprobs is not None:
+            largest_num_logprobs = max(largest_num_logprobs,
+                                       sampling_params.logprobs)
+        sample_idx += num_parent_seqs
+    assert sample_idx == logprobs.size(0)
+
+    batched_logprobs_query_seq_indices_gpu = torch.tensor(
+        batched_logprobs_query_seq_indices, device=logprobs.device)
+    batched_logprobs_query_token_indices_gpu = torch.tensor(
+        batched_logprobs_query_token_indices, device=logprobs.device)
+
+    # Batched query for logprobs of selected token
+    batched_logprobs_query_result = logprobs[[
+        batched_logprobs_query_seq_indices_gpu,
+        batched_logprobs_query_token_indices_gpu
+    ]]
+
+    batched_ranks_query_result = _get_ranks(
+        logprobs[batched_logprobs_query_seq_indices_gpu],
+        batched_logprobs_query_token_indices_gpu)
+
+    # Batched query for logprobs of topk tokens
+    if largest_num_logprobs > 0:
+        top_logprobs, top_token_ids = torch.topk(logprobs,
+                                                 largest_num_logprobs,
+                                                 dim=-1)
+        top_logprobs = top_logprobs.cpu()
+        top_token_ids = top_token_ids.cpu()
+    else:
+        top_logprobs, top_token_ids = None, None
+
+    batched_logprobs_query_result = batched_logprobs_query_result.cpu()
+    batched_ranks_query_result = batched_ranks_query_result.cpu()
+
+    # Gather results
+    result_prompt_logprobs: List[Optional[PromptLogprobs]] = []
+    result_sample_logprobs: List[SampleLogprobs] = []
+    sample_idx = 0
+    query_result_idx = 0
+    for i, (seq_group, sample_result) in enumerate(
+            zip(sampling_metadata.seq_groups, sample_results)):
+        seq_ids, sampling_params = seq_group
+        next_token_ids, parent_ids = sample_result
+
+        # Prompt logprobs
+        if (i < sampling_metadata.num_prompts
+                and sampling_params.prompt_logprobs is not None):
+            num_logprobs = sampling_params.prompt_logprobs
+            prompt_tokens = sampling_metadata.seq_data[
+                seq_ids[0]].prompt_token_ids
+            group_prompt_logprobs: PromptLogprobs = [None]
+            for token_id in prompt_tokens[1:]:
+                prompt_logprobs_dict = {
+                    token_id:
+                    (batched_logprobs_query_result[query_result_idx].item(),
+                     batched_ranks_query_result[query_result_idx].item())
+                }
+                if num_logprobs > 0:
+                    prompt_logprobs_dict.update(
+                        zip(
+                            top_token_ids[sample_idx, :num_logprobs].tolist(),
+                            zip(
+                                top_logprobs[
+                                    sample_idx, :num_logprobs].tolist(),
+                                range(1, num_logprobs + 1))))
+                group_prompt_logprobs.append({
+                    token_id: Logprob(*logprob_rank)
+                    for token_id, logprob_rank in prompt_logprobs_dict.items()
+                })
+                sample_idx += 1
+                query_result_idx += 1
+            result_prompt_logprobs.append(group_prompt_logprobs)
+        else:
+            result_prompt_logprobs.append(None)
+
+        # Sample logprobs
+        num_logprobs = sampling_params.logprobs
+        if num_logprobs is None:
+            num_logprobs = 0
+        group_sample_logprobs: SampleLogprobs = []
+        for next_token_id, parent_id in zip(next_token_ids, parent_ids):
+            sample_logprobs_dict = {
+                next_token_id:
+                (batched_logprobs_query_result[query_result_idx].item(),
+                 batched_ranks_query_result[query_result_idx].item())
+            }
+            query_result_idx += 1
+            if num_logprobs >= 0:
+                sample_logprobs_dict.update(
+                    zip(
+                        top_token_ids[sample_idx +
+                                      parent_id, :num_logprobs].tolist(),
+                        zip(
+                            top_logprobs[sample_idx +
+                                         parent_id, :num_logprobs].tolist(),
+                            range(1, num_logprobs + 1))))
+            group_sample_logprobs.append({
+                token_id: Logprob(*logprob_rank)
+                for token_id, logprob_rank in sample_logprobs_dict.items()
+            })
+        result_sample_logprobs.append(group_sample_logprobs)
+        sample_idx += len(seq_ids)
+
+    return result_prompt_logprobs, result_sample_logprobs
+
+
+def _modify_greedy_probs_inplace(logprobs: torch.Tensor, probs: torch.Tensor,
+                                 sample_indices: torch.Tensor,
+                                 greedy_samples: torch.Tensor) -> None:
+    """Modify the probability distributions of the greedily-sampled tokens such
+    that each sampled token has a "probability" of 1.0. This is required by
+    speculative decoding, which depends on the sampling method being encoded
+    within the probability distribution for correctness.
+
+    # Why do we only need to do this for greedy sampling?
+
+    vLLM's sampler performs the following steps for greedy or multinomial
+    (random) sampling:
+        1. Get logits from model.
+        2. Modify logits according to per-sequence sampling parameters.
+            - Multiply by temperature, top-k and top-p masking, penalize tokens
+                according to their frequency, etc.
+        3. Sample a token.
+            - Random sampling simply samples from the modified probability
+                distribution.
+            - Greedy sampling performs `argmax` to obtain the token with the
+                highest likelihood.
+    
+    Ignoring greedy sampling for a moment, we find that the computed probability
+    distribution has the following property: we can sample from it independently
+    and find that the token sampled by the Sampler has a frequency corresponding
+    to how often we see it in our sampling. In other words, for tokens sampled
+    with vLLM's random SamplingType, the computed probability distribution
+    encodes the sampling methodology completely.
+
+    Greedy sampling does not normally have this property. vLLM modifies logits
+    according to sampling params, then performs `argmax`, then returns the
+    sampled token and the computed probability distribution. If we sample from
+    the distribution, we'll find the likelihood of the greedily-sampled token
+    is not always 1.0.
+
+    Since lossless speculative decoding requires that the sampling methodology
+    be encoded within the probability distribution, we are motivated to modify
+    the probability distribution such that the sampled token has probability 1
+    when speculative decoding is used.
+
+    NOTE: Alternatively, we could use an extremely low temperature to achieve
+    greedy sampling using multinomial computation and unite the codepaths. This
+    has implications on the overall design of the sampler, e.g. how to record
+    accurate logprobs for the user, so this improvement is deferred to later.
+    """
+    logprobs[sample_indices, :] = -float('inf')
+    logprobs[sample_indices, greedy_samples] = 0.0
+    probs[sample_indices, :] = 0
+    probs[sample_indices, greedy_samples] = 1.0
+
+
+def _build_sampler_output(
+    sample_results: List[Tuple[List[int], List[int]]],
+    sampling_metadata: SamplingMetadata,
+    prompt_logprobs: List[Optional[PromptLogprobs]],
+    sample_logprobs: List[SampleLogprobs],
+    on_device_tensors: Optional[Tuple[torch.Tensor, torch.Tensor]],
+) -> SamplerOutput:
+    """Construct Python objects with the output of sampling.
+
+    Args:
+        on_device_tensors: Tuple containing on-device tensors with the
+            probabilities used in sampling and the sampled token ids. This
+            allows post-processing without copies to CPU/serialization, e.g. in
+            speculative decoding rejection sampling.
+    """
+
+    sampler_output = []
+    for (seq_group, sample_result, group_prompt_logprobs,
+         group_sample_logprobs) in zip(sampling_metadata.seq_groups,
+                                       sample_results, prompt_logprobs,
+                                       sample_logprobs):
+        seq_ids, _ = seq_group
+        next_token_ids, parent_ids = sample_result
+        seq_outputs = []
+        for parent_id, next_token_id, logprobs in zip(parent_ids,
+                                                      next_token_ids,
+                                                      group_sample_logprobs):
+            seq_outputs.append(
+                SequenceOutput(seq_ids[parent_id], next_token_id, logprobs))
+        sampler_output.append(
+            SequenceGroupOutput(seq_outputs, group_prompt_logprobs))
+
+    # If not specified, store None values in SamplerOutput.
+    if on_device_tensors is not None:
+        sampled_token_probs, sampled_token_ids = on_device_tensors
+    else:
+        sampled_token_probs, sampled_token_ids = (None, None)
+
+    return SamplerOutput(
+        outputs=sampler_output,
+        sampled_token_probs=sampled_token_probs,
+        sampled_token_ids=sampled_token_ids,
+    )

autoregressive/serve/worker.py

@@ -0,0 +1,349 @@
+"""A GPU worker class."""
+import gc
+import os
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+import torch
+import torch.distributed
+
+from vllm.config import (CacheConfig, DeviceConfig, LoadConfig, LoRAConfig,
+                         ModelConfig, ParallelConfig, SchedulerConfig,
+                         VisionLanguageConfig)
+from vllm.distributed import (broadcast_tensor_dict,
+                              ensure_model_parallel_initialized,
+                              init_distributed_environment)
+from vllm.distributed.device_communicators import pynccl_utils
+from vllm.distributed.device_communicators.custom_all_reduce import (
+    init_custom_ar)
+from vllm.lora.request import LoRARequest
+from vllm.model_executor import set_random_seed
+from vllm.sequence import SamplerOutput, SequenceGroupMetadata
+from vllm.worker.cache_engine import CacheEngine
+# from vllm.worker.model_runner import ModelRunner
+from vllm.worker.worker_base import WorkerBase
+from autoregressive.serve.model_runner import ModelRunner
+
+
+class Worker(WorkerBase):
+    """A worker class that executes (a partition of) the model on a GPU.
+
+    Each worker is associated with a single GPU. The worker is responsible for
+    maintaining the KV cache and executing the model on the GPU. In case of
+    distributed inference, each worker is assigned a partition of the model.
+    """
+
+    def __init__(
+        self,
+        model_config: ModelConfig,
+        parallel_config: ParallelConfig,
+        scheduler_config: SchedulerConfig,
+        device_config: DeviceConfig,
+        cache_config: CacheConfig,
+        load_config: LoadConfig,
+        local_rank: int,
+        rank: int,
+        distributed_init_method: str,
+        lora_config: Optional[LoRAConfig] = None,
+        vision_language_config: Optional[VisionLanguageConfig] = None,
+        is_driver_worker: bool = False,
+    ) -> None:
+        self.model_config = model_config
+        self.parallel_config = parallel_config
+        self.scheduler_config = scheduler_config
+        self.device_config = device_config
+        self.cache_config = cache_config
+        self.local_rank = local_rank
+        self.rank = rank
+        self.distributed_init_method = distributed_init_method
+        self.lora_config = lora_config
+        self.load_config = load_config
+        self.is_driver_worker = is_driver_worker
+        if self.is_driver_worker:
+            assert self.rank == 0, "The driver worker must have rank 0."
+
+        if self.model_config.trust_remote_code:
+            # note: lazy import to avoid importing torch before initializing
+            from vllm.utils import init_cached_hf_modules
+            init_cached_hf_modules()
+        self.vision_language_config = vision_language_config
+        if self.vision_language_config:
+            assert not self.lora_config, (
+                "To be tested: vision language model with LoRA settings.")
+
+        self.model_runner = ModelRunner(
+            model_config,
+            parallel_config,
+            scheduler_config,
+            device_config,
+            load_config=load_config,
+            lora_config=self.lora_config,
+            kv_cache_dtype=self.cache_config.cache_dtype,
+            is_driver_worker=is_driver_worker,
+            vision_language_config=vision_language_config,
+        )
+        # Uninitialized cache engine. Will be initialized by
+        # initialize_cache.
+        self.cache_engine: CacheEngine
+        self.gpu_cache: List[torch.Tensor]
+
+    def init_device(self) -> None:
+        if self.device_config.device.type == "cuda":
+            # torch.distributed.all_reduce does not free the input tensor until
+            # the synchronization point. This causes the memory usage to grow
+            # as the number of all_reduce calls increases. This env var disables
+            # this behavior.
+            # Related issue:
+            # https://discuss.pytorch.org/t/cuda-allocation-lifetime-for-inputs-to-distributed-all-reduce/191573
+            os.environ["TORCH_NCCL_AVOID_RECORD_STREAMS"] = "1"
+
+            # This env var set by Ray causes exceptions with graph building.
+            os.environ.pop("NCCL_ASYNC_ERROR_HANDLING", None)
+            self.device = torch.device(f"cuda:{self.local_rank}")
+            torch.cuda.set_device(self.device)
+
+            _check_if_gpu_supports_dtype(self.model_config.dtype)
+            torch.cuda.empty_cache()
+            self.init_gpu_memory = torch.cuda.mem_get_info()[0]
+        else:
+            raise RuntimeError(
+                f"Not support device type: {self.device_config.device}")
+        # Initialize the distributed environment.
+        init_worker_distributed_environment(self.parallel_config, self.rank,
+                                            self.distributed_init_method,
+                                            self.local_rank)
+        # Set random seed.
+        set_random_seed(self.model_config.seed)
+
+    def load_model(self, args):
+        self.model_runner.load_model(args)
+
+    @torch.inference_mode()
+    def determine_num_available_blocks(self) -> Tuple[int, int]:
+        """Profiles the peak memory usage of the model to determine how many
+        KV blocks may be allocated without OOMs.
+
+        The engine will first conduct a profiling of the existing memory usage.
+        Then, it calculate the maximum possible number of GPU and CPU blocks
+        that can be allocated with the remaining free memory.
+
+        .. tip::
+            You may limit the usage of GPU memory
+            by adjusting the `gpu_memory_utilization` parameter.
+        """
+        # Profile the memory usage of the model and get the maximum number of
+        # cache blocks that can be allocated with the remaining free memory.
+        torch.cuda.empty_cache()
+
+        # Execute a forward pass with dummy inputs to profile the memory usage
+        # of the model.
+        self.model_runner.profile_run()
+
+        # Calculate the number of blocks that can be allocated with the
+        # profiled peak memory.
+        torch.cuda.synchronize()
+        free_gpu_memory, total_gpu_memory = torch.cuda.mem_get_info()
+        # NOTE(woosuk): Here we assume that the other processes using the same
+        # GPU did not change their memory usage during the profiling.
+        peak_memory = self.init_gpu_memory - free_gpu_memory
+        assert peak_memory > 0, (
+            "Error in memory profiling. This happens when the GPU memory was "
+            "not properly cleaned up before initializing the vLLM instance.")
+
+        cache_block_size = self.get_cache_block_size_bytes()
+        num_gpu_blocks = int(
+            (total_gpu_memory * self.cache_config.gpu_memory_utilization -
+             peak_memory) // cache_block_size)
+        num_cpu_blocks = int(self.cache_config.swap_space_bytes //
+                             cache_block_size)
+        num_gpu_blocks = max(num_gpu_blocks, 0)
+        num_cpu_blocks = max(num_cpu_blocks, 0)
+        if self.model_runner.lora_manager:
+            self.model_runner.remove_all_loras()
+        gc.collect()
+        torch.cuda.empty_cache()
+        return num_gpu_blocks, num_cpu_blocks
+
+    def initialize_cache(self, num_gpu_blocks: int,
+                         num_cpu_blocks: int) -> None:
+        """Allocate GPU and CPU KV cache with the specified number of blocks.
+
+        This also warms up the model, which may record CUDA graphs.
+        """
+        raise_if_cache_size_invalid(num_gpu_blocks,
+                                    self.cache_config.block_size,
+                                    self.model_config.max_model_len)
+
+        self.cache_config.num_gpu_blocks = num_gpu_blocks
+        self.cache_config.num_cpu_blocks = num_cpu_blocks
+
+        self._init_cache_engine()
+        self._warm_up_model()
+
+    def _init_cache_engine(self):
+        assert self.cache_config.num_gpu_blocks is not None
+        self.cache_engine = CacheEngine(self.cache_config, self.model_config,
+                                        self.parallel_config)
+        self.gpu_cache = self.cache_engine.gpu_cache
+        self.model_runner.set_block_size(self.cache_engine.block_size)
+
+    def _warm_up_model(self) -> None:
+        if not self.model_config.enforce_eager:
+            self.model_runner.capture_model(self.gpu_cache)
+        # Reset the seed to ensure that the random state is not affected by
+        # the model initialization and profiling.
+        set_random_seed(self.model_config.seed)
+
+    def cache_swap(
+        self,
+        blocks_to_swap_in: Dict[int, int],
+        blocks_to_swap_out: Dict[int, int],
+        blocks_to_copy: Dict[int, List[int]],
+    ) -> None:
+        # Issue cache operations.
+        # TODO(woosuk): Profile swapping overhead and optimize if needed.
+        if blocks_to_swap_in:
+            self.cache_engine.swap_in(blocks_to_swap_in)
+        if blocks_to_swap_out:
+            self.cache_engine.swap_out(blocks_to_swap_out)
+        if blocks_to_copy:
+            self.cache_engine.copy(blocks_to_copy)
+
+    @torch.inference_mode()
+    def execute_model(
+        self,
+        seq_group_metadata_list: Optional[List[SequenceGroupMetadata]] = None,
+        blocks_to_swap_in: Optional[Dict[int, int]] = None,
+        blocks_to_swap_out: Optional[Dict[int, int]] = None,
+        blocks_to_copy: Optional[Dict[int, List[int]]] = None,
+        num_lookahead_slots: int = 0,
+    ) -> List[SamplerOutput]:
+
+        if self.is_driver_worker:
+            assert seq_group_metadata_list is not None
+            num_seq_groups = len(seq_group_metadata_list)
+            assert blocks_to_swap_in is not None
+            assert blocks_to_swap_out is not None
+            assert blocks_to_copy is not None
+            data: Dict[str, Any] = {
+                "num_seq_groups": num_seq_groups,
+                "blocks_to_swap_in": blocks_to_swap_in,
+                "blocks_to_swap_out": blocks_to_swap_out,
+                "blocks_to_copy": blocks_to_copy,
+            }
+            broadcast_tensor_dict(data, src=0)
+        else:
+            data = broadcast_tensor_dict(src=0)
+            num_seq_groups = data["num_seq_groups"]
+            blocks_to_swap_in = data["blocks_to_swap_in"]
+            blocks_to_swap_out = data["blocks_to_swap_out"]
+            blocks_to_copy = data["blocks_to_copy"]
+
+        assert blocks_to_swap_in is not None
+        assert blocks_to_swap_out is not None
+        assert blocks_to_copy is not None
+        self.cache_swap(blocks_to_swap_in, blocks_to_swap_out, blocks_to_copy)
+
+        # If there is no input, we don't need to execute the model.
+        if num_seq_groups == 0:
+            return []
+
+        output = self.model_runner.execute_model(seq_group_metadata_list,
+                                                 self.gpu_cache)
+
+        # Worker only supports single-step execution. Wrap the output in a list
+        # to conform to interface.
+        return [output]
+
+    def add_lora(self, lora_request: LoRARequest) -> bool:
+        return self.model_runner.add_lora(lora_request)
+
+    def remove_lora(self, lora_id: int) -> bool:
+        return self.model_runner.remove_lora(lora_id)
+
+    def list_loras(self) -> Set[int]:
+        return self.model_runner.list_loras()
+
+    @property
+    def max_model_len(self) -> int:
+        return self.model_config.max_model_len
+
+    @property
+    def vocab_size(self) -> int:
+        return self.model_runner.vocab_size
+
+    def get_cache_block_size_bytes(self) -> int:
+        """Get the size of the KV cache block size in bytes.
+        """
+        return CacheEngine.get_cache_block_size(self.cache_config,
+                                                self.model_config,
+                                                self.parallel_config)
+
+
+def init_worker_distributed_environment(
+    parallel_config: ParallelConfig,
+    rank: int,
+    distributed_init_method: Optional[str] = None,
+    local_rank: int = -1,
+) -> None:
+    """Initialize the distributed environment."""
+    init_distributed_environment(parallel_config.world_size, rank,
+                                 distributed_init_method, local_rank)
+
+    if pynccl_utils.is_initialized():
+        pynccl_world_size = pynccl_utils.get_world_size()
+        if pynccl_world_size != parallel_config.world_size:
+            raise RuntimeError(
+                "pynccl is already initialized but the pynccl world "
+                "size does not match parallel_config.world_size "
+                f"({pynccl_world_size} vs. {parallel_config.world_size}).")
+    elif parallel_config.world_size > 1:
+        # NOTE(woosuk): We don't initialize pynccl process group when world size
+        # is 1.
+        pynccl_utils.init_process_group(
+            world_size=parallel_config.world_size,
+            local_rank=local_rank,
+            rank=rank,
+            init_method=distributed_init_method,
+        )
+
+    ensure_model_parallel_initialized(parallel_config.tensor_parallel_size,
+                                      parallel_config.pipeline_parallel_size)
+
+    # Initialize a custom fast all-reduce implementation.
+    if not parallel_config.disable_custom_all_reduce:
+        init_custom_ar()
+
+    # A small all_reduce for warmup.
+    torch.distributed.all_reduce(torch.zeros(1).cuda())
+    if pynccl_utils.is_initialized():
+        pynccl_utils.all_reduce(torch.zeros(1).cuda())
+
+
+def _check_if_gpu_supports_dtype(torch_dtype: torch.dtype):
+    # Check if the GPU supports the dtype.
+    if torch_dtype == torch.bfloat16:
+        compute_capability = torch.cuda.get_device_capability()
+        if compute_capability[0] < 8:
+            gpu_name = torch.cuda.get_device_name()
+            raise ValueError(
+                "Bfloat16 is only supported on GPUs with compute capability "
+                f"of at least 8.0. Your {gpu_name} GPU has compute capability "
+                f"{compute_capability[0]}.{compute_capability[1]}. "
+                "You can use float16 instead by explicitly setting the"
+                "`dtype` flag in CLI, for example: --dtype=half.")
+
+
+def raise_if_cache_size_invalid(num_gpu_blocks, block_size,
+                                max_model_len) -> None:
+    if num_gpu_blocks <= 0:
+        raise ValueError("No available memory for the cache blocks. "
+                         "Try increasing `gpu_memory_utilization` when "
+                         "initializing the engine.")
+    max_seq_len = block_size * num_gpu_blocks
+    if max_model_len > max_seq_len:
+        raise ValueError(
+            f"The model's max seq len ({max_model_len}) "
+            "is larger than the maximum number of tokens that can be "
+            f"stored in KV cache ({max_seq_len}). Try increasing "
+            "`gpu_memory_utilization` or decreasing `max_model_len` when "
+            "initializing the engine.")

autoregressive/test/metric.py

@@ -0,0 +1,97 @@
+import numpy as np
+from skimage.metrics import structural_similarity as ssim
+from sklearn.metrics import f1_score
+from torchmetrics.image import MultiScaleStructuralSimilarityIndexMeasure
+from torchmetrics.classification import BinaryF1Score
+
+class SSIM:
+    def __init__(self, data_range=1.0):
+        ssim = MultiScaleStructuralSimilarityIndexMeasure(data_range=1.0)#.to(device)
+        self.total_ssim = 0.0
+        self.count = 0
+    def update(self, img1, img2):
+        ssim_value = ssim((img1/255).clip(0,1), (img2/255).clip(0,1), data_range=1.0)
+        self.total_ssim += ssim_value
+        self.count += 1
+
+    def calculate(self):
+        if self.count == 0:
+            raise ValueError("No images have been added.")
+        return self.total_ssim / self.count   
+        
+        
+        
+class F1score:
+    def __init__(self, threshold=128):
+        self.threshold = threshold
+        self.total_f1 = 0
+        self.count = 0
+
+    def update(self, img1, img2):
+        
+        assert img1.size == img2.size, "The images must be the same size."
+    
+        binary_image1 = (img1 > self.threshold).astype(int)
+        binary_image2 = (img2 > self.threshold).astype(int)
+
+        y_true = binary_image1.flatten()
+        y_pred = binary_image2.flatten()
+
+        f1 = f1_score(y_true, y_pred)
+
+        self.total_f1 += f1
+        self.count += 1
+
+    def calculate(self):
+        average_f1 = self.total_f1 / self.count
+        return average_f1
+
+class RMSE:
+    def __init__(self):
+        self.total_rmse = 0
+        self.count = 0
+
+    def update(self, img1, img2):
+        
+        assert img1.size == img2.size, "The images must be the same size."
+        diff = img1 - img2
+        diff_squared = np.square(diff)
+        mse = np.mean(diff_squared)
+        rmse = np.sqrt(mse)
+        self.total_rmse += rmse
+        self.count += 1
+
+    def calculate(self):
+        average_f1 = self.total_rmse / self.count
+        return average_f1
+
+
+
+
+
+if __name__ == "__main__":
+    img1_1 = np.random.randn(256,256)
+    img1_1 = img1_1 - img1_1.min()
+    img1_1 = 255*img1_1/img1_1.max()
+    img1_1 = img1_1.astype(np.uint8)
+    img1_2 = np.random.randn(256,256)
+    img1_2 = img1_2 - img1_2.min()
+    img1_2 = 255*img1_2/img1_2.max()
+    img1_2 = img1_2.astype(np.uint8)
+    img2_1 = np.random.randn(256,256)
+    img2_1 = img2_1 - img2_1.min()
+    img2_1 = 255*img2_1/img2_1.max()
+    img2_1 = img2_1.astype(np.uint8)
+    img2_2 = np.random.randn(256,256)
+    img2_2 = img2_2 - img2_2.min()
+    img2_2 = 255*img2_2/img2_2.max()
+    img2_2 = img2_2.astype(np.uint8)
+    img_pairs = [(img1_1, img2_1), (img1_2, img2_2)]
+    
+    calculator = AverageSSIMCalculator()
+    
+    for img1, img2 in img_pairs:
+        calculator.add_images(img1, img2)
+    
+    avg_ssim = calculator.calculate_average_ssim()
+    print(f'Average SSIM: {avg_ssim}')

autoregressive/test/test_c2i.py

@@ -0,0 +1,267 @@
+# Modified from:
+#   DiT:  https://github.com/facebookresearch/DiT/blob/main/sample.py
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+torch.set_float32_matmul_precision('high')
+setattr(torch.nn.Linear, 'reset_parameters', lambda self: None)
+setattr(torch.nn.LayerNorm, 'reset_parameters', lambda self: None)
+from torchvision.utils import save_image
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+import time
+import argparse
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from autoregressive.models.gpt import GPT_models
+from autoregressive.models.generate import generate
+from condition.hed import HEDdetector, nms
+from condition.canny import CannyDetector
+from condition.midas.depth import MidasDetector
+from autoregressive.test.metric import SSIM, F1score, RMSE
+import torch.distributed as dist
+from dataset.augmentation import center_crop_arr
+from dataset.build import build_dataset
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torchvision import transforms
+from PIL import Image
+import os
+import numpy as np
+import cv2
+from tqdm import tqdm
+from functools import partial
+from skimage.transform import resize
+from torch.nn.functional import interpolate
+def create_npz_from_sample_folder(sample_dir, num=50_000):
+    """
+    Builds a single .npz file from a folder of .png samples.
+    """
+    samples = []
+    for i in tqdm(range(num), desc="Building .npz file from samples"):
+        sample_pil = Image.open(f"{sample_dir}/{i:06d}.png")
+        sample_np = np.asarray(sample_pil).astype(np.uint8)
+        samples.append(sample_np)
+    samples = np.stack(samples)
+    assert samples.shape == (num, samples.shape[1], samples.shape[2], 3)
+    npz_path = f"{sample_dir}.npz"
+    np.savez(npz_path, arr_0=samples)
+    print(f"Saved .npz file to {npz_path} [shape={samples.shape}].")
+    return npz_path
+
+def main(args):
+    assert torch.cuda.is_available(), "Sampling with DDP requires at least one GPU. sample.py supports CPU-only usage"
+    torch.set_grad_enabled(False)
+    # Setup DDP:
+    dist.init_process_group("nccl")
+    rank = dist.get_rank()
+    device = rank % torch.cuda.device_count()
+    seed = args.global_seed * dist.get_world_size() + rank
+    torch.manual_seed(seed)
+    torch.cuda.set_device(device)
+    print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+    
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.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 = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.precision]
+    latent_size = args.image_size // args.downsample_size
+    gpt_model = GPT_models[args.gpt_model](
+        vocab_size=args.codebook_size,
+        block_size=latent_size ** 2,
+        num_classes=args.num_classes,
+        cls_token_num=args.cls_token_num,
+        model_type=args.gpt_type,
+        condition_token_num=args.condition_token_nums,
+        # image_size=args.image_size
+    ).to(device=device, dtype=precision)
+    
+    
+    _, file_extension = os.path.splitext(args.gpt_ckpt)
+    if file_extension.lower() == '.safetensors':
+        from safetensors.torch import load_file
+        model_weight = load_file(args.gpt_ckpt)
+        gpt_model.load_state_dict(model_weight, strict=False)
+        gpt_model.eval()
+    else:
+        checkpoint = torch.load(args.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 args.condition_type == 'hed':
+        get_condition = HEDdetector(device=device)
+        get_metric = SSIM()
+    elif args.condition_type == 'canny':
+        get_condition = CannyDetector()
+        get_metric = F1score()
+    elif args.condition_type == 'depth':
+        get_condition = MidasDetector(device=device)
+        get_metric = RMSE()
+    # Setup data:
+    transform = transforms.Compose([
+        transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, args.image_size)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+    ])
+
+    if args.dataset == 'imagenet':
+        dataset = build_dataset(args, transform=transform)
+    elif args.dataset == 'coco':
+        dataset = build_dataset(args, transform=transform)
+    elif args.dataset == 'imagenet_code':
+        dataset = build_dataset(args)
+    else:
+        raise Exception("please check dataset")
+    
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=False,
+        seed=args.global_seed
+    )
+    loader = DataLoader(
+        dataset,
+        batch_size=args.per_proc_batch_size,
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=False
+    )    
+
+
+    if args.compile:
+        print(f"compiling the model...")
+        gpt_model = torch.compile(
+            gpt_model,
+            mode="reduce-overhead",
+            fullgraph=True
+        ) # requires PyTorch 2.0 (optional)
+    else:
+        pass
+        # print(f"no need to compile model in demo") 
+    
+    # Create folder to save samples:
+    model_string_name = args.gpt_model.replace("/", "-")
+    if args.from_fsdp:
+        ckpt_string_name = args.gpt_ckpt.split('/')[-2]
+    else:
+        ckpt_string_name = os.path.basename(args.gpt_ckpt).replace(".pth", "").replace(".pt", "")
+
+    date = os.path.split(os.path.dirname(os.path.dirname(os.path.dirname(args.gpt_ckpt))))[-1]
+
+    sample_folder_dir = f"{args.sample_dir}/imagenet/{args.condition_type}"
+    if rank == 0:
+        if args.save_image:
+            os.makedirs(sample_folder_dir, exist_ok=True)
+            print(f"Saving .png samples at {sample_folder_dir}")
+    n = args.per_proc_batch_size
+    global_batch_size = n * dist.get_world_size()
+    total = 0
+
+    condition_null = None
+    num = 0
+    for batch in tqdm(loader):
+        num += 1
+        # if num > 40:
+        #     break
+        class_labels = batch["labels"].to(device).squeeze(1)
+        condition_image = batch["condition_img"].to(device)
+        condition_imgs = batch["condition_imgs"].to(device)
+
+        batch_size = class_labels.shape[0]
+        
+        c_indices = class_labels
+        qzshape = [len(class_labels), args.codebook_embed_dim, latent_size, latent_size]
+
+        index_sample = generate(
+            gpt_model, c_indices, latent_size ** 2, condition=condition_imgs.repeat(1,3,1,1).to(precision), condition_null=condition_null, condition_token_nums=args.condition_token_nums,
+            cfg_scale=args.cfg_scale, cfg_interval=args.cfg_interval,
+            temperature=args.temperature, top_k=args.top_k,
+            top_p=args.top_p, sample_logits=True, 
+            )
+
+        samples = vq_model.decode_code(index_sample, qzshape) # output value is between [-1, 1]
+        samples = 255*(samples*0.5 + 0.5)
+        if samples.shape[2] != 256:
+            samples = interpolate(samples, size=(256, 256), mode='bilinear', align_corners=False)
+       
+        condition_imgs = 255*(condition_imgs*0.5 + 0.5)
+        if condition_imgs.shape[2] != 256:
+            condition_imgs = interpolate(condition_imgs, size=(256, 256), mode='bilinear', align_corners=False)
+        for i in range(len(samples)):
+           
+            sample = samples[i].to(torch.uint8).permute(1,2,0)
+            sample_condition = get_condition(sample)
+            if torch.is_tensor(sample_condition):
+                sample_condition = sample_condition.cpu().numpy()
+            condition_img = condition_imgs[i,0].cpu().detach().numpy()
+
+            get_metric.update(condition_img, sample_condition)
+
+            index = i * dist.get_world_size() + rank + total
+            if args.save_image:
+                save_image(2*(samples[i]/255 - 0.5), f"{sample_folder_dir}/{index:06d}.png", nrow=1, normalize=True, value_range=(-1, 1))
+
+        total += global_batch_size
+    
+    metric = get_metric.calculate()
+    print(f'count: {get_metric.count}')
+    print(f'{args.condition_type}: {metric}')
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-B")
+    parser.add_argument("--gpt-ckpt", type=str, default=None)
+    parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="c2i", help="class-conditional or text-conditional")
+    parser.add_argument("--from-fsdp", action='store_true')
+    parser.add_argument("--cls-token-num", type=int, default=1, help="max token number of condition input")
+    parser.add_argument("--precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    parser.add_argument("--compile", action='store_true', default=False)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512], default=256)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--num-classes", type=int, default=1000)
+    parser.add_argument("--cfg-scale", type=float, default=4.0)
+    parser.add_argument("--cfg-interval", type=float, default=-1)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--top-k", type=int, default=2000,help="top-k value to sample with")
+    parser.add_argument("--temperature", type=float, default=1.0, help="temperature value to sample with")
+    parser.add_argument("--top-p", type=float, default=1.0, help="top-p value to sample with")
+    parser.add_argument("--condition-token-nums", type=int, default=0)
+    parser.add_argument("--condition-type", type=str, default='canny', choices=['canny', 'depth'])
+    parser.add_argument("--per-proc-batch-size", type=int, default=32)
+    parser.add_argument("--get-condition-img", type=bool, default=False)
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--dataset", type=str, choices=['imagenet', 'coco', 'imagenet_code'], default='imagenet_code')
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--num-workers", type=int, default=16)
+    parser.add_argument("--sample-dir", type=str, default="samples")
+    parser.add_argument("--save-image", type=bool, default=False)
+    args = parser.parse_args()
+    main(args)

autoregressive/test/test_ssim.py

@@ -0,0 +1,21 @@
+
+import torch
+from torchmetrics.image import MultiScaleStructuralSimilarityIndexMeasure
+import torchvision.transforms as transforms
+from PIL import Image
+
+img1 = Image.open('autoregressive/test/label.png').convert('L')  # 
+img2 = Image.open('autoregressive/test/pred.png').convert('L')
+
+to_tensor = transforms.ToTensor()
+img1_tensor = to_tensor(img1).unsqueeze(0)  # (C, H, W) -> (1, C, H, W)
+img2_tensor = to_tensor(img2).unsqueeze(0)
+
+img1_tensor = img1_tensor.float()
+img2_tensor = img2_tensor.float()
+
+ms_ssim = MultiScaleStructuralSimilarityIndexMeasure(data_range=1.0)
+
+ms_ssim_score = ms_ssim(img1_tensor, img2_tensor)
+
+print("MS-SSIM:", ms_ssim_score.item())

autoregressive/test/test_t2i.py

@@ -0,0 +1,285 @@
+# Modified from:
+#   DiT:  https://github.com/facebookresearch/DiT/blob/main/sample.py
+import warnings
+warnings.filterwarnings('ignore')
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+torch.set_float32_matmul_precision('high')
+setattr(torch.nn.Linear, 'reset_parameters', lambda self: None)
+setattr(torch.nn.LayerNorm, 'reset_parameters', lambda self: None)
+from torchvision.utils import save_image
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+import time
+import argparse
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from autoregressive.models.gpt_t2i import GPT_models
+from autoregressive.models.generate import generate
+from condition.hed import HEDdetector, nms
+from condition.canny import CannyDetector
+from autoregressive.test.metric import SSIM, F1score, RMSE
+from condition.midas.depth import MidasDetector
+import torch.distributed as dist
+from dataset.augmentation import center_crop_arr
+from dataset.build import build_dataset
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torchvision import transforms
+from PIL import Image
+import os
+import numpy as np
+import cv2
+from tqdm import tqdm
+from functools import partial
+from dataset.t2i_control import build_t2i_control_code
+from language.t5 import T5Embedder
+from torchmetrics.image import MultiScaleStructuralSimilarityIndexMeasure
+from condition.lineart import LineArt
+import torch.nn.functional as F
+
+def main(args):
+    # # Setup PyTorch:
+    assert torch.cuda.is_available(), "Sampling with DDP requires at least one GPU. sample.py supports CPU-only usage"
+    torch.set_grad_enabled(False)
+    # Setup DDP:
+    dist.init_process_group("nccl")
+    rank = dist.get_rank()
+    device = rank % torch.cuda.device_count()
+    seed = args.global_seed * dist.get_world_size() + rank
+    torch.manual_seed(seed)
+    torch.cuda.set_device(device)
+    print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+    
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.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 = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.precision]
+    latent_size = args.image_size // args.downsample_size
+    gpt_model = GPT_models[args.gpt_model](
+        vocab_size=args.codebook_size,
+        block_size=latent_size ** 2,
+        num_classes=args.num_classes,
+        cls_token_num=args.cls_token_num,
+        model_type=args.gpt_type,
+        adapter_size=args.adapter_size,
+        condition_type=args.condition_type,
+    ).to(device=device, dtype=precision)
+        
+    _, file_extension = os.path.splitext(args.gpt_ckpt)
+    if file_extension.lower() == '.safetensors':
+        from safetensors.torch import load_file
+        model_weight = load_file(args.gpt_ckpt)
+        gpt_model.load_state_dict(model_weight, strict=False)
+        gpt_model.eval()
+    else:
+        checkpoint = torch.load(args.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")
+    
+
+    t5_model = T5Embedder(
+        device=device, 
+        local_cache=True, 
+        cache_dir=args.t5_path, 
+        dir_or_name=args.t5_model_type,
+        torch_dtype=precision,
+        model_max_length=args.t5_feature_max_len,
+    )
+
+    # Setup data:
+    transform = transforms.Compose([
+        transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, args.image_size)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+    ])
+    
+    dataset = build_t2i_control_code(args)
+    
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=False,
+        seed=args.global_seed
+    )
+    loader = DataLoader(
+        dataset,
+        batch_size=args.per_proc_batch_size,
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=False,
+        collate_fn=dataset.collate_fn,
+    )    
+
+
+    if args.compile:
+        print(f"compiling the model...")
+        gpt_model = torch.compile(
+            gpt_model,
+            mode="reduce-overhead",
+            fullgraph=True
+        ) # requires PyTorch 2.0 (optional)
+    else:
+        pass
+        # print(f"no need to compile model in demo") 
+    
+    # Create folder to save samples:
+    model_string_name = args.gpt_model.replace("/", "-")
+    if args.from_fsdp:
+        ckpt_string_name = args.gpt_ckpt.split('/')[-2]
+    else:
+        ckpt_string_name = os.path.basename(args.gpt_ckpt).replace(".pth", "").replace(".pt", "")
+    # import pdb;pdb.set_trace()
+    date = os.path.split(os.path.dirname(os.path.dirname(os.path.dirname(args.gpt_ckpt))))[-1]
+    folder_name = f"{model_string_name}-{date}-{ckpt_string_name}-size-{args.image_size}-{args.vq_model}-" \
+                  f"topk-{args.top_k}-topp-{args.top_p}-temperature-{args.temperature}-" \
+                  f"cfg-{args.cfg_scale}-seed-{args.global_seed}"
+    sample_folder_dir = f"{args.sample_dir}"
+    if rank == 0:
+        if args.save_image:
+            os.makedirs(sample_folder_dir, exist_ok=True)
+            os.makedirs(f"{args.sample_dir}/visualization", exist_ok=True)
+            os.makedirs(f"{args.sample_dir}/annotations", exist_ok=True)
+            print(f"Saving .png samples at {sample_folder_dir}")
+    n = args.per_proc_batch_size
+    global_batch_size = n * dist.get_world_size()
+    total = 0
+    
+    if args.condition_type == 'hed':
+        get_condition = HEDdetector().to(device).eval()
+    elif args.condition_type == 'canny':
+        get_condition = CannyDetector()
+    elif args.condition_type == 'lineart':
+        get_condition = LineArt()
+        get_condition.load_state_dict(torch.load('condition/ckpts/model.pth', map_location=torch.device('cpu')))
+        get_condition.to(device)
+
+    condition_null = None
+    num = 0
+    print(len(loader))
+    for batch in tqdm(loader):
+        num += 1
+        # if num>2:
+        #     break
+        prompts = batch['prompt']
+        condition_imgs = batch['control'].to(device)
+        
+        if args.condition_type in ['hed', 'lineart']:
+            with torch.no_grad():
+                condition_imgs = get_condition(condition_imgs.float())
+                if args.condition_type == 'hed':
+                    condition_imgs = condition_imgs.unsqueeze(1)/255
+                # if args.condition_type == 'lineart':
+                #     condition_imgs = 1 - condition_imgs
+                condition_imgs = condition_imgs.repeat(1,3,1,1)
+                condition_imgs = 2*(condition_imgs - 0.5)
+        # condition_origin = condition_imgs.clone()
+
+        if args.condition_type == 'seg':
+            labels = batch['label']
+
+        
+        caption_embs, emb_masks = t5_model.get_text_embeddings(prompts)
+
+        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())
+            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)
+        c_indices = new_caption_embs * new_emb_masks[:,:, None]
+        c_emb_masks = new_emb_masks
+
+        qzshape = [len(c_indices), args.codebook_embed_dim, args.image_H//args.downsample_size, args.image_W//args.downsample_size]
+
+        index_sample = generate(
+            gpt_model, c_indices, (args.image_H//args.downsample_size)*(args.image_W//args.downsample_size), c_emb_masks, condition=condition_imgs.to(precision),
+            cfg_scale=args.cfg_scale, cfg_interval=args.cfg_interval,
+            temperature=args.temperature, top_k=args.top_k,
+            top_p=args.top_p, sample_logits=True, 
+            )  
+
+        samples = vq_model.decode_code(index_sample, qzshape) # output value is between [-1, 1]
+
+        for i in range(len(samples)):
+            # # Save samples to disk as individual .png files
+            index = i * dist.get_world_size() + rank + total
+            if args.save_image:
+                save_image(samples[i], f"{args.sample_dir}/visualization/{index:06d}.png", nrow=1, normalize=True, value_range=(-1, 1))
+                save_image(condition_imgs[i,0], f"{args.sample_dir}/annotations/{index:06d}.png", nrow=1, normalize=True, value_range=(-1, 1))
+            if args.condition_type == 'seg':
+                Image.fromarray(labels[i].numpy().astype('uint8'), mode='L').save(f"{args.sample_dir}/annotations/{index:06d}.png")
+        total += global_batch_size
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-B")
+    parser.add_argument("--gpt-ckpt", type=str, default=None)
+    parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="t2i", help="class-conditional or text-conditional")
+    parser.add_argument("--from-fsdp", action='store_true')
+    parser.add_argument("--cls-token-num", type=int, default=120, help="max token number of condition input")
+    parser.add_argument("--precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    parser.add_argument("--compile", action='store_true', default=False)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512, 768], default=512)
+    parser.add_argument("--image-H", type=int, choices=[256, 320, 384, 400, 448, 512, 576, 640, 704, 768, 832, 960, 1024], default=512)
+    parser.add_argument("--image-W", type=int, choices=[256, 320, 384, 400, 448, 512, 576, 640, 704, 768, 832, 960, 1024], default=512)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--num-classes", type=int, default=1000)
+    parser.add_argument("--cfg-scale", type=float, default=4)
+    parser.add_argument("--cfg-interval", type=float, default=-1)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--top-k", type=int, default=2000,help="top-k value to sample with")
+    parser.add_argument("--temperature", type=float, default=1.0, help="temperature value to sample with")
+    parser.add_argument("--top-p", type=float, default=1.0, help="top-p value to sample with")
+    parser.add_argument("--condition", type=str, default='hed', choices=['canny', 'hed'])
+    parser.add_argument("--per-proc-batch-size", type=int, default=25)
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--dataset", type=str, choices=['imagenet', 'coco', 'imagenet_code'], default='imagenet_code')
+    parser.add_argument("--num-workers", type=int, default=16)
+    parser.add_argument("--sample-dir", type=str, default="samples")
+    parser.add_argument("--num-fid-samples", type=int, default=2000)
+    parser.add_argument("--save-image", type=bool, default=True)
+    parser.add_argument("--t5-path", type=str, default='checkpoints/t5-ckpt')
+    parser.add_argument("--t5-model-type", type=str, default='flan-t5-xl')
+    parser.add_argument("--t5-feature-max-len", type=int, default=120)
+    parser.add_argument("--t5-feature-dim", type=int, default=2048)
+    parser.add_argument("--code-path", type=str, default="code")
+    parser.add_argument("--code-path2", type=str, default=None)
+    parser.add_argument("--get-image", type=bool, default=False)
+    parser.add_argument("--get-prompt", type=bool, default=True)
+    parser.add_argument("--get-label", type=bool, default=False)
+    parser.add_argument("--condition-type", type=str, choices=['seg', 'canny', 'hed', 'lineart', 'depth'], default="canny")
+    parser.add_argument("--adapter-size", type=str, default="small")
+    args = parser.parse_args()
+    main(args)

autoregressive/train/extract_codes_c2i.py

@@ -0,0 +1,139 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT/blob/main/extract_features.py
+# import os
+# os.environ['CUDA_VISIBLE_DEVICES'] = '0,1'
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torchvision import transforms
+import numpy as np
+import argparse
+import os
+
+from utils.distributed import init_distributed_mode
+from dataset.augmentation import center_crop_arr
+from dataset.build import build_dataset
+from tokenizer.tokenizer_image.vq_model import VQ_models
+
+
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+def main(args):
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+    # Setup DDP:
+    if not args.debug:
+        init_distributed_mode(args)
+        rank = dist.get_rank()
+        device = rank % torch.cuda.device_count()
+        seed = args.global_seed * dist.get_world_size() + rank
+        torch.manual_seed(seed)
+        torch.cuda.set_device(device)
+        print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+    else:
+        device = 'cuda'
+        rank = 0
+    
+    # Setup a feature folder:
+    if args.debug or rank == 0:
+        os.makedirs(args.code_path, exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'{args.dataset}{args.image_size}_codes'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'{args.dataset}{args.image_size}_labels'), exist_ok=True)
+
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.vq_ckpt, map_location="cpu")
+    vq_model.load_state_dict(checkpoint["model"])
+    del checkpoint
+
+    # Setup data:
+    if args.ten_crop:
+        crop_size = int(args.image_size * args.crop_range)
+        transform = transforms.Compose([
+            transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+            transforms.TenCrop(args.image_size), # this is a tuple of PIL Images
+            transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])), # returns a 4D tensor
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+    else:
+        crop_size = args.image_size 
+        transform = transforms.Compose([
+            transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+    dataset = build_dataset(args, transform=transform)
+    if not args.debug:
+        sampler = DistributedSampler(
+            dataset,
+            num_replicas=dist.get_world_size(),
+            rank=rank,
+            shuffle=False,
+            seed=args.global_seed
+        )
+    else:
+        sampler = None
+    loader = DataLoader(
+        dataset,
+        batch_size=1, # important!
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=False
+    )
+    from tqdm import tqdm
+    total = 0
+    for x, y in tqdm(loader):
+        x = x.to(device)
+        if args.ten_crop:
+            x_all = x.flatten(0, 1)
+            num_aug = 10
+        else:
+            x_flip = torch.flip(x, dims=[-1])
+            x_all = torch.cat([x, x_flip])
+            num_aug = 2
+        y = y.to(device)
+        with torch.no_grad():
+            _, _, [_, _, indices] = vq_model.encode(x_all)
+        codes = indices.reshape(x.shape[0], num_aug, -1)
+
+        x = codes.detach().cpu().numpy()    # (1, num_aug, args.image_size//16 * args.image_size//16)
+        train_steps = rank + total
+        np.save(f'{args.code_path}/{args.dataset}{args.image_size}_codes/{train_steps}.npy', x)
+
+        y = y.detach().cpu().numpy()    # (1,)
+        np.save(f'{args.code_path}/{args.dataset}{args.image_size}_labels/{train_steps}.npy', y)
+        if not args.debug:
+            total += dist.get_world_size()
+        else:
+            total += 1
+        #print(total)
+
+    dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-path", type=str, required=True)
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, required=True, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--dataset", type=str, default='imagenet')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=256)
+    parser.add_argument("--ten-crop", action='store_true', help="whether using random crop")
+    parser.add_argument("--crop-range", type=float, default=1.1, help="expanding range of center crop")
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=24)
+    parser.add_argument("--debug", action='store_true')
+    args = parser.parse_args()
+    main(args)

autoregressive/train/extract_codes_t2i.py

@@ -0,0 +1,144 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT/blob/main/extract_features.py
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.utils.data import Dataset, DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torchvision import transforms
+import numpy as np
+from PIL import Image
+import glob
+import argparse
+import os
+import json
+
+from utils.distributed import init_distributed_mode
+from dataset.augmentation import center_crop_arr
+from tokenizer.tokenizer_image.vq_model import VQ_models
+
+
+#################################################################################
+#                             Training Helper Functions                         #
+#################################################################################
+class CustomDataset(Dataset):
+    def __init__(self, lst_dir, start, end, transform):
+        img_path_list = []
+        for lst_name in sorted(os.listdir(lst_dir))[start: end+1]:
+            if not lst_name.endswith('.jsonl'):
+                continue
+            file_path = os.path.join(lst_dir, lst_name)
+            with open(file_path, 'r') as file:
+                for line_idx, line in enumerate(file):
+                    data = json.loads(line)
+                    img_path = data['image_path']
+                    code_dir = file_path.split('/')[-1].split('.')[0]
+                    img_path_list.append((img_path, code_dir, line_idx))
+        self.img_path_list = img_path_list
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.img_path_list)
+
+    def __getitem__(self, index):
+        img_path, code_dir, code_name = self.img_path_list[index]
+        img = Image.open(img_path).convert("RGB")
+        if self.transform is not None:
+            img = self.transform(img)
+        return img, code_dir, code_name
+
+
+        
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+def main(args):
+    """
+    Trains a new DiT model.
+    """
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+
+    # Setup DDP:
+    # dist.init_process_group("nccl")
+    init_distributed_mode(args)
+    rank = dist.get_rank()
+    device = rank % torch.cuda.device_count()
+    seed = args.global_seed * dist.get_world_size() + rank
+    torch.manual_seed(seed)
+    torch.cuda.set_device(device)
+    print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+
+    # Setup a feature folder:
+    if rank == 0:
+        os.makedirs(args.code_path, exist_ok=True)
+
+
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.vq_ckpt, map_location="cpu")
+    vq_model.load_state_dict(checkpoint["model"])
+    del checkpoint
+
+
+    # Setup data:
+    transform = transforms.Compose([
+        transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, args.image_size)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+    ])
+    print(f"Dataset is preparing...")
+    dataset = CustomDataset(args.data_path, args.data_start, args.data_end, transform=transform)
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=False,
+        seed=args.global_seed
+    )
+    loader = DataLoader(
+        dataset,
+        batch_size=1, # important!
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=False
+    )
+    print(f"Dataset contains {len(dataset):,} images")
+
+    # total = 0
+    for img, code_dir, code_name in loader:
+        img = img.to(device)
+        with torch.no_grad():
+            _, _, [_, _, indices] = vq_model.encode(img)
+        codes = indices.reshape(img.shape[0], -1)
+        x = codes.detach().cpu().numpy()    # (1, args.image_size//16 * args.image_size//16)
+        os.makedirs(os.path.join(args.code_path, code_dir[0]), exist_ok=True)
+        np.save(os.path.join(args.code_path, code_dir[0], '{}.npy'.format(code_name.item())), x)
+
+        # total += dist.get_world_size()
+        print(code_name.item())
+
+    dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-path", type=str, required=True)
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--data-start", type=int, required=True)
+    parser.add_argument("--data-end", type=int, required=True)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=512)
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=24)
+    args = parser.parse_args()
+    main(args)

autoregressive/train/extract_file_ade.py

@@ -0,0 +1,511 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT/blob/main/extract_features.py
+import os
+os.environ['CUDA_VISIBLE_DEVICES'] = '0,1'
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torchvision import transforms
+import numpy as np
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from dataset.augmentation import center_crop_arr
+from dataset.build import build_dataset
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from condition.hed import HEDdetector, ControlNetHED_Apache2
+import cv2
+from torch.nn.parallel import DataParallel
+from einops import rearrange
+from datasets import load_dataset
+from torchvision import transforms
+from PIL import Image
+from language.t5 import T5Embedder
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+resolution = (512, 512)
+image_transforms = transforms.Compose(
+    [
+        transforms.Resize(resolution, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True),
+        transforms.ToTensor(),
+        transforms.Normalize([0.5], [0.5]),
+    ]
+)
+conditioning_image_transforms = transforms.Compose(
+        [
+            transforms.Resize(resolution, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True),
+            transforms.ToTensor(),
+        ]
+    )
+label_image_transforms = transforms.Compose(
+        [
+            transforms.Resize(resolution, interpolation=transforms.InterpolationMode.NEAREST, antialias=True),
+        ]
+    )
+
+def collate_fn(examples):
+    
+    pil_images = [example['image'].convert("RGB") for example in examples]
+    images = [image_transforms(image) for image in pil_images]
+    images = torch.stack(images)
+    
+    conditioning_images = [example['control_seg'].convert("RGB") for example in examples]
+    conditioning_images = [conditioning_image_transforms(image) for image in conditioning_images]
+    conditioning_images = torch.stack(conditioning_images)
+    
+    captions = [example['prompt'] for example in examples]
+    
+    dtype = torch.long
+    # labels = [torch.from_numpy(np.array(example['panoptic_seg_map'])).unsqueeze(0) for example in examples]  # seg_map  panoptic_seg_map
+    # labels = [label_image_transforms(label) for label in labels]
+    # labels = torch.stack(labels)
+    labels = [example['seg_map'] for example in examples]
+    
+
+    return {
+        "images": images,  # -1~1
+        "conditioning_images": conditioning_images,  # 0~1
+        "captions": captions,
+        "labels": labels
+    }
+
+def main(args):
+    
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+    # Setup DDP:
+    if not args.debug:
+        init_distributed_mode(args)
+        rank = dist.get_rank()
+        device = rank % torch.cuda.device_count()
+        seed = args.global_seed * dist.get_world_size() + rank
+        torch.manual_seed(seed)
+        torch.cuda.set_device(device)
+        print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+    else:
+        device = 'cuda'
+        rank = 0
+    
+    # Setup a feature folder:
+    if args.debug or rank == 0:
+        os.makedirs(args.code_path, exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'code'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'image'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'control'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'caption_emb'), exist_ok=True)
+        if args.split == 'validation':
+            os.makedirs(os.path.join(args.code_path, f'label'), exist_ok=True)
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.vq_ckpt, map_location="cpu")
+    vq_model.load_state_dict(checkpoint["model"])
+    del checkpoint
+    
+    t5_model = T5Embedder(
+        device=device, 
+        local_cache=True, 
+        cache_dir=args.t5_path, 
+        dir_or_name=args.t5_model_type,
+        model_max_length=args.t5_feature_max_len,
+    )
+
+    # Setup data:
+    if args.ten_crop:
+        crop_size = int(args.image_size * args.crop_range)
+        transform = transforms.Compose([
+            transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+            transforms.TenCrop(args.image_size), # this is a tuple of PIL Images
+            transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])), # returns a 4D tensor
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+    else:
+        crop_size = args.image_size 
+        transform = transforms.Compose([
+            transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+    # dataset = build_dataset(args, transform=transform)
+    # dataset = load_dataset(
+    #                 args.data_path,
+    #                 cache_dir=None,
+    #             )
+    dataset = load_dataset(args.data_path, split=args.split,   # "train" or "validation"
+    cache_dir=None,)
+    print(dataset)
+
+    if not args.debug:
+        sampler = DistributedSampler(
+            # dataset[args.split],
+            dataset,
+            num_replicas=dist.get_world_size(),
+            rank=rank,
+            shuffle=False,
+            seed=args.global_seed
+        )
+    else:
+        sampler = None
+    loader = DataLoader(
+        # dataset[args.split],
+        dataset,
+        batch_size=1, # important!
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        collate_fn=collate_fn,
+        pin_memory=True,
+        drop_last=False
+    )
+
+    from tqdm import tqdm
+    total = 0
+    code_len = 1024
+    t5_feature_max_len = 120
+    t5_feature_dim = 2048
+    max_seq_length = t5_feature_max_len + code_len
+    for batch in tqdm(loader):
+        
+        captions = batch['captions']
+        
+        train_steps = rank + total
+        img_save_path = f'{args.code_path}/image/{train_steps}.png'
+        cond_save_path = f'{args.code_path}/control/{train_steps}.png'
+        label_save_path = f'{args.code_path}/label/{train_steps}.png'
+        Image.fromarray((255*(batch['images'][0].numpy().transpose(1,2,0)*0.5+0.5)).astype('uint8'), mode='RGB').save(img_save_path)
+        Image.fromarray((255*batch['conditioning_images'][0].numpy().transpose(1,2,0)).astype('uint8'), mode='RGB').save(cond_save_path)
+        
+        label = Image.fromarray(np.array(batch['labels'][0]).astype('uint8'))
+        label.resize((512,512), Image.Resampling.NEAREST).save(label_save_path)
+        with torch.no_grad():
+            _, _, [_, _, indices] = vq_model.encode(batch['images'].to(device))
+            
+            caption_emb, emb_mask = t5_model.get_text_embeddings(captions)
+            valid_num = int(emb_mask.sum().item())
+            caption_emb = caption_emb[:, :valid_num]
+        
+        codes = indices.reshape(1, 1, -1)
+        x = codes.detach().cpu().numpy()    # (1, num_aug, args.image_size//16 * args.image_size//16)
+        np.save(f'{args.code_path}/code/{train_steps}.npy', x)
+
+        caption_emb = caption_emb.to(torch.float32).detach().cpu().numpy()
+        caption_dict = {}
+        caption_dict['prompt'] = captions
+        caption_dict['caption_emb'] = caption_emb
+        np.savez(f'{args.code_path}/caption_emb/{train_steps}.npz', **caption_dict)
+        
+        # 👇 新增：保存 prompt 为 .txt 文件，方便外部评估
+        with open(f'{args.code_path}/prompt/{train_steps}.txt', 'w', encoding='utf-8') as f:
+            f.write(captions[0])  # 假设 batch_size = 1
+        
+        if not args.debug:
+            total += dist.get_world_size()
+        else:
+            total += 1
+
+    dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--data-path", type=str, required=True)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, required=True, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--dataset", type=str, default='imagenet')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=256)
+    parser.add_argument("--ten-crop", action='store_true', help="whether using random crop")
+    parser.add_argument("--crop-range", type=float, default=1.1, help="expanding range of center crop")
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=24)
+    parser.add_argument("--debug", action='store_true')
+    parser.add_argument("--min-threshold", type=int, default=200)
+    parser.add_argument("--max-threshold", type=int, default=400)
+    parser.add_argument("--t5-path", type=str, default='checkpoints/t5-ckpt')
+    parser.add_argument("--t5-model-type", type=str, default='flan-t5-xl')
+    parser.add_argument("--t5-feature-max-len", type=int, default=120)
+    parser.add_argument("--split", type=str, default='train',help="train or validation")
+    args = parser.parse_args()
+    main(args)
+
+
+
+# # Modified from:
+# #   fast-DiT: https://github.com/chuanyangjin/fast-DiT/blob/main/extract_features.py
+# import os
+# # os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2,3'
+# import torch
+# torch.backends.cuda.matmul.allow_tf32 = True
+# torch.backends.cudnn.allow_tf32 = True
+# import torch.distributed as dist
+# from torch.utils.data import DataLoader
+# from torch.utils.data.distributed import DistributedSampler
+# from torchvision import transforms
+# import numpy as np
+# import argparse
+# import os
+# import sys
+# current_directory = os.getcwd()
+# sys.path.append(current_directory)
+# from utils.distributed import init_distributed_mode
+# from dataset.augmentation import center_crop_arr
+# from dataset.build import build_dataset
+# from tokenizer.tokenizer_image.vq_model import VQ_models
+# # from condition.hed import HEDdetector, ControlNetHED_Apache2
+# import cv2
+# from torch.nn.parallel import DataParallel
+# from einops import rearrange
+# from datasets import load_dataset
+# from torchvision import transforms
+# from PIL import Image
+# from language.t5 import T5Embedder
+# #################################################################################
+# #                                  Training Loop                                #
+# #################################################################################
+# resolution = (512, 512)
+# image_transforms = transforms.Compose(
+#     [
+#         transforms.Resize(resolution, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True),
+#         transforms.ToTensor(),
+#         transforms.Normalize([0.5], [0.5]),
+#     ]
+# )
+# conditioning_image_transforms = transforms.Compose(
+#         [
+#             transforms.Resize(resolution, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True),
+#             transforms.ToTensor(),
+#         ]
+#     )
+# label_image_transforms = transforms.Compose(
+#         [
+#             transforms.Resize(resolution, interpolation=transforms.InterpolationMode.NEAREST, antialias=True),
+#         ]
+#     )
+# def collate_fn(examples):
+#     print("Examples:", examples)  # 打印原始数据结构
+#     print("Available keys:", examples[0].keys())  # 打印数据集中包含的键
+#     exit()  # 直接终止，查看输出
+
+# def collate_fn(examples):
+    
+#     pil_images = [example['image'].convert("RGB") for example in examples]
+#     images = [image_transforms(image) for image in pil_images]
+#     images = torch.stack(images)
+    
+#     conditioning_images = [example['control_seg'].convert("RGB") for example in examples]
+#     conditioning_images = [example["control_seg"][0].convert("RGB") for example in examples]
+#     conditioning_images = [conditioning_image_transforms(image) for image in conditioning_images]
+#     conditioning_images = torch.stack(conditioning_images)
+    
+#     # captions = [example['prompt'] for example in examples]
+    
+#     # dtype = torch.long
+#     # # labels = [torch.from_numpy(np.array(example['panoptic_seg_map'])).unsqueeze(0) for example in examples]  # seg_map  panoptic_seg_map
+#     # # labels = [label_image_transforms(label) for label in labels]
+#     # # labels = torch.stack(labels)
+#     # labels = [example['seg_map'] for example in examples]
+#         # **修改 captions 逻辑**
+#     captions = [" ".join(example["scene"]) if "scene" in example else "unknown" for example in examples]
+
+#     labels = [example["control_seg"][0] for example in examples]
+
+#     return {
+#         "images": images,  # -1~1
+#         "conditioning_images": conditioning_images,  # 0~1
+#         "captions": captions,
+#         "labels": labels
+#     }
+
+# def main(args):
+    
+#     assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+#     # Setup DDP:
+#     # if not args.debug:
+#     #     init_distributed_mode(args)
+#     #     rank = dist.get_rank()
+#     #     device = rank % torch.cuda.device_count()
+#     #     seed = args.global_seed * dist.get_world_size() + rank
+#     #     torch.manual_seed(seed)
+#     #     torch.cuda.set_device(device)
+#     #     print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+#     # else:
+#     #     device = 'cuda'
+#     #     rank = 0
+#     device = torch.device("cuda")
+#     # Setup a feature folder:
+#     # if args.debug or rank == 0:
+#     #     os.makedirs(args.code_path, exist_ok=True)
+#     #     os.makedirs(os.path.join(args.code_path, f'code'), exist_ok=True)
+#     #     os.makedirs(os.path.join(args.code_path, f'image'), exist_ok=True)
+#     #     os.makedirs(os.path.join(args.code_path, f'control'), exist_ok=True)
+#     #     os.makedirs(os.path.join(args.code_path, f'caption_emb'), exist_ok=True)
+#     #     if args.split == 'validation':
+#     #         os.makedirs(os.path.join(args.code_path, f'label'), exist_ok=True)
+#     os.makedirs(args.code_path, exist_ok=True)
+#     os.makedirs(os.path.join(args.code_path, f'code'), exist_ok=True)
+#     os.makedirs(os.path.join(args.code_path, f'image'), exist_ok=True)
+#     os.makedirs(os.path.join(args.code_path, f'control'), exist_ok=True)
+#     os.makedirs(os.path.join(args.code_path, f'caption_emb'), exist_ok=True)
+#     if args.split == 'validation':
+#         os.makedirs(os.path.join(args.code_path, f'label'), exist_ok=True)
+
+#     # create and load model加载 VQ 模型
+#     vq_model = VQ_models[args.vq_model](
+#         codebook_size=args.codebook_size,
+#         codebook_embed_dim=args.codebook_embed_dim)
+#     vq_model.to(device)
+#     vq_model.eval()
+#     # 加载模型权重
+#     checkpoint = torch.load(args.vq_ckpt, map_location="cpu")
+#     vq_model.load_state_dict(checkpoint["model"])
+#     del checkpoint
+#     # 加载 T5 文本嵌入模型
+#     t5_model = T5Embedder(
+#         device=device, 
+#         local_cache=True, 
+#         cache_dir=args.t5_path, 
+#         dir_or_name=args.t5_model_type,
+#         model_max_length=args.t5_feature_max_len,
+#     )
+# # 以下注释
+#     # Setup data:
+#     if args.ten_crop:
+#         crop_size = int(args.image_size * args.crop_range)
+#         transform = transforms.Compose([
+#             transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+#             transforms.TenCrop(args.image_size), # this is a tuple of PIL Images
+#             transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])), # returns a 4D tensor
+#             transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+#         ])
+#     else:
+#         crop_size = args.image_size 
+#         transform = transforms.Compose([
+#             transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+#             transforms.ToTensor(),
+#             transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+#         ])
+#     # dataset = build_dataset(args, transform=transform)
+#     dataset = load_dataset(
+#                     args.data_path,
+#                     cache_dir=None,
+#                 ) # 读取数据集 
+#     if not args.debug:
+#         sampler = DistributedSampler(
+#             dataset[args.split],
+#             num_replicas=dist.get_world_size(),
+#             rank=rank,
+#             shuffle=False,
+#             seed=args.global_seed
+#         )
+#     else:
+#         sampler = None
+#     loader = DataLoader(
+#         dataset[args.split],
+#         batch_size=1, # important!
+#         shuffle=False,
+#         sampler=sampler,
+#         num_workers=args.num_workers,
+#         collate_fn=collate_fn,
+#         pin_memory=True,
+#         drop_last=False
+#     )
+# # 以上注释并添加下边的数据预处理
+#     #    # 设置数据预处理
+#     # crop_size = int(args.image_size * args.crop_range) if args.ten_crop else args.image_size
+#     # transform = transforms.Compose([
+#     #     transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+#     #     transforms.ToTensor(),
+#     #     transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+#     # ])
+
+#     # # 加载数据集
+#     # dataset = load_dataset(args.data_path, cache_dir=None)
+    
+#     # # **修改 DataLoader**
+#     # loader = DataLoader(
+#     #     dataset[args.split],
+#     #     batch_size=1,  # 重要！
+#     #     shuffle=True,  # **单 GPU 训练时使用 shuffle**
+#     #     num_workers=args.num_workers,
+#     #     collate_fn=collate_fn,
+#     #     pin_memory=True,
+#     #     drop_last=False
+#     # )
+
+#     from tqdm import tqdm
+#     total = 0
+#     code_len = 1024
+#     t5_feature_max_len = 120
+#     t5_feature_dim = 2048
+#     max_seq_length = t5_feature_max_len + code_len
+#     for batch in tqdm(loader):
+        
+#         captions = batch['captions']
+        
+#         # train_steps = rank + total
+#         img_save_path = f'{args.code_path}/image/{total}.png'
+#         cond_save_path = f'{args.code_path}/control/{total}.png'
+#         label_save_path = f'{args.code_path}/label/{total}.png'
+#         Image.fromarray((255*(batch['images'][0].numpy().transpose(1,2,0)*0.5+0.5)).astype('uint8'), mode='RGB').save(img_save_path)
+#         Image.fromarray((255*batch['conditioning_images'][0].numpy().transpose(1,2,0)).astype('uint8'), mode='RGB').save(cond_save_path)
+        
+#         label = Image.fromarray(np.array(batch['labels'][0]).astype('uint8'))
+#         label.resize((512,512), Image.Resampling.NEAREST).save(label_save_path)
+#         with torch.no_grad():
+#             _, _, [_, _, indices] = vq_model.encode(batch['images'].to(device))
+            
+#             caption_emb, emb_mask = t5_model.get_text_embeddings(captions)
+#             valid_num = int(emb_mask.sum().item())
+#             caption_emb = caption_emb[:, :valid_num]
+        
+#         codes = indices.reshape(1, 1, -1)
+#         x = codes.detach().cpu().numpy()    # (1, num_aug, args.image_size//16 * args.image_size//16)
+#         np.save(f'{args.code_path}/code/{total}.npy', x) # 保存将图像编码成的离散Token
+
+#         caption_emb = caption_emb.to(torch.float32).detach().cpu().numpy()
+#         caption_dict = {}
+#         caption_dict['prompt'] = captions
+#         caption_dict['caption_emb'] = caption_emb
+#         np.savez(f'{args.code_path}/caption_emb/{total}.npz', **caption_dict) # 保存文本的 T5 Embeddings
+#         # if not args.debug:
+#         #     total += dist.get_world_size()
+#         # else:
+#         #     total += 1
+#         total += 1
+#     dist.destroy_process_group()
+
+
+# if __name__ == "__main__":
+#     parser = argparse.ArgumentParser()
+#     parser.add_argument("--code-path", type=str, required=True)
+#     parser.add_argument("--data-path", type=str, required=True)
+#     parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+#     parser.add_argument("--vq-ckpt", type=str, required=True, help="ckpt path for vq model")
+#     parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+#     parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+#     parser.add_argument("--dataset", type=str, default='imagenet')
+#     parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=256)
+#     parser.add_argument("--ten-crop", action='store_true', help="whether using random crop")
+#     parser.add_argument("--crop-range", type=float, default=1.1, help="expanding range of center crop")
+#     parser.add_argument("--global-seed", type=int, default=0)
+#     parser.add_argument("--num-workers", type=int, default=24)
+#     parser.add_argument("--debug", action='store_true')
+#     parser.add_argument("--min-threshold", type=int, default=200)
+#     parser.add_argument("--max-threshold", type=int, default=400)
+#     parser.add_argument("--t5-path", type=str, default='checkpoints/t5-ckpt')
+#     parser.add_argument("--t5-model-type", type=str, default='flan-t5-xl')
+#     parser.add_argument("--t5-feature-max-len", type=int, default=120)
+#     parser.add_argument("--split", type=str, default='train')
+#     args = parser.parse_args()
+#     main(args)

autoregressive/train/extract_file_cocostuff.py

@@ -0,0 +1,228 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT/blob/main/extract_features.py
+import os
+# os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2,3'
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torchvision import transforms
+import numpy as np
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from dataset.augmentation import center_crop_arr
+from dataset.build import build_dataset
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from condition.hed import HEDdetector, ControlNetHED_Apache2
+import cv2
+from torch.nn.parallel import DataParallel
+from einops import rearrange
+from datasets import load_dataset
+from torchvision import transforms
+from PIL import Image
+from language.t5 import T5Embedder
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+resolution = (512, 512)
+image_transforms = transforms.Compose(
+    [
+        transforms.Resize(resolution, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True),
+        transforms.ToTensor(),
+        transforms.Normalize([0.5], [0.5]),
+    ]
+)
+conditioning_image_transforms = transforms.Compose(
+        [
+            transforms.Resize(resolution, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True),
+            transforms.ToTensor(),
+        ]
+    )
+label_image_transforms = transforms.Compose(
+        [
+            transforms.Resize(resolution, interpolation=transforms.InterpolationMode.NEAREST, antialias=True),
+        ]
+    )
+
+def collate_fn(examples):
+    
+    pil_images = [example['image'].convert("RGB") for example in examples]
+    images = [image_transforms(image) for image in pil_images]
+    images = torch.stack(images)
+    
+    conditioning_images = [example['control_seg'].convert("RGB") for example in examples]
+    conditioning_images = [conditioning_image_transforms(image) for image in conditioning_images]
+    conditioning_images = torch.stack(conditioning_images)
+    
+    captions = [example['prompt'] for example in examples]
+    
+    dtype = torch.long
+    # labels = [torch.from_numpy(np.array(example['panoptic_seg_map'])).unsqueeze(0) for example in examples]  # seg_map  panoptic_seg_map
+    # labels = [label_image_transforms(label) for label in labels]
+    # labels = torch.stack(labels)
+    labels = [example['panoptic_seg_map'] for example in examples]
+    
+
+    return {
+        "images": images,  # -1~1
+        "conditioning_images": conditioning_images,  # 0~1
+        "captions": captions,
+        "labels": labels
+    }
+
+def main(args):
+    
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+    # Setup DDP:
+    if not args.debug:
+        init_distributed_mode(args)
+        rank = dist.get_rank()
+        device = rank % torch.cuda.device_count()
+        seed = args.global_seed * dist.get_world_size() + rank
+        torch.manual_seed(seed)
+        torch.cuda.set_device(device)
+        print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+    else:
+        device = 'cuda'
+        rank = 0
+    
+    # Setup a feature folder:
+    if args.debug or rank == 0:
+        os.makedirs(args.code_path, exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'code'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'image'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'control'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'caption_emb'), exist_ok=True)
+        if args.split == 'validation':
+            os.makedirs(os.path.join(args.code_path, f'label'), exist_ok=True)
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.vq_ckpt, map_location="cpu")
+    vq_model.load_state_dict(checkpoint["model"])
+    del checkpoint
+    
+    t5_model = T5Embedder(
+        device=device, 
+        local_cache=True, 
+        cache_dir=args.t5_path, 
+        dir_or_name=args.t5_model_type,
+        model_max_length=args.t5_feature_max_len,
+    )
+
+    # Setup data:
+    if args.ten_crop:
+        crop_size = int(args.image_size * args.crop_range)
+        transform = transforms.Compose([
+            transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+            transforms.TenCrop(args.image_size), # this is a tuple of PIL Images
+            transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])), # returns a 4D tensor
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+    else:
+        crop_size = args.image_size 
+        transform = transforms.Compose([
+            transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+    dataset = load_dataset(
+                    args.data_path,
+                    cache_dir=None,
+                )
+    if not args.debug:
+        sampler = DistributedSampler(
+            dataset[args.split],
+            num_replicas=dist.get_world_size(),
+            rank=rank,
+            shuffle=False,
+            seed=args.global_seed
+        )
+    else:
+        sampler = None
+    loader = DataLoader(
+        dataset[args.split],
+        batch_size=1, # important!
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        collate_fn=collate_fn,
+        pin_memory=True,
+        drop_last=False
+    )
+
+    from tqdm import tqdm
+    total = 0
+    code_len = 1024
+    t5_feature_max_len = 120
+    t5_feature_dim = 2048
+    max_seq_length = t5_feature_max_len + code_len
+    for batch in tqdm(loader):
+        
+        captions = batch['captions']
+        
+        train_steps = rank + total
+        img_save_path = f'{args.code_path}/image/{train_steps}.png'
+        cond_save_path = f'{args.code_path}/control/{train_steps}.png'
+        label_save_path = f'{args.code_path}/label/{train_steps}.png'
+        Image.fromarray((255*(batch['images'][0].numpy().transpose(1,2,0)*0.5+0.5)).astype('uint8'), mode='RGB').save(img_save_path)
+        Image.fromarray((255*batch['conditioning_images'][0].numpy().transpose(1,2,0)).astype('uint8'), mode='RGB').save(cond_save_path)
+        
+        label = Image.fromarray(np.array(batch['labels'][0]).astype('uint8'))
+        label.resize((512,512), Image.Resampling.NEAREST).save(label_save_path)
+        with torch.no_grad():
+            _, _, [_, _, indices] = vq_model.encode(batch['images'].to(device))
+            
+            caption_emb, emb_mask = t5_model.get_text_embeddings(captions)
+            valid_num = int(emb_mask.sum().item())
+            caption_emb = caption_emb[:, :valid_num]
+        
+        codes = indices.reshape(1, 1, -1)
+        x = codes.detach().cpu().numpy()    # (1, num_aug, args.image_size//16 * args.image_size//16)
+        np.save(f'{args.code_path}/code/{train_steps}.npy', x)
+
+        caption_emb = caption_emb.to(torch.float32).detach().cpu().numpy()
+        caption_dict = {}
+        caption_dict['prompt'] = captions
+        caption_dict['caption_emb'] = caption_emb
+        np.savez(f'{args.code_path}/caption_emb/{train_steps}.npz', **caption_dict)
+        if not args.debug:
+            total += dist.get_world_size()
+        else:
+            total += 1
+
+    dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--data-path", type=str, required=True)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, required=True, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--dataset", type=str, default='imagenet')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=256)
+    parser.add_argument("--ten-crop", action='store_true', help="whether using random crop")
+    parser.add_argument("--crop-range", type=float, default=1.1, help="expanding range of center crop")
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=24)
+    parser.add_argument("--debug", action='store_true')
+    parser.add_argument("--min-threshold", type=int, default=200)
+    parser.add_argument("--max-threshold", type=int, default=400)
+    parser.add_argument("--t5-path", type=str, default='checkpoints/t5-ckpt')
+    parser.add_argument("--t5-model-type", type=str, default='flan-t5-xl')
+    parser.add_argument("--t5-feature-max-len", type=int, default=120)
+    parser.add_argument("--split", type=str, default='train')
+    args = parser.parse_args()
+    main(args)

autoregressive/train/extract_file_imagenet.py

@@ -0,0 +1,168 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT/blob/main/extract_features.py
+import os
+# os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2,3'
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torchvision import transforms
+import numpy as np
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from dataset.augmentation import center_crop_arr
+from dataset.build import build_dataset
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from condition.canny import CannyDetector
+import cv2
+from condition.midas.depth import MidasDetector
+
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+def main(args):
+    
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+    # Setup DDP:
+    if not args.debug:
+        init_distributed_mode(args)
+        rank = dist.get_rank()
+        device = rank % torch.cuda.device_count()
+        seed = args.global_seed * dist.get_world_size() + rank
+        torch.manual_seed(seed)
+        torch.cuda.set_device(device)
+        print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+    else:
+        device = 'cuda'
+        rank = 0
+    
+    # Setup a feature folder:
+    if args.debug or rank == 0:
+        os.makedirs(args.code_path, exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'{args.dataset}{args.image_size}_codes'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'{args.dataset}{args.image_size}_labels'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'{args.dataset}{args.image_size}_canny_imagesnpy'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'{args.dataset}{args.image_size}_canny_images'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'{args.dataset}{args.image_size}_depth_imagesnpy'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'{args.dataset}{args.image_size}_depth_images'), exist_ok=True)
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.vq_ckpt, map_location="cpu")
+    vq_model.load_state_dict(checkpoint["model"])
+    del checkpoint
+
+    # Setup data:
+    if args.ten_crop:
+        crop_size = int(args.image_size * args.crop_range)
+        transform = transforms.Compose([
+            transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+            transforms.TenCrop(args.image_size), # this is a tuple of PIL Images
+            transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])), # returns a 4D tensor
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+    else:
+        crop_size = args.image_size 
+        transform = transforms.Compose([
+            transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+    dataset = build_dataset(args, transform=transform)
+    if not args.debug:
+        sampler = DistributedSampler(
+            dataset,
+            num_replicas=dist.get_world_size(),
+            rank=rank,
+            shuffle=False,
+            seed=args.global_seed
+        )
+    else:
+        sampler = None
+    loader = DataLoader(
+        dataset,
+        batch_size=1, # important!
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=False
+    )
+    apply_canny = CannyDetector()
+    depth_model = MidasDetector(device=device)
+    
+    from tqdm import tqdm
+    total = 0
+    for x, y in tqdm(loader):
+        x = x.to(device)
+        batch_size_per_gpu = x.shape[0] 
+        if args.ten_crop:
+            x_all = x.flatten(0, 1)
+            num_aug = 10
+        else:
+            x_flip = torch.flip(x, dims=[-1])
+            x_all = torch.cat([x, x_flip])
+            num_aug = 2
+        y = y.to(device)
+
+        canny = []
+        depths = []
+        for i in range(x_all.shape[0]):
+            canny.append(apply_canny((255*(x_all[i]*0.5 + 0.5)).cpu().numpy().transpose(1,2,0).astype(np.uint8),low_threshold=args.min_threshold, high_threshold=args.max_threshold)[None,None,...])
+            img = (255*(x_all[i]*0.5 + 0.5)).permute(1,2,0)
+            depth = depth_model(img)
+            depths.append(depth[None,None,...])
+        depths = np.concatenate(depths, axis=0)
+        cannys = np.concatenate(canny, axis=0)
+        train_steps = rank + total
+        np.save(f'{args.code_path}/{args.dataset}{args.image_size}_canny_imagesnpy/{train_steps}.npy', cannys)
+        np.save(f'{args.code_path}/{args.dataset}{args.image_size}_depth_imagesnpy/{train_steps}.npy', depths)
+        with torch.no_grad():
+            _, _, [_, _, indices] = vq_model.encode(x_all)
+        
+        codes = indices.reshape(x.shape[0], num_aug, -1)
+        x = codes.detach().cpu().numpy()    # (1, num_aug, args.image_size//16 * args.image_size//16)
+        y = y.detach().cpu().numpy()    # (1,)
+    
+        train_steps = rank + total
+        
+        cv2.imwrite(f'{args.code_path}/{args.dataset}{args.image_size}_canny_images/{train_steps}.png', cannys[0,0])
+        cv2.imwrite(f'{args.code_path}/{args.dataset}{args.image_size}_depth_images/{train_steps}.png', depths[0,0])   
+        np.save(f'{args.code_path}/{args.dataset}{args.image_size}_codes/{train_steps}.npy', x)
+        np.save(f'{args.code_path}/{args.dataset}{args.image_size}_labels/{train_steps}.npy', y)
+        if not args.debug:
+            total += dist.get_world_size()
+        else:
+            total += 1
+
+    dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-path", type=str, required=True)
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, required=True, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--dataset", type=str, default='imagenet')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=256)
+    parser.add_argument("--ten-crop", action='store_true', help="whether using random crop")
+    parser.add_argument("--crop-range", type=float, default=1.1, help="expanding range of center crop")
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=24)
+    parser.add_argument("--debug", action='store_true')
+    parser.add_argument("--min-threshold", type=int, default=100)
+    parser.add_argument("--max-threshold", type=int, default=200)
+    args = parser.parse_args()
+    main(args)

autoregressive/train/extract_file_multigen.py

@@ -0,0 +1,228 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT/blob/main/extract_features.py
+
+import warnings
+warnings.filterwarnings("ignore")
+import os
+# os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2,3'
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torchvision import transforms
+import numpy as np
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from dataset.augmentation import center_crop_arr
+from dataset.build import build_dataset
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from condition.hed import HEDdetector, ControlNetHED_Apache2
+import cv2
+from torch.nn.parallel import DataParallel
+from einops import rearrange
+from datasets import load_dataset
+from torchvision import transforms
+from PIL import Image
+from language.t5 import T5Embedder
+from condition.canny import CannyDetector
+from condition.hed import HEDdetector
+from condition.lineart import LineArt
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+resolution = (512, 512)
+image_transforms = transforms.Compose(
+    [
+        transforms.Resize(resolution, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True),
+        transforms.ToTensor(),
+        transforms.Normalize([0.5], [0.5]),
+    ]
+)
+conditioning_image_transforms = transforms.Compose(
+        [
+            transforms.Resize(resolution, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True),
+            transforms.ToTensor(),
+        ]
+    )
+label_image_transforms = transforms.Compose(
+        [
+            transforms.Resize(resolution, interpolation=transforms.InterpolationMode.NEAREST, antialias=True),
+        ]
+    )
+
+def collate_fn(examples):
+
+    pil_images = [example['image'].convert("RGB") for example in examples]
+    images = [image_transforms(image) for image in pil_images]
+    images = torch.stack(images)
+    
+    conditioning_images = [example['control_depth'].convert("RGB") for example in examples]
+    conditioning_images = [conditioning_image_transforms(image) for image in conditioning_images]
+    conditioning_images = torch.stack(conditioning_images)
+    captions = [example['text'] for example in examples]
+
+    
+
+    return {
+        "images": images,  # -1~1
+        "conditioning_images": conditioning_images,  # 0~1
+        "captions": captions,
+        # "labels": labels
+    }
+
+def main(args):
+    
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+    # Setup DDP:
+    if not args.debug:
+        init_distributed_mode(args)
+        rank = dist.get_rank()
+        device = rank % torch.cuda.device_count()
+        seed = args.global_seed * dist.get_world_size() + rank
+        torch.manual_seed(seed)
+        torch.cuda.set_device(device)
+        print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+    else:
+        device = 'cuda'
+        rank = 0
+    
+    # Setup a feature folder:
+    if args.debug or rank == 0:
+        os.makedirs(args.code_path, exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'code'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'image'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'control_depth'), exist_ok=True)
+        os.makedirs(os.path.join(args.code_path, f'caption_emb'), exist_ok=True)
+
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.vq_ckpt, map_location="cpu")
+    vq_model.load_state_dict(checkpoint["model"])
+    del checkpoint
+    
+    t5_model = T5Embedder(
+        device=device, 
+        local_cache=True, 
+        cache_dir=args.t5_path, 
+        dir_or_name=args.t5_model_type,
+        model_max_length=args.t5_feature_max_len,
+    )
+
+    # Setup data:
+    if args.ten_crop:
+        crop_size = int(args.image_size * args.crop_range)
+        transform = transforms.Compose([
+            transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+            transforms.TenCrop(args.image_size), # this is a tuple of PIL Images
+            transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])), # returns a 4D tensor
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+    else:
+        crop_size = args.image_size 
+        transform = transforms.Compose([
+            transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, crop_size)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+    dataset = load_dataset(
+                    args.data_path,
+                    cache_dir=None,
+                )
+    try:
+        if not args.debug:
+            sampler = DistributedSampler(
+                dataset[args.split],
+                num_replicas=dist.get_world_size(),
+                rank=rank,
+                shuffle=False,
+                seed=args.global_seed
+            )
+        else:
+            sampler = None
+        loader = DataLoader(
+            dataset[args.split],
+            batch_size=1, # important!
+            shuffle=False,
+            sampler=sampler,
+            num_workers=args.num_workers,
+            collate_fn=collate_fn,
+            pin_memory=True,
+            drop_last=False
+        )
+    except Exception as e:
+        pass
+    
+    from tqdm import tqdm
+    total = 0
+    code_len = 1024
+    t5_feature_max_len = 120
+    t5_feature_dim = 2048
+    max_seq_length = t5_feature_max_len + code_len
+    for batch in tqdm(loader):
+        
+        captions = batch['captions']
+        
+        train_steps = rank + total
+        img_save_path = f'{args.code_path}/image/{train_steps}.png'
+        depth_save_path = f'{args.code_path}/control_depth/{train_steps}.png'
+
+        Image.fromarray((255*(batch['images'][0].numpy().transpose(1,2,0)*0.5+0.5)).astype('uint8'), mode='RGB').save(img_save_path)
+        Image.fromarray((255*batch['conditioning_images'][0].numpy().transpose(1,2,0)).astype('uint8'), mode='RGB').save(depth_save_path)
+        
+        with torch.no_grad():
+            _, _, [_, _, indices] = vq_model.encode(batch['images'].to(device))
+            
+            caption_emb, emb_mask = t5_model.get_text_embeddings(captions)
+            valid_num = int(emb_mask.sum().item())
+            caption_emb = caption_emb[:, :valid_num]
+        
+        codes = indices.reshape(1, 1, -1)
+        x = codes.detach().cpu().numpy()    # (1, num_aug, args.image_size//16 * args.image_size//16)
+        np.save(f'{args.code_path}/code/{train_steps}.npy', x)
+
+        caption_emb = caption_emb.to(torch.float32).detach().cpu().numpy()
+        caption_dict = {}
+        caption_dict['prompt'] = captions
+        caption_dict['caption_emb'] = caption_emb
+        np.savez(f'{args.code_path}/caption_emb/{train_steps}.npz', **caption_dict)
+        if not args.debug:
+            total += dist.get_world_size()
+        else:
+            total += 1
+
+    dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-path", type=str, required=True)
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, required=True, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--dataset", type=str, default='imagenet')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=256)
+    parser.add_argument("--ten-crop", action='store_true', help="whether using random crop")
+    parser.add_argument("--crop-range", type=float, default=1.1, help="expanding range of center crop")
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=24)
+    parser.add_argument("--debug", action='store_true')
+    parser.add_argument("--min-threshold", type=int, default=200)
+    parser.add_argument("--max-threshold", type=int, default=400)
+    parser.add_argument("--t5-path", type=str, default='checkpoints/t5-ckpt')
+    parser.add_argument("--t5-model-type", type=str, default='flan-t5-xl')
+    parser.add_argument("--t5-feature-max-len", type=int, default=120)
+    parser.add_argument("--split", type=str, default='train')
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_c2i.py

@@ -0,0 +1,294 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT/blob/main/train.py
+#   nanoGPT: https://github.com/karpathy/nanoGPT/blob/master/model.py
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from glob import glob
+from copy import deepcopy
+import os
+import time
+import inspect
+import argparse
+
+from utils.logger import create_logger
+from utils.distributed import init_distributed_mode
+from utils.ema import update_ema, requires_grad
+from dataset.build import build_dataset
+from autoregressive.models.gpt import GPT_models
+
+
+#################################################################################
+#                             Training Helper Functions                         #
+#################################################################################
+def creat_optimizer(model, weight_decay, learning_rate, betas, logger):
+    # start with all of the candidate parameters
+    param_dict = {pn: p for pn, p in model.named_parameters()}
+    # filter out those that do not require grad
+    param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+    # create optim groups. Any parameters that is 2D will be weight decayed, otherwise no.
+    # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.
+    decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]
+    nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]
+    optim_groups = [
+        {'params': decay_params, 'weight_decay': weight_decay},
+        {'params': nodecay_params, 'weight_decay': 0.0}
+    ]
+    num_decay_params = sum(p.numel() for p in decay_params)
+    num_nodecay_params = sum(p.numel() for p in nodecay_params)
+    logger.info(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+    logger.info(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+    # Create AdamW optimizer and use the fused version if it is available
+    fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+    extra_args = dict(fused=True) if fused_available else dict()
+    optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, **extra_args)
+    logger.info(f"using fused AdamW: {fused_available}")
+    return optimizer
+
+
+
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+def main(args):
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+    
+    # Setup DDP:
+    init_distributed_mode(args)
+    assert args.global_batch_size % dist.get_world_size() == 0, f"Batch size must be divisible by world size."
+    rank = dist.get_rank()
+    device = rank % torch.cuda.device_count()
+    seed = args.global_seed * dist.get_world_size() + rank
+    torch.manual_seed(seed)
+    torch.cuda.set_device(device)
+
+    # Setup an experiment folder:
+    if rank == 0:
+        os.makedirs(args.results_dir, exist_ok=True)  # Make results folder (holds all experiment subfolders)
+        experiment_index = len(glob(f"{args.results_dir}/*"))
+        model_string_name = args.gpt_model.replace("/", "-")  # e.g., GPT-XL/2 --> GPT-XL-2 (for naming folders)
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"  # Create an experiment folder
+        checkpoint_dir = f"{experiment_dir}/checkpoints"  # Stores saved model checkpoints
+        os.makedirs(checkpoint_dir, exist_ok=True)
+        logger = create_logger(experiment_dir)
+        logger.info(f"Experiment directory created at {experiment_dir}")
+
+        time_record = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime())
+        cloud_results_dir = f"{args.cloud_save_path}/{time_record}"
+        cloud_checkpoint_dir = f"{cloud_results_dir}/{experiment_index:03d}-{model_string_name}/checkpoints"
+        os.makedirs(cloud_checkpoint_dir, exist_ok=True)
+        logger.info(f"Experiment directory created in cloud at {cloud_checkpoint_dir}")
+    
+    else:
+        logger = create_logger(None)
+
+    # training args
+    logger.info(f"{args}")
+
+    # training env
+    logger.info(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+
+
+    # Setup model
+    if args.drop_path_rate > 0.0:
+        dropout_p = 0.0
+    else:
+        dropout_p = args.dropout_p
+    latent_size = args.image_size // args.downsample_size
+    model = GPT_models[args.gpt_model](
+        vocab_size=args.vocab_size,
+        block_size=latent_size ** 2,
+        num_classes=args.num_classes,
+        cls_token_num=args.cls_token_num,
+        model_type=args.gpt_type,
+        resid_dropout_p=dropout_p,
+        ffn_dropout_p=dropout_p,
+        drop_path_rate=args.drop_path_rate,
+        token_dropout_p=args.token_dropout_p,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+    if args.ema:
+        ema = deepcopy(model).to(device)  # Create an EMA of the model for use after training
+        requires_grad(ema, False)
+        logger.info(f"EMA Parameters: {sum(p.numel() for p in ema.parameters()):,}")
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+
+    # Setup data:
+    dataset = build_dataset(args)
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+    loader = DataLoader(
+        dataset,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=True
+    )
+    flip_info = 'with' if dataset.flip else 'without'
+    aug_info = 10 if 'ten_crop' in dataset.feature_dir else 1
+    aug_info = 2 * aug_info if dataset.aug_feature_dir is not None else aug_info
+    logger.info(f"Dataset contains {len(dataset):,} images ({args.code_path}) "
+                f"{flip_info} flip augmentation and {aug_info} crop augmentation")
+
+    # Prepare models for training:
+    if args.gpt_ckpt:
+        checkpoint = torch.load(args.gpt_ckpt, map_location="cpu")
+        model.load_state_dict(checkpoint["model"])
+        if args.ema:
+            ema.load_state_dict(checkpoint["ema"] if "ema" in checkpoint else checkpoint["model"])
+        optimizer.load_state_dict(checkpoint["optimizer"])
+        train_steps = checkpoint["steps"] if "steps" in checkpoint else int(args.gpt_ckpt.split('/')[-1].split('.')[0])
+        start_epoch = int(train_steps / int(len(dataset) / args.global_batch_size))
+        train_steps = int(start_epoch * int(len(dataset) / args.global_batch_size))
+        del checkpoint
+        logger.info(f"Resume training from checkpoint: {args.gpt_ckpt}")
+        logger.info(f"Initial state: steps={train_steps}, epochs={start_epoch}")
+    else:
+        train_steps = 0
+        start_epoch = 0
+        if args.ema:
+            update_ema(ema, model, decay=0)  # Ensure EMA is initialized with synced weights
+
+    if not args.no_compile:
+        logger.info("compiling the model... (may take several minutes)")
+        model = torch.compile(model) # requires PyTorch 2.0        
+    
+    model = DDP(model.to(device), device_ids=[args.gpu])
+    model.train()  # important! This enables embedding dropout for classifier-free guidance
+    if args.ema:
+        ema.eval()  # EMA model should always be in eval mode
+
+    ptdtype = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.mixed_precision]
+    # initialize a GradScaler. If enabled=False scaler is a no-op
+    scaler = torch.cuda.amp.GradScaler(enabled=(args.mixed_precision =='fp16'))
+    # Variables for monitoring/logging purposes:
+    log_steps = 0
+    running_loss = 0
+    start_time = time.time()
+
+    logger.info(f"Training for {args.epochs} epochs...")
+    for epoch in range(start_epoch, args.epochs):
+        sampler.set_epoch(epoch)
+        logger.info(f"Beginning epoch {epoch}...")
+        for x, y in loader:
+            x = x.to(device, non_blocking=True)
+            y = y.to(device, non_blocking=True)
+            z_indices = x.reshape(x.shape[0], -1)
+            c_indices = y.reshape(-1)
+            assert z_indices.shape[0] == c_indices.shape[0]
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices)
+            # backward pass, with gradient scaling if training in fp16         
+            scaler.scale(loss).backward()
+            if args.max_grad_norm != 0.0:
+                scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
+            # step the optimizer and scaler if training in fp16
+            scaler.step(optimizer)
+            scaler.update()
+            # flush the gradients as soon as we can, no need for this memory anymore
+            optimizer.zero_grad(set_to_none=True)
+            if args.ema:
+                update_ema(ema, model.module._orig_mod if not args.no_compile else model.module)
+
+            # Log loss values:
+            running_loss += loss.item()
+            log_steps += 1
+            train_steps += 1
+            if train_steps % args.log_every == 0:
+                # Measure training speed:
+                torch.cuda.synchronize()
+                end_time = time.time()
+                steps_per_sec = log_steps / (end_time - start_time)
+                # Reduce loss history over all processes:
+                avg_loss = torch.tensor(running_loss / log_steps, device=device)
+                dist.all_reduce(avg_loss, op=dist.ReduceOp.SUM)
+                avg_loss = avg_loss.item() / dist.get_world_size()
+                logger.info(f"(step={train_steps:07d}) Train Loss: {avg_loss:.4f}, Train Steps/Sec: {steps_per_sec:.2f}")
+                # Reset monitoring variables:
+                running_loss = 0
+                log_steps = 0
+                start_time = time.time()
+
+            # Save checkpoint:
+            if train_steps % args.ckpt_every == 0 and train_steps > 0:
+                if rank == 0:
+                    if not args.no_compile:
+                        model_weight = model.module._orig_mod.state_dict()
+                    else:
+                        model_weight = model.module.state_dict()  
+                    checkpoint = {
+                        "model": model_weight,
+                        "optimizer": optimizer.state_dict(),
+                        "steps": train_steps,
+                        "args": args
+                    }
+                    if args.ema:
+                        checkpoint["ema"] = ema.state_dict()
+                    if not args.no_local_save:
+                        checkpoint_path = f"{checkpoint_dir}/{train_steps:07d}.pt"
+                        torch.save(checkpoint, checkpoint_path)
+                        logger.info(f"Saved checkpoint to {checkpoint_path}")
+                    
+                    cloud_checkpoint_path = f"{cloud_checkpoint_dir}/{train_steps:07d}.pt"
+                    torch.save(checkpoint, cloud_checkpoint_path)
+                    logger.info(f"Saved checkpoint in cloud to {cloud_checkpoint_path}")
+                dist.barrier()
+
+    model.eval()  # important! This disables randomized embedding dropout
+    # do any sampling/FID calculation/etc. with ema (or model) in eval mode ...
+
+    logger.info("Done!")
+    dist.destroy_process_group()
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--cloud-save-path", type=str, required=True, help='please specify a cloud disk path, if not, local path')
+    parser.add_argument("--no-local-save", action='store_true', help='no save checkpoints to local path for limited disk volume')
+    parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-B")
+    parser.add_argument("--gpt-ckpt", type=str, default=None, help="ckpt path for resume training")
+    parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="c2i", help="class-conditional or text-conditional")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--ema", action='store_true', help="whether using ema training")
+    parser.add_argument("--cls-token-num", type=int, default=1, help="max token number of condition input")
+    parser.add_argument("--dropout-p", type=float, default=0.1, help="dropout_p of resid_dropout_p and ffn_dropout_p")
+    parser.add_argument("--token-dropout-p", type=float, default=0.1, help="dropout_p of token_dropout_p")
+    parser.add_argument("--drop-path-rate", type=float, default=0.0, help="using stochastic depth decay")
+    parser.add_argument("--no-compile", action='store_true')
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='imagenet_code')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=256)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--num-classes", type=int, default=1000)
+    parser.add_argument("--epochs", type=int, default=300)
+    parser.add_argument("--lr", type=float, default=1e-4)
+    parser.add_argument("--weight-decay", type=float, default=5e-2, help="Weight decay to use")
+    parser.add_argument("--beta1", type=float, default=0.9, help="beta1 parameter for the Adam optimizer")
+    parser.add_argument("--beta2", type=float, default=0.95, help="beta2 parameter for the Adam optimizer")
+    parser.add_argument("--max-grad-norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--global-batch-size", type=int, default=256)
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=24)
+    parser.add_argument("--log-every", type=int, default=100)
+    parser.add_argument("--ckpt-every", type=int, default=5000)
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=1)
+    parser.add_argument("--mixed-precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_c2i_canny.py

@@ -0,0 +1,306 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT/blob/main/train.py
+#   nanoGPT: https://github.com/karpathy/nanoGPT/blob/master/model.py
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from glob import glob
+from copy import deepcopy
+import os
+import time
+import inspect
+import argparse
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.logger import create_logger
+from utils.distributed import init_distributed_mode
+from utils.ema import update_ema, requires_grad
+from dataset.build import build_dataset
+from autoregressive.models.gpt import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+
+
+#################################################################################
+#                             Training Helper Functions                         #
+#################################################################################
+def creat_optimizer(model, weight_decay, learning_rate, betas, logger):
+    # start with all of the candidate parameters
+    param_dict = {pn: p for pn, p in model.named_parameters()}
+    # filter out those that do not require grad
+    param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+    # create optim groups. Any parameters that is 2D will be weight decayed, otherwise no.
+    # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.
+    decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]
+    nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]
+    optim_groups = [
+        {'params': decay_params, 'weight_decay': weight_decay},
+        {'params': nodecay_params, 'weight_decay': 0.0}
+    ]
+    num_decay_params = sum(p.numel() for p in decay_params)
+    num_nodecay_params = sum(p.numel() for p in nodecay_params)
+    logger.info(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+    logger.info(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+    # Create AdamW optimizer and use the fused version if it is available
+    fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+    extra_args = dict(fused=True) if fused_available else dict()
+    optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, **extra_args)
+    logger.info(f"using fused AdamW: {fused_available}")
+    return optimizer
+
+
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+def main(args):
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+    
+    # Setup DDP:
+    init_distributed_mode(args)
+    assert args.global_batch_size % dist.get_world_size() == 0, f"Batch size must be divisible by world size."
+    rank = dist.get_rank()
+    device = rank % torch.cuda.device_count()
+    seed = args.global_seed * dist.get_world_size() + rank
+    torch.manual_seed(seed)
+    torch.cuda.set_device(device)
+
+    # Setup an experiment folder:
+    if rank == 0:
+        os.makedirs(args.results_dir, exist_ok=True)  # Make results folder (holds all experiment subfolders)
+        experiment_index = len(glob(f"{args.results_dir}/*"))
+        model_string_name = args.gpt_model.replace("/", "-")  # e.g., GPT-XL/2 --> GPT-XL-2 (for naming folders)
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"  # Create an experiment folder
+        checkpoint_dir = f"{experiment_dir}/checkpoints"  # Stores saved model checkpoints
+        os.makedirs(checkpoint_dir, exist_ok=True)
+        logger = create_logger(experiment_dir)
+        logger.info(f"Experiment directory created at {experiment_dir}")
+
+        time_record = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime())
+        cloud_results_dir = f"{args.cloud_save_path}/{time_record}"
+        cloud_checkpoint_dir = f"{cloud_results_dir}/{experiment_index:03d}-{model_string_name}/checkpoints"
+        os.makedirs(cloud_checkpoint_dir, exist_ok=True)
+        logger.info(f"Experiment directory created in cloud at {cloud_checkpoint_dir}")
+    
+    else:
+        logger = create_logger(None)
+
+    # training args
+    logger.info(f"{args}")
+
+    # training env
+    logger.info(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+
+    # Setup model
+    if args.drop_path_rate > 0.0:
+        dropout_p = 0.0
+    else:
+        dropout_p = args.dropout_p
+    latent_size = args.image_size // args.downsample_size
+    model = GPT_models[args.gpt_model](
+        vocab_size=args.vocab_size,
+        block_size=latent_size ** 2,
+        num_classes=args.num_classes,
+        cls_token_num=args.cls_token_num,
+        model_type=args.gpt_type,
+        resid_dropout_p=dropout_p,
+        ffn_dropout_p=dropout_p,
+        drop_path_rate=args.drop_path_rate,
+        token_dropout_p=args.token_dropout_p,
+        condition_token_num=args.condition_token_num,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+    if args.ema:
+        ema = deepcopy(model).to(device)  # Create an EMA of the model for use after training
+        requires_grad(ema, False)
+        logger.info(f"EMA Parameters: {sum(p.numel() for p in ema.parameters()):,}")
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+
+    # Setup data:
+    dataset = build_dataset(args)
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+    loader = DataLoader(
+        dataset,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=True
+    )
+    flip_info = 'with' if dataset.flip else 'without'
+    aug_info = 10 if 'ten_crop' in dataset.feature_dir else 1
+    aug_info = 2 * aug_info if dataset.aug_feature_dir is not None else aug_info
+    logger.info(f"Dataset contains {len(dataset):,} images ({args.code_path}) "
+                f"{flip_info} flip augmentation and {aug_info} crop augmentation")
+
+    # Prepare models for training:
+    if args.gpt_ckpt:
+        checkpoint = torch.load(args.gpt_ckpt, map_location="cpu")
+        model.load_state_dict(checkpoint["model"],strict=False)
+        if args.ema:
+            ema.load_state_dict(checkpoint["ema"] if "ema" in checkpoint else checkpoint["model"])
+        #optimizer.load_state_dict(checkpoint["optimizer"])
+        train_steps = 0#checkpoint["steps"] if "steps" in checkpoint else int(args.gpt_ckpt.split('/')[-1].split('.')[0])
+        start_epoch = 0#int(train_steps / int(len(dataset) / args.global_batch_size))
+        train_steps = 0#int(start_epoch * int(len(dataset) / args.global_batch_size))
+        del checkpoint
+        logger.info(f"Resume training from checkpoint: {args.gpt_ckpt}")
+        logger.info(f"Initial state: steps={train_steps}, epochs={start_epoch}")
+    else:
+        train_steps = 0
+        start_epoch = 0
+        if args.ema:
+            update_ema(ema, model, decay=0)  # Ensure EMA is initialized with synced weights
+
+    if not args.no_compile:
+        logger.info("compiling the model... (may take several minutes)")
+        vq_model = torch.compile(vq_model) # requires PyTorch 2.0
+        model = torch.compile(model) # requires PyTorch 2.0        
+    
+    model = DDP(model.to(device), device_ids=[args.gpu],find_unused_parameters=True)
+    model.train()  # important! This enables embedding dropout for classifier-free guidance
+    if args.ema:
+        ema.eval()  # EMA model should always be in eval mode
+
+    ptdtype = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.mixed_precision]
+    # initialize a GradScaler. If enabled=False scaler is a no-op
+    scaler = torch.cuda.amp.GradScaler(enabled=(args.mixed_precision =='fp16'))
+    # Variables for monitoring/logging purposes:
+    log_steps = 0
+    running_loss = 0
+    start_time = time.time()
+
+    logger.info(f"Training for {args.epochs} epochs...")
+    for epoch in range(start_epoch, args.epochs):
+        sampler.set_epoch(epoch)
+        logger.info(f"Beginning epoch {epoch}...")
+        for batch in loader:
+            x = batch['img_code']
+            y = batch['labels']
+            condition_img = batch['condition_imgs']
+            x = x.to(device, non_blocking=True)
+            y = y.to(device, non_blocking=True)
+            condition_img = condition_img.to(device, non_blocking=True)
+            z_indices = x.reshape(x.shape[0], -1)
+            c_indices = y.reshape(-1)
+            assert z_indices.shape[0] == c_indices.shape[0]
+            with torch.cuda.amp.autocast(dtype=ptdtype): 
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, condition=condition_img.repeat(1,3,1,1).to(ptdtype))
+            # backward pass, with gradient scaling if training in fp16         
+            scaler.scale(loss).backward()
+            if args.max_grad_norm != 0.0:
+                scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
+            # step the optimizer and scaler if training in fp16
+            scaler.step(optimizer)
+            scaler.update()
+            # flush the gradients as soon as we can, no need for this memory anymore
+            optimizer.zero_grad(set_to_none=True)
+            if args.ema:
+                update_ema(ema, model.module._orig_mod if not args.no_compile else model.module)
+
+            # Log loss values:
+            running_loss += loss.item()
+            log_steps += 1
+            train_steps += 1
+            if train_steps % args.log_every == 0:
+                # Measure training speed:
+                torch.cuda.synchronize()
+                end_time = time.time()
+                steps_per_sec = log_steps / (end_time - start_time)
+                # Reduce loss history over all processes:
+                avg_loss = torch.tensor(running_loss / log_steps, device=device)
+                dist.all_reduce(avg_loss, op=dist.ReduceOp.SUM)
+                avg_loss = avg_loss.item() / dist.get_world_size()
+                logger.info(f"(step={train_steps:07d}) Train Loss: {avg_loss:.4f}, Train Steps/Sec: {steps_per_sec:.2f}")
+                # Reset monitoring variables:
+                running_loss = 0
+                log_steps = 0
+                start_time = time.time()
+
+            # Save checkpoint:
+            if train_steps % args.ckpt_every == 0 and train_steps > 0:
+                if rank == 0:
+                    if not args.no_compile:
+                        model_weight = model.module._orig_mod.state_dict()
+                    else:
+                        model_weight = model.module.state_dict()  
+                    checkpoint = {
+                        "model": model_weight,
+                        "steps": train_steps,
+                        "args": args
+                    }
+                    if args.ema:
+                        checkpoint["ema"] = ema.state_dict()
+                    # if not args.no_local_save:
+                    #     checkpoint_path = f"{checkpoint_dir}/{train_steps:07d}.pt"
+                    #     torch.save(checkpoint, checkpoint_path)
+                    #     logger.info(f"Saved checkpoint to {checkpoint_path}")
+                    
+                    cloud_checkpoint_path = f"{cloud_checkpoint_dir}/{train_steps:07d}.pt"
+                    torch.save(checkpoint, cloud_checkpoint_path)
+                    logger.info(f"Saved checkpoint to {cloud_checkpoint_path}")
+                dist.barrier()
+    model.eval()  # important! This disables randomized embedding dropout
+    # do any sampling/FID calculation/etc. with ema (or model) in eval mode ...
+
+    logger.info("Done!")
+    dist.destroy_process_group()
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--cloud-save-path", type=str, required=True, help='please specify a cloud disk path, if not, local path')
+    parser.add_argument("--no-local-save", action='store_true', help='no save checkpoints to local path for limited disk volume')
+    parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-B")
+    parser.add_argument("--gpt-ckpt", type=str, default=None, help="ckpt path for resume training")
+    parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="c2i", help="class-conditional or text-conditional")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--ema", action='store_true', help="whether using ema training")
+    parser.add_argument("--cls-token-num", type=int, default=1, help="max token number of condition input")
+    parser.add_argument("--dropout-p", type=float, default=0.1, help="dropout_p of resid_dropout_p and ffn_dropout_p")
+    parser.add_argument("--token-dropout-p", type=float, default=0.1, help="dropout_p of token_dropout_p")
+    parser.add_argument("--drop-path-rate", type=float, default=0.0, help="using stochastic depth decay")
+    parser.add_argument("--no-compile", action='store_true', default=True)
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='imagenet_code')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=256)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--num-classes", type=int, default=1000)
+    parser.add_argument("--epochs", type=int, default=20)
+    parser.add_argument("--lr", type=float, default=1e-4)
+    parser.add_argument("--weight-decay", type=float, default=5e-2, help="Weight decay to use")
+    parser.add_argument("--beta1", type=float, default=0.9, help="beta1 parameter for the Adam optimizer")
+    parser.add_argument("--beta2", type=float, default=0.95, help="beta2 parameter for the Adam optimizer")
+    parser.add_argument("--max-grad-norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--global-batch-size", type=int, default=256)
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=24)
+    parser.add_argument("--log-every", type=int, default=100)
+    parser.add_argument("--ckpt-every", type=int, default=25000)
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=1)
+    parser.add_argument("--mixed-precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    parser.add_argument("--condition-type", type=str, default='canny', choices=["depth", "canny"]) 
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for resume training")
+    parser.add_argument("--condition-token-num", type=int, default=0)
+    parser.add_argument("--get-condition-img", type=bool, default=False)
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_c2i_depth.py

@@ -0,0 +1,314 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT/blob/main/train.py
+#   nanoGPT: https://github.com/karpathy/nanoGPT/blob/master/model.py
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from glob import glob
+from copy import deepcopy
+import os
+import time
+import inspect
+import argparse
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.logger import create_logger
+from utils.distributed import init_distributed_mode
+from utils.ema import update_ema, requires_grad
+from dataset.build import build_dataset
+from autoregressive.models.gpt import GPT_models
+# from autoregressive.models.gpt_cross import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from autoregressive.models.generate import sample
+from condition.hed import HEDdetector
+import torch.nn.functional as F
+#################################################################################
+#                             Training Helper Functions                         #
+#################################################################################
+def creat_optimizer(model, weight_decay, learning_rate, betas, logger):
+    # start with all of the candidate parameters
+    param_dict = {pn: p for pn, p in model.named_parameters()}
+    # filter out those that do not require grad
+    param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+    # create optim groups. Any parameters that is 2D will be weight decayed, otherwise no.
+    # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.
+    decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]
+    nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]
+    optim_groups = [
+        {'params': decay_params, 'weight_decay': weight_decay},
+        {'params': nodecay_params, 'weight_decay': 0.0}
+    ]
+    num_decay_params = sum(p.numel() for p in decay_params)
+    num_nodecay_params = sum(p.numel() for p in nodecay_params)
+    logger.info(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+    logger.info(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+    # Create AdamW optimizer and use the fused version if it is available
+    fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+    extra_args = dict(fused=True) if fused_available else dict()
+    optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, **extra_args)
+    logger.info(f"using fused AdamW: {fused_available}")
+    return optimizer
+
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+def main(args):
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+    
+    # Setup DDP:
+    init_distributed_mode(args)
+    assert args.global_batch_size % dist.get_world_size() == 0, f"Batch size must be divisible by world size."
+    rank = dist.get_rank()
+    device = rank % torch.cuda.device_count()
+    seed = args.global_seed * dist.get_world_size() + rank
+    torch.manual_seed(seed)
+    torch.cuda.set_device(device)
+
+    # Setup an experiment folder:
+    if rank == 0:
+        os.makedirs(args.results_dir, exist_ok=True)  # Make results folder (holds all experiment subfolders)
+        experiment_index = len(glob(f"{args.results_dir}/*"))
+        model_string_name = args.gpt_model.replace("/", "-")  # e.g., GPT-XL/2 --> GPT-XL-2 (for naming folders)
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"  # Create an experiment folder
+        checkpoint_dir = f"{experiment_dir}/checkpoints"  # Stores saved model checkpoints
+        os.makedirs(checkpoint_dir, exist_ok=True)
+        logger = create_logger(experiment_dir)
+        logger.info(f"Experiment directory created at {experiment_dir}")
+
+        time_record = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime())
+        cloud_results_dir = f"{args.cloud_save_path}/{time_record}"
+        cloud_checkpoint_dir = f"{cloud_results_dir}/{experiment_index:03d}-{model_string_name}/checkpoints"
+        os.makedirs(cloud_checkpoint_dir, exist_ok=True)
+        logger.info(f"Experiment directory created in cloud at {cloud_checkpoint_dir}")
+    
+    else:
+        logger = create_logger(None)
+
+    # training args
+    logger.info(f"{args}")
+
+    # training env
+    logger.info(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+
+
+    # Setup model
+    if args.drop_path_rate > 0.0:
+        dropout_p = 0.0
+    else:
+        dropout_p = args.dropout_p
+    latent_size = args.image_size // args.downsample_size
+    model = GPT_models[args.gpt_model](
+        vocab_size=args.vocab_size,
+        block_size=latent_size ** 2,
+        num_classes=args.num_classes,
+        cls_token_num=args.cls_token_num,
+        model_type=args.gpt_type,
+        resid_dropout_p=dropout_p,
+        ffn_dropout_p=dropout_p,
+        drop_path_rate=args.drop_path_rate,
+        token_dropout_p=args.token_dropout_p,
+        condition_token_num=args.condition_token_num,
+        image_size=args.image_size,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+    if args.ema:
+        ema = deepcopy(model).to(device)  # Create an EMA of the model for use after training
+        requires_grad(ema, False)
+        logger.info(f"EMA Parameters: {sum(p.numel() for p in ema.parameters()):,}")
+
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+
+    # Setup data:
+    dataset = build_dataset(args)
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+    loader = DataLoader(
+        dataset,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=True
+    )
+    flip_info = 'with' if dataset.flip else 'without'
+    aug_info = 10 if 'ten_crop' in dataset.feature_dir else 1
+    aug_info = 2 * aug_info if dataset.aug_feature_dir is not None else aug_info
+    logger.info(f"Dataset contains {len(dataset):,} images ({args.code_path}) "
+                f"{flip_info} flip augmentation and {aug_info} crop augmentation")
+
+    # Prepare models for training:
+    if args.gpt_ckpt:
+        checkpoint = torch.load(args.gpt_ckpt, map_location="cpu")
+        model.load_state_dict(checkpoint["model"],strict=False)
+        if args.ema:
+            ema.load_state_dict(checkpoint["ema"] if "ema" in checkpoint else checkpoint["model"])
+        train_steps = 0#checkpoint["steps"] if "steps" in checkpoint else int(args.gpt_ckpt.split('/')[-1].split('.')[0])
+        start_epoch = 0#int(train_steps / int(len(dataset) / args.global_batch_size))
+        train_steps = 0#int(start_epoch * int(len(dataset) / args.global_batch_size))
+        del checkpoint
+        logger.info(f"Resume training from checkpoint: {args.gpt_ckpt}")
+        logger.info(f"Initial state: steps={train_steps}, epochs={start_epoch}")
+    else:
+        train_steps = 0
+        start_epoch = 0
+        if args.ema:
+            update_ema(ema, model, decay=0)  # Ensure EMA is initialized with synced weights
+
+    if not args.no_compile:
+        logger.info("compiling the model... (may take several minutes)")
+        model = torch.compile(model) # requires PyTorch 2.0        
+
+    
+    
+    model = DDP(model.to(device), device_ids=[args.gpu],find_unused_parameters=True)
+    model.train()  # important! This enables embedding dropout for classifier-free guidance
+    if args.ema:
+        ema.eval()  # EMA model should always be in eval mode
+
+    ptdtype = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.mixed_precision]
+    # initialize a GradScaler. If enabled=False scaler is a no-op
+    scaler = torch.cuda.amp.GradScaler(enabled=(args.mixed_precision =='fp16'))
+    # Variables for monitoring/logging purposes:
+    log_steps = 0
+    running_loss = 0
+    start_time = time.time()
+    initial_params = copy.deepcopy(model.module.condition_embeddings.weight)
+    logger.info(f"Training for {args.epochs} epochs...")
+    
+    
+    for epoch in range(start_epoch, args.epochs):
+        sampler.set_epoch(epoch)
+        logger.info(f"Beginning epoch {epoch}...")
+        for batch in loader:
+            x = batch['img_code']
+            y = batch['labels']
+            condition_img = batch['condition_imgs']
+            x = x.to(device, non_blocking=True)
+            y = y.to(device, non_blocking=True)
+            condition_img = condition_img.to(device, non_blocking=True).repeat(1,3,1,1)
+            z_indices = x.reshape(x.shape[0], -1)
+            c_indices = y.reshape(-1)
+            batchsize = y.shape[0]
+            assert z_indices.shape[0] == c_indices.shape[0]
+            with torch.cuda.amp.autocast(dtype=ptdtype): 
+                pred, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, condition=condition_img.to(ptdtype))
+                
+            # backward pass, with gradient scaling if training in fp16         
+            scaler.scale(loss).backward()
+            if args.max_grad_norm != 0.0:
+                scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
+            # step the optimizer and scaler if training in fp16
+            scaler.step(optimizer)
+            scaler.update()
+            # flush the gradients as soon as we can, no need for this memory anymore
+            optimizer.zero_grad(set_to_none=True)
+            if args.ema:
+                update_ema(ema, model.module._orig_mod if not args.no_compile else model.module)
+
+            # Log loss values:
+            running_loss += loss.item()
+            log_steps += 1
+            train_steps += 1
+            if train_steps % args.log_every == 0:
+                # Measure training speed:
+                torch.cuda.synchronize()
+                end_time = time.time()
+                steps_per_sec = log_steps / (end_time - start_time)
+                # Reduce loss history over all processes:
+                avg_loss = torch.tensor(running_loss / log_steps, device=device)
+                dist.all_reduce(avg_loss, op=dist.ReduceOp.SUM)
+                avg_loss = avg_loss.item() / dist.get_world_size()
+                logger.info(f"(step={train_steps:07d}) Train Loss: {avg_loss:.4f}, Train Steps/Sec: {steps_per_sec:.2f}")
+                # Reset monitoring variables:
+                running_loss = 0
+                log_steps = 0
+                start_time = time.time()
+
+            # Save checkpoint:
+            if train_steps % args.ckpt_every == 0 and train_steps > 0:
+                if rank == 0:
+                    if not args.no_compile:
+                        model_weight = model.module._orig_mod.state_dict()
+                    else:
+                        model_weight = model.module.state_dict()  
+                    checkpoint = {
+                        "model": model_weight,
+                        "steps": train_steps,
+                        "args": args
+                    }
+                    if args.ema:
+                        checkpoint["ema"] = ema.state_dict()
+                    # if not args.no_local_save:
+                    #     checkpoint_path = f"{checkpoint_dir}/{train_steps:07d}.pt"
+                    #     torch.save(checkpoint, checkpoint_path)
+                    #     logger.info(f"Saved checkpoint to {checkpoint_path}")
+                    
+                    cloud_checkpoint_path = f"{cloud_checkpoint_dir}/{train_steps:07d}.pt"
+                    torch.save(checkpoint, cloud_checkpoint_path)
+                    logger.info(f"Saved checkpoint to {cloud_checkpoint_path}")
+                dist.barrier()
+    model.eval()  # important! This disables randomized embedding dropout
+    # do any sampling/FID calculation/etc. with ema (or model) in eval mode ...
+
+    logger.info("Done!")
+    dist.destroy_process_group()
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--cloud-save-path", type=str, required=True, help='please specify a cloud disk path, if not, local path')
+    parser.add_argument("--no-local-save", action='store_true', help='no save checkpoints to local path for limited disk volume')
+    parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-B")
+    parser.add_argument("--gpt-ckpt", type=str, default=None, help="ckpt path for resume training")
+    parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="c2i", help="class-conditional or text-conditional")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--ema", action='store_true', help="whether using ema training")
+    parser.add_argument("--cls-token-num", type=int, default=1, help="max token number of condition input")
+    parser.add_argument("--dropout-p", type=float, default=0.1, help="dropout_p of resid_dropout_p and ffn_dropout_p")
+    parser.add_argument("--token-dropout-p", type=float, default=0.1, help="dropout_p of token_dropout_p")
+    parser.add_argument("--drop-path-rate", type=float, default=0.0, help="using stochastic depth decay")
+    parser.add_argument("--no-compile", action='store_true', default=True)
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='imagenet_code')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=256)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--num-classes", type=int, default=1000)
+    parser.add_argument("--epochs", type=int, default=15)
+    parser.add_argument("--lr", type=float, default=1e-4)
+    parser.add_argument("--weight-decay", type=float, default=5e-2, help="Weight decay to use")
+    parser.add_argument("--beta1", type=float, default=0.9, help="beta1 parameter for the Adam optimizer")
+    parser.add_argument("--beta2", type=float, default=0.95, help="beta2 parameter for the Adam optimizer")
+    parser.add_argument("--max-grad-norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--global-batch-size", type=int, default=256)
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=24)
+    parser.add_argument("--log-every", type=int, default=100)
+    parser.add_argument("--ckpt-every", type=int, default=25000)
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=1)
+    parser.add_argument("--mixed-precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    parser.add_argument("--condition-type", type=str, default='depth', choices=["canny", "depth"]) 
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for resume training")
+    parser.add_argument("--condition-token-num", type=int, default=0)
+    parser.add_argument("--get-condition-img", type=bool, default=False)
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_c2i_fsdp.py

@@ -0,0 +1,390 @@
+# Modified from:
+#   Large-DiT: https://github.com/Alpha-VLLM/LLaMA2-Accessory/blob/main/Large-DiT-ImageNet/train.py
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.nn as nn
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torch.distributed.fsdp import (
+    FullyShardedDataParallel as FSDP,
+    ShardingStrategy, MixedPrecision, StateDictType, FullStateDictConfig
+)
+from torch.distributed.fsdp.wrap import lambda_auto_wrap_policy, size_based_auto_wrap_policy
+
+import os
+import time
+import inspect
+import functools
+import argparse
+import contextlib
+from glob import glob
+import wandb
+
+from utils.logger import create_logger
+from dataset.build import build_dataset
+from autoregressive.models.gpt import GPT_models
+
+
+
+def setup_fsdp_sync(model: nn.Module, args: argparse.Namespace, device) -> FSDP:
+    model = FSDP(
+        model,
+        auto_wrap_policy=functools.partial(
+            lambda_auto_wrap_policy,
+            lambda_fn=lambda m: m in model.get_fsdp_wrap_module_list(),
+        ),
+        # auto_wrap_policy=size_based_auto_wrap_policy,
+        # process_group=fs_init.get_data_parallel_group(),
+        device_id=device,
+        sharding_strategy={
+            "fsdp": ShardingStrategy.FULL_SHARD,
+            "sdp": ShardingStrategy.SHARD_GRAD_OP,
+            "hsdp": ShardingStrategy.HYBRID_SHARD,
+        }[args.data_parallel],
+        mixed_precision=MixedPrecision(
+            param_dtype={
+                "fp32": torch.float, "tf32": torch.float,
+                "bf16": torch.bfloat16, "fp16": torch.float16,
+            }[args.mixed_precision],
+            reduce_dtype={
+                "fp32": torch.float, "tf32": torch.float,
+                "bf16": torch.bfloat16, "fp16": torch.float16,
+            }[args.grad_precision or args.mixed_precision],
+        ),
+        sync_module_states=True,
+        limit_all_gathers=True,
+        use_orig_params=True,
+    )
+
+    torch.cuda.synchronize()
+
+    return model
+
+
+
+def creat_optimizer_by_name(model, weight_decay, learning_rate, betas, global_rank, logger):
+    # start with all of the candidate parameters
+    all_param_dict = {pn: p for pn, p in model.named_parameters()}
+    # filter out those that do not require grad
+    param_dict = {pn: p for pn, p in all_param_dict.items() if p.requires_grad}
+    
+    # create optim groups. 
+    # Any parameters that is 2D will be weight decayed, otherwise no.
+    # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.
+    
+    # decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]
+    # nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]
+    
+    # model params are flatten by fsdp, we need to set the params by its name
+    decay_params = [p for n, p in param_dict.items() if 'norm' not in n]
+    nodecay_params = [p for n, p in param_dict.items() if 'norm' in n]
+    optim_groups = [
+        {'params': decay_params, 'weight_decay': weight_decay},
+        {'params': nodecay_params, 'weight_decay': 0.0}
+    ]
+    num_decay_params = sum(p.numel() for p in decay_params)
+    num_nodecay_params = sum(p.numel() for p in nodecay_params)
+    logger.info(f"(rank {global_rank}) num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+    logger.info(f"(rank {global_rank}) num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+    print(f"(rank {global_rank}) num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+    print(f"(rank {global_rank}) num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+    # Create AdamW optimizer and use the fused version if it is available
+    fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+    extra_args = dict(fused=True) if fused_available else dict()
+    optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, **extra_args)
+    logger.info(f"using fused AdamW: {fused_available}")
+    return optimizer
+
+
+
+def main(args):
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+    assert args.gpt_type == 'c2i', "FSDP only supports c2i currently."
+    # =======================================
+    #    Initialize Distributed Training
+    # =======================================
+    dist.init_process_group("nccl")
+    # init_distributed_mode(args)
+    assert args.global_batch_size % dist.get_world_size() == 0, f"Batch size must be divisible by world size."
+    global_rank = dist.get_rank()
+    device = global_rank % torch.cuda.device_count()
+    seed = args.global_seed * dist.get_world_size() + global_rank
+    torch.manual_seed(seed)
+    torch.cuda.set_device(device)
+    print(f"Starting rank={global_rank}, device={device}, seed={seed}, world_size={dist.get_world_size()}.")
+    
+
+    # =======================================
+    #    Initialize logger and wandb
+    # =======================================
+    timestamp = None
+    if global_rank == 0:
+        timestamp = time.localtime()
+        timestamp = int(time.strftime("%Y%m%d%H%M%S", timestamp))
+    # Convert timestamp to a tensor for broadcasting
+    timestamp_tensor = torch.tensor([timestamp] if timestamp is not None else [0.0], dtype=torch.double).to(device)
+    # Broadcast the timestamp to all processes
+    dist.broadcast(timestamp_tensor, src=0)
+    # All processes receive the timestamp
+    timestamp = int(timestamp_tensor.item())
+    model_string_name = args.gpt_model.replace("/", "-")  # e.g., GPT/XL --> GPT-XL (for naming folders)
+    experiment_dir = f"{args.results_dir}/{timestamp}-{model_string_name}"
+    cloud_checkpoint_dir = f"{args.cloud_save_path}/{timestamp}-{model_string_name}"
+    if global_rank == 0:
+        os.makedirs(experiment_dir, exist_ok=True) # in each local machine
+        os.makedirs(cloud_checkpoint_dir, exist_ok=True) # in one shared file storage
+        logger = create_logger(experiment_dir)
+    else:
+        logger = create_logger(None)
+    logger.info(f"Experiment directory created at {experiment_dir}")
+    logger.info(f"Experiment directory created in cloud at {cloud_checkpoint_dir}")
+
+    # training args
+    logger.info(f"{args}")  
+
+    # wandb
+    if not args.no_wandb and global_rank == 0:
+        os.environ["WANDB_DIR"] = experiment_dir   
+        wandb.init(
+            project=args.wandb_project, 
+            name = f"{timestamp}-{model_string_name}",
+            config=vars(args)
+        )
+
+
+    # ======================================================
+    #     Initialize model and resume
+    # ======================================================
+    if args.drop_path_rate > 0.0:
+        dropout_p = 0.0
+    else:
+        dropout_p = args.dropout_p
+    latent_size = args.image_size // args.downsample_size
+    model = GPT_models[args.gpt_model](
+        vocab_size=args.vocab_size,
+        block_size=latent_size ** 2,
+        num_classes=args.num_classes,
+        cls_token_num=args.cls_token_num,
+        model_type=args.gpt_type,
+        resid_dropout_p=dropout_p,
+        ffn_dropout_p=dropout_p,
+        drop_path_rate=args.drop_path_rate,
+        token_dropout_p=args.token_dropout_p,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+    if args.gpt_resume:
+        if global_rank == 0:  # other ranks receive weights in setup_fsdp_sync
+            logger.info(f"Resuming model weights from: {args.gpt_resume}")
+            model.load_state_dict(torch.load(os.path.join(
+                args.gpt_resume, "consolidated.pth",
+            ), map_location="cpu"), strict=True)
+
+    model = setup_fsdp_sync(model, args, device)
+
+
+    # ======================================================
+    #     Initialize optimizer and resume
+    # ======================================================
+    optimizer = creat_optimizer_by_name(model, args.weight_decay, args.lr, (args.beta1, args.beta2), global_rank, logger)
+    if args.gpt_resume:
+        opt_state_world_size = len([
+            x for x in os.listdir(args.gpt_resume)
+            if x.startswith("optimizer.") and x.endswith(".pth")
+        ])
+        assert opt_state_world_size == dist.get_world_size(), (
+            f"Resuming from a checkpoint with unmatched world size "
+            f"({dist.get_world_size()} vs. {opt_state_world_size}) "
+            f"is currently not supported."
+        )
+        logger.info(f"Resuming optimizer states from: {args.gpt_resume}")
+        optimizer.load_state_dict(torch.load(os.path.join(
+            args.gpt_resume,
+            f"optimizer.{dist.get_rank():05d}-of-"
+            f"{dist.get_world_size():05d}.pth",
+        ), map_location="cpu"))
+
+
+
+    # ======================================================
+    #     Initialize Dataloader
+    # ======================================================
+    dataset = build_dataset(args)
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=dist.get_world_size(),
+        rank=global_rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+    loader = DataLoader(
+        dataset,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=True
+    )
+    flip_info = 'with' if dataset.flip else 'without'
+    aug_info = 10 if 'ten_crop' in dataset.feature_dir else 1
+    aug_info = 2 * aug_info if dataset.aug_feature_dir is not None else aug_info
+    logger.info(f"Dataset contains {len(dataset):,} images ({args.code_path}) "
+                f"{flip_info} flip augmentation and {aug_info} crop augmentation")
+    
+
+
+    # ======================================================
+    #   Start training !!!
+    # ======================================================
+    if args.gpt_resume:
+        with open(os.path.join(args.gpt_resume, "resume_step.txt")) as f:
+            train_steps = int(f.read().strip())
+        start_epoch = int(train_steps / int(len(dataset) / args.global_batch_size))
+        train_steps = int(start_epoch * int(len(dataset) / args.global_batch_size))
+        logger.info(f"Initial state: steps={train_steps}, epochs={start_epoch}")
+    else:
+        train_steps = 0
+        start_epoch = 0
+    
+    model.train()  # important! This enables embedding dropout for classifier-free guidance
+
+    # Variables for monitoring/logging purposes:
+    log_steps = 0
+    running_loss = 0
+    start_time = time.time()
+
+    logger.info(f"Training for {args.epochs} epochs...")
+    for epoch in range(start_epoch, args.epochs):
+        sampler.set_epoch(epoch)
+        logger.info(f"Beginning epoch {epoch}...")
+        for x, y in loader:
+            x = x.to(device, non_blocking=True)
+            y = y.to(device, non_blocking=True)
+            z_indices = x.reshape(x.shape[0], -1)
+            c_indices = y.reshape(-1)
+            assert z_indices.shape[0] == c_indices.shape[0]
+
+            optimizer.zero_grad()
+            with {
+                "bf16": torch.cuda.amp.autocast(dtype=torch.bfloat16),
+                "fp16": torch.cuda.amp.autocast(dtype=torch.float16),
+                "fp32": contextlib.nullcontext(),
+                "tf32": contextlib.nullcontext(),
+            }[args.mixed_precision]: 
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices)
+            loss.backward()
+            
+            if args.max_grad_norm != 0.0:
+            #   according to https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.FullyShardedDataParallel.clip_grad_norm_
+            #   torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
+                model.clip_grad_norm_(args.max_grad_norm)
+            optimizer.step()
+            
+
+            # Log loss values:
+            running_loss += loss.item()
+            log_steps += 1
+            train_steps += 1
+            if train_steps % args.log_every == 0:
+                # Measure training speed:
+                torch.cuda.synchronize()
+                end_time = time.time()
+                steps_per_sec = log_steps / (end_time - start_time)
+                # Reduce loss history over all processes:
+                avg_loss = torch.tensor(running_loss / log_steps, device=device)
+                dist.all_reduce(avg_loss, op=dist.ReduceOp.SUM)
+                avg_loss = avg_loss.item() / dist.get_world_size()
+                logger.info(f"(step={train_steps:07d}) Train Loss: {avg_loss:.4f}, Train Steps/Sec: {steps_per_sec:.2f}")
+                if not args.no_wandb and global_rank == 0:
+                    wandb.log({"train_loss": avg_loss}, step=train_steps)
+
+                # Reset monitoring variables:
+                running_loss = 0
+                log_steps = 0
+                start_time = time.time()
+
+
+            # Save checkpoint:
+            if train_steps % args.ckpt_every == 0 and train_steps > 0:
+                cloud_checkpoint_path = f"{cloud_checkpoint_dir}/{train_steps:07d}"
+                os.makedirs(cloud_checkpoint_path, exist_ok=True)
+
+                ### saving model parameters
+                with FSDP.state_dict_type(
+                    model,
+                    StateDictType.FULL_STATE_DICT,
+                    FullStateDictConfig(rank0_only=True, offload_to_cpu=True),
+                ):
+                    consolidated_model_state_dict = model.state_dict()
+                    if global_rank == 0:
+                        consolidated_fn = "consolidated.pth"
+                        torch.save(consolidated_model_state_dict, 
+                        os.path.join(cloud_checkpoint_path, consolidated_fn))
+                dist.barrier()
+                del consolidated_model_state_dict
+                logger.info(f"Saved consolidated to {cloud_checkpoint_path}")
+
+                ### saving optimizer
+                opt_state_fn = (
+                    f"optimizer.{dist.get_rank():05d}-of-"
+                    f"{dist.get_world_size():05d}.pth"
+                )
+                torch.save(optimizer.state_dict(), os.path.join(cloud_checkpoint_path, opt_state_fn))
+                dist.barrier()
+                logger.info(f"Saved optimizer to {cloud_checkpoint_path}")
+
+                ### saving training step
+                if global_rank == 0:
+                    with open(os.path.join(cloud_checkpoint_path, "resume_step.txt"), "w") as f:
+                        print(train_steps, file=f)
+                dist.barrier()
+                logger.info(f"Saved training step to {cloud_checkpoint_path}")
+
+    model.eval()  # important! This disables randomized embedding dropout
+    # do any sampling/FID calculation/etc. with ema (or model) in eval mode ...
+
+    logger.info("Done!")
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--cloud-save-path", type=str, required=True, help='please specify a cloud disk path, if not, local path')
+    parser.add_argument("--no-local-save", action='store_true', help='no save checkpoints to local path for limited disk volume')
+    parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-B")
+    parser.add_argument("--gpt-resume", type=str, default=None, help="model, optimizer and argument path for resume training")
+    parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="c2i", help="class-conditional or text-conditional")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--ema", action='store_true', help="whether using ema training")
+    parser.add_argument("--cls-token-num", type=int, default=1, help="max token number of condition input")
+    parser.add_argument("--dropout-p", type=float, default=0.1, help="dropout_p of resid_dropout_p and ffn_dropout_p")
+    parser.add_argument("--token-dropout-p", type=float, default=0.1, help="dropout_p of token_dropout_p")
+    parser.add_argument("--drop-path-rate", type=float, default=0.0, help="using stochastic depth decay")
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='imagenet_code')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=256)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--num-classes", type=int, default=1000)
+    parser.add_argument("--epochs", type=int, default=300)
+    parser.add_argument("--lr", type=float, default=1e-4)
+    parser.add_argument("--weight-decay", type=float, default=5e-2, help="Weight decay to use")
+    parser.add_argument("--beta1", type=float, default=0.9, help="beta1 parameter for the Adam optimizer")
+    parser.add_argument("--beta2", type=float, default=0.95, help="beta2 parameter for the Adam optimizer")
+    parser.add_argument("--max-grad-norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--global-batch-size", type=int, default=256)
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=24)
+    parser.add_argument("--log-every", type=int, default=100)
+    parser.add_argument("--ckpt-every", type=int, default=5000)
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=1)
+    parser.add_argument("--mixed-precision", type=str, choices=["fp32", "tf32", "fp16", "bf16"], default='bf16') 
+    parser.add_argument("--data-parallel", type=str, choices=["sdp", "fsdp", "hsdp"], default="fsdp")
+    parser.add_argument("--grad-precision", type=str, choices=["fp32", "fp16", "bf16"])
+    parser.add_argument("--wandb-project", type=str, default='c2i_fsdp')
+    parser.add_argument("--no-wandb", action='store_true')
+    args = parser.parse_args()
+    main(args)

tokenizer/tokenizer_image/cache/vgg.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a78928a0af1e5f0fcb1f3b9e8f8c3a2a5a3de244d830ad5c1feddc79b8432868
+size 7289

tokenizer/tokenizer_image/vq_model_hf.py

@@ -0,0 +1,17 @@
+from huggingface_hub import PyTorchModelHubMixin
+
+from tokenizer.tokenizer_image.vq_model import ModelArgs, VQModel
+
+class VQModelHF(VQModel, PyTorchModelHubMixin, repo_url="https://github.com/FoundationVision/LlamaGen", license="mit", tags=["llamagen", "text-to-image"]):
+    pass
+
+#################################################################################
+#                              VQ Model Configs                                 #
+#################################################################################
+def VQ_8(**kwargs):
+    return VQModelHF(ModelArgs(encoder_ch_mult=[1, 2, 2, 4], decoder_ch_mult=[1, 2, 2, 4], **kwargs))
+
+def VQ_16(**kwargs):
+    return VQModelHF(ModelArgs(encoder_ch_mult=[1, 1, 2, 2, 4], decoder_ch_mult=[1, 1, 2, 2, 4], **kwargs))
+
+VQ_models_HF = {'VQ-16': VQ_16, 'VQ-8': VQ_8}

tokenizer/tokenizer_image/vq_train.py

@@ -0,0 +1,323 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT/blob/main/train.py
+#   nanoGPT: https://github.com/karpathy/nanoGPT/blob/master/model.py
+import torch
+# the first flag below was False when we tested this script but True makes A100 training a lot faster:
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import Dataset, DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torchvision.datasets import ImageFolder
+from torchvision import transforms
+
+import os
+import time
+import argparse
+from glob import glob
+from copy import deepcopy
+# import sys
+# sys.path.append('/data/vjuicefs_sz_cv_v2/11171709/ControlAR')
+from utils.logger import create_logger
+from utils.distributed import init_distributed_mode
+from utils.ema import update_ema, requires_grad
+from dataset.augmentation import random_crop_arr
+from dataset.build import build_dataset
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from tokenizer.tokenizer_image.vq_loss import VQLoss
+
+import warnings
+warnings.filterwarnings('ignore')
+
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+
+def main(args):
+    """
+    Trains a new model.
+    """
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+    
+    # Setup DDP:
+    init_distributed_mode(args)
+    assert args.global_batch_size % dist.get_world_size() == 0, f"Batch size must be divisible by world size."
+    rank = dist.get_rank()
+    device = rank % torch.cuda.device_count()
+    seed = args.global_seed * dist.get_world_size() + rank
+    torch.manual_seed(seed)
+    torch.cuda.set_device(device)
+
+    # Setup an experiment folder:
+    if rank == 0:
+        os.makedirs(args.results_dir, exist_ok=True)  # Make results folder (holds all experiment subfolders)
+        experiment_index = len(glob(f"{args.results_dir}/*"))
+        model_string_name = args.vq_model.replace("/", "-")
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"  # Create an experiment folder
+        checkpoint_dir = f"{experiment_dir}/checkpoints"  # Stores saved model checkpoints
+        os.makedirs(checkpoint_dir, exist_ok=True)
+        logger = create_logger(experiment_dir)
+        logger.info(f"Experiment directory created at {experiment_dir}")
+
+        time_record = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime())
+        cloud_results_dir = f"{args.cloud_save_path}/{time_record}"
+        cloud_checkpoint_dir = f"{cloud_results_dir}/{experiment_index:03d}-{model_string_name}/checkpoints"
+        os.makedirs(cloud_checkpoint_dir, exist_ok=True)
+        logger.info(f"Experiment directory created in cloud at {cloud_checkpoint_dir}")
+    
+    else:
+        logger = create_logger(None)
+
+    # training args
+    logger.info(f"{args}")
+
+    # training env
+    logger.info(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim,
+        commit_loss_beta=args.commit_loss_beta,
+        entropy_loss_ratio=args.entropy_loss_ratio,
+        dropout_p=args.dropout_p,
+    )
+    logger.info(f"VQ Model Parameters: {sum(p.numel() for p in vq_model.parameters()):,}")
+    if args.ema:
+        ema = deepcopy(vq_model).to(device)  # Create an EMA of the model for use after training
+        requires_grad(ema, False)
+        logger.info(f"VQ Model EMA Parameters: {sum(p.numel() for p in ema.parameters()):,}")
+    vq_model = vq_model.to(device)
+
+    vq_loss = VQLoss(
+        disc_start=args.disc_start, 
+        disc_weight=args.disc_weight,
+        disc_type=args.disc_type,
+        disc_loss=args.disc_loss,
+        gen_adv_loss=args.gen_loss,
+        image_size=args.image_size,
+        perceptual_weight=args.perceptual_weight,
+        reconstruction_weight=args.reconstruction_weight,
+        reconstruction_loss=args.reconstruction_loss,
+        codebook_weight=args.codebook_weight,  
+    ).to(device)
+    logger.info(f"Discriminator Parameters: {sum(p.numel() for p in vq_loss.discriminator.parameters()):,}")
+
+    # initialize a GradScaler. If enabled=False scaler is a no-op
+    scaler = torch.cuda.amp.GradScaler(enabled=(args.mixed_precision =='fp16'))
+    scaler_disc = torch.cuda.amp.GradScaler(enabled=(args.mixed_precision =='fp16'))
+    # Setup optimizer
+    optimizer = torch.optim.Adam(vq_model.parameters(), lr=args.lr, betas=(args.beta1, args.beta2))
+    optimizer_disc = torch.optim.Adam(vq_loss.discriminator.parameters(), lr=args.lr, betas=(args.beta1, args.beta2))
+
+    # Setup data:
+    transform = transforms.Compose([
+        transforms.Lambda(lambda pil_image: random_crop_arr(pil_image, args.image_size)),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+    ])
+    if args.dataset == 'imagenet_code':
+        dataset = build_dataset(args)
+    else:
+        dataset = build_dataset(args, transform=transform)
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+    loader = DataLoader(
+        dataset,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=True
+    )
+    logger.info(f"Dataset contains {len(dataset):,} images ({args.data_path})")
+    
+
+    # Prepare models for training:
+    if args.vq_ckpt:
+        checkpoint = torch.load(args.vq_ckpt, map_location="cpu")
+        vq_model.load_state_dict(checkpoint["model"])
+        if args.ema:
+            ema.load_state_dict(checkpoint["ema"])
+        optimizer.load_state_dict(checkpoint["optimizer"])
+        vq_loss.discriminator.load_state_dict(checkpoint["discriminator"])
+        optimizer_disc.load_state_dict(checkpoint["optimizer_disc"])
+        if not args.finetune:
+            train_steps = checkpoint["steps"] if "steps" in checkpoint else int(args.vq_ckpt.split('/')[-1].split('.')[0])
+            start_epoch = int(train_steps / int(len(dataset) / args.global_batch_size))
+            train_steps = int(start_epoch * int(len(dataset) / args.global_batch_size))
+        else:
+            train_steps = 0
+            start_epoch = 0           
+        del checkpoint
+        logger.info(f"Resume training from checkpoint: {args.vq_ckpt}")
+        logger.info(f"Initial state: steps={train_steps}, epochs={start_epoch}")
+    else:
+        train_steps = 0
+        start_epoch = 0
+        if args.ema:
+            update_ema(ema, vq_model, decay=0)  # Ensure EMA is initialized with synced weights
+    
+    if args.compile:
+        logger.info("compiling the model... (may take several minutes)")
+        vq_model = torch.compile(vq_model) # requires PyTorch 2.0        
+    
+    vq_model = DDP(vq_model.to(device), device_ids=[args.gpu])
+    vq_model.train()
+    if args.ema:
+        ema.eval()  # EMA model should always be in eval mode
+    vq_loss = DDP(vq_loss.to(device), device_ids=[args.gpu])
+    vq_loss.train()
+
+    ptdtype = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.mixed_precision]
+
+    # Variables for monitoring/logging purposes:
+    log_steps = 0
+    running_loss = 0
+    start_time = time.time()
+
+    logger.info(f"Training for {args.epochs} epochs...")
+    for epoch in range(start_epoch, args.epochs):
+        sampler.set_epoch(epoch)
+        logger.info(f"Beginning epoch {epoch}...")
+        for x, y in loader:
+            imgs = x.to(device, non_blocking=True)
+
+            # generator training
+            optimizer.zero_grad()
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                recons_imgs, codebook_loss = vq_model(imgs)
+                loss_gen = vq_loss(codebook_loss, imgs, recons_imgs, optimizer_idx=0, global_step=train_steps+1, 
+                                   last_layer=vq_model.module.decoder.last_layer, 
+                                   logger=logger, log_every=args.log_every)
+            scaler.scale(loss_gen).backward()
+            if args.max_grad_norm != 0.0:
+                scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(vq_model.parameters(), args.max_grad_norm)
+            scaler.step(optimizer)
+            scaler.update()
+            if args.ema:
+                update_ema(ema, vq_model.module._orig_mod if args.compile else vq_model.module)
+
+            # discriminator training            
+            optimizer_disc.zero_grad()
+            with torch.cuda.amp.autocast(dtype=ptdtype):
+                loss_disc = vq_loss(codebook_loss, imgs, recons_imgs, optimizer_idx=1, global_step=train_steps+1,
+                                    logger=logger, log_every=args.log_every)
+            scaler_disc.scale(loss_disc).backward()
+            if args.max_grad_norm != 0.0:
+                scaler_disc.unscale_(optimizer_disc)
+                torch.nn.utils.clip_grad_norm_(vq_loss.module.discriminator.parameters(), args.max_grad_norm)
+            scaler_disc.step(optimizer_disc)
+            scaler_disc.update()
+            
+            # # Log loss values:
+            running_loss += loss_gen.item() + loss_disc.item()
+            
+            log_steps += 1
+            train_steps += 1
+            if train_steps % args.log_every == 0:
+                # Measure training speed:
+                torch.cuda.synchronize()
+                end_time = time.time()
+                steps_per_sec = log_steps / (end_time - start_time)
+                # Reduce loss history over all processes:
+                avg_loss = torch.tensor(running_loss / log_steps, device=device)
+                dist.all_reduce(avg_loss, op=dist.ReduceOp.SUM)
+                avg_loss = avg_loss.item() / dist.get_world_size()
+                logger.info(f"(step={train_steps:07d}) Train Loss: {avg_loss:.4f}, Train Steps/Sec: {steps_per_sec:.2f}")
+                # Reset monitoring variables:
+                running_loss = 0
+                log_steps = 0
+                start_time = time.time()
+
+            # Save checkpoint:
+            if train_steps % args.ckpt_every == 0 and train_steps > 0:
+                if rank == 0:
+                    if args.compile:
+                        model_weight = vq_model.module._orig_mod.state_dict()
+                    else:
+                        model_weight = vq_model.module.state_dict()  
+                    checkpoint = {
+                        "model": model_weight,
+                        "optimizer": optimizer.state_dict(),
+                        "discriminator": vq_loss.module.discriminator.state_dict(),
+                        "optimizer_disc": optimizer_disc.state_dict(),
+                        "steps": train_steps,
+                        "args": args
+                    }
+                    if args.ema:
+                        checkpoint["ema"] = ema.state_dict()
+                    if not args.no_local_save:
+                        checkpoint_path = f"{checkpoint_dir}/{train_steps:07d}.pt"
+                        torch.save(checkpoint, checkpoint_path)
+                        logger.info(f"Saved checkpoint to {checkpoint_path}")
+                    
+                    cloud_checkpoint_path = f"{cloud_checkpoint_dir}/{train_steps:07d}.pt"
+                    torch.save(checkpoint, cloud_checkpoint_path)
+                    logger.info(f"Saved checkpoint in cloud to {cloud_checkpoint_path}")
+                dist.barrier()
+
+    vq_model.eval()  # important! This disables randomized embedding dropout
+    # do any sampling/FID calculation/etc. with ema (or model) in eval mode ...
+
+    logger.info("Done!")
+    dist.destroy_process_group()
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-path", type=str, default=None)
+    parser.add_argument("--code-path", type=str, default=None)
+    parser.add_argument("--data-face-path", type=str, default=None, help="face datasets to improve vq model")
+    parser.add_argument("--cloud-save-path", type=str, required=True, help='please specify a cloud disk path, if not, local path')
+    parser.add_argument("--no-local-save", action='store_true', help='no save checkpoints to local path for limited disk volume')
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for resume training")
+    parser.add_argument("--finetune", action='store_true', help="finetune a pre-trained vq model")
+    parser.add_argument("--ema", action='store_true', help="whether using ema training")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--codebook-l2-norm", action='store_true', default=True, help="l2 norm codebook")
+    parser.add_argument("--codebook-weight", type=float, default=1.0, help="codebook loss weight for vector quantization")
+    parser.add_argument("--entropy-loss-ratio", type=float, default=0.0, help="entropy loss ratio in codebook loss")
+    parser.add_argument("--commit-loss-beta", type=float, default=0.25, help="commit loss beta in codebook loss")
+    parser.add_argument("--reconstruction-weight", type=float, default=1.0, help="reconstruction loss weight of image pixel")
+    parser.add_argument("--reconstruction-loss", type=str, default='l2', help="reconstruction loss type of image pixel")
+    parser.add_argument("--perceptual-weight", type=float, default=1.0, help="perceptual loss weight of LPIPS")
+    parser.add_argument("--disc-weight", type=float, default=0.5, help="discriminator loss weight for gan training")
+    parser.add_argument("--disc-start", type=int, default=20000, help="iteration to start discriminator training and loss")
+    parser.add_argument("--disc-type", type=str, choices=['patchgan', 'stylegan'], default='patchgan', help="discriminator type")
+    parser.add_argument("--disc-loss", type=str, choices=['hinge', 'vanilla', 'non-saturating'], default='hinge', help="discriminator loss")
+    parser.add_argument("--gen-loss", type=str, choices=['hinge', 'non-saturating'], default='hinge', help="generator loss for gan training")
+    parser.add_argument("--compile", action='store_true', default=False)
+    parser.add_argument("--dropout-p", type=float, default=0.0, help="dropout_p")
+    parser.add_argument("--results-dir", type=str, default="results_tokenizer_image")
+    parser.add_argument("--dataset", type=str, default='imagenet')
+    parser.add_argument("--image-size", type=int, choices=[256, 512], default=256)
+    parser.add_argument("--epochs", type=int, default=40)
+    parser.add_argument("--lr", type=float, default=1e-4)
+    parser.add_argument("--weight-decay", type=float, default=5e-2, help="Weight decay to use.")
+    parser.add_argument("--beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+    parser.add_argument("--beta2", type=float, default=0.95, help="The beta2 parameter for the Adam optimizer.")
+    parser.add_argument("--max-grad-norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--global-batch-size", type=int, default=64)
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=16)
+    parser.add_argument("--log-every", type=int, default=100)
+    parser.add_argument("--ckpt-every", type=int, default=5000)
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=1)
+    parser.add_argument("--mixed-precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    parser.add_argument("--condition", type=str, default='hed')
+    parser.add_argument("--get-condition-img", type=bool, default=False)
+    args = parser.parse_args()
+    main(args)

tokenizer/vqgan/README.md

@@ -0,0 +1,21 @@
+## Pretrained VQVAE Models
+
+### install
+```
+pip install omegaconf
+pip install einops
+```
+* download all needed models from https://github.com/CompVis/taming-transformers and put in pretrained_models/
+* pip install pytorch_lightning
+* python3 tools/convert_pytorch_lightning_to_torch.py
+* pip uninstall pytorch_lightning
+
+### demo
+```
+cd ${THIS_REPO_ROOT}
+python3 tokenizer/vqgan/taming_vqgan_demo.py
+```
+
+### acknowledge
+Codes in this folder are modified from from https://github.com/CompVis/taming-transformers
+

tokenizer/vqgan/configs/vqgan_imagenet_f16_1024.yaml

@@ -0,0 +1,32 @@
+model:
+  base_learning_rate: 4.5e-06
+  target: taming.models.vqgan.VQModel
+  params:
+    embed_dim: 256
+    n_embed: 1024
+    ddconfig:
+      double_z: false
+      z_channels: 256
+      resolution: 256
+      in_channels: 3
+      out_ch: 3
+      ch: 128
+      ch_mult:
+      - 1
+      - 1
+      - 2
+      - 2
+      - 4
+      num_res_blocks: 2
+      attn_resolutions:
+      - 16
+      dropout: 0.0
+    lossconfig:
+      target: taming.modules.losses.vqperceptual.VQLPIPSWithDiscriminator
+      params:
+        disc_conditional: false
+        disc_in_channels: 3
+        disc_start: 0
+        disc_weight: 0.8
+        codebook_weight: 1.0
+        

tokenizer/vqgan/configs/vqgan_imagenet_f16_16384.yaml

@@ -0,0 +1,34 @@
+model:
+  base_learning_rate: 4.5e-06
+  target: taming.models.vqgan.VQModel
+  params:
+    embed_dim: 256
+    n_embed: 16384
+    monitor: val/rec_loss
+    ddconfig:
+      double_z: false
+      z_channels: 256
+      resolution: 256
+      in_channels: 3
+      out_ch: 3
+      ch: 128
+      ch_mult:
+      - 1
+      - 1
+      - 2
+      - 2
+      - 4
+      num_res_blocks: 2
+      attn_resolutions:
+      - 16
+      dropout: 0.0
+    lossconfig:
+      target: taming.modules.losses.vqperceptual.VQLPIPSWithDiscriminator
+      params:
+        disc_conditional: false
+        disc_in_channels: 3
+        disc_start: 0
+        disc_weight: 0.75
+        disc_num_layers: 2
+        codebook_weight: 1.0
+

tokenizer/vqgan/configs/vqgan_openimage_f8_16384.yaml

@@ -0,0 +1,20 @@
+model:
+  params:
+    embed_dim: 4
+    n_embed: 16384
+    ddconfig:
+      double_z: false
+      z_channels: 4
+      resolution: 256
+      in_channels: 3
+      out_ch: 3
+      ch: 128
+      ch_mult:
+      - 1
+      - 2
+      - 2
+      - 4
+      num_res_blocks: 2
+      attn_resolutions:
+      - 32
+      dropout: 0.0

tokenizer/vqgan/configs/vqgan_openimage_f8_256.yaml

@@ -0,0 +1,20 @@
+model:
+  params:
+    embed_dim: 4
+    n_embed: 256
+    ddconfig:
+      double_z: false
+      z_channels: 4
+      resolution: 256
+      in_channels: 3
+      out_ch: 3
+      ch: 128
+      ch_mult:
+      - 1
+      - 2
+      - 2
+      - 4
+      num_res_blocks: 2
+      attn_resolutions:
+      - 32
+      dropout: 0.0

tokenizer/vqgan/layer.py

@@ -0,0 +1,372 @@
+# pytorch_diffusion + derived encoder decoder
+import math
+import torch
+import torch.nn as nn
+import numpy as np
+
+
+def nonlinearity(x):
+    # swish
+    return x*torch.sigmoid(x)
+
+
+def Normalize(in_channels):
+    return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+
+
+class Upsample(nn.Module):
+    def __init__(self, in_channels, with_conv):
+        super().__init__()
+        self.with_conv = with_conv
+        if self.with_conv:
+            self.conv = torch.nn.Conv2d(in_channels,
+                                        in_channels,
+                                        kernel_size=3,
+                                        stride=1,
+                                        padding=1)
+
+    def forward(self, x):
+        x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest")
+        if self.with_conv:
+            x = self.conv(x)
+        return x
+
+
+class Downsample(nn.Module):
+    def __init__(self, in_channels, with_conv):
+        super().__init__()
+        self.with_conv = with_conv
+        if self.with_conv:
+            # no asymmetric padding in torch conv, must do it ourselves
+            self.conv = torch.nn.Conv2d(in_channels,
+                                        in_channels,
+                                        kernel_size=3,
+                                        stride=2,
+                                        padding=0)
+
+    def forward(self, x):
+        if self.with_conv:
+            pad = (0,1,0,1)
+            x = torch.nn.functional.pad(x, pad, mode="constant", value=0)
+            x = self.conv(x)
+        else:
+            x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2)
+        return x
+
+
+class ResnetBlock(nn.Module):
+    def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False,
+                 dropout, temb_channels=512):
+        super().__init__()
+        self.in_channels = in_channels
+        out_channels = in_channels if out_channels is None else out_channels
+        self.out_channels = out_channels
+        self.use_conv_shortcut = conv_shortcut
+
+        self.norm1 = Normalize(in_channels)
+        self.conv1 = torch.nn.Conv2d(in_channels,
+                                     out_channels,
+                                     kernel_size=3,
+                                     stride=1,
+                                     padding=1)
+        if temb_channels > 0:
+            self.temb_proj = torch.nn.Linear(temb_channels,
+                                             out_channels)
+        self.norm2 = Normalize(out_channels)
+        self.dropout = torch.nn.Dropout(dropout)
+        self.conv2 = torch.nn.Conv2d(out_channels,
+                                     out_channels,
+                                     kernel_size=3,
+                                     stride=1,
+                                     padding=1)
+        if self.in_channels != self.out_channels:
+            if self.use_conv_shortcut:
+                self.conv_shortcut = torch.nn.Conv2d(in_channels,
+                                                     out_channels,
+                                                     kernel_size=3,
+                                                     stride=1,
+                                                     padding=1)
+            else:
+                self.nin_shortcut = torch.nn.Conv2d(in_channels,
+                                                    out_channels,
+                                                    kernel_size=1,
+                                                    stride=1,
+                                                    padding=0)
+
+    def forward(self, x, temb):
+        h = x
+        h = self.norm1(h)
+        h = nonlinearity(h)
+        h = self.conv1(h)
+
+        if temb is not None:
+            h = h + self.temb_proj(nonlinearity(temb))[:,:,None,None]
+
+        h = self.norm2(h)
+        h = nonlinearity(h)
+        h = self.dropout(h)
+        h = self.conv2(h)
+
+        if self.in_channels != self.out_channels:
+            if self.use_conv_shortcut:
+                x = self.conv_shortcut(x)
+            else:
+                x = self.nin_shortcut(x)
+
+        return x+h
+
+
+class AttnBlock(nn.Module):
+    def __init__(self, in_channels):
+        super().__init__()
+        self.in_channels = in_channels
+
+        self.norm = Normalize(in_channels)
+        self.q = torch.nn.Conv2d(in_channels,
+                                 in_channels,
+                                 kernel_size=1,
+                                 stride=1,
+                                 padding=0)
+        self.k = torch.nn.Conv2d(in_channels,
+                                 in_channels,
+                                 kernel_size=1,
+                                 stride=1,
+                                 padding=0)
+        self.v = torch.nn.Conv2d(in_channels,
+                                 in_channels,
+                                 kernel_size=1,
+                                 stride=1,
+                                 padding=0)
+        self.proj_out = torch.nn.Conv2d(in_channels,
+                                        in_channels,
+                                        kernel_size=1,
+                                        stride=1,
+                                        padding=0)
+
+
+    def forward(self, x):
+        h_ = x
+        h_ = self.norm(h_)
+        q = self.q(h_)
+        k = self.k(h_)
+        v = self.v(h_)
+
+        # compute attention
+        b,c,h,w = q.shape
+        q = q.reshape(b,c,h*w)
+        q = q.permute(0,2,1)   # b,hw,c
+        k = k.reshape(b,c,h*w) # b,c,hw
+        w_ = torch.bmm(q,k)     # b,hw,hw    w[b,i,j]=sum_c q[b,i,c]k[b,c,j]
+        w_ = w_ * (int(c)**(-0.5))
+        w_ = torch.nn.functional.softmax(w_, dim=2)
+
+        # attend to values
+        v = v.reshape(b,c,h*w)
+        w_ = w_.permute(0,2,1)   # b,hw,hw (first hw of k, second of q)
+        h_ = torch.bmm(v,w_)     # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j]
+        h_ = h_.reshape(b,c,h,w)
+
+        h_ = self.proj_out(h_)
+
+        return x+h_
+
+
+
+class Encoder(nn.Module):
+    def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
+                 attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
+                 resolution, z_channels, double_z=True, **ignore_kwargs):
+        super().__init__()
+        self.ch = ch
+        self.temb_ch = 0
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+
+        # downsampling
+        self.conv_in = torch.nn.Conv2d(in_channels,
+                                       self.ch,
+                                       kernel_size=3,
+                                       stride=1,
+                                       padding=1)
+
+        curr_res = resolution
+        in_ch_mult = (1,)+tuple(ch_mult)
+        self.down = nn.ModuleList()
+        for i_level in range(self.num_resolutions):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_in = ch*in_ch_mult[i_level]
+            block_out = ch*ch_mult[i_level]
+            for i_block in range(self.num_res_blocks):
+                block.append(ResnetBlock(in_channels=block_in,
+                                         out_channels=block_out,
+                                         temb_channels=self.temb_ch,
+                                         dropout=dropout))
+                block_in = block_out
+                if curr_res in attn_resolutions:
+                    attn.append(AttnBlock(block_in))
+            down = nn.Module()
+            down.block = block
+            down.attn = attn
+            if i_level != self.num_resolutions-1:
+                down.downsample = Downsample(block_in, resamp_with_conv)
+                curr_res = curr_res // 2
+            self.down.append(down)
+
+        # middle
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(in_channels=block_in,
+                                       out_channels=block_in,
+                                       temb_channels=self.temb_ch,
+                                       dropout=dropout)
+        self.mid.attn_1 = AttnBlock(block_in)
+        self.mid.block_2 = ResnetBlock(in_channels=block_in,
+                                       out_channels=block_in,
+                                       temb_channels=self.temb_ch,
+                                       dropout=dropout)
+
+        # end
+        self.norm_out = Normalize(block_in)
+        self.conv_out = torch.nn.Conv2d(block_in,
+                                        2*z_channels if double_z else z_channels,
+                                        kernel_size=3,
+                                        stride=1,
+                                        padding=1)
+
+
+    def forward(self, x):
+        #assert x.shape[2] == x.shape[3] == self.resolution, "{}, {}, {}".format(x.shape[2], x.shape[3], self.resolution)
+
+        # timestep embedding
+        temb = None
+
+        # downsampling
+        hs = [self.conv_in(x)]
+        for i_level in range(self.num_resolutions):
+            for i_block in range(self.num_res_blocks):
+                h = self.down[i_level].block[i_block](hs[-1], temb)
+                if len(self.down[i_level].attn) > 0:
+                    h = self.down[i_level].attn[i_block](h)
+                hs.append(h)
+            if i_level != self.num_resolutions-1:
+                hs.append(self.down[i_level].downsample(hs[-1]))
+
+        # middle
+        h = hs[-1]
+        h = self.mid.block_1(h, temb)
+        h = self.mid.attn_1(h)
+        h = self.mid.block_2(h, temb)
+
+        # end
+        h = self.norm_out(h)
+        h = nonlinearity(h)
+        h = self.conv_out(h)
+        return h
+
+
+class Decoder(nn.Module):
+    def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
+                 attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
+                 resolution, z_channels, give_pre_end=False, **ignorekwargs):
+        super().__init__()
+        self.ch = ch
+        self.temb_ch = 0
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+        self.give_pre_end = give_pre_end
+
+        # compute in_ch_mult, block_in and curr_res at lowest res
+        in_ch_mult = (1,)+tuple(ch_mult)
+        block_in = ch*ch_mult[self.num_resolutions-1]
+        curr_res = resolution // 2**(self.num_resolutions-1)
+        self.z_shape = (1,z_channels,curr_res,curr_res)
+        print("Working with z of shape {} = {} dimensions.".format(
+            self.z_shape, np.prod(self.z_shape)))
+
+        # z to block_in
+        self.conv_in = torch.nn.Conv2d(z_channels,
+                                       block_in,
+                                       kernel_size=3,
+                                       stride=1,
+                                       padding=1)
+
+        # middle
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(in_channels=block_in,
+                                       out_channels=block_in,
+                                       temb_channels=self.temb_ch,
+                                       dropout=dropout)
+        self.mid.attn_1 = AttnBlock(block_in)
+        self.mid.block_2 = ResnetBlock(in_channels=block_in,
+                                       out_channels=block_in,
+                                       temb_channels=self.temb_ch,
+                                       dropout=dropout)
+
+        # upsampling
+        self.up = nn.ModuleList()
+        for i_level in reversed(range(self.num_resolutions)):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_out = ch*ch_mult[i_level]
+            for i_block in range(self.num_res_blocks+1):
+                block.append(ResnetBlock(in_channels=block_in,
+                                         out_channels=block_out,
+                                         temb_channels=self.temb_ch,
+                                         dropout=dropout))
+                block_in = block_out
+                if curr_res in attn_resolutions:
+                    attn.append(AttnBlock(block_in))
+            up = nn.Module()
+            up.block = block
+            up.attn = attn
+            if i_level != 0:
+                up.upsample = Upsample(block_in, resamp_with_conv)
+                curr_res = curr_res * 2
+            self.up.insert(0, up) # prepend to get consistent order
+
+        # end
+        self.norm_out = Normalize(block_in)
+        self.conv_out = torch.nn.Conv2d(block_in,
+                                        out_ch,
+                                        kernel_size=3,
+                                        stride=1,
+                                        padding=1)
+
+    def forward(self, z):
+        #assert z.shape[1:] == self.z_shape[1:]
+        self.last_z_shape = z.shape
+
+        # timestep embedding
+        temb = None
+
+        # z to block_in
+        h = self.conv_in(z)
+
+        # middle
+        h = self.mid.block_1(h, temb)
+        h = self.mid.attn_1(h)
+        h = self.mid.block_2(h, temb)
+
+        # upsampling
+        for i_level in reversed(range(self.num_resolutions)):
+            for i_block in range(self.num_res_blocks+1):
+                h = self.up[i_level].block[i_block](h, temb)
+                if len(self.up[i_level].attn) > 0:
+                    h = self.up[i_level].attn[i_block](h)
+            if i_level != 0:
+                h = self.up[i_level].upsample(h)
+
+        # end
+        if self.give_pre_end:
+            return h
+
+        h = self.norm_out(h)
+        h = nonlinearity(h)
+        h = self.conv_out(h)
+        return h
+
+

tokenizer/vqgan/model.py

@@ -0,0 +1,88 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from tokenizer.vqgan.layer import Encoder, Decoder
+from tokenizer.vqgan.quantize import VectorQuantizer2 as VectorQuantizer
+
+
+VQGAN_FROM_TAMING = {
+    'vqgan_imagenet_f16_1024': (
+        'tokenizer/vqgan/configs/vqgan_imagenet_f16_1024.yaml',
+        'pretrained_models/vqgan_imagenet_f16_1024/ckpts/last.pth'),
+    'vqgan_imagenet_f16_16384': (
+        'tokenizer/vqgan/configs/vqgan_imagenet_f16_16384.yaml', 
+        'pretrained_models/vqgan_imagenet_f16_16384/ckpts/last.pth'),
+    'vqgan_openimage_f8_256': (
+        'tokenizer/vqgan/configs/vqgan_openimage_f8_256.yaml', 
+        'pretrained_models/vq-f8-n256/model.pth'),
+    'vqgan_openimage_f8_16384': (
+        'tokenizer/vqgan/configs/vqgan_openimage_f8_16384.yaml',
+        'pretrained_models/vq-f8/model.pth'),
+}
+
+class VQModel(nn.Module):
+    def __init__(self,
+                 ddconfig,
+                 n_embed,
+                 embed_dim,
+                 ckpt_path=None,
+                 ignore_keys=[],
+                 image_key="image",
+                 colorize_nlabels=None,
+                 monitor=None,
+                 remap=None,
+                 sane_index_shape=False,  # tell vector quantizer to return indices as bhw
+                 **kwargs,
+                 ):
+        super().__init__()
+        self.image_key = image_key
+        self.encoder = Encoder(**ddconfig)
+        self.decoder = Decoder(**ddconfig)
+        self.quantize = VectorQuantizer(n_embed, embed_dim, beta=0.25,
+                                        remap=remap, sane_index_shape=sane_index_shape)
+        self.quant_conv = torch.nn.Conv2d(ddconfig["z_channels"], embed_dim, 1)
+        self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1)
+        if ckpt_path is not None:
+            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
+        self.image_key = image_key
+        if colorize_nlabels is not None:
+            assert type(colorize_nlabels)==int
+            self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1))
+        if monitor is not None:
+            self.monitor = monitor
+
+    def init_from_ckpt(self, path, ignore_keys=list(), logging=True):
+        model_weight = torch.load(path, map_location="cpu")["state_dict"]
+        keys = list(model_weight.keys())
+        for k in keys:
+            for ik in ignore_keys:
+                if k.startswith(ik):
+                    print("Deleting key {} from state_dict.".format(k))
+                    del model_weight[k]
+        missing, unexpected = self.load_state_dict(model_weight, strict=False)
+        if logging:
+            print(f"Restored from {path}")
+            print(f"Missing Keys in State Dict: {missing}")
+            print(f"Unexpected Keys in State Dict: {unexpected}")
+
+    def encode(self, x):
+        h = self.encoder(x)
+        h = self.quant_conv(h)
+        quant, emb_loss, info = self.quantize(h)
+        return quant, emb_loss, info
+
+    def decode(self, quant):
+        quant = self.post_quant_conv(quant)
+        dec = self.decoder(quant)
+        return dec
+
+    def decode_code(self, code_b, shape, channel_first=True):
+        quant_b = self.quantize.get_codebook_entry(code_b, shape, channel_first)
+        dec = self.decode(quant_b)
+        return dec
+
+    def forward(self, input):
+        quant, diff, _ = self.encode(input)
+        dec = self.decode(quant)
+        return dec, diff

tokenizer/vqgan/quantize.py

@@ -0,0 +1,229 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from torch import einsum
+from einops import rearrange
+
+
+class VectorQuantizer(nn.Module):
+    """
+    see https://github.com/MishaLaskin/vqvae/blob/d761a999e2267766400dc646d82d3ac3657771d4/models/quantizer.py
+    ____________________________________________
+    Discretization bottleneck part of the VQ-VAE.
+    Inputs:
+    - n_e : number of embeddings
+    - e_dim : dimension of embedding
+    - beta : commitment cost used in loss term, beta * ||z_e(x)-sg[e]||^2
+    _____________________________________________
+    """
+
+    # NOTE: this class contains a bug regarding beta; see VectorQuantizer2 for
+    # a fix and use legacy=False to apply that fix. VectorQuantizer2 can be
+    # used wherever VectorQuantizer has been used before and is additionally
+    # more efficient.
+    def __init__(self, n_e, e_dim, beta):
+        super(VectorQuantizer, self).__init__()
+        self.n_e = n_e
+        self.e_dim = e_dim
+        self.beta = beta
+
+        self.embedding = nn.Embedding(self.n_e, self.e_dim)
+        self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e)
+
+    def forward(self, z):
+        """
+        Inputs the output of the encoder network z and maps it to a discrete
+        one-hot vector that is the index of the closest embedding vector e_j
+        z (continuous) -> z_q (discrete)
+        z.shape = (batch, channel, height, width)
+        quantization pipeline:
+            1. get encoder input (B,C,H,W)
+            2. flatten input to (B*H*W,C)
+        """
+        # reshape z -> (batch, height, width, channel) and flatten
+        z = z.permute(0, 2, 3, 1).contiguous()
+        z_flattened = z.view(-1, self.e_dim)
+        # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
+
+        d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \
+            torch.sum(self.embedding.weight**2, dim=1) - 2 * \
+            torch.matmul(z_flattened, self.embedding.weight.t())
+
+        ## could possible replace this here
+        # #\start...
+        # find closest encodings
+        min_encoding_indices = torch.argmin(d, dim=1).unsqueeze(1)
+
+        min_encodings = torch.zeros(
+            min_encoding_indices.shape[0], self.n_e).to(z)
+        min_encodings.scatter_(1, min_encoding_indices, 1)
+
+        # dtype min encodings: torch.float32
+        # min_encodings shape: torch.Size([2048, 512])
+        # min_encoding_indices.shape: torch.Size([2048, 1])
+
+        # get quantized latent vectors
+        z_q = torch.matmul(min_encodings, self.embedding.weight).view(z.shape)
+        #.........\end
+
+        # with:
+        # .........\start
+        #min_encoding_indices = torch.argmin(d, dim=1)
+        #z_q = self.embedding(min_encoding_indices)
+        # ......\end......... (TODO)
+
+        # compute loss for embedding
+        loss = torch.mean((z_q.detach()-z)**2) + self.beta * \
+            torch.mean((z_q - z.detach()) ** 2)
+
+        # preserve gradients
+        z_q = z + (z_q - z).detach()
+
+        # perplexity
+        e_mean = torch.mean(min_encodings, dim=0)
+        perplexity = torch.exp(-torch.sum(e_mean * torch.log(e_mean + 1e-10)))
+
+        # reshape back to match original input shape
+        z_q = z_q.permute(0, 3, 1, 2).contiguous()
+
+        return z_q, loss, (perplexity, min_encodings, min_encoding_indices)
+
+    def get_codebook_entry(self, indices, shape):
+        # shape specifying (batch, height, width, channel)
+        # TODO: check for more easy handling with nn.Embedding
+        min_encodings = torch.zeros(indices.shape[0], self.n_e).to(indices)
+        min_encodings.scatter_(1, indices[:,None], 1)
+
+        # get quantized latent vectors
+        z_q = torch.matmul(min_encodings.float(), self.embedding.weight)
+
+        if shape is not None:
+            z_q = z_q.view(shape)
+
+            # reshape back to match original input shape
+            z_q = z_q.permute(0, 3, 1, 2).contiguous()
+
+        return z_q
+
+
+class VectorQuantizer2(nn.Module):
+    """
+    Improved version over VectorQuantizer, can be used as a drop-in replacement. Mostly
+    avoids costly matrix multiplications and allows for post-hoc remapping of indices.
+    """
+    # NOTE: due to a bug the beta term was applied to the wrong term. for
+    # backwards compatibility we use the buggy version by default, but you can
+    # specify legacy=False to fix it.
+    def __init__(self, n_e, e_dim, beta, remap=None, unknown_index="random",
+                 sane_index_shape=False, legacy=True):
+        super().__init__()
+        self.n_e = n_e
+        self.e_dim = e_dim
+        self.beta = beta
+        self.legacy = legacy
+
+        self.embedding = nn.Embedding(self.n_e, self.e_dim)
+        self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e)
+
+        self.remap = remap
+        if self.remap is not None:
+            self.register_buffer("used", torch.tensor(np.load(self.remap)))
+            self.re_embed = self.used.shape[0]
+            self.unknown_index = unknown_index # "random" or "extra" or integer
+            if self.unknown_index == "extra":
+                self.unknown_index = self.re_embed
+                self.re_embed = self.re_embed+1
+            print(f"Remapping {self.n_e} indices to {self.re_embed} indices. "
+                  f"Using {self.unknown_index} for unknown indices.")
+        else:
+            self.re_embed = n_e
+
+        self.sane_index_shape = sane_index_shape
+
+    def remap_to_used(self, inds):
+        ishape = inds.shape
+        assert len(ishape)>1
+        inds = inds.reshape(ishape[0],-1)
+        used = self.used.to(inds)
+        match = (inds[:,:,None]==used[None,None,...]).long()
+        new = match.argmax(-1)
+        unknown = match.sum(2)<1
+        if self.unknown_index == "random":
+            new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device)
+        else:
+            new[unknown] = self.unknown_index
+        return new.reshape(ishape)
+
+    def unmap_to_all(self, inds):
+        ishape = inds.shape
+        assert len(ishape)>1
+        inds = inds.reshape(ishape[0],-1)
+        used = self.used.to(inds)
+        if self.re_embed > self.used.shape[0]: # extra token
+            inds[inds>=self.used.shape[0]] = 0 # simply set to zero
+        back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds)
+        return back.reshape(ishape)
+
+    def forward(self, z, temp=None, rescale_logits=False, return_logits=False):
+        assert temp is None or temp==1.0, "Only for interface compatible with Gumbel"
+        assert rescale_logits==False, "Only for interface compatible with Gumbel"
+        assert return_logits==False, "Only for interface compatible with Gumbel"
+        # reshape z -> (batch, height, width, channel) and flatten
+        z = rearrange(z, 'b c h w -> b h w c').contiguous()
+        z_flattened = z.view(-1, self.e_dim)
+        # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
+
+        d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \
+            torch.sum(self.embedding.weight**2, dim=1) - 2 * \
+            torch.einsum('bd,dn->bn', z_flattened, rearrange(self.embedding.weight, 'n d -> d n'))
+
+        min_encoding_indices = torch.argmin(d, dim=1)
+        z_q = self.embedding(min_encoding_indices).view(z.shape)
+        perplexity = None
+        min_encodings = None
+
+        # compute loss for embedding
+        if not self.legacy:
+            loss = self.beta * torch.mean((z_q.detach()-z)**2) + \
+                   torch.mean((z_q - z.detach()) ** 2)
+        else:
+            loss = torch.mean((z_q.detach()-z)**2) + self.beta * \
+                   torch.mean((z_q - z.detach()) ** 2)
+
+        # preserve gradients
+        z_q = z + (z_q - z).detach()
+
+        # reshape back to match original input shape
+        z_q = rearrange(z_q, 'b h w c -> b c h w').contiguous()
+
+        if self.remap is not None:
+            min_encoding_indices = min_encoding_indices.reshape(z.shape[0],-1) # add batch axis
+            min_encoding_indices = self.remap_to_used(min_encoding_indices)
+            min_encoding_indices = min_encoding_indices.reshape(-1,1) # flatten
+
+        if self.sane_index_shape:
+            min_encoding_indices = min_encoding_indices.reshape(
+                z_q.shape[0], z_q.shape[2], z_q.shape[3])
+
+        return z_q, loss, (perplexity, min_encodings, min_encoding_indices)
+
+    def get_codebook_entry(self, indices, shape, channel_first=True):
+        # shape = (batch, channel, height, width) if channel_first else (batch, height, width, channel)
+        if self.remap is not None:
+            indices = indices.reshape(shape[0],-1) # add batch axis
+            indices = self.unmap_to_all(indices)
+            indices = indices.reshape(-1) # flatten again
+
+        # get quantized latent vectors
+        z_q = self.embedding(indices)  # (b*h*w, c)
+
+        if shape is not None:
+            if channel_first:
+                z_q = z_q.reshape(shape[0], shape[2], shape[3], shape[1])
+                # reshape back to match original input shape
+                z_q = z_q.permute(0, 3, 1, 2).contiguous()
+            else:
+                z_q = z_q.view(shape)
+
+        return z_q

tokenizer/vqgan/reconstruction_vqgan_ddp.py

@@ -0,0 +1,215 @@
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.utils.data import Dataset, DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torchvision.datasets import ImageFolder
+from torchvision import transforms
+from tqdm import tqdm
+import os
+from PIL import Image
+import numpy as np
+import itertools
+import argparse
+import random
+
+from skimage.metrics import peak_signal_noise_ratio as psnr_loss
+from skimage.metrics import structural_similarity as ssim_loss
+from omegaconf import OmegaConf
+from tokenizer.vqgan.model import VQModel
+from tokenizer.vqgan.model import VQGAN_FROM_TAMING
+
+
+class SingleFolderDataset(Dataset):
+    def __init__(self, directory, transform=None):
+        super().__init__()
+        self.directory = directory
+        self.transform = transform
+        self.image_paths = [os.path.join(directory, file_name) for file_name in os.listdir(directory)
+                            if os.path.isfile(os.path.join(directory, file_name))]
+
+    def __len__(self):
+        return len(self.image_paths)
+
+    def __getitem__(self, idx):
+        image_path = self.image_paths[idx]
+        image = Image.open(image_path).convert('RGB')
+        if self.transform:
+            image = self.transform(image)
+        return image, torch.tensor(0)
+
+
+def create_npz_from_sample_folder(sample_dir, num=50_000):
+    """
+    Builds a single .npz file from a folder of .png samples.
+    """
+    samples = []
+    for i in tqdm(range(num), desc="Building .npz file from samples"):
+        sample_pil = Image.open(f"{sample_dir}/{i:06d}.png")
+        sample_np = np.asarray(sample_pil).astype(np.uint8)
+        samples.append(sample_np)
+
+    random.shuffle(samples) # This is very important for IS(Inception Score) !!!
+    samples = np.stack(samples)
+    assert samples.shape == (num, samples.shape[1], samples.shape[2], 3)
+    npz_path = f"{sample_dir}.npz"
+    np.savez(npz_path, arr_0=samples)
+    print(f"Saved .npz file to {npz_path} [shape={samples.shape}].")
+    return npz_path
+
+
+def center_crop_arr(pil_image, image_size):
+    """
+    Center cropping implementation from ADM.
+    https://github.com/openai/guided-diffusion/blob/8fb3ad9197f16bbc40620447b2742e13458d2831/guided_diffusion/image_datasets.py#L126
+    """
+    while min(*pil_image.size) >= 2 * image_size:
+        pil_image = pil_image.resize(
+            tuple(x // 2 for x in pil_image.size), resample=Image.BOX
+        )
+
+    scale = image_size / min(*pil_image.size)
+    pil_image = pil_image.resize(
+        tuple(round(x * scale) for x in pil_image.size), resample=Image.BICUBIC
+    )
+
+    arr = np.array(pil_image)
+    crop_y = (arr.shape[0] - image_size) // 2
+    crop_x = (arr.shape[1] - image_size) // 2
+    return Image.fromarray(arr[crop_y: crop_y + image_size, crop_x: crop_x + image_size])
+
+
+def main(args):
+    # Setup PyTorch:
+    assert torch.cuda.is_available(), "Sampling with DDP requires at least one GPU. sample.py supports CPU-only usage"
+    torch.set_grad_enabled(False)
+
+    # Setup DDP:
+    dist.init_process_group("nccl")
+    rank = dist.get_rank()
+    device = rank % torch.cuda.device_count()
+    seed = args.global_seed * dist.get_world_size() + rank
+    torch.manual_seed(seed)
+    torch.cuda.set_device(device)
+    print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+
+    # create and load vqgan
+    cfg, ckpt = VQGAN_FROM_TAMING[args.vqgan]
+    config = OmegaConf.load(cfg)
+    vq_model = VQModel(**config.model.get("params", dict())).to(device)
+    vq_model.init_from_ckpt(ckpt, logging=False)
+    vq_model.eval()
+
+    # Create folder to save samples:
+    folder_name = f"{args.vqgan}-{args.dataset}-size-{args.image_size}-seed-{args.global_seed}"
+    sample_folder_dir = f"{args.sample_dir}/{folder_name}"
+    if rank == 0:
+        os.makedirs(sample_folder_dir, exist_ok=True)
+        print(f"Saving .png samples at {sample_folder_dir}")
+    dist.barrier()
+
+    # Setup data:
+    transform = transforms.Compose([
+        transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, args.image_size)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+    ])
+
+    if args.dataset == 'imagenet':
+        dataset = ImageFolder(args.data_path, transform=transform)
+        num_fid_samples = 50000
+    elif args.dataset == 'coco':
+        dataset = SingleFolderDataset(args.data_path, transform=transform)
+        num_fid_samples = 5000
+    else:
+        raise Exception("please check dataset")
+    
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=False,
+        seed=args.global_seed
+    )
+    loader = DataLoader(
+        dataset,
+        batch_size=args.per_proc_batch_size,
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=False
+    )    
+
+    # Figure out how many samples we need to generate on each GPU and how many iterations we need to run:
+    n = args.per_proc_batch_size
+    global_batch_size = n * dist.get_world_size()
+    
+    psnr_val_rgb = []
+    ssim_val_rgb = []
+    loader = tqdm(loader) if rank == 0 else loader
+    total = 0
+    for x, _ in loader:
+        rgb_gts = x
+        rgb_gts = (rgb_gts.permute(0, 2, 3, 1).to("cpu").numpy() + 1.0) / 2.0 # rgb_gt value is between [0, 1]
+        x = x.to(device)
+        with torch.no_grad():
+            latent, _, [_, _, indices] = vq_model.encode(x)
+            samples = vq_model.decode_code(indices, latent.shape) # output value is between [-1, 1]
+        samples = torch.clamp(127.5 * samples + 128.0, 0, 255).permute(0, 2, 3, 1).to("cpu", dtype=torch.uint8).numpy()
+        
+        # Save samples to disk as individual .png files
+        for i, (sample, rgb_gt) in enumerate(zip(samples, rgb_gts)):
+            index = i * dist.get_world_size() + rank + total
+            Image.fromarray(sample).save(f"{sample_folder_dir}/{index:06d}.png")
+            # metric
+            rgb_restored = sample.astype(np.float32) / 255. # rgb_restored value is between [0, 1]
+            psnr = psnr_loss(rgb_restored, rgb_gt)
+            ssim = ssim_loss(rgb_restored, rgb_gt, multichannel=True, data_range=2.0, channel_axis=-1)
+            psnr_val_rgb.append(psnr)
+            ssim_val_rgb.append(ssim)
+        total += global_batch_size
+
+    # ------------------------------------
+    #       Summary
+    # ------------------------------------
+    # Make sure all processes have finished saving their samples
+    dist.barrier()
+    world_size = dist.get_world_size()
+    gather_psnr_val = [None for _ in range(world_size)]
+    gather_ssim_val = [None for _ in range(world_size)]
+    dist.all_gather_object(gather_psnr_val, psnr_val_rgb)
+    dist.all_gather_object(gather_ssim_val, ssim_val_rgb)
+
+    if rank == 0:
+        gather_psnr_val = list(itertools.chain(*gather_psnr_val))
+        gather_ssim_val = list(itertools.chain(*gather_ssim_val))        
+        psnr_val_rgb = sum(gather_psnr_val) / len(gather_psnr_val)
+        ssim_val_rgb = sum(gather_ssim_val) / len(gather_ssim_val)
+        print("PSNR: %f, SSIM: %f " % (psnr_val_rgb, ssim_val_rgb))
+
+        result_file = f"{sample_folder_dir}_results.txt"
+        print("writing results to {}".format(result_file))
+        with open(result_file, 'w') as f:
+            print("PSNR: %f, SSIM: %f " % (psnr_val_rgb, ssim_val_rgb), file=f)
+
+        create_npz_from_sample_folder(sample_folder_dir, num_fid_samples)
+        print("Done.")
+    
+    dist.barrier()
+    dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-path", type=str, required=True)
+    parser.add_argument("--dataset", type=str, choices=['imagenet', 'coco'], default='imagenet')
+    parser.add_argument("--vqgan", type=str, choices=list(VQGAN_FROM_TAMING.keys()), default="vqgan_imagenet_f16_16384")
+    parser.add_argument("--image-size", type=int, choices=[256, 512], default=256)
+    parser.add_argument("--sample-dir", type=str, default="reconstructions")
+    parser.add_argument("--per-proc-batch-size", type=int, default=32)
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=4)
+    args = parser.parse_args()
+    main(args)

tokenizer/vqgan/taming_vqgan_demo.py

@@ -0,0 +1,68 @@
+import argparse
+import torch
+import torch.nn.functional as F
+import numpy as np
+from PIL import Image
+from omegaconf import OmegaConf
+from tokenizer.vqgan.model import VQModel
+from tokenizer.vqgan.model import VQGAN_FROM_TAMING
+
+# before running demo, make sure to:
+# (1) download all needed models from https://github.com/CompVis/taming-transformers and put in pretrained_models/
+# (2) pip install pytorch_lightning
+# (3) python3 tools/convert_pytorch_lightning_to_torch.py
+# (4) pip uninstall pytorch_lightning
+
+
+def main(args):
+    # Setup PyTorch:
+    torch.manual_seed(args.seed)
+    torch.set_grad_enabled(False)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    
+    # create and load model
+    cfg, ckpt = VQGAN_FROM_TAMING[args.vqgan]
+    config = OmegaConf.load(cfg)
+    model = VQModel(**config.model.get("params", dict()))
+    model.init_from_ckpt(ckpt)
+    model.to(device)
+    model.eval()
+
+    # load image
+    img_path = args.image_path
+    out_path = args.image_path.replace('.jpg', '_vqgan.jpg').replace('.jpeg', '_vqgan.jpeg').replace('.png', '_vqgan.png')
+    input_size = args.image_size
+    img = Image.open(img_path).convert("RGB")
+
+    # preprocess
+    size_org = img.size
+    img = img.resize((input_size, input_size))
+    img = np.array(img) / 255.
+    x = 2.0 * img - 1.0 # x value is between [-1, 1]
+    x = torch.tensor(x)
+    x = x.unsqueeze(dim=0)
+    x = torch.einsum('nhwc->nchw', x)
+    x_input = x.float().to("cuda")
+
+    # inference
+    with torch.no_grad():
+        latent, _, [_, _, indices] = model.encode(x_input)
+        output = model.decode_code(indices, latent.shape) # output value is between [-1, 1]
+
+    # postprocess
+    output = F.interpolate(output, size=[size_org[1], size_org[0]], mode='bilinear').permute(0, 2, 3, 1)[0]
+    sample = torch.clamp(127.5 * output + 128.0, 0, 255).to("cpu", dtype=torch.uint8).numpy()
+
+    # save        
+    Image.fromarray(sample).save(out_path)
+    print("Reconstructed image is saved to {}".format(out_path))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--image-path", type=str, default="assets/example.jpg")
+    parser.add_argument("--vqgan", type=str, choices=list(VQGAN_FROM_TAMING.keys()), default="vqgan_openimage_f8_16384")
+    parser.add_argument("--image-size", type=int, choices=[256, 512, 1024], default=512)
+    parser.add_argument("--seed", type=int, default=0)
+    args = parser.parse_args()
+    main(args)

tools/check_image_codes.py

@@ -0,0 +1,55 @@
+import argparse
+import torch
+import numpy as np
+
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from torchvision.utils import save_image
+
+
+def main(args):
+    # Setup PyTorch:
+    torch.manual_seed(args.seed)
+    torch.set_grad_enabled(False)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    
+    # create and load model
+    vq_model = VQ_models[args.vq_model](
+        codebook_size=args.codebook_size,
+        codebook_embed_dim=args.codebook_embed_dim)
+    vq_model.to(device)
+    vq_model.eval()
+    checkpoint = torch.load(args.vq_ckpt, map_location="cpu")
+    vq_model.load_state_dict(checkpoint["model"])
+    del checkpoint
+
+    # load image code
+    latent_dim = args.codebook_embed_dim
+    latent_size = args.image_size // args.downsample_size
+    codes = torch.from_numpy(np.load(args.code_path)).to(device)
+    if codes.ndim == 3: # flip augmentation
+        qzshape = (codes.shape[1], latent_dim, latent_size, latent_size)
+    else:
+        qzshape = (1, latent_dim, latent_size, latent_size)
+    index_sample = codes.reshape(-1)
+    samples = vq_model.decode_code(index_sample, qzshape) # output value is between [-1, 1]
+
+    # save
+    out_path = "sample_image_code.png"
+    nrow = max(4, int(codes.shape[1]//2))
+    save_image(samples, out_path, nrow=nrow, normalize=True, value_range=(-1, 1))
+    print("Reconstructed image is saved to {}".format(out_path))
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 448, 512], default=256)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--seed", type=int, default=0)
+    args = parser.parse_args()
+    main(args)

tools/convert_pytorch_lightning_to_torch.py

@@ -0,0 +1,25 @@
+import os
+import torch
+
+MODEL_PATH = 'pretrained_models'
+pt_lightnings = [
+    'vqgan_imagenet_f16_1024/ckpts/last.ckpt',
+    'vqgan_imagenet_f16_16384/ckpts/last.ckpt',
+    'vq-f8-n256/model.ckpt',
+    'vq-f8/model.ckpt',
+]
+pts = [
+    'vqgan_imagenet_f16_1024/ckpts/last.pth',
+    'vqgan_imagenet_f16_16384/ckpts/last.pth',
+    'vq-f8-n256/model.pth',
+    'vq-f8/model.pth',
+]
+
+for pt_l, pt in zip(pt_lightnings, pts):
+    pt_l_weight = torch.load(os.path.join(MODEL_PATH, pt_l), map_location='cpu')
+    pt_weight = {
+        'state_dict': pt_l_weight['state_dict']
+    }
+    pt_path = os.path.join(MODEL_PATH, pt)
+    torch.save(pt_weight, pt_path)
+    print(f'saving to {pt_path}')

tools/draw_figure.py

@@ -0,0 +1,141 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+font_size = 14
+
+def fid_scaling_law_no_cfg():
+    # data
+    steps = np.array([50, 100, 200, 300,])
+    loss_b = np.array([41.025, 33.442, 32.105, 32.196])
+    loss_l = np.array([25.889, 24.654, 19.742, 19.070])
+    loss_xl = np.array([19.820, 18.037, 14.772, 15.549])
+
+    steps_ = np.array([50, 200, 300,])
+    loss_xxl = np.array([17.195, 13.997, 14.648])
+    loss_3b = np.array([16.431, 9.949, 9.380])
+    # Plot
+    plt.figure(figsize=(6, 4))
+
+    plt.plot(steps, loss_b, 'o-', label='B', color='red')
+    plt.plot(steps, loss_l, 'o-', label='L', color='orange')
+    plt.plot(steps, loss_xl, 'o-', label='XL', color='green')
+    plt.plot(steps_, loss_xxl, 'o-', label='XXL', color='blue')
+    plt.plot(steps_, loss_3b, 'o-', label='3B', color='purple')
+
+    plt.xlabel('Training Epochs', fontsize=font_size)
+    plt.ylabel('FID', fontsize=font_size)
+    # plt.grid(True)
+    # plt.yscale('log')
+
+    # Customize the plot to match the appearance of the provided figure
+    plt.legend(loc='upper right', framealpha=0.5, fontsize=font_size, facecolor='white')
+
+    # Customizing the x and y axis ticks (to match the example's steps)
+    # plt.xticks(np.linspace(0, 800000, 5), ['0', '200K', '400K', '600K', '800K'])
+    plt.yticks(np.arange(5, 50, step=5))
+
+    # Show plot
+    plt.tight_layout()
+    plt.savefig('fid_scaling_law_no_cfg.png', dpi=600)
+
+
+
+def fid_scaling_law_cfg():
+    # data
+    steps = np.array([50, 100, 200, 300,])
+    loss_b_cfg = np.array([8.309, 7.256, 6.542, 6.249])
+    loss_l_cfg = np.array([4.240, 3.705, 3.220, 3.075])
+    loss_xl_cfg = np.array([3.420, 3.089, 2.617, 2.629])
+
+    steps_ = np.array([50, 200, 300,])
+    loss_xxl_cfg = np.array([2.893, 2.331, 2.340])
+    loss_3b_cfg = np.array([2.611, 2.381, 2.329])
+    # Plot
+    plt.figure(figsize=(6, 4))
+
+    plt.plot(steps, loss_b_cfg, 'o-', label='B', color='red')
+    plt.plot(steps, loss_l_cfg, 'o-', label='L', color='orange')
+    plt.plot(steps, loss_xl_cfg, 'o-', label='XL', color='green')
+    plt.plot(steps_, loss_xxl_cfg, 'o-', label='XXL', color='blue')
+    plt.plot(steps_, loss_3b_cfg, 'o-', label='3B', color='purple')
+
+    plt.xlabel('Training Epochs', fontsize=font_size)
+    plt.ylabel('FID', fontsize=font_size)
+    # plt.grid(True)
+    # plt.yscale('log')
+
+    # Customize the plot to match the appearance of the provided figure
+    plt.legend(loc='upper right', framealpha=0.5, fontsize=font_size, facecolor='white')
+
+    # Customizing the x and y axis ticks (to match the example's steps)
+    # plt.xticks(np.linspace(0, 800000, 5), ['0', '200K', '400K', '600K', '800K'])
+    plt.yticks(np.arange(2, 9, step=1))
+
+    # Show plot
+    plt.tight_layout()
+    plt.savefig('fid_scaling_law_cfg.png', dpi=600)
+
+
+
+def sample_topk():
+    # Data
+    top_k = np.array([16384, 10000, 8000, 6000, 4000, 2000, 1000])
+    fid_values = np.array([3.075, 3.369, 3.643, 3.969, 4.635, 5.998, 7.428])
+    inception_scores = np.array([256.067, 265.222, 268.237, 270.159, 271.455, 267.278, 251.268])
+
+    fig, ax1 = plt.subplots()
+    # Create first y-axis
+    ax1.set_xlabel('top-k', fontsize=font_size)
+    ax1.set_ylabel('FID', color='teal', fontsize=font_size)
+    ax1.plot(top_k, fid_values, 'o-', color='teal', label="FID")
+    ax1.tick_params(axis='y', labelcolor='teal')
+    ax1.tick_params(axis='x')
+
+    # Create second y-axis
+    ax2 = ax1.twinx()
+    ax2.set_ylabel('Inception Score', color='brown', fontsize=font_size)
+    ax2.plot(top_k, inception_scores, 'o-', color='brown', label="Inception Score")
+    ax2.tick_params(axis='y', labelcolor='brown')
+
+    # Adding a legend
+    fig.legend(loc='upper right', bbox_to_anchor=(1.0, 1.0), bbox_transform=ax1.transAxes, fontsize=font_size)
+
+    fig.tight_layout()  # Adjust layout to prevent overlap
+    plt.savefig('effect_topk.png', dpi=600)
+
+
+
+def sample_cfg():
+    # Data
+    cfg = np.array([1.5, 1.75, 2.00, 2.25])
+    fid_values = np.array([4.743, 3.151, 3.075, 3.620])
+    inception_scores = np.array([165.381, 214.152, 256.067, 291.695])
+
+    plt.figure(figsize=(10, 4))
+    fig, ax1 = plt.subplots()
+    # Create first y-axis
+    ax1.set_xlabel('cfg', fontsize=font_size)
+    ax1.set_ylabel('FID', color='teal', fontsize=font_size)
+    ax1.plot(cfg, fid_values, 'o-', color='teal', label="FID")
+    ax1.tick_params(axis='y', labelcolor='teal')
+    ax1.tick_params(axis='x')
+
+    # Create second y-axis
+    ax2 = ax1.twinx()
+    ax2.set_ylabel('Inception Score', color='brown', fontsize=font_size)
+    ax2.plot(cfg, inception_scores, 'o-', color='brown', label="Inception Score")
+    ax2.tick_params(axis='y', labelcolor='brown')
+
+    # Adding a legend
+    fig.legend(loc='upper right', bbox_to_anchor=(1.0, 1.0), bbox_transform=ax1.transAxes, fontsize=font_size)
+
+    fig.tight_layout()  # Adjust layout to prevent overlap
+    plt.savefig('effect_cfg.png', dpi=600)
+
+
+
+if __name__ == "__main__":
+    fid_scaling_law_no_cfg()
+    fid_scaling_law_cfg()
+    sample_cfg()
+    sample_topk()

tools/imagenet_en_cn.py

@@ -0,0 +1,1002 @@
+IMAGENET_1K_CLASSES = {
+  0: 'tench, Tinca tinca [丁鲷]',
+  1: 'goldfish, Carassius auratus [金鱼]',
+  2: 'great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias [大白鲨]',
+  3: 'tiger shark, Galeocerdo cuvieri [虎鲨]',
+  4: 'hammerhead, hammerhead shark [锤头鲨]',
+  5: 'electric ray, crampfish, numbfish, torpedo [电鳐]',
+  6: 'stingray [黄貂鱼]',
+  7: 'cock [公鸡]',
+  8: 'hen [母鸡]',
+  9: 'ostrich, Struthio camelus [鸵鸟]',
+  10: 'brambling, Fringilla montifringilla [燕雀]',
+  11: 'goldfinch, Carduelis carduelis [金翅雀]',
+  12: 'house finch, linnet, Carpodacus mexicanus [家朱雀]',
+  13: 'junco, snowbird [灯芯草雀]',
+  14: 'indigo bunting, indigo finch, indigo bird, Passerina cyanea [靛蓝雀,靛蓝鸟]',
+  15: 'robin, American robin, Turdus migratorius [蓝鹀]',
+  16: 'bulbul [夜莺]',
+  17: 'jay [松鸦]',
+  18: 'magpie [喜鹊]',
+  19: 'chickadee [山雀]',
+  20: 'water ouzel, dipper [河鸟]',
+  21: 'kite [鸢（猛禽）]',
+  22: 'bald eagle, American eagle, Haliaeetus leucocephalus [秃头鹰]',
+  23: 'vulture [秃鹫]',
+  24: 'great grey owl, great gray owl, Strix nebulosa [大灰猫头鹰]',
+  25: 'European fire salamander, Salamandra salamandra [欧洲火蝾螈]',
+  26: 'common newt, Triturus vulgaris [普通蝾螈]',
+  27: 'eft [水蜥]',
+  28: 'spotted salamander, Ambystoma maculatum [斑点蝾螈]',
+  29: 'axolotl, mud puppy, Ambystoma mexicanum [蝾螈,泥狗]',
+  30: 'bullfrog, Rana catesbeiana [牛蛙]',
+  31: 'tree frog, tree-frog [树蛙]',
+  32: 'tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui [尾蛙,铃蟾蜍,肋蟾蜍,尾蟾蜍]',
+  33: 'loggerhead, loggerhead turtle, Caretta caretta [红海龟]',
+  34: 'leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea [皮革龟]',
+  35: 'mud turtle [泥龟]',
+  36: 'terrapin [淡水龟]',
+  37: 'box turtle, box tortoise [箱龟]',
+  38: 'banded gecko [带状壁虎]',
+  39: 'common iguana, iguana, Iguana iguana [普通鬣蜥]',
+  40: 'American chameleon, anole, Anolis carolinensis [美国变色龙]',
+  41: 'whiptail, whiptail lizard [鞭尾蜥蜴]',
+  42: 'agama [飞龙科蜥蜴]',
+  43: 'frilled lizard, Chlamydosaurus kingi [褶边蜥蜴]',
+  44: 'alligator lizard [鳄鱼蜥蜴]',
+  45: 'Gila monster, Heloderma suspectum [毒蜥]',
+  46: 'green lizard, Lacerta viridis [绿蜥蜴]',
+  47: 'African chameleon, Chamaeleo chamaeleon [非洲变色龙]',
+  48: 'Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis [科莫多蜥蜴]',
+  49: 'African crocodile, Nile crocodile, Crocodylus niloticus [非洲鳄,尼罗河鳄鱼]',
+  50: 'American alligator, Alligator mississipiensis [美国鳄鱼,鳄鱼]',
+  51: 'triceratops [三角龙]',
+  52: 'thunder snake, worm snake, Carphophis amoenus [雷蛇,蠕虫蛇]',
+  53: 'ringneck snake, ring-necked snake, ring snake [环蛇,环颈蛇]',
+  54: 'hognose snake, puff adder, sand viper [希腊蛇]',
+  55: 'green snake, grass snake [绿蛇,草蛇]',
+  56: 'king snake, kingsnake [国王蛇]',
+  57: 'garter snake, grass snake [袜带蛇,草蛇]',
+  58: 'water snake [水蛇]',
+  59: 'vine snake [藤蛇]',
+  60: 'night snake, Hypsiglena torquata [夜蛇]',
+  61: 'boa constrictor, Constrictor constrictor [大蟒蛇]',
+  62: 'rock python, rock snake, Python sebae [岩石蟒蛇,岩蛇,蟒蛇]',
+  63: 'Indian cobra, Naja naja [印度眼镜蛇]',
+  64: 'green mamba [绿曼巴]',
+  65: 'sea snake [海蛇]',
+  66: 'horned viper, cerastes, sand viper, horned asp, Cerastes cornutus [角腹蛇]',
+  67: 'diamondback, diamondback rattlesnake, Crotalus adamanteus [菱纹响尾蛇]',
+  68: 'sidewinder, horned rattlesnake, Crotalus cerastes [角响尾蛇]',
+  69: 'trilobite [三叶虫]',
+  70: 'harvestman, daddy longlegs, Phalangium opilio [盲蜘蛛]',
+  71: 'scorpion [蝎子]',
+  72: 'black and gold garden spider, Argiope aurantia [黑金花园蜘蛛]',
+  73: 'barn spider, Araneus cavaticus [谷仓蜘蛛]',
+  74: 'garden spider, Aranea diademata [花园蜘蛛]',
+  75: 'black widow, Latrodectus mactans [黑寡妇蜘蛛]',
+  76: 'tarantula [狼蛛]',
+  77: 'wolf spider, hunting spider [狼蜘蛛,狩猎蜘蛛]',
+  78: 'tick [壁虱]',
+  79: 'centipede [蜈蚣]',
+  80: 'black grouse [黑松鸡]',
+  81: 'ptarmigan [松鸡,雷鸟]',
+  82: 'ruffed grouse, partridge, Bonasa umbellus [披肩鸡,披肩榛鸡]',
+  83: 'prairie chicken, prairie grouse, prairie fowl [草原鸡,草原松鸡]',
+  84: 'peacock [孔雀]',
+  85: 'quail [鹌鹑]',
+  86: 'partridge [鹧鸪]',
+  87: 'African grey, African gray, Psittacus erithacus [非洲灰鹦鹉]',
+  88: 'macaw [金刚鹦鹉]',
+  89: 'sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita [硫冠鹦鹉]',
+  90: 'lorikeet [短尾鹦鹉]',
+  91: 'coucal [褐翅鸦鹃]',
+  92: 'bee eater [蜜蜂]',
+  93: 'hornbill [犀鸟]',
+  94: 'hummingbird [蜂鸟]',
+  95: 'jacamar [鹟䴕]',
+  96: 'toucan [犀鸟]',
+  97: 'drake [野鸭]',
+  98: 'red-breasted merganser, Mergus serrator [���胸秋沙鸭]',
+  99: 'goose [鹅]',
+  100: 'black swan, Cygnus atratus [黑天鹅]',
+  101: 'tusker [大象]',
+  102: 'echidna, spiny anteater, anteater [针鼹鼠]',
+  103: 'platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus [鸭嘴兽]',
+  104: 'wallaby, brush kangaroo [沙袋鼠]',
+  105: 'koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus [考拉,考拉熊]',
+  106: 'wombat [袋熊]',
+  107: 'jellyfish [水母]',
+  108: 'sea anemone, anemone [海葵]',
+  109: 'brain coral [脑珊瑚]',
+  110: 'flatworm, platyhelminth [扁形虫扁虫]',
+  111: 'nematode, nematode worm, roundworm [线虫,蛔虫]',
+  112: 'conch [海螺]',
+  113: 'snail [蜗牛]',
+  114: 'slug [鼻涕虫]',
+  115: 'sea slug, nudibranch [海参]',
+  116: 'chiton, coat-of-mail shell, sea cradle, polyplacophore [石鳖]',
+  117: 'chambered nautilus, pearly nautilus, nautilus [鹦鹉螺]',
+  118: 'Dungeness crab, Cancer magister [珍宝蟹]',
+  119: 'rock crab, Cancer irroratus [石蟹]',
+  120: 'fiddler crab [招潮蟹]',
+  121: 'king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica [帝王蟹,阿拉斯加蟹,阿拉斯加帝王蟹]',
+  122: 'American lobster, Northern lobster, Maine lobster, Homarus americanus [美国龙虾,缅因州龙虾]',
+  123: 'spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish [大螯虾]',
+  124: 'crayfish, crawfish, crawdad, crawdaddy [小龙虾]',
+  125: 'hermit crab [寄居蟹]',
+  126: 'isopod [等足目动物(明虾和螃蟹近亲)]',
+  127: 'white stork, Ciconia ciconia [白鹳]',
+  128: 'black stork, Ciconia nigra [黑鹳]',
+  129: 'spoonbill [鹭]',
+  130: 'flamingo [火烈鸟]',
+  131: 'little blue heron, Egretta caerulea [小蓝鹭]',
+  132: 'American egret, great white heron, Egretta albus [美国鹭,大白鹭]',
+  133: 'bittern [麻鸦]',
+  134: 'crane [鹤]',
+  135: 'limpkin, Aramus pictus [秧鹤]',
+  136: 'European gallinule, Porphyrio porphyrio [欧洲水鸡,紫水鸡]',
+  137: 'American coot, marsh hen, mud hen, water hen, Fulica americana [沼泽泥母鸡,水母鸡]',
+  138: 'bustard [鸨]',
+  139: 'ruddy turnstone, Arenaria interpres [红翻石鹬]',
+  140: 'red-backed sandpiper, dunlin, Erolia alpina [红背鹬,黑腹滨鹬]',
+  141: 'redshank, Tringa totanus [红脚鹬]',
+  142: 'dowitcher [半蹼鹬]',
+  143: 'oystercatcher, oyster catcher [蛎鹬]',
+  144: 'pelican [鹈鹕]',
+  145: 'king penguin, Aptenodytes patagonica [国王企鹅]',
+  146: 'albatross, mollymawk [信天翁,大海鸟]',
+  147: 'grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus [灰鲸]',
+  148: 'killer whale, killer, orca, grampus, sea wolf, Orcinus orca [杀人鲸,逆戟鲸,虎鲸]',
+  149: 'dugong, Dugong dugon [海牛]',
+  150: 'sea lion [海狮]',
+  151: 'Chihuahua [奇瓦瓦]',
+  152: 'Japanese spaniel [日本猎犬]',
+  153: 'Maltese dog, Maltese terrier, Maltese [马尔济斯犬]',
+  154: 'Pekinese, Pekingese, Peke [狮子狗]',
+  155: 'Shih-Tzu [西施犬]',
+  156: 'Blenheim spaniel [布莱尼姆猎犬]',
+  157: 'papillon [巴比狗]',
+  158: 'toy terrier [玩具犬]',
+  159: 'Rhodesian ridgeback [罗得西亚长背猎狗]',
+  160: 'Afghan hound, Afghan [阿富汗猎犬]',
+  161: 'basset, basset hound [猎犬]',
+  162: 'beagle [比格犬,猎兔犬]',
+  163: 'bloodhound, sleuthhound [侦探犬]',
+  164: 'bluetick [蓝色快狗]',
+  165: 'black-and-tan coonhound [黑褐猎浣熊犬]',
+  166: 'Walker hound, Walker foxhound [沃克猎犬]',
+  167: 'English foxhound [英国猎狐犬]',
+  168: 'redbone [美洲赤狗]',
+  169: 'borzoi, Russian wolfhound [俄罗斯猎狼犬]',
+  170: 'Irish wolfhound [爱尔兰猎狼犬]',
+  171: 'Italian greyhound [意大利灰狗]',
+  172: 'whippet [惠比特犬]',
+  173: 'Ibizan hound, Ibizan Podenco [依比沙猎犬]',
+  174: 'Norwegian elkhound, elkhound [挪威猎犬]',
+  175: 'otterhound, otter hound [奥达猎犬,水獭猎犬]',
+  176: 'Saluki, gazelle hound [沙克犬,瞪羚猎犬]',
+  177: 'Scottish deerhound, deerhound [苏格兰猎鹿犬,猎鹿犬]',
+  178: 'Weimaraner [威玛猎犬]',
+  179: 'Staffordshire bullterrier, Staffordshire bull terrier [斯塔福德郡牛头梗,斯塔福德郡斗牛梗]',
+  180: 'American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier [美国斯塔福德郡梗,美国比特斗牛梗,斗牛梗]',
+  181: 'Bedlington terrier [贝德灵顿梗]',
+  182: 'Border terrier [边境梗]',
+  183: 'Kerry blue terrier [凯丽蓝梗]',
+  184: 'Irish terrier [爱尔兰梗]',
+  185: 'Norfolk terrier [诺福克梗]',
+  186: 'Norwich terrier [诺维奇梗]',
+  187: 'Yorkshire terrier [约克郡梗]',
+  188: 'wire-haired fox terrier [刚毛猎狐梗]',
+  189: 'Lakeland terrier [莱克兰梗]',
+  190: 'Sealyham terrier, Sealyham [锡利哈姆梗]',
+  191: 'Airedale, Airedale terrier [艾尔谷犬]',
+  192: 'cairn, cairn terrier [凯恩梗]',
+  193: 'Australian terrier [澳大利亚梗]',
+  194: 'Dandie Dinmont, Dandie Dinmont terrier [丹迪丁蒙梗]',
+  195: 'Boston bull, Boston terrier [波士顿梗]',
+  196: 'miniature schnauzer [迷你雪纳瑞犬]',
+  197: 'giant schnauzer [巨型雪纳瑞犬]',
+  198: 'standard schnauzer [标准雪纳瑞犬]',
+  199: 'Scotch terrier, Scottish terrier, Scottie [苏格兰梗]',
+  200: 'Tibetan terrier, chrysanthemum dog [西藏梗,菊花狗]',
+  201: 'silky terrier, Sydney silky [丝毛梗]',
+  202: 'soft-coated wheaten terrier [软毛麦色梗]',
+  203: 'West Highland white terrier [西高地白梗]',
+  204: 'Lhasa, Lhasa apso [拉萨阿普索犬]',
+  205: 'flat-coated retriever [平毛寻回犬]',
+  206: 'curly-coated retriever [卷毛寻回犬]',
+  207: 'golden retriever [金毛猎犬]',
+  208: 'Labrador retriever [拉布拉多猎犬]',
+  209: 'Chesapeake Bay retriever [乞沙比克猎犬]',
+  210: 'German short-haired pointer [德国短毛猎犬]',
+  211: 'vizsla, Hungarian pointer [维兹拉犬]',
+  212: 'English setter [英国谍犬]',
+  213: 'Irish setter, red setter [爱尔兰雪达犬,红色猎犬]',
+  214: 'Gordon setter [戈登雪达犬]',
+  215: 'Brittany spaniel [布列塔尼犬猎犬]',
+  216: 'clumber, clumber spaniel [黄毛,黄毛猎犬]',
+  217: 'English springer, English springer spaniel [英国史宾格犬]',
+  218: 'Welsh springer spaniel [威尔士史宾格犬]',
+  219: 'cocker spaniel, English cocker spaniel, cocker [可卡犬,英国可卡犬]',
+  220: 'Sussex spaniel [萨塞克斯猎犬]',
+  221: 'Irish water spaniel [爱尔兰水猎犬]',
+  222: 'kuvasz [哥威斯犬]',
+  223: 'schipperke [舒柏奇犬]',
+  224: 'groenendael [比利时牧羊犬]',
+  225: 'malinois [马里努阿犬]',
+  226: 'briard [伯瑞犬]',
+  227: 'kelpie [凯尔皮犬]',
+  228: 'komondor [匈牙利牧羊犬]',
+  229: 'Old English sheepdog, bobtail [老英国牧羊犬]',
+  230: 'Shetland sheepdog, Shetland sheep dog, Shetland [喜乐蒂牧羊犬]',
+  231: 'collie [牧羊犬]',
+  232: 'Border collie [边境牧羊犬]',
+  233: 'Bouvier des Flandres, Bouviers des Flandres [法兰德斯牧牛狗]',
+  234: 'Rottweiler [罗特韦尔犬]',
+  235: 'German shepherd, German shepherd dog, German police dog, alsatian [德国牧羊犬,德国警犬,阿尔萨斯]',
+  236: 'Doberman, Doberman pinscher [多伯曼犬,杜宾犬]',
+  237: 'miniature pinscher [迷你杜宾犬]',
+  238: 'Greater Swiss Mountain dog [大瑞士山地犬]',
+  239: 'Bernese mountain dog [伯恩山犬]',
+  240: 'Appenzeller [Appenzeller狗]',
+  241: 'EntleBucher [EntleBucher狗]',
+  242: 'boxer [拳师狗]',
+  243: 'bull mastiff [斗牛獒]',
+  244: 'Tibetan mastiff [藏獒]',
+  245: 'French bulldog [法国斗牛犬]',
+  246: 'Great Dane [大丹犬]',
+  247: 'Saint Bernard, St Bernard [圣伯纳德狗]',
+  248: 'Eskimo dog, husky [爱斯基摩犬,哈士奇]',
+  249: 'malamute, malemute, Alaskan malamute [雪橇犬,阿拉斯加爱斯基摩狗]',
+  250: 'Siberian husky [哈士奇]',
+  251: 'dalmatian, coach dog, carriage dog [达尔马提亚,教练车狗]',
+  252: 'affenpinscher, monkey pinscher, monkey dog [狮毛狗]',
+  253: 'basenji [巴辛吉狗]',
+  254: 'pug, pug-dog [哈巴狗,狮子狗]',
+  255: 'Leonberg [莱昂贝格狗]',
+  256: 'Newfoundland, Newfoundland dog [纽芬兰岛狗]',
+  257: 'Great Pyrenees [大白熊犬]',
+  258: 'Samoyed, Samoyede [萨摩耶犬]',
+  259: 'Pomeranian [博美犬]',
+  260: 'chow, chow chow [松狮,松狮]',
+  261: 'keeshond [荷兰卷尾狮毛狗]',
+  262: 'Brabancon griffon [布鲁塞尔格林芬犬]',
+  263: 'Pembroke, Pembroke Welsh corgi [彭布洛克威尔士科基犬]',
+  264: 'Cardigan, Cardigan Welsh corgi [威尔士柯基犬]',
+  265: 'toy poodle [玩具贵宾犬]',
+  266: 'miniature poodle [迷你贵宾犬]',
+  267: 'standard poodle [标准贵宾犬]',
+  268: 'Mexican hairless [墨西哥无毛犬]',
+  269: 'timber wolf, grey wolf, gray wolf, Canis lupus [灰狼]',
+  270: 'white wolf, Arctic wolf, Canis lupus tundrarum [白狼,北极狼]',
+  271: 'red wolf, maned wolf, Canis rufus, Canis niger [红太狼,鬃狼,犬犬鲁弗斯]',
+  272: 'coyote, prairie wolf, brush wolf, Canis latrans [狼,草原狼,刷狼,郊狼]',
+  273: 'dingo, warrigal, warragal, Canis dingo [澳洲野狗,澳大利亚野犬]',
+  274: 'dhole, Cuon alpinus [豺]',
+  275: 'African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus [非洲猎犬,土狼犬]',
+  276: 'hyena, hyaena [鬣狗]',
+  277: 'red fox, Vulpes vulpes [红狐狸]',
+  278: 'kit fox, Vulpes macrotis [沙狐]',
+  279: 'Arctic fox, white fox, Alopex lagopus [北极狐狸,白狐狸]',
+  280: 'grey fox, gray fox, Urocyon cinereoargenteus [灰狐狸]',
+  281: 'tabby, tabby cat [虎斑猫]',
+  282: 'tiger cat [山猫,虎猫]',
+  283: 'Persian cat [波斯猫]',
+  284: 'Siamese cat, Siamese [暹罗暹罗猫,]',
+  285: 'Egyptian cat [埃及猫]',
+  286: 'cougar, puma, catamount, mountain lion, painter, panther, Felis concolor [美洲狮,美洲豹]',
+  287: 'lynx, catamount [猞猁,山猫]',
+  288: 'leopard, Panthera pardus [豹子]',
+  289: 'snow leopard, ounce, Panthera uncia [雪豹]',
+  290: 'jaguar, panther, Panthera onca, Felis onca [美洲虎]',
+  291: 'lion, king of beasts, Panthera leo [狮子]',
+  292: 'tiger, Panthera tigris [老虎]',
+  293: 'cheetah, chetah, Acinonyx jubatus [猎豹]',
+  294: 'brown bear, bruin, Ursus arctos [棕熊]',
+  295: 'American black bear, black bear, Ursus americanus, Euarctos americanus [美洲黑熊]',
+  296: 'ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus [冰熊,北极熊]',
+  297: 'sloth bear, Melursus ursinus, Ursus ursinus [懒熊]',
+  298: 'mongoose [猫鼬]',
+  299: 'meerkat, mierkat [猫鼬,海猫]',
+  300: 'tiger beetle [虎甲虫]',
+  301: 'ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle [瓢虫]',
+  302: 'ground beetle, carabid beetle [土鳖虫]',
+  303: 'long-horned beetle, longicorn, longicorn beetle [天牛]',
+  304: 'leaf beetle, chrysomelid [龟甲虫]',
+  305: 'dung beetle [粪甲虫]',
+  306: 'rhinoceros beetle [犀牛甲虫]',
+  307: 'weevil [象甲]',
+  308: 'fly [苍蝇]',
+  309: 'bee [蜜蜂]',
+  310: 'ant, emmet, pismire [蚂蚁]',
+  311: 'grasshopper, hopper [蚱蜢]',
+  312: 'cricket [蟋蟀]',
+  313: 'walking stick, walkingstick, stick insect [竹节虫]',
+  314: 'cockroach, roach [蟑螂]',
+  315: 'mantis, mantid [螳螂]',
+  316: 'cicada, cicala [蝉]',
+  317: 'leafhopper [叶蝉]',
+  318: 'lacewing, lacewing fly [草蜻蛉]',
+  319: 'dragonfly, darning needle, devils darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk [蜻蜓]',
+  320: 'damselfly [豆娘,蜻蛉]',
+  321: 'admiral [优红蛱蝶]',
+  322: 'ringlet, ringlet butterfly [小环蝴蝶]',
+  323: 'monarch, monarch butterfly, milkweed butterfly, Danaus plexippus [君主蝴蝶,大斑蝶]',
+  324: 'cabbage butterfly [菜粉蝶]',
+  325: 'sulphur butterfly, sulfur butterfly [白蝴蝶]',
+  326: 'lycaenid, lycaenid butterfly [灰蝶]',
+  327: 'starfish, sea star [海星]',
+  328: 'sea urchin [海胆]',
+  329: 'sea cucumber, holothurian [海参,海黄瓜]',
+  330: 'wood rabbit, cottontail, cottontail rabbit [野兔]',
+  331: 'hare [兔]',
+  332: 'Angora, Angora rabbit [安哥拉兔]',
+  333: 'hamster [仓鼠]',
+  334: 'porcupine, hedgehog [刺猬,豪猪,]',
+  335: 'fox squirrel, eastern fox squirrel, Sciurus niger [黑松鼠]',
+  336: 'marmot [土拨鼠]',
+  337: 'beaver [海狸]',
+  338: 'guinea pig, Cavia cobaya [豚鼠,豚鼠]',
+  339: 'sorrel [栗色马]',
+  340: 'zebra [斑马]',
+  341: 'hog, pig, grunter, squealer, Sus scrofa [猪]',
+  342: 'wild boar, boar, Sus scrofa [野猪]',
+  343: 'warthog [疣猪]',
+  344: 'hippopotamus, hippo, river horse, Hippopotamus amphibius [河马]',
+  345: 'ox [牛]',
+  346: 'water buffalo, water ox, Asiatic buffalo, Bubalus bubalis [水牛,亚洲水牛]',
+  347: 'bison [野牛]',
+  348: 'ram, tup [公羊]',
+  349: 'bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis [大角羊,洛矶山大角羊]',
+  350: 'ibex, Capra ibex [山羊]',
+  351: 'hartebeest [狷羚]',
+  352: 'impala, Aepyceros melampus [黑斑羚]',
+  353: 'gazelle [瞪羚]',
+  354: 'Arabian camel, dromedary, Camelus dromedarius [阿拉伯单峰骆驼,骆驼]',
+  355: 'llama [骆驼]',
+  356: 'weasel [黄鼠狼]',
+  357: 'mink [水貂]',
+  358: 'polecat, fitch, foulmart, foumart, Mustela putorius [臭猫]',
+  359: 'black-footed ferret, ferret, Mustela nigripes [黑足鼬]',
+  360: 'otter [水獭]',
+  361: 'skunk, polecat, wood pussy [臭鼬,木猫]',
+  362: 'badger [獾]',
+  363: 'armadillo [犰狳]',
+  364: 'three-toed sloth, ai, Bradypus tridactylus [树懒]',
+  365: 'orangutan, orang, orangutang, Pongo pygmaeus [猩猩,婆罗洲猩猩]',
+  366: 'gorilla, Gorilla gorilla [大猩猩]',
+  367: 'chimpanzee, chimp, Pan troglodytes [黑猩猩]',
+  368: 'gibbon, Hylobates lar [长臂猿]',
+  369: 'siamang, Hylobates syndactylus, Symphalangus syndactylus [合趾猿长臂猿,合趾猿]',
+  370: 'guenon, guenon monkey [长尾猴]',
+  371: 'patas, hussar monkey, Erythrocebus patas [赤猴]',
+  372: 'baboon [狒狒]',
+  373: 'macaque [恒河猴,猕猴]',
+  374: 'langur [白头叶猴]',
+  375: 'colobus, colobus monkey [疣猴]',
+  376: 'proboscis monkey, Nasalis larvatus [长鼻猴]',
+  377: 'marmoset [狨（美洲产小型长尾猴）]',
+  378: 'capuchin, ringtail, Cebus capucinus [卷尾猴]',
+  379: 'howler monkey, howler [吼猴]',
+  380: 'titi, titi monkey [伶猴]',
+  381: 'spider monkey, Ateles geoffroyi [蜘蛛猴]',
+  382: 'squirrel monkey, Saimiri sciureus [松鼠猴]',
+  383: 'Madagascar cat, ring-tailed lemur, Lemur catta [马达加斯加环尾狐猴,鼠狐猴]',
+  384: 'indri, indris, Indri indri, Indri brevicaudatus [大狐猴,马达加斯加大狐猴]',
+  385: 'Indian elephant, Elephas maximus [印度大象,亚洲象]',
+  386: 'African elephant, Loxodonta africana [非洲象,非洲象]',
+  387: 'lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens [小熊猫]',
+  388: 'giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca [大熊猫]',
+  389: 'barracouta, snoek [杖鱼]',
+  390: 'eel [鳗鱼]',
+  391: 'coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch [银鲑,银鲑鱼]',
+  392: 'rock beauty, Holocanthus tricolor [三色刺蝶鱼]',
+  393: 'anemone fish [海葵鱼]',
+  394: 'sturgeon [鲟鱼]',
+  395: 'gar, garfish, garpike, billfish, Lepisosteus osseus [雀鳝]',
+  396: 'lionfish [狮子鱼]',
+  397: 'puffer, pufferfish, blowfish, globefish [河豚]',
+  398: 'abacus [算盘]',
+  399: 'abaya [长袍]',
+  400: 'academic gown, academic robe, judge robe [学位袍]',
+  401: 'accordion, piano accordion, squeeze box [手风琴]',
+  402: 'acoustic guitar [原声吉他]',
+  403: 'aircraft carrier, carrier, flattop, attack aircraft carrier [航空母舰]',
+  404: 'airliner [客机]',
+  405: 'airship, dirigible [飞艇]',
+  406: 'altar [祭坛]',
+  407: 'ambulance [救护车]',
+  408: 'amphibian, amphibious vehicle [水陆两用车]',
+  409: 'analog clock [模拟时钟]',
+  410: 'apiary, bee house [蜂房]',
+  411: 'apron [围裙]',
+  412: 'ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin [垃圾桶]',
+  413: 'assault rifle, assault gun [攻击步枪,枪]',
+  414: 'backpack, back pack, knapsack, packsack, rucksack, haversack [背包]',
+  415: 'bakery, bakeshop, bakehouse [面包店,面包铺,]',
+  416: 'balance beam, beam [平衡木]',
+  417: 'balloon [热气球]',
+  418: 'ballpoint, ballpoint pen, ballpen, Biro [圆珠笔]',
+  419: 'Band Aid [创可贴]',
+  420: 'banjo [班卓琴]',
+  421: 'bannister, banister, balustrade, balusters, handrail [栏杆,楼梯扶手]',
+  422: 'barbell [杠铃]',
+  423: 'barber chair [理发师的椅子]',
+  424: 'barbershop [理发店]',
+  425: 'barn [牲口棚]',
+  426: 'barometer [晴雨表]',
+  427: 'barrel, cask [圆筒]',
+  428: 'barrow, garden cart, lawn cart, wheelbarrow [园地小车,手推车]',
+  429: 'baseball [棒球]',
+  430: 'basketball [篮球]',
+  431: 'bassinet [婴儿床]',
+  432: 'bassoon [巴松管,低音管]',
+  433: 'bathing cap, swimming cap [游泳帽]',
+  434: 'bath towel [沐浴毛巾]',
+  435: 'bathtub, bathing tub, bath, tub [浴缸,澡盆]',
+  436: 'beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon [沙滩车,旅行车]',
+  437: 'beacon, lighthouse, beacon light, pharos [灯塔]',
+  438: 'beaker [高脚杯]',
+  439: 'bearskin, busby, shako [熊皮高帽]',
+  440: 'beer bottle [啤酒瓶]',
+  441: 'beer glass [啤酒杯]',
+  442: 'bell cote, bell cot [钟塔]',
+  443: 'bib [（小儿用的）围嘴]',
+  444: 'bicycle-built-for-two, tandem bicycle, tandem [串联自行车,]',
+  445: 'bikini, two-piece [比基尼]',
+  446: 'binder, ring-binder [装订册]',
+  447: 'binoculars, field glasses, opera glasses [双筒望远镜]',
+  448: 'birdhouse [鸟舍]',
+  449: 'boathouse [船库]',
+  450: 'bobsled, bobsleigh, bob [雪橇]',
+  451: 'bolo tie, bolo, bola tie, bola [饰扣式领带]',
+  452: 'bonnet, poke bonnet [阔边女帽]',
+  453: 'bookcase [书橱]',
+  454: 'bookshop, bookstore, bookstall [书店,书摊]',
+  455: 'bottlecap [瓶盖]',
+  456: 'bow [弓箭]',
+  457: 'bow tie, bow-tie, bowtie [蝴蝶结领结]',
+  458: 'brass, memorial tablet, plaque [铜制牌位]',
+  459: 'brassiere, bra, bandeau [奶罩]',
+  460: 'breakwater, groin, groyne, mole, bulwark, seawall, jetty [防波堤,海堤]',
+  461: 'breastplate, aegis, egis [铠甲]',
+  462: 'broom [扫帚]',
+  463: 'bucket, pail [桶]',
+  464: 'buckle [扣环]',
+  465: 'bulletproof vest [防弹背心]',
+  466: 'bullet train, bullet [动车,子弹头列车]',
+  467: 'butcher shop, meat market [肉铺,肉菜市场]',
+  468: 'cab, hack, taxi, taxicab [出租车]',
+  469: 'caldron, cauldron [大锅]',
+  470: 'candle, taper, wax light [蜡烛]',
+  471: 'cannon [大炮]',
+  472: 'canoe [独木舟]',
+  473: 'can opener, tin opener [开瓶器,开罐器]',
+  474: 'cardigan [开衫]',
+  475: 'car mirror [车镜]',
+  476: 'carousel, carrousel, merry-go-round, roundabout, whirligig [旋转木马]',
+  477: 'carpenters kit, tool kit [木匠的工具包,工具包]',
+  478: 'carton [纸箱]',
+  479: 'car wheel [车轮]',
+  480: 'cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM [取款机,自动取款机]',
+  481: 'cassette [盒式录音带]',
+  482: 'cassette player [卡带播放器]',
+  483: 'castle [城堡]',
+  484: 'catamaran [双体船]',
+  485: 'CD player [CD播放器]',
+  486: 'cello, violoncello [大提琴]',
+  487: 'cellular telephone, cellular phone, cellphone, cell, mobile phone [移动电话,手机]',
+  488: 'chain [铁链]',
+  489: 'chainlink fence [围栏]',
+  490: 'chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour [链甲]',
+  491: 'chain saw, chainsaw [电锯,油锯]',
+  492: 'chest [箱子]',
+  493: 'chiffonier, commode [衣柜,洗脸台]',
+  494: 'chime, bell, gong [编钟,钟,锣]',
+  495: 'china cabinet, china closet [中国橱柜]',
+  496: 'Christmas stocking [圣诞袜]',
+  497: 'church, church building [教堂,教堂建筑]',
+  498: 'cinema, movie theater, movie theatre, movie house, picture palace [电影院,剧场]',
+  499: 'cleaver, meat cleaver, chopper [切肉刀,菜刀]',
+  500: 'cliff dwelling [悬崖屋]',
+  501: 'cloak [斗篷]',
+  502: 'clog, geta, patten, sabot [木屐,木鞋]',
+  503: 'cocktail shaker [鸡尾酒调酒器]',
+  504: 'coffee mug [咖啡杯]',
+  505: 'coffeepot [咖啡壶]',
+  506: 'coil, spiral, volute, whorl, helix [螺旋结构（楼梯）]',
+  507: 'combination lock [组合锁]',
+  508: 'computer keyboard, keypad [电脑键盘,键盘]',
+  509: 'confectionery, confectionary, candy store [糖果,糖果店]',
+  510: 'container ship, containership, container vessel [集装箱船]',
+  511: 'convertible [敞篷车]',
+  512: 'corkscrew, bottle screw [开瓶器,瓶螺杆]',
+  513: 'cornet, horn, trumpet, trump [短号,喇叭]',
+  514: 'cowboy boot [牛仔靴]',
+  515: 'cowboy hat, ten-gallon hat [牛仔帽]',
+  516: 'cradle [摇篮]',
+  517: 'crane [起重机]',
+  518: 'crash helmet [头盔]',
+  519: 'crate [板条箱]',
+  520: 'crib, cot [小儿床]',
+  521: 'Crock Pot [砂锅]',
+  522: 'croquet ball [槌球]',
+  523: 'crutch [拐杖]',
+  524: 'cuirass [胸甲]',
+  525: 'dam, dike, dyke [大坝,堤防]',
+  526: 'desk [书桌]',
+  527: 'desktop computer [台式电脑]',
+  528: 'dial telephone, dial phone [有线电话]',
+  529: 'diaper, nappy, napkin [尿布湿]',
+  530: 'digital clock [数字时钟]',
+  531: 'digital watch [数字手表]',
+  532: 'dining table, board [餐桌板]',
+  533: 'dishrag, dishcloth [抹布]',
+  534: 'dishwasher, dish washer, dishwashing machine [洗碗机,洗碟机]',
+  535: 'disk brake, disc brake [盘式制动器]',
+  536: 'dock, dockage, docking facility [码头,船坞,码头设施]',
+  537: 'dogsled, dog sled, dog sleigh [狗拉雪橇]',
+  538: 'dome [圆顶]',
+  539: 'doormat, welcome mat [门垫,垫子]',
+  540: 'drilling platform, offshore rig [钻井平台,海上钻井]',
+  541: 'drum, membranophone, tympan [鼓,乐器,鼓膜]',
+  542: 'drumstick [鼓槌]',
+  543: 'dumbbell [哑铃]',
+  544: 'Dutch oven [荷兰烤箱]',
+  545: 'electric fan, blower [电风扇,鼓风机]',
+  546: 'electric guitar [电吉他]',
+  547: 'electric locomotive [电力机车]',
+  548: 'entertainment center [电视,电视柜]',
+  549: 'envelope [信封]',
+  550: 'espresso maker [浓缩咖啡机]',
+  551: 'face powder [扑面粉]',
+  552: 'feather boa, boa [女用长围巾]',
+  553: 'file, file cabinet, filing cabinet [文件,文件柜,档案柜]',
+  554: 'fireboat [消防船]',
+  555: 'fire engine, fire truck [消防车]',
+  556: 'fire screen, fireguard [火炉栏]',
+  557: 'flagpole, flagstaff [旗杆]',
+  558: 'flute, transverse flute [长笛]',
+  559: 'folding chair [折叠椅]',
+  560: 'football helmet [橄榄球头盔]',
+  561: 'forklift [叉车]',
+  562: 'fountain [喷泉]',
+  563: 'fountain pen [钢笔]',
+  564: 'four-poster [有四根帷柱的床]',
+  565: 'freight car [运货车厢]',
+  566: 'French horn, horn [圆号,喇叭]',
+  567: 'frying pan, frypan, skillet [煎锅]',
+  568: 'fur coat [裘皮大衣]',
+  569: 'garbage truck, dustcart [垃圾车]',
+  570: 'gasmask, respirator, gas helmet [防毒面具,呼吸器]',
+  571: 'gas pump, gasoline pump, petrol pump, island dispenser [汽油泵]',
+  572: 'goblet [高脚杯]',
+  573: 'go-kart [卡丁车]',
+  574: 'golf ball [高尔夫球]',
+  575: 'golfcart, golf cart [高尔夫球车]',
+  576: 'gondola [狭长小船]',
+  577: 'gong, tam-tam [锣]',
+  578: 'gown [礼服]',
+  579: 'grand piano, grand [钢琴]',
+  580: 'greenhouse, nursery, glasshouse [温室,苗圃]',
+  581: 'grille, radiator grille [散热器格栅]',
+  582: 'grocery store, grocery, food market, market [杂货店,食品市场]',
+  583: 'guillotine [断头台]',
+  584: 'hair slide [小发夹]',
+  585: 'hair spray [头发喷雾]',
+  586: 'half track [半履带装甲车]',
+  587: 'hammer [锤子]',
+  588: 'hamper [大篮子]',
+  589: 'hand blower, blow dryer, blow drier, hair dryer, hair drier [手摇鼓风机,吹风机]',
+  590: 'hand-held computer, hand-held microcomputer [手提电脑]',
+  591: 'handkerchief, hankie, hanky, hankey [手帕]',
+  592: 'hard disc, hard disk, fixed disk [硬盘]',
+  593: 'harmonica, mouth organ, harp, mouth harp [口琴,口风琴]',
+  594: 'harp [竖琴]',
+  595: 'harvester, reaper [收割机]',
+  596: 'hatchet [斧头]',
+  597: 'holster [手枪皮套]',
+  598: 'home theater, home theatre [家庭影院]',
+  599: 'honeycomb [蜂窝]',
+  600: 'hook, claw [钩爪]',
+  601: 'hoopskirt, crinoline [衬裙]',
+  602: 'horizontal bar, high bar [单杠]',
+  603: 'horse cart, horse-cart [马车]',
+  604: 'hourglass [沙漏]',
+  605: 'iPod [手机，iPad]',
+  606: 'iron, smoothing iron [熨斗]',
+  607: 'jack-o-lantern [南瓜灯笼]',
+  608: 'jean, blue jean, denim [牛仔裤,蓝色牛仔裤]',
+  609: 'jeep, landrover [吉普车]',
+  610: 'jersey, T-shirt, tee shirt [运动衫,T恤]',
+  611: 'jigsaw puzzle [拼图]',
+  612: 'jinrikisha, ricksha, rickshaw [人力车]',
+  613: 'joystick [操纵杆]',
+  614: 'kimono [和服]',
+  615: 'knee pad [护膝]',
+  616: 'knot [蝴蝶结]',
+  617: 'lab coat, laboratory coat [大褂,实验室外套]',
+  618: 'ladle [长柄勺]',
+  619: 'lampshade, lamp shade [灯罩]',
+  620: 'laptop, laptop computer [笔记本电脑]',
+  621: 'lawn mower, mower [割草机]',
+  622: 'lens cap, lens cover [镜头盖]',
+  623: 'letter opener, paper knife, paperknife [开信刀,裁纸刀]',
+  624: 'library [图书馆]',
+  625: 'lifeboat [救生艇]',
+  626: 'lighter, light, igniter, ignitor [点火器,打火机]',
+  627: 'limousine, limo [豪华轿车]',
+  628: 'liner, ocean liner [远洋班轮]',
+  629: 'lipstick, lip rouge [唇膏,口红]',
+  630: 'Loafer [平底便鞋]',
+  631: 'lotion [洗剂]',
+  632: 'loudspeaker, speaker, speaker unit, loudspeaker system, speaker system [扬声器]',
+  633: 'loupe, jewelers loupe [放大镜]',
+  634: 'lumbermill, sawmill [锯木厂]',
+  635: 'magnetic compass [磁罗盘]',
+  636: 'mailbag, postbag [邮袋]',
+  637: 'mailbox, letter box [信箱]',
+  638: 'maillot [女游泳衣]',
+  639: 'maillot, tank suit [有肩带浴衣]',
+  640: 'manhole cover [窨井盖]',
+  641: 'maraca [沙球（一种打击乐器）]',
+  642: 'marimba, xylophone [马林巴木琴]',
+  643: 'mask [面膜]',
+  644: 'matchstick [火柴]',
+  645: 'maypole [花柱]',
+  646: 'maze, labyrinth [迷宫]',
+  647: 'measuring cup [量杯]',
+  648: 'medicine chest, medicine cabinet [药箱]',
+  649: 'megalith, megalithic structure [巨石,巨石结构]',
+  650: 'microphone, mike [麦克风]',
+  651: 'microwave, microwave oven [微波炉]',
+  652: 'military uniform [军装]',
+  653: 'milk can [奶桶]',
+  654: 'minibus [迷你巴士]',
+  655: 'miniskirt, mini [迷你裙]',
+  656: 'minivan [面包车]',
+  657: 'missile [导弹]',
+  658: 'mitten [连指手套]',
+  659: 'mixing bowl [搅拌钵]',
+  660: 'mobile home, manufactured home [活动房屋（由汽车拖拉的）]',
+  661: 'Model T [T型发动机小汽车]',
+  662: 'modem [调制解调器]',
+  663: 'monastery [修道院]',
+  664: 'monitor [显示器]',
+  665: 'moped [电瓶车]',
+  666: 'mortar [砂浆]',
+  667: 'mortarboard [学士]',
+  668: 'mosque [清真寺]',
+  669: 'mosquito net [蚊帐]',
+  670: 'motor scooter, scooter [摩托车]',
+  671: 'mountain bike, all-terrain bike, off-roader [山地自行车]',
+  672: 'mountain tent [登山帐]',
+  673: 'mouse, computer mouse [鼠标,电脑鼠标]',
+  674: 'mousetrap [捕鼠器]',
+  675: 'moving van [搬家车]',
+  676: 'muzzle [口套]',
+  677: 'nail [钉子]',
+  678: 'neck brace [颈托]',
+  679: 'necklace [项链]',
+  680: 'nipple [乳头（瓶）]',
+  681: 'notebook, notebook computer [笔记本,笔记本电脑]',
+  682: 'obelisk [方尖碑]',
+  683: 'oboe, hautboy, hautbois [双簧管]',
+  684: 'ocarina, sweet potato [陶笛,卵形笛]',
+  685: 'odometer, hodometer, mileometer, milometer [里程表]',
+  686: 'oil filter [滤油器]',
+  687: 'organ, pipe organ [风琴,管风琴]',
+  688: 'oscilloscope, scope, cathode-ray oscilloscope, CRO [示波器]',
+  689: 'overskirt [罩裙]',
+  690: 'oxcart [牛车]',
+  691: 'oxygen mask [氧气面罩]',
+  692: 'packet [包装]',
+  693: 'paddle, boat paddle [船桨]',
+  694: 'paddlewheel, paddle wheel [明轮,桨轮]',
+  695: 'padlock [挂锁,扣锁]',
+  696: 'paintbrush [画笔]',
+  697: 'pajama, pyjama, pjs, jammies [睡衣]',
+  698: 'palace [宫殿]',
+  699: 'panpipe, pandean pipe, syrinx [排箫,鸣管]',
+  700: 'paper towel [纸巾]',
+  701: 'parachute, chute [降落伞]',
+  702: 'parallel bars, bars [双杠]',
+  703: 'park bench [公园长椅]',
+  704: 'parking meter [停车收费表,停车计时器]',
+  705: 'passenger car, coach, carriage [客车,教练车]',
+  706: 'patio, terrace [露台,阳台]',
+  707: 'pay-phone, pay-station [付费电话]',
+  708: 'pedestal, plinth, footstall [基座,基脚]',
+  709: 'pencil box, pencil case [铅笔盒]',
+  710: 'pencil sharpener [卷笔刀]',
+  711: 'perfume, essence [香水（瓶）]',
+  712: 'Petri dish [培养皿]',
+  713: 'photocopier [复印机]',
+  714: 'pick, plectrum, plectron [拨弦片,拨子]',
+  715: 'pickelhaube [尖顶头盔]',
+  716: 'picket fence, paling [栅栏,栅栏]',
+  717: 'pickup, pickup truck [皮卡,皮卡车]',
+  718: 'pier [桥墩]',
+  719: 'piggy bank, penny bank [存钱罐]',
+  720: 'pill bottle [药瓶]',
+  721: 'pillow [枕头]',
+  722: 'ping-pong ball [乒乓球]',
+  723: 'pinwheel [风车]',
+  724: 'pirate, pirate ship [海盗船]',
+  725: 'pitcher, ewer [水罐]',
+  726: 'plane, carpenters plane, woodworking plane [木工刨]',
+  727: 'planetarium [天文馆]',
+  728: 'plastic bag [塑料袋]',
+  729: 'plate rack [板架]',
+  730: 'plow, plough [犁型铲雪机]',
+  731: 'plunger, plumbers helper [手压皮碗泵]',
+  732: 'Polaroid camera, Polaroid Land camera [宝丽来相机]',
+  733: 'pole [电线杆]',
+  734: 'police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria [警车,巡逻车]',
+  735: 'poncho [雨披]',
+  736: 'pool table, billiard table, snooker table [台球桌]',
+  737: 'pop bottle, soda bottle [充气饮料瓶]',
+  738: 'pot, flowerpot [花盆]',
+  739: 'potters wheel [陶工旋盘]',
+  740: 'power drill [电钻]',
+  741: 'prayer rug, prayer mat [祈祷垫,地毯]',
+  742: 'printer [打印机]',
+  743: 'prison, prison house [监狱]',
+  744: 'projectile, missile [炮弹,导弹]',
+  745: 'projector [投影仪]',
+  746: 'puck, hockey puck [冰球]',
+  747: 'punching bag, punch bag, punching ball, punchball [沙包,吊球]',
+  748: 'purse [钱包]',
+  749: 'quill, quill pen [羽管笔]',
+  750: 'quilt, comforter, comfort, puff [被子]',
+  751: 'racer, race car, racing car [赛车]',
+  752: 'racket, racquet [球拍]',
+  753: 'radiator [散热器]',
+  754: 'radio, wireless [收音机]',
+  755: 'radio telescope, radio reflector [射电望远镜,无线电反射器]',
+  756: 'rain barrel [雨桶]',
+  757: 'recreational vehicle, RV, R.V. [休闲车,房车]',
+  758: 'reel [卷轴,卷筒]',
+  759: 'reflex camera [反射式照相机]',
+  760: 'refrigerator, icebox [冰箱,冰柜]',
+  761: 'remote control, remote [遥控器]',
+  762: 'restaurant, eating house, eating place, eatery [餐厅,饮食店,食堂]',
+  763: 'revolver, six-gun, six-shooter [左轮手枪]',
+  764: 'rifle [步枪]',
+  765: 'rocking chair, rocker [摇椅]',
+  766: 'rotisserie [电转烤肉架]',
+  767: 'rubber eraser, rubber, pencil eraser [橡皮]',
+  768: 'rugby ball [橄榄球]',
+  769: 'rule, ruler [直尺]',
+  770: 'running shoe [跑步鞋]',
+  771: 'safe [保险柜]',
+  772: 'safety pin [安全别针]',
+  773: 'saltshaker, salt shaker [盐瓶（调味用）]',
+  774: 'sandal [凉鞋]',
+  775: 'sarong [纱笼,围裙]',
+  776: 'sax, saxophone [萨克斯管]',
+  777: 'scabbard [剑鞘]',
+  778: 'scale, weighing machine [秤,称重机]',
+  779: 'school bus [校车]',
+  780: 'schooner [帆船]',
+  781: 'scoreboard [记分牌]',
+  782: 'screen, CRT screen [屏幕]',
+  783: 'screw [螺丝]',
+  784: 'screwdriver [螺丝刀]',
+  785: 'seat belt, seatbelt [安全带]',
+  786: 'sewing machine [缝纫机]',
+  787: 'shield, buckler [盾牌,盾牌]',
+  788: 'shoe shop, shoe-shop, shoe store [皮鞋店,鞋店]',
+  789: 'shoji [障子]',
+  790: 'shopping basket [购物篮]',
+  791: 'shopping cart [购物车]',
+  792: 'shovel [铁锹]',
+  793: 'shower cap [浴帽]',
+  794: 'shower curtain [浴帘]',
+  795: 'ski [滑雪板]',
+  796: 'ski mask [滑雪面罩]',
+  797: 'sleeping bag [睡袋]',
+  798: 'slide rule, slipstick [滑尺]',
+  799: 'sliding door [滑动门]',
+  800: 'slot, one-armed bandit [角子老虎机]',
+  801: 'snorkel [潜水通气管]',
+  802: 'snowmobile [雪橇]',
+  803: 'snowplow, snowplough [扫雪机,扫雪机]',
+  804: 'soap dispenser [皂液器]',
+  805: 'soccer ball [足球]',
+  806: 'sock [袜子]',
+  807: 'solar dish, solar collector, solar furnace [碟式太阳能,太阳能集热器,太阳能炉]',
+  808: 'sombrero [宽边帽]',
+  809: 'soup bowl [汤碗]',
+  810: 'space bar [空格键]',
+  811: 'space heater [空间加热器]',
+  812: 'space shuttle [航天飞机]',
+  813: 'spatula [铲（搅拌或涂敷用的）]',
+  814: 'speedboat [快艇]',
+  815: 'spider web, spiders web [蜘蛛网]',
+  816: 'spindle [纺锤,纱锭]',
+  817: 'sports car, sport car [跑车]',
+  818: 'spotlight, spot [聚光灯]',
+  819: 'stage [舞台]',
+  820: 'steam locomotive [蒸汽机车]',
+  821: 'steel arch bridge [钢拱桥]',
+  822: 'steel drum [钢滚筒]',
+  823: 'stethoscope [听诊器]',
+  824: 'stole [女用披肩]',
+  825: 'stone wall [石头墙]',
+  826: 'stopwatch, stop watch [秒表]',
+  827: 'stove [火炉]',
+  828: 'strainer [过滤器]',
+  829: 'streetcar, tram, tramcar, trolley, trolley car [有轨电车,电车]',
+  830: 'stretcher [担架]',
+  831: 'studio couch, day bed [沙发床]',
+  832: 'stupa, tope [佛塔]',
+  833: 'submarine, pigboat, sub, U-boat [潜艇,潜水艇]',
+  834: 'suit, suit of clothes [套装,衣服]',
+  835: 'sundial [日晷]',
+  836: 'sunglass [太阳镜]',
+  837: 'sunglasses, dark glasses, shades [太阳镜,墨镜]',
+  838: 'sunscreen, sunblock, sun blocker [防晒霜,防晒剂]',
+  839: 'suspension bridge [悬索桥]',
+  840: 'swab, swob, mop [拖把]',
+  841: 'sweatshirt [运动衫]',
+  842: 'swimming trunks, bathing trunks [游泳裤]',
+  843: 'swing [秋千]',
+  844: 'switch, electric switch, electrical switch [开关,电器开关]',
+  845: 'syringe [注射器]',
+  846: 'table lamp [台灯]',
+  847: 'tank, army tank, armored combat vehicle, armoured combat vehicle [坦克,装甲战车,装甲战斗车辆]',
+  848: 'tape player [磁带播放器]',
+  849: 'teapot [茶壶]',
+  850: 'teddy, teddy bear [泰迪,泰迪熊]',
+  851: 'television, television system [电视]',
+  852: 'tennis ball [网球]',
+  853: 'thatch, thatched roof [茅草,茅草屋顶]',
+  854: 'theater curtain, theatre curtain [幕布,剧院的帷幕]',
+  855: 'thimble [顶针]',
+  856: 'thresher, thrasher, threshing machine [脱粒机]',
+  857: 'throne [宝座]',
+  858: 'tile roof [瓦屋顶]',
+  859: 'toaster [烤面包机]',
+  860: 'tobacco shop, tobacconist shop, tobacconist [烟草店,烟草]',
+  861: 'toilet seat [马桶]',
+  862: 'torch [火炬]',
+  863: 'totem pole [图腾柱]',
+  864: 'tow truck, tow car, wrecker [拖车,牵引车,清障车]',
+  865: 'toyshop [玩具店]',
+  866: 'tractor [拖拉机]',
+  867: 'trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi [拖车,铰接式卡车]',
+  868: 'tray [托盘]',
+  869: 'trench coat [风衣]',
+  870: 'tricycle, trike, velocipede [三轮车]',
+  871: 'trimaran [三体船]',
+  872: 'tripod [三脚架]',
+  873: 'triumphal arch [凯旋门]',
+  874: 'trolleybus, trolley coach, trackless trolley [无轨电车]',
+  875: 'trombone [长号]',
+  876: 'tub, vat [浴盆,浴缸]',
+  877: 'turnstile [旋转式栅门]',
+  878: 'typewriter keyboard [打字机键盘]',
+  879: 'umbrella [伞]',
+  880: 'unicycle, monocycle [独轮车]',
+  881: 'upright, upright piano [直立式钢琴]',
+  882: 'vacuum, vacuum cleaner [真空吸尘器]',
+  883: 'vase [花瓶]',
+  884: 'vault [拱顶]',
+  885: 'velvet [天鹅绒]',
+  886: 'vending machine [自动售货机]',
+  887: 'vestment [祭服]',
+  888: 'viaduct [高架桥]',
+  889: 'violin, fiddle [小提琴,小提琴]',
+  890: 'volleyball [排球]',
+  891: 'waffle iron [松饼机]',
+  892: 'wall clock [挂钟]',
+  893: 'wallet, billfold, notecase, pocketbook [钱包,皮夹]',
+  894: 'wardrobe, closet, press [衣柜,壁橱]',
+  895: 'warplane, military plane [军用飞机]',
+  896: 'washbasin, handbasin, washbowl, lavabo, wash-hand basin [洗脸盆,洗手盆]',
+  897: 'washer, automatic washer, washing machine [洗衣机,自动洗衣机]',
+  898: 'water bottle [水瓶]',
+  899: 'water jug [水壶]',
+  900: 'water tower [水塔]',
+  901: 'whiskey jug [威士忌壶]',
+  902: 'whistle [哨子]',
+  903: 'wig [假发]',
+  904: 'window screen [纱窗]',
+  905: 'window shade [百叶窗]',
+  906: 'Windsor tie [温莎领带]',
+  907: 'wine bottle [葡萄酒瓶]',
+  908: 'wing [飞机翅膀,飞机]',
+  909: 'wok [炒菜锅]',
+  910: 'wooden spoon [木制的勺子]',
+  911: 'wool, woolen, woollen [毛织品,羊绒]',
+  912: 'worm fence, snake fence, snake-rail fence, Virginia fence [栅栏,围栏]',
+  913: 'wreck [沉船]',
+  914: 'yawl [双桅船]',
+  915: 'yurt [蒙古包]',
+  916: 'web site, website, internet site, site [网站,互联网网站]',
+  917: 'comic book [漫画]',
+  918: 'crossword puzzle, crossword [纵横字谜]',
+  919: 'street sign [路标]',
+  920: 'traffic light, traffic signal, stoplight [交通信号灯]',
+  921: 'book jacket, dust cover, dust jacket, dust wrapper [防尘罩,书皮]',
+  922: 'menu [菜单]',
+  923: 'plate [盘子]',
+  924: 'guacamole [鳄梨酱]',
+  925: 'consomme [清汤]',
+  926: 'hot pot, hotpot [罐焖土豆烧肉]',
+  927: 'trifle [蛋糕]',
+  928: 'ice cream, icecream [冰淇淋]',
+  929: 'ice lolly, lolly, lollipop, popsicle [雪糕,冰棍,冰棒]',
+  930: 'French loaf [法式面包]',
+  931: 'bagel, beigel [百吉饼]',
+  932: 'pretzel [椒盐脆饼]',
+  933: 'cheeseburger [芝士汉堡]',
+  934: 'hotdog, hot dog, red hot [热狗]',
+  935: 'mashed potato [土豆泥]',
+  936: 'head cabbage [结球甘蓝]',
+  937: 'broccoli [西兰花]',
+  938: 'cauliflower [菜花]',
+  939: 'zucchini, courgette [绿皮密生西葫芦]',
+  940: 'spaghetti squash [西葫芦]',
+  941: 'acorn squash [小青南瓜]',
+  942: 'butternut squash [南瓜]',
+  943: 'cucumber, cuke [黄瓜]',
+  944: 'artichoke, globe artichoke [朝鲜蓟]',
+  945: 'bell pepper [甜椒]',
+  946: 'cardoon [刺棘蓟]',
+  947: 'mushroom [蘑菇]',
+  948: 'Granny Smith [绿苹果]',
+  949: 'strawberry [草莓]',
+  950: 'orange [橘子]',
+  951: 'lemon [柠檬]',
+  952: 'fig [无花果]',
+  953: 'pineapple, ananas [菠萝]',
+  954: 'banana [香蕉]',
+  955: 'jackfruit, jak, jack [菠萝蜜]',
+  956: 'custard apple [蛋奶冻苹果]',
+  957: 'pomegranate [石榴]',
+  958: 'hay [干草]',
+  959: 'carbonara [烤面条加干酪沙司]',
+  960: 'chocolate sauce, chocolate syrup [巧克力酱,巧克力糖浆]',
+  961: 'dough [面团]',
+  962: 'meat loaf, meatloaf [瑞士肉包,肉饼]',
+  963: 'pizza, pizza pie [披萨,披萨饼]',
+  964: 'potpie [馅饼]',
+  965: 'burrito [卷饼]',
+  966: 'red wine [红葡萄酒]',
+  967: 'espresso [意大利浓咖啡]',
+  968: 'cup [杯子]',
+  969: 'eggnog [蛋酒]',
+  970: 'alp [高山]',
+  971: 'bubble [泡泡]',
+  972: 'cliff, drop, drop-off [悬崖]',
+  973: 'coral reef [珊瑚礁]',
+  974: 'geyser [间歇泉]',
+  975: 'lakeside, lakeshore [湖边,湖岸]',
+  976: 'promontory, headland, head, foreland [海角]',
+  977: 'sandbar, sand bar [沙洲,沙坝]',
+  978: 'seashore, coast, seacoast, sea-coast [海滨,海岸]',
+  979: 'valley, vale [峡谷]',
+  980: 'volcano [火山]',
+  981: 'ballplayer, baseball player [棒球,棒球运动员]',
+  982: 'groom, bridegroom [新郎]',
+  983: 'scuba diver [潜水员]',
+  984: 'rapeseed [油菜]',
+  985: 'daisy [雏菊]',
+  986: 'yellow ladys slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum [杓兰]',
+  987: 'corn [玉米]',
+  988: 'acorn [橡子]',
+  989: 'hip, rose hip, rosehip [玫瑰果]',
+  990: 'buckeye, horse chestnut, conker [七叶树果实]',
+  991: 'coral fungus [珊瑚菌]',
+  992: 'agaric [木耳]',
+  993: 'gyromitra [鹿花菌]',
+  994: 'stinkhorn, carrion fungus [鬼笔菌]',
+  995: 'earthstar [地星（菌类）]',
+  996: 'hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa [多叶奇果菌]',
+  997: 'bolete [牛肝菌]',
+  998: 'ear, spike, capitulum [玉米穗]',
+  999: 'toilet tissue, toilet paper, bathroom tissue [卫生纸]',
+}

tools/push_gpt_to_hf.py

@@ -0,0 +1,71 @@
+# Modified from:
+#   DiT:  https://github.com/facebookresearch/DiT/blob/main/sample_ddp.py
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import argparse
+
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from autoregressive.models.gpt_hf import GPT_models_HF, TransformerHF
+
+device = "cuda" if torch.cuda_is_available() else "cpu"
+
+def main(args):
+    # Setup PyTorch:
+    assert torch.cuda.is_available(), "Sampling with DDP requires at least one GPU. sample.py supports CPU-only usage"
+    torch.set_grad_enabled(False)
+
+    # create and load gpt model
+    precision = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.precision]
+    latent_size = args.image_size // args.downsample_size
+    gpt_model = GPT_models_HF[args.gpt_model](
+        vocab_size=args.codebook_size,
+        block_size=latent_size ** 2,
+        num_classes=args.num_classes,
+        cls_token_num=args.cls_token_num,
+        model_type=args.gpt_type,
+    ).to(device=device, dtype=precision)
+    checkpoint = torch.load(args.gpt_ckpt, map_location="cpu")
+    if args.from_fsdp: # fsdp
+        model_weight = checkpoint
+    elif "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, maybe add --from-fsdp to run command")
+
+    # load weights
+    gpt_model.load_state_dict(model_weight, strict=False)
+    gpt_model.eval()
+    del checkpoint
+
+    # push to hub
+    repo_id = f"FoundationVision/{args.gpt_model}-{args.image_size}"
+    gpt_model.push_to_hub(repo_id)
+
+    # reload
+    model = TransformerHF.from_pretrained(repo_id)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-B")
+    parser.add_argument("--gpt-ckpt", type=str, default=None)
+    parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="c2i", help="class-conditional or text-conditional")
+    parser.add_argument("--from-fsdp", action='store_true')
+    parser.add_argument("--cls-token-num", type=int, default=1, help="max token number of condition input")
+    parser.add_argument("--precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) 
+    parser.add_argument("--compile", action='store_true', default=True)
+    parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16")
+    parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for vq model")
+    parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization")
+    parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization")
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512], default=384)
+    parser.add_argument("--image-size-eval", type=int, choices=[256, 384, 512], default=256)
+    parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16)
+    parser.add_argument("--num-classes", type=int, default=1000)
+    args = parser.parse_args()
+    main(args)

utils/data.py

@@ -0,0 +1,22 @@
+import numpy as np
+from PIL import Image
+
+def center_crop_arr(pil_image, image_size):
+    """
+    Center cropping implementation from ADM.
+    https://github.com/openai/guided-diffusion/blob/8fb3ad9197f16bbc40620447b2742e13458d2831/guided_diffusion/image_datasets.py#L126
+    """
+    while min(*pil_image.size) >= 2 * image_size:
+        pil_image = pil_image.resize(
+            tuple(x // 2 for x in pil_image.size), resample=Image.BOX
+        )
+
+    scale = image_size / min(*pil_image.size)
+    pil_image = pil_image.resize(
+        tuple(round(x * scale) for x in pil_image.size), resample=Image.BICUBIC
+    )
+
+    arr = np.array(pil_image)
+    crop_y = (arr.shape[0] - image_size) // 2
+    crop_x = (arr.shape[1] - image_size) // 2
+    return Image.fromarray(arr[crop_y: crop_y + image_size, crop_x: crop_x + image_size])