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)
