def test_transform(args, image): input_size1 = 512 input_size2 = 448 if int(args.subset) == 0 or int(args.subset) == 192: transform = transforms.Compose([ transforms.Resize(input_size1), transforms.CenterCrop(input_size2), transforms.Upscale(upscale_factor=2), transforms.TransformUpscaledDCT(), transforms.ToTensorDCT(), transforms.Aggregate(), transforms.NormalizeDCT( train_upscaled_static_mean, train_upscaled_static_std, ) ]) else: transform = transforms.Compose([ transforms.Resize(input_size1), transforms.CenterCrop(input_size2), transforms.Upscale(upscale_factor=2), transforms.TransformUpscaledDCT(), transforms.ToTensorDCT(), transforms.SubsetDCT(channels=args.subset), transforms.Aggregate(), transforms.NormalizeDCT(train_upscaled_static_mean, train_upscaled_static_std, channels=args.subset) ]) return transform
def trainloader_upscaled_static(args, model='mobilenet'): valdir = os.path.join(args.data, 'train') if model == 'mobilenet': input_size1 = 1024 input_size2 = 896 elif model == 'resnet': input_size1 = 512 input_size2 = 448 else: raise NotImplementedError if int(args.subset) == 0 or int(args.subset) == 192: transform = transforms.Compose([ enhance.random_crop(), enhance.horizontal_flip(), enhance.vertical_flip(), enhance.random_rotation(), enhance.tocv2(), transforms.Resize(input_size1), transforms.CenterCrop(input_size2), transforms.Upscale(upscale_factor=2), transforms.TransformUpscaledDCT(), transforms.ToTensorDCT(), transforms.Aggregate(), transforms.NormalizeDCT( train_upscaled_static_mean, train_upscaled_static_std, ) ]) else: transform = transforms.Compose([ enhance.random_crop(), enhance.horizontal_flip(), enhance.vertical_flip(), enhance.random_rotation(), enhance.tocv2(), transforms.Resize(input_size1), transforms.CenterCrop(input_size2), transforms.Upscale(upscale_factor=2), transforms.TransformUpscaledDCT(), transforms.ToTensorDCT(), transforms.SubsetDCT(channels=args.subset), transforms.Aggregate(), transforms.NormalizeDCT(train_upscaled_static_mean, train_upscaled_static_std, channels=args.subset) ]) dset = ImageFolderDCT(valdir, transform, backend='pil') val_loader = torch.utils.data.DataLoader(dset, batch_size=args.train_batch, shuffle=True, num_workers=args.workers, pin_memory=True) return val_loader, len(dset), dset.get_clsnum()
def trainloader_dct_subset(args): traindir = os.path.join(args.data, 'train') train_dataset = ImageFolderDCT(traindir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.TransformDCT(), transforms.ToTensorDCT(), transforms.SubsetDCT(args.subset_channels), transforms.NormalizeDCT( train_y_mean, train_y_std, train_cb_mean, train_cb_std, train_cr_mean, train_cr_std), ])) if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) else: train_sampler = None train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.train_batch, shuffle=(train_sampler is None), num_workers=args.workers, pin_memory=True, sampler=train_sampler) train_loader_len = len(train_loader) return train_loader, train_sampler, train_loader_len
def valloader_upscaled_static(args, model='mobilenet'): valdir = os.path.join(args.data, 'val') if model == 'mobilenet': input_size1 = 1024 input_size2 = 896 elif model == 'resnet': input_size1 = 512 input_size2 = 448 else: raise NotImplementedError transform = transforms.Compose([ transforms.Resize(input_size1), transforms.CenterCrop(input_size2), transforms.Upscale(upscale_factor=2), transforms.TransformUpscaledDCT(), transforms.ToTensorDCT(), transforms.SubsetDCT(channels=args.subset, pattern=args.pattern), transforms.Aggregate(), transforms.NormalizeDCT( train_upscaled_static_mean, train_upscaled_static_std, channels=args.subset, pattern=args.pattern ) ]) val_loader = torch.utils.data.DataLoader( ImageFolderDCT(valdir, transform), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=True) return val_loader
def trainloader_dct_resized(args): traindir = os.path.join(args.data, 'train') train_dataset = ImageFolderDCT(traindir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.TransformDCT(), # 28x28x192 transforms.DCTFlatten2D(), transforms.UpsampleDCT(upscale_ratio_h=4, upscale_ratio_w=4, debug=False), transforms.ToTensorDCT(), transforms.SubsetDCT(channels=args.subset), transforms.Aggregate(), transforms.NormalizeDCT( train_dct_subset_mean, train_dct_subset_std, channels=args.subset ) ])) if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) else: train_sampler = None train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.train_batch, shuffle=(train_sampler is None), num_workers=args.workers, pin_memory=True, sampler=train_sampler) train_loader_len = len(train_loader) return train_loader, train_sampler, train_loader_len
def test(model): # bar = Bar('Processing', max=len(val_loader)) # batch_time = AverageMeter() # data_time = AverageMeter() # losses = AverageMeter() # top1 = AverageMeter() # top5 = AverageMeter() # switch to evaluate mode model.eval() csvfile = open('./csv.csv', 'w') writer = csv.writer(csvfile) test_root = './data/test/' img_test = os.listdir(test_root) img_test.sort(key=lambda x: int(x[:-4])) input_size1 = 512 input_size2 = 448 transform = transforms.Compose([ transforms.Resize(input_size1), transforms.CenterCrop(input_size2), transforms.Upscale(upscale_factor=2), transforms.TransformUpscaledDCT(), transforms.ToTensorDCT(), transforms.SubsetDCT(channels=args.subset), transforms.Aggregate(), transforms.NormalizeDCT(train_upscaled_static_mean, train_upscaled_static_std, channels=args.subset) ]) with torch.no_grad(): # end = time.time() for i in range(len(img_test)): model.eval() # measure data loading time # data_time.update(time.time() - end) # image, target = image.cuda(non_blocking=True), target.cuda( # non_blocking=True) image = cv2.imread(str(test_root + img_test[i])) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # print(transform(image)[0]) # print(type(transform(image)[0])) # compute output output = model(transform(image)[0].unsqueeze(dim=0)) #print(output) _, pred = torch.max(output.data, 1) print(i, pred.tolist()[0]) writer.writerow([i, pred.tolist()[0]])
def folder2lmdb(dpath, name="train", write_frequency=1): directory = osp.expanduser(osp.join(dpath, name)) print("Loading dataset from %s" % directory) dataset = ImageFolderDCT('/ILSVRC2012/train', transforms.Compose([ transforms.DCTFlatten2D(), transforms.UpsampleDCT(upscale_ratio_h=4, upscale_ratio_w=4, debug=False), transforms.ToTensorDCT(), transforms.SubsetDCT(channels=32), ]), backend='dct') data_loader = torch.utils.data.DataLoader( dataset, num_workers=0, ) lmdb_path = osp.join(dpath, "%s.lmdb" % name) isdir = os.path.isdir(lmdb_path) print("Generate LMDB to %s" % lmdb_path) db = lmdb.open( lmdb_path, subdir=isdir, map_size=1281167 * 224 * 224 * 32 * 10, readonly=False, # map_size=1099511627776 * 2, readonly=False, meminit=False, map_async=True) txn = db.begin(write=True) for idx, (image, label) in enumerate(data_loader): image = image.numpy() label = label.numpy() txn.put(u'{}'.format(idx).encode('ascii'), dumps_pyarrow((bz2.compress(image), label))) if idx % write_frequency == 0: print("[%d/%d]" % (idx, len(data_loader))) txn.commit() txn = db.begin(write=True) # finish iterating through dataset txn.commit() keys = [u'{}'.format(k).encode('ascii') for k in range(idx + 1)] with db.begin(write=True) as txn: txn.put(b'__keys__', dumps_pyarrow(keys)) txn.put(b'__len__', dumps_pyarrow(len(keys))) print("Flushing database ...") db.sync() db.close()
def get_composed_transform_dct(self, aug=False, filter_size=8): # print("aug: ", aug) # print("filter size,", filter_size) if aug == False: transform = transforms_dct.Compose([ #transform_funcs, transforms_dct.Resize(int(filter_size * 56 * 1.15)), transforms_dct.CenterCrop(filter_size * 56), transforms_dct.GetDCT(filter_size), transforms_dct.UpScaleDCT(size=56), transforms_dct.ToTensorDCT(), transforms_dct.SubsetDCT(channels=24), transforms_dct.Aggregate(), transforms_dct.NormalizeDCT( # train_y_mean_resized, train_y_std_resized, # train_cb_mean_resized, train_cb_std_resized, # train_cr_mean_resized, train_cr_std_resized), train_upscaled_static_mean, train_upscaled_static_std, channels=24) #transforms_dct.Aggregate() ]) else: transform = transforms_dct.Compose([ #transform_funcs, transforms_dct.RandomResizedCrop(filter_size * 56), transforms_dct.ImageJitter(self.jitter_param), transforms_dct.RandomHorizontalFlip(), transforms_dct.GetDCT(filter_size), transforms_dct.UpScaleDCT(size=56), transforms_dct.ToTensorDCT(), transforms_dct.SubsetDCT(channels=24), transforms_dct.Aggregate(), transforms_dct.NormalizeDCT( # train_y_mean_resized, train_y_std_resized, # train_cb_mean_resized, train_cb_std_resized, # train_cr_mean_resized, train_cr_std_resized), train_upscaled_static_mean, train_upscaled_static_std, channels=24) ]) return transform
def cvt_transform(self, img): return cvtransforms.Compose([ cvtransforms.RandomResizedCrop(self.img_size), # cvtransforms.RandomHorizontalFlip(), cvtransforms.Upscale(upscale_factor=2), cvtransforms.TransformUpscaledDCT(), cvtransforms.ToTensorDCT(), cvtransforms.SubsetDCT(channels=192), cvtransforms.Aggregate(), cvtransforms.NormalizeDCT(train_upscaled_static_mean, train_upscaled_static_std, channels=192) ])(img)
def valloader_dct(args): valdir = os.path.join(args.data, 'val') val_loader = torch.utils.data.DataLoader( ImageFolderDCT(valdir, transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.TransformDCT(), transforms.ToTensorDCT(), transforms.NormalizeDCT( train_y_mean, train_y_std, train_cb_mean, train_cb_std, train_cr_mean, train_cr_std), ])), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=True) return val_loader
def trainloader_upscaled_static(args, model='mobilenet'): traindir = os.path.join(args.data, 'train') if model == 'mobilenet': input_size = 896 elif model == 'resnet': input_size = 448 else: raise NotImplementedError transform = transforms.Compose([ transforms.RandomResizedCrop(input_size), transforms.RandomHorizontalFlip(), transforms.Upscale(upscale_factor=2), transforms.TransformUpscaledDCT(), transforms.ToTensorDCT(), transforms.SubsetDCT(channels=args.subset, pattern=args.pattern), transforms.Aggregate(), transforms.NormalizeDCT( train_upscaled_static_mean, train_upscaled_static_std, channels=args.subset, pattern=args.pattern ) ]) train_dataset = ImageFolderDCT(traindir, transform) if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) else: train_sampler = None train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.train_batch, shuffle=(train_sampler is None), num_workers=args.workers, pin_memory=True, sampler=train_sampler) train_loader_len = len(train_loader) return train_loader, train_sampler, train_loader_len
def valloader_dct_resized(args): valdir = os.path.join(args.data, 'val') val_loader = torch.utils.data.DataLoader( ImageFolderDCT(valdir, transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.TransformDCT(), # 28x28x192 transforms.DCTFlatten2D(), transforms.UpsampleDCT(upscale_ratio_h=4, upscale_ratio_w=4, debug=False), transforms.ToTensorDCT(), transforms.SubsetDCT(channels=args.subset), transforms.Aggregate(), transforms.NormalizeDCT( train_dct_subset_mean, train_dct_subset_std, channels=args.subset ) ])), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=True) return val_loader
std=train_cb_std_resized) input_normalize_cr = transforms.Normalize(mean=train_cr_mean_resized, std=train_cr_std_resized) input_normalize.append(input_normalize_y) input_normalize.append(input_normalize_cb) input_normalize.append(input_normalize_cr) val_loader = torch.utils.data.DataLoader( # ImageFolderDCT('/mnt/ssd/kai.x/dataset/ILSVRC2012/val', transforms.Compose([ ImageFolderDCT( '/storage-t1/user/kaixu/datasets/ILSVRC2012/val', transforms.Compose([ transforms.ToYCrCb(), transforms.TransformDCT(), transforms.UpsampleDCT(T=896, debug=False), transforms.CenterCropDCT(112), transforms.ToTensorDCT(), transforms.NormalizeDCT(train_y_mean_resized, train_y_std_resized, train_cb_mean_resized, train_cb_std_resized, train_cr_mean_resized, train_cr_std_resized), ])), batch_size=1, shuffle=False, num_workers=1, pin_memory=False) # train_dataset = ImageFolderDCT('/mnt/ssd/kai.x/dataset/ILSVRC2012/train', transforms.Compose([ train_dataset = ImageFolderDCT( '/storage-t1/user/kaixu/datasets/ILSVRC2012/train',
def get_mean_and_std_dct(dataset, sublist=None): '''Compute the mean and std value of dataset.''' import datasets.cvtransforms as transforms # jpeg_encoder = TurboJPEG('/home/kai.x/work/local/lib/libturbojpeg.so') # Dataset = ImageFolderDCT(dataset, transforms.Compose([ # # transforms.RandomResizedCrop(224), # # # transforms.RandomHorizontalFlip(), # # transforms.TransformDCT(), # # transforms.UpsampleDCT(896), # # transforms.ToTensorDCT() # # # transforms.RandomResizedCrop(256), # # # transforms.RandomHorizontalFlip(), # # # transforms.TransformDCT(), # # # transforms.UpsampleDCT(256, 256), # # # transforms.CenterCropDCT(112), # # # transforms.ToTensorDCT() # # ])) # Dataset = ImageFolderDCT(dataset, transforms.Compose([ # transforms.Upscale(), # transforms.TransformDCT(), # transforms.ToTensorDCT(), # ])) Dataset = ImageFolderDCT(dataset, transforms.Compose([ transforms.DCTFlatten2D(), transforms.UpsampleDCT(upscale_ratio_h=4, upscale_ratio_w=4, debug=False), transforms.ToTensorDCT(), transforms.Average() ]), backend='dct') dataloader = torch.utils.data.DataLoader(Dataset, batch_size=1, pin_memory=True, shuffle=False, num_workers=0) mean_y, mean_cb, mean_cr = torch.zeros(64), torch.zeros(64), torch.zeros(64) std_y, std_cb, std_cr = torch.zeros(64), torch.zeros(64), torch.zeros(64) print('==> Computing mean and std..') end = time.time() if sublist is None: for i, (inputs_y, inputs_cb, inputs_cr, targets) in enumerate(dataloader): print('data time: {}'.format(time.time()-end)) print('{}/{}'.format(i, len(dataloader))) mean_y += inputs_y.mean(dim=0) std_y += inputs_y.std(dim=0) mean_cb += inputs_cb.mean(dim=0) std_cb += inputs_cb.std(dim=0) mean_cr += inputs_cr.mean(dim=0) std_cr += inputs_cr.std(dim=0) end = time.time() mean_y.div_(i+1) std_y.div_(i+1) mean_cb.div_(i+1) std_cb.div_(i+1) mean_cr.div_(i+1) std_cr.div_(i+1) else: dataloader_iterator = iter(dataloader) for i in range(sublist): try: inputs_y, inputs_cb, inputs_cr, targets = next(dataloader_iterator) except: print('error') print('{}/{}'.format(i, sublist)) for i in range(64): mean_y[i] += inputs_y[:, i, :, :].mean() std_y[i] += inputs_y[:, i, :, :].std() mean_cb[i] += inputs_cb[:, i, :, :].mean() std_cb[i] += inputs_cb[:, i, :, :].std() mean_cr[i] += inputs_cr[:, i, :, :].mean() std_cr[i] += inputs_cr[:, i, :, :].std() mean_y.div_(sublist) std_y.div_(sublist) mean_cb.div_(sublist) std_cb.div_(sublist) mean_cr.div_(sublist) std_cr.div_(sublist) return mean_y, std_y, mean_cb, std_cb, mean_cr, std_cr