Add files using upload-large-folder tool

autoregressive/train/train_t2i.py

@@ -0,0 +1,268 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT
+#   nanoGPT: https://github.com/karpathy/nanoGPT
+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 torchvision import transforms
+from glob import glob
+import time
+import argparse
+import os
+
+from utils.distributed import init_distributed_mode
+from utils.logger import create_logger
+from dataset.build import build_dataset
+from dataset.augmentation import center_crop_arr
+from autoregressive.train.train_c2i import creat_optimizer
+from autoregressive.models.gpt import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+
+
+
+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("/", "-") 
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"
+        checkpoint_dir = f"{experiment_dir}/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
+    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=args.dropout_p,
+        ffn_dropout_p=args.dropout_p,
+        token_dropout_p=args.token_dropout_p,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+
+    # Setup data:
+    if args.dataset == 't2i':     # 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        
+    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_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")
+
+    # Prepare models for training:
+    if args.gpt_ckpt:
+        checkpoint = torch.load(args.gpt_ckpt, map_location="cpu")
+        model.load_state_dict(checkpoint["model"], strict=True)
+        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 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
+
+    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, attn_mask, valid in loader:
+            x = x.to(device, non_blocking=True)
+            y = y.to(device, non_blocking=True)
+            if args.dataset == 't2i':
+                img = x
+                with torch.no_grad():
+                    _, _, [_, _, indices] = vq_model.encode(img)#图像编码
+                x = indices.reshape(img.shape[0], -1)
+            z_indices = x.reshape(x.shape[0], -1) #图像
+            c_indices = y.reshape(y.shape[0], y.shape[-2], y.shape[-1])# 文本已经经过T5编码之后的了
+            assert z_indices.shape[0] == c_indices.shape[0]
+            attn_mask = attn_mask.reshape(attn_mask.shape[0], 1, attn_mask.shape[-2], attn_mask.shape[-1]) # (bs, n_head, seq_len, seq_len)
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, mask=attn_mask[:, :, :-1,:-1], valid=valid)
+            # 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)
+
+            # 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 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("--data-path", type=str, required=True, help='包含 .jsonl 文件的路径')
+    parser.add_argument("--t5-feat-path", type=str, required=True, help='T5 .npy 文件路径')
+    parser.add_argument("--short-t5-feat-path", type=str, default=None, help="short caption of t5_feat_path")
+    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 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("--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="t2i")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--cls-token-num", type=int, default=120, 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", type=float, default=0.0, help="drop_path_rate of attention and ffn")
+    parser.add_argument("--no-compile", action='store_true')
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='t2i')
+    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("--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="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=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_t2i_canny.py

@@ -0,0 +1,283 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT
+#   nanoGPT: https://github.com/karpathy/nanoGPT
+from PIL import PngImagePlugin
+MaximumDecompressedSize = 1024
+MegaByte = 2**20
+PngImagePlugin.MAX_TEXT_CHUNK = MaximumDecompressedSize * MegaByte
+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 torchvision import transforms
+from glob import glob
+import time
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from utils.logger import create_logger
+from dataset.build import build_dataset
+from dataset.augmentation import center_crop_arr
+from autoregressive.train.train_c2i import creat_optimizer
+
+from autoregressive.models.gpt_t2i import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from accelerate.utils import ProjectConfiguration, set_seed
+from pathlib import Path
+from accelerate import Accelerator
+from language.t5 import T5Embedder
+from dataset.t2i_control import build_t2i_control_code
+import torch._dynamo
+torch._dynamo.config.suppress_errors = True
+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("/", "-") 
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"
+        checkpoint_dir = f"{experiment_dir}/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
+    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=args.dropout_p,
+        ffn_dropout_p=args.dropout_p,
+        token_dropout_p=args.token_dropout_p,
+        adapter_size=args.adapter_size,
+        condition_type=args.condition_type,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+
+    train_dataset = build_t2i_control_code(args)
+    sampler = DistributedSampler(
+        train_dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+
+    loader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=False,
+        collate_fn=train_dataset.collate_fn,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        num_workers=args.num_workers,
+        pin_memory=True,
+        sampler=sampler,
+        drop_last=True
+    )
+    logger.info(f"Dataset contains {len(train_dataset):,} images")
+
+    # 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)
+        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 not args.no_compile:
+        logger.info("compiling the model... (may take several minutes)")
+        model = torch.compile(model) # requires PyTorch 2.0        
+    # model.zero_init_mlp()
+    model = DDP(model.to(device), device_ids=[args.gpu], find_unused_parameters=True)
+    model.train()  # important! This enables embedding dropout for classifier-free guidance
+    
+    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['code']
+            caption_emb = batch['caption_emb']
+            condition_img = batch['control']
+
+            attn_mask = batch['attn_mask']
+            valid = batch['valid']
+            y = caption_emb
+            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(y.shape[0], y.shape[-2], y.shape[-1])
+            assert z_indices.shape[0] == c_indices.shape[0]
+            attn_mask = attn_mask.reshape(attn_mask.shape[0], 1, attn_mask.shape[-2], attn_mask.shape[-1]) # (bs, n_head, seq_len, seq_len)
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, mask=attn_mask[:, :, :-1,:-1], valid=valid, 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)
+
+            # 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 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("--data-path", type=str, required=False)
+    parser.add_argument("--t5-feat-path", type=str, required=False)
+    parser.add_argument("--short-t5-feat-path", type=str, default=None, help="short caption of t5_feat_path")
+    parser.add_argument("--cloud-save-path", type=str, required=False, 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 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("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL")
+    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="t2i")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--cls-token-num", type=int, default=120, 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", type=float, default=0.0, help="drop_path_rate of attention and ffn")
+    parser.add_argument("--no-compile", action='store_true')
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='t2i_control')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512], 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("--epochs", type=int, default=6)
+    parser.add_argument("--lr", type=float, default=5e-5)
+    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=96)
+    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=10000)
+    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, choices=['canny', 'hed', 'lineart', 'depth'], default="canny")
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--code-path2", type=str, default=None)
+    parser.add_argument("--adapter-size", type=str, default='small')
+    parser.add_argument("--get-image", type=bool, default=True)
+    parser.add_argument("--get-prompt", type=bool, default=False)
+    parser.add_argument("--get-label", type=bool, default=False)
+    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("--keep_in_memory",type=bool,default=False)
+    parser.add_argument("--wrong_ids_file",type=str,default=None)
+    parser.add_argument("--logging_dir",type=str,default="logs")
+    
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_t2i_depth.py

@@ -0,0 +1,286 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT
+#   nanoGPT: https://github.com/karpathy/nanoGPT
+from PIL import PngImagePlugin
+MaximumDecompressedSize = 1024
+MegaByte = 2**20
+PngImagePlugin.MAX_TEXT_CHUNK = MaximumDecompressedSize * MegaByte
+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 torchvision import transforms
+from glob import glob
+import time
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from utils.logger import create_logger
+from dataset.build import build_dataset
+from dataset.augmentation import center_crop_arr
+from autoregressive.train.train_c2i import creat_optimizer
+from torch.optim.lr_scheduler import StepLR
+from autoregressive.models.gpt_t2i import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from accelerate.utils import ProjectConfiguration, set_seed
+from pathlib import Path
+from accelerate import Accelerator
+from language.t5 import T5Embedder
+from dataset.t2i_control import build_t2i_control_code
+import torch._dynamo
+torch._dynamo.config.suppress_errors = True
+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("/", "-") 
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"
+        checkpoint_dir = f"{experiment_dir}/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
+    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=args.dropout_p,
+        ffn_dropout_p=args.dropout_p,
+        token_dropout_p=args.token_dropout_p,
+        condition_type=args.condition_type,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+    lr_scheduler = StepLR(optimizer, step_size=1, gamma=0.5) # 每10个epoch后，学习率乘以0.1
+    train_dataset = build_t2i_control_code(args)
+    sampler = DistributedSampler(
+        train_dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+
+    loader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=False,
+        collate_fn=train_dataset.collate_fn,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        num_workers=args.num_workers,
+        pin_memory=True,
+        sampler=sampler,
+        drop_last=True
+    )
+    logger.info(f"Dataset contains {len(train_dataset):,} images")
+
+    # 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)
+        # 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 not args.no_compile:
+        logger.info("compiling the model... (may take several minutes)")
+        model = torch.compile(model) # requires PyTorch 2.0        
+    # model.zero_init_mlp()
+    model = DDP(model.to(device), device_ids=[args.gpu], find_unused_parameters=True)
+    model.train()  # important! This enables embedding dropout for classifier-free guidance
+    
+    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, attn_mask, valid in loader:
+        for batch in loader:
+            
+            x = batch['code']
+            caption_emb = batch['caption_emb']
+            condition_img = batch['control']
+
+            attn_mask = batch['attn_mask']
+            valid = batch['valid']
+            y = caption_emb
+            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(y.shape[0], y.shape[-2], y.shape[-1])
+            assert z_indices.shape[0] == c_indices.shape[0]
+            attn_mask = attn_mask.reshape(attn_mask.shape[0], 1, attn_mask.shape[-2], attn_mask.shape[-1]) # (bs, n_head, seq_len, seq_len)
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, mask=attn_mask[:, :, :-1,:-1], valid=valid, 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)
+
+            # 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 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()
+        lr_scheduler.step()
+    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, required=False)
+    parser.add_argument("--t5-feat-path", type=str, required=False)
+    parser.add_argument("--short-t5-feat-path", type=str, default=None, help="short caption of t5_feat_path")
+    parser.add_argument("--cloud-save-path", type=str, required=False, 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 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("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL")
+    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="t2i")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--cls-token-num", type=int, default=120, 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", type=float, default=0.0, help="drop_path_rate of attention and ffn")
+    parser.add_argument("--no-compile", action='store_true')
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='t2i_control')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512], 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("--epochs", type=int, default=7)
+    parser.add_argument("--lr", type=float, default=5e-5)
+    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=96)
+    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=10000)
+    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, choices=['canny', 'hed', 'lineart', 'depth'], default="depth")
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--code-path2", type=str, default=None)
+    parser.add_argument("--get-image", type=bool, default=True)
+    parser.add_argument("--get-prompt", type=bool, default=False)
+    parser.add_argument("--get-label", type=bool, default=False)
+    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("--keep_in_memory",type=bool,default=False)
+    parser.add_argument("--wrong_ids_file",type=str,default=None)
+    parser.add_argument("--logging_dir",type=str,default="logs")
+    
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_t2i_depth_multiscale.py

@@ -0,0 +1,357 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT
+#   nanoGPT: https://github.com/karpathy/nanoGPT
+import warnings
+warnings.filterwarnings("ignore")
+from PIL import PngImagePlugin
+MaximumDecompressedSize = 1024
+MegaByte = 2**20
+PngImagePlugin.MAX_TEXT_CHUNK = MaximumDecompressedSize * MegaByte
+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 torchvision import transforms
+from glob import glob
+import time
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from utils.logger import create_logger
+from dataset.build import build_dataset
+from dataset.augmentation import center_crop_arr
+from autoregressive.train.train_c2i import creat_optimizer
+from autoregressive.models.gpt_t2i import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from accelerate.utils import ProjectConfiguration, set_seed
+from pathlib import Path
+from accelerate import Accelerator
+from language.t5 import T5Embedder
+from dataset.t2i_control import build_t2i_control_code
+import torch._dynamo
+torch._dynamo.config.suppress_errors = True
+import random
+import torch.nn.functional as F
+from condition.hed import HEDdetector
+from condition.lineart import LineArt
+import numpy as np
+def random_sample_scale(image, condition=None):
+
+    H = np.arange(384, 1024+16, 16)
+    W = np.arange(384, 1024+16, 16)
+    resolution = [1024,1024]
+    while resolution[0]//16+resolution[1]//16 > 2304:
+        resolution = [random.choice(H), random.choice(W)]
+    assert resolution[0]//16+resolution[1]//16 <= 2304
+    image = F.interpolate(image.to(torch.float32), size=resolution, mode='bilinear', align_corners=False, antialias=True)
+    if condition is not None:
+        condition = F.interpolate(condition.to(torch.float32), size=resolution, mode='bilinear', align_corners=False, antialias=True)
+        return image, condition
+    return image
+
+
+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("/", "-") 
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"
+        checkpoint_dir = f"{experiment_dir}/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
+    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=args.dropout_p,
+        ffn_dropout_p=args.dropout_p,
+        token_dropout_p=args.token_dropout_p,
+        condition_type=args.condition_type,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+    # # Freeze all the layers
+    # for param in model.parameters():
+    #     param.requires_grad = False
+    # for name, param in model.named_parameters():
+    #     if 'condition' in name:
+    #         param.requires_grad = True
+    #         print(name)
+    #     if 'adapter' in name:
+    #         param.requires_grad = True
+    #         print(name)
+    #     if 'layers.0.' in name:
+    #         param.requires_grad = True
+    #         print(name)
+    #     if 'layers.12.' in name:
+    #         param.requires_grad = True
+    #         print(name)
+    #     if 'layers.24.' in name:
+    #         param.requires_grad = True
+    #         print(name)
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+
+    # Setup data:
+    if args.dataset == 't2i_control':     # 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        
+
+    train_dataset = build_t2i_control_code(args)
+    sampler = DistributedSampler(
+        train_dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+
+    loader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=False,
+        collate_fn=train_dataset.collate_fn,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        num_workers=args.num_workers,
+        pin_memory=True,
+        sampler=sampler,
+        drop_last=True
+    )
+    logger.info(f"Dataset contains {len(train_dataset):,} images")
+
+    # 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)
+        # 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 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
+    
+
+    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()
+    # get_condition = HEDdetector().to(device).eval()
+    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['code']
+            image = batch['image']
+            caption_emb = batch['caption_emb']
+            condition_img = batch['control']
+
+            attn_mask = batch['attn_mask']
+            valid = batch['valid']
+            y = caption_emb
+            x = x.to(device, non_blocking=True)
+            image = image.to(device, non_blocking=True)
+            y = y.to(device, non_blocking=True)
+            condition_img = condition_img.to(device, non_blocking=True)
+            image, condition_img = random_sample_scale(image, condition_img)
+            
+            if args.dataset == 't2i_control':
+                img = 2*(image/255 - 0.5)
+                
+                with torch.no_grad():
+                    _, _, [_, _, indices] = vq_model.encode(img)
+                x = indices.reshape(img.shape[0], -1)
+            z_indices = x.reshape(x.shape[0], -1)
+            c_indices = y.reshape(y.shape[0], y.shape[-2], y.shape[-1])
+            assert z_indices.shape[0] == c_indices.shape[0]
+            attn_mask = attn_mask.reshape(attn_mask.shape[0], 1, attn_mask.shape[-2], attn_mask.shape[-1]) # (bs, n_head, seq_len, seq_len)
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, mask=attn_mask[:, :, :x.shape[1]+120-1,:x.shape[1]+120-1], valid=valid, 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)
+
+            # 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 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("--data-path", type=str, required=False)
+    parser.add_argument("--t5-feat-path", type=str, required=False)
+    parser.add_argument("--short-t5-feat-path", type=str, default=None, help="short caption of t5_feat_path")
+    parser.add_argument("--cloud-save-path", type=str, required=False, 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 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("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL")
+    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="t2i")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--cls-token-num", type=int, default=120, 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", type=float, default=0.0, help="drop_path_rate of attention and ffn")
+    parser.add_argument("--no-compile", action='store_true')
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='t2i_control')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512, 768, 832, 896, 960], 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("--epochs", type=int, default=15)
+    parser.add_argument("--lr", type=float, default=1e-5)
+    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=24)
+    parser.add_argument("--log-every", type=int, default=100)
+    parser.add_argument("--ckpt-every", type=int, default=30000)
+    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("--code-path", type=str, required=True)
+    parser.add_argument("--code-path2", type=str, default=None)
+    parser.add_argument("--condition-type", type=str, choices=['segmentation', 'canny', 'hed', 'lineart', 'depth'], default="depth")
+    parser.add_argument("--get-image", type=bool, default=True)
+    parser.add_argument("--get-prompt", type=bool, default=False)
+    parser.add_argument("--get-label", type=bool, default=False)
+    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("--keep_in_memory",type=bool,default=False)
+    parser.add_argument("--wrong_ids_file",type=str,default=None)
+    parser.add_argument("--logging_dir",type=str,default="logs")
+    parser.add_argument("--report_to",type=str,default="wandb")
+    parser.add_argument("--task_name",type=str,default='segmentation')
+    parser.add_argument("--dataset_name",type=str,default=None)
+    parser.add_argument("--dataset_config_name",type=str,default=None)
+    
+    parser.add_argument("--image_column", type=str, default="image", help="The column of the dataset containing the target image.")
+    parser.add_argument("--conditioning_image_column",type=str,default="control_seg",help="The column of the dataset containing the controlnet conditioning image.")
+    parser.add_argument("--caption_column",type=str,default="prompt",help="The column of the dataset containing a caption or a list of captions.")
+    parser.add_argument("--label_column",type=str,default=None,help="The column of the dataset containing the original labels. `seg_map` for ADE20K; `panoptic_seg_map` for COCO-Stuff.")
+    parser.add_argument("--max_train_samples",type=int,default=None)
+    parser.add_argument("--image_condition_dropout",type=float,default=0)
+    parser.add_argument("--text_condition_dropout",type=float,default=0)
+    parser.add_argument("--all_condition_dropout",type=float,default=0)
+    
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_t2i_hed.py

@@ -0,0 +1,291 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT
+#   nanoGPT: https://github.com/karpathy/nanoGPT
+from PIL import PngImagePlugin
+MaximumDecompressedSize = 1024
+MegaByte = 2**20
+PngImagePlugin.MAX_TEXT_CHUNK = MaximumDecompressedSize * MegaByte
+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 torchvision import transforms
+from glob import glob
+import time
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from utils.logger import create_logger
+from dataset.build import build_dataset
+from dataset.augmentation import center_crop_arr
+from autoregressive.train.train_c2i import creat_optimizer
+from autoregressive.models.gpt_t2i import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from accelerate.utils import ProjectConfiguration, set_seed
+from pathlib import Path
+from accelerate import Accelerator
+from language.t5 import T5Embedder
+from dataset.t2i_control import build_t2i_control_code
+import torch._dynamo
+from condition.hed import HEDdetector
+torch._dynamo.config.suppress_errors = True
+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("/", "-") 
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"
+        checkpoint_dir = f"{experiment_dir}/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
+    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=args.dropout_p,
+        ffn_dropout_p=args.dropout_p,
+        token_dropout_p=args.token_dropout_p,
+        adapter_size=args.adapter_size,
+        condition_type=args.condition_type,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+    get_condition = HEDdetector().to(device).eval()
+
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+
+    train_dataset = build_t2i_control_code(args)
+    sampler = DistributedSampler(
+        train_dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+
+    loader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=False,
+        collate_fn=train_dataset.collate_fn,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        num_workers=args.num_workers,
+        pin_memory=True,
+        sampler=sampler,
+        drop_last=True
+    )
+    logger.info(f"Dataset contains {len(train_dataset):,} images")
+
+    # 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)
+        # 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 not args.no_compile:
+        logger.info("compiling the model... (may take several minutes)")
+        model = torch.compile(model) # requires PyTorch 2.0        
+    # model.zero_init_mlp()
+    model = DDP(model.to(device), device_ids=[args.gpu], find_unused_parameters=True)
+    model.train()  # important! This enables embedding dropout for classifier-free guidance
+    
+    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, attn_mask, valid in loader:
+        for batch in loader:
+
+            x = batch['code']
+            caption_emb = batch['caption_emb']
+            condition_img = batch['control']
+
+            attn_mask = batch['attn_mask']
+            valid = batch['valid']
+            y = caption_emb
+            x = x.to(device, non_blocking=True)
+            y = y.to(device, non_blocking=True)
+            condition_img = condition_img.to(device, non_blocking=True)
+
+            with torch.no_grad():
+                condition_img = get_condition(condition_img).unsqueeze(1).repeat(1,3,1,1)
+                condition_img = 2*(condition_img/255 - 0.5)
+    
+            z_indices = x.reshape(x.shape[0], -1)
+            c_indices = y.reshape(y.shape[0], y.shape[-2], y.shape[-1])
+            assert z_indices.shape[0] == c_indices.shape[0]
+            attn_mask = attn_mask.reshape(attn_mask.shape[0], 1, attn_mask.shape[-2], attn_mask.shape[-1]) # (bs, n_head, seq_len, seq_len)
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, mask=attn_mask[:, :, :-1,:-1], valid=valid, 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)
+
+            # 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 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("--data-path", type=str, required=False)
+    parser.add_argument("--t5-feat-path", type=str, required=False)
+    parser.add_argument("--short-t5-feat-path", type=str, default=None, help="short caption of t5_feat_path")
+    parser.add_argument("--cloud-save-path", type=str, required=False, 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 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("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL")
+    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="t2i")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--cls-token-num", type=int, default=120, 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", type=float, default=0.0, help="drop_path_rate of attention and ffn")
+    parser.add_argument("--no-compile", action='store_true')
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='t2i_control')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512], 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("--epochs", type=int, default=3)
+    parser.add_argument("--lr", type=float, default=5e-5)
+    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=88)
+    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=10000)
+    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, choices=['canny', 'hed', 'lineart', 'depth'], default="hed")
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--code-path2", type=str, default=None)
+    parser.add_argument("--get-image", type=bool, default=True)
+    parser.add_argument("--get-prompt", type=bool, default=False)
+    parser.add_argument("--get-label", type=bool, default=False)
+    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("--keep_in_memory",type=bool,default=False)
+    parser.add_argument("--wrong_ids_file",type=str,default=None)
+    parser.add_argument("--logging_dir",type=str,default="logs")
+    parser.add_argument("--adapter-size", type=str, default='small')
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_t2i_hed_multiscale.py

@@ -0,0 +1,342 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT
+#   nanoGPT: https://github.com/karpathy/nanoGPT
+import warnings
+warnings.filterwarnings("ignore")
+from PIL import PngImagePlugin
+MaximumDecompressedSize = 1024
+MegaByte = 2**20
+PngImagePlugin.MAX_TEXT_CHUNK = MaximumDecompressedSize * MegaByte
+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 torchvision import transforms
+from glob import glob
+import time
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from utils.logger import create_logger
+from dataset.build import build_dataset
+from dataset.augmentation import center_crop_arr
+from autoregressive.train.train_c2i import creat_optimizer
+from autoregressive.models.gpt_t2i import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from accelerate.utils import ProjectConfiguration, set_seed
+from pathlib import Path
+from accelerate import Accelerator
+from language.t5 import T5Embedder
+from dataset.t2i_control import build_t2i_control_code
+import torch._dynamo
+torch._dynamo.config.suppress_errors = True
+import random
+import torch.nn.functional as F
+from condition.hed import HEDdetector
+def random_sample_scale(image, condition=None):
+
+    H = np.arange(384, 1024+16, 16)
+    W = np.arange(384, 1024+16, 16)
+    resolution = [1024,1024]
+    while resolution[0]//16+resolution[1]//16 > 2304:
+        resolution = [random.choice(H), random.choice(W)]
+    assert resolution[0]//16+resolution[1]//16 <= 2304
+    image = F.interpolate(image.to(torch.float32), size=resolution, mode='bilinear', align_corners=False, antialias=True)
+    if condition is not None:
+        condition = F.interpolate(condition.to(torch.float32), size=resolution, mode='bilinear', align_corners=False, antialias=True)
+        return image, condition
+    return image
+
+
+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("/", "-") 
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"
+        checkpoint_dir = f"{experiment_dir}/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
+    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=args.dropout_p,
+        ffn_dropout_p=args.dropout_p,
+        token_dropout_p=args.token_dropout_p,
+        condition_type=args.condition_type,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+
+    # Setup data:
+    if args.dataset == 't2i_control':     # 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        
+
+    # train_dataset,val_dataset = build_dataset(args, tokenizer=None, accelerator=accelerator)
+    train_dataset = build_t2i_control_code(args)
+    sampler = DistributedSampler(
+        train_dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+
+    loader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=False,
+        collate_fn=train_dataset.collate_fn,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        num_workers=args.num_workers,
+        pin_memory=True,
+        sampler=sampler,
+        drop_last=True
+    )
+    logger.info(f"Dataset contains {len(train_dataset):,} images")
+
+    # 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)
+        # 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 not args.no_compile:
+        logger.info("compiling the model... (may take several minutes)")
+        model = torch.compile(model) # requires PyTorch 2.0        
+    # model.zero_init_mlp()
+    model = DDP(model.to(device), device_ids=[args.gpu], find_unused_parameters=True)
+    model.train()  # important! This enables embedding dropout for classifier-free guidance
+
+    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()
+    get_condition = HEDdetector().to(device).eval()
+    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['code']
+            image = batch['image']
+            caption_emb = batch['caption_emb']
+            condition_img = batch['control']
+            condition_img = 2*(condition_img - 0.5)
+            attn_mask = batch['attn_mask']
+            valid = batch['valid']
+            y = caption_emb
+            x = x.to(device, non_blocking=True)
+            image = image.to(device, non_blocking=True)
+            y = y.to(device, non_blocking=True)
+            condition_img = condition_img.to(device, non_blocking=True)
+            image = random_sample_scale(image)
+            with torch.no_grad():
+                condition_img = get_condition(image).unsqueeze(1).repeat(1,3,1,1)
+                condition_img = 2*(condition_img/255 - 0.5)
+         
+            if args.dataset == 't2i_control':
+                img = 2*(image/255 - 0.5)
+                
+                with torch.no_grad():
+                    _, _, [_, _, indices] = vq_model.encode(img)
+                x = indices.reshape(img.shape[0], -1)
+            z_indices = x.reshape(x.shape[0], -1)
+            c_indices = y.reshape(y.shape[0], y.shape[-2], y.shape[-1])
+            assert z_indices.shape[0] == c_indices.shape[0]
+            attn_mask = attn_mask.reshape(attn_mask.shape[0], 1, attn_mask.shape[-2], attn_mask.shape[-1]) # (bs, n_head, seq_len, seq_len)
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, mask=attn_mask[:, :, :x.shape[1]+120-1,:x.shape[1]+120-1], valid=valid, 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)
+
+            # 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 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("--data-path", type=str, required=False)
+    parser.add_argument("--t5-feat-path", type=str, required=False)
+    parser.add_argument("--short-t5-feat-path", type=str, default=None, help="short caption of t5_feat_path")
+    parser.add_argument("--cloud-save-path", type=str, required=False, 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 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("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL")
+    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="t2i")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--cls-token-num", type=int, default=120, 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", type=float, default=0.0, help="drop_path_rate of attention and ffn")
+    parser.add_argument("--no-compile", action='store_true')
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='t2i_control')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512, 768, 832, 896, 960], 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("--epochs", type=int, default=15)
+    parser.add_argument("--lr", type=float, default=1e-5)
+    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=16)
+    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=10000)
+    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("--code-path", type=str, required=True)
+    parser.add_argument("--code-path2", type=str, default=None)
+    parser.add_argument("--condition-type", type=str, choices=['segmentation', 'canny', 'hed', 'lineart', 'depth'], default="hed")
+    parser.add_argument("--get-image", type=bool, default=True)
+    parser.add_argument("--get-prompt", type=bool, default=False)
+    parser.add_argument("--get-label", type=bool, default=False)
+    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("--keep_in_memory",type=bool,default=False)
+    parser.add_argument("--wrong_ids_file",type=str,default=None)
+    parser.add_argument("--logging_dir",type=str,default="logs")
+    parser.add_argument("--report_to",type=str,default="wandb")
+    parser.add_argument("--task_name",type=str,default='segmentation')
+    parser.add_argument("--dataset_name",type=str,default=None)
+    parser.add_argument("--dataset_config_name",type=str,default=None)
+    
+    parser.add_argument("--image_column", type=str, default="image", help="The column of the dataset containing the target image.")
+    parser.add_argument("--conditioning_image_column",type=str,default="control_seg",help="The column of the dataset containing the controlnet conditioning image.")
+    parser.add_argument("--caption_column",type=str,default="prompt",help="The column of the dataset containing a caption or a list of captions.")
+    parser.add_argument("--label_column",type=str,default=None,help="The column of the dataset containing the original labels. `seg_map` for ADE20K; `panoptic_seg_map` for COCO-Stuff.")
+    parser.add_argument("--max_train_samples",type=int,default=None)
+    parser.add_argument("--image_condition_dropout",type=float,default=0)
+    parser.add_argument("--text_condition_dropout",type=float,default=0)
+    parser.add_argument("--all_condition_dropout",type=float,default=0)
+    
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_t2i_lineart.py

@@ -0,0 +1,290 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT
+#   nanoGPT: https://github.com/karpathy/nanoGPT
+from PIL import PngImagePlugin
+MaximumDecompressedSize = 1024
+MegaByte = 2**20
+PngImagePlugin.MAX_TEXT_CHUNK = MaximumDecompressedSize * MegaByte
+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 torchvision import transforms
+from glob import glob
+import time
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from utils.logger import create_logger
+from dataset.build import build_dataset
+from dataset.augmentation import center_crop_arr
+from autoregressive.train.train_c2i import creat_optimizer
+from autoregressive.models.gpt_t2i import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from accelerate.utils import ProjectConfiguration, set_seed
+from pathlib import Path
+from accelerate import Accelerator
+from language.t5 import T5Embedder
+from dataset.t2i_control import build_t2i_control_code
+import torch._dynamo
+from condition.hed import HEDdetector
+from condition.lineart import LineArt
+torch._dynamo.config.suppress_errors = True
+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("/", "-") 
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"
+        checkpoint_dir = f"{experiment_dir}/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
+    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=args.dropout_p,
+        ffn_dropout_p=args.dropout_p,
+        token_dropout_p=args.token_dropout_p,
+        condition_type=args.condition_type,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+    get_condition = LineArt()
+    get_condition.load_state_dict(torch.load('/data/vjuicefs_sz_cv_v2/11171709/ControlAR/condition/ckpts/model.pth', map_location=torch.device('cpu')))
+    get_condition.to(device)
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+
+    train_dataset = build_t2i_control_code(args)
+    sampler = DistributedSampler(
+        train_dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+
+    loader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=False,
+        collate_fn=train_dataset.collate_fn,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        num_workers=args.num_workers,
+        pin_memory=True,
+        sampler=sampler,
+        drop_last=True
+    )
+    logger.info(f"Dataset contains {len(train_dataset):,} images")
+
+    # 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)
+        # 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 not args.no_compile:
+        logger.info("compiling the model... (may take several minutes)")
+        model = torch.compile(model) # requires PyTorch 2.0        
+    # model.zero_init_mlp()
+    model = DDP(model.to(device), device_ids=[args.gpu], find_unused_parameters=True)
+    model.train()  # important! This enables embedding dropout for classifier-free guidance
+    
+    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['code']
+            caption_emb = batch['caption_emb']
+            condition_img = batch['control']
+
+            attn_mask = batch['attn_mask']
+            valid = batch['valid']
+            y = caption_emb
+            x = x.to(device, non_blocking=True)
+            y = y.to(device, non_blocking=True)
+            condition_img = condition_img.to(device, non_blocking=True)
+            with torch.no_grad():
+                condition_img = get_condition(condition_img.float()).repeat(1,3,1,1)
+                condition_img = 2*(condition_img - 0.5)
+    
+            z_indices = x.reshape(x.shape[0], -1)
+            c_indices = y.reshape(y.shape[0], y.shape[-2], y.shape[-1])
+            assert z_indices.shape[0] == c_indices.shape[0]
+            attn_mask = attn_mask.reshape(attn_mask.shape[0], 1, attn_mask.shape[-2], attn_mask.shape[-1]) # (bs, n_head, seq_len, seq_len)
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, mask=attn_mask[:, :, :-1,:-1], valid=valid, 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)
+
+            # 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 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("--data-path", type=str, required=False)
+    parser.add_argument("--t5-feat-path", type=str, required=False)
+    parser.add_argument("--short-t5-feat-path", type=str, default=None, help="short caption of t5_feat_path")
+    parser.add_argument("--cloud-save-path", type=str, required=False, 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 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("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL")
+    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="t2i")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--cls-token-num", type=int, default=120, 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", type=float, default=0.0, help="drop_path_rate of attention and ffn")
+    parser.add_argument("--no-compile", action='store_true')
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='t2i_control')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512], 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("--epochs", type=int, default=3)
+    parser.add_argument("--lr", type=float, default=5e-5)
+    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=88)
+    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=10000)
+    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, choices=['canny', 'hed', 'lineart', 'depth'], default="lineart")
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--code-path2", type=str, default=None)
+    parser.add_argument("--get-image", type=bool, default=True)
+    parser.add_argument("--get-prompt", type=bool, default=False)
+    parser.add_argument("--get-label", type=bool, default=False)
+    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("--keep_in_memory",type=bool,default=False)
+    parser.add_argument("--wrong_ids_file",type=str,default=None)
+    parser.add_argument("--logging_dir",type=str,default="logs")
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_t2i_lineart_multiscale.py

@@ -0,0 +1,343 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT
+#   nanoGPT: https://github.com/karpathy/nanoGPT
+import warnings
+warnings.filterwarnings("ignore")
+from PIL import PngImagePlugin
+MaximumDecompressedSize = 1024
+MegaByte = 2**20
+PngImagePlugin.MAX_TEXT_CHUNK = MaximumDecompressedSize * MegaByte
+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 torchvision import transforms
+from glob import glob
+import time
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from utils.logger import create_logger
+from dataset.build import build_dataset
+from dataset.augmentation import center_crop_arr
+from autoregressive.train.train_c2i import creat_optimizer
+
+from autoregressive.models.gpt_t2i import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from accelerate.utils import ProjectConfiguration, set_seed
+from pathlib import Path
+from accelerate import Accelerator
+from language.t5 import T5Embedder
+from dataset.t2i_control import build_t2i_control_code
+import torch._dynamo
+torch._dynamo.config.suppress_errors = True
+import random
+import torch.nn.functional as F
+from condition.hed import HEDdetector
+from condition.lineart import LineArt
+def random_sample_scale(image, condition=None):
+    H = np.arange(384, 1024+16, 16)
+    W = np.arange(384, 1024+16, 16)
+    resolution = [1024,1024]
+    while resolution[0]//16+resolution[1]//16 > 2304:
+        resolution = [random.choice(H), random.choice(W)]
+    assert resolution[0]//16+resolution[1]//16 <= 2304
+    image = F.interpolate(image.to(torch.float32), size=resolution, mode='bilinear', align_corners=False, antialias=True)
+    if condition is not None:
+        condition = F.interpolate(condition.to(torch.float32), size=resolution, mode='bilinear', align_corners=False, antialias=True)
+        return image, condition
+    return image
+
+
+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("/", "-") 
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"
+        checkpoint_dir = f"{experiment_dir}/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
+    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=args.dropout_p,
+        ffn_dropout_p=args.dropout_p,
+        token_dropout_p=args.token_dropout_p,
+        condition_type=args.condition_type,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+    get_condition = LineArt()
+    get_condition.load_state_dict(torch.load('/data/vjuicefs_sz_cv_v2/11171709/ControlAR/condition/ckpts/model.pth', map_location=torch.device('cpu')))
+    get_condition.to(device)
+    
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+
+    # Setup data:
+    if args.dataset == 't2i_control':     # 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        
+    
+    train_dataset = build_t2i_control_code(args)
+    sampler = DistributedSampler(
+        train_dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+
+    loader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=False,
+        collate_fn=train_dataset.collate_fn,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        num_workers=args.num_workers,
+        pin_memory=True,
+        sampler=sampler,
+        drop_last=True
+    )
+    logger.info(f"Dataset contains {len(train_dataset):,} images")
+
+    # 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)
+        # 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 not args.no_compile:
+        logger.info("compiling the model... (may take several minutes)")
+        model = torch.compile(model) # requires PyTorch 2.0        
+    # model.zero_init_mlp()
+    model = DDP(model.to(device), device_ids=[args.gpu], find_unused_parameters=True)
+    model.train()  # important! This enables embedding dropout for classifier-free guidance
+    
+    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()
+    # get_condition = HEDdetector().to(device).eval()
+    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['code']
+            image = batch['image']
+            caption_emb = batch['caption_emb']
+            condition_img = batch['control']
+            condition_img = 2*(condition_img - 0.5)
+            attn_mask = batch['attn_mask']
+            valid = batch['valid']
+            y = caption_emb
+            x = x.to(device, non_blocking=True)
+            image = image.to(device, non_blocking=True)
+            y = y.to(device, non_blocking=True)
+            condition_img = condition_img.to(device, non_blocking=True)
+            image = random_sample_scale(image)
+            with torch.no_grad():
+                condition_img = get_condition(image.float()).repeat(1,3,1,1)
+                condition_img = 2*(condition_img - 0.5)
+           
+            if args.dataset == 't2i_control':
+                img = 2*(image/255 - 0.5)
+                
+                with torch.no_grad():
+                    _, _, [_, _, indices] = vq_model.encode(img)
+                x = indices.reshape(img.shape[0], -1)
+            z_indices = x.reshape(x.shape[0], -1)
+            c_indices = y.reshape(y.shape[0], y.shape[-2], y.shape[-1])
+            assert z_indices.shape[0] == c_indices.shape[0]
+            attn_mask = attn_mask.reshape(attn_mask.shape[0], 1, attn_mask.shape[-2], attn_mask.shape[-1]) # (bs, n_head, seq_len, seq_len)
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, mask=attn_mask[:, :, :x.shape[1]+120-1,:x.shape[1]+120-1], valid=valid, 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)
+
+            # 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 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("--data-path", type=str, required=False)
+    parser.add_argument("--t5-feat-path", type=str, required=False)
+    parser.add_argument("--short-t5-feat-path", type=str, default=None, help="short caption of t5_feat_path")
+    parser.add_argument("--cloud-save-path", type=str, required=False, 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 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("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL")
+    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="t2i")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--cls-token-num", type=int, default=120, 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", type=float, default=0.0, help="drop_path_rate of attention and ffn")
+    parser.add_argument("--no-compile", action='store_true')
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='t2i_control')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512, 768, 832, 896, 960], 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("--epochs", type=int, default=15)
+    parser.add_argument("--lr", type=float, default=1e-5)
+    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=16)
+    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=30000)
+    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("--code-path", type=str, required=True)
+    parser.add_argument("--code-path2", type=str, default=None)
+    parser.add_argument("--condition-type", type=str, choices=['segmentation', 'canny', 'hed', 'lineart', 'depth'], default="lineart")
+    parser.add_argument("--get-image", type=bool, default=True)
+    parser.add_argument("--get-prompt", type=bool, default=False)
+    parser.add_argument("--get-label", type=bool, default=False)
+    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("--keep_in_memory",type=bool,default=False)
+    parser.add_argument("--wrong_ids_file",type=str,default=None)
+    parser.add_argument("--logging_dir",type=str,default="logs")
+    parser.add_argument("--report_to",type=str,default="wandb")
+    parser.add_argument("--task_name",type=str,default='segmentation')
+    parser.add_argument("--dataset_name",type=str,default=None)
+    parser.add_argument("--dataset_config_name",type=str,default=None)
+    
+    parser.add_argument("--image_column", type=str, default="image", help="The column of the dataset containing the target image.")
+    parser.add_argument("--conditioning_image_column",type=str,default="control_seg",help="The column of the dataset containing the controlnet conditioning image.")
+    parser.add_argument("--caption_column",type=str,default="prompt",help="The column of the dataset containing a caption or a list of captions.")
+    parser.add_argument("--label_column",type=str,default=None,help="The column of the dataset containing the original labels. `seg_map` for ADE20K; `panoptic_seg_map` for COCO-Stuff.")
+    parser.add_argument("--max_train_samples",type=int,default=None)
+    parser.add_argument("--image_condition_dropout",type=float,default=0)
+    parser.add_argument("--text_condition_dropout",type=float,default=0)
+    parser.add_argument("--all_condition_dropout",type=float,default=0)
+    
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_t2i_seg.py

@@ -0,0 +1,298 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT
+#   nanoGPT: https://github.com/karpathy/nanoGPT
+from PIL import PngImagePlugin
+MaximumDecompressedSize = 1024
+MegaByte = 2**20
+PngImagePlugin.MAX_TEXT_CHUNK = MaximumDecompressedSize * MegaByte
+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 torchvision import transforms
+from glob import glob
+import time
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from utils.logger import create_logger
+from dataset.build import build_dataset
+from dataset.augmentation import center_crop_arr
+from autoregressive.train.train_c2i import creat_optimizer
+from torch.optim.lr_scheduler import StepLR
+
+from autoregressive.models.gpt_t2i import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from accelerate.utils import ProjectConfiguration, set_seed
+from pathlib import Path
+from accelerate import Accelerator
+from language.t5 import T5Embedder
+from dataset.t2i_control import build_t2i_control_code
+import torch._dynamo
+torch._dynamo.config.suppress_errors = True
+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("/", "-") 
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"
+        checkpoint_dir = f"{experiment_dir}/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
+    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=args.dropout_p,
+        ffn_dropout_p=args.dropout_p,
+        token_dropout_p=args.token_dropout_p,
+        adapter_size=args.adapter_size,
+        condition_type=args.condition_type,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+    lr_scheduler = StepLR(optimizer, step_size=1, gamma=0.9) # 每10个epoch后，学习率乘以0.1
+
+    # 加载数据集
+    train_dataset = build_t2i_control_code(args)
+    sampler = DistributedSampler(
+        train_dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+
+    loader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=False,
+        collate_fn=train_dataset.collate_fn,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        num_workers=args.num_workers,
+        pin_memory=True,
+        sampler=sampler,
+        drop_last=True
+    )
+    logger.info(f"Dataset contains {len(train_dataset):,} images")
+
+    # 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)
+        # 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 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
+    
+
+    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)# 设定采样器的 epoch
+        logger.info(f"Beginning epoch {epoch}...")
+        # 载入数据
+        for batch in loader:
+            
+            x = batch['code']# 生成的图像的 VQ 代码
+            caption_emb = batch['caption_emb']# 文本 T5 Embedding
+            condition_img = batch['control'] # 条件图像（如 Canny Edge）
+
+            attn_mask = batch['attn_mask']# 注意力掩码
+            valid = batch['valid'] # 有效性标记
+            y = caption_emb # `y` 作为 `GPT` 的 condition
+            
+            #将数据移到GPU
+            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(y.shape[0], y.shape[-2], y.shape[-1])
+            assert z_indices.shape[0] == c_indices.shape[0]
+            attn_mask = attn_mask.reshape(attn_mask.shape[0], 1, attn_mask.shape[-2], attn_mask.shape[-1]) # (bs, n_head, seq_len, seq_len)
+            
+            # 前向传播
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, mask=attn_mask[:, :, :-1,:-1], valid=valid, 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)
+
+            # 记录训练损失 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 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()
+        lr_scheduler.step()
+
+        for param_group in optimizer.param_groups:
+            print(f"Epoch {epoch + 1}, LR: {param_group['lr']}")
+    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, required=False)
+    parser.add_argument("--t5-feat-path", type=str, required=False)
+    parser.add_argument("--short-t5-feat-path", type=str, default=None, help="short caption of t5_feat_path")
+    parser.add_argument("--cloud-save-path", type=str, required=False, 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 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("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL")
+    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="t2i")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--cls-token-num", type=int, default=120, 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", type=float, default=0.0, help="drop_path_rate of attention and ffn")
+    parser.add_argument("--no-compile", action='store_true')
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='t2i_control')
+    parser.add_argument("--image-size", type=int, choices=[256, 384, 512], 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("--epochs", type=int, default=20)
+    parser.add_argument("--lr", type=float, default=5e-5)
+    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=96)
+    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=1443)
+    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, choices=['segmentation', 'canny', 'hed', 'lineart', 'depth'], default="segmentation")
+    parser.add_argument("--code-path", type=str, required=True)
+    parser.add_argument("--code-path2", type=str, default=None)
+    parser.add_argument("--adapter-size", type=str, default='small')
+    parser.add_argument("--get-image", type=bool, default=False)
+    parser.add_argument("--get-prompt", type=bool, default=False)
+    parser.add_argument("--get-label", type=bool, default=False)
+    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)
+    
+    args = parser.parse_args()
+    main(args)

autoregressive/train/train_t2i_seg_multiscale.py

@@ -0,0 +1,338 @@
+# Modified from:
+#   fast-DiT: https://github.com/chuanyangjin/fast-DiT
+#   nanoGPT: https://github.com/karpathy/nanoGPT
+import warnings
+warnings.filterwarnings("ignore")
+from PIL import PngImagePlugin
+MaximumDecompressedSize = 1024
+MegaByte = 2**20
+PngImagePlugin.MAX_TEXT_CHUNK = MaximumDecompressedSize * MegaByte
+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 torchvision import transforms
+from glob import glob
+import time
+import argparse
+import os
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from utils.distributed import init_distributed_mode
+from utils.logger import create_logger
+from dataset.build import build_dataset
+from dataset.augmentation import center_crop_arr
+from autoregressive.train.train_c2i import creat_optimizer
+
+from autoregressive.models.gpt_t2i import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from accelerate.utils import ProjectConfiguration, set_seed
+from pathlib import Path
+from accelerate import Accelerator
+from language.t5 import T5Embedder
+from dataset.t2i_control import build_t2i_control_code
+import torch._dynamo
+torch._dynamo.config.suppress_errors = True
+import random
+import torch.nn.functional as F
+from condition.hed import HEDdetector
+def random_sample_scale(image, condition=None):
+    H = np.arange(384, 1024+16, 16)
+    W = np.arange(384, 1024+16, 16)
+    resolution = [1024,1024]
+    while resolution[0]//16+resolution[1]//16 > 2304:
+        resolution = [random.choice(H), random.choice(W)]
+    assert resolution[0]//16+resolution[1]//16 <= 2304
+    image = F.interpolate(image.to(torch.float32), size=resolution, mode='bilinear', align_corners=False, antialias=True)
+    if condition is not None:
+        condition = F.interpolate(condition.to(torch.float32), size=resolution, mode='bilinear', align_corners=False, antialias=True)
+        return image, condition
+    return image
+
+
+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("/", "-") 
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"
+        checkpoint_dir = f"{experiment_dir}/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
+    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=args.dropout_p,
+        ffn_dropout_p=args.dropout_p,
+        token_dropout_p=args.token_dropout_p,
+        condition_type=args.condition_type,
+    ).to(device)
+    logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+
+    # Setup optimizer
+    optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger)
+
+    # Setup data:
+    if args.dataset == 't2i_control':     # 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        
+    train_dataset = build_t2i_control_code(args)
+    sampler = DistributedSampler(
+        train_dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+
+    loader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=False,
+        collate_fn=train_dataset.collate_fn,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        num_workers=args.num_workers,
+        pin_memory=True,
+        sampler=sampler,
+        drop_last=True
+    )
+    logger.info(f"Dataset contains {len(train_dataset):,} images")
+
+    # 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)
+        # 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 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
+    
+
+    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()
+    get_condition = HEDdetector().to(device).eval()
+    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['code']
+            image = batch['image']
+            caption_emb = batch['caption_emb']
+            condition_img = batch['control']
+            condition_img = 2*(condition_img - 0.5)
+            attn_mask = batch['attn_mask']
+            valid = batch['valid']
+            y = caption_emb
+            x = x.to(device, non_blocking=True)
+            image = image.to(device, non_blocking=True)
+            y = y.to(device, non_blocking=True)
+            condition_img = condition_img.to(device, non_blocking=True)
+            with torch.no_grad():
+                condition_img = get_condition(image).unsqueeze(1).repeat(1,3,1,1)
+                condition_img = 2*(condition_img/255 - 0.5)
+            image, condition_img = random_sample_scale(image, condition_img)
+
+            if args.dataset == 't2i_control':
+                img = 2*(image/255 - 0.5)
+                
+                with torch.no_grad():
+                    _, _, [_, _, indices] = vq_model.encode(img)
+                x = indices.reshape(img.shape[0], -1)
+            z_indices = x.reshape(x.shape[0], -1)
+            c_indices = y.reshape(y.shape[0], y.shape[-2], y.shape[-1])
+            assert z_indices.shape[0] == c_indices.shape[0]
+            attn_mask = attn_mask.reshape(attn_mask.shape[0], 1, attn_mask.shape[-2], attn_mask.shape[-1]) # (bs, n_head, seq_len, seq_len)
+            with torch.cuda.amp.autocast(dtype=ptdtype):  
+                _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, mask=attn_mask[:, :, :x.shape[1]+120-1,:x.shape[1]+120-1], valid=valid, 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)
+
+            # 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 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("--data-path", type=str, required=False)
+    parser.add_argument("--t5-feat-path", type=str, required=False)
+    parser.add_argument("--short-t5-feat-path", type=str, default=None, help="short caption of t5_feat_path")
+    parser.add_argument("--cloud-save-path", type=str, required=False, 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 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("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL")
+    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="t2i")
+    parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer")
+    parser.add_argument("--cls-token-num", type=int, default=120, 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", type=float, default=0.0, help="drop_path_rate of attention and ffn")
+    parser.add_argument("--no-compile", action='store_true')
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--dataset", type=str, default='t2i_control')
+    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("--epochs", type=int, default=50)
+    parser.add_argument("--lr", type=float, default=5e-5)
+    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=24)
+    parser.add_argument("--log-every", type=int, default=100)
+    parser.add_argument("--ckpt-every", type=int, default=2000)
+    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("--code-path", type=str, required=True)
+    parser.add_argument("--code-path2", type=str, default=None)
+    parser.add_argument("--condition-type", type=str, choices=['segmentation', 'canny', 'hed', 'lineart', 'depth'], default="segmentation")
+    parser.add_argument("--get-image", type=bool, default=True)
+    parser.add_argument("--get-prompt", type=bool, default=False)
+    parser.add_argument("--get-label", type=bool, default=False)
+    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("--keep_in_memory",type=bool,default=False)
+    parser.add_argument("--wrong_ids_file",type=str,default=None)
+    parser.add_argument("--logging_dir",type=str,default="logs")
+    parser.add_argument("--report_to",type=str,default="wandb")
+    parser.add_argument("--task_name",type=str,default='segmentation')
+    parser.add_argument("--dataset_name",type=str,default=None)
+    parser.add_argument("--dataset_config_name",type=str,default=None)
+    
+    parser.add_argument("--image_column", type=str, default="image", help="The column of the dataset containing the target image.")
+    parser.add_argument("--conditioning_image_column",type=str,default="control_seg",help="The column of the dataset containing the controlnet conditioning image.")
+    parser.add_argument("--caption_column",type=str,default="prompt",help="The column of the dataset containing a caption or a list of captions.")
+    parser.add_argument("--label_column",type=str,default=None,help="The column of the dataset containing the original labels. `seg_map` for ADE20K; `panoptic_seg_map` for COCO-Stuff.")
+    parser.add_argument("--max_train_samples",type=int,default=None)
+    parser.add_argument("--image_condition_dropout",type=float,default=0)
+    parser.add_argument("--text_condition_dropout",type=float,default=0)
+    parser.add_argument("--all_condition_dropout",type=float,default=0)
+    
+    args = parser.parse_args()
+    main(args)

condition/README.md

@@ -0,0 +1,23 @@
+Prepare the preprocessing model
+
+Hed: https://huggingface.co/lllyasviel/Annotators/blob/main/ControlNetHED.pth\
+Lineart: https://huggingface.co/spaces/awacke1/Image-to-Line-Drawings/resolve/main/model.pth\
+depth: https://huggingface.co/lllyasviel/Annotators/blob/main/dpt_hybrid-midas-501f0c75.pt (hybrid for inference)\
+       https://huggingface.co/Intel/dpt-large (large for test conditional consistency and fid)\
+
+We recommend storing them in the following paths
+
+    |---condition
+        |---ckpts
+            |---dpt_large
+                |---config.json
+                |---preprocessor_config.json
+                |---pytorch_model.bin
+            |---ControlNetHED.pth
+            |---dpt_hybrid-midas-501f0c75.pt
+            |---model.pth
+        |---example
+        |---midas
+        .
+        .
+        .

condition/canny.py

@@ -0,0 +1,25 @@
+import cv2
+import torch
+import numpy as np
+
+
+class CannyDetector:
+    def __call__(self, img, low_threshold=100, high_threshold=200):
+        """
+        input: array or tensor (H,W,3)
+        output: array (H,W)
+        """
+        if torch.is_tensor(img):
+            img = img.cpu().detach().numpy().astype(np.uint8)
+        return cv2.Canny(img, low_threshold, high_threshold)
+    
+
+if __name__ == '__main__':
+    apply_canny = CannyDetector()
+    img = cv2.imread('condition/dragon_resize.png')
+    import numpy as np
+    print(img.max())
+    detected_map = apply_canny(img, 100, 200)
+    print(detected_map.shape, detected_map.max(), detected_map.min())
+    cv2.imwrite('condition/example_canny.jpg', detected_map)
+    np.save('condition/example_canny.npy', detected_map[None,None])

condition/depth.py

@@ -0,0 +1,47 @@
+from controlnet_aux import LineartDetector
+import torch
+import cv2
+import numpy as np
+from transformers import DPTImageProcessor, DPTForDepthEstimation
+class Depth:
+    def __init__(self, device):
+        self.model = DPTForDepthEstimation.from_pretrained("condition/ckpts/dpt_large")
+        
+    def __call__(self, input_image):
+        """
+        input: tensor()
+        """
+        control_image = self.model(input_image)
+        return np.array(control_image)
+    
+if __name__ == '__main__':
+    import matplotlib.pyplot as plt
+    from tqdm import tqdm
+    from transformers import DPTImageProcessor, DPTForDepthEstimation
+    from PIL import Image
+
+    image = Image.open('condition/example/t2i/depth/depth.png')
+    img = cv2.imread('condition/example/t2i/depth/depth.png')
+    processor = DPTImageProcessor.from_pretrained("condition/ckpts/dpt_large")
+    model = DPTForDepthEstimation.from_pretrained("condition/ckpts/dpt_large")
+
+    inputs = torch.from_numpy(np.array(img)).permute(2,0,1).unsqueeze(0).float()#
+    inputs = 2*(inputs/255 - 0.5)
+    inputs = processor(images=image, return_tensors="pt", size=(512,512))
+    print(inputs)
+    with torch.no_grad():
+        outputs = model(**inputs)
+        predicted_depth = outputs.predicted_depth
+    print(predicted_depth.shape)
+    prediction = torch.nn.functional.interpolate(
+        predicted_depth.unsqueeze(1),
+        size=image.size[::-1],
+        mode="bicubic",
+        align_corners=False,
+    )
+
+    output = prediction.squeeze().cpu().numpy()
+    formatted = (output * 255 / np.max(output)).astype("uint8")
+    
+    depth = Image.fromarray(formatted)
+    depth.save('condition/example/t2i/depth/example_depth.jpg')

condition/example/c2i/canny/15000.npy

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

condition/example/c2i/canny/2312.npy

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

condition/example/c2i/canny/48850.npy

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

condition/example/c2i/canny/650.npy

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

condition/example/c2i/depth/101.npy

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

condition/example/c2i/depth/10601.npy

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

condition/example/c2i/depth/48901.npy

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

condition/hed.py

@@ -0,0 +1,117 @@
+# This is an improved version and model of HED edge detection with Apache License, Version 2.0.
+# Please use this implementation in your products
+# This implementation may produce slightly different results from Saining Xie's official implementations,
+# but it generates smoother edges and is more suitable for ControlNet as well as other image-to-image translations.
+# Different from official models and other implementations, this is an RGB-input model (rather than BGR)
+# and in this way it works better for gradio's RGB protocol
+
+import os
+import cv2
+import torch
+import numpy as np
+from torch.nn.parallel import DataParallel
+from einops import rearrange
+from condition.utils import annotator_ckpts_path
+import torch.nn.functional as F
+
+class DoubleConvBlock(torch.nn.Module):
+    def __init__(self, input_channel, output_channel, layer_number):
+        super().__init__()
+        self.convs = torch.nn.Sequential()
+        self.convs.append(torch.nn.Conv2d(in_channels=input_channel, out_channels=output_channel, kernel_size=(3, 3), stride=(1, 1), padding=1))
+        for i in range(1, layer_number):
+            self.convs.append(torch.nn.Conv2d(in_channels=output_channel, out_channels=output_channel, kernel_size=(3, 3), stride=(1, 1), padding=1))
+        self.projection = torch.nn.Conv2d(in_channels=output_channel, out_channels=1, kernel_size=(1, 1), stride=(1, 1), padding=0)
+
+    def __call__(self, x, down_sampling=False):
+        h = x
+        if down_sampling:
+            h = torch.nn.functional.max_pool2d(h, kernel_size=(2, 2), stride=(2, 2))
+        for conv in self.convs:
+            h = conv(h)
+            h = torch.nn.functional.relu(h)
+        return h, self.projection(h)
+
+
+class ControlNetHED_Apache2(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.norm = torch.nn.Parameter(torch.zeros(size=(1, 3, 1, 1)))
+        self.block1 = DoubleConvBlock(input_channel=3, output_channel=64, layer_number=2)
+        self.block2 = DoubleConvBlock(input_channel=64, output_channel=128, layer_number=2)
+        self.block3 = DoubleConvBlock(input_channel=128, output_channel=256, layer_number=3)
+        self.block4 = DoubleConvBlock(input_channel=256, output_channel=512, layer_number=3)
+        self.block5 = DoubleConvBlock(input_channel=512, output_channel=512, layer_number=3)
+
+    def __call__(self, x):
+        h = x - self.norm
+        h, projection1 = self.block1(h)
+        h, projection2 = self.block2(h, down_sampling=True)
+        h, projection3 = self.block3(h, down_sampling=True)
+        h, projection4 = self.block4(h, down_sampling=True)
+        h, projection5 = self.block5(h, down_sampling=True)
+        return projection1, projection2, projection3, projection4, projection5
+
+
+class HEDdetector(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        remote_model_path = "https://huggingface.co/lllyasviel/Annotators/resolve/main/ControlNetHED.pth"
+        modelpath = os.path.join(annotator_ckpts_path, "ControlNetHED.pth")
+        if not os.path.exists(modelpath):
+            from basicsr.utils.download_util import load_file_from_url
+            load_file_from_url(remote_model_path, model_dir=annotator_ckpts_path)
+        self.netNetwork = ControlNetHED_Apache2().float()#.to(self.device).eval()
+        self.netNetwork.load_state_dict(torch.load(modelpath))
+
+    def __call__(self, input_image):
+        """
+        input: tensor (B,C,H,W)
+        output: tensor (B,H,W)
+        """
+        B, C, H, W = input_image.shape
+        image_hed = input_image
+
+        edges = self.netNetwork(image_hed)
+        edges = [F.interpolate(e, size=(H, W), mode='bilinear', align_corners=False).squeeze(1) for e in edges]
+        edges = torch.stack(edges, dim=1)
+        edge = 1 / (1 + torch.exp(-torch.mean(edges, dim=1)))
+        edge = (edge * 255.0).clamp(0, 255)
+
+        return edge
+
+
+def nms(x, t, s):
+    x = cv2.GaussianBlur(x.astype(np.float32), (0, 0), s)
+
+    f1 = np.array([[0, 0, 0], [1, 1, 1], [0, 0, 0]], dtype=np.uint8)
+    f2 = np.array([[0, 1, 0], [0, 1, 0], [0, 1, 0]], dtype=np.uint8)
+    f3 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=np.uint8)
+    f4 = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]], dtype=np.uint8)
+
+    y = np.zeros_like(x)
+
+    for f in [f1, f2, f3, f4]:
+        np.putmask(y, cv2.dilate(x, kernel=f) == x, x)
+
+    z = np.zeros_like(y, dtype=np.uint8)
+    z[y > t] = 255
+    return z
+
+if __name__ == '__main__':
+    import matplotlib.pyplot as plt
+    from tqdm import tqdm
+    import torch.nn.functional as F
+    device = torch.device('cuda')
+    apply_hed = HEDdetector().to(device).eval()
+    img = cv2.imread('condition/dragon_1024_512.jpg')
+    H,W = img.shape[:2]
+    resize_img = cv2.resize(img,(512,1024))
+    detected_map = apply_hed(torch.from_numpy(img).permute(2,0,1).unsqueeze(0).cuda())
+    resize_detected_map = apply_hed(torch.from_numpy(resize_img).permute(2,0,1).unsqueeze(0).cuda())
+    cv2.imwrite('condition/example_hed_resize.jpg', resize_detected_map[0].cpu().detach().numpy())
+    resize_detected_map = F.interpolate(resize_detected_map.unsqueeze(0).to(torch.float32), size=(H,W), mode='bilinear', align_corners=False, antialias=True)
+    print(abs(detected_map - resize_detected_map).sum())
+    print(img.shape, img.max(),img.min(),detected_map.shape, detected_map.max(),detected_map.min())
+    cv2.imwrite('condition/example_hed.jpg', detected_map[0].cpu().detach().numpy())
+    cv2.imwrite('condition/example_hed_resized.jpg', resize_detected_map[0,0].cpu().detach().numpy())

condition/lineart.py

@@ -0,0 +1,98 @@
+from controlnet_aux import LineartDetector
+import torch
+import cv2
+import numpy as np
+import torch.nn as nn
+
+
+norm_layer = nn.InstanceNorm2d
+class ResidualBlock(nn.Module):
+    def __init__(self, in_features):
+        super(ResidualBlock, self).__init__()
+
+        conv_block = [  nn.ReflectionPad2d(1),
+                        nn.Conv2d(in_features, in_features, 3),
+                        norm_layer(in_features),
+                        nn.ReLU(inplace=True),
+                        nn.ReflectionPad2d(1),
+                        nn.Conv2d(in_features, in_features, 3),
+                        norm_layer(in_features)
+                        ]
+
+        self.conv_block = nn.Sequential(*conv_block)
+
+    def forward(self, x):
+        return x + self.conv_block(x)
+class LineArt(nn.Module):
+    def __init__(self, input_nc=3, output_nc=1, n_residual_blocks=3, sigmoid=True):
+        super(LineArt, self).__init__()
+
+        # Initial convolution block
+        model0 = [   nn.ReflectionPad2d(3),
+                    nn.Conv2d(input_nc, 64, 7),
+                    norm_layer(64),
+                    nn.ReLU(inplace=True) ]
+        self.model0 = nn.Sequential(*model0)
+
+        # Downsampling
+        model1 = []
+        in_features = 64
+        out_features = in_features*2
+        for _ in range(2):
+            model1 += [  nn.Conv2d(in_features, out_features, 3, stride=2, padding=1),
+                        norm_layer(out_features),
+                        nn.ReLU(inplace=True) ]
+            in_features = out_features
+            out_features = in_features*2
+        self.model1 = nn.Sequential(*model1)
+
+        model2 = []
+        # Residual blocks
+        for _ in range(n_residual_blocks):
+            model2 += [ResidualBlock(in_features)]
+        self.model2 = nn.Sequential(*model2)
+
+        # Upsampling
+        model3 = []
+        out_features = in_features//2
+        for _ in range(2):
+            model3 += [  nn.ConvTranspose2d(in_features, out_features, 3, stride=2, padding=1, output_padding=1),
+                        norm_layer(out_features),
+                        nn.ReLU(inplace=True) ]
+            in_features = out_features
+            out_features = in_features//2
+        self.model3 = nn.Sequential(*model3)
+
+        # Output layer
+        model4 = [  nn.ReflectionPad2d(3),
+                        nn.Conv2d(64, output_nc, 7)]
+        if sigmoid:
+            model4 += [nn.Sigmoid()]
+
+        self.model4 = nn.Sequential(*model4)
+
+    def forward(self, x, cond=None):
+        """
+        input: tensor (B,C,H,W)
+        output: tensor (B,1,H,W) 0~1
+        """
+
+        out = self.model0(x)
+        out = self.model1(out)
+        out = self.model2(out)
+        out = self.model3(out)
+        out = self.model4(out)
+
+        return out
+    
+    
+if __name__ == '__main__':
+    import matplotlib.pyplot as plt
+    from tqdm import tqdm
+    apply_lineart = LineArt()
+    apply_lineart.load_state_dict(torch.load('condition/ckpts/model.pth', map_location=torch.device('cpu')))
+    img = cv2.imread('condition/car_448_768.jpg')
+    img = torch.from_numpy(img).permute(2,0,1).unsqueeze(0).repeat(8,1,1,1).float()
+    detected_map = apply_lineart(img)
+    print(img.shape, img.max(),img.min(),detected_map.shape, detected_map.max(),detected_map.min())
+    cv2.imwrite('condition/example_lineart.jpg', 255*detected_map[0,0].cpu().detach().numpy())

condition/midas/depth.py

@@ -0,0 +1,221 @@
+# Midas Depth Estimation
+# From https://github.com/isl-org/MiDaS
+# MIT LICENSE
+
+import cv2
+import numpy as np
+import torch
+import sys
+sys.path.append('/data/vjuicefs_sz_cv_v2/11171709/ControlAR')
+from einops import rearrange
+# from .api import MiDaSInference
+from condition.utils import annotator_ckpts_path
+from condition.midas.midas.dpt_depth import DPTDepthModel
+from condition.midas.midas.midas_net import MidasNet
+from condition.midas.midas.midas_net_custom import MidasNet_small
+from condition.midas.midas.transforms import Resize, NormalizeImage, PrepareForNet
+import os
+import torch.nn as nn
+from torchvision.transforms import Compose
+
+ISL_PATHS = {
+    "dpt_large": os.path.join(annotator_ckpts_path, "dpt_large-midas-2f21e586.pt"),
+    "dpt_hybrid": os.path.join(annotator_ckpts_path, "dpt_hybrid-midas-501f0c75.pt"),
+    "midas_v21": "",
+    "midas_v21_small": "",
+}
+
+remote_model_path = "https://huggingface.co/lllyasviel/ControlNet/resolve/main/annotator/ckpts/dpt_hybrid-midas-501f0c75.pt"
+
+
+def disabled_train(self, mode=True):
+    """Overwrite model.train with this function to make sure train/eval mode
+    does not change anymore."""
+    return self
+
+
+def load_midas_transform(model_type):
+    # https://github.com/isl-org/MiDaS/blob/master/run.py
+    # load transform only
+    if model_type == "dpt_large":  # DPT-Large
+        net_w, net_h = 384, 384
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "dpt_hybrid":  # DPT-Hybrid
+        net_w, net_h = 384, 384
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "midas_v21":
+        net_w, net_h = 384, 384
+        resize_mode = "upper_bound"
+        normalization = NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+
+    elif model_type == "midas_v21_small":
+        net_w, net_h = 256, 256
+        resize_mode = "upper_bound"
+        normalization = NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+
+    else:
+        assert False, f"model_type '{model_type}' not implemented, use: --model_type large"
+
+    transform = Compose(
+        [
+            Resize(
+                net_w,
+                net_h,
+                resize_target=None,
+                keep_aspect_ratio=True,
+                ensure_multiple_of=32,
+                resize_method=resize_mode,
+                image_interpolation_method=cv2.INTER_CUBIC,
+            ),
+            normalization,
+            PrepareForNet(),
+        ]
+    )
+
+    return transform
+
+
+def load_model(model_type):
+    # https://github.com/isl-org/MiDaS/blob/master/run.py
+    # load network
+    model_path = ISL_PATHS[model_type]
+    if model_type == "dpt_large":  # DPT-Large
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="vitl16_384",
+            non_negative=True,
+        )
+        net_w, net_h = 384, 384
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "dpt_hybrid":  # DPT-Hybrid
+        if not os.path.exists(model_path):
+            from basicsr.utils.download_util import load_file_from_url
+            load_file_from_url(remote_model_path, model_dir=annotator_ckpts_path)
+
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="vitb_rn50_384",
+            non_negative=True,
+        )
+        net_w, net_h = 384, 384
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "midas_v21":
+        model = MidasNet(model_path, non_negative=True)
+        net_w, net_h = 384, 384
+        resize_mode = "upper_bound"
+        normalization = NormalizeImage(
+            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+        )
+
+    elif model_type == "midas_v21_small":
+        model = MidasNet_small(model_path, features=64, backbone="efficientnet_lite3", exportable=True,
+                               non_negative=True, blocks={'expand': True})
+        net_w, net_h = 256, 256
+        resize_mode = "upper_bound"
+        normalization = NormalizeImage(
+            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+        )
+
+    else:
+        print(f"model_type '{model_type}' not implemented, use: --model_type large")
+        assert False
+
+    transform = Compose(
+        [
+            Resize(
+                net_w,
+                net_h,
+                resize_target=None,
+                keep_aspect_ratio=True,
+                ensure_multiple_of=32,
+                resize_method=resize_mode,
+                image_interpolation_method=cv2.INTER_CUBIC,
+            ),
+            normalization,
+            PrepareForNet(),
+        ]
+    )
+
+    return model.eval(), transform
+
+
+class MiDaSInference(nn.Module):
+    MODEL_TYPES_TORCH_HUB = [
+        "DPT_Large",
+        "DPT_Hybrid",
+        "MiDaS_small"
+    ]
+    MODEL_TYPES_ISL = [
+        "dpt_large",
+        "dpt_hybrid",
+        "midas_v21",
+        "midas_v21_small",
+    ]
+
+    def __init__(self, model_type):
+        super().__init__()
+        assert (model_type in self.MODEL_TYPES_ISL)
+        model, _ = load_model(model_type)
+        self.model = model
+        self.model.train = disabled_train
+
+    def forward(self, x):
+        with torch.no_grad():
+            prediction = self.model(x)
+        return prediction
+
+
+class MidasDetector:
+    def __init__(self,device=torch.device('cuda:0'), model_type="dpt_hybrid"):
+        self.device = device
+        self.model = MiDaSInference(model_type=model_type).to(device)
+
+    def __call__(self, input_image, a=np.pi * 2.0, bg_th=0.1):
+        assert input_image.ndim == 3
+        image_depth = input_image
+        with torch.no_grad():
+            image_depth = image_depth
+            image_depth = image_depth / 127.5 - 1.0
+            image_depth = rearrange(image_depth, 'h w c -> 1 c h w')
+            depth = self.model(image_depth)[0]
+
+            depth_pt = depth.clone()
+            depth_pt -= torch.min(depth_pt)
+            depth_pt /= torch.max(depth_pt)
+            depth_pt = depth_pt.cpu().numpy()
+            depth_image = (depth_pt * 255.0).clip(0, 255).astype(np.uint8)
+
+            depth_np = depth.cpu().numpy()
+            x = cv2.Sobel(depth_np, cv2.CV_32F, 1, 0, ksize=3)
+            y = cv2.Sobel(depth_np, cv2.CV_32F, 0, 1, ksize=3)
+            z = np.ones_like(x) * a
+            x[depth_pt < bg_th] = 0
+            y[depth_pt < bg_th] = 0
+            # normal = np.stack([x, y, z], axis=2)
+            # normal /= np.sum(normal ** 2.0, axis=2, keepdims=True) ** 0.5
+            # normal_image = (normal * 127.5 + 127.5).clip(0, 255).astype(np.uint8)
+
+            return depth_image#, normal_image
+        
+if __name__ == '__main__':
+    import matplotlib.pyplot as plt
+    from tqdm import tqdm
+    from PIL import Image
+    import torchvision.transforms.functional as F
+    apply_depth = MidasDetector(device=torch.device('cuda:0'))
+    img = cv2.imread('/data/vjuicefs_sz_cv_v2/11171709/ControlAR_github/condition/example/t2i/multi_resolution/car_1_448_768.jpg')
+    img = cv2.resize(img,(768,448))
+    detected_map = apply_depth(torch.from_numpy(img).cuda().float())
+    print(img.shape, img.max(),img.min(),detected_map.shape, detected_map.max(),detected_map.min())
+    plt.imshow(detected_map, cmap='gray')
+    plt.show()
+    cv2.imwrite('condition/example_depth.jpg', detected_map)
+    # cv2.imwrite('condition/example_normal.jpg', normal_map)

condition/midas/midas/base_model.py

@@ -0,0 +1,16 @@
+import torch
+
+
+class BaseModel(torch.nn.Module):
+    def load(self, path):
+        """Load model from file.
+
+        Args:
+            path (str): file path
+        """
+        parameters = torch.load(path, map_location=torch.device('cpu'))
+
+        if "optimizer" in parameters:
+            parameters = parameters["model"]
+
+        self.load_state_dict(parameters)

condition/midas/midas/blocks.py

@@ -0,0 +1,341 @@
+import torch
+import torch.nn as nn
+
+from .vit import (
+    _make_pretrained_vitb_rn50_384,
+    _make_pretrained_vitl16_384,
+    _make_pretrained_vitb16_384,
+    forward_vit,
+)
+
+def _make_encoder(backbone, features, use_pretrained, groups=1, expand=False, exportable=True, hooks=None, use_vit_only=False, use_readout="ignore",):
+    if backbone == "vitl16_384":
+        pretrained = _make_pretrained_vitl16_384(
+            use_pretrained, hooks=hooks, use_readout=use_readout
+        )
+        scratch = _make_scratch(
+            [256, 512, 1024, 1024], features, groups=groups, expand=expand
+        )  # ViT-L/16 - 85.0% Top1 (backbone)
+    elif backbone == "vitb_rn50_384":
+        pretrained = _make_pretrained_vitb_rn50_384(
+            use_pretrained,
+            hooks=hooks,
+            use_vit_only=use_vit_only,
+            use_readout=use_readout,
+        )
+        scratch = _make_scratch(
+            [256, 512, 768, 768], features, groups=groups, expand=expand
+        )  # ViT-H/16 - 85.0% Top1 (backbone)
+    elif backbone == "vitb16_384":
+        pretrained = _make_pretrained_vitb16_384(
+            use_pretrained, hooks=hooks, use_readout=use_readout
+        )
+        scratch = _make_scratch(
+            [96, 192, 384, 768], features, groups=groups, expand=expand
+        )  # ViT-B/16 - 84.6% Top1 (backbone)
+    elif backbone == "resnext101_wsl":
+        pretrained = _make_pretrained_resnext101_wsl(use_pretrained)
+        scratch = _make_scratch([256, 512, 1024, 2048], features, groups=groups, expand=expand)     # efficientnet_lite3  
+    elif backbone == "efficientnet_lite3":
+        pretrained = _make_pretrained_efficientnet_lite3(use_pretrained, exportable=exportable)
+        scratch = _make_scratch([32, 48, 136, 384], features, groups=groups, expand=expand)  # efficientnet_lite3     
+    else:
+        print(f"Backbone '{backbone}' not implemented")
+        assert False
+        
+    return pretrained, scratch
+
+
+def _make_scratch(in_shape, out_shape, groups=1, expand=False):
+    scratch = nn.Module()
+
+    out_shape1 = out_shape
+    out_shape2 = out_shape
+    out_shape3 = out_shape
+    out_shape4 = out_shape
+    if expand==True:
+        out_shape1 = out_shape
+        out_shape2 = out_shape*2
+        out_shape3 = out_shape*4
+        out_shape4 = out_shape*8
+
+    scratch.layer1_rn = nn.Conv2d(
+        in_shape[0], out_shape1, kernel_size=3, stride=1, padding=1, bias=False, groups=groups
+    )
+    scratch.layer2_rn = nn.Conv2d(
+        in_shape[1], out_shape2, kernel_size=3, stride=1, padding=1, bias=False, groups=groups
+    )
+    scratch.layer3_rn = nn.Conv2d(
+        in_shape[2], out_shape3, kernel_size=3, stride=1, padding=1, bias=False, groups=groups
+    )
+    scratch.layer4_rn = nn.Conv2d(
+        in_shape[3], out_shape4, kernel_size=3, stride=1, padding=1, bias=False, groups=groups
+    )
+
+    return scratch
+
+
+def _make_pretrained_efficientnet_lite3(use_pretrained, exportable=False):
+    efficientnet = torch.hub.load(
+        "rwightman/gen-efficientnet-pytorch",
+        "tf_efficientnet_lite3",
+        pretrained=use_pretrained,
+        exportable=exportable
+    )
+    return _make_efficientnet_backbone(efficientnet)
+
+
+def _make_efficientnet_backbone(effnet):
+    pretrained = nn.Module()
+
+    pretrained.layer1 = nn.Sequential(
+        effnet.conv_stem, effnet.bn1, effnet.act1, *effnet.blocks[0:2]
+    )
+    pretrained.layer2 = nn.Sequential(*effnet.blocks[2:3])
+    pretrained.layer3 = nn.Sequential(*effnet.blocks[3:5])
+    pretrained.layer4 = nn.Sequential(*effnet.blocks[5:9])
+
+    return pretrained
+    
+
+def _make_resnet_backbone(resnet):
+    pretrained = nn.Module()
+    pretrained.layer1 = nn.Sequential(
+        resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1
+    )
+
+    pretrained.layer2 = resnet.layer2
+    pretrained.layer3 = resnet.layer3
+    pretrained.layer4 = resnet.layer4
+
+    return pretrained
+
+
+def _make_pretrained_resnext101_wsl(use_pretrained):
+    resnet = torch.hub.load("facebookresearch/WSL-Images", "resnext101_32x8d_wsl")
+    return _make_resnet_backbone(resnet)
+
+
+
+class Interpolate(nn.Module):
+    """Interpolation module.
+    """
+
+    def __init__(self, scale_factor, mode, align_corners=False):
+        """Init.
+
+        Args:
+            scale_factor (float): scaling
+            mode (str): interpolation mode
+        """
+        super(Interpolate, self).__init__()
+
+        self.interp = nn.functional.interpolate
+        self.scale_factor = scale_factor
+        self.mode = mode
+        self.align_corners = align_corners
+
+    def forward(self, x):
+        """Forward pass.
+
+        Args:
+            x (tensor): input
+
+        Returns:
+            tensor: interpolated data
+        """
+
+        x = self.interp(
+            x, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners
+        )
+
+        return x
+
+
+class ResidualConvUnit(nn.Module):
+    """Residual convolution module.
+    """
+
+    def __init__(self, features):
+        """Init.
+
+        Args:
+            features (int): number of features
+        """
+        super().__init__()
+
+        self.conv1 = nn.Conv2d(
+            features, features, kernel_size=3, stride=1, padding=1, bias=True
+        )
+
+        self.conv2 = nn.Conv2d(
+            features, features, kernel_size=3, stride=1, padding=1, bias=True
+        )
+
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        """Forward pass.
+
+        Args:
+            x (tensor): input
+
+        Returns:
+            tensor: output
+        """
+        out = self.relu(x)
+        out = self.conv1(out)
+        out = self.relu(out)
+        out = self.conv2(out)
+
+        return out + x
+
+
+class FeatureFusionBlock(nn.Module):
+    """Feature fusion block.
+    """
+
+    def __init__(self, features):
+        """Init.
+
+        Args:
+            features (int): number of features
+        """
+        super(FeatureFusionBlock, self).__init__()
+
+        self.resConfUnit1 = ResidualConvUnit(features)
+        self.resConfUnit2 = ResidualConvUnit(features)
+
+    def forward(self, *xs):
+        """Forward pass.
+
+        Returns:
+            tensor: output
+        """
+        output = xs[0]
+
+        if len(xs) == 2:
+            output += self.resConfUnit1(xs[1])
+
+        output = self.resConfUnit2(output)
+
+        output = nn.functional.interpolate(
+            output, scale_factor=2, mode="bilinear", align_corners=True
+        )
+
+        return output
+
+
+
+
+class ResidualConvUnit_custom(nn.Module):
+    """Residual convolution module.
+    """
+
+    def __init__(self, features, activation, bn):
+        """Init.
+
+        Args:
+            features (int): number of features
+        """
+        super().__init__()
+
+        self.bn = bn
+
+        self.groups=1
+
+        self.conv1 = nn.Conv2d(
+            features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups
+        )
+        
+        self.conv2 = nn.Conv2d(
+            features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups
+        )
+
+        if self.bn==True:
+            self.bn1 = nn.BatchNorm2d(features)
+            self.bn2 = nn.BatchNorm2d(features)
+
+        self.activation = activation
+
+        self.skip_add = nn.quantized.FloatFunctional()
+
+    def forward(self, x):
+        """Forward pass.
+
+        Args:
+            x (tensor): input
+
+        Returns:
+            tensor: output
+        """
+        
+        out = self.activation(x)
+        out = self.conv1(out)
+        if self.bn==True:
+            out = self.bn1(out)
+       
+        out = self.activation(out)
+        out = self.conv2(out)
+        if self.bn==True:
+            out = self.bn2(out)
+
+        if self.groups > 1:
+            out = self.conv_merge(out)
+
+        return self.skip_add.add(out, x)
+
+        # return out + x
+
+
+class FeatureFusionBlock_custom(nn.Module):
+    """Feature fusion block.
+    """
+
+    def __init__(self, features, activation, deconv=False, bn=False, expand=False, align_corners=True):
+        """Init.
+
+        Args:
+            features (int): number of features
+        """
+        super(FeatureFusionBlock_custom, self).__init__()
+
+        self.deconv = deconv
+        self.align_corners = align_corners
+
+        self.groups=1
+
+        self.expand = expand
+        out_features = features
+        if self.expand==True:
+            out_features = features//2
+        
+        self.out_conv = nn.Conv2d(features, out_features, kernel_size=1, stride=1, padding=0, bias=True, groups=1)
+
+        self.resConfUnit1 = ResidualConvUnit_custom(features, activation, bn)
+        self.resConfUnit2 = ResidualConvUnit_custom(features, activation, bn)
+        
+        self.skip_add = nn.quantized.FloatFunctional()
+
+    def forward(self, *xs):
+        """Forward pass.
+
+        Returns:
+            tensor: output
+        """
+        output = xs[0]
+
+        if len(xs) == 2:
+            res = self.resConfUnit1(xs[1])
+            output = self.skip_add.add(output, res)
+            # output += res
+
+        output = self.resConfUnit2(output)
+
+        output = nn.functional.interpolate(
+            output, scale_factor=2, mode="bilinear", align_corners=self.align_corners
+        )
+
+        output = self.out_conv(output)
+
+        return output

condition/midas/midas/dpt_depth.py

@@ -0,0 +1,108 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .base_model import BaseModel
+from .blocks import (
+    FeatureFusionBlock,
+    FeatureFusionBlock_custom,
+    Interpolate,
+    _make_encoder,
+    forward_vit,
+)
+
+
+def _make_fusion_block(features, use_bn):
+    return FeatureFusionBlock_custom(
+        features,
+        nn.ReLU(False),
+        deconv=False,
+        bn=use_bn,
+        expand=False,
+        align_corners=True,
+    )
+
+
+class DPT(BaseModel):
+    def __init__(
+        self,
+        head,
+        features=256,
+        backbone="vitb_rn50_384",
+        readout="project",
+        channels_last=False,
+        use_bn=False,
+    ):
+
+        super(DPT, self).__init__()
+
+        self.channels_last = channels_last
+
+        hooks = {
+            "vitb_rn50_384": [0, 1, 8, 11],
+            "vitb16_384": [2, 5, 8, 11],
+            "vitl16_384": [5, 11, 17, 23],
+        }
+
+        # Instantiate backbone and reassemble blocks
+        self.pretrained, self.scratch = _make_encoder(
+            backbone,
+            features,
+            False, # Set to true of you want to train from scratch, uses ImageNet weights
+            groups=1,
+            expand=False,
+            exportable=False,
+            hooks=hooks[backbone],
+            use_readout=readout,
+        )
+
+        self.scratch.refinenet1 = _make_fusion_block(features, use_bn)
+        self.scratch.refinenet2 = _make_fusion_block(features, use_bn)
+        self.scratch.refinenet3 = _make_fusion_block(features, use_bn)
+        self.scratch.refinenet4 = _make_fusion_block(features, use_bn)
+
+        self.scratch.output_conv = head
+
+
+    def forward(self, x):
+        if self.channels_last == True:
+            x.contiguous(memory_format=torch.channels_last)
+
+        layer_1, layer_2, layer_3, layer_4 = forward_vit(self.pretrained, x)
+
+        layer_1_rn = self.scratch.layer1_rn(layer_1)
+        layer_2_rn = self.scratch.layer2_rn(layer_2)
+        layer_3_rn = self.scratch.layer3_rn(layer_3)
+        layer_4_rn = self.scratch.layer4_rn(layer_4)
+
+        path_4 = self.scratch.refinenet4(layer_4_rn)
+        path_3 = self.scratch.refinenet3(path_4, layer_3_rn)
+        path_2 = self.scratch.refinenet2(path_3, layer_2_rn)
+        path_1 = self.scratch.refinenet1(path_2, layer_1_rn)
+
+        out = self.scratch.output_conv(path_1)
+
+        return out
+
+
+class DPTDepthModel(DPT):
+    def __init__(self, path=None, non_negative=True, **kwargs):
+        features = kwargs["features"] if "features" in kwargs else 256
+
+        head = nn.Sequential(
+            nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1),
+            Interpolate(scale_factor=2, mode="bilinear", align_corners=True),
+            nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(True),
+            nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0),
+            nn.ReLU(True) if non_negative else nn.Identity(),
+            nn.Identity(),
+        )
+
+        super().__init__(head, **kwargs)
+
+        if path is not None:
+           self.load(path)
+
+    def forward(self, x):
+        return super().forward(x).squeeze(dim=1)

condition/midas/midas/midas_net.py

@@ -0,0 +1,76 @@
+"""MidashNet: Network for monocular depth estimation trained by mixing several datasets.
+This file contains code that is adapted from
+https://github.com/thomasjpfan/pytorch_refinenet/blob/master/pytorch_refinenet/refinenet/refinenet_4cascade.py
+"""
+import torch
+import torch.nn as nn
+
+from .base_model import BaseModel
+from .blocks import FeatureFusionBlock, Interpolate, _make_encoder
+
+
+class MidasNet(BaseModel):
+    """Network for monocular depth estimation.
+    """
+
+    def __init__(self, path=None, features=256, non_negative=True):
+        """Init.
+
+        Args:
+            path (str, optional): Path to saved model. Defaults to None.
+            features (int, optional): Number of features. Defaults to 256.
+            backbone (str, optional): Backbone network for encoder. Defaults to resnet50
+        """
+        print("Loading weights: ", path)
+
+        super(MidasNet, self).__init__()
+
+        use_pretrained = False if path is None else True
+
+        self.pretrained, self.scratch = _make_encoder(backbone="resnext101_wsl", features=features, use_pretrained=use_pretrained)
+
+        self.scratch.refinenet4 = FeatureFusionBlock(features)
+        self.scratch.refinenet3 = FeatureFusionBlock(features)
+        self.scratch.refinenet2 = FeatureFusionBlock(features)
+        self.scratch.refinenet1 = FeatureFusionBlock(features)
+
+        self.scratch.output_conv = nn.Sequential(
+            nn.Conv2d(features, 128, kernel_size=3, stride=1, padding=1),
+            Interpolate(scale_factor=2, mode="bilinear"),
+            nn.Conv2d(128, 32, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(True),
+            nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0),
+            nn.ReLU(True) if non_negative else nn.Identity(),
+        )
+
+        if path:
+            self.load(path)
+
+    def forward(self, x):
+        """Forward pass.
+
+        Args:
+            x (tensor): input data (image)
+
+        Returns:
+            tensor: depth
+        """
+
+        layer_1 = self.pretrained.layer1(x)
+        layer_2 = self.pretrained.layer2(layer_1)
+        layer_3 = self.pretrained.layer3(layer_2)
+        layer_4 = self.pretrained.layer4(layer_3)
+
+        layer_1_rn = self.scratch.layer1_rn(layer_1)
+        layer_2_rn = self.scratch.layer2_rn(layer_2)
+        layer_3_rn = self.scratch.layer3_rn(layer_3)
+        layer_4_rn = self.scratch.layer4_rn(layer_4)
+
+        path_4 = self.scratch.refinenet4(layer_4_rn)
+        path_3 = self.scratch.refinenet3(path_4, layer_3_rn)
+        path_2 = self.scratch.refinenet2(path_3, layer_2_rn)
+        path_1 = self.scratch.refinenet1(path_2, layer_1_rn)
+
+        out = self.scratch.output_conv(path_1)
+
+        return torch.squeeze(out, dim=1)

condition/midas/midas/midas_net_custom.py

@@ -0,0 +1,128 @@
+"""MidashNet: Network for monocular depth estimation trained by mixing several datasets.
+This file contains code that is adapted from
+https://github.com/thomasjpfan/pytorch_refinenet/blob/master/pytorch_refinenet/refinenet/refinenet_4cascade.py
+"""
+import torch
+import torch.nn as nn
+
+from .base_model import BaseModel
+from .blocks import FeatureFusionBlock, FeatureFusionBlock_custom, Interpolate, _make_encoder
+
+
+class MidasNet_small(BaseModel):
+    """Network for monocular depth estimation.
+    """
+
+    def __init__(self, path=None, features=64, backbone="efficientnet_lite3", non_negative=True, exportable=True, channels_last=False, align_corners=True,
+        blocks={'expand': True}):
+        """Init.
+
+        Args:
+            path (str, optional): Path to saved model. Defaults to None.
+            features (int, optional): Number of features. Defaults to 256.
+            backbone (str, optional): Backbone network for encoder. Defaults to resnet50
+        """
+        print("Loading weights: ", path)
+
+        super(MidasNet_small, self).__init__()
+
+        use_pretrained = False if path else True
+                
+        self.channels_last = channels_last
+        self.blocks = blocks
+        self.backbone = backbone
+
+        self.groups = 1
+
+        features1=features
+        features2=features
+        features3=features
+        features4=features
+        self.expand = False
+        if "expand" in self.blocks and self.blocks['expand'] == True:
+            self.expand = True
+            features1=features
+            features2=features*2
+            features3=features*4
+            features4=features*8
+
+        self.pretrained, self.scratch = _make_encoder(self.backbone, features, use_pretrained, groups=self.groups, expand=self.expand, exportable=exportable)
+  
+        self.scratch.activation = nn.ReLU(False)    
+
+        self.scratch.refinenet4 = FeatureFusionBlock_custom(features4, self.scratch.activation, deconv=False, bn=False, expand=self.expand, align_corners=align_corners)
+        self.scratch.refinenet3 = FeatureFusionBlock_custom(features3, self.scratch.activation, deconv=False, bn=False, expand=self.expand, align_corners=align_corners)
+        self.scratch.refinenet2 = FeatureFusionBlock_custom(features2, self.scratch.activation, deconv=False, bn=False, expand=self.expand, align_corners=align_corners)
+        self.scratch.refinenet1 = FeatureFusionBlock_custom(features1, self.scratch.activation, deconv=False, bn=False, align_corners=align_corners)
+
+        
+        self.scratch.output_conv = nn.Sequential(
+            nn.Conv2d(features, features//2, kernel_size=3, stride=1, padding=1, groups=self.groups),
+            Interpolate(scale_factor=2, mode="bilinear"),
+            nn.Conv2d(features//2, 32, kernel_size=3, stride=1, padding=1),
+            self.scratch.activation,
+            nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0),
+            nn.ReLU(True) if non_negative else nn.Identity(),
+            nn.Identity(),
+        )
+        
+        if path:
+            self.load(path)
+
+
+    def forward(self, x):
+        """Forward pass.
+
+        Args:
+            x (tensor): input data (image)
+
+        Returns:
+            tensor: depth
+        """
+        if self.channels_last==True:
+            print("self.channels_last = ", self.channels_last)
+            x.contiguous(memory_format=torch.channels_last)
+
+
+        layer_1 = self.pretrained.layer1(x)
+        layer_2 = self.pretrained.layer2(layer_1)
+        layer_3 = self.pretrained.layer3(layer_2)
+        layer_4 = self.pretrained.layer4(layer_3)
+        
+        layer_1_rn = self.scratch.layer1_rn(layer_1)
+        layer_2_rn = self.scratch.layer2_rn(layer_2)
+        layer_3_rn = self.scratch.layer3_rn(layer_3)
+        layer_4_rn = self.scratch.layer4_rn(layer_4)
+
+
+        path_4 = self.scratch.refinenet4(layer_4_rn)
+        path_3 = self.scratch.refinenet3(path_4, layer_3_rn)
+        path_2 = self.scratch.refinenet2(path_3, layer_2_rn)
+        path_1 = self.scratch.refinenet1(path_2, layer_1_rn)
+        
+        out = self.scratch.output_conv(path_1)
+
+        return torch.squeeze(out, dim=1)
+
+
+
+def fuse_model(m):
+    prev_previous_type = nn.Identity()
+    prev_previous_name = ''
+    previous_type = nn.Identity()
+    previous_name = ''
+    for name, module in m.named_modules():
+        if prev_previous_type == nn.Conv2d and previous_type == nn.BatchNorm2d and type(module) == nn.ReLU:
+            # print("FUSED ", prev_previous_name, previous_name, name)
+            torch.quantization.fuse_modules(m, [prev_previous_name, previous_name, name], inplace=True)
+        elif prev_previous_type == nn.Conv2d and previous_type == nn.BatchNorm2d:
+            # print("FUSED ", prev_previous_name, previous_name)
+            torch.quantization.fuse_modules(m, [prev_previous_name, previous_name], inplace=True)
+        # elif previous_type == nn.Conv2d and type(module) == nn.ReLU:
+        #    print("FUSED ", previous_name, name)
+        #    torch.quantization.fuse_modules(m, [previous_name, name], inplace=True)
+
+        prev_previous_type = previous_type
+        prev_previous_name = previous_name
+        previous_type = type(module)
+        previous_name = name

condition/midas/midas/transforms.py

@@ -0,0 +1,234 @@
+import numpy as np
+import cv2
+import math
+
+
+def apply_min_size(sample, size, image_interpolation_method=cv2.INTER_AREA):
+    """Rezise the sample to ensure the given size. Keeps aspect ratio.
+
+    Args:
+        sample (dict): sample
+        size (tuple): image size
+
+    Returns:
+        tuple: new size
+    """
+    shape = list(sample["disparity"].shape)
+
+    if shape[0] >= size[0] and shape[1] >= size[1]:
+        return sample
+
+    scale = [0, 0]
+    scale[0] = size[0] / shape[0]
+    scale[1] = size[1] / shape[1]
+
+    scale = max(scale)
+
+    shape[0] = math.ceil(scale * shape[0])
+    shape[1] = math.ceil(scale * shape[1])
+
+    # resize
+    sample["image"] = cv2.resize(
+        sample["image"], tuple(shape[::-1]), interpolation=image_interpolation_method
+    )
+
+    sample["disparity"] = cv2.resize(
+        sample["disparity"], tuple(shape[::-1]), interpolation=cv2.INTER_NEAREST
+    )
+    sample["mask"] = cv2.resize(
+        sample["mask"].astype(np.float32),
+        tuple(shape[::-1]),
+        interpolation=cv2.INTER_NEAREST,
+    )
+    sample["mask"] = sample["mask"].astype(bool)
+
+    return tuple(shape)
+
+
+class Resize(object):
+    """Resize sample to given size (width, height).
+    """
+
+    def __init__(
+        self,
+        width,
+        height,
+        resize_target=True,
+        keep_aspect_ratio=False,
+        ensure_multiple_of=1,
+        resize_method="lower_bound",
+        image_interpolation_method=cv2.INTER_AREA,
+    ):
+        """Init.
+
+        Args:
+            width (int): desired output width
+            height (int): desired output height
+            resize_target (bool, optional):
+                True: Resize the full sample (image, mask, target).
+                False: Resize image only.
+                Defaults to True.
+            keep_aspect_ratio (bool, optional):
+                True: Keep the aspect ratio of the input sample.
+                Output sample might not have the given width and height, and
+                resize behaviour depends on the parameter 'resize_method'.
+                Defaults to False.
+            ensure_multiple_of (int, optional):
+                Output width and height is constrained to be multiple of this parameter.
+                Defaults to 1.
+            resize_method (str, optional):
+                "lower_bound": Output will be at least as large as the given size.
+                "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.)
+                "minimal": Scale as least as possible.  (Output size might be smaller than given size.)
+                Defaults to "lower_bound".
+        """
+        self.__width = width
+        self.__height = height
+
+        self.__resize_target = resize_target
+        self.__keep_aspect_ratio = keep_aspect_ratio
+        self.__multiple_of = ensure_multiple_of
+        self.__resize_method = resize_method
+        self.__image_interpolation_method = image_interpolation_method
+
+    def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
+        y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if max_val is not None and y > max_val:
+            y = (np.floor(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if y < min_val:
+            y = (np.ceil(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        return y
+
+    def get_size(self, width, height):
+        # determine new height and width
+        scale_height = self.__height / height
+        scale_width = self.__width / width
+
+        if self.__keep_aspect_ratio:
+            if self.__resize_method == "lower_bound":
+                # scale such that output size is lower bound
+                if scale_width > scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "upper_bound":
+                # scale such that output size is upper bound
+                if scale_width < scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "minimal":
+                # scale as least as possbile
+                if abs(1 - scale_width) < abs(1 - scale_height):
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            else:
+                raise ValueError(
+                    f"resize_method {self.__resize_method} not implemented"
+                )
+
+        if self.__resize_method == "lower_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, min_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, min_val=self.__width
+            )
+        elif self.__resize_method == "upper_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, max_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, max_val=self.__width
+            )
+        elif self.__resize_method == "minimal":
+            new_height = self.constrain_to_multiple_of(scale_height * height)
+            new_width = self.constrain_to_multiple_of(scale_width * width)
+        else:
+            raise ValueError(f"resize_method {self.__resize_method} not implemented")
+
+        return (new_width, new_height)
+
+    def __call__(self, sample):
+        width, height = self.get_size(
+            sample["image"].shape[1], sample["image"].shape[0]
+        )
+
+        # resize sample
+        sample["image"] = cv2.resize(
+            sample["image"],
+            (width, height),
+            interpolation=self.__image_interpolation_method,
+        )
+
+        if self.__resize_target:
+            if "disparity" in sample:
+                sample["disparity"] = cv2.resize(
+                    sample["disparity"],
+                    (width, height),
+                    interpolation=cv2.INTER_NEAREST,
+                )
+
+            if "depth" in sample:
+                sample["depth"] = cv2.resize(
+                    sample["depth"], (width, height), interpolation=cv2.INTER_NEAREST
+                )
+
+            sample["mask"] = cv2.resize(
+                sample["mask"].astype(np.float32),
+                (width, height),
+                interpolation=cv2.INTER_NEAREST,
+            )
+            sample["mask"] = sample["mask"].astype(bool)
+
+        return sample
+
+
+class NormalizeImage(object):
+    """Normlize image by given mean and std.
+    """
+
+    def __init__(self, mean, std):
+        self.__mean = mean
+        self.__std = std
+
+    def __call__(self, sample):
+        sample["image"] = (sample["image"] - self.__mean) / self.__std
+
+        return sample
+
+
+class PrepareForNet(object):
+    """Prepare sample for usage as network input.
+    """
+
+    def __init__(self):
+        pass
+
+    def __call__(self, sample):
+        image = np.transpose(sample["image"], (2, 0, 1))
+        sample["image"] = np.ascontiguousarray(image).astype(np.float32)
+
+        if "mask" in sample:
+            sample["mask"] = sample["mask"].astype(np.float32)
+            sample["mask"] = np.ascontiguousarray(sample["mask"])
+
+        if "disparity" in sample:
+            disparity = sample["disparity"].astype(np.float32)
+            sample["disparity"] = np.ascontiguousarray(disparity)
+
+        if "depth" in sample:
+            depth = sample["depth"].astype(np.float32)
+            sample["depth"] = np.ascontiguousarray(depth)
+
+        return sample

condition/midas/midas/vit.py

@@ -0,0 +1,491 @@
+import torch
+import torch.nn as nn
+import timm
+import types
+import math
+import torch.nn.functional as F
+
+
+class Slice(nn.Module):
+    def __init__(self, start_index=1):
+        super(Slice, self).__init__()
+        self.start_index = start_index
+
+    def forward(self, x):
+        return x[:, self.start_index :]
+
+
+class AddReadout(nn.Module):
+    def __init__(self, start_index=1):
+        super(AddReadout, self).__init__()
+        self.start_index = start_index
+
+    def forward(self, x):
+        if self.start_index == 2:
+            readout = (x[:, 0] + x[:, 1]) / 2
+        else:
+            readout = x[:, 0]
+        return x[:, self.start_index :] + readout.unsqueeze(1)
+
+
+class ProjectReadout(nn.Module):
+    def __init__(self, in_features, start_index=1):
+        super(ProjectReadout, self).__init__()
+        self.start_index = start_index
+
+        self.project = nn.Sequential(nn.Linear(2 * in_features, in_features), nn.GELU())
+
+    def forward(self, x):
+        readout = x[:, 0].unsqueeze(1).expand_as(x[:, self.start_index :])
+        features = torch.cat((x[:, self.start_index :], readout), -1)
+
+        return self.project(features)
+
+
+class Transpose(nn.Module):
+    def __init__(self, dim0, dim1):
+        super(Transpose, self).__init__()
+        self.dim0 = dim0
+        self.dim1 = dim1
+
+    def forward(self, x):
+        x = x.transpose(self.dim0, self.dim1)
+        return x
+
+
+def forward_vit(pretrained, x):
+    b, c, h, w = x.shape
+
+    glob = pretrained.model.forward_flex(x)
+
+    layer_1 = pretrained.activations["1"]
+    layer_2 = pretrained.activations["2"]
+    layer_3 = pretrained.activations["3"]
+    layer_4 = pretrained.activations["4"]
+
+    layer_1 = pretrained.act_postprocess1[0:2](layer_1)
+    layer_2 = pretrained.act_postprocess2[0:2](layer_2)
+    layer_3 = pretrained.act_postprocess3[0:2](layer_3)
+    layer_4 = pretrained.act_postprocess4[0:2](layer_4)
+
+    unflatten = nn.Sequential(
+        nn.Unflatten(
+            2,
+            torch.Size(
+                [
+                    h // pretrained.model.patch_size[1],
+                    w // pretrained.model.patch_size[0],
+                ]
+            ),
+        )
+    )
+
+    if layer_1.ndim == 3:
+        layer_1 = unflatten(layer_1)
+    if layer_2.ndim == 3:
+        layer_2 = unflatten(layer_2)
+    if layer_3.ndim == 3:
+        layer_3 = unflatten(layer_3)
+    if layer_4.ndim == 3:
+        layer_4 = unflatten(layer_4)
+
+    layer_1 = pretrained.act_postprocess1[3 : len(pretrained.act_postprocess1)](layer_1)
+    layer_2 = pretrained.act_postprocess2[3 : len(pretrained.act_postprocess2)](layer_2)
+    layer_3 = pretrained.act_postprocess3[3 : len(pretrained.act_postprocess3)](layer_3)
+    layer_4 = pretrained.act_postprocess4[3 : len(pretrained.act_postprocess4)](layer_4)
+
+    return layer_1, layer_2, layer_3, layer_4
+
+
+def _resize_pos_embed(self, posemb, gs_h, gs_w):
+    posemb_tok, posemb_grid = (
+        posemb[:, : self.start_index],
+        posemb[0, self.start_index :],
+    )
+
+    gs_old = int(math.sqrt(len(posemb_grid)))
+
+    posemb_grid = posemb_grid.reshape(1, gs_old, gs_old, -1).permute(0, 3, 1, 2)
+    posemb_grid = F.interpolate(posemb_grid, size=(gs_h, gs_w), mode="bilinear")
+    posemb_grid = posemb_grid.permute(0, 2, 3, 1).reshape(1, gs_h * gs_w, -1)
+
+    posemb = torch.cat([posemb_tok, posemb_grid], dim=1)
+
+    return posemb
+
+
+def forward_flex(self, x):
+    b, c, h, w = x.shape
+
+    pos_embed = self._resize_pos_embed(
+        self.pos_embed, h // self.patch_size[1], w // self.patch_size[0]
+    )
+
+    B = x.shape[0]
+
+    if hasattr(self.patch_embed, "backbone"):
+        x = self.patch_embed.backbone(x)
+        if isinstance(x, (list, tuple)):
+            x = x[-1]  # last feature if backbone outputs list/tuple of features
+
+    x = self.patch_embed.proj(x).flatten(2).transpose(1, 2)
+
+    if getattr(self, "dist_token", None) is not None:
+        cls_tokens = self.cls_token.expand(
+            B, -1, -1
+        )  # stole cls_tokens impl from Phil Wang, thanks
+        dist_token = self.dist_token.expand(B, -1, -1)
+        x = torch.cat((cls_tokens, dist_token, x), dim=1)
+    else:
+        cls_tokens = self.cls_token.expand(
+            B, -1, -1
+        )  # stole cls_tokens impl from Phil Wang, thanks
+        x = torch.cat((cls_tokens, x), dim=1)
+
+    x = x + pos_embed
+    x = self.pos_drop(x)
+
+    for blk in self.blocks:
+        x = blk(x)
+
+    x = self.norm(x)
+
+    return x
+
+
+activations = {}
+
+
+def get_activation(name):
+    def hook(model, input, output):
+        activations[name] = output
+
+    return hook
+
+
+def get_readout_oper(vit_features, features, use_readout, start_index=1):
+    if use_readout == "ignore":
+        readout_oper = [Slice(start_index)] * len(features)
+    elif use_readout == "add":
+        readout_oper = [AddReadout(start_index)] * len(features)
+    elif use_readout == "project":
+        readout_oper = [
+            ProjectReadout(vit_features, start_index) for out_feat in features
+        ]
+    else:
+        assert (
+            False
+        ), "wrong operation for readout token, use_readout can be 'ignore', 'add', or 'project'"
+
+    return readout_oper
+
+
+def _make_vit_b16_backbone(
+    model,
+    features=[96, 192, 384, 768],
+    size=[384, 384],
+    hooks=[2, 5, 8, 11],
+    vit_features=768,
+    use_readout="ignore",
+    start_index=1,
+):
+    pretrained = nn.Module()
+
+    pretrained.model = model
+    pretrained.model.blocks[hooks[0]].register_forward_hook(get_activation("1"))
+    pretrained.model.blocks[hooks[1]].register_forward_hook(get_activation("2"))
+    pretrained.model.blocks[hooks[2]].register_forward_hook(get_activation("3"))
+    pretrained.model.blocks[hooks[3]].register_forward_hook(get_activation("4"))
+
+    pretrained.activations = activations
+
+    readout_oper = get_readout_oper(vit_features, features, use_readout, start_index)
+
+    # 32, 48, 136, 384
+    pretrained.act_postprocess1 = nn.Sequential(
+        readout_oper[0],
+        Transpose(1, 2),
+        nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])),
+        nn.Conv2d(
+            in_channels=vit_features,
+            out_channels=features[0],
+            kernel_size=1,
+            stride=1,
+            padding=0,
+        ),
+        nn.ConvTranspose2d(
+            in_channels=features[0],
+            out_channels=features[0],
+            kernel_size=4,
+            stride=4,
+            padding=0,
+            bias=True,
+            dilation=1,
+            groups=1,
+        ),
+    )
+
+    pretrained.act_postprocess2 = nn.Sequential(
+        readout_oper[1],
+        Transpose(1, 2),
+        nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])),
+        nn.Conv2d(
+            in_channels=vit_features,
+            out_channels=features[1],
+            kernel_size=1,
+            stride=1,
+            padding=0,
+        ),
+        nn.ConvTranspose2d(
+            in_channels=features[1],
+            out_channels=features[1],
+            kernel_size=2,
+            stride=2,
+            padding=0,
+            bias=True,
+            dilation=1,
+            groups=1,
+        ),
+    )
+
+    pretrained.act_postprocess3 = nn.Sequential(
+        readout_oper[2],
+        Transpose(1, 2),
+        nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])),
+        nn.Conv2d(
+            in_channels=vit_features,
+            out_channels=features[2],
+            kernel_size=1,
+            stride=1,
+            padding=0,
+        ),
+    )
+
+    pretrained.act_postprocess4 = nn.Sequential(
+        readout_oper[3],
+        Transpose(1, 2),
+        nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])),
+        nn.Conv2d(
+            in_channels=vit_features,
+            out_channels=features[3],
+            kernel_size=1,
+            stride=1,
+            padding=0,
+        ),
+        nn.Conv2d(
+            in_channels=features[3],
+            out_channels=features[3],
+            kernel_size=3,
+            stride=2,
+            padding=1,
+        ),
+    )
+
+    pretrained.model.start_index = start_index
+    pretrained.model.patch_size = [16, 16]
+
+    # We inject this function into the VisionTransformer instances so that
+    # we can use it with interpolated position embeddings without modifying the library source.
+    pretrained.model.forward_flex = types.MethodType(forward_flex, pretrained.model)
+    pretrained.model._resize_pos_embed = types.MethodType(
+        _resize_pos_embed, pretrained.model
+    )
+
+    return pretrained
+
+
+def _make_pretrained_vitl16_384(pretrained, use_readout="ignore", hooks=None):
+    model = timm.create_model("vit_large_patch16_384", pretrained=pretrained)
+
+    hooks = [5, 11, 17, 23] if hooks == None else hooks
+    return _make_vit_b16_backbone(
+        model,
+        features=[256, 512, 1024, 1024],
+        hooks=hooks,
+        vit_features=1024,
+        use_readout=use_readout,
+    )
+
+
+def _make_pretrained_vitb16_384(pretrained, use_readout="ignore", hooks=None):
+    model = timm.create_model("vit_base_patch16_384", pretrained=pretrained)
+
+    hooks = [2, 5, 8, 11] if hooks == None else hooks
+    return _make_vit_b16_backbone(
+        model, features=[96, 192, 384, 768], hooks=hooks, use_readout=use_readout
+    )
+
+
+def _make_pretrained_deitb16_384(pretrained, use_readout="ignore", hooks=None):
+    model = timm.create_model("vit_deit_base_patch16_384", pretrained=pretrained)
+
+    hooks = [2, 5, 8, 11] if hooks == None else hooks
+    return _make_vit_b16_backbone(
+        model, features=[96, 192, 384, 768], hooks=hooks, use_readout=use_readout
+    )
+
+
+def _make_pretrained_deitb16_distil_384(pretrained, use_readout="ignore", hooks=None):
+    model = timm.create_model(
+        "vit_deit_base_distilled_patch16_384", pretrained=pretrained
+    )
+
+    hooks = [2, 5, 8, 11] if hooks == None else hooks
+    return _make_vit_b16_backbone(
+        model,
+        features=[96, 192, 384, 768],
+        hooks=hooks,
+        use_readout=use_readout,
+        start_index=2,
+    )
+
+
+def _make_vit_b_rn50_backbone(
+    model,
+    features=[256, 512, 768, 768],
+    size=[384, 384],
+    hooks=[0, 1, 8, 11],
+    vit_features=768,
+    use_vit_only=False,
+    use_readout="ignore",
+    start_index=1,
+):
+    pretrained = nn.Module()
+
+    pretrained.model = model
+
+    if use_vit_only == True:
+        pretrained.model.blocks[hooks[0]].register_forward_hook(get_activation("1"))
+        pretrained.model.blocks[hooks[1]].register_forward_hook(get_activation("2"))
+    else:
+        pretrained.model.patch_embed.backbone.stages[0].register_forward_hook(
+            get_activation("1")
+        )
+        pretrained.model.patch_embed.backbone.stages[1].register_forward_hook(
+            get_activation("2")
+        )
+
+    pretrained.model.blocks[hooks[2]].register_forward_hook(get_activation("3"))
+    pretrained.model.blocks[hooks[3]].register_forward_hook(get_activation("4"))
+
+    pretrained.activations = activations
+
+    readout_oper = get_readout_oper(vit_features, features, use_readout, start_index)
+
+    if use_vit_only == True:
+        pretrained.act_postprocess1 = nn.Sequential(
+            readout_oper[0],
+            Transpose(1, 2),
+            nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])),
+            nn.Conv2d(
+                in_channels=vit_features,
+                out_channels=features[0],
+                kernel_size=1,
+                stride=1,
+                padding=0,
+            ),
+            nn.ConvTranspose2d(
+                in_channels=features[0],
+                out_channels=features[0],
+                kernel_size=4,
+                stride=4,
+                padding=0,
+                bias=True,
+                dilation=1,
+                groups=1,
+            ),
+        )
+
+        pretrained.act_postprocess2 = nn.Sequential(
+            readout_oper[1],
+            Transpose(1, 2),
+            nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])),
+            nn.Conv2d(
+                in_channels=vit_features,
+                out_channels=features[1],
+                kernel_size=1,
+                stride=1,
+                padding=0,
+            ),
+            nn.ConvTranspose2d(
+                in_channels=features[1],
+                out_channels=features[1],
+                kernel_size=2,
+                stride=2,
+                padding=0,
+                bias=True,
+                dilation=1,
+                groups=1,
+            ),
+        )
+    else:
+        pretrained.act_postprocess1 = nn.Sequential(
+            nn.Identity(), nn.Identity(), nn.Identity()
+        )
+        pretrained.act_postprocess2 = nn.Sequential(
+            nn.Identity(), nn.Identity(), nn.Identity()
+        )
+
+    pretrained.act_postprocess3 = nn.Sequential(
+        readout_oper[2],
+        Transpose(1, 2),
+        nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])),
+        nn.Conv2d(
+            in_channels=vit_features,
+            out_channels=features[2],
+            kernel_size=1,
+            stride=1,
+            padding=0,
+        ),
+    )
+
+    pretrained.act_postprocess4 = nn.Sequential(
+        readout_oper[3],
+        Transpose(1, 2),
+        nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])),
+        nn.Conv2d(
+            in_channels=vit_features,
+            out_channels=features[3],
+            kernel_size=1,
+            stride=1,
+            padding=0,
+        ),
+        nn.Conv2d(
+            in_channels=features[3],
+            out_channels=features[3],
+            kernel_size=3,
+            stride=2,
+            padding=1,
+        ),
+    )
+
+    pretrained.model.start_index = start_index
+    pretrained.model.patch_size = [16, 16]
+
+    # We inject this function into the VisionTransformer instances so that
+    # we can use it with interpolated position embeddings without modifying the library source.
+    pretrained.model.forward_flex = types.MethodType(forward_flex, pretrained.model)
+
+    # We inject this function into the VisionTransformer instances so that
+    # we can use it with interpolated position embeddings without modifying the library source.
+    pretrained.model._resize_pos_embed = types.MethodType(
+        _resize_pos_embed, pretrained.model
+    )
+
+    return pretrained
+
+
+def _make_pretrained_vitb_rn50_384(
+    pretrained, use_readout="ignore", hooks=None, use_vit_only=False
+):
+    model = timm.create_model("vit_base_resnet50_384", pretrained=pretrained)
+
+    hooks = [0, 1, 8, 11] if hooks == None else hooks
+    return _make_vit_b_rn50_backbone(
+        model,
+        features=[256, 512, 768, 768],
+        size=[384, 384],
+        hooks=hooks,
+        use_vit_only=use_vit_only,
+        use_readout=use_readout,
+    )

condition/utils.py

@@ -0,0 +1,38 @@
+import numpy as np
+import cv2
+import os
+
+
+annotator_ckpts_path = os.path.join(os.path.dirname(__file__), 'ckpts')
+
+
+def HWC3(x):
+    assert x.dtype == np.uint8
+    if x.ndim == 2:
+        x = x[:, :, None]
+    assert x.ndim == 3
+    H, W, C = x.shape
+    assert C == 1 or C == 3 or C == 4
+    if C == 3:
+        return x
+    if C == 1:
+        return np.concatenate([x, x, x], axis=2)
+    if C == 4:
+        color = x[:, :, 0:3].astype(np.float32)
+        alpha = x[:, :, 3:4].astype(np.float32) / 255.0
+        y = color * alpha + 255.0 * (1.0 - alpha)
+        y = y.clip(0, 255).astype(np.uint8)
+        return y
+
+
+def resize_image(input_image, resolution):
+    H, W, C = input_image.shape
+    H = float(H)
+    W = float(W)
+    k = float(resolution) / min(H, W)
+    H *= k
+    W *= k
+    H = int(np.round(H / 64.0)) * 64
+    W = int(np.round(W / 64.0)) * 64
+    img = cv2.resize(input_image, (W, H), interpolation=cv2.INTER_LANCZOS4 if k > 1 else cv2.INTER_AREA)
+    return img

data/Captioned_ADE20K/.gitattributes

@@ -0,0 +1,55 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text

data/Captioned_ADE20K/.hfd/last_download_command

@@ -0,0 +1 @@
+REPO_ID=limingcv/Captioned_ADE20K TOOL=wget INCLUDE_PATTERNS= EXCLUDE_PATTERNS= DATASET=1 HF_USERNAME= HF_TOKEN= HF_TOKEN=https://hf-mirror.com REVISION=main

data/Captioned_ADE20K/.hfd/repo_metadata.json

@@ -0,0 +1 @@
+{"_id":"653f319baa1f487614013f5a","id":"limingcv/Captioned_ADE20K","author":"limingcv","sha":"1406fc53a4749e505126bd385035cd7968e76dba","lastModified":"2023-10-30T04:38:04.000Z","private":false,"gated":false,"disabled":false,"tags":["size_categories:10K<n<100K","format:parquet","modality:image","modality:text","library:datasets","library:dask","library:mlcroissant","library:polars","region:us"],"citation":null,"description":null,"downloads":396,"likes":2,"cardData":{"dataset_info":{"features":[{"name":"image","dtype":"image"},{"name":"detailed_prompt","dtype":"string"},{"name":"control_seg","dtype":"image"},{"name":"seg_map","sequence":{"sequence":"uint8"}},{"name":"image_path","dtype":"string"},{"name":"prompt","dtype":"string"}],"splits":[{"name":"train","num_bytes":11095603078.08,"num_examples":20210},{"name":"validation","num_bytes":1128604170,"num_examples":2000}],"download_size":7044514076,"dataset_size":12224207248.08},"configs":[{"config_name":"default","data_files":[{"split":"train","path":"data/train-*"},{"split":"validation","path":"data/validation-*"}]}]},"siblings":[{"rfilename":".gitattributes"},{"rfilename":"README.md"},{"rfilename":"data/train-00000-of-00023.parquet"},{"rfilename":"data/train-00001-of-00023.parquet"},{"rfilename":"data/train-00002-of-00023.parquet"},{"rfilename":"data/train-00003-of-00023.parquet"},{"rfilename":"data/train-00004-of-00023.parquet"},{"rfilename":"data/train-00005-of-00023.parquet"},{"rfilename":"data/train-00006-of-00023.parquet"},{"rfilename":"data/train-00007-of-00023.parquet"},{"rfilename":"data/train-00008-of-00023.parquet"},{"rfilename":"data/train-00009-of-00023.parquet"},{"rfilename":"data/train-00010-of-00023.parquet"},{"rfilename":"data/train-00011-of-00023.parquet"},{"rfilename":"data/train-00012-of-00023.parquet"},{"rfilename":"data/train-00013-of-00023.parquet"},{"rfilename":"data/train-00014-of-00023.parquet"},{"rfilename":"data/train-00015-of-00023.parquet"},{"rfilename":"data/train-00016-of-00023.parquet"},{"rfilename":"data/train-00017-of-00023.parquet"},{"rfilename":"data/train-00018-of-00023.parquet"},{"rfilename":"data/train-00019-of-00023.parquet"},{"rfilename":"data/train-00020-of-00023.parquet"},{"rfilename":"data/train-00021-of-00023.parquet"},{"rfilename":"data/train-00022-of-00023.parquet"},{"rfilename":"data/validation-00000-of-00003.parquet"},{"rfilename":"data/validation-00001-of-00003.parquet"},{"rfilename":"data/validation-00002-of-00003.parquet"}],"createdAt":"2023-10-30T04:31:23.000Z","usedStorage":24658841884}

data/Captioned_ADE20K/.hfd/wget_urls.txt

@@ -0,0 +1,28 @@
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/.gitattributes
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/README.md
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00000-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00001-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00002-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00003-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00004-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00005-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00006-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00007-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00008-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00009-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00010-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00011-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00012-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00013-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00014-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00015-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00016-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00017-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00018-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00019-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00020-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00021-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/train-00022-of-00023.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/validation-00000-of-00003.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/validation-00001-of-00003.parquet
+https://hf-mirror.com/datasets/limingcv/Captioned_ADE20K/resolve/main/data/validation-00002-of-00003.parquet

data/Captioned_ADE20K/README.md

@@ -0,0 +1,33 @@
+---
+dataset_info:
+  features:
+  - name: image
+    dtype: image
+  - name: detailed_prompt
+    dtype: string
+  - name: control_seg
+    dtype: image
+  - name: seg_map
+    sequence:
+      sequence: uint8
+  - name: image_path
+    dtype: string
+  - name: prompt
+    dtype: string
+  splits:
+  - name: train
+    num_bytes: 11095603078.08
+    num_examples: 20210
+  - name: validation
+    num_bytes: 1128604170.0
+    num_examples: 2000
+  download_size: 7044514076
+  dataset_size: 12224207248.08
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*
+  - split: validation
+    path: data/validation-*
+---

data/Captioned_ADE20K/see_parquet.py

@@ -0,0 +1,13 @@
+import pandas as pd
+
+
+parquet_path = "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/data/train-00006-of-00023.parquet"
+
+# 读取 parquet 文件
+df = pd.read_parquet(parquet_path)
+
+# 显示字段名（列名）
+print("字段列名：", df.columns.tolist())
+
+# 显示前几行内容
+print(df.head())

data/Captioned_ADE20K/train.jsonl

@@ -0,0 +1,880 @@
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/0.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/1.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/10.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/100.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/101.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/102.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/103.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/104.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/105.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/106.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/107.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/108.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/109.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/11.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/110.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/111.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/112.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/113.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/114.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/115.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/116.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/117.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/118.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/119.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/12.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/120.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/121.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/122.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/123.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/124.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/125.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/126.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/127.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/128.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/129.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/13.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/130.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/131.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/132.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/133.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/134.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/135.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/136.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/137.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/138.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/139.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/14.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/140.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/141.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/142.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/143.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/144.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/145.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/146.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/147.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/148.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/149.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/15.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/150.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/151.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/152.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/153.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/154.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/155.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/156.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/157.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/158.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/159.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/16.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/160.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/161.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/162.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/163.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/164.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/165.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/166.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/167.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/168.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/169.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/17.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/170.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/171.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/172.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/173.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/174.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/175.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/176.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/177.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/178.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/179.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/18.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/180.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/181.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/182.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/183.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/184.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/185.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/186.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/187.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/188.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/189.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/19.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/190.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/191.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/192.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/193.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/194.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/195.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/196.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/197.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/198.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/199.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/2.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/20.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/200.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/201.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/202.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/203.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/204.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/205.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/206.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/207.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/208.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/209.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/21.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/210.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/211.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/212.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/213.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/214.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/215.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/216.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/217.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/218.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/219.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/22.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/220.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/221.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/222.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/223.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/224.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/225.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/226.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/227.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/228.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/229.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/23.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/230.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/231.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/232.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/233.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/234.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/235.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/236.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/237.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/238.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/239.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/24.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/240.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/241.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/242.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/243.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/244.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/245.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/246.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/247.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/248.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/249.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/25.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/250.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/251.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/252.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/253.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/254.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/255.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/256.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/257.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/258.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/259.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/26.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/260.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/261.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/262.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/263.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/264.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/265.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/266.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/267.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/268.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/269.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/27.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/270.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/271.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/272.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/273.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/274.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/275.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/276.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/277.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/278.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/279.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/28.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/280.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/281.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/282.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/283.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/284.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/285.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/286.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/287.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/288.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/289.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/29.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/290.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/291.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/292.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/293.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/294.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/295.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/296.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/297.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/298.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/299.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/3.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/30.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/300.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/301.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/302.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/303.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/304.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/305.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/306.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/307.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/308.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/309.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/31.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/310.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/311.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/312.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/313.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/314.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/315.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/316.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/317.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/318.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/319.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/32.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/320.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/321.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/322.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/323.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/324.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/325.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/326.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/327.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/328.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/329.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/33.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/330.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/331.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/332.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/333.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/334.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/335.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/336.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/337.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/338.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/339.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/34.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/340.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/341.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/342.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/343.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/344.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/345.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/346.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/347.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/348.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/349.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/35.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/350.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/351.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/352.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/353.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/354.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/355.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/356.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/357.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/358.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/359.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/36.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/360.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/361.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/362.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/363.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/364.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/365.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/366.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/367.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/368.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/369.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/37.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/370.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/371.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/372.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/373.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/374.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/375.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/376.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/377.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/378.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/379.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/38.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/380.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/381.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/382.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/383.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/384.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/385.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/386.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/387.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/388.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/389.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/39.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/390.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/391.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/392.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/393.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/394.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/395.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/396.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/397.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/398.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/399.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/4.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/40.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/400.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/401.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/402.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/403.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/404.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/405.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/406.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/407.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/408.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/409.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/41.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/410.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/411.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/412.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/413.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/414.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/415.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/416.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/417.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/418.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/419.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/42.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/420.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/421.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/422.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/423.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/424.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/425.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/426.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/427.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/428.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/429.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/43.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/430.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/431.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/432.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/433.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/434.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/435.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/436.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/437.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/438.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/439.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/44.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/440.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/441.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/442.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/443.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/444.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/445.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/446.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/447.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/448.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/449.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/45.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/450.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/451.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/452.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/453.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/454.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/455.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/456.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/457.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/458.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/459.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/46.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/460.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/461.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/462.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/463.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/464.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/465.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/466.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/467.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/468.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/469.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/47.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/470.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/471.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/472.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/473.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/474.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/475.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/476.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/477.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/478.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/479.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/48.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/480.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/481.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/482.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/483.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/484.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/485.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/486.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/487.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/488.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/489.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/49.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/490.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/491.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/492.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/493.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/494.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/495.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/496.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/497.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/498.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/499.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/5.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/50.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/500.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/501.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/502.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/503.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/504.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/505.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/506.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/507.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/508.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/509.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/51.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/510.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/511.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/512.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/513.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/514.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/515.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/516.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/517.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/518.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/519.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/52.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/520.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/521.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/522.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/523.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/524.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/525.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/526.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/527.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/528.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/529.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/53.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/530.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/531.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/532.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/533.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/534.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/535.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/536.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/537.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/538.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/539.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/54.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/540.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/541.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/542.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/543.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/544.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/545.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/546.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/547.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/548.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/549.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/55.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/550.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/551.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/552.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/553.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/554.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/555.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/556.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/557.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/558.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/559.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/56.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/560.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/561.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/562.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/563.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/564.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/565.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/566.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/567.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/568.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/569.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/57.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/570.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/571.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/572.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/573.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/574.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/575.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/576.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/577.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/578.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/579.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/58.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/580.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/581.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/582.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/583.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/584.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/585.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/586.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/587.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/588.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/589.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/59.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/590.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/591.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/592.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/593.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/594.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/595.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/596.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/597.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/598.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/599.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/6.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/60.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/600.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/601.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/602.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/603.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/604.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/605.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/606.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/607.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/608.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/609.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/61.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/610.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/611.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/612.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/613.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/614.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/615.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/616.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/617.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/618.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/619.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/62.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/620.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/621.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/622.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/623.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/624.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/625.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/626.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/627.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/628.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/629.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/63.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/630.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/631.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/632.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/633.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/634.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/635.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/636.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/637.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/638.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/639.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/64.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/640.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/641.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/642.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/643.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/644.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/645.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/646.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/647.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/648.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/649.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/65.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/650.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/651.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/652.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/653.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/654.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/655.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/656.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/657.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/658.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/659.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/66.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/660.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/661.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/662.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/663.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/664.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/665.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/666.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/667.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/668.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/669.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/67.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/670.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/671.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/672.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/673.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/674.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/675.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/676.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/677.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/678.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/679.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/68.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/680.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/681.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/682.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/683.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/684.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/685.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/686.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/687.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/688.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/689.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/69.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/690.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/691.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/692.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/693.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/694.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/695.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/696.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/697.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/698.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/699.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/7.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/70.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/700.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/701.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/702.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/703.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/704.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/705.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/706.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/707.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/708.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/709.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/71.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/710.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/711.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/712.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/713.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/714.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/715.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/716.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/717.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/718.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/719.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/72.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/720.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/721.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/722.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/723.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/724.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/725.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/726.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/727.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/728.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/729.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/73.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/730.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/731.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/732.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/733.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/734.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/735.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/736.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/737.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/738.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/739.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/74.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/740.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/741.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/742.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/743.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/744.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/745.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/746.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/747.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/748.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/749.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/75.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/750.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/751.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/752.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/753.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/754.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/755.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/756.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/757.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/758.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/759.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/76.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/760.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/761.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/762.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/763.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/764.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/765.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/766.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/767.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/768.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/769.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/77.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/770.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/771.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/772.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/773.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/774.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/775.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/776.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/777.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/778.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/779.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/78.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/780.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/781.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/782.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/783.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/784.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/785.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/786.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/787.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/788.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/789.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/79.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/790.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/791.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/792.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/793.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/794.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/795.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/796.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/797.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/798.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/799.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/8.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/80.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/800.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/801.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/802.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/803.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/804.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/805.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/806.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/807.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/808.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/809.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/81.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/810.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/811.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/812.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/813.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/814.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/815.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/816.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/817.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/818.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/819.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/82.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/820.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/821.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/822.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/823.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/824.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/825.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/826.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/827.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/828.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/829.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/83.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/830.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/831.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/832.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/833.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/834.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/835.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/836.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/837.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/838.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/839.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/84.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/840.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/841.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/842.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/843.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/844.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/845.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/846.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/847.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/848.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/849.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/85.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/850.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/851.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/852.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/853.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/854.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/855.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/856.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/857.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/858.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/859.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/86.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/860.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/861.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/862.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/863.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/864.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/865.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/866.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/867.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/868.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/869.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/87.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/870.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/871.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/872.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/873.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/874.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/875.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/876.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/877.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/878.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/879.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/88.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/89.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/9.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/90.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/91.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/92.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/93.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/94.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/95.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/96.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/97.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/98.png"}
+{"image_path": "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image/99.png"}