| import sys |
| import os |
| sys.path.append(os.path.dirname(__file__) + os.sep + '../') |
| import clip |
| from config import * |
|
|
|
|
| class CLIPSimilarity(nn.Module): |
| def __init__(self, model_filename): |
| super(CLIPSimilarity, self).__init__() |
| self.model_filename = model_filename |
| self.model, self.p = clip.load(model_filename, device='cpu') |
| self.model = self.model.eval() |
|
|
| def forward(self, text, image, batch_size=None): |
| ''' |
| text: [X] |
| for example, ['str_1', 'str_2', ..., 'str_X'] |
| image: [Y, c, w, h] |
| |
| return: [X, Y] |
| ''' |
| device = image.device |
| img_input = F.interpolate(image, size=224) |
| image_mean = torch.tensor([0.48145466, 0.4578275, 0.40821073]).to(device) |
| image_std = torch.tensor([0.26862954, 0.26130258, 0.27577711]).to(device) |
| img_input = (img_input.clamp(min=-1.0, max=1.0) + 1.0) / 2.0 |
| img_input -= image_mean[:, None, None] |
| img_input /= image_std[:, None, None] |
| text_input = clip.tokenize(text, truncate=True).to(device) |
| with torch.no_grad(): |
| text_features = self.model.encode_text(text_input).float() |
| image_features = self.model.encode_image(img_input).float() |
|
|
| image_features /= image_features.norm(dim=-1, keepdim=True) |
| text_features /= text_features.norm(dim=-1, keepdim=True) |
|
|
| logit_scale = 1.0 |
| if batch_size: |
| text_features = rearrange(text_features, '(b x) d -> b x d', b=batch_size) |
| image_features = rearrange(image_features, '(b y) d -> b d y', b=batch_size) |
| else: |
| image_features = image_features.t() |
| logits_per_text = logit_scale * torch.matmul(text_features, image_features) |
| similarity = logits_per_text |
| return similarity |
|
|
|
|
| class BaseDataset(Dataset): |
| def __init__(self, img_list, txt_list): |
|
|
| self.img_list = img_list |
| self.txt_list = txt_list |
|
|
| assert len(img_list) == len(txt_list), 'len_img must equal len_txt!' |
|
|
| self.transform = transforms.Compose([ |
| transforms.Resize((224, 224)), |
| transforms.ToTensor(), |
| transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), |
| ]) |
|
|
| def __len__(self): |
| return len(self.img_list) |
|
|
| def __getitem__(self, i): |
| img_path = self.img_list[i] |
| caption = self.txt_list[i] |
| img = Image.open(img_path).convert('RGB') |
| image = self.transform(img) |
|
|
| sample = {"label_imgs": image, 'input_text': caption} |
| return sample |
|
|
|
|
| def compute_clip_score(model_pth, img_list, txt_list, batch_size=32, cuda_device=0): |
|
|
| device = torch.device(f'cuda:{cuda_device}') |
| model = CLIPSimilarity(model_pth).to(device) |
|
|
| data = BaseDataset(img_list, txt_list) |
| loader = DataLoader(data, batch_size=batch_size, shuffle=False, num_workers=32) |
|
|
| clip_sim_total = 0 |
| num = 0 |
| for sample in tqdm(loader): |
| imgs = sample['label_imgs'].to(device) |
| caps = sample['input_text'] |
|
|
| clip_sim = model(caps, imgs, batch_size=len(caps)) |
|
|
| clip_sim_total += clip_sim.mean().item() |
| num += 1 |
|
|
| return clip_sim_total/num |
|
|
