|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
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 |
|
|
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): |
|
|
|
|
|
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) |
