def test_random_erasing(self): img = torch.rand(3, 60, 60) # Test Set 0: invalid value random_erasing = T.RandomErasing(value=(0.1, 0.2, 0.3, 0.4), p=1.0) with self.assertRaises(ValueError, msg="If value is a sequence, it should have either a single value or 3"): random_erasing(img) tensor, _ = self._create_data(24, 32, channels=3, device=self.device) batch_tensors = torch.rand(4, 3, 44, 56, device=self.device) test_configs = [ {"value": 0.2}, {"value": "random"}, {"value": (0.2, 0.2, 0.2)}, {"value": "random", "ratio": (0.1, 0.2)}, ] for config in test_configs: fn = T.RandomErasing(**config) scripted_fn = torch.jit.script(fn) self._test_transform_vs_scripted(fn, scripted_fn, tensor) self._test_transform_vs_scripted_on_batch(fn, scripted_fn, batch_tensors) with get_tmp_dir() as tmp_dir: scripted_fn.save(os.path.join(tmp_dir, "t_random_erasing.pt"))
def __init__(self, root, data_list_file, phase='train', input_shape=(1, 128, 128)): self.phase = phase self.input_shape = input_shape with open(os.path.join(data_list_file), 'r') as fd: imgs = fd.readlines() imgs = [os.path.join(root, img[:-1]) for img in imgs] self.imgs = np.random.permutation(imgs) # normalize = T.Normalize(mean=[0.5, 0.5, 0.5], # std=[0.5, 0.5, 0.5]) normalize = T.Normalize(mean=[0.5], std=[0.5]) if self.phase == 'train': self.transforms = T.Compose([ PadingWithLongerSize(), T.Resize(self.input_shape[1:]), # T.Grayscale(), T.ToTensor(), normalize, T.RandomErasing(), ]) else: self.transforms = T.Compose([ PadingWithLongerSize(), T.Resize(self.input_shape[1:]), # T.Grayscale(), T.ToTensor(), normalize, T.RandomErasing(), ])
def data_process(self): normal = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) if cfg.use_autoaugment: train_transform = transforms.Compose([ transforms.Resize(cfg.image_size), transforms.CenterCrop(cfg.crop_image_size), # transforms.RandomRotation(cfg.rotate_degree), auto_augment.AutoAugment(dataset=cfg.autoaugment_dataset), transforms.ToTensor(), transforms.RandomErasing(p=0.3, scale=(0.02, 0.1), ratio=(0.6, 1.2)), normal ]) else: train_transform = transforms.Compose([ transforms.Resize(cfg.image_size), transforms.CenterCrop(cfg.crop_image_size), transforms.RandomRotation(cfg.rotate_degree), transforms.ToTensor(), transforms.RandomErasing(p=0.3, scale=(0.02, 0.1), ratio=(0.6, 1.2)), normal ]) test_trainsform = transforms.Compose([ transforms.Resize(cfg.image_size), transforms.CenterCrop(cfg.crop_image_size), transforms.ToTensor(), normal ]) return train_transform, test_trainsform
def create_transforms(self, img_width, img_height): pil_trans = [] tensor_trans = [] if self.train_mode and config.args.activate_transformations: if config.args.transform_train_rotate_prob != 0: tran = transforms.RandomRotation(config.args.transform_train_rotate_angle) self.add_random_apply_transformation(pil_trans, tran, config.args.transform_train_rotate_prob) if config.args.transform_train_crop_prob != 0: tran = transforms.RandomCrop(config.args.transform_train_crop_size) self.add_random_apply_transformation(pil_trans, tran, config.args.transform_train_crop_prob) if config.args.transform_train_rectangle_erasing_prob != 0: tensor_trans.append(transforms.RandomErasing(config.args.transform_train_rectangle_erasing_prob)) if config.args.transform_train_gaussian_noise_std != 0: noise_std = config.args.transform_train_gaussian_noise_std tensor_trans.append(transforms.Lambda(lambda x: x + torch.normal(0.0, noise_std, size=x.shape))) elif self.eval_mode and config.args.activate_transformations: if config.args.transform_test_rotate_prob != 0: tran = transforms.RandomRotation(config.args.transform_test_rotate_angle) self.add_random_apply_transformation(pil_trans, tran, config.args.transform_test_rotate_prob) if config.args.transform_test_crop_prob != 0: tran = transforms.RandomCrop(config.args.transform_test_crop_size) self.add_random_apply_transformation(pil_trans, tran, config.args.transform_test_crop_prob) if config.args.transform_test_rectangle_erasing_prob != 0: tensor_trans.append(transforms.RandomErasing(config.args.transform_test_rectangle_erasing_prob)) if config.args.transform_test_gaussian_noise_std != 0: noise_std = config.args.transform_test_gaussian_noise_std tensor_trans.append(transforms.Lambda(lambda x: x + torch.normal(0.0, noise_std, size=x.shape))) pil_trans.append(transforms.Resize((img_width, img_height))) return transforms.Compose([*pil_trans, transforms.ToTensor(), transforms.Normalize(mean=self.img_mean, std=self.img_std), *tensor_trans])
def __init__(self, ds_path="../dataset", dataset="300w"): self.ds_name = dataset if dataset == "300w": self.imgs = [] sub_dirs = [ "AFW", "AFW_Flip", "HELEN", "HELEN_Flip", "IBUG", "IBUG_Flip", "LFPW", "LFPW_Flip" ] #sub_dirs = ["AFW"] for dir in sub_dirs: self.imgs.extend( glob.glob("{}/{}/{}/*.jpg".format(ds_path, "300W_LP", dir))) self.transform = transforms.Compose([ transforms.Resize((64, 64)), transforms.RandomGrayscale(), transforms.ToTensor(), transforms.RandomErasing() ]) self.transform_rand = transforms.Compose([ transforms.Resize((96, 96)), transforms.RandomCrop(64), transforms.RandomGrayscale(), transforms.ToTensor(), transforms.RandomErasing(), ]) else: self.imgs = glob.glob("{}/{}/*.jpg".format(ds_path, "AFLW2000")) self.transform = transforms.Compose([ transforms.Resize((64, 64)), transforms.ToTensor(), ])
def data_loader(rotated): batch_size = 32 # Transformations for train- and testset # transform_train = albu.Compose([ # albu.Rotate(limit=(90, 90), always_apply=True), # albu.CoarseDropout(max_holes=8, max_height=3, max_width=3, # min_holes=1, min_height=1, min_width=1, # fill_value=255, p=0.9), # albu.CoarseDropout(max_holes=8, max_height=3, max_width=3, # min_holes=1, min_height=1, min_width=1, # fill_value=0, p=0.9), # albu.Normalize(mean=0.5, std=0.5, always_apply=True), # albu.pytorch.ToTensorV2(always_apply=True) # ]) # transform_test = albu.Compose([ # albu.Normalize(mean=0.5, std=0.5, always_apply=True), # albu.pytorch.ToTensorV2(always_apply=True) # ]) transform_train = transforms.Compose([ transforms.RandomRotation((90, 90) if rotated else (0, 0)), transforms.RandomPerspective(p=0.9, distortion_scale=0.1), transforms.ToTensor(), transforms.Normalize(mean=0.5, std=0.5) ] + [ transforms.RandomErasing( p=0.7, scale=(0.002, 0.002), ratio=(1, 1), value=0) ] * 10 + [ transforms.RandomErasing( p=0.7, scale=(0.002, 0.002), ratio=(1, 1), value=1) ] * 10) transform_test = transforms.Compose([ transforms.RandomRotation((90, 90) if rotated else (0, 0)), transforms.ToTensor(), transforms.Normalize(mean=0.5, std=0.5) ]) # Initialise dataset global trainset, valset, testset trainset = torchvision.datasets.mnist.MNIST(root='./data', train=True, download=True, transform=transform_train) trainset, valset, _ = torch.utils.data.random_split( trainset, [2000, 200, 57800]) testset = torchvision.datasets.mnist.MNIST(root='./data', train=False, download=True, transform=transform_test) testset, _ = torch.utils.data.random_split(testset, [200, 9800]) # Create loaders global train_loader, val_loader, test_loader train_loader = DataLoader(trainset, batch_size, shuffle=True, num_workers=1) val_loader = DataLoader(valset, len(valset), shuffle=True, num_workers=1) test_loader = DataLoader(testset, batch_size, shuffle=False, num_workers=1)
def read_dataset(): ''' Augmentations ''' # Train augmentations transform_x = transforms.Compose( [transforms.ToTensor(), transforms.Normalize(mean=0.5, std=0.5)] + [ transforms.RandomErasing( p=1, scale=(0.0005, 0.0005), ratio=(1, 1), value=1) ] * 100 + [ transforms.RandomErasing( p=1, scale=(0.0005, 0.0005), ratio=(1, 1), value=0) ] * 100) global transform_y transform_y = transforms.Compose( [transforms.ToTensor(), transforms.Normalize(mean=0.5, std=0.5)]) print('Reading data...') # Load MNIST images traindata = torchvision.datasets.mnist.MNIST(root='./data', train=True, download=True) traindata, _ = torch.utils.data.random_split(traindata, [10000, 50000]) valdata = torchvision.datasets.mnist.MNIST(root='./data', train=False, download=True) valdata, inferdata, _ = torch.utils.data.random_split( valdata, [100, 1000, 8900]) # show_transform(traindata, transform_x, transform_y) # Initialise dataset global trainset, valset, inferset if src == 'create': for img, _ in traindata: trainset.extend([[transform_x(img), transform_y(img)]]) for img, _ in valdata: valset.extend([[transform_x(img), transform_y(img)]]) for img, _ in inferdata: inferset.extend([[transform_x(img), transform_y(img)]]) # Create loaders global train_loader, val_loader, infer_loader if src == 'create': train_loader = DataLoader(trainset, batch_size, shuffle=False, num_workers=1) val_loader = DataLoader(valset, len(valset), shuffle=False, num_workers=1) infer_loader = DataLoader(inferset, batch_size, shuffle=False, num_workers=1) print('Dataset\'s read')
def get_dataset(size=(224, 224), data_root='/home/cmf/datasets/helmet_all/train_val', batch_size=32, num_workers=4, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]): seq = iaa.Sequential([ iaa.Sometimes( 0.5, iaa.CoarseDropout((0.03, 0.15), size_percent=(0.1, 0.4)), # iaa.JpegCompression() ), # iaa.MotionBlur(k=13) # iaa.GaussianBlur((0, 3.0)), ]) data_transforms = { 'train': transforms.Compose([ transforms.Resize(size), transforms.RandomHorizontalFlip(), transforms.ColorJitter(0.3, 0.3, 0.3, 0.2), transforms.RandomAffine(50), # transforms.Grayscale(3), ImgAug(seq), transforms.ToTensor(), transforms.RandomErasing(ratio=(10, 15), inplace=True), transforms.RandomErasing(ratio=(10, 15), inplace=True), transforms.RandomErasing(ratio=(0.1, 0.2), inplace=True), transforms.RandomErasing(ratio=(0.1, 0.2), inplace=True), # transforms.Normalize(mean, std) ]), 'val': transforms.Compose([ transforms.Resize(size), transforms.ToTensor(), # transforms.Normalize(mean, std) ]) } image_datasets = { x: ImageFolder(os.path.join(data_root, x), data_transforms[x]) for x in ('train', 'val') } dataloaders = { x: DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=num_workers) for x in ('train', 'val') } dataset_sizes = {x: len(image_datasets[x]) for x in ('train', 'val')} class_names = image_datasets['train'].classes return dataloaders, dataset_sizes, class_names
def get_transforms(params): tensor_transform = [] train_transforms = [transforms.RandomHorizontalFlip()] if params['RandomAffine'] != 0: if params['RandomAffine'] == 1: train_transforms.append( transforms.RandomAffine(degrees=20, scale=(.8, 1.2), shear=0)) elif params['RandomAffine'] == 2: train_transforms.append( transforms.RandomAffine(degrees=40, scale=(.7, 1.3), shear=0)) elif params['ColorJitter'] != 0: if params['ColorJitter'] == 1: train_transforms.append( transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2)) elif params['ColorJitter'] == 2: train_transforms.append( transforms.ColorJitter(brightness=0.5, contrast=0.5, saturation=0.5)) elif params['RandomPerspective'] != 0: if params['RandomPerspective'] == 1: train_transforms.append( transforms.RandomPerspective(distortion_scale=0.1)) elif params['RandomPerspective'] == 2: train_transforms.append( transforms.RandomPerspective(distortion_scale=0.2)) elif params['RandomErasing'] != 0: if params['RandomErasing'] == 1: tensor_transform.append( transforms.RandomErasing(scale=(0.02, 0.15), ratio=(0.3, 1.6))) elif params['RandomErasing'] == 2: tensor_transform.append( transforms.RandomErasing(scale=(0.1, 0.5), ratio=(0.2, 5))) train_transforms = transforms.Compose(train_transforms) tensor_transform = transforms.Compose(tensor_transform) train_transforms = transforms.Compose([ train_transforms, transforms.CenterCrop((512, 960)), transforms.ToTensor(), transforms.Normalize(training_mean, training_std), tensor_transform, ]) val_transforms = transforms.Compose([ transforms.CenterCrop((512, 960)), transforms.ToTensor(), transforms.Normalize(training_mean, training_std) ]) return train_transforms, val_transforms
def get_transforms(params, image_size, mean, std): tensor_transform = [] train_transforms = [transforms.RandomHorizontalFlip()] if params['RandomErasing'] != 0: if params['RandomErasing'] == 1: tensor_transform.append( transforms.RandomErasing(scale=(0.1, 0.3), ratio=(0.2, 5))) elif params['RandomErasing'] == 2: tensor_transform.append( transforms.RandomErasing(scale=(0.3, 0.4), ratio=(0.2, 5))) elif params['RandomErasing'] == 3: tensor_transform.append( transforms.RandomErasing(scale=(0.4, 0.5), ratio=(0.2, 5))) elif params['RandomErasing'] == 4: tensor_transform.append( transforms.RandomErasing(scale=(0.5, 0.6), ratio=(0.2, 5))) elif params['RandomCrop'] != 0: if params['RandomCrop'] == 1: train_transforms.append( transforms.RandomResizedCrop(image_size, scale=(0.8, 1), ratio=(0.8, 1.25))) elif params['RandomCrop'] == 2: train_transforms.append( transforms.RandomResizedCrop(image_size, scale=(0.75, 1), ratio=(0.75, 1.33333))) elif params['RandomCrop'] == 3: train_transforms.append( transforms.RandomResizedCrop(image_size, scale=(0.66, 1), ratio=(0.666, 1.51515))) train_transforms = transforms.Compose(train_transforms) tensor_transform = transforms.Compose(tensor_transform) train_transforms = transforms.Compose([ train_transforms, transforms.Resize(image_size), transforms.ToTensor(), transforms.Normalize(mean=mean, std=std), tensor_transform, ]) val_transforms = transforms.Compose([ transforms.Resize(image_size), transforms.ToTensor(), transforms.Normalize(mean=mean, std=std) ]) return train_transforms, val_transforms
def __init__(self, datadir, datafile, input_size, is_training=False): self.datapath = load_datapath_from_csv(datadir, datafile) self.datadir = datadir self.input_size = input_size if is_training: self.transforms = transforms.Compose([ transforms.RandomResizedCrop(input_size, scale=(0.6, 1.0)), # transforms.Resize([input_size,input_size]), transforms.ColorJitter(), transforms.RandomGrayscale(0.25), transforms.RandomHorizontalFlip(p=0.25), transforms.RandomVerticalFlip(p=0.25), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), transforms.RandomErasing(p=0.5, scale=(0.1, 0.4), ratio=(0.3, 3.3)) ]) else: self.transforms = transforms.Compose([ transforms.Resize([input_size, input_size]), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ])
def build_transform(cfg, is_train=True): min, max = cfg.TRANSFORM.JITTER_SCALES MEAN = cfg.TRANSFORM.MEAN STD = cfg.TRANSFORM.STD RANDOM_ROTATION = cfg.TRANSFORM.RANDOM_ROTATION brightness, contrast, saturation, hue = cfg.TRANSFORM.COLOR_JITTER if is_train: crop_size = cfg.TRANSFORM.TRAIN_CROP_SIZE transform = transforms.Compose([ transforms.ToPILImage(), RandomResize(min, max), transforms.RandomCrop(crop_size), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=brightness, contrast=contrast, saturation=saturation, hue=hue), transforms.RandomRotation(RANDOM_ROTATION), transforms.ToTensor(), transforms.Normalize(MEAN, STD), transforms.RandomErasing() ]) else: crop_size = cfg.TRANSFORM.TEST_CROP_SIZE transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize(min), transforms.CenterCrop(crop_size), transforms.ToTensor(), transforms.Normalize(MEAN, STD) ]) return transform
def __init__(self, info, noise_trans=None, load_res=False): # -- setup parameters -- self.nframes = info['nframes'] self.ppf = info['ppf'] self.frame_size = info['frame_size'] self.load_res = load_res self.sobel_filter = create_sobel_filter() # -- manage frame size -- if isinstance(self.frame_size, int): self.frame_size = (self.frame_size, self.frame_size) if not (self.frame_size is None): if self.frame_size[0] <= 64: self.very_small = True else: self.very_small = False self.min_frame_size = np.min(self.frame_size) else: self.very_small = None self.min_frame_size = None # -- optional -- self.total_pixels = return_optional(info, 'total_pixels', 0) self.random_eraser_bool = return_optional(info, 'random_eraser_bool', False) self.reset_seed = return_optional(info, 'reset_seed', False) self.textured = return_optional(info, 'textured', False) # -- init vars and consts -- self.random_eraser = thT.RandomErasing() #scale=(0.40,0.80)) self.PI = 2 * torch.acos(torch.zeros(1)).item() self.szm = thT.Compose([ScaleZeroMean()]) self.noise_trans = noise_trans
def get_transform(phase="train"): transfrom_PIL_list = [ transforms.RandomAffine((-2, 2), fillcolor=255), transforms.ColorJitter(brightness=0.5), transforms.ColorJitter(contrast=0.5), transforms.ColorJitter(saturation=0.5), ] transfrom_tensor_list = [ transforms.RandomErasing(p=0.5, scale=(0.02, 0.1), value=0), ] if phase == "train": transform = transforms.Compose([ transforms.RandomApply(transfrom_PIL_list), transforms.ToTensor(), # transforms.RandomApply(transfrom_tensor_list), transforms.Normalize( mean=[0.5], std=[0.5]), ]) else: transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize( mean=[0.5], std=[0.5]), ]) return transform
def __init__(self, x_dict, y_dict, train_flag=True): self.images = [x['image_path'] for x in x_dict] self.labels = [y['labels'] for y in y_dict] if train_flag: self.transform = transforms.Compose( [ # transforms.RandomCrop(196), transforms.Resize((224, 224)), transforms.RandomAffine(degrees=(-15, 15), translate=(0.05, 0.05), scale=(0.95, 1.05), fillcolor=128), # Cutout(), transforms.RandomHorizontalFlip(), # 随机水平翻转 transforms.RandomVerticalFlip(), # 随机竖直翻转 transforms.RandomRotation(30), #(-30,+30)之间随机旋转 transforms.ToTensor(), #转成tensor[0, 255] -> [0.0,1.0] transforms.RandomErasing(), ] ) #transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) else: self.transform = transforms.Compose( [ transforms.Resize((224, 224)), transforms.ToTensor(), ] ) #transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
def __init__(self, data_root, batch_size, num_workers): super().__init__() self.data_root = data_root self.batch_size = batch_size self.num_workers = num_workers mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] preprocess = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor() ]) self.common_transforms = transforms.Compose( [preprocess, transforms.Normalize(mean, std)]) self.aug_transforms = transforms.Compose([ transforms.RandomResizedCrop(256), transforms.ColorJitter(brightness=0.5, contrast=0.5, saturation=0.5, hue=0.3), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomRotation(90), transforms.RandomGrayscale(p=0.1), self.common_transforms, transforms.RandomErasing(), ])
def __init__( self, labels, img_dir, tags=[3, 4, 6, 8, 9], train=True, label_dict=None, train_aug=False, return_fname=False ): self.csv_path = labels self.img_dir = img_dir # 图片文件目录 df = pd.read_csv(labels) # 读取labels.csv self.train = train self.fnames = df["fname"] self.labels = df["tags"] self.return_fname = return_fname self.det = df.iloc[:, 1:11].values.astype(np.float32) # self.det = preprocessing.scale(self.det, axis=0) # 归一化 # 0sex,1age,2HR,3PR,4QRS,5QRS_axis,6QT,7QTc,8RV5,9SV1 # selected_idx = [3, 4, 6, 8, 9] # selected_idx = [3, 4, 6] selected_idx = tags # selected_idx = [6] self.det = self.det[:, selected_idx] # 0PR,1QRS,2QT,3RV5,4SV1 self.det[:, [0, 1, 2]] /= 100 # self.det[:,[0]]/=100 if label_dict == None: self.label_dict = { "WPW": 0, "LAFB": 1, "MI": 2, "RBBB": 3, "LBBB": 4, "IAVB": 5, "RAE": 6, "LVH": 7, "RVH": 8, } else: self.label_dict = label_dict if train_aug: self.affine_grid = _affine_grid((1, 768, 64)) self.tfms_train = transforms.Compose( [ RandomImageFilter(), transforms.Lambda(lambda x: vjitter(x, self.affine_grid, magnitude=0.02, p=0.1)), transforms.Lambda(lambda x: random_baseline_drift(x, self.affine_grid, magnitude=0.3, p=1)), transforms.RandomErasing(p=0.8, scale=(0.1, 0.1)), transforms.Lambda(lambda x: cut_lead(x)), ] ) else: self.tfms_train = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: cut_lead(x)),]) self.tfms_test = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: cut_lead(x)),]) # 生成多标签targets self.targets = torch.zeros(len(self.fnames), len(self.label_dict)) for n, line in enumerate(self.labels): for label in line.split(): if label in self.label_dict.keys(): self.targets[n, self.label_dict[label]] = 1
def __init__(self, is_train, dataframe, data_dir): self.is_train = is_train self.dataframe = dataframe self.data_dir = data_dir if self.is_train: transforms_list = [ transforms.Resize((INPUT_SIZE, INPUT_SIZE)), transforms.RandomApply([transforms.RandomResizedCrop(size=INPUT_SIZE)], p=0.33), transforms.RandomChoice([ transforms.ColorJitter(0.2, 0.2, 0.2, 0.2), transforms.RandomAffine( degrees=10, translate=(0.2, 0.2), scale=(0.8, 1.2), resample=Image.BILINEAR) ]), transforms.ToTensor(), transforms.RandomApply([transforms.RandomErasing(p=1, scale=(0.2, 0.33), ratio=(0.5, 2))], p=0.8), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.25, 0.25, 0.25)) ] else: transforms_list = [ transforms.Resize((INPUT_SIZE, INPUT_SIZE)), transforms.ToTensor(), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.25, 0.25, 0.25)) ] self.transforms = transforms.Compose(transforms_list)
def load_data(data_root_dir='../data/'): train_transform = transforms.Compose([ transforms.Resize(256), transforms.RandomCrop(224), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1), transforms.ToTensor(), transforms.RandomErasing(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # 测试阶段 Ten Crop test test_transform = transforms.Compose([ transforms.Resize(256), transforms.TenCrop(224), transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])), transforms.Lambda(lambda crops: torch.stack( [transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))(crop) for crop in crops])) ]) data_loaders = {} data_sizes = {} for name in ['train', 'test']: if name == 'train': data_set = CIFAR100(data_root_dir, train=True, download=True, transform=train_transform) data_loader = DataLoader(data_set, batch_size=96, shuffle=True, num_workers=8) else: data_set = CIFAR100(data_root_dir, train=False, download=True, transform=test_transform) data_loader = DataLoader(data_set, batch_size=48, shuffle=True, num_workers=8) data_loaders[name] = data_loader data_sizes[name] = len(data_set) return data_loaders, data_sizes
def __init__(self, opt): BaseDataset.__init__(self, opt) # 2d features self.shapes_info = os.listdir(os.path.join(opt.dataroot, 'input_data')) if '.DS_Store' in self.shapes_info: self.shapes_info.remove('.DS_Store') self.shapes_info.sort() self.phase = opt.phase self.data_size = len(self.shapes_info) self.input_2d_path = os.path.join(opt.dataroot, 'input_data') self.input_3d_path = os.path.join(opt.dataroot, 'notexture_pool_data') self.query_transform = transforms.Compose([ transforms.Resize(256), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) opt.fine_size = 256 self.fine_size = opt.fine_size self.phase = opt.phase self.query_random_erase = transforms.Compose( [transforms.RandomErasing()])
def __init__(self, opt): BaseDataset.__init__(self, opt) # 3d feature self.shapes_info = np.load(os.path.join(opt.dataroot, 'data_info', opt.dataset_name), allow_pickle=True) self.phase = opt.phase self.data_size = len(self.shapes_info) self.input_2d_path = os.path.join(opt.dataroot, 'input_data') self.input_3d_path = os.path.join(opt.dataroot, 'notexture_pool_data') self.query_transform = transforms.Compose([ transforms.Resize(256), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) opt.fine_size = 256 self.fine_size = opt.fine_size self.phase = opt.phase self.query_random_erase = transforms.Compose( [transforms.RandomErasing()])
def car_recogniser(our_img): car_image = our_img trans = transforms.Compose([ transforms.Resize((400, 400)), transforms.RandomRotation(15), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.RandomErasing(inplace=True), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # preprocessing for prediction image input = trans(car_image) input = input.view(1, 3, 400, 400) output = car_model(input) prediction = int(torch.max(output.data, 1)[1].numpy()) # return prediction label predicted_val = ([value for value in labels_dict.values()][prediction]) st.text("Detected vehicle model: ") predicted_val #converting PIL object into numpy array for ocr new_array = np.array(car_image) reader = easyocr.Reader(['en'], gpu=False) bounds = reader.readtext(new_array, detail=0) st.text("Detected license plate number: ") for x in bounds: x
def __init__(self, labels_path, image_size, istraining=False, sample=True): normalize = transforms.Normalize(mean=[0.4771, 0.4769, 0.4355], std=[0.2189, 0.1199, 0.1717]) self.istraining = istraining self.images = dd.io.load(labels_path) if istraining: self.transform = transforms.Compose([ transforms.ColorJitter( 64.0 / 255, 0.75, 0.25, 0.04), transforms.RandomHorizontalFlip(), transforms.RandomRotation(10), transforms.RandomResizedCrop(image_size), transforms.RandomApply( [GaussianBlur([.1, 2.])], p=0.5), transforms.ToTensor(), normalize, transforms.RandomErasing(), # transforms.ToPILImage() ]) else: self.transform = transforms.Compose([ transforms.Resize([image_size, image_size]), transforms.ToTensor(), normalize, ]) print(len(self.images))
def __init__(self, train=False, seed=1, resize=510, centerCrop=448): self.transformations = transforms.Compose([ transforms.Resize(resize), transforms.CenterCrop(centerCrop), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) self.random_transformations = transforms.Compose([ transforms.RandomRotation(90, expand=False, fill=None), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomVerticalFlip(p=0.5), transforms.GaussianBlur(11, sigma=(0.1, 2.0)), torch.nn.Dropout2d(0.1), transforms.RandomErasing(p=0.25) ]) self.train = train # pandas dataframe that stores image names and labels self.df = pd.read_csv('./data/train.csv').sample(frac=1, random_state=seed) test_section = int(0.8 * len(self.df)) if train: self.df = self.df.iloc[:test_section] self.df_transformed = self.df.copy() self.df = pd.concat([self.df, self.df_transformed]) else: self.df = self.df.iloc[test_section:]
def get_transforms(): """ Defines a transform to resize and normalize the test data, and defines a transform with some addition augmentations for the train data. :return: A transform with augmentations and a transform without augmentations. """ # Create a transform with augmentations. aug_transform = transforms.Compose([ transforms.Resize((250, 250)), # resize image transforms.RandomHorizontalFlip(p=0.5), # AUGMENTATION: Random Horizontal Flip transforms.RandomRotation(20), # AUGMENTATION: Random Rotation transforms.RandomResizedCrop(224), # AUGMENTATION: Random Cropping transforms.RandomGrayscale(p=0.1), # AUGMENTATION: Random Greyscale transforms.ToTensor(), # numpy array to tensor transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), # normalize the image transforms.RandomErasing(p=1) # AUGMENTATION: Random Erasing ]) # Create a basic transform without augmentations. no_aug_transform = transforms.Compose([ transforms.Resize((224, 224)), # resize image transforms.ToTensor(), # numpy array to tensor transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # normalize the image ]) return aug_transform, no_aug_transform
def get_mini_imagenet_data_loader(task, num_per_class=1, split='train', shuffle=False): normalize = transforms.Normalize(mean=[0.92206, 0.92206, 0.92206], std=[0.08426, 0.08426, 0.08426]) trans = transforms.Compose([ transforms.Resize((288, 144)), transforms.RandomCrop((256, 128)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, transforms.RandomErasing(p=0.5) ]) dataset = MiniImagenet(task, split=split, transform=trans) if split == 'train': sampler = ClassBalancedSamplerOld(num_per_class, task.num_classes, task.train_num, shuffle=shuffle) else: sampler = ClassBalancedSampler(task.num_classes, task.test_num, shuffle=shuffle) loader = DataLoader(dataset, batch_size=num_per_class * task.num_classes, sampler=sampler) return loader
def get_data_transform(means, stds): # Train Phase transformations normalize = transforms.Normalize(means, stds) #normalize = transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)) # mean and std #normalize = transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # mean and std # resize = transforms.Resize((28, 28)) train_transforms = transforms.Compose([ #resize, #transforms.ColorJitter(brightness=0.10, contrast=0.1, saturation=0.10, hue=0.1), #transforms.RandomRotation((-7.0, 7.0), fill=(1,)), #transforms.RandomCrop(32, padding=4), #transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, transforms.RandomErasing(scale=(0.02, 0.20), ratio=(0.8, 1.2)) ]) # Test Phase transformations test_transforms = transforms.Compose([ #resize, transforms.ToTensor(), normalize ]) return train_transforms, test_transforms
def __init__(self, hdf5_filename, which_set='train', roi_size=80, labels_dtype=torch.long, is_use_default_transforms=True): self.fname = hdf5_filename self.set_name = which_set + '_df' self.label_info = [] self._is_return_extra_info = False self._all_dfs = None # # get labels info # ann_df = pd.read_hdf(hdf5_filename, key='/'+self.set_name) # self.label_info = ann_df[self.INFO_COLS].copy() self.roi_size = roi_size # size we want to train on self.labels_dtype = labels_dtype self.frame_height, self.frame_width = ( self._get_frame(0).squeeze().shape[-2:]) # any transform? self.default_transforms_list = [ transforms.RandomVerticalFlip(p=0.5), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomErasing(), ] if is_use_default_transforms and which_set in ['train', 'val']: self.transform = transforms.Compose(self.default_transforms_list) else: self.transform = transforms.Compose([]) # does nothing
def random_aug(x): # gamma correction if random.random() <= 0.3: gamma = random.uniform(1.0, 1.5) x = gamma_correction(x, gamma) # random erasing with mean value mean_v = tuple(x.view(x.size(0), -1).mean(-1)) re = transforms.RandomErasing(p=0.5, value=mean_v) x = re(x) # color channel shuffle if random.random() <= 0.3: l = [0, 1, 2] random.shuffle(l) x_c = torch.zeros_like(x) x_c[l] = x x = x_c # horizontal flip or vertical flip if random.random() <= 0.5: if random.random() <= 0.5: x = torch.flip(x, [1]) else: x = torch.flip(x, [2]) # rotate 90, 180 or 270 degree if random.random() <= 0.5: degree = [90, 180, 270] d = random.choice(degree) x = torch.rot90(x, d // 90, [1, 2]) return x
def init_dataloaders(self): batch_size = self.config.hp.batch_size project_path = self.paths.project_path data_dir = os.path.join(project_path, self.config.data_dir) train_transform = transforms.Compose([ transforms.Pad(padding=4), transforms.RandomCrop(size=(32, 32)), transforms.RandomHorizontalFlip(p=0.5), transforms.ToTensor(), transforms.RandomErasing(p=0.5, scale=(0.25, 0.25), ratio=(1., 1.)), # Cut out 8x8 square transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) test_transform = transforms.Compose([ # transforms.Pad(padding=4), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) data_train = CIFAR10(data_dir, train=True, transform=train_transform) data_test = CIFAR10(data_dir, train=False, transform=test_transform) self.train_dataloader = DataLoader(data_train, batch_size=batch_size, num_workers=0, shuffle=True) self.val_dataloader = DataLoader(data_test, batch_size=batch_size, num_workers=0, shuffle=False)