def __init__(self, img_size: int, original_size: int, mean: float = 0, std: float = 1, brightness: float = 0.3, contrast: float = 0.5, saturation: float = 0.5, hue: float = 0.3, rotation_degree: int = 10, hflip: float = 0.5, debug: bool = False): self.original_size = original_size self.target_size = img_size self.to_pil = transforms.ToPILImage() self.color_jitter = transforms.ColorJitter(brightness=brightness, contrast=contrast, saturation=saturation, hue=hue) self.resize = transforms.Resize(img_size) self.to_tensor = transforms.ToTensor() self.normalize = transforms.Normalize(mean, std) self.r_horizontal_flip = RandomHorizontalFlip(p=hflip) self.r_rotation = RandomRotation(rotation_degree) self.debug = debug
def get_transform(train=True, low=0.5, high=0.5): transforms = [] transforms.append(T.ToTensor()) if train: # transforms.append(T.Occlude((0, 1.0))) pass else: # transforms.append(T.Occlude(low=low, high=high, color="black")) transforms.append(T.ToPILImage()) return T.Compose(transforms)
def __init__(self, masked_paths: list, unmasked_paths: list, tgt_size: tuple): self.masked_paths = masked_paths self.unmasked_paths = unmasked_paths self.transform = T.Compose([ T.ToPILImage(), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), T.Resize(tgt_size) ])
def get_transform(train=True): transforms = [] transforms.append(T.ToTensor()) if train: # transforms.append(T.Occlude((0, 1.0))) pass else: # transforms.append(T.Occlude((0.4, 0.8))) transforms.append(T.ToPILImage()) return T.Compose(transforms)
def save_mix_images(self, x_batch, epoch, batch_idx, end_epoch = 0, end_batch_idx = 5): if epoch == end_epoch and batch_idx <= end_batch_idx: for i in range(len(x_batch)): unloader = transforms.ToPILImage() image = x_batch[i].cpu().clone() image = image.squeeze(0) image = unloader(image) out_dir = 'mix_results' if not os.path.exists(out_dir): os.makedirs(out_dir) image.save('mix_results/results_{}_{}.jpg'.format(batch_idx, i))
def __init__(self, data_path, split, augment=True, load_everything=True, filename='cifar-10.npz'): self.count = 0 file_path = os.path.join(data_path, filename) full_data = np.load(file_path) self.normalize = transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = [ # transforms.Scale(256), # transforms.RandomCrop(224), # transforms.RandomResizedCrop(224) ] self.split = split self.dataset = full_data['arr_0'] self.labels = full_data['arr_1'] if split == 'train': if filename == 'cifar-10.npz': self.dataset = self.dataset[:50000] self.labels = self.labels[:50000] self.dataset = self.dataset.reshape((50000, 3, 32, 32)) else: if filename == 'cifar-10.npz': self.dataset = full_data[50000:] self.labels = self.labels[50000:] self.dataset = self.dataset.reshape((10000, 3, 32, 32)) self.dataset = np.transpose(self.dataset, (0, 2, 3, 1)) print(self.dataset.shape) # if augment: # transform.extend([ # transforms.ColorJitter(brightness=0.1, contrast=0.0, saturation=0.3, hue=0.05), # transforms.RandomHorizontalFlip(), # # transforms.RandomVerticalFlip(), # ]) transform += [transforms.ToTensor()] # if augment: # transform.append( # affine_transforms.Affine(rotation_range=5.0, zoom_range=(0.85, 1.0), fill_mode='constant') # ) # if augment: # transform.append( # affine_transforms.Affine(rotation_range=10.0, translation_range=0.1, zoom_range=(0.5, 1.0), fill_mode='constant') # ) transform += [ self.normalize] self.preprocess = transforms.Compose(transform) self.to_image = transforms.ToPILImage()
def recover_img_to_PIL(image, mean, std): """ Inverse step of the [normalize, toTensor] step Args: image: tensor c * h * w mean: list c std: list c return: image: PILImage """ import transforms for t, m, s in zip(image, mean, std): t.mul_(s).add_(m) return transforms.ToPILImage()(image)
batch_size=128, shuffle=True, num_workers=0) PublicTestset = FER2013(split='PublicTest', transform=transform_test) PublicTestloader = torch.utils.data.DataLoader(PublicTestset, batch_size=128, shuffle=False, num_workers=0) PrivateTestset = FER2013(split='PrivateTest', transform=transform_test) PrivateTestloader = torch.utils.data.DataLoader(PrivateTestset, batch_size=128, shuffle=False, num_workers=0) dataiter = iter(trainloader) imgs, labels = next(dataiter) unloader = transforms.ToPILImage() print(np.shape(imgs)) print(np.shape(labels)) image = unloader(imgs[0]) plt.imshow(image) plt.pause(0.3) Modell = VGG('VGG19') Modell.load_state_dict( torch.load('./FER2013_VGG19/PublicTest_model.t7', map_location='cpu')['net']) Returnnn = perturb(imgs, labels, 0.2, Modell=Modell) Returnnn = torch.Tensor(Returnnn) image = unloader(Returnnn[0])
def main(**kwargs): test_path = kwargs.get('test_data_path') submission_file_path = kwargs.get('submission_file_path') idlookup_file_path = kwargs.get('idlookup_file_path') checkpoint_path = kwargs.get('checkpoint_path') backbone_name = kwargs.get('backbone') num_classes = kwargs.get('num_classes') device = kwargs.get('device') batch_size = kwargs.get('batch_size') # TODO give trained mean and std mean = 0 std = 1 original_img_size = 96 submission_df = pd.read_csv(submission_file_path) idlookup_df = pd.read_csv(idlookup_file_path) backbone = get_backbone(backbone_name) model = FacialKeypointsDetector(backbone, device=device, num_classes=num_classes) transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize(model.get_input_size()), transforms.ToTensor(), transforms.Normalize(mean, std) ]) dataset = get_test_dataset(root_path=test_path, transform=transform) dl = torch.utils.data.DataLoader(dataset, num_workers=4, batch_size=batch_size, pin_memory=True, collate_fn=custom_collate_fn) load_model(model, checkpoint_path) predictions = {} for imgs, img_ids in tqdm(dl, total=len(dl.dataset) // batch_size): # {img_id:{'loc1':pred}} preds = model.predict(imgs) * original_img_size preds = torch.clamp(preds, min=0, max=original_img_size) for img_idx, pred in zip(img_ids, preds.cpu().numpy().tolist()): predictions[img_idx] = {} for label, location in zip(labels, pred): predictions[img_idx][label] = location locations = [] row_ids = [] for s, lookup in zip(submission_df.iterrows(), idlookup_df.iterrows()): s = s[1] lookup = lookup[1] # RowId,Location s = json.loads(s.to_json()) # RowId,ImageId,FeatureName,Location lookup = json.loads(lookup.to_json()) img_idx = lookup['ImageId'] feature = lookup['FeatureName'] row_id = s['RowId'] location = predictions[img_idx][feature] locations.append(location) row_ids.append(row_id) new_submission_df = pd.DataFrame(data={ 'RowId': row_ids, 'Location': locations }) submissin_dir_path = os.path.dirname(submission_file_path) new_submission_file_path = os.path.join(submissin_dir_path, 'submission.csv') print(new_submission_df.head()) new_submission_df.to_csv(new_submission_file_path, index=False, header=1)
def main(): global args, best_prec1 args = parser.parse_args() # torch.cuda.set_device(args.gpu) if args.tensorboard: print("Using TensorBoard") configure("exp/%s" % (args.name)) # Data loading code if args.augment: transform_train = transforms.Compose([ transforms.ToTensor(), transforms.Lambda(lambda x: F.pad( Variable(x.unsqueeze(0), requires_grad=False, volatile=True), (4, 4, 4, 4), mode='replicate').data.squeeze()), transforms.ToPILImage(), transforms.RandomCrop(32), transforms.RandomHorizontalFlip(), transforms.ToTensor(), ]) else: transform_train = transforms.Compose([ transforms.ToTensor(), ]) transform_test = transforms.Compose([ transforms.ToTensor(), ]) kwargs = {'num_workers': 1, 'pin_memory': True} assert (args.dataset == 'cifar10' or args.dataset == 'cifar100') train_loader = torch.utils.data.DataLoader( datasets.__dict__[args.dataset.upper()]('../data', train=True, download=True, transform=transform_train), batch_size=args.batch_size, shuffle=True, **kwargs) val_loader = torch.utils.data.DataLoader( datasets.__dict__[args.dataset.upper()]('../data', train=False, transform=transform_test), batch_size=args.batch_size, shuffle=True, **kwargs) # create model model = WideResNetMulti(args.layers, args.dataset == 'cifar10' and 10 or 100, args.num_rotate_classes, args.widen_factor, dropRate=args.droprate) # get the number of model parameters print('Number of model parameters: {}'.format( sum([p.data.nelement() for p in model.parameters()]))) # for training on multiple GPUs. # Use CUDA_VISIBLE_DEVICES=0,1 to specify which GPUs to use # model = torch.nn.DataParallel(model).cuda() model = model.cuda() # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, nesterov=args.nesterov, weight_decay=args.weight_decay) for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch + 1) # train for one epoch train(train_loader, model, criterion, optimizer, epoch) # evaluate on validation set prec1 = validate(val_loader, model, criterion, epoch) # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, }, is_best) print 'Best accuracy: ', best_prec1
def from_image(cls, img, sr_factor): pil = transforms.ToPILImage()(transforms.ToTensor()(img)) return ZSSRDataset(pil, sr_factor)
def main(**kwargs): training_path = kwargs.get('training_data_path') checkpoint_path = kwargs.get('checkpoint_path') tensorboard_log_dir = kwargs.get('tensorboard_log_dir') if not os.path.isdir(checkpoint_path): os.mkdir(checkpoint_path) backbone_name = kwargs.get('backbone') criterion_name = kwargs.get('criterion').upper() optimizer_name = kwargs.get('optimizer').upper() scheduler = kwargs.get('scheduler',None) pretrained = kwargs.get('pretrained') num_classes = kwargs.get('num_classes') device = kwargs.get('device') batch_size = kwargs.get('batch_size') epochs = kwargs.get('epochs') hyperparameters = kwargs.get('hyperparameters',{}) augmentations = kwargs.get('augmentations',{}) verbose = kwargs.get('verbose') train_split = kwargs.get('train_split') nfolds = kwargs.get('nfolds') val_splits = [(1-train_split) / nfolds] * nfolds resume = kwargs.get('resume') only_weights = kwargs.get('only_weights') seed = hyperparameters.get('seed') random_jitter = augmentations.get('jitter',{}) random_horizontal_flip = augmentations.get('horizontal_flip', 0.5) random_rotation = augmentations.get('rotation', 20) writer = SummaryWriter(log_dir=tensorboard_log_dir, flush_secs=20) if seed: seed_everything(seed) # TODO calculate mean and std mean = hyperparameters.get('mean',0) std = hyperparameters.get('std',1) splits = [train_split]+val_splits assert sum(splits) <= 1,"given splits must be lower or equal than 1" original_img_size = 96 criterion = get_criterion(criterion_name) backbone = get_backbone(backbone_name, pretrained=pretrained) model = FacialKeypointsDetector(backbone, criterion=criterion, device=device, num_classes=num_classes) optimizer = get_optimizer(optimizer_name, model.parameters(), kwargs=hyperparameters.get('optimizer',{})) scaler = GradScaler() val_transforms = None val_target_transform = TargetTransform(original_img_size) train_transform = train_target_transform = None train_transforms = transforms.TrainTransforms(model.get_input_size(), original_img_size, mean=mean, std=std, brightness=random_jitter.get('brightness'), contrast=random_jitter.get('contrast'), saturation=random_jitter.get('saturation'), hue=random_jitter.get('hue'), rotation_degree=random_rotation, hflip=random_horizontal_flip) val_transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize(model.get_input_size()), transforms.ToTensor(), transforms.Normalize(mean,std)]) train_dataset,*val_datasets = get_training_datasets(root_path=training_path, train_transforms=(train_transforms,train_transform,train_target_transform), val_transforms=(val_transforms,val_transform,val_target_transform), split_ratios=splits) val_dls = [] train_dl = torch.utils.data.DataLoader(train_dataset, num_workers=4, batch_size=batch_size, pin_memory=True, collate_fn=custom_collate_fn, shuffle=True) for val_ds in val_datasets: val_dls.append( torch.utils.data.DataLoader( val_ds, batch_size=batch_size, num_workers=2) ) current_epoch = 0 best_loss = math.inf if resume: print(Fore.CYAN, f"loading checkpoint from {checkpoint_path}",Style.RESET_ALL) best_loss,current_epoch = load_checkpoint(model, optimizer, scheduler=scheduler, save_path=checkpoint_path, suffix='last', only_weights=only_weights) try: for epoch in range(current_epoch,epochs): training_loop(train_dl, model, epoch, epochs, optimizer, writer,scaler, scheduler=scheduler, verbose=verbose) val_losses = [] for i,val_dl in enumerate(val_dls): val_loss = validation_loop(val_dl, model) val_losses.append(val_loss) print(Fore.LIGHTBLUE_EX, f"validation [{i+1}] loss: {val_loss:.07f}",Style.RESET_ALL) writer.add_scalar(f'Loss/val_{i+1}', val_loss, epoch) mean_val_loss = sum(val_losses) / len(val_losses) print(Fore.LIGHTBLUE_EX, f"validation [mean] loss: {mean_val_loss:.07f}",Style.RESET_ALL) writer.add_scalar(f'Loss/val_mean', mean_val_loss, epoch) writer.flush() if mean_val_loss < best_loss: best_loss = mean_val_loss print(Fore.CYAN, "saving best checkpoint...",Style.RESET_ALL) save_checkpoint(model,optimizer,epoch,best_loss, scheduler=scheduler, suffix='best', save_path=checkpoint_path) print(Fore.CYAN, "saving last checkpoint...",Style.RESET_ALL) save_checkpoint(model,optimizer,epoch,best_loss, scheduler=scheduler, suffix='last', save_path=checkpoint_path) except KeyboardInterrupt: print(Fore.RED, "training interrupted with ctrl+c saving current state of the model",Style.RESET_ALL) save_checkpoint(model,optimizer,epoch,best_loss, scheduler=scheduler, suffix='last', save_path=checkpoint_path) writer.close()
def train_each_teacher(num_epoch, train_data, train_label, test_data, test_label, save_path): torch.manual_seed(config.seed) print('len of train_data in network', len(train_data)) os.environ['CUDA_VISIBLE_DEVICES'] = config.gpu_devices print('it is training now') use_gpu = torch.cuda.is_available() if config.use_cpu: use_gpu = False print('whether evaluate', config.evaluate) if use_gpu: print("Currently using GPU {}".format(config.gpu_devices)) cudnn.benchmark = True torch.cuda.manual_seed_all(config.seed) else: print("Currently using CPU (GPU is highly recommended)") if config.dataset == 'mnist': transform_train = T.Compose([ T.Random2DTranslation(config.height, config.width), #T.RandomHorizontalFlip(), T.ToTensor(), T.Normalize(mean=[0.1307], std=[0.3081]), ]) transform_test = T.Compose([ T.Resize((config.height, config.width)), T.ToTensor(), T.Normalize(mean=[0.1307], std=[0.3081]), ]) else: transform_train = T.Compose([ #T.Random2DTranslation(config.height, config.width), T.ToPILImage(), T.RandomCrop(32, padding=4), T.RandomHorizontalFlip(), T.ToTensor(), #T.Resize(32), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) transform_test = T.Compose([ T.ToPILImage(), #T.Resize(32), #T.Resize((config.height, config.width,3)), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) pin_memory = True if use_gpu else False print('train_data', len(train_data), 'train_label', len(train_label)) trainloader = DataLoader( ImageDataset(train_data, label=train_label, transform=transform_train), batch_size=config.train_batch, shuffle=True, num_workers=config.workers, pin_memory=pin_memory, drop_last=True, ) testloader = DataLoader( ImageDataset(test_data, label=test_label, transform=transform_test), batch_size=config.test_batch, shuffle=False, num_workers=config.workers, pin_memory=pin_memory, drop_last=False, ) model = models.init_model(name=config.arch, num_classes=config.nb_labels, loss={'xent'}, use_gpu=use_gpu) if use_gpu: model = nn.DataParallel(model).cuda() criterion = torch.nn.CrossEntropyLoss() #optimizer = init_optim(config.optim, model.parameters(), config.lr, config.weight_decay) #if config.stepsize > 0: # scheduler = lr_scheduler.StepLR(optimizer, step_size=config.stepsize, gamma=config.gamma) print("==> Start training") start_time = time.time() for epoch in range(num_epoch): optimizer = optim.SGD(model.parameters(), lr=learning_rate(config.lr, epoch), momentum=0.9, weight_decay=0.0005) print('\n=> Training Epoch #%d, LR=%.4f' % (epoch, learning_rate(config.lr, epoch))) train(epoch, model, criterion, optimizer, trainloader, use_gpu) #if config.stepsize > 0: scheduler.step() rank1 = test(model, testloader, use_gpu) rank1 = test(model, testloader, use_gpu) if use_gpu: state_dict = model.module.state_dict() else: state_dict = model.state_dict() print('save model', save_path) torch.save(state_dict, save_path) #print("==> Hamming Score {:.3%}".format(rank1)) elapsed = round(time.time() - start_time) print("Finished. Training time (h:m:s): {}.".format(elapsed))
def pred(data, save_path, return_feature=False): torch.manual_seed(config.seed) os.environ['CUDA_VISIBLE_DEVICES'] = config.gpu_devices use_gpu = torch.cuda.is_available() if config.use_cpu: use_gpu = False if use_gpu: print("Currently using GPU {}".format(config.gpu_devices)) cudnn.benchmark = True torch.cuda.manual_seed_all(config.seed) else: print("Currently using CPU (GPU is highly recommended)") if config.dataset == 'mnist': transform_test = T.Compose([ T.Resize((config.height, config.width)), T.ToTensor(), T.Normalize(mean=[0.1307], std=[0.3081]), ]) else: transform_test = T.Compose([ T.ToPILImage(), T.Resize((config.height, config.width)), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) pin_memory = True if use_gpu else False testloader = DataLoader( ImageDataset(data, transform=transform_test), batch_size=512, shuffle=False, num_workers=config.workers, pin_memory=pin_memory, drop_last=False, ) model = models.init_model(name=config.arch, num_classes=config.nb_labels, loss={'xent'}, use_gpu=use_gpu) checkpoint = torch.load(save_path) model.load_state_dict(checkpoint) if use_gpu: model = nn.DataParallel(model).cuda() model.eval() with torch.no_grad(): hamming_score, pred_list, feature_list = [], [], [] float_logit_list = [] for batch_idx, (imgs) in enumerate(testloader): if use_gpu: imgs = imgs.cuda() if batch_idx % 50 == 0: print('batch {}/{}', batch_idx, len(testloader)) end = time.time() features, predA = model(imgs) predA = predA.cpu() #print('features shape {} predA shape'.format(features.shape, predA.shape)) float_logit_list.append(torch.sigmoid(predA)) if return_feature is True: feature_list.append(features.cpu()) _, predicted = torch.max(predA.data, 1) #print('predAs', predicted) pred_list.append(predicted) predA_t = (((torch.cat(pred_list, 0)).float()).numpy()).tolist() predA_t = np.array(predA_t) #float_logit_list = (((torch.cat(float_logit_list, 0)).float()).numpy()).tolist() #float_logit_list = np.array(float_logit_list) if return_feature == True: feature_list = (((torch.cat(feature_list, 0)).float()).numpy()).tolist() feature_list = np.array(feature_list) return feature_list return predA_t else: return predA_t
def detect_mask(self): # detect whether the face is wearing a mask box = self.box.astype(np.int) people_size = abs(box[2] - box[0]) * abs(box[3] - box[1]) # model_mask.eval() # prepare face slice data global_face_loc = (self.face_loc).astype(np.int) box = global_face_loc face_size = abs(box[2] - box[0]) * abs(box[3] - box[1]) # if (face_size/people_size > 1): # model_mask = self.model_mask[1] # use_soft = True # else: # model_mask = self.model_mask[0] # use_soft = False # print(global_face_loc) img = self.frame_orig face_slice = img[global_face_loc[1]:global_face_loc[3], global_face_loc[0]:global_face_loc[2], :] # face_slice = np.floor(face_slice * 255).astype(np.uint8) face_slice = face_slice.astype(np.uint8) size_grads = [14, 28, 56, 112, 224] def argmin_dist(img_size) -> int: H, W = img_size min_dist = 2**32 out_size = None for size_cand in size_grads: cur_dist = abs(H - size_cand) + abs(W - size_cand) if min_dist > cur_dist: out_size = size_cand min_dist = cur_dist return out_size if min(face_slice.shape[:2]) < 40: out_size = 4 * argmin_dist(face_slice.shape[:2]) model_mask = self.model_mask[1] # use small face model else: out_size = argmin_dist(face_slice.shape[:2]) model_mask = self.model_mask[0] # use big face model # out_size = argmin_dist(face_slice.shape[:2]) # if out_size==14 or out_size==28: # # model_mask = self.model_mask[1] # use small face model # out_size = 4*out_size # else: # # model_mask = self.model_mask[0] # use large face model # out_size = out_size # model_mask = self.model_mask[0] # use large face model only transformations = T.Compose([ T.ToPILImage(), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), T.Resize((out_size, out_size)) ]) # transformations = Compose([ # ToPILImage(), # Resize(256), # CenterCrop(224), # ToTensor(), # Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225]), # ]) # soft = Softmax() # if use_soft: # prob_mask = soft(model_mask(transformations(face_slice).unsqueeze(0).to(device)))[0,1] # probability of wearing a mask #else: soft = nn.Softmax(dim=1) prob_mask = soft( model_mask(transformations(face_slice).unsqueeze(0).to(device)))[0, 1] prob_mask = prob_mask.data.cpu().numpy() #print(prob_mask) return prob_mask
transforms.Lambda(lambda x: x[torch.LongTensor([2, 1, 0])]), # turn to BGR transforms.Normalize( mean=[0.40760392, 0.45795686, 0.48501961], # subtract imagenet mean std=[1, 1, 1]), transforms.Lambda(lambda x: x.mul_(255)), ]) postpa = transforms.Compose([ transforms.Lambda(lambda x: x.mul_(1. / 255)), transforms.Normalize( mean=[-0.40760392, -0.45795686, -0.48501961], # add imagenet mean std=[1, 1, 1]), transforms.Lambda(lambda x: x[torch.LongTensor([2, 1, 0])]), # turn to RGB ]) mask_tf = transforms.Compose([ToUnNormalizedTensor()]) postpb = transforms.Compose([transforms.ToPILImage()]) def postp(tensor): # to clip results in the range [0,1] t = post_tensor(tensor) img = postpb(t) return img # return t def post_tensor(tensor): t = postpa(tensor) t[t > 1] = 1 t[t < 0] = 0 return t
def main(): global best_prec1 best_prec1 = 0 global val_acc val_acc = [] global class_num class_num = args.dataset == 'cifar10' and 10 or 100 normalize = transforms.Normalize( mean=[x / 255.0 for x in [125.3, 123.0, 113.9]], std=[x / 255.0 for x in [63.0, 62.1, 66.7]]) if args.augment: if args.autoaugment: print('Autoaugment') transform_train = transforms.Compose([ transforms.ToTensor(), transforms.Lambda(lambda x: F.pad(x.unsqueeze(0), (4, 4, 4, 4), mode='reflect').squeeze()), transforms.ToPILImage(), transforms.RandomCrop(32), transforms.RandomHorizontalFlip(), CIFAR10Policy(), transforms.ToTensor(), Cutout(n_holes=args.n_holes, length=args.length), normalize, ]) elif args.cutout: print('Cutout') transform_train = transforms.Compose([ transforms.ToTensor(), transforms.Lambda(lambda x: F.pad(x.unsqueeze(0), (4, 4, 4, 4), mode='reflect').squeeze()), transforms.ToPILImage(), transforms.RandomCrop(32), transforms.RandomHorizontalFlip(), transforms.ToTensor(), Cutout(n_holes=args.n_holes, length=args.length), normalize, ]) else: print('Standrad Augmentation!') transform_train = transforms.Compose([ transforms.ToTensor(), transforms.Lambda(lambda x: F.pad(x.unsqueeze(0), (4, 4, 4, 4), mode='reflect').squeeze()), transforms.ToPILImage(), transforms.RandomCrop(32), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ]) else: transform_train = transforms.Compose([ transforms.ToTensor(), normalize, ]) transform_test = transforms.Compose([transforms.ToTensor(), normalize]) kwargs = {'num_workers': 1, 'pin_memory': True} assert (args.dataset == 'cifar10' or args.dataset == 'cifar100') train_loader = torch.utils.data.DataLoader( datasets.__dict__[args.dataset.upper()]('../data', train=True, download=True, transform=transform_train), batch_size=training_configurations[args.model]['batch_size'], shuffle=True, **kwargs) val_loader = torch.utils.data.DataLoader( datasets.__dict__[args.dataset.upper()]('../data', train=False, transform=transform_test), batch_size=training_configurations[args.model]['batch_size'], shuffle=True, **kwargs) # create model if args.model == 'resnet': model = eval('networks.resnet.resnet' + str(args.layers) + '_cifar')(dropout_rate=args.droprate) elif args.model == 'se_resnet': model = eval('networks.se_resnet.resnet' + str(args.layers) + '_cifar')(dropout_rate=args.droprate) elif args.model == 'wideresnet': model = networks.wideresnet.WideResNet(args.layers, args.dataset == 'cifar10' and 10 or 100, args.widen_factor, dropRate=args.droprate) elif args.model == 'se_wideresnet': model = networks.se_wideresnet.WideResNet( args.layers, args.dataset == 'cifar10' and 10 or 100, args.widen_factor, dropRate=args.droprate) elif args.model == 'densenet_bc': model = networks.densenet_bc.DenseNet( growth_rate=args.growth_rate, block_config=(int((args.layers - 4) / 6), ) * 3, compression=args.compression_rate, num_init_features=24, bn_size=args.bn_size, drop_rate=args.droprate, small_inputs=True, efficient=False) elif args.model == 'shake_pyramidnet': model = networks.shake_pyramidnet.PyramidNet(dataset=args.dataset, depth=args.layers, alpha=args.alpha, num_classes=class_num, bottleneck=True) elif args.model == 'resnext': if args.cardinality == 8: model = networks.resnext.resnext29_8_64(class_num) if args.cardinality == 16: model = networks.resnext.resnext29_16_64(class_num) elif args.model == 'shake_shake': if args.widen_factor == 112: model = networks.shake_shake.shake_resnet26_2x112d(class_num) if args.widen_factor == 32: model = networks.shake_shake.shake_resnet26_2x32d(class_num) if args.widen_factor == 96: model = networks.shake_shake.shake_resnet26_2x32d(class_num) elif args.model == 'shake_shake_x': model = networks.shake_shake.shake_resnext29_2x4x64d(class_num) if not os.path.isdir(check_point): mkdir_p(check_point) fc = Full_layer(int(model.feature_num), class_num) print('Number of final features: {}'.format(int(model.feature_num))) print('Number of model parameters: {}'.format( sum([p.data.nelement() for p in model.parameters()]) + sum([p.data.nelement() for p in fc.parameters()]))) cudnn.benchmark = True # define loss function (criterion) and optimizer isda_criterion = ISDALoss(int(model.feature_num), class_num).cuda() ce_criterion = nn.CrossEntropyLoss().cuda() optimizer = torch.optim.SGD( [{ 'params': model.parameters() }, { 'params': fc.parameters() }], lr=training_configurations[args.model]['initial_learning_rate'], momentum=training_configurations[args.model]['momentum'], nesterov=training_configurations[args.model]['nesterov'], weight_decay=training_configurations[args.model]['weight_decay']) model = torch.nn.DataParallel(model).cuda() fc = nn.DataParallel(fc).cuda() if args.resume: # Load checkpoint. print('==> Resuming from checkpoint..') assert os.path.isfile( args.resume), 'Error: no checkpoint directory found!' args.checkpoint = os.path.dirname(args.resume) checkpoint = torch.load(args.resume) start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) fc.load_state_dict(checkpoint['fc']) optimizer.load_state_dict(checkpoint['optimizer']) isda_criterion = checkpoint['isda_criterion'] val_acc = checkpoint['val_acc'] best_prec1 = checkpoint['best_acc'] np.savetxt(accuracy_file, np.array(val_acc)) else: start_epoch = 0 for epoch in range(start_epoch, training_configurations[args.model]['epochs']): adjust_learning_rate(optimizer, epoch + 1) # train for one epoch train(train_loader, model, fc, isda_criterion, optimizer, epoch) # evaluate on validation set prec1 = validate(val_loader, model, fc, ce_criterion, epoch) # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'fc': fc.state_dict(), 'best_acc': best_prec1, 'optimizer': optimizer.state_dict(), 'isda_criterion': isda_criterion, 'val_acc': val_acc, }, is_best, checkpoint=check_point) print('Best accuracy: ', best_prec1) np.savetxt(accuracy_file, np.array(val_acc)) print('Best accuracy: ', best_prec1) print('Average accuracy', sum(val_acc[len(val_acc) - 10:]) / 10) # val_acc.append(sum(val_acc[len(val_acc) - 10:]) / 10) # np.savetxt(val_acc, np.array(val_acc)) np.savetxt(accuracy_file, np.array(val_acc))
def get_transform_eval(): transforms = [] transforms.append(T.ToTensor()) transforms.append(T.ToPILImage()) return T.Compose(transforms)