def get_data_transforms(self):
cfg = self.cfg
bbox_params = self.get_bbox_params()
transform = Compose([Resize(cfg.data.img_sz, cfg.data.img_sz)],
bbox_params=bbox_params)
augmentors_dict = {
'Blur': Blur(),
'RandomRotate90': RandomRotate90(),
'HorizontalFlip': HorizontalFlip(),
'VerticalFlip': VerticalFlip(),
'GaussianBlur': GaussianBlur(),
'GaussNoise': GaussNoise(),
'RGBShift': RGBShift(),
'ToGray': ToGray()
}
aug_transforms = []
for augmentor in cfg.data.augmentors:
try:
aug_transforms.append(augmentors_dict[augmentor])
except KeyError as e:
log.warning(
'{0} is an unknown augmentor. Continuing without {0}. \
Known augmentors are: {1}'.format(
e, list(augmentors_dict.keys())))
aug_transforms.append(Resize(cfg.data.img_sz, cfg.data.img_sz))
aug_transform = Compose(aug_transforms, bbox_params=bbox_params)
return transform, aug_transform
def get_data_transforms(self) -> Tuple[BasicTransform, BasicTransform]:
"""Get albumentations transform objects for data augmentation.
Returns:
1st tuple arg: a transform that doesn't do any data augmentation
2nd tuple arg: a transform with data augmentation
"""
cfg = self.cfg
bbox_params = self.get_bbox_params()
transform = Compose([Resize(cfg.data.img_sz, cfg.data.img_sz)],
bbox_params=bbox_params)
augmentors_dict = {
'Blur': Blur(),
'RandomRotate90': RandomRotate90(),
'HorizontalFlip': HorizontalFlip(),
'VerticalFlip': VerticalFlip(),
'GaussianBlur': GaussianBlur(),
'GaussNoise': GaussNoise(),
'RGBShift': RGBShift(),
'ToGray': ToGray()
}
aug_transforms = []
for augmentor in cfg.data.augmentors:
try:
aug_transforms.append(augmentors_dict[augmentor])
except KeyError as e:
log.warning(
'{0} is an unknown augmentor. Continuing without {0}. \
Known augmentors are: {1}'.format(
e, list(augmentors_dict.keys())))
aug_transforms.append(Resize(cfg.data.img_sz, cfg.data.img_sz))
aug_transform = Compose(aug_transforms, bbox_params=bbox_params)
return transform, aug_transform
def oneof_always_apply_crash():
aug = Compose(
[HorizontalFlip(),
Rotate(),
OneOf([Blur(), MedianBlur()], p=1)], p=1)
image = np.ones((8, 8))
data = aug(image=image)
assert data
def test_deterministic_one_or_other():
aug = ReplayCompose([OneOrOther(HorizontalFlip(), Blur())], p=1)
for i in range(10):
image = (np.random.random((8, 8)) * 255).astype(np.uint8)
image2 = np.copy(image)
data = aug(image=image)
assert "replay" in data
data2 = ReplayCompose.replay(data["replay"], image=image2)
assert np.array_equal(data["image"], data2["image"])
def test_named_args():
image = np.empty([100, 100, 3], dtype=np.uint8)
aug = HorizontalFlip(p=1)
with pytest.raises(KeyError) as exc_info:
aug(image)
assert str(exc_info.value) == (
"'You have to pass data to augmentations as named arguments, for example: aug(image=image)'"
)
def _define_augment(self, input_shape, do_augmentation):
# mean, std, max_pixel_valueは適宜変更してください
mean = (0.485 * 255, 0.456 * 255, 0.406 * 255)
std = (0.229 * 255, 0.224 * 255, 0.225 * 255)
normalize = Normalize(mean=mean, std=std, max_pixel_value=1)
# データ拡張内容は適宜変更してください
if do_augmentation:
return Compose([normalize, HorizontalFlip(p=0.5)])
else:
return Compose([normalize])
def aug_preprocess(resize):
return Compose([
RandomResizedCrop(height=resize,
width=resize,
scale=(0.8, 1.0),
ratio=(4 / 5, 5 / 4)),
RandomBrightnessContrast(0.1, 0.1),
HorizontalFlip(p=0.5),
Lambda(image=preprocess_input)
],
p=1) # always apply augmentation
def __init__(self):
self.transforms = Compose([
HueSaturationValue(p=0.5),
RandomBrightnessContrast(),
GaussianBlur(),
HorizontalFlip(p=.5),
Normalize(mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010),
max_pixel_value=255.0,
always_apply=True,
p=1.0)
])
def __init__(self):
self.transforms = Compose([
PadIfNeeded(40, 40),
RandomCrop(32, 32),
HorizontalFlip(p=.5),
Cutout(8, 8),
Normalize(mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010),
max_pixel_value=255.0,
always_apply=True,
p=1.0),
ToTensor()
])
def rand_aug():
return Compose([
RandomRotate90(p=0.2),
GaussNoise(p=0.2),
HorizontalFlip(p=0.2),
RandomCrop(p=0.2),
HueSaturationValue(p=0.2),
RandomBrightness(p=0.2),
RandomContrast(p=0.2),
RandomGamma(p=0.2),
GaussianBlur(p=0.2),
]),
Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1.0)
def __init__(self,
df,
df_controls,
stats_experiments,
img_dir,
mode,
verbose=True,
channels=[1, 2, 3, 4, 5, 6]):
self.records = deepcopy(df).to_records(index=False)
df_conts = deepcopy(df_controls)
mask = (df_conts['well_type'] == 'negative_control') & \
(df_conts['well'] == 'B02')
df_neg_conts = df_conts[mask]
self.records_neg_conts = df_neg_conts.to_records(index=False)
mask = (df_conts['well_type'] == 'positive_control')
df_pos_conts = df_conts[mask]
self.records_pos_conts = df_pos_conts.to_records(index=False)
self.stats_exps = stats_experiments
self.mode = mode
self.channels = channels
self.img_dir = img_dir
self.len = df.shape[0]
self.transform_train = Compose([
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
ShiftScaleRotate(
shift_limit=0, scale_limit=0, rotate_limit=180, p=1.0),
RandomCrop(height=364, width=364, p=1.0)
],
p=1.0)
self.transform_val = Compose(
[CenterCrop(height=364, width=364, p=1.0)], p=1.0)
if verbose:
print()
self.imgs = self._load_imgs(self.records,
desc='Images',
verbose=verbose)
self.imgs_neg_conts = self._load_imgs(self.records_neg_conts,
desc='Negative controls',
verbose=verbose)
self.imgs_pos_conts = self._load_imgs(self.records_pos_conts,
desc='Positive controls',
verbose=verbose)
def build_databunch(data_dir, img_sz, batch_sz, class_names, augmentors):
num_workers = 4
train_dir = join(data_dir, 'train')
valid_dir = join(data_dir, 'valid')
augmentors_dict = {
'Blur': Blur(),
'RandomRotate90': RandomRotate90(),
'HorizontalFlip': HorizontalFlip(),
'VerticalFlip': VerticalFlip(),
'GaussianBlur': GaussianBlur(),
'GaussNoise': GaussNoise(),
'RGBShift': RGBShift(),
'ToGray': ToGray()
}
aug_transforms = []
for augmentor in augmentors:
try:
aug_transforms.append(augmentors_dict[augmentor])
except KeyError as e:
log.warning('{0} is an unknown augmentor. Continuing without {0}. \
Known augmentors are: {1}'.format(e,
list(
augmentors_dict.keys())))
aug_transforms = Compose(aug_transforms)
train_ds = AlbumentationDataset(ImageFolder(train_dir,
classes=class_names),
transform=aug_transforms)
valid_ds = AlbumentationDataset(ImageFolder(valid_dir,
classes=class_names))
train_dl = DataLoader(train_ds,
shuffle=True,
batch_size=batch_sz,
num_workers=num_workers,
drop_last=True,
pin_memory=True)
valid_dl = DataLoader(valid_ds,
batch_size=batch_sz,
num_workers=num_workers,
pin_memory=True)
return DataBunch(train_ds, train_dl, valid_ds, valid_dl, class_names)
def __init__(self,
df=None,
size=150,
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
augment=True,
frames=30,
stochastic=True):
""" Dataset initialization
Parameters
----------
df : pd.DataFrame
Dataframe with preprocessed data
transform : torchvision.transforms
Transformation operations for loaded images
path : str
Path to folder with the data
frames : int
Frames to load per video
"""
assert df is not None, 'Missing dataframe for data'
self.frames = frames
self.df = df[df['nframes'] >= frames]
self.stochastic = stochastic
addtl_img = {}
for idx in range(frames):
addtl_img['image{}'.format(idx)] = 'image'
if augment:
self.transform = albumentations.Compose(
[
ShiftScaleRotate(p=0.3,
scale_limit=0.25,
border_mode=1,
rotate_limit=15),
HorizontalFlip(p=0.2),
RandomBrightnessContrast(
p=0.3, brightness_limit=0.25, contrast_limit=0.5),
MotionBlur(p=.2),
GaussNoise(p=.2),
JpegCompression(p=.2, quality_lower=50),
Normalize(mean, std)
],
additional_targets=addtl_img)
else:
self.transform = albumentations.Compose([Normalize(mean, std)])
self.resize = transforms.Resize((size, size))
def transform(self, img: t.Any) -> t.Any:
max_hw = max(img.shape[0:2])
img = PadIfNeeded(max_hw, max_hw, border_mode=cv2.BORDER_REPLICATE)(image=img)[
"image"
]
img = Resize(self.resolution, self.resolution)(image=img)["image"]
img = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225],)(
image=img
)["image"]
if self.mode == "Train":
img = RandomResizedCrop(self.resolution, self.resolution)(image=img)[
"image"
]
img = Cutout(p=0.2)(image=img)["image"]
img = HorizontalFlip(p=0.5)(image=img)["image"]
img = ShiftScaleRotate(
shift_limit=0.1, scale_limit=0.0, rotate_limit=10, p=0.3
)(image=img)["image"]
img = ToTensorV2()(image=img)["image"]
return img
def get_transforms(config, mode: str = "train") -> Compose:
"""
Composes albumentations transforms.
Returns the full list of transforms when mode is "train".
mode should be one of "train", "val".
"""
# compose validation transforms
if mode == "val":
transforms = Compose(
[],
bbox_params=BboxParams(
format="pascal_voc",
min_area=0.0,
min_visibility=0.0,
label_fields=["category_id"],
),
)
# compose train transforms
# TODO: make transformation parameters configurable from yml
elif mode == "train":
transforms = Compose(
[
LongestMaxSize(
max_size=config["LONGESTMAXSIZE_MAXSIZE"],
p=config["LONGESTMAXSIZE_P"],
),
# PadIfNeeded(min_height=768, min_width=768, border_mode=0, p=1),
RandomSizedBBoxSafeCrop(
height=config["RANDOMSIZEDBBOXSAFECROP_HEIGHT"],
width=config["RANDOMSIZEDBBOXSAFECROP_WIDTH"],
p=config["LONGESTMAXSIZE_P"],
),
ShiftScaleRotate(
shift_limit=config["SHIFTSCALEROTATE_SHIFTLIMIT"],
scale_limit=config["SHIFTSCALEROTATE_SCALELIMIT"],
rotate_limit=config["SHIFTSCALEROTATE_ROTATELIMIT"],
p=config["SHIFTSCALEROTATE_P"],
),
HorizontalFlip(p=config["HORIZONTALFLIP_P"]),
RandomRotate90(p=config["RANDOMROTATE90_P"]),
RandomBrightnessContrast(
brightness_limit=config[
"RANDOMBRIGHTNESSCONTRAST_BRIGHTNESSLIMIT"],
contrast_limit=config[
"RANDOMBRIGHTNESSCONTRAST_CONTRASTLIMIT"],
p=config["RANDOMBRIGHTNESSCONTRAST_P"],
),
RandomGamma(
gamma_limit=config["RANDOMGAMMA_GAMMALIMIT"],
p=config["RANDOMGAMMA_P"],
),
HueSaturationValue(
hue_shift_limit=config["HUESATURATIONVALUE_HUESHIFTLIMIT"],
sat_shift_limit=config["HUESATURATIONVALUE_SATSHIFTLIMIT"],
val_shift_limit=config["HUESATURATIONVALUE_VALSHIFTLIMIT"],
p=config["HUESATURATIONVALUE_P"],
),
MotionBlur(
blur_limit=tuple(config["MOTIONBLUR_BLURLIMIT"]),
p=config["MOTIONBLUR_P"],
),
JpegCompression(
quality_lower=config["JPEGCOMPRESSION_QUALITYLOWER"],
quality_upper=config["JPEGCOMPRESSION_QUALITYUPPER"],
p=config["JPEGCOMPRESSION_P"],
),
],
bbox_params=BboxParams(
format="pascal_voc",
min_area=0.0,
min_visibility=0.0,
label_fields=["category_id"],
),
)
return transforms
def main():
global args, config, best_loss
args = parser.parse_args()
with open(args.config) as f:
config = yaml.load(f)
for k, v in config['common'].items():
setattr(args, k, v)
config = EasyDict(config['common'])
rank, world_size, device_id = dist_init(
os.path.join(args.distributed_path, config.distributed_file))
args.save_path_dated = args.save_path + '/' + args.datetime
if args.run_tag != '':
args.save_path_dated += '-' + args.run_tag
# create model
model = model_entry(config.model)
model.cuda()
model = nn.parallel.DistributedDataParallel(model, device_ids=[device_id])
# create optimizer
opt_config = config.optimizer
opt_config.kwargs.lr = config.lr_scheduler.base_lr
opt_config.kwargs.params = model.parameters()
optimizer = optim_entry(opt_config)
# optionally resume from a checkpoint
last_iter = -1
best_loss = 1e9
if args.load_path:
if args.recover:
best_loss, last_iter = load_state(args.load_path,
model,
optimizer=optimizer)
else:
load_state(args.load_path, model)
cudnn.benchmark = True
# train augmentation
if config.augmentation.get('imgnet_mean', False):
model_mean = (0.485, 0.456, 0.406)
model_std = (0.229, 0.224, 0.225)
else:
model_mean = (0.5, 0.5, 0.5)
model_std = (0.5, 0.5, 0.5)
trans = albumentations.Compose([
RandomResizedCrop(config.augmentation.input_size,
config.augmentation.input_size,
scale=(config.augmentation.min_scale**2., 1.),
ratio=(1., 1.)),
HorizontalFlip(p=0.5),
RandomBrightnessContrast(brightness_limit=0.25,
contrast_limit=0.1,
p=0.5),
JpegCompression(p=.2, quality_lower=50),
MotionBlur(p=0.5),
Normalize(mean=model_mean, std=model_std),
ToTensorV2()
])
train_dataset = FaceDataset(config.train_root,
config.train_source,
transform=trans,
resize=config.augmentation.input_size,
image_format=config.get('image_format', None),
random_frame=config.get(
'train_random_frame', False),
bgr=config.augmentation.get('bgr', False))
train_sampler = DistributedGivenIterationSampler(
train_dataset,
config.lr_scheduler.max_iter,
config.batch_size,
last_iter=last_iter)
train_loader = DataLoader(train_dataset,
batch_size=config.batch_size,
shuffle=False,
num_workers=config.workers,
pin_memory=True,
sampler=train_sampler)
# validation augmentation
trans = albumentations.Compose([
Resize(config.augmentation.input_size, config.augmentation.input_size),
Normalize(mean=model_mean, std=model_std),
ToTensorV2()
])
val_multi_loader = []
if args.val_source != '':
for dataset_idx in range(len(args.val_source)):
val_dataset = FaceDataset(
args.val_root[dataset_idx],
args.val_source[dataset_idx],
transform=trans,
output_index=True,
resize=config.augmentation.input_size,
image_format=config.get('image_format', None),
bgr=config.augmentation.get('bgr', False))
val_sampler = DistributedSampler(val_dataset, round_up=False)
val_loader = DataLoader(val_dataset,
batch_size=config.batch_size,
shuffle=False,
num_workers=config.workers,
pin_memory=True,
sampler=val_sampler)
val_multi_loader.append(val_loader)
config.lr_scheduler['optimizer'] = optimizer
config.lr_scheduler['last_iter'] = last_iter
lr_scheduler = get_scheduler(config.lr_scheduler)
if rank == 0:
mkdir(args.save_path)
mkdir(args.save_path_dated)
tb_logger = SummaryWriter(args.save_path_dated)
logger = create_logger('global_logger',
args.save_path_dated + '-log.txt')
logger.info('{}'.format(args))
logger.info(model)
logger.info(parameters_string(model))
logger.info('len(train dataset) = %d' % len(train_loader.dataset))
for dataset_idx in range(len(val_multi_loader)):
logger.info(
'len(val%d dataset) = %d' %
(dataset_idx, len(val_multi_loader[dataset_idx].dataset)))
mkdir(args.save_path_dated + '/saves')
else:
tb_logger = None
positive_weight = config.get('positive_weight', 0.5)
weight = torch.tensor([1. - positive_weight, positive_weight]) * 2.
if rank == 0:
logger.info('using class weights: {}'.format(weight.tolist()))
criterion = nn.CrossEntropyLoss(weight=weight).cuda()
if args.evaluate:
if args.evaluate_path:
all_ckpt = get_all_checkpoint(args.evaluate_path, args.range_list,
rank)
for ckpt in all_ckpt:
if rank == 0:
logger.info('Testing ckpt: ' + ckpt)
last_iter = -1
_, last_iter = load_state(ckpt, model, optimizer=optimizer)
for dataset_idx in range(len(val_multi_loader)):
validate(dataset_idx,
val_multi_loader[dataset_idx],
model,
criterion,
tb_logger,
curr_step=last_iter,
save_softmax=True)
else:
for dataset_idx in range(len(val_multi_loader)):
validate(dataset_idx,
val_multi_loader[dataset_idx],
model,
criterion,
tb_logger,
curr_step=last_iter,
save_softmax=True)
return
train(train_loader, val_multi_loader, model, criterion, optimizer,
lr_scheduler, last_iter + 1, tb_logger)
return
def main():
args = arg_parser()
seed_everything(args.seed)
if cuda.is_available() and not args.cpu:
device = torch.device("cuda:0")
else:
device = torch.device("cpu")
print(device)
if args.model_type == 'cnn':
if args.preprocess:
train_df = pd.read_csv('../input/preprocessed_train_df.csv')
valid_df = pd.read_csv('../input/preprocessed_valid_df.csv')
else:
train_df = pd.read_csv('../input/train_df.csv')
valid_df = pd.read_csv('../input/valid_df.csv')
valid_sample_num = 40000
elif args.model_type == 'lrcn':
if args.preprocess:
train_df = pd.read_pickle(
'../input/preprocessed_lrcn_train_df.pkl')
valid_df = pd.read_pickle(
'../input/preprocessed_lrcn_train_df.pkl')
else:
train_df = pd.read_pickle('../input/lrcn_train_df.pkl')
valid_df = pd.read_pickle('../input/lrcn_valid_df.pkl')
valid_sample_num = 15000
print("number of train data {}".format(len(train_df)))
print("number of valid data {}\n".format(len(valid_df)))
train_df = train_df.sample(frac=args.train_sample_num,
random_state=args.seed).reset_index(drop=True)
valid_df_sub = valid_df.sample(
frac=1.0, random_state=42).reset_index(drop=True)[:valid_sample_num]
valid_df_sub1 = valid_df.sample(
frac=1.0, random_state=52).reset_index(drop=True)[:valid_sample_num]
valid_df_sub2 = valid_df.sample(
frac=1.0, random_state=62).reset_index(drop=True)[:valid_sample_num]
del valid_df
gc.collect()
if args.DEBUG:
train_df = train_df[:1000]
valid_df_sub = valid_df_sub[:1000]
valid_df_sub1 = valid_df_sub1[:1000]
valid_df_sub2 = valid_df_sub2[:1000]
if args.model_type == 'cnn':
train_transforms = albumentations.Compose([
HorizontalFlip(p=0.3),
# ShiftScaleRotate(p=0.3, scale_limit=0.25, border_mode=1, rotate_limit=25),
# RandomBrightnessContrast(p=0.2, brightness_limit=0.25, contrast_limit=0.5),
# MotionBlur(p=0.2),
GaussNoise(p=0.3),
JpegCompression(p=0.3, quality_lower=50),
# Normalize()
])
valid_transforms = albumentations.Compose([
HorizontalFlip(p=0.2),
albumentations.OneOf([
JpegCompression(quality_lower=8, quality_upper=30, p=1.0),
GaussNoise(p=1.0),
],
p=0.22),
# Normalize()
])
elif args.model_type == 'lrcn':
train_transforms = None
valid_transforms = None
train_loader = build_dataset(args,
train_df,
transforms=train_transforms,
is_train=True)
batch_num = len(train_loader)
valid_loader = build_dataset(args,
valid_df_sub,
transforms=valid_transforms,
is_train=False)
valid_loader1 = build_dataset(args,
valid_df_sub1,
transforms=valid_transforms,
is_train=False)
valid_loader2 = build_dataset(args,
valid_df_sub2,
transforms=valid_transforms,
is_train=False)
model = build_model(args, device)
if args.model == 'mobilenet_v2':
save_path = os.path.join(args.PATH, 'weights', f'mobilenet_v2_best.pt')
elif args.model == 'resnet18':
save_path = os.path.join(args.PATH, 'weights', f'resnet18_best.pt')
elif args.model == 'resnet50':
save_path = os.path.join(args.PATH, 'weights', f'resnet50_best.pt')
elif args.model == 'resnext':
save_path = os.path.join(args.PATH, 'weights', f'resnext_best.pt')
elif args.model == 'xception':
save_path = os.path.join(args.PATH, 'weights', f'xception_best.pt')
else:
NotImplementedError
if args.model_type == 'lrcn':
save_path = os.path.join(args.PATH, 'weights', f'lrcn_best.pt')
optimizer = build_optimizer(args, model)
scheduler = build_scheduler(args, optimizer, batch_num)
train_cfg = {
'train_loader': train_loader,
'valid_loader': valid_loader,
'valid_loader1': valid_loader1,
'valid_loader2': valid_loader2,
'model': model,
'criterion': nn.BCEWithLogitsLoss(),
'optimizer': optimizer,
'scheduler': scheduler,
'save_path': save_path,
'device': device
}
train_model(args, train_cfg)
def build_databunch(data_dir, img_sz, batch_sz, class_names, rare_classes,
desired_prob, augmentors):
num_workers = 4
train_dir = join(data_dir, 'train')
valid_dir = join(data_dir, 'valid')
augmentors_dict = {
'Blur': Blur(),
'RandomRotate90': RandomRotate90(),
'HorizontalFlip': HorizontalFlip(),
'VerticalFlip': VerticalFlip(),
'GaussianBlur': GaussianBlur(),
'GaussNoise': GaussNoise(),
'RGBShift': RGBShift(),
'ToGray': ToGray()
}
aug_transforms = []
for augmentor in augmentors:
try:
aug_transforms.append(augmentors_dict[augmentor])
except KeyError as e:
log.warning('{0} is an unknown augmentor. Continuing without {0}. \
Known augmentors are: {1}'.format(e,
list(
augmentors_dict.keys())))
aug_transforms = Compose(aug_transforms)
train_ds = AlbumentationDataset(ImageFolder(train_dir,
classes=class_names),
transform=aug_transforms)
valid_ds = AlbumentationDataset(ImageFolder(valid_dir,
classes=class_names))
if rare_classes != []:
targets = [target for _, target in train_ds.orig_dataset.imgs]
train_sample_weights = calculate_oversampling_weights(
targets, rare_classes, desired_prob)
num_train_samples = len(train_ds)
train_sampler = WeightedRandomSampler(weights=train_sample_weights,
num_samples=num_train_samples,
replacement=True)
shuffle = False
else:
train_sampler = None
shuffle = True
train_dl = DataLoader(train_ds,
shuffle=shuffle,
batch_size=batch_sz,
num_workers=num_workers,
drop_last=True,
pin_memory=True,
sampler=train_sampler)
valid_dl = DataLoader(valid_ds,
batch_size=batch_sz,
num_workers=num_workers,
pin_memory=True)
return DataBunch(train_ds, train_dl, valid_ds, valid_dl, class_names)
### Dataloaders
X, val_X, y, val_y = get_random_sampling(paths, y, val_paths, val_y)
print('There are ' + str(y.count(1)) + ' fake train samples')
print('There are ' + str(y.count(0)) + ' real train samples')
print('There are ' + str(val_y.count(1)) + ' fake val samples')
print('There are ' + str(val_y.count(0)) + ' real val samples')
import albumentations
from albumentations.augmentations.transforms import ShiftScaleRotate, HorizontalFlip, Normalize, RandomBrightnessContrast, MotionBlur, Blur, GaussNoise, JpegCompression
train_transform = albumentations.Compose([
ShiftScaleRotate(p=0.3, scale_limit=0.25, border_mode=1, rotate_limit=25),
HorizontalFlip(p=0.2),
RandomBrightnessContrast(p=0.3, brightness_limit=0.25, contrast_limit=0.5),
MotionBlur(p=.2),
GaussNoise(p=.2),
JpegCompression(p=.2, quality_lower=50),
Normalize()
])
val_transform = albumentations.Compose([
Normalize()
])
train_dataset = ImageDataset(X, y, transform=train_transform)
val_dataset = ImageDataset(val_X, val_y, transform=val_transform)
### Train