def __init__(self, h: int, w: int):
super(ResizeImage, self).__init__(1)
self.resize = albumentations.Resize(h, w)
alb_val_trnsfms = A.Compose([
# A.CLAHE(p=1),
# A.Resize(*INPUT_SIZE),
A.CenterCrop(*config.INPUT_SIZE),
A.Normalize(
mean=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
),
ATorch.transforms.ToTensor()
], p=1)
alb_tst_trnsfms = A.Compose([
# A.CLAHE(),
A.Resize(*config.TEST_INPUT_SIZE),
A.Normalize(
mean=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
),
ATorch.transforms.ToTensor()
], p=1)
class CellerDataset(Dataset):
target_name = 'sirna'
image_name = ''
id_name = 'id_code'
site = 1
def __init__(self, df, image_dir, transform, mode):
'shuffle': shuffle,
'validation_split': validation_split,
'num_workers': num_workers,
'collate_fn': dataset.collate_fn
}
super(ChargridDataloader, self).__init__(**kwarg)
if __name__ == "__main__":
size = 64
aug = alb.Compose([
alb.LongestMaxSize(size + 24),
alb.PadIfNeeded(size + 24, size + 24, border_mode=cv2.BORDER_CONSTANT),
alb.RandomCrop(size, size, p=0.3),
alb.Resize(size, size)
], alb.BboxParams(format='coco', label_fields=['lbl_id'], min_area=2.0))
dataset = SegDataset('./data', 'train_files.txt', transform=aug)
data_loader = DataLoader(dataset,
batch_size=4,
shuffle=True,
collate_fn=dataset.collate_fn)
print(len(data_loader))
for idx, sample in enumerate(data_loader):
img, mask, boxes, lbl_boxes = sample
print(img.size())
print(mask.size())
print(lbl_boxes)
# print(lbl_boxes)
else:
return data.SequentialSampler(dataset)
def sample_data(loader):
while True:
for batch in loader:
yield batch
# %%
transform = albumentations.Compose(
[
albumentations.HorizontalFlip(),
albumentations.Resize(256, 256),
albumentations.ElasticTransform(p=0.5, alpha=100, alpha_affine=1, sigma=10),
albumentations.ShiftScaleRotate(p=0.5, rotate_limit=10),
albumentations.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
AlbToTensor()
]
)
# %%
dataset = ImageMeasureDataset(
"/raid/data/celeba",
"/raid/data/celeba_masks",
img_transform=transform
)
def get_validation_augmentation():
"""Add paddings to make image shape divisible by 32"""
test_transform = [albu.Resize(320, 640)]
return albu.Compose(test_transform)
def get_test_transform(image_size):
return A.Compose([A.Resize(image_size[0], image_size[1], p = 1.0), A.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225), p = 1.0), ToTensor()])
device = "cuda" if torch.cuda.is_available() else "cpu" # GPU 사용 가능 여부에 따라 device 정보 저장
dataset_path = '../input/data'
batch_size = 16
num_epochs = 1
val_every = 1
train_path = dataset_path + '/train.json'
val_path = dataset_path + '/val.json'
test_path = dataset_path + '/test.json'
category_names = ['Backgroud','UNKNOWN','General trash','Paper','Paper pack','Metal','Glass','Plastic','Styrofoam','Plastic bag','Battery','Clothing']
# 데이터셋
test_transform = A.Compose([A.Resize(256, 256),
ToTensorV2()])
train_transform = A.Compose([A.Resize(256, 256),
ToTensorV2()])
val_transform = A.Compose([A.Resize(256, 256),
ToTensorV2()])
test_dataset = COCODataLoader(data_dir=test_path,
dataset_path=dataset_path,
mode='test',
category_names=category_names,
transform=test_transform)
train_dataset = COCODataLoader(data_dir=train_path,
import albumentations as A
from bengali_experiments import N_CLASSES, IMG_SIZE
from bengali_experiments.densenet._base import densenet
from core import AdaptiveConcatPool2d, BaseExperiment, BaseHeadNet, MultiHead
TRANSFORM_TRAIN = A.Compose([
A.Resize(width=IMG_SIZE[1], height=IMG_SIZE[0]),
A.OneOf([
A.RandomBrightnessContrast(),
A.RandomGamma(),
], p=0.5),
A.OneOf([
A.GridDistortion(),
A.ElasticTransform(),
A.OpticalDistortion(),
A.ShiftScaleRotate()
],
p=0.25),
A.CoarseDropout(),
A.Normalize(mean=0.5, std=0.5)
])
TRANSFORM_VALID = A.Compose([
A.Resize(width=IMG_SIZE[1], height=IMG_SIZE[0]),
A.Normalize(mean=0.5, std=0.5)
])
class BengaliDenseNetThreeHeads(BaseExperiment):
def __init__(self, params, pretrained: bool = True, metrics=None):
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
train_transforms = A.Compose([
A.RandomResizedCrop(train_crop_size, train_crop_size, scale=(0.08, 1.0)),
A.HorizontalFlip(),
A.CoarseDropout(max_height=32, max_width=32),
A.HueSaturationValue(),
A.Normalize(mean=mean, std=std),
ToTensor(),
])
val_transforms = A.Compose([
# https://github.com/facebookresearch/FixRes/blob/b27575208a7c48a3a6e0fa9efb57baa4021d1305/imnet_resnet50_scratch/transforms.py#L76
A.Resize(int((256 / 224) * val_crop_size), int(
(256 / 224) * val_crop_size)),
A.CenterCrop(val_crop_size, val_crop_size),
A.Normalize(mean=mean, std=std),
ToTensor(),
])
train_loader, val_loader, train_eval_loader = get_train_val_loaders(
data_path,
train_transforms=train_transforms,
val_transforms=val_transforms,
batch_size=batch_size,
num_workers=num_workers,
val_batch_size=batch_size,
pin_memory=True,
train_sampler="distributed",
val_sampler="distributed",
def run(base_path, model_path, gpu_name, batch_size, num_epochs, num_workers):
"""
Main method to train, evaluate and test the instanced-based approach to classify the Paxos dataset into refer- and nonreferable retinopathy.
:param base_path: Absolute path to the dataset. The folder should have folders for training (train), evaluation (val) and corresponding label files
:param model_path: Absolute path to the pretrained model
:param gpu_name: ID of the gpu (e.g. cuda0)
:param batch_size: Bath size
:param num_epochs: Maximum number of training epochs
:param num_workers: Number of threads used for data loading
:return: f1-score for the evaluation (or test) set
"""
device = torch.device(gpu_name if torch.cuda.is_available() else "cpu")
print(f'Using device {device}')
hyperparameter = {
'data': os.path.basename(os.path.normpath(base_path)),
'learning_rate': 1e-4,
'weight_decay': 1e-4,
'num_epochs': num_epochs,
'batch_size': batch_size,
'optimizer': optim.Adam.__name__,
'freeze': 0.0,
'balance': 0.3,
'image_size': 450,
'crop_size': 399,
'pretraining': True,
'preprocessing': False,
'multi_channel': False,
'boosting': 1.00,
'use_clahe': False,
'narrow_model': False,
'remove_glare': False,
'voting_percentage': 1.0,
'validation':
'tv', # tvt = train / val / test, tt = train(train + val) / test, tv = train / val
'network': 'alexnet' # alexnet / inception
}
aug_pipeline_train = A.Compose([
A.CLAHE(always_apply=hyperparameter['use_clahe'],
p=1.0 if hyperparameter['use_clahe'] else 0.0),
ThresholdGlare(always_apply=hyperparameter['remove_glare'],
p=1.0 if hyperparameter['remove_glare'] else 0.0),
A.Resize(hyperparameter['image_size'],
hyperparameter['image_size'],
always_apply=True,
p=1.0),
A.RandomCrop(hyperparameter['crop_size'],
hyperparameter['crop_size'],
always_apply=True,
p=1.0),
A.HorizontalFlip(p=0.5),
A.CoarseDropout(min_holes=1,
max_holes=3,
max_width=75,
max_height=75,
min_width=25,
min_height=25,
p=0.5),
A.ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.3,
rotate_limit=45,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=0.5),
A.OneOf([
A.GaussNoise(p=0.5),
A.ISONoise(p=0.5),
A.IAAAdditiveGaussianNoise(p=0.25),
A.MultiplicativeNoise(p=0.25)
],
p=0.3),
A.OneOf([
A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT, value=0,
p=0.5),
A.GridDistortion(p=0.5)
],
p=0.3),
A.OneOf(
[A.HueSaturationValue(p=0.5),
A.ToGray(p=0.5),
A.RGBShift(p=0.5)],
p=0.3),
A.OneOf([
RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.2),
A.RandomGamma()
],
p=0.3),
A.Normalize(always_apply=True, p=1.0),
ToTensorV2(always_apply=True, p=1.0)
],
p=1.0)
aug_pipeline_val = A.Compose([
A.CLAHE(always_apply=hyperparameter['use_clahe'],
p=1.0 if hyperparameter['use_clahe'] else 0.0),
ThresholdGlare(always_apply=hyperparameter['remove_glare'],
p=1.0 if hyperparameter['remove_glare'] else 0.0),
A.Resize(hyperparameter['image_size'],
hyperparameter['image_size'],
always_apply=True,
p=1.0),
A.CenterCrop(hyperparameter['crop_size'],
hyperparameter['crop_size'],
always_apply=True,
p=1.0),
A.Normalize(always_apply=True, p=1.0),
ToTensorV2(always_apply=True, p=1.0)
],
p=1.0)
hyperparameter_str = str(hyperparameter).replace(', \'', ',\n \'')[1:-1]
print(f'Hyperparameter info:\n {hyperparameter_str}')
loaders = prepare_dataset(os.path.join(base_path, ''), hyperparameter,
aug_pipeline_train, aug_pipeline_val,
num_workers)
net = prepare_model(model_path, hyperparameter, device)
optimizer_ft = optim.Adam([{
'params': net.features.parameters(),
'lr': 1e-5
}, {
'params': net.classifier.parameters()
}],
lr=hyperparameter['learning_rate'],
weight_decay=hyperparameter['weight_decay'])
criterion = nn.CrossEntropyLoss()
plateau_scheduler = lr_scheduler.ReduceLROnPlateau(optimizer_ft,
mode='min',
factor=0.1,
patience=10,
verbose=True)
desc = f'_paxos_frames_{str("_".join([k[0] + str(hp) for k, hp in hyperparameter.items()]))}'
writer = SummaryWriter(comment=desc)
model_path, f1 = train_model(net,
criterion,
optimizer_ft,
plateau_scheduler,
loaders,
device,
writer,
hyperparameter,
num_epochs=hyperparameter['num_epochs'],
description=desc)
print('Best identified model: ', model_path)
print('Performance F1: ', f1)
return f1
#remove lo intensity pixels as noise
img[img < 28] = 0
lx, ly = xmax - xmin, ymax - ymin
l = max(lx, ly) + pad
#make sure that the aspect ratio is kept in rescaling
img = np.pad(img, [((l - ly) // 2, ), ((l - lx) // 2, )], mode='constant')
return cv2.resize(img, (size, size))
############################## Prapare Augmentation
train_transform = albumentations.Compose([
# albumentations.OneOf([
# albumentations.Resize(IMAGE_HEIGHT_RESIZE, IMAGE_WIDTH_RESIZE),
# albumentations.RandomResizedCrop(IMAGE_HEIGHT_RESIZE, IMAGE_WIDTH_RESIZE, scale=(0.75, 1.0)),
# ], p=1),
albumentations.Resize(IMAGE_HEIGHT_RESIZE, IMAGE_WIDTH_RESIZE),
albumentations.OneOf(
[
# albumentations.Cutout(num_holes=8, max_h_size=2, max_w_size=4, fill_value=0),
GridMask(num_grid=(3, 7), p=1),
albumentations.ShiftScaleRotate(scale_limit=.15,
rotate_limit=20,
border_mode=cv2.BORDER_CONSTANT),
albumentations.IAAAffine(shear=20, mode='constant'),
albumentations.IAAPerspective(),
# albumentations.GridDistortion(distort_limit=0.01),
],
p=0.8)
])
test_transform = albumentations.Compose([
def get_transforms(crop_size: int, size: int, validate=False):
randomCrop = albu.Compose([albu.RandomCrop(crop_size, crop_size, always_apply=True), albu.Resize(size, size),
albu.VerticalFlip(), albu.RandomRotate90(always_apply=True)],
additional_targets={'target': 'image'})
centerCrop = albu.Compose([albu.CenterCrop(crop_size, crop_size, always_apply=True), albu.Resize(size, size),
albu.VerticalFlip(), albu.RandomRotate90(always_apply=True)],
additional_targets={'target': 'image'})
pipeline = randomCrop if not validate else randomCrop
def process(a, b, c):
r = pipeline(image=a, target=b, mask=c)
return r['image'], r['target'], r['mask']
return process
def __len__(self):
return len(self.df)
if __name__ == '__main__':
seed_val = 2020
_ = seed_everything(seed_val)
IMG_SIZE = 224
# data augmentations
data_transforms = {
'train': al.Compose([
al.Resize(IMG_SIZE, IMG_SIZE),
al.Cutout(p=.6, max_h_size=15, max_w_size=10, num_holes=4),
al.Rotate(limit=35, p=.04),
al.Normalize((0.1307,), (0.3081,))
]),
'test': al.Compose([
al.Resize(IMG_SIZE, IMG_SIZE),
al.Cutout(p=.6, max_h_size=15, max_w_size=10, num_holes=4),
al.Normalize((0.1307,), (0.3081,))
])
}
# data loaders
#train_df = pd.read_csv('../data/Giz-agri-keywords-data/final_train.csv')
#ds = AudioDataset(images_path='../data/Giz-agri-keywords-data/datasets/images', df=train_df, transforms=data_transforms['train'])
return self.df.shape[0]
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
train_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(mean, std)])
val_transform = transforms.Compose([
transforms.Resize((config['image_sz'], config['image_sz']), 3),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
A_transform = A.Compose(
[
A.Resize(config['image_sz'], config['image_sz'], interpolation=2, p=1),
A.Flip(p=0.5),
A.RandomRotate90(p=1),
A.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.2,
rotate_limit=45,
interpolation=2,
border_mode=0,
p=0.5),
#A.OneOf([
# A.IAAAdditiveGaussianNoise(),
# A.GaussNoise(),
# ], p=0.0),
A.OneOf([
A.MotionBlur(p=0.25),
A.MedianBlur(blur_limit=3, p=0.25),
def __init__(self, root, train=True, imwidth=100, crop=15):
from scipy.io import loadmat
self.root = root
self.imwidth = imwidth
self.train = train
self.crop = crop
afw = loadmat(
os.path.join(root, 'Bounding Boxes/bounding_boxes_afw.mat'))
helentr = loadmat(
os.path.join(root,
'Bounding Boxes/bounding_boxes_helen_trainset.mat'))
helente = loadmat(
os.path.join(root,
'Bounding Boxes/bounding_boxes_helen_testset.mat'))
lfpwtr = loadmat(
os.path.join(root,
'Bounding Boxes/bounding_boxes_lfpw_trainset.mat'))
lfpwte = loadmat(
os.path.join(root,
'Bounding Boxes/bounding_boxes_lfpw_testset.mat'))
ibug = loadmat(
os.path.join(root, 'Bounding Boxes/bounding_boxes_ibug.mat'))
self.filenames = []
self.bounding_boxes = []
self.keypoints = []
if train:
datasets = [(afw, 'afw'), (helentr, 'helen/trainset'),
(lfpwtr, 'lfpw/trainset')]
else:
datasets = [(helente, 'helen/testset'), (lfpwte, 'lfpw/testset'),
(ibug, 'ibug')]
for dset in datasets:
ds = dset[0]
ds_imroot = dset[1]
imnames = [
ds['bounding_boxes'][0, i]['imgName'][0, 0][0]
for i in range(ds['bounding_boxes'].shape[1])
]
bbs = [
ds['bounding_boxes'][0, i]['bb_ground_truth'][0, 0][0]
for i in range(ds['bounding_boxes'].shape[1])
]
for i, imn in enumerate(imnames):
# only some of the images given in ibug boxes exist (those that start with 'image')
if ds is not ibug or imn.startswith('image'):
self.filenames.append(os.path.join(ds_imroot, imn))
self.bounding_boxes.append(bbs[i])
kpfile = os.path.join(root, ds_imroot, imn[:-3] + 'pts')
with open(kpfile) as kpf:
kp = kpf.read()
kp = kp.split()[5:-1]
kp = [float(k) for k in kp]
assert len(kp) == 68 * 2
kp = np.array(kp).astype(np.float32).reshape(-1, 2)
self.keypoints.append(kp)
if train:
assert len(self.filenames) == 3148
else:
assert len(self.filenames) == 689
# normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
# augmentations = [transforms.ToTensor()] if train else [transforms.ToTensor()]
#
# self.initial_transforms = transforms.Compose([transforms.Resize((self.imwidth, self.imwidth))])
# self.transforms = transforms.Compose(augmentations)
# self.transforms = transforms.Compose(augmentations + [normalize])
self.transforms = albumentations.Compose([
albumentations.Resize(self.imwidth, self.imwidth),
albumentations.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5,
0.5]),
ToTensorV2()
])
def __init__(self,
base_dir='../../data/apolloscape',
road_record_list=[{
'road': 'road02_seg',
'record': [22, 23, 24, 25, 26]
}, {
'road': 'road03_seg',
'record': [7, 8, 9, 10, 11, 12]
}],
ignore_index=255,
debug=False):
self.debug = debug
self.base_dir = Path(base_dir)
self.ignore_index = ignore_index
self.img_paths = []
self.lbl_paths = []
for road_record in road_record_list:
self.road_dir = self.base_dir / Path(road_record['road'])
self.record_list = road_record['record']
for record in self.record_list:
img_paths_tmp = self.road_dir.glob(
f'ColorImage/Record{record:03}/Camera 5/*.jpg')
lbl_paths_tmp = self.road_dir.glob(
f'Label/Record{record:03}/Camera 5/*.png')
img_paths_basenames = {
Path(img_path.name).stem
for img_path in img_paths_tmp
}
lbl_paths_basenames = {
Path(lbl_path.name).stem.replace('_bin', '')
for lbl_path in lbl_paths_tmp
}
intersection_basenames = img_paths_basenames & lbl_paths_basenames
img_paths_intersection = [
self.road_dir / Path(
f'ColorImage/Record{record:03}/Camera 5/{intersection_basename}.jpg'
) for intersection_basename in intersection_basenames
]
lbl_paths_intersection = [
self.road_dir / Path(
f'Label/Record{record:03}/Camera 5/{intersection_basename}_bin.png'
) for intersection_basename in intersection_basenames
]
self.img_paths += img_paths_intersection
self.lbl_paths += lbl_paths_intersection
self.img_paths.sort()
self.lbl_paths.sort()
print(len(self.img_paths), len(self.lbl_paths))
assert len(self.img_paths) == len(self.lbl_paths)
self.resizer = albu.Resize(height=512, width=1024)
self.augmenter = albu.Compose([
albu.HorizontalFlip(p=0.5),
# albu.RandomRotate90(p=0.5),
albu.Rotate(limit=10, p=0.5),
# albu.CLAHE(p=0.2),
# albu.RandomContrast(p=0.2),
# albu.RandomBrightness(p=0.2),
# albu.RandomGamma(p=0.2),
# albu.GaussNoise(p=0.2),
# albu.Cutout(p=0.2)
])
self.img_transformer = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
self.lbl_transformer = torch.LongTensor
def pre_transforms(image_size=224):
return [albu.Resize(image_size, image_size, p=1)]
def test_fn():
from argparse import ArgumentParser
from config.data_config import get_data_config
parser = ArgumentParser(description=("Script to test the augmentation pipeline. "
"Run with 'python -m src.dataset.data_transformations_albumentations "
"<path>'."))
parser.add_argument("img_path", type=Path, help="Path to the image to use.")
parser.add_argument("--mask_path", "-m", type=Path, default=None,
help="Path to the mask corresponding to the image. Defaults to same name with '_mask.png'.")
parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
args = parser.parse_args()
img_path: Path = args.img_path
mask_path: Path = args.mask_path if args.mask_path else img_path.parent / (img_path.stem + "_mask.png")
debug: bool = args.debug
img = cv2.imread(str(img_path))
mask = cv2.imread(str(mask_path))
mask_rgb = cv2.cvtColor(mask, cv2.COLOR_BGR2RGB)
# This requires having a config and dataset (not ideal), but it's just to test so whatever...
data_config = get_data_config()
one_hot_mask = np.zeros((*mask.shape[:2][::1], data_config.OUTPUT_CLASSES))
for key in range(len(data_config.COLOR_MAP)):
one_hot_mask[:, :, key][(mask_rgb == data_config.COLOR_MAP[key]).all(axis=-1)] = 1
model_config = get_model_config()
img_sizes = model_config.IMAGE_SIZES
batch_size = 4
img_batch = np.asarray([img.copy() for _ in range(batch_size)])
mask_batch = np.asarray([one_hot_mask.copy() for _ in range(batch_size)])
transform = albumentations.Compose([
albumentations.HorizontalFlip(p=0.5),
albumentations.RandomBrightnessContrast(p=0.2),
albumentations.Resize(img_sizes[0], img_sizes[1], interpolation=cv2.INTER_AREA, always_apply=False, p=1)
])
augmentation_pipeline = albumentation_wrapper(transform)
aug_imgs, aug_one_hot_masks = augmentation_pipeline(img_batch, mask_batch)
# Prepare the original image / mask so that the can be displayed next to the augmented ones
img = cv2.resize(img, img_sizes)
mask = cv2.resize(mask, img_sizes, interpolation=cv2.INTER_NEAREST)
original = cv2.hconcat([img, mask])
for i in range(batch_size):
# One hot to bgr
aug_mask = np.argmax(aug_one_hot_masks[i], axis=-1)
aug_mask_rgb = np.asarray(data_config.COLOR_MAP[aug_mask], dtype=np.uint8)
aug_mask_bgr = cv2.cvtColor(aug_mask_rgb, cv2.COLOR_RGB2BGR)
if debug:
print(f"{aug_one_hot_masks[i].shape=}")
print(f"{set(aug_one_hot_masks[i].flat)=}")
print(f"{aug_mask.shape=}")
print(f"{set(aug_mask.flat)=}")
assert set(mask.flat) == set(aug_mask_bgr.flat), ("Impurities detected! "
f"({set(mask.flat)} vs {set(aug_mask_bgr.flat)})")
aug_result = cv2.hconcat([aug_imgs[i], aug_mask_bgr])
display_img = cv2.vconcat([original, aug_result])
show_img(display_img)
val_df = df[df.fold == fold].reset_index()
train_df = df[df.fold != fold].reset_index()
# transforms
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
transform_levels = {
'level2':
albumentations.Compose([
albumentations.RandomBrightness(),
albumentations.Rotate(limit=(30, 30)),
albumentations.RGBShift(),
albumentations.HorizontalFlip(),
albumentations.RandomContrast(),
albumentations.Resize(*image_size),
albumentations.Normalize(mean=mean, std=std, p=1),
ToTensorV2()
]),
'level3':
albumentations.Compose([
albumentations.RandomBrightness(),
albumentations.Rotate(limit=(30, 30)),
albumentations.RGBShift(),
albumentations.RandomGamma(),
albumentations.OpticalDistortion(),
albumentations.HorizontalFlip(),
albumentations.ShiftScaleRotate(),
albumentations.HueSaturationValue(),
albumentations.RandomContrast(),
albumentations.Resize(*image_size),
def albumentations_transforms(data_map,
data_stats,
do_img_aug=False,
im_size=64):
transforms_list_map = {}
transforms_map = {}
for dname in data_map.keys():
transforms_list_map[dname] = []
# Resize
size = (im_size, im_size)
for k, v in transforms_list_map.items():
v.append(
A.Resize(height=size[0],
width=size[0],
interpolation=cv2.INTER_LANCZOS4,
always_apply=True))
# Use data aug only for train data
if do_img_aug:
# RGB shift and Hue Saturation value
for k, v in transforms_list_map.items():
if k not in ("bg", "fg_bg"):
continue
v.append(
A.OneOf([
A.RGBShift(r_shift_limit=20,
g_shift_limit=20,
b_shift_limit=20,
p=0.5),
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
p=0.5)
],
p=0.5))
# GaussNoise
for k, v in transforms_list_map.items():
if k not in ("bg", "fg_bg"):
continue
v.append(A.GaussNoise(p=0.5))
# Random horizontal flipping
if random.random() > 0.5:
for k, v in transforms_list_map.items():
v.append(A.HorizontalFlip(always_apply=True))
# Random vertical flipping
if random.random() > 0.7:
for k, v in transforms_list_map.items():
v.append(A.VerticalFlip(always_apply=True))
# Random rotate
if random.random() > 0.3:
angle = random.uniform(-15, 15)
for k, v in transforms_list_map.items():
v.append(
A.Rotate(limit=(angle, angle),
interpolation=cv2.INTER_LANCZOS4,
always_apply=True))
# Coarse dropout
for k, v in transforms_list_map.items():
if k not in ("bg", "fg_bg"):
continue
v.append(
A.CoarseDropout(max_holes=2,
fill_value=0,
max_height=size[0] // 3,
max_width=size[1] // 4,
p=0.5))
# fill_value=data_stats[k]["mean"]*255.0
# for k, v in transforms_list_map.items():
# v.append(
# A.Normalize(
# mean=data_stats[k]["mean"],
# std=data_stats[k]["std"],
# max_pixel_value=255.0,
# always_apply=True
# )
# )
for k, v in transforms_list_map.items():
v.append(AP.ToTensor())
for k, v in transforms_list_map.items():
np_img = np.array(data_map[k])
if np_img.ndim == 2:
np_img = np_img[:, :, np.newaxis]
transforms_map[k] = A.Compose(v, p=1.0)(image=np_img)["image"]
# transforms_map["fg_bg_mask"] = torch.gt(transforms_map["fg_bg_mask"], 0.8).float()
return transforms_map
def pre_porcess(height=256, width=256, p=1.0):
return albumentations.Compose([albumentations.Resize(height, width)], p=p)
def __init__(self, image_size, autocrop=False):
super().__init__()
self.tfms = ab_tfms(image_size)
self.valid_tfm = ab.Resize(*image_size)
self.autocrop = autocrop
def get_valid_transforms():
return A.Compose([
A.Resize(config.dim[0], config.dim[1], always_apply=True),
A.Normalize(),
ToTensorV2(p=1.0)
])
from chexpert.data import datasets
from chexpert.data.transforms import TemplateMatch, ToRGB
parser = create_configargparser()
args = parser.parse_args()
args.device = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
args.num_classes = len(args.classes)
assert (args.model_path is not None
), "No model defined, use --model_path to define a model to validate."
preprocessing = albumentations.Compose([
TemplateMatch(args.data_dir, args.dataset),
ToRGB(),
albumentations.Resize(args.image_size, args.image_size),
])
transforms = albumentations.Compose([
albumentations.Normalize(),
ToTensorV2(),
])
if args.multi_view_model:
Dataset = datasets.MultiViewDataset
else:
Dataset = datasets.SingleViewDataset
dataset = Dataset(
data_dir=args.data_dir,
dataset=args.dataset,
import torch
import numpy as np
import cv2
from tqdm import tqdm
import random
import albumentations
import json
fpath = open('../configs/path_configs_25.json', encoding='utf-8')
path_data = json.load(fpath)
train_img_path = path_data['train_img_path']
IMAGENET_SIZE = 256
train_transform = albumentations.Compose([
albumentations.Resize(IMAGENET_SIZE, IMAGENET_SIZE),
# albumentations.RandomCrop(512, 512),
# illumilation
# albumentations.JpegCompression(quality_lower=99, quality_upper=100,p=0.5),
albumentations.OneOf([
albumentations.RandomGamma(gamma_limit=(60, 120), p=0.9),
albumentations.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
p=0.9),
albumentations.RandomBrightness(limit=0.2, p=0.9),
albumentations.RandomContrast(limit=0.2, p=0.9)
]),
# CLAHE(clip_limit=4.0, tile_grid_size=(3, 3), p=1)
# albumentations.GaussNoise(var_limit=(10, 30), p=0.5),
albumentations.HorizontalFlip(p=0.5),
9: 'boat',
10: 'bus',
11: 'car',
12: 'motorbike',
13: 'train',
14: 'bottle',
15: 'chair',
16: 'diningtable',
17: 'pottedplant',
18: 'sofa',
19: 'tvmonitor'
}
# train Data
transforms = A.Compose(
[A.Resize(448, 448), A.HueSaturationValue()],
bbox_params=A.BboxParams(format="pascal_voc",
label_fields=["category_ids"]))
trainset = MyDataset("data/train", transforms)
train_iter = DataLoader(trainset, batch_size=64, shuffle=True)
# sample image
# Data
sample_trans = A.Compose([
A.Resize(448, 448),
])
sample = cv2.imread("data/valid/image/2009_000412.jpg")
sample = cv2.cvtColor(sample, cv2.COLOR_BGR2RGB)
sample = sample_trans(image=sample)
sample = sample["image"] / 255
def get_valid_transforms(): return A.Compose([A.Resize(height=64, width=64, p=1.0), ToTensorV2(p=1.0)], p=1.0, bbox_params=A.BboxParams(format='coco',min_area=10, min_visibility=0,label_fields=['labels']) )
'pretrained_weights': None,
'optim':'sgd',
"batch_size" : 12,
"n_splits" : 5,
"fold" : 0,
"seed" : 9999,
"device" : "cuda:0",
"out_dim" : 1049,
"n_classes" : 1049,
'class_weights': 'log',
'class_weights_norm' :'batch',
"normalization" : "imagenet",
}
args['tr_aug'] = A.Compose([
A.HorizontalFlip(p=0.5),
A.ImageCompression(quality_lower=99, quality_upper=100),
A.ShiftScaleRotate(shift_limit=0.2, scale_limit=0.2, rotate_limit=10, border_mode=0, p=0.7),
A.Resize(540, 540),
A.Cutout(max_h_size=int(540 * 0.35), max_w_size=int(540 * 0.35), num_holes=1, p=0.6),
])
args['val_aug'] = A.Compose([
A.ImageCompression(quality_lower=99, quality_upper=100),
A.Resize(540, 540),
])
def pet_augmentation_valid():
transform_list = [
albu.Resize(320, 320),
]
return albu.Compose(transform_list)
def get_test_transforms(height=1024, width=1024):
"""Resize and other transformations for doing predictions"""
return A.Compose(
[A.Resize(height=height, width=width, p=1),
ToTensorV2(p=1)], p=1)
