# Copyright (c) Alibaba Group import argparse import torch import torchvision.datasets as datasets import torch.nn.functional as F import clip import os import math import numpy as np from torchvision.datasets import MNIST, CIFAR10 from datetime import datetime import logging from MAPLS.mapls import mapls from MAPLS.common import lsc log_filename = os.path.join("logs", f"onzeta_eval_{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.log") logging.basicConfig( level=logging.INFO, format='%(message)s', handlers=[ logging.FileHandler(log_filename), logging.StreamHandler() ] ) model_names = ['RN50', 'ViT-B/32', 'ViT-B/16', 'ViT-L/14', 'ViT-L/14@336px'] parser = argparse.ArgumentParser(description='OnZeta for ImageNet') parser.add_argument('--data_path', default='./CIFAR10_TEST', type=str, help='dataset path') parser.add_argument('-a', '--arch', metavar='ARCH', default='ViT-B/16', choices=model_names, help='model architecture: ' + ' | '.join(model_names) + ' (default: RN50)') parser.add_argument('-j', '--workers', default=8, type=int, metavar='N', help='number of data loading workers (default: 8)') parser.add_argument('-b', '--batch-size', default=256, type=int, metavar='N', help='mini-batch size (default: 256)') parser.add_argument('--tau_t', default=0.01, type=float) parser.add_argument('--tau_i', default=0.04, type=float) parser.add_argument('--cw', default=0.5, type=float) parser.add_argument('--cr', default=20, type=float) parser.add_argument('--alpha', default=0, type=float) parser.add_argument('--beta', default=0.4, type=float) parser.add_argument('--repeat', default=5, type=int) device = "cuda" if torch.cuda.is_available() else "cpu" def main(beta): args = parser.parse_args() logging.info(args) lam = 1 args.beta = beta logging.info("the beta is {}".format(beta)) cifar10_classes = [ 'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck', ] cifar10_templates = [ 'a photo of a {}.', 'a blurry photo of a {}.', 'a black and white photo of a {}.', 'a low contrast photo of a {}.', 'a high contrast photo of a {}.', 'a bad photo of a {}.', 'a good photo of a {}.', 'a photo of a small {}.', 'a photo of a big {}.', 'a photo of the {}.', 'a blurry photo of the {}.', 'a black and white photo of the {}.', 'a low contrast photo of the {}.', 'a high contrast photo of the {}.', 'a bad photo of the {}.', 'a good photo of the {}.', 'a photo of the small {}.', 'a photo of the big {}.', ] logging.info('load pre-trained model') model, preprocess = clip.load(args.arch) model = model.cuda() model.eval() logging.info('load data') # valdir = os.path.join(args.data_path, 'val') # valdir = os.path.join(args.data_path, '') cifar10 = CIFAR10(root=os.path.expanduser("~/.cache"), download=True, train=False) # val_set = datasets.ImageFolder(valdir, transform=preprocess) # loader = torch.utils.data.DataLoader(val_set, batch_size=args.batch_size, num_workers=args.workers) with torch.no_grad(): image_feat = [] image_label = [] for i, (images, target) in enumerate(cifar10): # images = images.cuda() # target = target.cuda() # image_features = model.encode_image(images) images = preprocess(images).unsqueeze(0).to(device) with torch.no_grad(): images = model.encode_image(images) images /= images.norm() image_feat.append(images) image_label.append(target) image_feat = torch.stack(image_feat, dim=1).to(device) image_feat = image_feat.squeeze() # image_label = torch.cat(image_label, dim=0) image_label = torch.tensor(image_label, dtype=torch.long).to(device) n = len(image_label) image_feat = image_feat.float() logging.info('obtain text proxy') text_classifier = zeroshot_classifier(clip, model, cifar10_classes, cifar10_templates) text_classifier = text_classifier.float() logits_t = image_feat @ text_classifier acc1, acc5 = accuracy(logits_t, image_label, topk=(1, 5)) top1 = (acc1 / n) * 100 logging.info(f'accuracy with text proxy: {top1:.2f}') logging.info('online zero-shot transfer: repeat {} times'.format(args.repeat)) num_class = len(torch.unique(image_label)) acc_onzeta = torch.zeros(args.repeat).cuda() acc_onlab = torch.zeros(args.repeat).cuda() acc_ls = torch.zeros(args.repeat).cuda() for iter in range(args.repeat): idx = torch.randperm(n).cuda() combo_label = torch.zeros(n, num_class).cuda() text_label = torch.zeros(n, num_class).cuda() w = text_classifier.clone() rho = torch.zeros(num_class).cuda() for i in range(n): lr = args.cw / math.sqrt(i + 1) rlr = args.cr / math.sqrt(i + 1) beta = args.beta * math.sqrt((i + 1) / n) x = image_feat[idx[i], :] tlabel = F.softmax(x @ text_classifier / args.tau_t, dim=0) tlabel = tlabel * torch.exp(rho) tlabel /= torch.sum(tlabel) rho -= rlr * (tlabel - args.alpha / num_class) rho[rho < 0] = 0 text_label[i, :] = tlabel vision_label = F.softmax(x @ w / args.tau_i, dim=0) combo_label[i, :] = beta * vision_label + (1 - beta) * tlabel grad = torch.outer(x, vision_label - tlabel) w -= (lr / args.tau_i) * grad w = F.normalize(w, dim=0) acc1, acc5 = accuracy(text_label, image_label[idx], topk=(1, 5)) acc_onlab[iter] = (acc1 / n) * 100 acc1, acc5 = accuracy(combo_label, image_label[idx], topk=(1, 5)) # MAPLS - EM Algorithm pz = np.full(len(cifar10_classes), 1.0 / len(cifar10_classes)) qy = mapls(combo_label, pz=pz, qy_mode="soft", max_iter=100, lam=lam) # FIXME why return nan w = np.array(qy) / np.array(pz) if combo_label.is_cuda: combo_label_cpu = combo_label.cpu() qy_probs = lsc(combo_label_cpu, 1.0 / w) acc1_ls, acc5_ls = accuracy(qy_probs, image_label[idx], topk=(1, 5)) acc_onzeta[iter] = (acc1 / n) * 100 acc_ls[iter] = (acc1_ls / n) * 100 logging.info('mean acc of onlab is: {:.2f}'.format(torch.mean(acc_onlab))) logging.info('mean acc of onzeta is: {:.2f}'.format(torch.mean(acc_onzeta))) logging.info('mean acc of MAPLS is: {:.2f}'.format(torch.mean(acc_ls))) def zeroshot_classifier(clip, model, classnames, templates): with torch.no_grad(): zeroshot_weights = [] for classname in classnames: texts = [template.format(classname) for template in templates] texts = clip.tokenize(texts).cuda() class_embeddings = model.encode_text(texts) class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True) class_embedding = class_embeddings.mean(dim=0) class_embedding /= class_embedding.norm() zeroshot_weights.append(class_embedding) zeroshot_weights = torch.stack(zeroshot_weights, dim=1).cuda() return zeroshot_weights def accuracy(output, target, topk=(1,)): pred = output.topk(max(topk), 1, True, True)[1].t() pred, target = pred.cpu(), target.cpu() correct = pred.eq(target.view(1, -1).expand_as(pred)) return [float(correct[:k].reshape(-1).float().sum(0, keepdim=True).cpu().numpy()) for k in topk] if __name__ == '__main__': # main() betas = [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1] for beta in betas: main(beta)