Add files using upload-large-folder tool

condition/example/c2i/depth/4351.npy

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

dataset/augmentation.py

@@ -0,0 +1,51 @@
+# from https://github.com/openai/guided-diffusion/blob/8fb3ad9197f16bbc40620447b2742e13458d2831/guided_diffusion/image_datasets.py
+import math
+import random
+import numpy as np
+from PIL import Image
+
+
+def center_crop_arr(pil_image, image_size):
+    """
+    Center cropping implementation from ADM.
+    https://github.com/openai/guided-diffusion/blob/8fb3ad9197f16bbc40620447b2742e13458d2831/guided_diffusion/image_datasets.py#L126
+    """
+    while min(*pil_image.size) >= 2 * image_size:
+        pil_image = pil_image.resize(
+            tuple(x // 2 for x in pil_image.size), resample=Image.BOX
+        )
+
+    scale = image_size / min(*pil_image.size)
+    pil_image = pil_image.resize(
+        tuple(round(x * scale) for x in pil_image.size), resample=Image.BICUBIC
+    )
+
+    arr = np.array(pil_image)
+    crop_y = (arr.shape[0] - image_size) // 2
+    crop_x = (arr.shape[1] - image_size) // 2
+    return Image.fromarray(arr[crop_y: crop_y + image_size, crop_x: crop_x + image_size])
+
+
+def random_crop_arr(pil_image, image_size, min_crop_frac=0.8, max_crop_frac=1.0):
+    min_smaller_dim_size = math.ceil(image_size / max_crop_frac)
+    max_smaller_dim_size = math.ceil(image_size / min_crop_frac)
+    smaller_dim_size = random.randrange(min_smaller_dim_size, max_smaller_dim_size + 1)
+
+    # We are not on a new enough PIL to support the `reducing_gap`
+    # argument, which uses BOX downsampling at powers of two first.
+    # Thus, we do it by hand to improve downsample quality.
+    while min(*pil_image.size) >= 2 * smaller_dim_size:
+        pil_image = pil_image.resize(
+            tuple(x // 2 for x in pil_image.size), resample=Image.BOX
+        )
+
+    scale = smaller_dim_size / min(*pil_image.size)
+    pil_image = pil_image.resize(
+        tuple(round(x * scale) for x in pil_image.size), resample=Image.BICUBIC
+    )
+
+    arr = np.array(pil_image)
+    crop_y = random.randrange(arr.shape[0] - image_size + 1)
+    crop_x = random.randrange(arr.shape[1] - image_size + 1)
+    return Image.fromarray(arr[crop_y : crop_y + image_size, crop_x : crop_x + image_size])
+

dataset/build.py

@@ -0,0 +1,29 @@
+from dataset.imagenet import build_imagenet, build_imagenet_code
+from dataset.coco import build_coco
+from dataset.openimage import build_openimage
+from dataset.pexels import build_pexels
+from dataset.t2i import build_t2i, build_t2i_code, build_t2i_image
+# from dataset.t2i_control import build_t2i_control
+
+def build_dataset(args, **kwargs):
+    # images
+    if args.dataset == 'imagenet':
+        return build_imagenet(args, **kwargs)
+    if args.dataset == 'imagenet_code':
+        return build_imagenet_code(args, **kwargs)
+    if args.dataset == 'coco':
+        return build_coco(args, **kwargs)
+    if args.dataset == 'openimage':
+        return build_openimage(args, **kwargs)
+    if args.dataset == 'pexels':
+        return build_pexels(args, **kwargs)
+    if args.dataset == 't2i_image':
+        return build_t2i_image(args, **kwargs)
+    if args.dataset == 't2i':
+        return build_t2i(args, **kwargs)
+    if args.dataset == 't2i_code':
+        return build_t2i_code(args, **kwargs)
+    # if args.dataset == 't2i_control':
+    #     return build_t2i_control(args, **kwargs)
+    
+    raise ValueError(f'dataset {args.dataset} is not supported')

dataset/coco.py

@@ -0,0 +1,27 @@
+import os
+import torch
+from torch.utils.data import Dataset
+from PIL import Image
+
+
+class SingleFolderDataset(Dataset):
+    def __init__(self, directory, transform=None):
+        super().__init__()
+        self.directory = directory
+        self.transform = transform
+        self.image_paths = [os.path.join(directory, file_name) for file_name in os.listdir(directory)
+                            if os.path.isfile(os.path.join(directory, file_name))]
+
+    def __len__(self):
+        return len(self.image_paths)
+
+    def __getitem__(self, idx):
+        image_path = self.image_paths[idx]
+        image = Image.open(image_path).convert('RGB')
+        if self.transform:
+            image = self.transform(image)
+        return image, torch.tensor(0)
+
+
+def build_coco(args, transform):
+    return SingleFolderDataset(args.data_path, transform=transform)

dataset/imagenet.py

@@ -0,0 +1,120 @@
+import torch
+import numpy as np
+import os
+from torch.utils.data import Dataset
+from torchvision.datasets import ImageFolder
+import cv2
+from datasets import load_dataset
+
+class CustomDataset(Dataset):
+    def __init__(self, feature_dir, label_dir, condition_dir=None, get_condition_img=False):
+        self.feature_dir = feature_dir
+        self.label_dir = label_dir
+        self.flip = 'flip' in self.feature_dir
+        self.get_condition_img = get_condition_img
+
+        aug_feature_dir = feature_dir.replace('ten_crop/', 'ten_crop_105/')
+        aug_label_dir = label_dir.replace('ten_crop/', 'ten_crop_105/')
+        if os.path.exists(aug_feature_dir) and os.path.exists(aug_label_dir):
+            self.aug_feature_dir = aug_feature_dir
+            self.aug_label_dir = aug_label_dir
+        else:
+            self.aug_feature_dir = None
+            self.aug_label_dir = None
+
+        if condition_dir is not None:
+            self.condition_dir = condition_dir
+            self.aug_condition_dir = condition_dir.replace('ten_crop/', 'ten_crop_105/')
+            if os.path.exists(self.aug_condition_dir):
+                self.aug_condition_dir = self.aug_condition_dir
+            else:
+                self.aug_condition_dir = None
+        else:
+            self.condition_dir = None
+
+        # file_num = min(129398,len(os.listdir(feature_dir)))
+        file_num = len(os.listdir(feature_dir))
+        # file_num = 1000
+        self.feature_files = [f"{i}.npy" for i in range(file_num)]
+        self.label_files = [f"{i}.npy" for i in range(file_num)]
+        self.condition_files = [f"{i}.npy" for i in range(file_num)]
+        # self.feature_files = sorted(os.listdir(feature_dir))
+        # self.label_files = sorted(os.listdir(label_dir))
+        # TODO: make it configurable
+        # self.feature_files = [f"{i}.npy" for i in range(1281167)]
+        # self.label_files = [f"{i}.npy" for i in range(1281167)]
+
+    def __len__(self):
+        assert len(self.feature_files) == len(self.label_files), \
+            "Number of feature files and label files should be same"
+        return len(self.feature_files)
+
+    def __getitem__(self, idx):
+        if self.aug_feature_dir is not None and torch.rand(1) < 0.5:
+            feature_dir = self.aug_feature_dir
+            label_dir = self.aug_label_dir
+        else:
+            feature_dir = self.feature_dir
+            label_dir = self.label_dir
+            if self.condition_dir is not None:
+                condition_dir = self.condition_dir
+                   
+        feature_file = self.feature_files[idx]
+        label_file = self.label_files[idx]
+        if self.condition_dir is not None:
+            condition_file = self.condition_files[idx]
+            # condition_code = np.load(os.path.join(condition_dir, condition_file))
+            condition_imgs = np.load(os.path.join(os.path.dirname(condition_dir), os.path.basename(condition_dir).replace('codes', 'imagesnpy'), condition_file))/255
+            condition_imgs = 2*(condition_imgs-0.5)
+            if self.get_condition_img:
+                # print(os.path.join(os.path.dirname(condition_dir), os.path.basename(condition_dir).replace('codes', 'images'), condition_file.replace('npy', 'png')))
+                condition_img = cv2.imread(os.path.join(os.path.dirname(condition_dir), os.path.basename(condition_dir).replace('codes', 'images'), condition_file.replace('npy', 'png')))/255
+                condition_img = 2*(condition_img-0.5)
+            #condition = condition[None,...].repeat(3, axis=2)
+
+        features = np.load(os.path.join(feature_dir, feature_file))
+        if self.flip:
+            aug_idx = torch.randint(low=0, high=features.shape[1], size=(1,)).item()
+            if self.get_condition_img:
+                aug_idx = 0
+            features = features[:, aug_idx]
+            if self.condition_dir is not None:
+                # condition_code = condition_code[:, aug_idx]
+                condition_imgs = condition_imgs[aug_idx]
+                
+        labels = np.load(os.path.join(label_dir, label_file))
+        # if self.condition_dir is not None:
+        #     if self.get_condition_img:
+        #         return torch.from_numpy(condition_img.transpose(2,0,1)).to(torch.float32), torch.from_numpy(condition)  # (1, 256), (1,1)
+        #     else:
+        #         return torch.from_numpy(features), torch.from_numpy(labels), torch.from_numpy(condition)  # (1, 256), (1,1)
+        # else:
+        #     return torch.from_numpy(features), torch.from_numpy(labels)
+        outputs = {}
+        outputs['img_code'] = torch.from_numpy(features)
+        outputs['labels'] = torch.from_numpy(labels)
+        if self.condition_dir is not None:
+            # outputs['condition_code'] = torch.from_numpy(condition_code)
+            outputs['condition_imgs'] = torch.from_numpy(condition_imgs)
+        if self.get_condition_img:
+            outputs['condition_img'] = torch.from_numpy(condition_img.transpose(2,0,1))
+        return outputs
+
+
+def build_imagenet(args, transform):
+    return ImageFolder(args.data_path, transform=transform)
+
+def build_imagenet_code(args):
+    feature_dir = f"{args.code_path}/imagenet{args.image_size}_codes"
+    label_dir = f"{args.code_path}/imagenet{args.image_size}_labels"
+    if args.condition_type == 'canny':
+        condition_dir = f"{args.code_path}/imagenet{args.image_size}_canny_codes"
+    elif args.condition_type == 'hed':
+        condition_dir = f"{args.code_path}/imagenet{args.image_size}_hed_codes"
+    elif args.condition_type == 'depth':
+        condition_dir = f"{args.code_path}/imagenet{args.image_size}_depth_codes"
+    elif args.condition_type == 'none':
+        condition_dir = None
+    assert os.path.exists(feature_dir) and os.path.exists(label_dir), \
+        f"please first run: bash scripts/autoregressive/extract_codes_c2i.sh ..."
+    return CustomDataset(feature_dir, label_dir, condition_dir, args.get_condition_img)

dataset/make_jsonl.py

@@ -0,0 +1,73 @@
+# import os
+# import json
+
+# image_dir = "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/image"
+# jsonl_path = "/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train/train.jsonl"
+
+# with open(jsonl_path, "w") as f:
+#     for filename in sorted(os.listdir(image_dir)):
+#         if filename.endswith(".png"):
+#             img_path = os.path.join(image_dir, filename)
+#             entry = {
+#                 "image_path": img_path
+#             }
+#             f.write(json.dumps(entry) + "\n")
+import os
+import json
+from PIL import Image
+from tqdm import tqdm
+
+def generate_jsonl_from_folder(
+    image_dir,
+    output_jsonl_path,
+    code_dir_name='code',
+    caption_emb_dir_name='caption_emb',
+    control_dir_name='control',
+    label_dir_name='label'
+):
+    """
+    自动从 image 文件夹构建 .jsonl 文件，记录 image_path 和 code_name
+    适配 Text2ImgDataset 类的数据读取格式
+    """
+    image_files = sorted([f for f in os.listdir(image_dir) if f.endswith('.png')])
+    parent_dir = os.path.basename(os.path.normpath(image_dir))  # 通常为 'train'
+
+    with open(output_jsonl_path, 'w') as f:
+        for file in tqdm(image_files, desc="Generating .jsonl"):
+            image_path = os.path.join(image_dir, file)
+            code_name = os.path.splitext(file)[0]  # 文件名去掉扩展名
+
+            # 检查其他文件是否都存在
+            code_path = os.path.join(os.path.dirname(image_dir), code_dir_name, f"{code_name}.npy")
+            caption_emb_path = os.path.join(os.path.dirname(image_dir), caption_emb_dir_name, f"{code_name}.npz")
+            control_path = os.path.join(os.path.dirname(image_dir), control_dir_name, f"{code_name}.png")
+            label_path = os.path.join(os.path.dirname(image_dir), label_dir_name, f"{code_name}.png")
+
+            if not (os.path.exists(code_path) and os.path.exists(caption_emb_path)
+                    and os.path.exists(control_path) and os.path.exists(label_path)):
+                print(f"⚠️ 缺失对应文件: {code_name}")
+                continue
+
+            data = {
+                "image_path": image_path,
+                "code_name": int(code_name)  # 保证仍然为数字编号
+            }
+            f.write(json.dumps(data) + '\n')
+
+    print(f"✅ 成功生成: {output_jsonl_path}")
+
+
+if __name__ == '__main__':
+    # 示例路径（按需修改）
+    root_dir = '/media2/user/data/wxy/ControlAR_old/data/Captioned_ADE20K/train'
+    image_dir = os.path.join(root_dir, 'image')
+    output_jsonl = os.path.join(root_dir, 'train_to_use.jsonl')
+
+    generate_jsonl_from_folder(
+        image_dir=image_dir,
+        output_jsonl_path=output_jsonl,
+        code_dir_name='code',
+        caption_emb_dir_name='caption_emb',
+        control_dir_name='control',
+        label_dir_name='label'
+    )

dataset/openimage.py

@@ -0,0 +1,42 @@
+import os
+import json
+import numpy as np
+from PIL import Image
+
+import torch
+from torch.utils.data import Dataset
+
+
+class DatasetJson(Dataset):
+    def __init__(self, data_path, transform=None):
+        super().__init__()
+        self.data_path = data_path
+        self.transform = transform
+        json_path = os.path.join(data_path, 'image_paths.json')
+        assert os.path.exists(json_path), f"please first run: python3 tools/openimage_json.py"
+        with open(json_path, 'r') as f:
+            self.image_paths = json.load(f)
+
+    def __len__(self):
+        return len(self.image_paths)
+
+    def __getitem__(self, idx):
+        for _ in range(20):
+            try:
+                return self.getdata(idx)
+            except Exception as e:
+                print(f"Error details: {str(e)}")
+                idx = np.random.randint(len(self))
+        raise RuntimeError('Too many bad data.')
+    
+    def getdata(self, idx):
+        image_path = self.image_paths[idx]
+        image_path_full = os.path.join(self.data_path, image_path)
+        image = Image.open(image_path_full).convert('RGB')
+        if self.transform:
+            image = self.transform(image)
+        return image, torch.tensor(0)
+
+
+def build_openimage(args, transform):
+    return DatasetJson(args.data_path, transform=transform)

dataset/pexels.py

@@ -0,0 +1,4 @@
+from torchvision.datasets import ImageFolder
+
+def build_pexels(args, transform):
+    return ImageFolder(args.data_path, transform=transform)

dataset/t2i.py

@@ -0,0 +1,167 @@
+import os
+import json
+import numpy as np
+
+import torch
+from torch.utils.data import Dataset
+from PIL import Image 
+
+# 这个类只是获取image，使用ImageNet数据集，用于C2I任务
+class Text2ImgDatasetImg(Dataset):
+    def __init__(self, lst_dir, face_lst_dir, transform):
+        img_path_list = []
+        valid_file_path = []
+        # 遍历数据路径，找到所有 jsonl 文件
+        for lst_name in sorted(os.listdir(lst_dir)):
+            if not lst_name.endswith('.jsonl'):
+                continue
+            file_path = os.path.join(lst_dir, lst_name)
+            valid_file_path.append(file_path)
+        
+        # collect valid jsonl for face
+        if face_lst_dir is not None:
+            for lst_name in sorted(os.listdir(face_lst_dir)):
+                if not lst_name.endswith('_face.jsonl'):
+                    continue
+                file_path = os.path.join(face_lst_dir, lst_name)
+                valid_file_path.append(file_path)            
+    #读取 jsonl，获取所有图像路径    
+        for file_path in valid_file_path:
+            with open(file_path, 'r') as file:
+                for line_idx, line in enumerate(file):
+                    data = json.loads(line)
+                    img_path = data['image_path']
+                    code_dir = file_path.split('/')[-1].split('.')[0] #code_dir 记录文件夹名称，方便匹配 T5 特征文件
+                    img_path_list.append((img_path, code_dir, line_idx))
+        self.img_path_list = img_path_list
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.img_path_list)
+# 预处理图像，self.transform 进行 归一化、调整大小（需要传入 transform 参数）
+    def __getitem__(self, index):
+        img_path, code_dir, code_name = self.img_path_list[index]
+        img = Image.open(img_path).convert("RGB")
+        if self.transform is not None:
+            img = self.transform(img)
+        return img, code_name 
+
+
+# 这个类是获取图像张量 [3, H, W]  文本特征 [1, 120, 2048]，使用ADE20k数据集，用于T2I任务
+class Text2ImgDataset(Dataset):
+    def __init__(self, args, transform):
+        img_path_list = []
+        valid_file_path = []
+        # collect valid jsonl file path
+        for lst_name in sorted(os.listdir(args.data_path)):
+            if not lst_name.endswith('.jsonl'):
+                continue
+            file_path = os.path.join(args.data_path, lst_name)
+            valid_file_path.append(file_path)           
+        
+        for file_path in valid_file_path:
+            with open(file_path, 'r') as file:
+                for line_idx, line in enumerate(file):
+                    data = json.loads(line)
+                    img_path = data['image_path']
+                    code_dir = file_path.split('/')[-1].split('.')[0]
+                    img_path_list.append((img_path, code_dir, line_idx))
+        self.img_path_list = img_path_list
+        self.transform = transform
+
+        self.t5_feat_path = args.t5_feat_path
+        self.short_t5_feat_path = args.short_t5_feat_path
+        self.t5_feat_path_base = self.t5_feat_path.split('/')[-1]
+        if self.short_t5_feat_path is not None:
+            self.short_t5_feat_path_base = self.short_t5_feat_path.split('/')[-1]
+        else:
+            self.short_t5_feat_path_base = self.t5_feat_path_base
+        self.image_size = args.image_size
+        latent_size = args.image_size // args.downsample_size
+        self.code_len = latent_size ** 2
+        self.t5_feature_max_len = 120
+        self.t5_feature_dim = 2048
+        self.max_seq_length = self.t5_feature_max_len + self.code_len
+
+    def __len__(self):
+        return len(self.img_path_list)
+    
+# 在数据加载失败时返回“占位数据”，防止 DataLoader 崩溃
+    def dummy_data(self):
+        img = torch.zeros((3, self.image_size, self.image_size), dtype=torch.float32)
+        t5_feat_padding = torch.zeros((1, self.t5_feature_max_len, self.t5_feature_dim))
+        attn_mask = torch.tril(torch.ones(self.max_seq_length, self.max_seq_length, dtype=torch.bool)).unsqueeze(0)
+        valid = 0
+        return img, t5_feat_padding, attn_mask, valid
+
+    def __getitem__(self, index):
+        img_path, code_dir, code_name = self.img_path_list[index]
+        try:
+            img = Image.open(img_path).convert("RGB")
+            print(f"✅ 打开图片成功: {img_path}")                 
+        except:
+            print(f"❌ 打开图片失败: {img_path}")
+            img, t5_feat_padding, attn_mask, valid = self.dummy_data()
+            return img, t5_feat_padding, attn_mask, torch.tensor(valid)
+
+        if min(img.size) < self.image_size:
+            print(f"⚠️ 图片尺寸太小: {img.size} < {self.image_size}")
+            img, t5_feat_padding, attn_mask, valid = self.dummy_data()
+            return img, t5_feat_padding, attn_mask, torch.tensor(valid)
+
+        # 图像预处理
+        if self.transform is not None:
+            img = self.transform(img)
+        # 加载 T5 文本特征
+        # t5_file = os.path.join(self.t5_feat_path, code_dir, f"{code_name}.npy")
+        t5_file = os.path.join(self.t5_feat_path, f"{code_name}.npz")
+        print(t5_file) 
+        if torch.rand(1) < 0.3:
+            t5_file = t5_file.replace(self.t5_feat_path_base, self.short_t5_feat_path_base)
+        
+        t5_feat_padding = torch.zeros((1, self.t5_feature_max_len, self.t5_feature_dim))
+        if os.path.isfile(t5_file):
+            try:
+                # t5_feat = torch.from_numpy(np.load(t5_file))
+                npz_data = np.load(t5_file)
+                t5_feat = torch.from_numpy(npz_data["caption_emb"])
+                t5_feat_len = t5_feat.shape[1] 
+                feat_len = min(self.t5_feature_max_len, t5_feat_len)
+                t5_feat_padding[:, -feat_len:] = t5_feat[:, :feat_len]
+                emb_mask = torch.zeros((self.t5_feature_max_len,))
+                emb_mask[-feat_len:] = 1
+                attn_mask = torch.tril(torch.ones(self.max_seq_length, self.max_seq_length))
+                T = self.t5_feature_max_len
+                attn_mask[:, :T] = attn_mask[:, :T] * emb_mask.unsqueeze(0)
+                eye_matrix = torch.eye(self.max_seq_length, self.max_seq_length)
+                attn_mask = attn_mask * (1 - eye_matrix) + eye_matrix
+                attn_mask = attn_mask.unsqueeze(0).to(torch.bool)
+                valid = 1
+            except:
+                img, t5_feat_padding, attn_mask, valid = self.dummy_data()
+        else:
+            img, t5_feat_padding, attn_mask, valid = self.dummy_data()
+        # 最终返回：  
+        # 图像张量 [3, H, W]  文本特征 [1, 120, 2048]
+        # 掩码 [1, max_seq_len, max_seq_len]
+        # 是否有效的标志位 valid。
+        return img, t5_feat_padding, attn_mask, torch.tensor(valid)
+
+
+# 这个类是获取图像张量，文本特征以及控制图像（seg,depth,canny等），使用ADE20k数据集或者coco等，用于T2I任务且使用control image
+# 这个提取数据的类单独在t2i_control.py中实现了
+class Text2ImgDatasetCode(Dataset):
+    def __init__(self, args):
+        pass
+
+
+
+
+def build_t2i_image(args, transform):
+    return Text2ImgDatasetImg(args.data_path, args.data_face_path, transform)
+
+def build_t2i(args, transform):
+    return Text2ImgDataset(args, transform)
+
+def build_t2i_code(args):
+    return Text2ImgDatasetCode(args)

dataset/t2i_control.py

@@ -0,0 +1,199 @@
+from PIL import PngImagePlugin
+MaximumDecompressedSize = 1024
+MegaByte = 2**20
+PngImagePlugin.MAX_TEXT_CHUNK = MaximumDecompressedSize * MegaByte
+import torch
+from datasets import load_dataset, load_from_disk
+import random
+import pickle
+import logging
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import ProjectConfiguration, set_seed
+from datasets import load_dataset, load_from_disk, concatenate_datasets
+from huggingface_hub import create_repo, upload_folder
+from transformers import AutoTokenizer, PretrainedConfig
+import argparse
+from PIL import Image
+from pathlib import Path
+from tqdm.auto import tqdm
+from packaging import version
+from torchvision import transforms
+from torch.cuda.amp import autocast
+from torchvision.transforms.functional import normalize
+
+from dataset.utils import group_random_crop
+import numpy as np
+import os
+from language.t5 import T5Embedder
+from torch.utils.data import Dataset
+from condition.canny import CannyDetector
+# from condition.hed import HEDdetector
+
+
+logger = get_logger(__name__)
+
+class T2IControlCode(Dataset):
+    def __init__(self, args):
+        self.get_image = args.get_image
+        self.get_prompt = args.get_prompt
+        self.get_label = args.get_label
+        self.control_type = args.condition_type
+        if self.control_type == 'canny':
+            self.get_control = CannyDetector()
+        
+        self.code_path = args.code_path
+        code_file_path = os.path.join(self.code_path, 'code')
+        file_num = len(os.listdir(code_file_path))
+        self.code_files = [os.path.join(code_file_path, f"{i}.npy") for i in range(file_num)]
+        
+        if args.code_path2 is not None:
+            self.code_path2 = args.code_path2
+            code_file_path2 = os.path.join(self.code_path2, 'code')
+            file_num2 = len(os.listdir(code_file_path2))
+            self.code_files2 = [os.path.join(code_file_path2, f"{i}.npy") for i in range(file_num2)]
+            self.code_files = self.code_files + self.code_files2
+
+        self.image_size = args.image_size
+        latent_size = args.image_size // args.downsample_size
+        self.code_len = latent_size ** 2
+        self.t5_feature_max_len = 120
+        self.t5_feature_dim = 2048
+        self.max_seq_length = self.t5_feature_max_len + self.code_len
+
+    def __len__(self):
+        return len(self.code_files)
+
+    def dummy_data(self):
+        img = torch.zeros((3, self.image_size, self.image_size), dtype=torch.float32)
+        t5_feat_padding = torch.zeros((1, self.t5_feature_max_len, self.t5_feature_dim))
+        attn_mask = torch.tril(torch.ones(self.max_seq_length, self.max_seq_length, dtype=torch.bool)).unsqueeze(0)
+        valid = 0
+        return img, t5_feat_padding, attn_mask, valid
+
+    def collate_fn(self, examples):
+        
+        code = torch.stack([example["code"] for example in examples])
+        control =  torch.stack([example["control"] for example in examples])
+        if self.control_type == 'canny':
+            control = control.unsqueeze(1).repeat(1,3,1,1)
+        caption_emb =  torch.stack([example["caption_emb"] for example in examples])
+        attn_mask = torch.stack([example["attn_mask"] for example in examples])
+        valid = torch.stack([example["valid"] for example in examples])
+        if self.get_image:
+            image = torch.stack([example["image"] for example in examples])
+        if self.get_prompt:
+            prompt = [example["prompt"][0] for example in examples]
+        if self.control_type == "seg":
+            label = torch.stack([example["label"] for example in examples])
+            
+        output = {}
+        output['code'] = code
+        output['control'] = control
+        output['caption_emb'] = caption_emb
+        output['attn_mask'] = attn_mask
+        output['valid'] = valid
+        output['prompt'] = prompt
+        if self.get_image:
+            output['image'] = image
+        if self.get_prompt:
+            output['prompt'] = prompt
+        if self.control_type == "seg":
+            output['label'] = label
+        return output
+
+    def __getitem__(self, index):
+        
+        
+        code_path = self.code_files[index]
+        if self.control_type == 'seg':
+            control_path = code_path.replace('code', 'control').replace('npy', 'png') 
+            control = np.array(Image.open(control_path))/255
+            control = 2*(control - 0.5)
+        elif self.control_type == 'depth':
+            control_path = code_path.replace('code', 'control_depth').replace('npy', 'png')
+            control = np.array(Image.open(control_path))/255
+            control = 2*(control - 0.5)
+        caption_path = code_path.replace('code', 'caption_emb').replace('npy', 'npz') 
+        image_path = code_path.replace('code', 'image').replace('npy', 'png')
+        label_path = code_path.replace('code', 'label').replace('npy', 'png') 
+        
+        code = np.load(code_path)
+        image = np.array(Image.open(image_path))
+        
+        
+        
+        t5_feat_padding = torch.zeros((1, self.t5_feature_max_len, self.t5_feature_dim))
+        caption = np.load(caption_path)
+        
+        t5_feat = torch.from_numpy(caption['caption_emb'])
+        prompt = caption['prompt']
+        t5_feat_len = t5_feat.shape[1] 
+        feat_len = min(self.t5_feature_max_len, t5_feat_len)
+        t5_feat_padding[:, -feat_len:] = t5_feat[:, :feat_len]
+        emb_mask = torch.zeros((self.t5_feature_max_len,))
+        emb_mask[-feat_len:] = 1
+        attn_mask = torch.tril(torch.ones(self.max_seq_length, self.max_seq_length))
+        T = self.t5_feature_max_len
+        attn_mask[:, :T] = attn_mask[:, :T] * emb_mask.unsqueeze(0)
+        eye_matrix = torch.eye(self.max_seq_length, self.max_seq_length)
+        attn_mask = attn_mask * (1 - eye_matrix) + eye_matrix
+        attn_mask = attn_mask.unsqueeze(0).to(torch.bool)
+        valid = 1
+        
+        output = {}
+        output['code'] = torch.from_numpy(code)
+        if self.control_type == 'canny':
+            output['control'] = torch.from_numpy(2*(self.get_control(image)/255 - 0.5))
+        elif self.control_type == "seg":
+            output['control'] = torch.from_numpy(control.transpose(2,0,1))
+        elif self.control_type == "depth":
+            output['control'] = torch.from_numpy(control.transpose(2,0,1))
+        elif self.control_type == 'hed':
+            output['control'] = torch.from_numpy(image.transpose(2,0,1))
+        elif self.control_type == 'lineart':
+            output['control'] = torch.from_numpy(image.transpose(2,0,1))
+        output['caption_emb'] = t5_feat_padding
+        output['attn_mask'] = attn_mask
+        output['valid'] = torch.tensor(valid)
+        output['image'] = torch.from_numpy(image.transpose(2,0,1))
+        if self.get_prompt:
+            output['prompt'] = prompt
+        if self.control_type == "seg":
+            output['label'] = torch.from_numpy(np.array(Image.open(label_path)))
+        return output
+
+
+def build_t2i_control_code(args):
+    dataset = T2IControlCode(args)
+    return dataset
+
+if __name__ == '__main__':
+
+    args = parse_args()
+
+    logging_dir = Path(args.output_dir, args.logging_dir)
+
+    accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to,
+        project_config=accelerator_project_config,
+    )
+
+    train_dataset, val_dataset = make_train_dataset(args, None, accelerator)
+
+
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=True,
+        collate_fn=collate_fn,
+        batch_size=8,
+        num_workers=0,
+    )
+
+    from tqdm import tqdm 
+    for step, batch in tqdm(enumerate(train_dataloader)):
+        continue

dataset/test_dataset_t2i.py

@@ -0,0 +1,47 @@
+import os
+import argparse
+import torch
+from torchvision import transforms
+from torch.utils.data import DataLoader
+from PIL import Image
+from t2i import Text2ImgDataset  # 确保你的类写在 t2i.py 或其他 import 位置正确
+from tqdm import tqdm
+
+def get_args():
+    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='备用 T5 特征路径')
+    parser.add_argument('--image_size', type=int, default=512)
+    parser.add_argument('--downsample_size', type=int, default=8)
+    parser.add_argument('--max_show', type=int, default=5, help='最多显示多少条样本')
+    return parser.parse_args()
+
+def main():
+    args = get_args()
+
+    transform = transforms.Compose([
+        transforms.Resize((args.image_size, args.image_size)),
+        transforms.ToTensor()
+    ])
+
+    dataset = Text2ImgDataset(args, transform=transform)
+    dataset.__getitem__
+    print(f"📦 数据集大小: {len(dataset)}")
+
+    loader = DataLoader(dataset, batch_size=1, shuffle=False, num_workers=2)
+
+    for i, (img, t5_feat, attn_mask, valid) in enumerate(tqdm(loader)):
+        print(f"\n🟡 Sample #{i}")
+        print(f" - 图像尺寸: {img.shape}")
+        print(f" - T5 特征 shape: {t5_feat.shape}")
+        print(f" - Attention mask shape: {attn_mask.shape}")
+        print(f" - 是否有效: {valid.item()}")
+        if valid.item() == 0:
+            print(" ⚠️ 无效样本，可能 T5 特征缺失或图片加载失败")
+        if i + 1 >= args.max_show:
+            break
+
+if __name__ == "__main__":
+    main()
+

dataset/test_t5_npz.py

@@ -0,0 +1,41 @@
+import os
+import json
+import argparse
+from tqdm import tqdm
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data_path', type=str, default="./data/Captioned_ADE20K/train", required=True, help='路径下包含多个 .jsonl 文件')
+    parser.add_argument('--t5_feat_path', default="./data/Captioned_ADE20K/train/caption_emb", type=str, required=True, help='T5 特征路径（主）')
+    return parser.parse_args()
+
+def main():
+    args = get_args()
+    error_list = []
+
+    # 遍历 .jsonl 文件
+    for fname in os.listdir(args.data_path):
+        if not fname.endswith('.jsonl'):
+            continue
+        fpath = os.path.join(args.data_path, fname)
+        with open(fpath, 'r') as f:
+            for line in tqdm(f, desc=f"Checking {fname}"):
+                data = json.loads(line.strip())
+                img_path = data['image_path']  # e.g., train/image/0.png
+                img_name = os.path.basename(img_path)  # e.g., 0.png
+                code_name = os.path.splitext(img_name)[0]  # e.g., 0
+
+                # 检查是否存在 .npz 或 .npy
+                npz_path = os.path.join(args.t5_feat_path, f"{code_name}.npz")
+                npy_path = os.path.join(args.t5_feat_path, f"{code_name}.npy")
+                if not os.path.exists(npz_path) and not os.path.exists(npy_path):
+                    error_list.append(code_name)
+
+    print(f"\n缺失 T5 特征文件的样本数: {len(error_list)}")
+    if error_list:
+        print("缺失编号（前20个）:")
+        for path in error_list[:20]:
+            print(path)
+
+if __name__ == '__main__':
+    main()

dataset/utils.py

@@ -0,0 +1,325 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import torchvision.transforms.functional as F
+
+from PIL import Image
+from typing import Optional
+from functools import partial
+from torch import Tensor
+from torchvision import transforms
+
+# from canny_tools import Canny  # canny edge detection
+# from mmengine.hub import get_model  # segmentation
+from transformers import DPTForDepthEstimation  # depth estimation
+
+# from mmseg.models.losses.silog_loss import silog_loss
+from torchvision.transforms import RandomCrop
+
+
+def get_reward_model(task='segmentation', model_path='mmseg::upernet/upernet_r50_4xb4-160k_ade20k-512x512.py'):
+    """Return reward model for different tasks.
+
+    Args:
+        task (str, optional): Task name. Defaults to 'segmentation'.
+        model_path (str, optional): Model name or pre-trained path.
+
+    """
+    if task == 'segmentation':
+        return get_model(model_path, pretrained=True)
+    elif task == 'canny':
+        return Canny()
+    elif task == 'depth':
+        return DPTForDepthEstimation.from_pretrained(model_path)
+    elif task == 'lineart':
+        model = LineDrawingModel()
+        model.load_state_dict(torch.hub.load_state_dict_from_url(model_path, map_location=torch.device('cpu')))
+        return model
+    elif task == 'hed':
+        return HEDdetector(model_path)
+    else:
+        raise not NotImplementedError("Only support segmentation, canny and depth for now.")
+
+
+def get_reward_loss(predictions, labels, task='segmentation', **args):
+    """Return reward loss for different tasks.
+
+    Args:
+        task (str, optional): Task name.
+
+    Returns:
+        torch.nn.Module: Loss class.
+    """
+    if task == 'segmentation':
+        return nn.functional.cross_entropy(predictions, labels, ignore_index=255, **args)
+    elif task == 'canny':
+        loss = nn.functional.mse_loss(predictions, labels, **args).mean(2)
+        return loss.mean((-1,-2))
+    elif task in ['depth', 'lineart', 'hed']:
+        loss = nn.functional.mse_loss(predictions, labels, **args)
+        return loss
+    else:
+        raise not NotImplementedError("Only support segmentation, canny and depth for now.")
+
+
+def image_grid(imgs, rows, cols):
+    """Image grid for visualization."""
+    assert len(imgs) == rows * cols
+
+    w, h = imgs[0].size
+    grid = Image.new("RGB", size=(cols * w, rows * h))
+
+    for i, img in enumerate(imgs):
+        grid.paste(img, box=(i % cols * w, i // cols * h))
+    return grid
+
+
+def map_color_to_index(image, dataset='limingcv/Captioned_ADE20K'):
+    """Map colored segmentation image (RGB) into original label format (L).
+
+    Args:
+        image (torch.tensor): image tensor with shape (N, 3, H, W).
+        dataset (str, optional): Dataset name. Defaults to 'ADE20K'.
+
+    Returns:
+        torch.tensor: mask tensor with shape (N, H, W).
+    """
+    if dataset == 'limingcv/Captioned_ADE20K':
+        palette = np.load('ade20k_palette.npy')
+    elif dataset == 'limingcv/Captioned_COCOStuff':
+        palette = np.load('coco_stuff_palette.npy')
+    else:
+        raise NotImplementedError("Only support ADE20K and COCO-Stuff dataset for now.")
+
+    image = image * 255
+    palette_tensor = torch.tensor(palette, dtype=image.dtype, device=image.device)
+    reshaped_image = image.permute(0, 2, 3, 1).reshape(-1, 3)
+
+    # Calculate the difference of colors and find the index of the minimum distance
+    indices = torch.argmin(torch.norm(reshaped_image[:, None, :] - palette_tensor, dim=-1), dim=-1)
+
+    # Transform indices back to original shape
+    return indices.view(image.shape[0], image.shape[2], image.shape[3])
+
+
+def seg_label_transform(
+        labels,
+        dataset_name='limingcv/Captioned_ADE20K',
+        output_size=(64, 64),
+        interpolation=transforms.InterpolationMode.NEAREST,
+        max_size=None,
+        antialias=True):
+    """Adapt RGB seg_map into loss computation. \
+    (1) Map the RGB seg_map into the original label format (Single Channel). \
+    (2) Resize the seg_map into the same size as the output feature map. \
+    (3) Remove background class if needed (usually for ADE20K).
+
+    Args:
+        labels (torch.tensor): Segmentation map. (N, 3, H, W) for ADE20K and (N, H, W) for COCO-Stuff.
+        dataset_name (string): Dataset name. Default to 'ADE20K'.
+        output_size (tuple): Resized image size, should be aligned with the output of segmentation models.
+        interpolation (optional): _description_. Defaults to transforms.InterpolationMode.NEAREST.
+        max_size (optional): Defaults to None.
+        antialias (optional): Defaults to True.
+
+    Returns:
+        torch.tensor: formatted labels for loss computation.
+    """
+
+    if dataset_name == 'limingcv/Captioned_ADE20K':
+        labels = map_color_to_index(labels, dataset_name)
+        labels = F.resize(labels, output_size, interpolation, max_size, antialias)
+
+        # 0 means the background class in ADE20K
+        # In a unified format, we use 255 to represent the background class for both ADE20K and COCO-Stuff
+        labels = labels - 1
+        labels[labels == -1] = 255
+    elif dataset_name == 'limingcv/Captioned_COCOStuff':
+        labels = F.resize(labels, output_size, interpolation, max_size, antialias)
+
+    return labels.long()
+
+def depth_label_transform(
+        labels,
+        dataset_name,
+        output_size=None,
+        interpolation=transforms.InterpolationMode.BILINEAR,
+        max_size=None,
+        antialias=True
+    ):
+
+    if output_size is not None:
+        labels = F.resize(labels, output_size, interpolation, max_size, antialias)
+    return labels
+
+
+def edge_label_transform(labels, dataset_name):
+    return labels
+
+
+def label_transform(labels, task, dataset_name, **args):
+    if task == 'segmentation':
+        return seg_label_transform(labels, dataset_name, **args)
+    elif task == 'depth':
+        return depth_label_transform(labels, dataset_name, **args)
+    elif task in ['canny', 'lineart', 'hed']:
+        return edge_label_transform(labels, dataset_name, **args)
+    else:
+        raise NotImplementedError("Only support segmentation and edge detection for now.")
+
+
+def group_random_crop(images, resolution):
+    """
+    Args:
+        images (list of PIL Image or Tensor): List of images to be cropped.
+
+    Returns:
+        List of PIL Image or Tensor: List of cropped image.
+    """
+
+    if isinstance(resolution, int):
+        resolution = (resolution, resolution)
+
+    for idx, image in enumerate(images):
+        i, j, h, w = RandomCrop.get_params(image, output_size=resolution)
+        images[idx] = F.crop(image, i, j, h, w)
+
+    return images
+
+
+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 LineDrawingModel(nn.Module):
+    def __init__(self, input_nc=3, output_nc=1, n_residual_blocks=3, sigmoid=True):
+        super(LineDrawingModel, 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):
+        out = self.model0(x)
+        out = self.model1(out)
+        out = self.model2(out)
+        out = self.model3(out)
+        out = self.model4(out)
+
+        return out
+
+
+
+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(nn.Module):
+    def __init__(self, model_path):
+        super().__init__()
+        state_dict = torch.hub.load_state_dict_from_url(model_path, map_location=torch.device('cpu'))
+
+        self.netNetwork = ControlNetHED_Apache2()
+        self.netNetwork.load_state_dict(state_dict)
+
+    def __call__(self, input_image):
+        H, W = input_image.shape[2], input_image.shape[3]
+
+        edges = self.netNetwork((input_image * 255).clip(0, 255))
+        edges = [torch.nn.functional.interpolate(edge, size=(H, W), mode='bilinear') for edge in edges]
+        edges = torch.stack(edges, dim=1)
+        edge = 1 / (1 + torch.exp(-torch.mean(edges, dim=1)))
+        edge = (edge * 255.0).clip(0, 255).to(torch.uint8)
+
+        return edge / 255.0

demo/app.py

@@ -0,0 +1,34 @@
+import os
+import gradio as gr
+from .model import Model
+from huggingface_hub import hf_hub_download
+from app_canny import create_demo as create_demo_canny
+from app_depth import create_demo as create_demo_depth
+
+hf_hub_download(repo_id='wondervictor/ControlAR',
+                filename='canny_base.safetensors',
+                local_dir='./checkpoints/')
+hf_hub_download(repo_id='wondervictor/ControlAR',
+                filename='depth_base.safetensors',
+                local_dir='./checkpoints/')
+# hf_hub_download('google/flan-t5-xl', cache_dir='./checkpoints/')
+
+DESCRIPTION = "# [ControlAR: Controllable Image Generation with Autoregressive Models](https://arxiv.org/abs/2410.02705) \n ### The first row in outputs is the input image and condition. The second row is the images generated by ControlAR.  \n ### You can run locally by following the instruction on our [Github Repo](https://github.com/hustvl/ControlAR)."
+SHOW_DUPLICATE_BUTTON = os.getenv("SHOW_DUPLICATE_BUTTON") == "1"
+model = Model()
+device = "cuda"
+with gr.Blocks(css="style.css") as demo:
+    gr.Markdown(DESCRIPTION)
+    gr.DuplicateButton(
+        value="Duplicate Space for private use",
+        elem_id="duplicate-button",
+        visible=SHOW_DUPLICATE_BUTTON,
+    )
+    with gr.Tabs():
+        with gr.TabItem("Depth"):
+            create_demo_depth(model.process_depth)
+        with gr.TabItem("Canny"):
+            create_demo_canny(model.process_edge)
+
+if __name__ == "__main__":
+    demo.launch(share=False)

demo/app_depth.py

@@ -0,0 +1,135 @@
+import gradio as gr
+import random
+
+
+def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:
+    if randomize_seed:
+        seed = random.randint(0, 100000000)
+    return seed
+
+
+examples = [
+            [
+                "condition/example/t2i/bird.jpg",
+                "A bird made of blue crystal"
+            ],
+            [
+                "condition/example/t2i/sofa.png",
+                "The red sofa in the living room has several pillows on it"
+            ],
+            [
+                "condition/example/t2i/house.jpg",
+                "A brick house with a chimney under a starry sky.",
+            ]
+           ]
+
+
+def create_demo(process):
+    with gr.Blocks() as demo:
+        with gr.Row():
+            with gr.Column():
+                image = gr.Image()
+                prompt = gr.Textbox(label="Prompt")
+                run_button = gr.Button("Run")
+                with gr.Accordion("Advanced options", open=False):
+                    preprocessor_name = gr.Radio(
+                        label="Preprocessor",
+                        choices=[
+                            "depth",
+                            "No preprocess",
+                        ],
+                        type="value",
+                        value="depth",
+                        info='depth.',
+                    )
+                    cfg_scale = gr.Slider(label="Guidance scale",
+                                          minimum=0.1,
+                                          maximum=30.0,
+                                          value=4,
+                                          step=0.1)
+                    control_strength = gr.Slider(minimum=0., maximum=1.0, step=0.1, value=0.6, label="control_strength")
+                    # resolution = gr.Slider(label="(H, W)",
+                    #                        minimum=384,
+                    #                        maximum=768,
+                    #                        value=512,
+                    #                        step=16)
+                    top_k = gr.Slider(minimum=1,
+                                      maximum=16384,
+                                      step=1,
+                                      value=2000,
+                                      label='Top-K')
+                    top_p = gr.Slider(minimum=0.,
+                                      maximum=1.0,
+                                      step=0.1,
+                                      value=1.0,
+                                      label="Top-P")
+                    temperature = gr.Slider(minimum=0.,
+                                            maximum=1.0,
+                                            step=0.1,
+                                            value=1.0,
+                                            label='Temperature')
+                    seed = gr.Slider(label="Seed",
+                                     minimum=0,
+                                     maximum=100000000,
+                                     step=1,
+                                     value=0)
+                    randomize_seed = gr.Checkbox(label="Randomize seed",
+                                                 value=True)
+            with gr.Column():
+                result = gr.Gallery(label="Output",
+                                    show_label=False,
+                                    height='800px',
+                                    columns=2,
+                                    object_fit="scale-down")
+        gr.Examples(
+            examples=examples,
+            inputs=[
+                image,
+                prompt,
+                # resolution,
+            ]
+        )
+        inputs = [
+            image,
+            prompt,
+            cfg_scale,
+            temperature,
+            top_k,
+            top_p,
+            seed,
+            control_strength,
+            preprocessor_name
+        ]
+        prompt.submit(
+            fn=randomize_seed_fn,
+            inputs=[seed, randomize_seed],
+            outputs=seed,
+            queue=False,
+            api_name=False,
+        ).then(
+            fn=process,
+            inputs=inputs,
+            outputs=result,
+            api_name=False,
+        )
+        run_button.click(
+            fn=randomize_seed_fn,
+            inputs=[seed, randomize_seed],
+            outputs=seed,
+            queue=False,
+            api_name=False,
+        ).then(
+            fn=process,
+            inputs=inputs,
+            outputs=result,
+            api_name="depth",
+        )
+    return demo
+
+
+if __name__ == "__main__":
+    from model import Model
+    model = Model()
+    demo = create_demo(model.process_depth)
+    demo.queue().launch(share=False, server_name="0.0.0.0")
+

demo/app_edge.py

@@ -0,0 +1,150 @@
+import gradio as gr
+import random
+
+
+def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:
+    if randomize_seed:
+        seed = random.randint(0, 100000000)
+    return seed
+
+
+examples = [
+    [
+        "condition/example/t2i/landscape.jpg",
+        "Landscape photos with snow on the mountains in the distance and clear reflections in the lake near by",
+    ],
+    [
+        "condition/example/t2i/girl.jpg",
+        "A girl with blue hair",
+    ],
+    [
+        "condition/example/t2i/eye.png",
+        "A vivid drawing of an eye with a few pencils nearby",
+    ],
+]
+
+
+def create_demo(process):
+    with gr.Blocks() as demo:
+        with gr.Row():
+            with gr.Column():
+                image = gr.Image()
+                prompt = gr.Textbox(label="Prompt")
+                run_button = gr.Button("Run")
+                with gr.Accordion("Advanced options", open=False):
+                    preprocessor_name = gr.Radio(
+                        label="Preprocessor",
+                        choices=[
+                            "Hed",
+                            "Canny",
+                            "Lineart",
+                            "No preprocess",
+                        ],
+                        type="value",
+                        value="Hed",
+                        info='Edge type.',
+                    )
+                    canny_low_threshold = gr.Slider(
+                        label="Canny low threshold",
+                        minimum=0,
+                        maximum=255,
+                        value=100,
+                        step=50)
+                    canny_high_threshold = gr.Slider(
+                        label="Canny high threshold",
+                        minimum=0,
+                        maximum=255,
+                        value=200,
+                        step=50)
+                    cfg_scale = gr.Slider(label="Guidance scale",
+                                          minimum=0.1,
+                                          maximum=30.0,
+                                          value=4,
+                                          step=0.1)
+                    control_strength = gr.Slider(minimum=0., maximum=1.0, step=0.1, value=0.6, label="control_strength")
+                    # relolution = gr.Slider(label="(H, W)",
+                    #                        minimum=384,
+                    #                        maximum=768,
+                    #                        value=512,
+                    #                        step=16)
+                    top_k = gr.Slider(minimum=1,
+                                      maximum=16384,
+                                      step=1,
+                                      value=2000,
+                                      label='Top-K')
+                    top_p = gr.Slider(minimum=0.,
+                                      maximum=1.0,
+                                      step=0.1,
+                                      value=1.0,
+                                      label="Top-P")
+                    temperature = gr.Slider(minimum=0.,
+                                            maximum=1.0,
+                                            step=0.1,
+                                            value=1.0,
+                                            label='Temperature')
+                    seed = gr.Slider(label="Seed",
+                                     minimum=0,
+                                     maximum=100000000,
+                                     step=1,
+                                     value=0)
+                    randomize_seed = gr.Checkbox(label="Randomize seed",
+                                                 value=True)
+            with gr.Column():
+                result = gr.Gallery(label="Output",
+                                    show_label=False,
+                                    height='800px',
+                                    columns=2,
+                                    object_fit="scale-down")
+        gr.Examples(
+            examples=examples,
+            inputs=[
+                image,
+                prompt,
+                # relolution,
+            ]
+        )
+        inputs = [
+            image,
+            prompt,
+            cfg_scale,
+            temperature,
+            top_k,
+            top_p,
+            seed,
+            canny_low_threshold,
+            canny_high_threshold,
+            control_strength,
+            preprocessor_name,
+        ]
+        # prompt.submit(
+        #     fn=randomize_seed_fn,
+        #     inputs=[seed, randomize_seed],
+        #     outputs=seed,
+        #     queue=False,
+        #     api_name=False,
+        # ).then(
+        #     fn=process,
+        #     inputs=inputs,
+        #     outputs=result,
+        #     api_name=False,
+        # )
+        run_button.click(
+            fn=randomize_seed_fn,
+            inputs=[seed, randomize_seed],
+            outputs=seed,
+            queue=False,
+            api_name=False,
+        ).then(
+            fn=process,
+            inputs=inputs,
+            outputs=result,
+            api_name="edge",
+        )
+    return demo
+
+
+if __name__ == "__main__":
+    from model import Model
+    model = Model()
+    demo = create_demo(model.process_edge)
+    demo.queue().launch(share=False, server_name="0.0.0.0")

demo/model.py

@@ -0,0 +1,284 @@
+import gc
+import spaces
+from safetensors.torch import load_file
+from autoregressive.models.gpt_t2i import GPT_models
+from tokenizer.tokenizer_image.vq_model import VQ_models
+from language.t5 import T5Embedder
+import torch
+import numpy as np
+import PIL
+from PIL import Image
+from condition.canny import CannyDetector
+import time
+from autoregressive.models.generate import generate
+from condition.midas.depth import MidasDetector
+from preprocessor import Preprocessor
+
+models = {
+    "edge": "checkpoints/edge_base.safetensors",
+    "depth": "checkpoints/depth_base.safetensors",
+}
+class Model:
+    def __init__(self):
+        self.device = torch.device(
+            "cuda")
+        self.base_model_id = ""
+        self.task_name = ""
+        self.vq_model = self.load_vq()
+        self.t5_model = self.load_t5()
+        # self.gpt_model_edge = self.load_gpt(condition_type='edge')
+        # self.gpt_model_depth = self.load_gpt(condition_type='depth')
+        self.gpt_model = self.load_gpt()
+        self.preprocessor = Preprocessor()
+
+    def to(self, device):
+        self.gpt_model_canny.to('cuda')
+
+    def load_vq(self):
+        vq_model = VQ_models["VQ-16"](codebook_size=16384,
+                                      codebook_embed_dim=8)
+        vq_model.eval()
+        checkpoint = torch.load(f"checkpoints/vq_ds16_t2i.pt",
+                                map_location="cpu")
+        vq_model.load_state_dict(checkpoint["model"])
+        del checkpoint
+        print("image tokenizer is loaded")
+        return vq_model
+
+    def load_gpt(self, condition_type='edge'):
+        # gpt_ckpt = models[condition_type]
+        # precision = torch.bfloat16
+        precision = torch.float32
+        latent_size = 512 // 16
+        gpt_model = GPT_models["GPT-XL"](
+            block_size=latent_size**2,
+            cls_token_num=120,
+            model_type='t2i',
+            condition_type=condition_type,
+            adapter_size='base',
+        ).to(device='cpu', dtype=precision)
+        # model_weight = load_file(gpt_ckpt)
+        # gpt_model.load_state_dict(model_weight, strict=False)
+        # gpt_model.eval()
+        # print("gpt model is loaded")
+        return gpt_model
+
+    def load_gpt_weight(self, condition_type='edge'):
+        torch.cuda.empty_cache()
+        gc.collect()
+        gpt_ckpt = models[condition_type]
+        model_weight = load_file(gpt_ckpt)
+        self.gpt_model.load_state_dict(model_weight, strict=False)
+        self.gpt_model.eval()
+        torch.cuda.empty_cache()
+        gc.collect()
+        # print("gpt model is loaded")
+        
+    def load_t5(self):
+        # precision = torch.bfloat16
+        precision = torch.float32
+        t5_model = T5Embedder(
+            device=self.device,
+            local_cache=True,
+            cache_dir='checkpoints/flan-t5-xl',
+            dir_or_name='flan-t5-xl',
+            torch_dtype=precision,
+            model_max_length=120,
+        )
+        return t5_model
+
+    @torch.no_grad()
+    @spaces.GPU(enable_queue=True)
+    def process_edge(
+        self,
+        image: np.ndarray,
+        prompt: str,
+        cfg_scale: float,
+        temperature: float,
+        top_k: int,
+        top_p: int,
+        seed: int,
+        low_threshold: int,
+        high_threshold: int,
+        control_strength: float,
+        preprocessor_name: str,
+    ) -> list[PIL.Image.Image]:
+        
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        origin_W, origin_H = image.size
+        if preprocessor_name == 'Canny':
+            self.preprocessor.load("Canny")
+            condition_img = self.preprocessor(
+                image=image, low_threshold=low_threshold, high_threshold=high_threshold, detect_resolution=512)
+        elif preprocessor_name == 'Hed':
+            self.preprocessor.load("HED")
+            condition_img = self.preprocessor(
+                image=image,image_resolution=512, detect_resolution=512)
+        elif preprocessor_name == 'Lineart':
+            self.preprocessor.load("Lineart")
+            condition_img = self.preprocessor(
+                image=image,image_resolution=512, detect_resolution=512)
+        elif preprocessor_name == 'No preprocess':
+            condition_img = image
+        print('get edge')
+        del self.preprocessor.model
+        torch.cuda.empty_cache()
+        condition_img = condition_img.resize((512,512))
+        W, H = condition_img.size
+
+        self.t5_model.model.to('cuda').to(torch.bfloat16)
+        self.load_gpt_weight('edge')
+        self.gpt_model.to('cuda').to(torch.bfloat16)
+        self.vq_model.to('cuda')
+        condition_img = torch.from_numpy(np.array(condition_img)).unsqueeze(0).permute(0,3,1,2).repeat(1,1,1,1)
+        condition_img = condition_img.to(self.device)
+        condition_img = 2*(condition_img/255 - 0.5)
+        prompts = [prompt] * 1
+        caption_embs, emb_masks = self.t5_model.get_text_embeddings(prompts)
+
+        print(f"processing left-padding...")
+        new_emb_masks = torch.flip(emb_masks, dims=[-1])
+        new_caption_embs = []
+        for idx, (caption_emb,
+                  emb_mask) in enumerate(zip(caption_embs, emb_masks)):
+            valid_num = int(emb_mask.sum().item())
+            print(f'  prompt {idx} token len: {valid_num}')
+            new_caption_emb = torch.cat(
+                [caption_emb[valid_num:], caption_emb[:valid_num]])
+            new_caption_embs.append(new_caption_emb)
+        new_caption_embs = torch.stack(new_caption_embs)
+        c_indices = new_caption_embs * new_emb_masks[:, :, None]
+        c_emb_masks = new_emb_masks
+        qzshape = [len(c_indices), 8, H // 16, W // 16]
+        t1 = time.time()
+        print(caption_embs.device)
+        index_sample = generate(
+            self.gpt_model,
+            c_indices,
+            (H // 16) * (W // 16),
+            c_emb_masks,
+            condition=condition_img,
+            cfg_scale=cfg_scale,
+            temperature=temperature,
+            top_k=top_k,
+            top_p=top_p,
+            sample_logits=True,
+            control_strength=control_strength,
+        )
+        sampling_time = time.time() - t1
+        print(f"Full sampling takes about {sampling_time:.2f} seconds.")
+
+        t2 = time.time()
+        print(index_sample.shape)
+        samples = self.vq_model.decode_code(
+            index_sample, qzshape)  # output value is between [-1, 1]
+        decoder_time = time.time() - t2
+        print(f"decoder takes about {decoder_time:.2f} seconds.")
+        # samples = condition_img[0:1]
+        samples = torch.cat((condition_img[0:1], samples), dim=0)
+        samples = 255 * (samples * 0.5 + 0.5)
+        samples = [
+            Image.fromarray(
+                sample.permute(1, 2, 0).cpu().detach().numpy().clip(
+                    0, 255).astype(np.uint8)) for sample in samples
+        ]
+        del condition_img
+        torch.cuda.empty_cache()
+        return samples
+
+    @torch.no_grad()
+    @spaces.GPU(enable_queue=True)
+    def process_depth(
+        self,
+        image: np.ndarray,
+        prompt: str,
+        cfg_scale: float,
+        temperature: float,
+        top_k: int,
+        top_p: int,
+        seed: int,
+        control_strength: float,
+        preprocessor_name: str
+    ) -> list[PIL.Image.Image]:
+        
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        origin_W, origin_H = image.size
+        # print(image)
+        if preprocessor_name == 'depth':
+            self.preprocessor.load("Depth")
+            condition_img = self.preprocessor(
+                    image=image,
+                    image_resolution=512,
+                    detect_resolution=512,
+                )
+        elif preprocessor_name == 'No preprocess':
+            condition_img = image
+        print('get depth')
+        del self.preprocessor.model
+        torch.cuda.empty_cache()
+        condition_img = condition_img.resize((512,512))
+        W, H = condition_img.size
+
+        self.t5_model.model.to(self.device).to(torch.bfloat16)
+        self.load_gpt_weight('depth')
+        self.gpt_model.to('cuda').to(torch.bfloat16)
+        self.vq_model.to(self.device)
+        condition_img = torch.from_numpy(np.array(condition_img)).unsqueeze(0).permute(0,3,1,2).repeat(1,1,1,1)
+        condition_img = condition_img.to(self.device)
+        condition_img = 2*(condition_img/255 - 0.5)
+        prompts = [prompt] * 1
+        caption_embs, emb_masks = self.t5_model.get_text_embeddings(prompts)
+
+        print(f"processing left-padding...")
+        new_emb_masks = torch.flip(emb_masks, dims=[-1])
+        new_caption_embs = []
+        for idx, (caption_emb,
+                  emb_mask) in enumerate(zip(caption_embs, emb_masks)):
+            valid_num = int(emb_mask.sum().item())
+            print(f'  prompt {idx} token len: {valid_num}')
+            new_caption_emb = torch.cat(
+                [caption_emb[valid_num:], caption_emb[:valid_num]])
+            new_caption_embs.append(new_caption_emb)
+        new_caption_embs = torch.stack(new_caption_embs)
+
+        c_indices = new_caption_embs * new_emb_masks[:, :, None]
+        c_emb_masks = new_emb_masks
+        qzshape = [len(c_indices), 8, H // 16, W // 16]
+        t1 = time.time()
+        index_sample = generate(
+            self.gpt_model,
+            c_indices,
+            (H // 16) * (W // 16),
+            c_emb_masks,
+            condition=condition_img,
+            cfg_scale=cfg_scale,
+            temperature=temperature,
+            top_k=top_k,
+            top_p=top_p,
+            sample_logits=True,
+            control_strength=control_strength,
+        )
+        sampling_time = time.time() - t1
+        print(f"Full sampling takes about {sampling_time:.2f} seconds.")
+
+        t2 = time.time()
+        print(index_sample.shape)
+        samples = self.vq_model.decode_code(index_sample, qzshape)
+        decoder_time = time.time() - t2
+        print(f"decoder takes about {decoder_time:.2f} seconds.")
+        condition_img = condition_img.cpu()
+        samples = samples.cpu()
+
+        # samples = condition_img[0:1]
+        samples = torch.cat((condition_img[0:1], samples), dim=0)
+        samples = 255 * (samples * 0.5 + 0.5)
+        samples = [
+            Image.fromarray(
+                sample.permute(1, 2, 0).cpu().detach().numpy().clip(0, 255).astype(np.uint8))
+            for sample in samples
+        ]
+        del condition_img
+        torch.cuda.empty_cache()
+        return samples

evaluations/ade20k_mIoU.py

@@ -0,0 +1,68 @@
+import os
+import numpy as np
+from mmseg.apis import init_model, inference_model, show_result_pyplot#, inference_segmentor
+import torch
+from PIL import Image
+from sklearn.metrics import confusion_matrix
+from torchmetrics import JaccardIndex
+
+def main():
+    config_file = 'mmsegmentation/configs/mask2former/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640.py'
+    checkpoint_file = 'evaluations/mask2former_swin-l-in22k-384x384-pre_8xb2-160k_ade20k-640x640_20221203_235933-7120c214.pth'
+    
+    # build the model from a config file and a checkpoint file
+    model = init_model(config_file, checkpoint_file, device='cuda:0')
+    
+    # Image and segmentation labels directories
+    img_dir = 'sample/ade20k/visualization'
+    ann_dir = 'sample/ade20k/annotations'
+    
+    # List all image files
+    img_fns = [f for f in sorted(os.listdir(img_dir)) if f.endswith(".png")]
+    # ann_fns = [f for f in sorted(os.listdir(ann_dir)) if f.endswith(".png")]
+    
+    total_mIoU = 0
+    from tqdm import tqdm
+    i = 0
+    jaccard_index = JaccardIndex(task="multiclass", num_classes=150)
+    num_classes = 150
+    conf_matrix = np.zeros((num_classes + 1, num_classes + 1), dtype=np.int64)
+    for img_fn in tqdm(img_fns):
+        i += 1
+        # if i >= 100:
+        #     break
+        # try:
+        img_path = os.path.join(img_dir, img_fn)
+        ann_path = os.path.join(ann_dir, img_fn)
+        result = inference_model(model, img_path)
+        # except Exception as e:
+        #     continue
+        # Read ground truth segmentation map
+        gt_semantic_seg = np.array(Image.open(ann_path))
+
+        ignore_label = 0
+        gt = gt_semantic_seg.copy()
+        pred = result.pred_sem_seg.data[0].cpu().numpy().copy()+1
+        gt[gt == ignore_label] = num_classes
+        conf_matrix += np.bincount(
+            (num_classes + 1) * pred.reshape(-1) + gt.reshape(-1),
+            minlength=conf_matrix.size,
+        ).reshape(conf_matrix.shape)
+        
+    
+    # calculate miou
+    acc = np.full(num_classes, np.nan, dtype=np.float64)
+    iou = np.full(num_classes, np.nan, dtype=np.float64)
+    tp = conf_matrix.diagonal()[:-1].astype(np.float64)
+    pos_gt = np.sum(conf_matrix[:-1, :-1], axis=0).astype(np.float64)
+    pos_pred = np.sum(conf_matrix[:-1, :-1], axis=1).astype(np.float64)
+    acc_valid = pos_gt > 0
+    acc[acc_valid] = tp[acc_valid] / pos_gt[acc_valid]
+    iou_valid = (pos_gt + pos_pred) > 0
+    union = pos_gt + pos_pred - tp
+    iou[acc_valid] = tp[acc_valid] / union[acc_valid]
+    miou = np.sum(iou[acc_valid]) / np.sum(iou_valid)
+    print(f"mIoU: {miou}")
+
+if __name__ == '__main__':
+    main()

evaluations/c2i/README.md

@@ -0,0 +1,96 @@
+# Evaluations from [OpenAI](https://github.com/openai/guided-diffusion/tree/main/evaluations)
+
+To compare different generative models, we use FID, sFID, Precision, Recall, and Inception Score. These metrics can all be calculated using batches of samples, which we store in `.npz` (numpy) files.
+
+# Installation
+### cuda version 11.7
+```
+pip install tensorflow-gpu==2.5.0
+pip install numpy==1.22.0
+pip install scipy
+pip install pydantic
+```
+There will happen error like `tensorflow.python.framework.errors_impl.NotFoundError: /usr/local/lib/python3.9/dist-packages/tensorflow/core/kernels/libtfkernel_sobol_op.so: undefined symbol: _ZN10tensorflow...`, deleting `/usr/local/lib/python3.9/dist-packages/tensorflow/core/kernels/libtfkernel_sobol_op.so` will fix this error.
+
+### cuda version 12.1
+```
+pip install tensorflow
+pip install numpy==1.23.5
+pip install scipy
+```
+
+### H100, cuda version 12.2
+```
+pip install tensorflow
+pip install numpy==1.26.2
+pip install scipy
+```
+
+# Download batches
+
+We provide pre-computed sample batches for the reference datasets, our diffusion models, and several baselines we compare against. These are all stored in `.npz` format.
+
+Reference dataset batches contain pre-computed statistics over the whole dataset, as well as 10,000 images for computing Precision and Recall. All other batches contain 50,000 images which can be used to compute statistics and Precision/Recall.
+
+Here are links to download all of the sample and reference batches:
+
+ * LSUN
+   * LSUN bedroom: [reference batch](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/lsun/bedroom/VIRTUAL_lsun_bedroom256.npz)
+     * [ADM (dropout)](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/lsun/bedroom/admnet_dropout_lsun_bedroom.npz)
+     * [DDPM](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/lsun/bedroom/ddpm_lsun_bedroom.npz)
+     * [IDDPM](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/lsun/bedroom/iddpm_lsun_bedroom.npz)
+     * [StyleGAN](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/lsun/bedroom/stylegan_lsun_bedroom.npz)
+   * LSUN cat: [reference batch](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/lsun/cat/VIRTUAL_lsun_cat256.npz)
+     * [ADM (dropout)](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/lsun/cat/admnet_dropout_lsun_cat.npz)
+     * [StyleGAN2](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/lsun/cat/stylegan2_lsun_cat.npz)
+   * LSUN horse: [reference batch](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/lsun/horse/VIRTUAL_lsun_horse256.npz)
+     * [ADM (dropout)](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/lsun/horse/admnet_dropout_lsun_horse.npz)
+     * [ADM](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/lsun/horse/admnet_lsun_horse.npz)
+
+ * ImageNet
+   * ImageNet 64x64: [reference batch](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/64/VIRTUAL_imagenet64_labeled.npz)
+     * [ADM](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/64/admnet_imagenet64.npz)
+     * [IDDPM](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/64/iddpm_imagenet64.npz)
+     * [BigGAN](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/64/biggan_deep_imagenet64.npz)
+   * ImageNet 128x128: [reference batch](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/128/VIRTUAL_imagenet128_labeled.npz)
+     * [ADM](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/128/admnet_imagenet128.npz)
+     * [ADM-G](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/128/admnet_guided_imagenet128.npz)
+     * [ADM-G, 25 steps](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/128/admnet_guided_25step_imagenet128.npz)
+     * [BigGAN-deep (trunc=1.0)](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/128/biggan_deep_trunc1_imagenet128.npz)
+   * ImageNet 256x256: [reference batch](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/256/VIRTUAL_imagenet256_labeled.npz)
+     * [ADM](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/256/admnet_imagenet256.npz)
+     * [ADM-G](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/256/admnet_guided_imagenet256.npz)
+     * [ADM-G, 25 step](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/256/admnet_guided_25step_imagenet256.npz)
+     * [ADM-G + ADM-U](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/256/admnet_guided_upsampled_imagenet256.npz)
+     * [ADM-U](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/256/admnet_upsampled_imagenet256.npz)
+     * [BigGAN-deep (trunc=1.0)](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/256/biggan_deep_trunc1_imagenet256.npz)
+   * ImageNet 512x512: [reference batch](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/512/VIRTUAL_imagenet512.npz)
+     * [ADM](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/512/admnet_imagenet512.npz)
+     * [ADM-G](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/512/admnet_guided_imagenet512.npz)
+     * [ADM-G, 25 step](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/512/admnet_guided_25step_imagenet512.npz)
+     * [ADM-G + ADM-U](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/512/admnet_guided_upsampled_imagenet512.npz)
+     * [ADM-U](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/512/admnet_upsampled_imagenet512.npz)
+     * [BigGAN-deep (trunc=1.0)](https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/512/biggan_deep_trunc1_imagenet512.npz)
+
+# Run evaluations
+
+First, generate or download a batch of samples and download the corresponding reference batch for the given dataset. For this example, we'll use ImageNet 256x256, so the refernce batch is `VIRTUAL_imagenet256_labeled.npz` and we can use the sample batch `admnet_guided_upsampled_imagenet256.npz`.
+
+Next, run the `evaluator.py` script. The requirements of this script can be found in [requirements.txt](requirements.txt). Pass two arguments to the script: the reference batch and the sample batch. The script will download the InceptionV3 model used for evaluations into the current working directory (if it is not already present). This file is roughly 100MB.
+
+The output of the script will look something like this, where the first `...` is a bunch of verbose TensorFlow logging:
+
+```
+$ python evaluator.py VIRTUAL_imagenet256_labeled.npz admnet_guided_upsampled_imagenet256.npz
+...
+computing reference batch activations...
+computing/reading reference batch statistics...
+computing sample batch activations...
+computing/reading sample batch statistics...
+Computing evaluations...
+Inception Score: 215.8370361328125
+FID: 3.9425574129223264
+sFID: 6.140433703346162
+Precision: 0.8265
+Recall: 0.5309
+```

evaluations/c2i/evaluator.py

@@ -0,0 +1,665 @@
+import argparse
+import io
+import os
+import random
+import warnings
+import zipfile
+from abc import ABC, abstractmethod
+from contextlib import contextmanager
+from functools import partial
+from multiprocessing import cpu_count
+from multiprocessing.pool import ThreadPool
+from typing import Iterable, Optional, Tuple
+
+import numpy as np
+import requests
+import tensorflow.compat.v1 as tf
+from scipy import linalg
+from tqdm.auto import tqdm
+
+INCEPTION_V3_URL = "https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/classify_image_graph_def.pb"
+INCEPTION_V3_PATH = "classify_image_graph_def.pb"
+
+FID_POOL_NAME = "pool_3:0"
+FID_SPATIAL_NAME = "mixed_6/conv:0"
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("ref_batch", help="path to reference batch npz file")
+    parser.add_argument("sample_batch", help="path to sample batch npz file")
+    args = parser.parse_args()
+
+    config = tf.ConfigProto(
+        allow_soft_placement=True  # allows DecodeJpeg to run on CPU in Inception graph
+    )
+    config.gpu_options.allow_growth = True
+    evaluator = Evaluator(tf.Session(config=config))
+
+    print("warming up TensorFlow...")
+    # This will cause TF to print a bunch of verbose stuff now rather
+    # than after the next print(), to help prevent confusion.
+    evaluator.warmup()
+
+    print("computing reference batch activations...")
+    ref_acts = evaluator.read_activations(args.ref_batch)
+    print("computing/reading reference batch statistics...")
+    ref_stats, ref_stats_spatial = evaluator.read_statistics(args.ref_batch, ref_acts)
+
+    print("computing sample batch activations...")
+    sample_acts = evaluator.read_activations(args.sample_batch)
+    print("computing/reading sample batch statistics...")
+    sample_stats, sample_stats_spatial = evaluator.read_statistics(args.sample_batch, sample_acts)
+
+    print("Computing evaluations...")
+    IS = evaluator.compute_inception_score(sample_acts[0])
+    FID = sample_stats.frechet_distance(ref_stats)
+    sFID = sample_stats_spatial.frechet_distance(ref_stats_spatial)
+    print("Inception Score:", IS)
+    print("FID:", FID)
+    print("sFID:", sFID)
+    prec, recall = evaluator.compute_prec_recall(ref_acts[0], sample_acts[0])
+    print("Precision:", prec)
+    print("Recall:", recall)
+
+    txt_path = args.sample_batch.replace('.npz', '.txt')
+    print("writing to {}".format(txt_path))
+    with open(txt_path, 'w') as f:
+        print("Inception Score:", IS, file=f)
+        print("FID:", FID, file=f)
+        print("sFID:", sFID, file=f)
+        print("Precision:", prec, file=f)
+        print("Recall:", recall, file=f)
+
+
+class InvalidFIDException(Exception):
+    pass
+
+
+class FIDStatistics:
+    def __init__(self, mu: np.ndarray, sigma: np.ndarray):
+        self.mu = mu
+        self.sigma = sigma
+
+    def frechet_distance(self, other, eps=1e-6):
+        """
+        Compute the Frechet distance between two sets of statistics.
+        """
+        # https://github.com/bioinf-jku/TTUR/blob/73ab375cdf952a12686d9aa7978567771084da42/fid.py#L132
+        mu1, sigma1 = self.mu, self.sigma
+        mu2, sigma2 = other.mu, other.sigma
+
+        mu1 = np.atleast_1d(mu1)
+        mu2 = np.atleast_1d(mu2)
+
+        sigma1 = np.atleast_2d(sigma1)
+        sigma2 = np.atleast_2d(sigma2)
+
+        assert (
+            mu1.shape == mu2.shape
+        ), f"Training and test mean vectors have different lengths: {mu1.shape}, {mu2.shape}"
+        assert (
+            sigma1.shape == sigma2.shape
+        ), f"Training and test covariances have different dimensions: {sigma1.shape}, {sigma2.shape}"
+
+        diff = mu1 - mu2
+
+        # product might be almost singular
+        covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)
+        if not np.isfinite(covmean).all():
+            msg = (
+                "fid calculation produces singular product; adding %s to diagonal of cov estimates"
+                % eps
+            )
+            warnings.warn(msg)
+            offset = np.eye(sigma1.shape[0]) * eps
+            covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))
+
+        # numerical error might give slight imaginary component
+        if np.iscomplexobj(covmean):
+            if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):
+                m = np.max(np.abs(covmean.imag))
+                raise ValueError("Imaginary component {}".format(m))
+            covmean = covmean.real
+
+        tr_covmean = np.trace(covmean)
+
+        return diff.dot(diff) + np.trace(sigma1) + np.trace(sigma2) - 2 * tr_covmean
+
+
+class Evaluator:
+    def __init__(
+        self,
+        session,
+        batch_size=64,
+        softmax_batch_size=512,
+    ):
+        self.sess = session
+        self.batch_size = batch_size
+        self.softmax_batch_size = softmax_batch_size
+        self.manifold_estimator = ManifoldEstimator(session)
+        with self.sess.graph.as_default():
+            self.image_input = tf.placeholder(tf.float32, shape=[None, None, None, 3])
+            self.softmax_input = tf.placeholder(tf.float32, shape=[None, 2048])
+            self.pool_features, self.spatial_features = _create_feature_graph(self.image_input)
+            self.softmax = _create_softmax_graph(self.softmax_input)
+
+    def warmup(self):
+        self.compute_activations(np.zeros([1, 8, 64, 64, 3]))
+
+    def read_activations(self, npz_path: str) -> Tuple[np.ndarray, np.ndarray]:
+        with open_npz_array(npz_path, "arr_0") as reader:
+            return self.compute_activations(reader.read_batches(self.batch_size))
+
+    def compute_activations(self, batches: Iterable[np.ndarray]) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Compute image features for downstream evals.
+
+        :param batches: a iterator over NHWC numpy arrays in [0, 255].
+        :return: a tuple of numpy arrays of shape [N x X], where X is a feature
+                 dimension. The tuple is (pool_3, spatial).
+        """
+        preds = []
+        spatial_preds = []
+        for batch in tqdm(batches):
+            batch = batch.astype(np.float32)
+            pred, spatial_pred = self.sess.run(
+                [self.pool_features, self.spatial_features], {self.image_input: batch}
+            )
+            preds.append(pred.reshape([pred.shape[0], -1]))
+            spatial_preds.append(spatial_pred.reshape([spatial_pred.shape[0], -1]))
+        return (
+            np.concatenate(preds, axis=0),
+            np.concatenate(spatial_preds, axis=0),
+        )
+
+    def read_statistics(
+        self, npz_path: str, activations: Tuple[np.ndarray, np.ndarray]
+    ) -> Tuple[FIDStatistics, FIDStatistics]:
+        obj = np.load(npz_path)
+        if "mu" in list(obj.keys()):
+            return FIDStatistics(obj["mu"], obj["sigma"]), FIDStatistics(
+                obj["mu_s"], obj["sigma_s"]
+            )
+        return tuple(self.compute_statistics(x) for x in activations)
+
+    def compute_statistics(self, activations: np.ndarray) -> FIDStatistics:
+        mu = np.mean(activations, axis=0)
+        sigma = np.cov(activations, rowvar=False)
+        return FIDStatistics(mu, sigma)
+
+    def compute_inception_score(self, activations: np.ndarray, split_size: int = 5000) -> float:
+        softmax_out = []
+        for i in range(0, len(activations), self.softmax_batch_size):
+            acts = activations[i : i + self.softmax_batch_size]
+            softmax_out.append(self.sess.run(self.softmax, feed_dict={self.softmax_input: acts}))
+        preds = np.concatenate(softmax_out, axis=0)
+        # https://github.com/openai/improved-gan/blob/4f5d1ec5c16a7eceb206f42bfc652693601e1d5c/inception_score/model.py#L46
+        scores = []
+        for i in range(0, len(preds), split_size):
+            part = preds[i : i + split_size]
+            kl = part * (np.log(part) - np.log(np.expand_dims(np.mean(part, 0), 0)))
+            kl = np.mean(np.sum(kl, 1))
+            scores.append(np.exp(kl))
+        return float(np.mean(scores))
+
+    def compute_prec_recall(
+        self, activations_ref: np.ndarray, activations_sample: np.ndarray
+    ) -> Tuple[float, float]:
+        radii_1 = self.manifold_estimator.manifold_radii(activations_ref)
+        radii_2 = self.manifold_estimator.manifold_radii(activations_sample)
+        pr = self.manifold_estimator.evaluate_pr(
+            activations_ref, radii_1, activations_sample, radii_2
+        )
+        return (float(pr[0][0]), float(pr[1][0]))
+
+
+class ManifoldEstimator:
+    """
+    A helper for comparing manifolds of feature vectors.
+
+    Adapted from https://github.com/kynkaat/improved-precision-and-recall-metric/blob/f60f25e5ad933a79135c783fcda53de30f42c9b9/precision_recall.py#L57
+    """
+
+    def __init__(
+        self,
+        session,
+        row_batch_size=10000,
+        col_batch_size=10000,
+        nhood_sizes=(3,),
+        clamp_to_percentile=None,
+        eps=1e-5,
+    ):
+        """
+        Estimate the manifold of given feature vectors.
+
+        :param session: the TensorFlow session.
+        :param row_batch_size: row batch size to compute pairwise distances
+                               (parameter to trade-off between memory usage and performance).
+        :param col_batch_size: column batch size to compute pairwise distances.
+        :param nhood_sizes: number of neighbors used to estimate the manifold.
+        :param clamp_to_percentile: prune hyperspheres that have radius larger than
+                                    the given percentile.
+        :param eps: small number for numerical stability.
+        """
+        self.distance_block = DistanceBlock(session)
+        self.row_batch_size = row_batch_size
+        self.col_batch_size = col_batch_size
+        self.nhood_sizes = nhood_sizes
+        self.num_nhoods = len(nhood_sizes)
+        self.clamp_to_percentile = clamp_to_percentile
+        self.eps = eps
+
+    def warmup(self):
+        feats, radii = (
+            np.zeros([1, 2048], dtype=np.float32),
+            np.zeros([1, 1], dtype=np.float32),
+        )
+        self.evaluate_pr(feats, radii, feats, radii)
+
+    def manifold_radii(self, features: np.ndarray) -> np.ndarray:
+        num_images = len(features)
+
+        # Estimate manifold of features by calculating distances to k-NN of each sample.
+        radii = np.zeros([num_images, self.num_nhoods], dtype=np.float32)
+        distance_batch = np.zeros([self.row_batch_size, num_images], dtype=np.float32)
+        seq = np.arange(max(self.nhood_sizes) + 1, dtype=np.int32)
+
+        for begin1 in range(0, num_images, self.row_batch_size):
+            end1 = min(begin1 + self.row_batch_size, num_images)
+            row_batch = features[begin1:end1]
+
+            for begin2 in range(0, num_images, self.col_batch_size):
+                end2 = min(begin2 + self.col_batch_size, num_images)
+                col_batch = features[begin2:end2]
+
+                # Compute distances between batches.
+                distance_batch[
+                    0 : end1 - begin1, begin2:end2
+                ] = self.distance_block.pairwise_distances(row_batch, col_batch)
+
+            # Find the k-nearest neighbor from the current batch.
+            radii[begin1:end1, :] = np.concatenate(
+                [
+                    x[:, self.nhood_sizes]
+                    for x in _numpy_partition(distance_batch[0 : end1 - begin1, :], seq, axis=1)
+                ],
+                axis=0,
+            )
+
+        if self.clamp_to_percentile is not None:
+            max_distances = np.percentile(radii, self.clamp_to_percentile, axis=0)
+            radii[radii > max_distances] = 0
+        return radii
+
+    def evaluate(self, features: np.ndarray, radii: np.ndarray, eval_features: np.ndarray):
+        """
+        Evaluate if new feature vectors are at the manifold.
+        """
+        num_eval_images = eval_features.shape[0]
+        num_ref_images = radii.shape[0]
+        distance_batch = np.zeros([self.row_batch_size, num_ref_images], dtype=np.float32)
+        batch_predictions = np.zeros([num_eval_images, self.num_nhoods], dtype=np.int32)
+        max_realism_score = np.zeros([num_eval_images], dtype=np.float32)
+        nearest_indices = np.zeros([num_eval_images], dtype=np.int32)
+
+        for begin1 in range(0, num_eval_images, self.row_batch_size):
+            end1 = min(begin1 + self.row_batch_size, num_eval_images)
+            feature_batch = eval_features[begin1:end1]
+
+            for begin2 in range(0, num_ref_images, self.col_batch_size):
+                end2 = min(begin2 + self.col_batch_size, num_ref_images)
+                ref_batch = features[begin2:end2]
+
+                distance_batch[
+                    0 : end1 - begin1, begin2:end2
+                ] = self.distance_block.pairwise_distances(feature_batch, ref_batch)
+
+            # From the minibatch of new feature vectors, determine if they are in the estimated manifold.
+            # If a feature vector is inside a hypersphere of some reference sample, then
+            # the new sample lies at the estimated manifold.
+            # The radii of the hyperspheres are determined from distances of neighborhood size k.
+            samples_in_manifold = distance_batch[0 : end1 - begin1, :, None] <= radii
+            batch_predictions[begin1:end1] = np.any(samples_in_manifold, axis=1).astype(np.int32)
+
+            max_realism_score[begin1:end1] = np.max(
+                radii[:, 0] / (distance_batch[0 : end1 - begin1, :] + self.eps), axis=1
+            )
+            nearest_indices[begin1:end1] = np.argmin(distance_batch[0 : end1 - begin1, :], axis=1)
+
+        return {
+            "fraction": float(np.mean(batch_predictions)),
+            "batch_predictions": batch_predictions,
+            "max_realisim_score": max_realism_score,
+            "nearest_indices": nearest_indices,
+        }
+
+    def evaluate_pr(
+        self,
+        features_1: np.ndarray,
+        radii_1: np.ndarray,
+        features_2: np.ndarray,
+        radii_2: np.ndarray,
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Evaluate precision and recall efficiently.
+
+        :param features_1: [N1 x D] feature vectors for reference batch.
+        :param radii_1: [N1 x K1] radii for reference vectors.
+        :param features_2: [N2 x D] feature vectors for the other batch.
+        :param radii_2: [N x K2] radii for other vectors.
+        :return: a tuple of arrays for (precision, recall):
+                 - precision: an np.ndarray of length K1
+                 - recall: an np.ndarray of length K2
+        """
+        features_1_status = np.zeros([len(features_1), radii_2.shape[1]], dtype=bool)
+        features_2_status = np.zeros([len(features_2), radii_1.shape[1]], dtype=bool)
+        for begin_1 in range(0, len(features_1), self.row_batch_size):
+            end_1 = begin_1 + self.row_batch_size
+            batch_1 = features_1[begin_1:end_1]
+            for begin_2 in range(0, len(features_2), self.col_batch_size):
+                end_2 = begin_2 + self.col_batch_size
+                batch_2 = features_2[begin_2:end_2]
+                batch_1_in, batch_2_in = self.distance_block.less_thans(
+                    batch_1, radii_1[begin_1:end_1], batch_2, radii_2[begin_2:end_2]
+                )
+                features_1_status[begin_1:end_1] |= batch_1_in
+                features_2_status[begin_2:end_2] |= batch_2_in
+        return (
+            np.mean(features_2_status.astype(np.float64), axis=0),
+            np.mean(features_1_status.astype(np.float64), axis=0),
+        )
+
+
+class DistanceBlock:
+    """
+    Calculate pairwise distances between vectors.
+
+    Adapted from https://github.com/kynkaat/improved-precision-and-recall-metric/blob/f60f25e5ad933a79135c783fcda53de30f42c9b9/precision_recall.py#L34
+    """
+
+    def __init__(self, session):
+        self.session = session
+
+        # Initialize TF graph to calculate pairwise distances.
+        with session.graph.as_default():
+            self._features_batch1 = tf.placeholder(tf.float32, shape=[None, None])
+            self._features_batch2 = tf.placeholder(tf.float32, shape=[None, None])
+            distance_block_16 = _batch_pairwise_distances(
+                tf.cast(self._features_batch1, tf.float16),
+                tf.cast(self._features_batch2, tf.float16),
+            )
+            self.distance_block = tf.cond(
+                tf.reduce_all(tf.math.is_finite(distance_block_16)),
+                lambda: tf.cast(distance_block_16, tf.float32),
+                lambda: _batch_pairwise_distances(self._features_batch1, self._features_batch2),
+            )
+
+            # Extra logic for less thans.
+            self._radii1 = tf.placeholder(tf.float32, shape=[None, None])
+            self._radii2 = tf.placeholder(tf.float32, shape=[None, None])
+            dist32 = tf.cast(self.distance_block, tf.float32)[..., None]
+            self._batch_1_in = tf.math.reduce_any(dist32 <= self._radii2, axis=1)
+            self._batch_2_in = tf.math.reduce_any(dist32 <= self._radii1[:, None], axis=0)
+
+    def pairwise_distances(self, U, V):
+        """
+        Evaluate pairwise distances between two batches of feature vectors.
+        """
+        return self.session.run(
+            self.distance_block,
+            feed_dict={self._features_batch1: U, self._features_batch2: V},
+        )
+
+    def less_thans(self, batch_1, radii_1, batch_2, radii_2):
+        return self.session.run(
+            [self._batch_1_in, self._batch_2_in],
+            feed_dict={
+                self._features_batch1: batch_1,
+                self._features_batch2: batch_2,
+                self._radii1: radii_1,
+                self._radii2: radii_2,
+            },
+        )
+
+
+def _batch_pairwise_distances(U, V):
+    """
+    Compute pairwise distances between two batches of feature vectors.
+    """
+    with tf.variable_scope("pairwise_dist_block"):
+        # Squared norms of each row in U and V.
+        norm_u = tf.reduce_sum(tf.square(U), 1)
+        norm_v = tf.reduce_sum(tf.square(V), 1)
+
+        # norm_u as a column and norm_v as a row vectors.
+        norm_u = tf.reshape(norm_u, [-1, 1])
+        norm_v = tf.reshape(norm_v, [1, -1])
+
+        # Pairwise squared Euclidean distances.
+        D = tf.maximum(norm_u - 2 * tf.matmul(U, V, False, True) + norm_v, 0.0)
+
+    return D
+
+
+class NpzArrayReader(ABC):
+    @abstractmethod
+    def read_batch(self, batch_size: int) -> Optional[np.ndarray]:
+        pass
+
+    @abstractmethod
+    def remaining(self) -> int:
+        pass
+
+    def read_batches(self, batch_size: int) -> Iterable[np.ndarray]:
+        def gen_fn():
+            while True:
+                batch = self.read_batch(batch_size)
+                if batch is None:
+                    break
+                yield batch
+
+        rem = self.remaining()
+        num_batches = rem // batch_size + int(rem % batch_size != 0)
+        return BatchIterator(gen_fn, num_batches)
+
+
+class BatchIterator:
+    def __init__(self, gen_fn, length):
+        self.gen_fn = gen_fn
+        self.length = length
+
+    def __len__(self):
+        return self.length
+
+    def __iter__(self):
+        return self.gen_fn()
+
+
+class StreamingNpzArrayReader(NpzArrayReader):
+    def __init__(self, arr_f, shape, dtype):
+        self.arr_f = arr_f
+        self.shape = shape
+        self.dtype = dtype
+        self.idx = 0
+
+    def read_batch(self, batch_size: int) -> Optional[np.ndarray]:
+        if self.idx >= self.shape[0]:
+            return None
+
+        bs = min(batch_size, self.shape[0] - self.idx)
+        self.idx += bs
+
+        if self.dtype.itemsize == 0:
+            return np.ndarray([bs, *self.shape[1:]], dtype=self.dtype)
+
+        read_count = bs * np.prod(self.shape[1:])
+        read_size = int(read_count * self.dtype.itemsize)
+        data = _read_bytes(self.arr_f, read_size, "array data")
+        return np.frombuffer(data, dtype=self.dtype).reshape([bs, *self.shape[1:]])
+
+    def remaining(self) -> int:
+        return max(0, self.shape[0] - self.idx)
+
+
+class MemoryNpzArrayReader(NpzArrayReader):
+    def __init__(self, arr):
+        self.arr = arr
+        self.idx = 0
+
+    @classmethod
+    def load(cls, path: str, arr_name: str):
+        with open(path, "rb") as f:
+            arr = np.load(f)[arr_name]
+        return cls(arr)
+
+    def read_batch(self, batch_size: int) -> Optional[np.ndarray]:
+        if self.idx >= self.arr.shape[0]:
+            return None
+
+        res = self.arr[self.idx : self.idx + batch_size]
+        self.idx += batch_size
+        return res
+
+    def remaining(self) -> int:
+        return max(0, self.arr.shape[0] - self.idx)
+
+
+@contextmanager
+def open_npz_array(path: str, arr_name: str) -> NpzArrayReader:
+    with _open_npy_file(path, arr_name) as arr_f:
+        version = np.lib.format.read_magic(arr_f)
+        if version == (1, 0):
+            header = np.lib.format.read_array_header_1_0(arr_f)
+        elif version == (2, 0):
+            header = np.lib.format.read_array_header_2_0(arr_f)
+        else:
+            yield MemoryNpzArrayReader.load(path, arr_name)
+            return
+        shape, fortran, dtype = header
+        if fortran or dtype.hasobject:
+            yield MemoryNpzArrayReader.load(path, arr_name)
+        else:
+            yield StreamingNpzArrayReader(arr_f, shape, dtype)
+
+
+def _read_bytes(fp, size, error_template="ran out of data"):
+    """
+    Copied from: https://github.com/numpy/numpy/blob/fb215c76967739268de71aa4bda55dd1b062bc2e/numpy/lib/format.py#L788-L886
+
+    Read from file-like object until size bytes are read.
+    Raises ValueError if not EOF is encountered before size bytes are read.
+    Non-blocking objects only supported if they derive from io objects.
+    Required as e.g. ZipExtFile in python 2.6 can return less data than
+    requested.
+    """
+    data = bytes()
+    while True:
+        # io files (default in python3) return None or raise on
+        # would-block, python2 file will truncate, probably nothing can be
+        # done about that.  note that regular files can't be non-blocking
+        try:
+            r = fp.read(size - len(data))
+            data += r
+            if len(r) == 0 or len(data) == size:
+                break
+        except io.BlockingIOError:
+            pass
+    if len(data) != size:
+        msg = "EOF: reading %s, expected %d bytes got %d"
+        raise ValueError(msg % (error_template, size, len(data)))
+    else:
+        return data
+
+
+@contextmanager
+def _open_npy_file(path: str, arr_name: str):
+    with open(path, "rb") as f:
+        with zipfile.ZipFile(f, "r") as zip_f:
+            if f"{arr_name}.npy" not in zip_f.namelist():
+                raise ValueError(f"missing {arr_name} in npz file")
+            with zip_f.open(f"{arr_name}.npy", "r") as arr_f:
+                yield arr_f
+
+
+def _download_inception_model():
+    if os.path.exists(INCEPTION_V3_PATH):
+        return
+    print("downloading InceptionV3 model...")
+    with requests.get(INCEPTION_V3_URL, stream=True) as r:
+        r.raise_for_status()
+        tmp_path = INCEPTION_V3_PATH + ".tmp"
+        with open(tmp_path, "wb") as f:
+            for chunk in tqdm(r.iter_content(chunk_size=8192)):
+                f.write(chunk)
+        os.rename(tmp_path, INCEPTION_V3_PATH)
+
+
+def _create_feature_graph(input_batch):
+    _download_inception_model()
+    prefix = f"{random.randrange(2**32)}_{random.randrange(2**32)}"
+    with open(INCEPTION_V3_PATH, "rb") as f:
+        graph_def = tf.GraphDef()
+        graph_def.ParseFromString(f.read())
+    pool3, spatial = tf.import_graph_def(
+        graph_def,
+        input_map={f"ExpandDims:0": input_batch},
+        return_elements=[FID_POOL_NAME, FID_SPATIAL_NAME],
+        name=prefix,
+    )
+    _update_shapes(pool3)
+    spatial = spatial[..., :7]
+    return pool3, spatial
+
+
+def _create_softmax_graph(input_batch):
+    _download_inception_model()
+    prefix = f"{random.randrange(2**32)}_{random.randrange(2**32)}"
+    with open(INCEPTION_V3_PATH, "rb") as f:
+        graph_def = tf.GraphDef()
+        graph_def.ParseFromString(f.read())
+    (matmul,) = tf.import_graph_def(
+        graph_def, return_elements=[f"softmax/logits/MatMul"], name=prefix
+    )
+    w = matmul.inputs[1]
+    logits = tf.matmul(input_batch, w)
+    return tf.nn.softmax(logits)
+
+
+def _update_shapes(pool3):
+    # https://github.com/bioinf-jku/TTUR/blob/73ab375cdf952a12686d9aa7978567771084da42/fid.py#L50-L63
+    ops = pool3.graph.get_operations()
+    for op in ops:
+        for o in op.outputs:
+            shape = o.get_shape()
+            if shape._dims is not None:  # pylint: disable=protected-access
+                # shape = [s.value for s in shape] TF 1.x
+                shape = [s for s in shape]  # TF 2.x
+                new_shape = []
+                for j, s in enumerate(shape):
+                    if s == 1 and j == 0:
+                        new_shape.append(None)
+                    else:
+                        new_shape.append(s)
+                o.__dict__["_shape_val"] = tf.TensorShape(new_shape)
+    return pool3
+
+
+def _numpy_partition(arr, kth, **kwargs):
+    num_workers = min(cpu_count(), len(arr))
+    chunk_size = len(arr) // num_workers
+    extra = len(arr) % num_workers
+
+    start_idx = 0
+    batches = []
+    for i in range(num_workers):
+        size = chunk_size + (1 if i < extra else 0)
+        batches.append(arr[start_idx : start_idx + size])
+        start_idx += size
+
+    with ThreadPool(num_workers) as pool:
+        return list(pool.map(partial(np.partition, kth=kth, **kwargs), batches))
+
+
+if __name__ == "__main__":
+    main()

evaluations/canny_f1score.py

@@ -0,0 +1,62 @@
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+from transformers import DPTImageProcessor, DPTForDepthEstimation
+from PIL import Image
+import os
+import sys
+import torch
+import numpy as np
+from torch.utils.data import DataLoader, Dataset
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from autoregressive.test.metric import RMSE, SSIM, F1score
+import torch.nn.functional as F
+from condition.hed import HEDdetector
+from condition.canny import CannyDetector
+from torchmetrics.classification import BinaryF1Score
+# Define a dataset class for loading image and label pairs
+class ImageDataset(Dataset):
+    def __init__(self, img_dir, label_dir):
+        self.img_dir = img_dir
+        self.label_dir = label_dir
+        self.images = os.listdir(img_dir)
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self.img_dir, self.images[idx])
+        label_path = os.path.join(self.label_dir, self.images[idx])
+
+        image = np.array(Image.open(img_path).convert("RGB"))
+        label = np.array(Image.open(label_path))
+        return torch.from_numpy(image), torch.from_numpy(label).permute(2, 0, 1)
+
+model = CannyDetector()
+# Define the dataset and data loader
+img_dir = 'sample/multigen/canny/visualization'
+label_dir = 'sample/multigen/canny/annotations'
+dataset = ImageDataset(img_dir, label_dir)
+data_loader = DataLoader(dataset, batch_size=16, shuffle=False, num_workers=4)
+
+# Instantiate the metric
+f1score = BinaryF1Score()
+f1 = []
+i = 0
+with torch.no_grad():
+    for images, labels in tqdm(data_loader):
+        i += 1
+        images = images
+        outputs = []
+        for img in images:   
+            outputs.append(model(img))
+        # Move predictions and labels to numpy for RMSE calculation
+        predicted_canny = outputs
+        labels = labels[:, 0, :, :].numpy() # Assuming labels are in Bx1xHxW format
+          
+        for pred, label in zip(predicted_canny, labels):
+            pred[pred == 255] = 1
+            label[label == 255] = 1
+            f1.append(f1score(torch.from_numpy(pred).flatten(), torch.from_numpy(label).flatten()).item())
+
+print(f'f1score: {np.array(f1).mean()}')

evaluations/clean_fid.py

@@ -0,0 +1,15 @@
+from cleanfid import fid
+import argparse
+
+def main(args):
+    real_data_path = args.val_images
+    gen_data_path = args.generated_images
+    cleanfid_score = fid.compute_fid(gen_data_path, real_data_path)
+    print(f"The Clean-FID score is {cleanfid_score}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--val-images", type=str, required=True)
+    parser.add_argument("--generated-images", type=str, required=True)
+    args = parser.parse_args()
+    main(args)

evaluations/cocostuff_mIoU.py

@@ -0,0 +1,72 @@
+import os
+import numpy as np
+from mmseg.apis import init_model, inference_model, show_result_pyplot#, inference_segmentor
+import torch
+from PIL import Image
+from sklearn.metrics import confusion_matrix
+from torchmetrics import JaccardIndex
+
+def main():
+    config_file = 'mmsegmentation/configs/deeplabv3/deeplabv3_r101-d8_4xb4-320k_coco-stuff164k-512x512.py'
+    checkpoint_file = 'evaluations/deeplabv3_r101-d8_512x512_4x4_320k_coco-stuff164k_20210709_155402-3cbca14d.pth'
+    
+    # build the model from a config file and a checkpoint file
+    model = init_model(config_file, checkpoint_file, device='cuda:1')
+    
+    # Image and segmentation labels directories
+    img_dir = 'sample/cocostuff/visualization'
+    ann_dir = 'sample/cocostuff/annotations'
+    
+    # List all image files
+    img_fns = [f for f in sorted(os.listdir(img_dir)) if f.endswith(".png")]
+
+    
+    total_mIoU = 0
+    from tqdm import tqdm
+    i = 0
+    num_classes = 171
+    jaccard_index = JaccardIndex(task="multiclass", num_classes=num_classes)
+    
+    conf_matrix = np.zeros((num_classes+1, num_classes+1), dtype=np.int64)
+    for img_fn in tqdm(img_fns):
+        ann_fn = img_fn
+        i += 1
+        # if i == 4891:
+        #     continue
+        try:
+            img_path = os.path.join(img_dir, img_fn)
+            ann_path = os.path.join(ann_dir, img_fn)
+            result = inference_model(model, img_path)
+        except Exception as e:
+            continue
+        # Read ground truth segmentation map
+        gt_semantic_seg = np.array(Image.open(ann_path))
+
+        ignore_label = 255
+        gt = gt_semantic_seg.copy()
+        # import pdb;pdb.set_trace()
+        # print(np.unique(gt), np.unique(result.pred_sem_seg.data[0].cpu().numpy()))
+        pred = result.pred_sem_seg.data[0].cpu().numpy().copy()#+1
+        gt[gt == ignore_label] = num_classes
+        conf_matrix += np.bincount(
+            (num_classes+1) * pred.reshape(-1) + gt.reshape(-1),
+            minlength=conf_matrix.size,
+        ).reshape(conf_matrix.shape)
+        
+    
+    # calculate miou
+    acc = np.full(num_classes, np.nan, dtype=np.float64)
+    iou = np.full(num_classes, np.nan, dtype=np.float64)
+    tp = conf_matrix.diagonal()[:-1].astype(np.float64)
+    pos_gt = np.sum(conf_matrix[:-1, :-1], axis=0).astype(np.float64)
+    pos_pred = np.sum(conf_matrix[:-1, :-1], axis=1).astype(np.float64)
+    acc_valid = pos_gt > 0
+    acc[acc_valid] = tp[acc_valid] / pos_gt[acc_valid]
+    iou_valid = (pos_gt + pos_pred) > 0
+    union = pos_gt + pos_pred - tp
+    iou[acc_valid] = tp[acc_valid] / union[acc_valid]
+    miou = np.sum(iou[acc_valid]) / np.sum(iou_valid)
+    print(f"mIoU: {miou}")
+
+if __name__ == '__main__':
+    main()

evaluations/depth_rmse.py

@@ -0,0 +1,62 @@
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+from transformers import DPTImageProcessor, DPTForDepthEstimation
+from PIL import Image
+import os
+import torch
+import numpy as np
+from torch.utils.data import DataLoader, Dataset
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from autoregressive.test.metric import RMSE
+import torch.nn.functional as F
+# Define a dataset class for loading image and label pairs
+class ImageDataset(Dataset):
+    def __init__(self, img_dir, label_dir):
+        self.img_dir = img_dir
+        self.label_dir = label_dir
+        self.images = os.listdir(img_dir)
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self.img_dir, self.images[idx])
+        label_path = os.path.join(self.label_dir, self.images[idx])
+        image = Image.open(img_path).convert("RGB")
+        label = np.array(Image.open(label_path))
+
+        return np.array(image), torch.from_numpy(label).permute(2, 0, 1)
+
+# Instantiate the model and processor
+processor = DPTImageProcessor.from_pretrained("condition/ckpts/dpt_large")
+model = DPTForDepthEstimation.from_pretrained("condition/ckpts/dpt_large").cuda()
+
+# Define the dataset and data loader
+img_dir = 'sample/multigen/depth/visualization'
+label_dir = 'sample/multigen/depth/annotations'
+dataset = ImageDataset(img_dir, label_dir)
+data_loader = DataLoader(dataset, batch_size=16, shuffle=False, num_workers=4)
+
+# Instantiate the metric
+metric = RMSE()
+
+# Perform inference on batches and calculate RMSE
+model.eval()
+rmse = []
+with torch.no_grad():
+    for images, labels in tqdm(data_loader):
+        inputs = processor(images=images, return_tensors="pt", size=(512,512)).to('cuda:0')
+        outputs = model(**inputs)
+        
+        predicted_depth = outputs.predicted_depth
+        predicted_depth = predicted_depth.squeeze().cpu()
+        labels = labels[:, 0, :, :]
+        
+        for pred, label in zip(predicted_depth, labels):
+            # Preprocess predicted depth for fair comparison
+            pred = (pred * 255 / pred.max())
+            per_pixel_mse = torch.sqrt(F.mse_loss(pred.float(), label.float()))
+            rmse.append(per_pixel_mse)
+print(np.array(rmse).mean())

evaluations/hed_ssim.py

@@ -0,0 +1,52 @@
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+from transformers import DPTImageProcessor, DPTForDepthEstimation
+from PIL import Image
+import os
+import torch
+import numpy as np
+from torch.utils.data import DataLoader, Dataset
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from autoregressive.test.metric import RMSE, SSIM
+import torch.nn.functional as F
+from condition.hed import HEDdetector
+from torchmetrics.image import MultiScaleStructuralSimilarityIndexMeasure
+# Define a dataset class for loading image and label pairs
+class ImageDataset(Dataset):
+    def __init__(self, img_dir, label_dir):
+        self.img_dir = img_dir
+        self.label_dir = label_dir
+        self.images = os.listdir(img_dir)
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self.img_dir, self.images[idx])
+        label_path = os.path.join(self.label_dir, self.images[idx])
+        image = np.array(Image.open(img_path).convert("RGB"))
+        label = np.array(Image.open(label_path))
+        return torch.from_numpy(image), torch.from_numpy(label).permute(2, 0, 1)
+
+model = HEDdetector().cuda().eval()
+
+# Define the dataset and data loader
+img_dir = 'sample/multigen/hed/visualization'
+label_dir = 'sample/multigen/hed/annotations'
+dataset = ImageDataset(img_dir, label_dir)
+data_loader = DataLoader(dataset, batch_size=16, shuffle=False, num_workers=4)
+
+model.eval()
+ssim = MultiScaleStructuralSimilarityIndexMeasure(data_range=1.0).cuda()
+ssim_score = []
+with torch.no_grad():
+    for images, labels in tqdm(data_loader):
+        images = images.permute(0,3,1,2).cuda()
+        outputs = model(images)
+        predicted_hed = outputs.unsqueeze(1)
+        labels = labels[:, 0:1, :, :].cuda()
+        ssim_score.append(ssim((predicted_hed/255.0).clip(0,1), (labels/255.0).clip(0,1)))
+
+print(f'ssim: {torch.stack(ssim_score).mean()}')

evaluations/lineart_ssim.py

@@ -0,0 +1,54 @@
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+from transformers import DPTImageProcessor, DPTForDepthEstimation
+from PIL import Image
+import os
+import torch
+import numpy as np
+from torch.utils.data import DataLoader, Dataset
+import sys
+current_directory = os.getcwd()
+sys.path.append(current_directory)
+from autoregressive.test.metric import RMSE, SSIM
+import torch.nn.functional as F
+from condition.hed import HEDdetector
+from torchmetrics.image import MultiScaleStructuralSimilarityIndexMeasure
+from condition.lineart import LineArt
+# Define a dataset class for loading image and label pairs
+class ImageDataset(Dataset):
+    def __init__(self, img_dir, label_dir):
+        self.img_dir = img_dir
+        self.label_dir = label_dir
+        self.images = os.listdir(img_dir)
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self.img_dir, self.images[idx])
+        label_path = os.path.join(self.label_dir, self.images[idx])
+
+        image = np.array(Image.open(img_path).convert("RGB"))
+        label = np.array(Image.open(label_path))
+        return torch.from_numpy(image), torch.from_numpy(label).permute(2, 0, 1)
+
+model = LineArt()
+model.load_state_dict(torch.load('condition/ckpts/model.pth', map_location=torch.device('cpu')))
+model.cuda()
+# Define the dataset and data loader
+img_dir = 'sample/multigen/lineart/visualization'
+label_dir = 'sample/multigen/lineart/annotations'
+dataset = ImageDataset(img_dir, label_dir)
+data_loader = DataLoader(dataset, batch_size=16, shuffle=False, num_workers=4)
+
+ssim = MultiScaleStructuralSimilarityIndexMeasure(data_range=1.0).cuda()
+ssim_score = []
+with torch.no_grad():
+    for images, labels in tqdm(data_loader):
+        images = images.permute(0,3,1,2).cuda()
+        outputs = model(images.float())*255
+        predicted_hed = outputs
+        labels = labels[:, 0:1, :, :].cuda()
+        ssim_score.append(ssim((predicted_hed/255.0).clip(0,1), (labels/255.0).clip(0,1)))
+
+print(f'ssim: {torch.stack(ssim_score).mean()}')

evaluations/t2i/README.md

@@ -0,0 +1,21 @@
+# Evaluations from [GigaGAN](https://github.com/mingukkang/GigaGAN/tree/main/evaluation)
+
+```
+pip install git+https://github.com/openai/CLIP.git
+pip install open_clip_torch
+pip install clean_fid
+```
+
+```
+python3 evaluations/t2i/evaluation.py \
+--eval_res 256 \ 
+--batch_size 256 \
+--how_many 30000 \
+--ref_data "coco2014" \
+--ref_type "val2014" \
+--eval_res 256 \
+--batch_size 256 \
+--ref_dir "/path/to/coco" \
+--fake_dir "/path/to/generation" \
+$@
+```

evaluations/t2i/evaluation.py

@@ -0,0 +1,260 @@
+# Modified from:
+#   GigaGAN: https://github.com/mingukkang/GigaGAN
+import os
+import torch
+import numpy as np
+import re
+import io
+import random
+
+from pathlib import Path
+from tqdm import tqdm
+from PIL import Image
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader
+from torchvision.datasets import CocoCaptions
+from torchvision.datasets import ImageFolder
+from torchvision.transforms import InterpolationMode
+from PIL import Image
+import torchvision.transforms as transforms
+import glob
+
+
+resizer_collection = {"nearest": InterpolationMode.NEAREST,
+                      "box": InterpolationMode.BOX,
+                      "bilinear": InterpolationMode.BILINEAR,
+                      "hamming": InterpolationMode.HAMMING,
+                      "bicubic": InterpolationMode.BICUBIC,
+                      "lanczos": InterpolationMode.LANCZOS}
+
+
+class CenterCropLongEdge(object):
+    """
+    this code is borrowed from https://github.com/ajbrock/BigGAN-PyTorch
+    MIT License
+    Copyright (c) 2019 Andy Brock
+    """ 
+    def __call__(self, img):
+        return transforms.functional.center_crop(img, min(img.size))
+
+    def __repr__(self):
+        return self.__class__.__name__
+
+
+class EvalDataset(Dataset):
+    def __init__(self,
+                 data_name,
+                 data_dir,
+                 data_type,
+                 crop_long_edge=False,
+                 resize_size=None,
+                 resizer="lanczos",
+                 normalize=True,
+                 load_txt_from_file=False,
+                 ):
+        super(EvalDataset, self).__init__()
+        self.data_name = data_name
+        self.data_dir = data_dir
+        self.data_type = data_type
+        self.resize_size = resize_size
+        self.normalize = normalize
+        self.load_txt_from_file = load_txt_from_file
+
+        self.trsf_list = [CenterCropLongEdge()]
+        if isinstance(self.resize_size, int):
+            self.trsf_list += [transforms.Resize(self.resize_size,
+                                                 interpolation=resizer_collection[resizer])]
+        if self.normalize:
+            self.trsf_list += [transforms.ToTensor()]
+            self.trsf_list += [transforms.Normalize([0.5, 0.5, 0.5],
+                                                    [0.5, 0.5, 0.5])]
+        else:
+            self.trsf_list += [transforms.PILToTensor()]
+        self.trsf = transforms.Compose(self.trsf_list)
+
+        self.load_dataset()
+
+    def natural_sort(self, l): 
+        convert = lambda text: int(text) if text.isdigit() else text.lower()
+        alphanum_key = lambda key: [convert(c) for c in re.split('([0-9]+)', key)]
+        return sorted(l, key=alphanum_key)
+
+    def load_dataset(self):
+        if self.data_name == "coco2014":
+            if self.load_txt_from_file:
+                self.imagelist = self.natural_sort(glob.glob(os.path.join(self.data_dir, self.data_type, "*.%s" % "png")))
+                captionfile = os.path.join(self.data_dir, "captions.txt")
+                with io.open(captionfile, 'r', encoding="utf-8") as f:
+                    self.captions = f.read().splitlines()
+                self.data = list(zip(self.imagelist, self.captions))
+            else:
+                self.data = CocoCaptions(root=os.path.join(self.data_dir,
+                                                        "val2014"),
+                                        annFile=os.path.join(self.data_dir,
+                                                            "annotations",
+                                                            "captions_val2014.json"))
+        else:
+            root = os.path.join(self.data_dir, self.data_type)
+            self.data = ImageFolder(root=root)
+
+    def __len__(self):
+        num_dataset = len(self.data)
+        return num_dataset
+
+    def __getitem__(self, index):
+        if self.data_name == "coco2014":
+            img, txt = self.data[index]
+            if isinstance(img, str):
+                img = Image.open(img).convert("RGB")
+            if isinstance(txt, list):
+                txt = txt[random.randint(0, 4)]
+            return self.trsf(img), txt
+        else:
+            img, label = self.data[index]
+            return self.trsf(img), int(label)
+
+
+def tensor2pil(image: torch.Tensor):
+    ''' output image : tensor to PIL
+    '''
+    if isinstance(image, list) or image.ndim == 4:
+        return [tensor2pil(im) for im in image]
+
+    assert image.ndim == 3
+    output_image = Image.fromarray(((image + 1.0) * 127.5).clamp(
+        0.0, 255.0).to(torch.uint8).permute(1, 2, 0).detach().cpu().numpy())
+    return output_image
+
+
+@torch.no_grad()
+def compute_clip_score(
+    dataset: DataLoader, clip_model="ViT-B/32", device="cuda", how_many=5000):
+    print("Computing CLIP score")
+    import clip as openai_clip 
+    if clip_model == "ViT-B/32":
+        clip, clip_preprocessor = openai_clip.load("ViT-B/32", device=device)
+        clip = clip.eval()
+    elif clip_model == "ViT-G/14":
+        import open_clip
+        clip, _, clip_preprocessor = open_clip.create_model_and_transforms("ViT-g-14", pretrained="laion2b_s12b_b42k")
+        clip = clip.to(device)
+        clip = clip.eval()
+        clip = clip.float()
+    else:
+        raise NotImplementedError
+
+    cos_sims = []
+    count = 0
+    for imgs, txts in tqdm(dataset):
+        imgs_pil = [clip_preprocessor(tensor2pil(img)) for img in imgs]
+        imgs = torch.stack(imgs_pil, dim=0).to(device)
+        tokens = openai_clip.tokenize(txts, truncate=True).to(device)
+        # Prepending text prompts with "A photo depicts "
+        # https://arxiv.org/abs/2104.08718
+        prepend_text = "A photo depicts "
+        prepend_text_token = openai_clip.tokenize(prepend_text)[:, 1:4].to(device)
+        prepend_text_tokens = prepend_text_token.expand(tokens.shape[0], -1)
+        
+        start_tokens = tokens[:, :1]
+        new_text_tokens = torch.cat(
+            [start_tokens, prepend_text_tokens, tokens[:, 1:]], dim=1)[:, :77]
+        last_cols = new_text_tokens[:, 77 - 1:77]
+        last_cols[last_cols > 0] = 49407  # eot token
+        new_text_tokens = torch.cat([new_text_tokens[:, :76], last_cols], dim=1)
+        
+        img_embs = clip.encode_image(imgs)
+        text_embs = clip.encode_text(new_text_tokens)
+
+        similarities = F.cosine_similarity(img_embs, text_embs, dim=1)
+        cos_sims.append(similarities)
+        count += similarities.shape[0]
+        if count >= how_many:
+            break
+    
+    clip_score = torch.cat(cos_sims, dim=0)[:how_many].mean()
+    clip_score = clip_score.detach().cpu().numpy()
+    return clip_score
+
+
+@torch.no_grad()
+def compute_fid(fake_dir: Path, gt_dir: Path,
+    resize_size=None, feature_extractor="clip"):
+    from cleanfid import fid
+    center_crop_trsf = CenterCropLongEdge()
+    def resize_and_center_crop(image_np):
+        image_pil = Image.fromarray(image_np) 
+        image_pil = center_crop_trsf(image_pil)
+
+        if resize_size is not None:
+            image_pil = image_pil.resize((resize_size, resize_size),
+                                         Image.LANCZOS)
+        return np.array(image_pil)
+
+    if feature_extractor == "inception":
+        model_name = "inception_v3"
+    elif feature_extractor == "clip":
+        model_name = "clip_vit_b_32"
+    else:
+        raise ValueError(
+            "Unrecognized feature extractor [%s]" % feature_extractor)
+    fid = fid.compute_fid(gt_dir,
+                          fake_dir,
+                          model_name=model_name,
+                          custom_image_tranform=resize_and_center_crop)
+    return fid
+
+
+def evaluate_model(opt):
+    ### Generated images
+    dset2 = EvalDataset(data_name=opt.ref_data,
+                        data_dir=opt.fake_dir,
+                        data_type="images",
+                        crop_long_edge=True,
+                        resize_size=opt.eval_res,
+                        resizer="lanczos",
+                        normalize=True,
+                        load_txt_from_file=True if opt.ref_data == "coco2014" else False)
+
+    dset2_dataloader = DataLoader(dataset=dset2,
+                                  batch_size=opt.batch_size,
+                                  shuffle=False,
+                                  pin_memory=True,
+                                  drop_last=False)
+
+    if opt.ref_data == "coco2014":
+        clip_score = compute_clip_score(dset2_dataloader, clip_model=opt.clip_model4eval, how_many=opt.how_many)
+        print(f"CLIP score: {clip_score}")
+
+    ref_sub_folder_name = "val2014" if opt.ref_data == "coco2014" else opt.ref_type
+    fake_sub_folder_name = "images"
+    fid = compute_fid(
+        os.path.join(opt.ref_dir, ref_sub_folder_name),
+        os.path.join(opt.fake_dir, fake_sub_folder_name),
+        resize_size=opt.eval_res,
+        feature_extractor="inception")
+    print(f"FID_{opt.eval_res}px: {fid}")
+
+    txt_path = opt.fake_dir + '/score.txt'
+    print("writing to {}".format(txt_path))
+    with open(txt_path, 'w') as f:
+        print(f"CLIP score: {clip_score}", file=f)
+        print(f"FID_{opt.eval_res}px: {fid}", file=f)
+
+    return
+
+
+if __name__ == "__main__":
+    import argparse 
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--fake_dir", required=True, default="/home/GigaGAN_images/", help="location of fake images for evaluation")
+    parser.add_argument("--ref_dir",  required=True, default="/home/COCO/", help="location of the reference images for evaluation")
+    parser.add_argument("--ref_data", default="coco2014", type=str, help="in [imagenet2012, coco2014, laion4k]")
+    parser.add_argument("--ref_type", default="train/valid/test", help="Type of reference dataset")
+
+    parser.add_argument("--how_many", default=30000, type=int)
+    parser.add_argument("--clip_model4eval", default="ViT-B/32", type=str, help="[WO, ViT-B/32, ViT-G/14]")
+    parser.add_argument("--eval_res", default=256, type=int)
+    parser.add_argument("--batch_size", default=8, type=int)
+    
+    opt, _ = parser.parse_known_args()
+    evaluate_model(opt)

language/README.md

@@ -0,0 +1,14 @@
+## Language models for text-conditional image generation
+
+### Requirements
+```
+pip install ftfy
+pip install transformers
+pip install accelerate
+pip install sentencepiece
+pip install pandas
+pip install bs4
+```
+
+### Language Models
+Download flan-t5-xl models from [flan-t5-xl](https://huggingface.co/google/flan-t5-xl) and put into the folder of `./pretrained_models/t5-ckpt/`

language/extract_t5_feature.py

@@ -0,0 +1,129 @@
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.utils.data import Dataset, DataLoader
+from torch.utils.data.distributed import DistributedSampler
+import numpy as np
+import argparse
+import os
+import json
+
+# from utils.distributed import init_distributed_mode
+from language.t5 import T5Embedder
+
+CAPTION_KEY = {
+    'blip': 0,
+    'llava': 1,
+    'llava_first': 2,
+}
+#################################################################################
+#                             Training Helper Functions                         #
+#################################################################################
+class CustomDataset(Dataset):
+    def __init__(self, lst_dir, start, end, caption_key, trunc_caption=False):
+        img_path_list = []
+        for lst_name in sorted(os.listdir(lst_dir))[start: end+1]:
+            if not lst_name.endswith('.jsonl'):
+                continue
+            file_path = os.path.join(lst_dir, lst_name)
+            with open(file_path, 'r') as file:
+                for line_idx, line in enumerate(file):
+                    data = json.loads(line)
+                    # caption = data[caption_key]
+                    caption = data['text'][CAPTION_KEY[caption_key]]
+                    code_dir = file_path.split('/')[-1].split('.')[0]
+                    if trunc_caption:
+                        caption = caption.split('.')[0]
+                    img_path_list.append((caption, code_dir, line_idx))
+        self.img_path_list = img_path_list
+
+    def __len__(self):
+        return len(self.img_path_list)
+
+    def __getitem__(self, index):
+        caption, code_dir, code_name = self.img_path_list[index]
+        return caption, code_dir, code_name
+
+
+        
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+def main(args):
+    """
+    Trains a new DiT model.
+    """
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+
+    # Setup DDP:
+    # dist.init_process_group("nccl")
+    init_distributed_mode(args)
+    rank = dist.get_rank()
+    device = rank % torch.cuda.device_count()
+    seed = args.global_seed * dist.get_world_size() + rank
+    torch.manual_seed(seed)
+    torch.cuda.set_device(device)
+    print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+
+    # Setup a feature folder:
+    if rank == 0:
+        os.makedirs(args.t5_path, exist_ok=True)
+
+    # Setup data:
+    print(f"Dataset is preparing...")
+    dataset = CustomDataset(args.data_path, args.data_start, args.data_end, args.caption_key, args.trunc_caption)
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=False,
+        seed=args.global_seed
+    )
+    loader = DataLoader(
+        dataset,
+        batch_size=1, # important!
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=False
+    )
+    print(f"Dataset contains {len(dataset):,} images")
+
+    precision = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.precision]
+    assert os.path.exists(args.t5_model_path)
+    t5_xxl = T5Embedder(
+        device=device, 
+        local_cache=True, 
+        cache_dir=args.t5_model_path, 
+        dir_or_name=args.t5_model_type,
+        torch_dtype=precision
+    )
+
+    for caption, code_dir, code_name in loader:
+        caption_embs, emb_masks = t5_xxl.get_text_embeddings(caption)
+        valid_caption_embs = caption_embs[:, :emb_masks.sum()]
+        x = valid_caption_embs.to(torch.float32).detach().cpu().numpy()
+        os.makedirs(os.path.join(args.t5_path, code_dir[0]), exist_ok=True)
+        np.save(os.path.join(args.t5_path, code_dir[0], '{}.npy'.format(code_name.item())), x)
+        print(code_name.item())
+
+    dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-path", type=str, required=True)
+    parser.add_argument("--t5-path", type=str, required=True)
+    parser.add_argument("--data-start", type=int, required=True)
+    parser.add_argument("--data-end", type=int, required=True)
+    parser.add_argument("--caption-key", type=str, default='blip', choices=list(CAPTION_KEY.keys()))
+    parser.add_argument("--trunc-caption", action='store_true', default=False)
+    parser.add_argument("--t5-model-path", type=str, default='./pretrained_models/t5-ckpt')
+    parser.add_argument("--t5-model-type", type=str, default='flan-t5-xl')
+    parser.add_argument("--precision", type=str, default='bf16', choices=["none", "fp16", "bf16"])
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--num-workers", type=int, default=24)
+    args = parser.parse_args()
+    main(args)

language/t5.py

@@ -0,0 +1,201 @@
+# Modified from:
+#   PixArt: https://github.com/PixArt-alpha/PixArt-alpha/blob/master/diffusion/model/t5.py
+import os
+import re
+import html
+import urllib.parse as ul
+
+import ftfy
+import torch
+from bs4 import BeautifulSoup
+from transformers import T5EncoderModel, AutoTokenizer
+from huggingface_hub import hf_hub_download
+
+
+class T5Embedder:
+    available_models = ['t5-v1_1-xxl', 't5-v1_1-xl', 'flan-t5-xl']
+    bad_punct_regex = re.compile(r'['+'#®•©™&@·º½¾¿¡§~'+'\)'+'\('+'\]'+'\['+'\}'+'\{'+'\|'+'\\'+'\/'+'\*' + r']{1,}')  # noqa
+
+    def __init__(self, device, dir_or_name='t5-v1_1-xxl', *, local_cache=False, cache_dir=None, hf_token=None, use_text_preprocessing=True,
+                 t5_model_kwargs=None, torch_dtype=None, use_offload_folder=None, model_max_length=120):
+        self.device = torch.device(device)
+        self.torch_dtype = torch_dtype or torch.bfloat16
+        if t5_model_kwargs is None:
+            t5_model_kwargs = {'low_cpu_mem_usage': True, 'torch_dtype': self.torch_dtype}
+            t5_model_kwargs['device_map'] = {'shared': self.device, 'encoder': self.device}
+
+        self.use_text_preprocessing = use_text_preprocessing
+        self.hf_token = hf_token
+        self.cache_dir = cache_dir or os.path.expanduser('~/.cache/IF_')
+        self.dir_or_name = dir_or_name
+        tokenizer_path, path = dir_or_name, dir_or_name
+        if local_cache:
+            cache_dir = os.path.join(self.cache_dir, dir_or_name)
+            tokenizer_path, path = cache_dir, cache_dir
+        elif dir_or_name in self.available_models:
+            cache_dir = os.path.join(self.cache_dir, dir_or_name)
+            for filename in [
+                'config.json', 'special_tokens_map.json', 'spiece.model', 'tokenizer_config.json',
+                'pytorch_model.bin.index.json', 'pytorch_model-00001-of-00002.bin', 'pytorch_model-00002-of-00002.bin'
+            ]:
+                hf_hub_download(repo_id=f'DeepFloyd/{dir_or_name}', filename=filename, cache_dir=cache_dir,
+                                force_filename=filename, token=self.hf_token)
+            tokenizer_path, path = cache_dir, cache_dir
+        else:
+            cache_dir = os.path.join(self.cache_dir, 't5-v1_1-xxl')
+            for filename in [
+                'config.json', 'special_tokens_map.json', 'spiece.model', 'tokenizer_config.json',
+            ]:
+                hf_hub_download(repo_id='DeepFloyd/t5-v1_1-xxl', filename=filename, cache_dir=cache_dir,
+                                force_filename=filename, token=self.hf_token)
+            tokenizer_path = cache_dir
+
+        print(tokenizer_path)
+        self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
+        self.model = T5EncoderModel.from_pretrained(path, **t5_model_kwargs).eval()
+        self.model_max_length = model_max_length
+
+    def get_text_embeddings(self, texts):
+        texts = [self.text_preprocessing(text) for text in texts]
+
+        text_tokens_and_mask = self.tokenizer(
+            texts,
+            max_length=self.model_max_length,
+            padding='max_length',
+            truncation=True,
+            return_attention_mask=True,
+            add_special_tokens=True,
+            return_tensors='pt'
+        )
+
+        text_tokens_and_mask['input_ids'] = text_tokens_and_mask['input_ids']
+        text_tokens_and_mask['attention_mask'] = text_tokens_and_mask['attention_mask']
+
+        with torch.no_grad():
+            text_encoder_embs = self.model(
+                input_ids=text_tokens_and_mask['input_ids'].to(self.device),
+                attention_mask=text_tokens_and_mask['attention_mask'].to(self.device),
+            )['last_hidden_state'].detach()
+        return text_encoder_embs, text_tokens_and_mask['attention_mask'].to(self.device)
+
+    def text_preprocessing(self, text):
+        if self.use_text_preprocessing:
+            # The exact text cleaning as was in the training stage:
+            text = self.clean_caption(text)
+            text = self.clean_caption(text)
+            return text
+        else:
+            return text.lower().strip()
+
+    @staticmethod
+    def basic_clean(text):
+        text = ftfy.fix_text(text)
+        text = html.unescape(html.unescape(text))
+        return text.strip()
+
+    def clean_caption(self, caption):
+        caption = str(caption)
+        caption = ul.unquote_plus(caption)
+        caption = caption.strip().lower()
+        caption = re.sub('<person>', 'person', caption)
+        # urls:
+        caption = re.sub(
+            r'\b((?:https?:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))',  # noqa
+            '', caption)  # regex for urls
+        caption = re.sub(
+            r'\b((?:www:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))',  # noqa
+            '', caption)  # regex for urls
+        # html:
+        caption = BeautifulSoup(caption, features='html.parser').text
+
+        # @<nickname>
+        caption = re.sub(r'@[\w\d]+\b', '', caption)
+
+        # 31C0—31EF CJK Strokes
+        # 31F0—31FF Katakana Phonetic Extensions
+        # 3200—32FF Enclosed CJK Letters and Months
+        # 3300—33FF CJK Compatibility
+        # 3400—4DBF CJK Unified Ideographs Extension A
+        # 4DC0—4DFF Yijing Hexagram Symbols
+        # 4E00—9FFF CJK Unified Ideographs
+        caption = re.sub(r'[\u31c0-\u31ef]+', '', caption)
+        caption = re.sub(r'[\u31f0-\u31ff]+', '', caption)
+        caption = re.sub(r'[\u3200-\u32ff]+', '', caption)
+        caption = re.sub(r'[\u3300-\u33ff]+', '', caption)
+        caption = re.sub(r'[\u3400-\u4dbf]+', '', caption)
+        caption = re.sub(r'[\u4dc0-\u4dff]+', '', caption)
+        caption = re.sub(r'[\u4e00-\u9fff]+', '', caption)
+        #######################################################
+
+        # все виды тире / all types of dash --> "-"
+        caption = re.sub(
+            r'[\u002D\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D]+',  # noqa
+            '-', caption)
+
+        # кавычки к одному стандарту
+        caption = re.sub(r'[`´«»“”¨]', '"', caption)
+        caption = re.sub(r'[‘’]', "'", caption)
+
+        # &quot;
+        caption = re.sub(r'&quot;?', '', caption)
+        # &amp
+        caption = re.sub(r'&amp', '', caption)
+
+        # ip adresses:
+        caption = re.sub(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', ' ', caption)
+
+        # article ids:
+        caption = re.sub(r'\d:\d\d\s+$', '', caption)
+
+        # \n
+        caption = re.sub(r'\\n', ' ', caption)
+
+        # "#123"
+        caption = re.sub(r'#\d{1,3}\b', '', caption)
+        # "#12345.."
+        caption = re.sub(r'#\d{5,}\b', '', caption)
+        # "123456.."
+        caption = re.sub(r'\b\d{6,}\b', '', caption)
+        # filenames:
+        caption = re.sub(r'[\S]+\.(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)', '', caption)
+
+        #
+        caption = re.sub(r'[\"\']{2,}', r'"', caption)  # """AUSVERKAUFT"""
+        caption = re.sub(r'[\.]{2,}', r' ', caption)  # """AUSVERKAUFT"""
+
+        caption = re.sub(self.bad_punct_regex, r' ', caption)  # ***AUSVERKAUFT***, #AUSVERKAUFT
+        caption = re.sub(r'\s+\.\s+', r' ', caption)  # " . "
+
+        # this-is-my-cute-cat / this_is_my_cute_cat
+        regex2 = re.compile(r'(?:\-|\_)')
+        if len(re.findall(regex2, caption)) > 3:
+            caption = re.sub(regex2, ' ', caption)
+
+        caption = self.basic_clean(caption)
+
+        caption = re.sub(r'\b[a-zA-Z]{1,3}\d{3,15}\b', '', caption)  # jc6640
+        caption = re.sub(r'\b[a-zA-Z]+\d+[a-zA-Z]+\b', '', caption)  # jc6640vc
+        caption = re.sub(r'\b\d+[a-zA-Z]+\d+\b', '', caption)  # 6640vc231
+
+        caption = re.sub(r'(worldwide\s+)?(free\s+)?shipping', '', caption)
+        caption = re.sub(r'(free\s)?download(\sfree)?', '', caption)
+        caption = re.sub(r'\bclick\b\s(?:for|on)\s\w+', '', caption)
+        caption = re.sub(r'\b(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)(\simage[s]?)?', '', caption)
+        caption = re.sub(r'\bpage\s+\d+\b', '', caption)
+
+        caption = re.sub(r'\b\d*[a-zA-Z]+\d+[a-zA-Z]+\d+[a-zA-Z\d]*\b', r' ', caption)  # j2d1a2a...
+
+        caption = re.sub(r'\b\d+\.?\d*[xх×]\d+\.?\d*\b', '', caption)
+
+        caption = re.sub(r'\b\s+\:\s+', r': ', caption)
+        caption = re.sub(r'(\D[,\./])\b', r'\1 ', caption)
+        caption = re.sub(r'\s+', ' ', caption)
+
+        caption.strip()
+
+        caption = re.sub(r'^[\"\']([\w\W]+)[\"\']$', r'\1', caption)
+        caption = re.sub(r'^[\'\_,\-\:;]', r'', caption)
+        caption = re.sub(r'[\'\_,\-\:\-\+]$', r'', caption)
+        caption = re.sub(r'^\.\S+$', '', caption)
+
+        return caption.strip()

scripts/autoregressive/extract_codes_c2i.sh

@@ -0,0 +1,7 @@
+# !/bin/bash
+set -x
+
+torchrun \
+--nnodes=1 --nproc_per_node=2 --node_rank=0 \
+--master_port=12335 \
+autoregressive/train/extract_codes_c2i.py "$@"