def mnist_aug_loader(train_size, test_size, args): transform_train = transforms.Compose([ transforms.RandomCrop(28, padding=4), # https://github.com/hwalsuklee/tensorflow-mnist-cnn/blob/master/mnist_data.py #transforms.RandomAffine(translate=0.12), transforms.RandomRotation((-15, 15)), transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )), #transforms.RandomErasing(probability=args.p, sh=args.sh, r1=args.r1, mean=[0.4914]), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )), ]) trainset = datasets.MNIST('./data/MNIST', train=True, download=True, transform=transform_train) train_loader = data.DataLoader(trainset, batch_size=train_size, shuffle=True) testset = datasets.MNIST(root='./data/MNIST', train=False, download=False, transform=transform_test) test_loader = data.DataLoader(testset, batch_size=test_size, shuffle=False) return train_loader, test_loader
def fashion_mnist_aug_loader(train_size, test_size, args): transform_train = transforms.Compose([ transforms.RandomCrop(28, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )), transforms.RandomErasing(probability=args.p, sh=args.sh, r1=args.r1, mean=[0.4914]), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )), ]) trainset = datasets.FashionMNIST('./data/MNIST-FASHION', train=True, download=True, transform=transform_train) train_loader = data.DataLoader(trainset, batch_size=train_size, shuffle=True) testset = datasets.FashionMNIST(root='./data/MNIST-FASHION', train=False, download=False, transform=transform_test) test_loader = data.DataLoader(testset, batch_size=test_size, shuffle=False) return train_loader, test_loader
def train(args): train_transforms = transforms.Compose([ transforms.Resize(args.image_shape), transforms.RandomHorizontalFlip(), transforms.Normalize() ]) eval_transforms = transforms.Compose( [transforms.Resize(args.image_shape), transforms.Normalize()]) train_dataset = Dataset( data_dir=args.data_dir, file_list=args.train_list, transforms=train_transforms, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=True) eval_dataset = None if args.val_list is not None: eval_dataset = Dataset( data_dir=args.data_dir, file_list=args.val_list, transforms=eval_transforms, num_workers='auto', buffer_size=100, parallel_method='thread', shuffle=False) if args.model_type == 'HumanSegMobile': model = HumanSegMobile(num_classes=2) elif args.model_type == 'HumanSegLite': model = HumanSegLite(num_classes=2) elif args.model_type == 'HumanSegServer': model = HumanSegServer(num_classes=2) else: raise ValueError( "--model_type: {} is set wrong, it shold be one of ('HumanSegMobile', " "'HumanSegLite', 'HumanSegServer')".format(args.model_type)) model.train( num_epochs=args.num_epochs, train_dataset=train_dataset, train_batch_size=args.batch_size, eval_dataset=eval_dataset, save_interval_epochs=args.save_interval_epochs, save_dir=args.save_dir, pretrained_weights=args.pretrained_weights, resume_weights=args.resume_weights, learning_rate=args.learning_rate, use_vdl=args.use_vdl)
def build_model(self): """ DataLoader """ train_transform = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.Resize((self.img_size + 30, self.img_size + 30)), transforms.RandomCrop(self.img_size), transforms.ToTensor(), transforms.Normalize(mean=0.5, std=0.5) ]) test_transform = transforms.Compose([ transforms.Resize((self.img_size, self.img_size)), transforms.ToTensor(), transforms.Normalize(mean=0.5, std=0.5) ]) self.trainA_loader = paddle.batch( a_reader(shuffle=True, transforms=train_transform), self.batch_size)() self.trainB_loader = paddle.batch( b_reader(shuffle=True, transforms=train_transform), self.batch_size)() self.testA_loader = a_test_reader(transforms=test_transform) self.testB_loader = b_test_reader(transforms=test_transform) """ Define Generator, Discriminator """ self.genA2B = ResnetGenerator(input_nc=3, output_nc=3, ngf=self.ch, n_blocks=self.n_res, img_size=self.img_size, light=self.light) self.genB2A = ResnetGenerator(input_nc=3, output_nc=3, ngf=self.ch, n_blocks=self.n_res, img_size=self.img_size, light=self.light) self.disGA = Discriminator(input_nc=3, ndf=self.ch, n_layers=7) self.disGB = Discriminator(input_nc=3, ndf=self.ch, n_layers=7) self.disLA = Discriminator(input_nc=3, ndf=self.ch, n_layers=5) self.disLB = Discriminator(input_nc=3, ndf=self.ch, n_layers=5) """ Define Loss """ self.L1_loss = L1Loss() self.MSE_loss = MSELoss() self.BCE_loss = BCEWithLogitsLoss() """ Trainer """ self.G_optim = self.optimizer_setting(self.genA2B.parameters() + self.genB2A.parameters()) self.D_optim = self.optimizer_setting(self.disGA.parameters() + self.disGB.parameters() + self.disLA.parameters() + self.disLB.parameters()) """ Define Rho clipper to constraint the value of rho in AdaILN and ILN""" self.Rho_clipper = RhoClipper(0, 1)
def __init__(self, args, use_gpu): super(DataManager, self).__init__() self.args = args self.use_gpu = use_gpu print("Initializing dataset {}".format(args.dataset)) dataset = mini_dataset.miniImageNet_load() transform_train = T.Compose([ T.RandomCrop(84, padding=8), T.RandomHorizontalFlip(), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) transform_test = T.Compose([ 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 self.trainloader = DataLoader( sample_train.FewShotDataset_train(name='train_loader', dataset=dataset.train, labels2inds=dataset.train_labels2inds, labelIds=dataset.train_labelIds, nKnovel=args.nKnovel, nExemplars=args.nExemplars, nTestNovel=args.train_nTestNovel, epoch_size=args.train_epoch_size, transform=transform_train, load=args.load, ), batch_size=args.train_batch, shuffle=True, num_workers=args.workers, pin_memory=pin_memory, drop_last=True, ) self.testloader = DataLoader( sample_test.FewShotDataset_test(name='test_loader', dataset=dataset.test, labels2inds=dataset.test_labels2inds, labelIds=dataset.test_labelIds, nKnovel=args.nKnovel, nExemplars=args.nExemplars, nTestNovel=args.nTestNovel, epoch_size=args.epoch_size, transform=transform_test, load=args.load, ), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=pin_memory, drop_last=False, )
def build_dataset(path_to_imgs, path_to_json_train, path_to_json_test): data_transforms = { 'train': transforms.Compose([ transforms.Resize(256), transforms.CustomCrop(), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'val': transforms.Compose([ transforms.Resize(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) } TID_train = TIDLoader(path_to_imgs, path_to_json_train, data_transforms['train']) TID_test = TIDLoader(path_to_imgs, path_to_json_test, data_transforms['val']) """ Since ground truth distributions were in train-test split (no val data), train data is split in two parts.Only 76 % of original train data is used for training, remaining is added to original test data. THis test data is then split into validation and test data. In short, the total number of images available in TID2013 (3k) are split in a ratio of 70-20-10 (train-val-test). """ train_len = len(TID_train) idx = list(range(train_len)) random.shuffle(idx) split_idx = idx[:int(0.76 * train_len)] train_split = Subset(TID_train, split_idx) split_idx = idx[int(0.76 * train_len):] train_val_split = Subset(TID_train, split_idx) val_split = ConcatDataset([train_val_split, TID_test]) val_len = len(val_split) val_idx = list(range(val_len)) random.shuffle(val_idx) val_split_idx = val_idx[:int(0.75 * val_len)] final_val_split = Subset(val_split, val_split_idx) test_split_idx = val_idx[int(0.75 * val_len):] test_split = Subset(val_split, test_split_idx) return train_split, final_val_split, test_split
def get(args): """ Entry point. Call this function to get all Charades dataloaders """ normalize = arraytransforms.Normalize(mean=[0.502], std=[1.0]) train_file = args.train_file val_file = args.val_file train_dataset = Charadesflow(args.data, 'train', train_file, args.cache, transform=transforms.Compose([ arraytransforms.RandomResizedCrop(224), arraytransforms.ToTensor(), normalize, transforms.Lambda(lambda x: torch.cat(x)), ])) val_transforms = transforms.Compose([ arraytransforms.Resize(256), arraytransforms.CenterCrop(224), arraytransforms.ToTensor(), normalize, transforms.Lambda(lambda x: torch.cat(x)), ]) val_dataset = Charadesflow(args.data, 'val', val_file, args.cache, transform=val_transforms) valvideo_dataset = Charadesflow(args.data, 'val_video', val_file, args.cache, transform=val_transforms) return train_dataset, val_dataset, valvideo_dataset
def __init__(self, file_path, transform=None, downsampling=2, phase='train', store_img_infor_root=None, store_matrix_root=None, store_baseline_root=None, store_focal_root=None, interval=1): self.file_path = file_path self.transform = transform self.downsampling = downsampling self.store_img_infor_root = store_img_infor_root self.store_matrix_root = store_matrix_root self.store_baseline_root = store_baseline_root self.store_focal_root = store_focal_root self.phase = phase self.interval = interval self.valid_transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]) if self.store_matrix_root is None: self.store_matrix_root = './{}_repro_matrixes.npz'.format(self.phase) if self.store_img_infor_root is None: self.store_img_infor_root = './{}_imgs_path.csv'.format(self.phase) if self.store_baseline_root is None: self.store_baseline_root = './{}_baselines.npy'.format(self.phase) if self.store_focal_root is None: self.store_focal_root = './{}_focal.npy'.format(self.phase) if os.path.exists(self.store_img_infor_root) and os.path.exists(self.store_matrix_root) and os.path.exists(self.store_baseline_root) and os.path.exists(self.store_focal_root): pass else: print("No Image information csv!!!") exit() self.rec_imgs_and_gts_names = pd.read_csv(self.store_img_infor_root) # self.reprojecton_matrixs = np.load(self.store_matrix_root, allow_pickle=True) baseline = np.load(self.store_baseline_root) self.baseline = baseline.tolist() focal = np.load(self.store_focal_root) self.focal = focal.tolist()
def get_transform(train): base_size = 520 crop_size = 480 min_size = int((0.5 if train else 1.0) * base_size) max_size = int((2.0 if train else 1.0) * base_size) transforms = [] transforms.append(T.RandomResize(min_size, max_size)) if train: transforms.append( T.RandomColorJitter(brightness=0.25, contrast=0.25, saturation=0.25, hue=0.25)) transforms.append(T.RandomGaussianSmoothing(radius=[0, 5])) transforms.append(T.RandomRotation(degrees=30, fill=0)) transforms.append(T.RandomHorizontalFlip(0.5)) transforms.append(T.RandomPerspective(fill=0)) transforms.append(T.RandomCrop(crop_size, fill=0)) transforms.append(T.RandomGrayscale(p=0.1)) transforms.append(T.ToTensor()) transforms.append( T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])) return T.Compose(transforms)
def main(): normalize = trans.Normalize(mean=[0.4001, 0.4401, 0.4687], std=[0.229, 0.224, 0.225]) transform = trans.Compose([ trans.Scale((224,224)), trans.ToTensor(), normalize, ]) classes = {int(key): value for (key, value) in parse_json(configs.class_info_dir).items()} vgg_cam = models.vgg_cam() vgg_cam = vgg_cam.cuda() checkpoint = torch.load(configs.best_ckpt_dir) vgg_cam.load_state_dict(checkpoint['state_dict']) # hook the feature extractor features_blobs = [] def hook_feature(module, input, output): features_blobs.append(output.data.cpu().numpy()) finalconv_name = 'classifier' # this is the last conv layer of the network vgg_cam._modules.get(finalconv_name).register_forward_hook(hook_feature) # get the softmax weight params = list(vgg_cam.parameters()) weight_softmax = np.squeeze(params[-1].data.cpu().numpy()) img_path = 'playing_guitar_023.jpg' save_fig_dir = 'cam_' + img_path img_pil = Image.open(img_path) img_tensor = transform(img_pil) img_variable = Variable(img_tensor.unsqueeze(0).cuda()) transformed_img = img_variable.data.cpu().numpy()[0] transformed_img = untransform(transformed_img) outputs, _ = vgg_cam(img_variable) h_x = F.softmax(outputs).data.squeeze() probs, idx = h_x.sort(0, True) top_number = 5 prob = probs.cpu().numpy()[:top_number] idx_ = idx.cpu().numpy()[:top_number] OUT_CAM = returnCAM(features_blobs[-1],weight_softmax,idx_,prob) plt.figure(1, figsize=(8, 6)) ax = plt.subplot(231) ax.imshow(transformed_img[:,:,(2,1,0)]) for b_index, (idx,prob_in,cam) in enumerate(zip(idx_,prob,OUT_CAM)): cl = str(classes[idx]) height, width, _ = transformed_img.shape heatmap = cv2.applyColorMap(cv2.resize(cam, (width, height)), cv2.COLORMAP_JET) result = heatmap * 0.3 + transformed_img * 0.7 ax = plt.subplot(2,3,b_index+2) ax.imshow(result.astype(np.uint8)[:,:,(2,1,0)]) ax.set_title(('{}:{}').format(cl,('%.3f' % prob_in)), fontsize=8) plt.savefig(save_fig_dir)
def main(cfgs): trans_in_train = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) dataset_train = data.dataset(cfgs, flag='train', trans=trans_in_train) trainer.trainer(cfgs, dataset_train)
def get_iterator(mode): 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]]) kwargs = {'num_workers': 4, 'pin_memory': True} transform_augment = transforms.Compose([ # transforms.RandomResizedCrop(args.size, scale=(0.8, 1.2)), # random scale 0.8-1 of original image area, crop to args.size transforms.RandomResizedCrop(size), transforms.RandomRotation(15), # random rotation -15 to +15 degrees transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ]) transform = transforms.Compose([transforms.Resize((size, size)), transforms.ToTensor(), normalize, ]) if mode: dataset = Dataset.MURA(split="train", transform=(transform_augment if augment else transform), type=type) loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True, **kwargs) else: dataset = Dataset.MURA(split="test", transform=transform, type=type) loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=False, **kwargs) return loader
def get_transforms(train=False, rescale_size=(256, 256), yolo=False): transforms = [] if train: transforms.append(my_T.Rescale(rescale_size, yolo)) transforms.append(my_T.Normalize()) transforms.append(my_T.ToTensor()) return my_T.Compose(transforms)
def get_transform(): transforms = [] transforms.append(T.ToTensor()) transforms.append( T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])) return T.Compose(transforms)
def make_dataset_dataloader(args, jsons, spk2genders, split='train'): if split == 'train': load_dir = os.path.join(args.temp_root, args.bucket_load_dir) else: load_dir = None gender_dataset = gender_subset.ESPnetGenderBucketDataset( os.path.join(args.temp_root, jsons[split]), os.path.join(args.temp_root, args.tok_file), os.path.join(args.temp_root, spk2genders[split]), load_dir=load_dir, num_buckets=args.n_buckets) if args.normalize == 'utt': gender_dataset.transform = transforms.Normalize() elif args.normalize == 'spk': gender_dataset.transform = transforms.SpeakerNormalize( os.path.join(args.temp_root, args.bucket_load_dir, f'{split}_stats/spk2meanstd.pkl')) elif args.normalize == 'gndr': gender_dataset.transform = transforms.GenderNormalize( os.path.join(args.temp_root, args.bucket_load_dir, f'{split}_stats/gndr2meanstd.pkl'), gender_dataset.utt2gender) gender_dataloader = torch.utils.data.DataLoader( gender_dataset, batch_sampler=dataset.BucketBatchSampler( shuffle=True, batch_size=args.batch_size, utt2idx=gender_dataset.utt2idx, buckets=gender_dataset.buckets), collate_fn=dataset.collate) return gender_dataset, gender_dataloader
def get_transform(train, resolution): transforms = [] # if square resolution, perform some aspect cropping # otherwise, resize to the resolution as specified if resolution[0] == resolution[1]: base_size = resolution[0] + 32 crop_size = resolution[0] min_size = int((0.5 if train else 1.0) * base_size) max_size = int((2.0 if train else 1.0) * base_size) transforms.append(T.RandomResize(min_size, max_size)) # during training mode, perform some data randomization if train: transforms.append(T.RandomHorizontalFlip(0.5)) transforms.append(T.RandomCrop(crop_size)) else: # transforms.append(T.Resize(resolution)) if train: transforms.append(T.RandomHorizontalFlip(0.5)) transforms.append(T.ToTensor()) transforms.append( T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])) return T.Compose(transforms)
def _setup_dataloaders(root_dir, return_dataset=False): """ Setup dataloaders. """ preprocessing = [ aug.NormalizeBboxes(cfg.grid_size), aug.Bboxes2Matrices(cfg.grid_size, cfg.num_classes), aug.Resize(cfg.target_size), aug.Normalize(cfg.mean, cfg.std, 1. / 255), aug.ToTensor() ] transforms_train = preprocessing transforms_val = preprocessing ds_train = VOCDataset(root_dir, image_set="train") dl_train = get_dataloader(ds_train, transforms_train, cfg.batch_size, num_workers=4) ds_val = VOCDataset(root_dir, image_set="val") dl_val = get_dataloader(ds_val, transforms_val, cfg.batch_size) if return_dataset: return dl_train, dl_val, ds_train, ds_val return dl_train, dl_val
def get_data(data_dir, source, target, height, width, batch_size, re=0, workers=8): # def get_data(height, width): dataset = IU_X_RAY('./dataset/') normalizer = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_transformer = T.Compose([ T.Resize((height, width), interpolation=3), T.ToTensor(), normalizer, ]) train_sampler = MRG_sampler(dataset.source_train, root=dataset.train_images_dir, transform=train_transformer) val_sampler = MRG_sampler(dataset.source_valid, root=dataset.valid_images_dir, transform=train_transformer) test_sampler = MRG_sampler(dataset.source_test, root=dataset.test_images_dir, transform=train_transformer) mesh_term_list = list( set(train_sampler.mesh_term_list) & set(test_sampler.mesh_term_list)) train_sampler.mesh_term_list = mesh_term_list test_sampler.mesh_term_list = mesh_term_list print('mesh_term:' + str(len(mesh_term_list))) train_dataloader = DataLoader(train_sampler, batch_size=batch_size, num_workers=workers, shuffle=True, pin_memory=True, drop_last=True) val_dataloader = DataLoader(val_sampler, batch_size=batch_size, num_workers=workers, shuffle=True, pin_memory=True, drop_last=True) test_dataloader = DataLoader(test_sampler, batch_size=batch_size, num_workers=workers, shuffle=True, pin_memory=True, drop_last=True) return dataset, mesh_term_list, train_dataloader, val_dataloader, test_dataloader
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 main(): # frames to infer files = [ "C:\\AML_seg_proj\\CRC-Segmentation\\data\\test\\frames\\frame#1058.npz", "C:\\AML_seg_proj\\CRC-Segmentation\\data\\test\\frames\\frame#139.npz", "C:\\AML_seg_proj\\CRC-Segmentation\\data\\test\\frames\\frame#26.npz" ] chkpt = "C:\\AML_seg_proj\\CRC-Segmentation\\model_large_drop_batch_wce\\model_chkpt_30.pt" # transforms to apply composed = Compose([ transforms.MirrorPad(((6, ), (6, ), (0, ))), transforms.ToTensor(), transforms.Normalize(means=(0.7942, 0.6693, 0.7722), stds=(0.1998, 0.3008, 0.2037)) ]) # model #model = UNet((512, 512), (500, 500), 32, 64, 128, 256, 512, droprate=0.5, Norm=torch.nn.BatchNorm2d) model = UNet((512, 512), (500, 500), 32, 64, 128, 256, 512, droprate=0.5, Norm=torch.nn.BatchNorm2d) model.load_state_dict(torch.load(chkpt, map_location='cpu')) model.eval() # evaluate metrics on the fly dice_sc, px_acc = Dice_Score(), Pixel_Accuracy((500, 500)) # make predictions and write images and masks to disk as png files with torch.no_grad(): for file in files: # load img, mask img, ground_truth = np.load(file)["arr_0"], np.load( file.replace("frame", "mask"))["arr_0"] img_copy = img.copy() # transform img img, ground_truth = composed([img, ground_truth]) # prediction shape (1, 3, 500, 500) pred = model(img.unsqueeze(0)) dice, pp_acc = dice_sc(pred, ground_truth.unsqueeze(0)), px_acc( pred, ground_truth.unsqueeze(0)) print(f"Dice Score: {dice}, PP-Accuracy: {pp_acc}") # mask shape (1, 500, 500) mask = (torch.argmax(F.softmax(pred, dim=1), dim=1).squeeze(0).numpy() / 2 * 255).astype( np.uint8) # prep image for writing, shape (1, 3, 512, 512) img = (img.squeeze(0).numpy() * 255).astype(np.uint8) identifier = file.split("\\")[-1].replace(".npz", ".png").replace( "#", "_") w_PNG(identifier=identifier, np_img=img_copy) w_PNG(identifier=identifier.replace("frame", "mask"), np_img=mask) plot_triple(img_copy, ground_truth, mask, identifier.replace(".png", "_triple.png"))
def __init__(self, batch_size, use_gpu, num_workers): transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) pin_memory = True if use_gpu else False trainset = torchvision.datasets.MNIST(root='./data/mnist', train=True, download=True, transform=transform) trainloader = torch.utils.data.DataLoader( trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=pin_memory, ) testset = torchvision.datasets.MNIST(root='./data/mnist', train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader( testset, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=pin_memory, ) self.trainloader = trainloader self.testloader = testloader self.num_classes = 10
def make_lvis_transforms(image_set): normalize = T.Compose([ T.ToTensor(), T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) scales = [480, 512, 544, 576, 608, 640, 672, 704, 736, 768, 800] transform_train = T.Compose([ T.RandomHorizontalFlip(), T.RandomSelect( T.RandomResize(scales, max_size=1333), T.Compose([ T.RandomResize([400, 500, 600]), T.RandomCrop((384, 384)), T.RandomResize(scales, max_size=1333), ]), ), normalize, ]) transform_val = T.Compose( [T.RandomResize([800], max_size=1333), normalize]) transforms = { "train": transform_train, "trainval": transform_train, "val": transform_val, "test": transform_val, } return transforms[image_set]
def __init__(self, batch_size, use_gpu, num_workers): transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ]) pin_memory = True if use_gpu else False trainset = ImageFolder('/home/mg/code/data/GEI_B/train/', transform=transform, loader=gei_loader) trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=pin_memory) testset = ImageFolder('/home/mg/code/data/GEI_B/test/', transform=transform, loader=gei_loader) testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=pin_memory) self.trainloader = trainloader self.testloader = testloader self.num_classes = 62
def make_voc_transforms(image_set, remove_difficult): normalize = T.Compose([ T.ToTensor(), T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) transform_train = T.Compose([ T.RandomHorizontalFlip(), T.RandomSelect( T.RandomResize([400, 500, 600], max_size=1000), T.Compose([ T.RandomResize([400, 500, 600]), T.RandomCrop((384, 384)), T.RandomResize([400, 500, 600], max_size=1000), ]), ), normalize, T.RemoveDifficult(remove_difficult), ]) transform_val = T.Compose( [T.RandomResize([600], max_size=1000), normalize]) transforms = { "train": transform_train, "trainval": transform_train, "val": transform_val, "test": transform_val, } return transforms[image_set]
def get_data_loaders(train_batch_size, val_batch_size): normalize = transforms.Normalize(mean=torch.Tensor([0.5]), std=torch.Tensor([0.2])) train_transform = transforms.Compose([ transforms.RandomResizedCrop(256), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.ToTensor(), transforms.MultiplicativeGaussianNoise(1, 0.01), normalize ]) val_transform = transforms.Compose( [transforms.Resize((512, 512)), transforms.ToTensor(), normalize]) train_loader = DataLoader(DWTDataset('dataset', split='train', transform=train_transform), batch_size=train_batch_size, shuffle=True) val_loader = DataLoader(DWTDataset('dataset', split='valid', transform=val_transform), batch_size=val_batch_size, shuffle=False) return train_loader, val_loader
def get_transform(param): """ Transform input into required image shape""" if 'train' == param: transform_train = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomFlipLeftRight(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) return transform_train elif 'test' == param: transform_test = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) return transform_test
def main(check_model, mm=1): dataset = data_manager.init_img_dataset( root=args.root, name=args.dataset, split_id=args.split_id, cuhk03_labeled=args.cuhk03_labeled, cuhk03_classic_split=args.cuhk03_classic_split, ) transform_train = T.Compose([ T.Random2DTranslation(args.height, args.width), T.RandomHorizontalFlip(), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) transform_test = T.Compose([ T.Resize((args.height, args.width)), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) '''trainloader = DataLoader( ImageDataset(dataset.train, transform=transform_train), batch_size=args.train_batch, shuffle=True, num_workers=args.workers, pin_memory=pin_memory, drop_last=True, )''' query = ImageDataset(dataset.query, transform=transform_test) if args.dataset == 'beijing': query = ImageDataset_forBeijing(dataset.query, transform=transform_test) #gallery = ImageDatasetLazy(dataset.gallery, transform=transform_test) gallery = ImageDataset(dataset.gallery, transform=transform_test) if args.dataset == 'beijing': gallery = ImageDataset_forBeijing(dataset.gallery, transform=transform_test) if args.evaluate: #print("Evaluate only") if mm == 1: cost, recall, precision = test(query, gallery, check_model, mm) return cost, recall, precision else: cost, recall, precision, delay = test(query, gallery, check_model, mm) return cost, recall, precision, delay
def __init__(self): super().__init__() self.transforms = T.Compose([ T.PILToTensor(), T.ConvertImageDtype(torch.float32), T.Normalize(mean=0.5, std=0.5), # map [0, 1] into [-1, 1] T.ValidateModelInput(), ])
def __init__(self, base_size, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)): self.transforms = T.Compose([ T.RandomResize(base_size, base_size), T.ToTensor(), T.Normalize(mean=mean, std=std), ])
def get_transform(pixmean, pixstd): # Data transforms logging.info('==> Preparing data..') # Random Crop, Zero out, flip, scale, transform_train = transforms.Compose([ transforms.RandomCrop(CROPSIZE, padding=4), transforms.RandomHorizontalFlip(), transforms.RandomYFlip(), transforms.RandomZFlip(), transforms.ZeroOut(4), transforms.ToTensor(), transforms.Normalize((pixmean), (pixstd)), # need to cal mean and std, revise norm func ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((pixmean), (pixstd)), ]) return transform_train, transform_test