from albumentations import Compose, Resize, HorizontalFlip, CenterCrop
from albumentations.pytorch import ToTensor
train_aug = Compose(
[HorizontalFlip(p=0.3),
Resize(128, 128, always_apply=True),
ToTensor()])
valid_aug = Compose([
CenterCrop(96, 96, always_apply=True),
Resize(128, 128, always_apply=True),
ToTensor()
])
from albumentations import Compose, Resize, RandomCrop, Flip, HorizontalFlip, VerticalFlip, Transpose
from albumentations.pytorch import ToTensor
train_aug = Compose([
RandomCrop(height=96, width=96, p=0.2),
VerticalFlip(p=0.2),
HorizontalFlip(p=0.3),
Transpose(p=0.2),
Resize(128, 128, always_apply=True),
ToTensor()
])
valid_aug = Compose([Resize(128, 128, always_apply=True), ToTensor()])
def pre_transforms(image_size=224):
return Compose([
Resize(image_size, image_size),
])
model.load_state_dict(torch.load(opt.pretrained_weights, map_location= "cpu" if not gpu else None))
optimizer = optim.Adam(model.parameters(), lr=1e-3)
scheduler = StepLR(optimizer, step_size=10, gamma=0.1)
criterion = F.cross_entropy
augmentation = Compose([
HorizontalFlip(),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.2),
OneOf([
MotionBlur(p=0.2),
MedianBlur(blur_limit=3, p=0.1),
Blur(blur_limit=3, p=0.1),
], p=0.2),
ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=30, p=0.2),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
RandomBrightnessContrast(),
], p=0.3),
], p=0.9)
data_train = OCTDataset(opt.path_to_train, transforms=augmentation, img_size=(opt.img_size, opt.img_size))
data_test = OCTDataset(opt.path_to_test, img_size=(opt.img_size, opt.img_size))
weights = get_weights(data_train)
sampler_train = WeightedRandomSampler(weights, len(data_train))
dataloader_train = DataLoader(data_train, batch_size=opt.batch_size, sampler=sampler_train, num_workers=opt.n_cpu)
canvas = canvas.astype(int)
# applying canvas
new_image = canvas + image
#limiting brightness to 255
new_image = np.vectorize(lambda x: x if x < 255 else 255)(new_image)
return new_image
augmentations = Compose([
ShiftScaleRotate(shift_limit=0.07,
scale_limit=0.07,
rotate_limit=50,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=0.95),
Lambda(image=randomBlotch, p=0.7),
ToFloat(max_value=255) # normalizes the data to [0,1] in float
])
class AugmentedDataSequence(Sequence):
def __init__(self, x_set, y_set, batch_size=32):
self.x = x_set
self.y = y_set
self.batch_size = batch_size
def __len__(self):
return int(np.ceil((len(self.x) + 0.0) / self.batch_size))
hist_rater_b.view(1, num_classes)) /
labels.shape[0]).sum()
return nom / (denom + epsilon)
# def mixed_loss(logits, labels):
# return .5 * qwk(logits, labels) + .5 * torch.nn.functional.cross_entropy(logits, labels)
augment_transform = Compose([
HorizontalFlip(p=.5),
VerticalFlip(p=.5),
RandomRotate90(p=.5),
ShiftScaleRotate(shift_limit=0, scale_limit=.1, rotate_limit=0, p=.5),
OneOf([
RandomContrast(limit=.2),
RandomGamma(gamma_limit=(80, 120)),
RandomBrightness(limit=.2)
],
p=.5),
Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1),
# CenterCrop(IMG_CROP_SIZE, IMG_CROP_SIZE, p=.5),
Resize(args.image_size, args.image_size),
ToTensor()
])
base_transform = Compose([
HorizontalFlip(p=.5),
VerticalFlip(p=.5),
RandomRotate90(p=.5),
Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1),
Resize(args.image_size, args.image_size),
ToTensor()
png = np.array(png)
train = train.set_index('Image').loc[png].reset_index()
# get fold
valdf = train[train['fold'] == fold].reset_index(drop=True)
trndf = train[train['fold'] != fold].reset_index(drop=True)
# Data loaders
mean_img = [0.22363983, 0.18190407, 0.2523437]
std_img = [0.32451536, 0.2956294, 0.31335256]
transform_train = Compose([
HorizontalFlip(p=0.5),
ShiftScaleRotate(shift_limit=0.05,
scale_limit=0.05,
rotate_limit=20,
p=0.3,
border_mode=cv2.BORDER_REPLICATE),
Transpose(p=0.5),
Normalize(mean=mean_img, std=std_img, max_pixel_value=255.0, p=1.0),
ToTensor()
])
HFLIPVAL = 1.0 if HFLIP == 'T' else 0.0
TRANSPOSEVAL = 1.0 if TRANSPOSE == 'P' else 0.0
transform_test = Compose([
HorizontalFlip(p=HFLIPVAL),
Transpose(p=TRANSPOSEVAL),
Normalize(mean=mean_img, std=std_img, max_pixel_value=255.0, p=1.0),
ToTensor()
])
def val_transform(p=1):
return Compose([Normalize(p=1)], p=p)
def build_test(self):
return Compose([
CenterCrop(64, 32),
ToTensor(),
])
"spot": sparse_categorical_crossentropy
}
lossWeights = {"defect": 1.0, "lacuna": 1.0, "spoke": 1.0, "spot": 1.0}
model.compile(loss=sparse_categorical_crossentropy,
optimizer='rmsprop',
metrics=['accuracy'],
loss_weights=lossWeights)
print('# 3) 데이터셋 생성')
AUGMENTATIONS_TRAIN = Compose([
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
ShiftScaleRotate(p=0.8),
RandomRotate90(p=0.8),
Transpose(p=0.5),
RandomSizedCrop(min_max_height=(FLG.HEIGHT * 2 / 3, FLG.WIDTH * 2 / 3),
height=FLG.HEIGHT,
width=FLG.WIDTH,
p=0.5),
RandomContrast(p=0.5),
RandomGamma(p=0.5),
RandomBrightness(p=0.5)
])
AUGMENTATIONS_TEST = Compose([VerticalFlip(p=0.5)])
data_dir = 'D:\Data\iris_pattern\Multi_output2_test40_train160'
dataLoader = {
'TrainGenerator':
ImageGenerator(data_dir + '/train', augmentations=AUGMENTATIONS_TRAIN),
'ValGenerator':
ImageGenerator(data_dir + '/test', augmentations=AUGMENTATIONS_TEST)
def train_transform(p=1):
return Compose(
[VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
Normalize(p=1)], p=p)
x_train, x_test, y_train, y_test = train_test_split(x_train, y_train, test_size=0.1, stratify=y_train,
random_state=17)
# normalizes using train_set data
channel_wise_mean = np.reshape(np.array([125.3, 123.0, 113.9]), (1, 1, 1, -1))
channel_wise_std = np.reshape(np.array([63.0, 62.1, 66.7]), (1, 1, 1, -1))
x_train = (x_train - channel_wise_mean) / channel_wise_std
x_test = (x_test - channel_wise_mean) / channel_wise_std
# Convert class vectors to binary class matrices.
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)
# data augmentation
augmentation = Compose([PadIfNeeded(min_height=40, min_width=40, border_mode=cv2.BORDER_REFLECT_101, p=1.0),
RandomCrop(32, 32, p=1.0),
HorizontalFlip(p=0.5)])
def real_data_augmentation_library(image, augmentation=augmentation):
augmented = augmentation(image=image)
return augmented['image']
datagen = ImageDataGenerator(preprocessing_function=real_data_augmentation_library)
# learning rate
if args.lr_type == 'adam':
optimizer = Adam(lr=args.learning_rate, beta_1=0.75)
callbacks = []
else:
if args.lr_type == 'rmsprop':
def step_decay(_, current_lr, decay_factor=args.lr_decay_ratio):
n_classes = 10
else:
n_classes = 1
#alaska_data = Alaska(PATH, train_val_ratio, mode, multiclass_file='./multiclass_stega_df.csv')
alaska_data = Alaska(PATH, train_val_ratio, mode, multiclass_file='./multiclass_stega_df_ricard.csv')
data = alaska_data.build()
IMAGE_IDS_train = data[0]
IMAGE_LABELS_train = data[1]
IMAGE_IDS_val = data[2]
IMAGE_LABELS_val = data[3]
AUGMENTATIONS_TRAIN = Compose([
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
ToFloat(max_value=255),
ToTensor()
], p=1)
AUGMENTATIONS_TEST = Compose([
ToFloat(max_value=255),
ToTensor()
], p=1)
train_dataset = Alaska2Dataset(IMAGE_IDS_train, IMAGE_LABELS_train, augmentations=AUGMENTATIONS_TRAIN, color_mode=color_mode)
valid_dataset = Alaska2Dataset(IMAGE_IDS_val, IMAGE_LABELS_val, augmentations=AUGMENTATIONS_TEST, color_mode=color_mode)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
def val_transform(p=1):
return Compose([
Normalize(p=1, mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
], p=p)
def apply_image_augmentation(augmentator, image):
augmented_image = augmentator(image=image)["image"]
return augmented_image
def horizontal_stack_images(image_1, image_2):
return np.hstack((image_1, image_2))
if __name__ == "__main__":
print("[INFO] Augmentation example, press 'q' to finish the example")
# Instancia o objeto de augmentação
augmentator = Compose([
Rotate(15),
Blur(5),
IAAPerspective(scale=(0.025, 0.05), p=0.8),
RandomBrightnessContrast(brightness_limit=0.35, contrast_limit=0.35)
],
p=0.7)
dataset, (characters_images,
characters_labels) = read_hdf5_dataset("characters_dataset.hdf5")
for idx, image in enumerate(characters_images):
augmented_image = apply_image_augmentation(augmentator, image)
cv2.imshow("Character x Augmented character",
horizontal_stack_images(image, augmented_image))
print("[INFO] Label => ", characters_labels[idx])
key = cv2.waitKey(0) & 0xff
if key == ord('q'):
)
transformimg = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406][::-1], std=[0.225, 0.224, 0.225][::-1]
),
]
)
transformaug = Compose(
[
VerticalFlip(p=0.5),
RandomRotate90(p=0.5),
ISONoise(p=0.5),
RandomBrightnessContrast(p=0.5),
RandomGamma(p=0.5),
RandomFog(fog_coef_lower=0.05, fog_coef_upper=0.15, p=0.5),
]
)
class XViewDataset(Dataset):
def __init__(
self, size=None, aug=True, pattern="data/train/images1024/*pre_disaster*.png"
):
self.name = "train"
self.aug = aug
self.pre = glob(pattern)
if size:
},
'train': {
'mean': [0.485, 0.456, 0.406],
'std': [0.229, 0.224, 0.225],
'loss': EXPERIMENT_TYPE_LOSS_SIMPLE,
'data': EXPERIMENT_TYPE_USE_ORIGINAL,
'contact': 13,
'init_lr': 0.0005,
'batch_size': 12,
'epochs': 60,
'train_transform': Compose(
[RandomCrop(512, 512, p=1.0),
HorizontalFlip(p=.5),
VerticalFlip(p=.5),
RandomRotate90(p=0.5),
RandomBrightnessContrast(p=0.3),
Blur(p=0.3),
Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
ToTensor(),
]),
'valid_transform': Compose(
[CenterCrop(512, 512, p=1.0),
Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
ToTensor()
]),
'infer_transform': Compose(
[
Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
def pad_img(h, w, interpolation=0):
return Compose([
PadIfNeeded(h, w, border_mode=0, always_apply=True),
Resize(h, w, interpolation=interpolation, always_apply=True),
])
def train(model, cfg, model_cfg, start_epoch=0):
cfg.batch_size = 28 if cfg.batch_size < 1 else cfg.batch_size
cfg.val_batch_size = cfg.batch_size
cfg.input_normalization = model_cfg.input_normalization
crop_size = model_cfg.crop_size
loss_cfg = edict()
loss_cfg.instance_loss = SigmoidBinaryCrossEntropyLoss()
loss_cfg.instance_loss_weight = 1.0
num_epochs = 120
num_masks = 1
train_augmentator = Compose([
Flip(),
RandomRotate90(),
ShiftScaleRotate(shift_limit=0.03,
scale_limit=0,
rotate_limit=(-3, 3),
border_mode=0,
p=0.75),
PadIfNeeded(
min_height=crop_size[0], min_width=crop_size[1], border_mode=0),
RandomCrop(*crop_size),
RandomBrightnessContrast(brightness_limit=(-0.25, 0.25),
contrast_limit=(-0.15, 0.4),
p=0.75),
RGBShift(r_shift_limit=10, g_shift_limit=10, b_shift_limit=10, p=0.75)
],
p=1.0)
val_augmentator = Compose([
PadIfNeeded(
min_height=crop_size[0], min_width=crop_size[1], border_mode=0),
RandomCrop(*crop_size)
],
p=1.0)
def scale_func(image_shape):
return random.uniform(0.75, 1.25)
points_sampler = MultiPointSampler(model_cfg.num_max_points,
prob_gamma=0.7,
merge_objects_prob=0.15,
max_num_merged_objects=2)
trainset = SBDDataset(
cfg.SBD_PATH,
split='train',
num_masks=num_masks,
augmentator=train_augmentator,
points_from_one_object=False,
input_transform=model_cfg.input_transform,
min_object_area=80,
keep_background_prob=0.0,
image_rescale=scale_func,
points_sampler=points_sampler,
samples_scores_path='./models/sbd/sbd_samples_weights.pkl',
samples_scores_gamma=1.25)
valset = SBDDataset(cfg.SBD_PATH,
split='val',
augmentator=val_augmentator,
num_masks=num_masks,
points_from_one_object=False,
input_transform=model_cfg.input_transform,
min_object_area=80,
image_rescale=scale_func,
points_sampler=points_sampler)
optimizer_params = {'lr': 5e-4, 'betas': (0.9, 0.999), 'eps': 1e-8}
lr_scheduler = partial(torch.optim.lr_scheduler.MultiStepLR,
milestones=[100],
gamma=0.1)
trainer = ISTrainer(model,
cfg,
model_cfg,
loss_cfg,
trainset,
valset,
optimizer_params=optimizer_params,
lr_scheduler=lr_scheduler,
checkpoint_interval=5,
image_dump_interval=200,
metrics=[AdaptiveIoU()],
max_interactive_points=model_cfg.num_max_points)
logger.info(f'Starting Epoch: {start_epoch}')
logger.info(f'Total Epochs: {num_epochs}')
for epoch in range(start_epoch, num_epochs):
trainer.training(epoch)
trainer.validation(epoch)
def run(*options, cfg=None, debug=False):
"""Run training and validation of model
Notes:
Options can be passed in via the options argument and loaded from the cfg file
Options from default.py will be overridden by options loaded from cfg file
Options passed in via options argument will override option loaded from cfg file
Args:
*options (str,int ,optional): Options used to overide what is loaded from the
config. To see what options are available consult
default.py
cfg (str, optional): Location of config file to load. Defaults to None.
debug (bool): Places scripts in debug/test mode and only executes a few iterations
"""
update_config(config, options=options, config_file=cfg)
# Start logging
load_log_configuration(config.LOG_CONFIG)
logger = logging.getLogger(__name__)
logger.debug(config.WORKERS)
scheduler_step = config.TRAIN.END_EPOCH // config.TRAIN.SNAPSHOTS
torch.backends.cudnn.benchmark = config.CUDNN.BENCHMARK
torch.manual_seed(config.SEED)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(config.SEED)
np.random.seed(seed=config.SEED)
# Setup Augmentations
basic_aug = Compose([
Normalize(mean=(config.TRAIN.MEAN, ),
std=(config.TRAIN.STD, ),
max_pixel_value=1),
Resize(
config.TRAIN.AUGMENTATIONS.RESIZE.HEIGHT,
config.TRAIN.AUGMENTATIONS.RESIZE.WIDTH,
always_apply=True,
),
PadIfNeeded(
min_height=config.TRAIN.AUGMENTATIONS.PAD.HEIGHT,
min_width=config.TRAIN.AUGMENTATIONS.PAD.WIDTH,
border_mode=cv2.BORDER_CONSTANT,
always_apply=True,
mask_value=255,
),
])
if config.TRAIN.AUGMENTATION:
train_aug = Compose([basic_aug, HorizontalFlip(p=0.5)])
val_aug = basic_aug
else:
train_aug = val_aug = basic_aug
TrainPatchLoader = get_patch_loader(config)
train_set = TrainPatchLoader(
config.DATASET.ROOT,
split="train",
is_transform=True,
stride=config.TRAIN.STRIDE,
patch_size=config.TRAIN.PATCH_SIZE,
augmentations=train_aug,
)
val_set = TrainPatchLoader(
config.DATASET.ROOT,
split="val",
is_transform=True,
stride=config.TRAIN.STRIDE,
patch_size=config.TRAIN.PATCH_SIZE,
augmentations=val_aug,
)
n_classes = train_set.n_classes
train_loader = data.DataLoader(
train_set,
batch_size=config.TRAIN.BATCH_SIZE_PER_GPU,
num_workers=config.WORKERS,
shuffle=True,
)
val_loader = data.DataLoader(
val_set,
batch_size=config.VALIDATION.BATCH_SIZE_PER_GPU,
num_workers=config.WORKERS,
)
model = getattr(models, config.MODEL.NAME).get_seg_model(config)
device = "cpu"
if torch.cuda.is_available():
device = "cuda"
model = model.to(device) # Send to GPU
optimizer = torch.optim.SGD(
model.parameters(),
lr=config.TRAIN.MAX_LR,
momentum=config.TRAIN.MOMENTUM,
weight_decay=config.TRAIN.WEIGHT_DECAY,
)
try:
output_dir = generate_path(
config.OUTPUT_DIR,
git_branch(),
git_hash(),
config.MODEL.NAME,
current_datetime(),
)
except TypeError:
output_dir = generate_path(
config.OUTPUT_DIR,
config.MODEL.NAME,
current_datetime(),
)
summary_writer = create_summary_writer(
log_dir=path.join(output_dir, config.LOG_DIR))
snapshot_duration = scheduler_step * len(train_loader)
scheduler = CosineAnnealingScheduler(optimizer, "lr", config.TRAIN.MAX_LR,
config.TRAIN.MIN_LR,
snapshot_duration)
# weights are inversely proportional to the frequency of the classes in the
# training set
class_weights = torch.tensor(config.DATASET.CLASS_WEIGHTS,
device=device,
requires_grad=False)
criterion = torch.nn.CrossEntropyLoss(weight=class_weights,
ignore_index=255,
reduction="mean")
trainer = create_supervised_trainer(model,
optimizer,
criterion,
prepare_batch,
device=device)
trainer.add_event_handler(Events.ITERATION_STARTED, scheduler)
trainer.add_event_handler(
Events.ITERATION_COMPLETED,
logging_handlers.log_training_output(log_interval=config.PRINT_FREQ),
)
trainer.add_event_handler(Events.EPOCH_STARTED,
logging_handlers.log_lr(optimizer))
trainer.add_event_handler(
Events.EPOCH_STARTED,
tensorboard_handlers.log_lr(summary_writer, optimizer, "epoch"),
)
trainer.add_event_handler(
Events.ITERATION_COMPLETED,
tensorboard_handlers.log_training_output(summary_writer),
)
def _select_pred_and_mask(model_out_dict):
return (model_out_dict["y_pred"].squeeze(),
model_out_dict["mask"].squeeze())
evaluator = create_supervised_evaluator(
model,
prepare_batch,
metrics={
"nll":
Loss(criterion, output_transform=_select_pred_and_mask),
"pixacc":
pixelwise_accuracy(n_classes,
output_transform=_select_pred_and_mask,
device=device),
"cacc":
class_accuracy(n_classes, output_transform=_select_pred_and_mask),
"mca":
mean_class_accuracy(n_classes,
output_transform=_select_pred_and_mask),
"ciou":
class_iou(n_classes, output_transform=_select_pred_and_mask),
"mIoU":
mean_iou(n_classes, output_transform=_select_pred_and_mask),
},
device=device,
)
# Set the validation run to start on the epoch completion of the training run
if debug:
logger.info("Running Validation in Debug/Test mode")
val_loader = take(3, val_loader)
trainer.add_event_handler(Events.EPOCH_COMPLETED,
Evaluator(evaluator, val_loader))
evaluator.add_event_handler(
Events.EPOCH_COMPLETED,
logging_handlers.log_metrics(
"Validation results",
metrics_dict={
"nll": "Avg loss :",
"pixacc": "Pixelwise Accuracy :",
"mca": "Avg Class Accuracy :",
"mIoU": "Avg Class IoU :",
},
),
)
evaluator.add_event_handler(
Events.EPOCH_COMPLETED,
tensorboard_handlers.log_metrics(
summary_writer,
trainer,
"epoch",
metrics_dict={
"mIoU": "Validation/mIoU",
"nll": "Validation/Loss",
"mca": "Validation/MCA",
"pixacc": "Validation/Pixel_Acc",
},
),
)
def _select_max(pred_tensor):
return pred_tensor.max(1)[1]
def _tensor_to_numpy(pred_tensor):
return pred_tensor.squeeze().cpu().numpy()
transform_func = compose(np_to_tb, decode_segmap(n_classes=n_classes),
_tensor_to_numpy)
transform_pred = compose(transform_func, _select_max)
evaluator.add_event_handler(
Events.EPOCH_COMPLETED,
create_image_writer(summary_writer, "Validation/Image", "image"),
)
evaluator.add_event_handler(
Events.EPOCH_COMPLETED,
create_image_writer(summary_writer,
"Validation/Mask",
"mask",
transform_func=transform_func),
)
evaluator.add_event_handler(
Events.EPOCH_COMPLETED,
create_image_writer(summary_writer,
"Validation/Pred",
"y_pred",
transform_func=transform_pred),
)
def snapshot_function():
return (trainer.state.iteration % snapshot_duration) == 0
checkpoint_handler = SnapshotHandler(
path.join(output_dir, config.TRAIN.MODEL_DIR),
config.MODEL.NAME,
extract_metric_from("mIoU"),
snapshot_function,
)
evaluator.add_event_handler(Events.EPOCH_COMPLETED, checkpoint_handler,
{"model": model})
logger.info("Starting training")
if debug:
logger.info("Running Training in Debug/Test mode")
train_loader = take(3, train_loader)
trainer.run(train_loader, max_epochs=config.TRAIN.END_EPOCH)
AUGMENTATIONS_TRAIN = Compose(
[
HorizontalFlip(p=0.5),
RandomContrast(limit=0.2, p=0.5),
RandomGamma(gamma_limit=(80, 120), p=0.5),
RandomBrightness(limit=1.2, p=0.5),
HueSaturationValue(
hue_shift_limit=5, sat_shift_limit=20, val_shift_limit=10, p=.5),
# CenterCrop(height=128, width=128, p=0.5),
Cutout(p=0.5),
OneOf([
MotionBlur(p=0.2),
MedianBlur(blur_limit=3, p=0.1),
Blur(blur_limit=3, p=0.1),
],
p=0.3),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.2),
# CLAHE(p=1.0, clip_limit=2.0),
ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.1,
rotate_limit=15,
border_mode=cv2.BORDER_REFLECT_101,
p=0.5),
# ToFloat(max_value=1)
],
p=1)
])
seg_aug = Compose([
Transpose(p=0.5),
RandomRotate90(p=1),
# RandomBrightnessContrast(p=1),
# RandomGamma(p=1),
OneOf([
# GaussNoise(p=1),
RandomBrightnessContrast(p=1),
RandomGamma(p=1),
]),
# OneOf([
# ElasticTransform(p=1, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
# ShiftScaleRotate(p=1),
# ]),
# ElasticTransform(p=1, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
# # ElasticTransform(p=1, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
OneOf([
ElasticTransform(p=1,
alpha=120,
sigma=120 * 0.05,
alpha_affine=120 * 0.03),
GridDistortion(p=1),
# ShiftScaleRotate(p=1),
OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5)
]),
RandomCrop(256, 256, p=1)
])
seg_aug_2 = Compose([
def valid_transforms(self,sz):
return Compose([
A.Resize(sz, sz),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0),
ToTensorV2(p=1.0),
], p=1.)
super(CarsRecognizer, self).__init__()
self.backbone = EfficientNet.from_name('efficientnet-b5')
self.avg_pooling = nn.AdaptiveAvgPool2d(1)
self.dropout = nn.Dropout(0.15)
self.linear = LazyLinear(in_features=None, out_features=n_classes)
def forward(self, img):
features = self.backbone.extract_features(img)
features = self.avg_pooling(features).squeeze()
features = self.dropout(features)
logits = self.linear(features)
return logits
test_transform = Compose(
[Resize(IMAGE_SIZE, IMAGE_SIZE),
Normalize(), ToTensor()])
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = CarsRecognizer(n_classes=11)
cp = torch.load(PATH_TO_WEIGHTS, map_location=device)
model.load_state_dict(cp['state_dict'])
def predict(image_path):
id2cartype = {
0: 'MAZDA_3_B',
1: 'КIА_RIО_B',
2: 'VОLКSWАGЕN_РОLО_B',
3: 'VOLVO_ALLVOLVO_C',
def __init__(self):
self.transform = Compose([
Normalize((0.4914, 0.4822, 0.4465), ((0.2023, 0.1994, 0.2010))),
ToTensor(),
])
def train(args):
# augmentations
train_transform = Compose([
Resize(args.img_size, args.img_size),
Cutout(num_holes=8, max_h_size=20, max_w_size=20, fill_value=0, always_apply=False, p=0.5),
Normalize(
mean=[0.0692],
std=[0.205],
),
ToTensorV2()
])
val_transform = Compose([
Resize(args.img_size, args.img_size),
Normalize(
mean=[0.0692],
std=[0.205],
),
ToTensorV2()
])
# Load data
df_train = pd.read_csv("../input/train_folds.csv")
if args.fold == -1:
sys.exit()
train = df_train[df_train['kfold']!=args.fold].reset_index(drop=True)#[:1000]
val = df_train[df_train['kfold']==args.fold].reset_index(drop=True)#[:1000]
train_data = ImageDataset('../input/images', train_transform, train)
train_loader = utils.DataLoader(train_data, shuffle=True, num_workers=5, batch_size=args.batch_size, pin_memory=True)
val_data = ImageDataset('../input/images', val_transform, val)
val_loader = utils.DataLoader(val_data, shuffle=False, num_workers=5, batch_size=args.batch_size, pin_memory=True)
# create model
device = torch.device(f"cuda:{args.gpu_n}")
model = PretrainedCNN()
if args.pretrain_path != "":
model.load_state_dict(torch.load(args.pretrain_path, map_location=f"cuda:{args.gpu_n}"))
print("weights loaded")
model.to(device)
optimizer = RAdam(model.parameters(), lr=args.start_lr)
opt_level = 'O1'
model, optimizer = amp.initialize(model, optimizer, opt_level=opt_level)
loss_fn = nn.CrossEntropyLoss()
scheduler = ReduceLROnPlateau(optimizer, mode='max', verbose=True, patience=8, factor=0.6)
best_models = deque(maxlen=5)
best_score = 0.99302
for e in range(args.epoch):
# Training:
train_loss = []
model.train()
for image, target in tqdm(train_loader, ncols = 70):
optimizer.zero_grad()
xs = image.to(device)
ys = target.to(device)
# Cutmix using with BUG
if np.random.rand()<0.5:
images, targets = cutmix(xs, ys[:,0], ys[:,1], ys[:,2], 1.0)
pred = model(xs)
output1 = pred[:,:168]
output2 = pred[:,168:179]
output3 = pred[:,179:]
loss = cutmix_criterion(output1,output2,output3, targets)
else:
pred = model(xs)
grapheme = pred[:,:168]
vowel = pred[:,168:179]
cons = pred[:,179:]
loss = loss_fn(grapheme, ys[:,0]) + loss_fn(vowel, ys[:,1])+ loss_fn(cons, ys[:,2])
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
optimizer.step()
train_loss.append(loss.item())
#Validation
val_loss = []
val_true = []
val_pred = []
model.eval()
with torch.no_grad():
for image, target in val_loader:#tqdm(val_loader, ncols=50):
xs = image.to(device)
ys = target.to(device)
pred = model(xs)
grapheme = pred[:,:168]
vowel = pred[:,168:179]
cons = pred[:,179:]
loss = loss_fn(grapheme, ys[:,0]) + loss_fn(vowel, ys[:,1])+ loss_fn(cons, ys[:,2])
val_loss.append(loss.item())
grapheme = grapheme.cpu().argmax(dim=1).data.numpy()
vowel = vowel.cpu().argmax(dim=1).data.numpy()
cons = cons.cpu().argmax(dim=1).data.numpy()
val_true.append(target.numpy())
val_pred.append(np.stack([grapheme, vowel, cons], axis=1))
val_true = np.concatenate(val_true)
val_pred = np.concatenate(val_pred)
val_loss = np.mean(val_loss)
train_loss = np.mean(train_loss)
scores = []
for i in [0,1,2]:
scores.append(sklearn.metrics.recall_score(val_true[:,i], val_pred[:,i], average='macro'))
final_score = np.average(scores, weights=[2,1,1])
print(f'Epoch: {e:03d}; train_loss: {train_loss:.05f}; val_loss: {val_loss:.05f}; ', end='')
print(f'score: {final_score:.5f} ', end='')
# Checkpoint model. If there are 2nd stage(224x224) save best 5 checkpoints
if final_score > best_score:
best_score = final_score
state_dict = copy.deepcopy(model.state_dict())
if args.save_queue==1:
best_models.append(state_dict)
for i, m in enumerate(best_models):
path = f"models/{args.exp_name}"
os.makedirs(path, exist_ok=True)
torch.save(m, join(path, f"{i}.pt"))
else:
path = f"models/{args.exp_name}"
os.makedirs(path, exist_ok=True)
torch.save(state_dict, join(path, "model.pt"))
print('+')
else:
print()
scheduler.step(final_score)
path_to_data = "./data/test_images"
path_to_csv = "./data/test.csv"
path_to_checkpoint = "./logs/test/checkpoints/best.pth"
path_to_submission = "./data/sample_submission.csv"
image_size = 256
batch_size = 32
num_workers = 4
device = torch.device("cuda:0")
checkpoint = torch.load(path_to_checkpoint)
model = resnet34(num_classes=1)
model.load_state_dict(checkpoint['model_state_dict'])
model = model.to(device)
model.eval()
test_transforms = Compose([pre_transforms(image_size), post_transforms()])
test_dataset = RetinopathyDatasetTest(csv_file=path_to_csv,
path_to_data=path_to_data,
transform=test_transforms)
test_dl = torch.utils.data.DataLoader(test_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers)
test_preds = predict(test_dl)
test_preds = round_preds(test_preds)
sample = pd.read_csv(path_to_submission)
sample.diagnosis = test_preds.astype(int)
print(sample.head())
sample.to_csv("submission.csv", index=False)
import jpeg4py
import cv2
import torch
from utils.preprocess import anno_open, questions_preproc
from torch.utils.data import Dataset
from albumentations.pytorch import ToTensor
from albumentations import (Compose, CenterCrop, VerticalFlip, RandomSizedCrop,
HorizontalFlip, HueSaturationValue,
ShiftScaleRotate, Resize, RandomCrop, Normalize,
Rotate, Normalize)
h, w = 224, 224
transforms = {
'train': Compose([Resize(h, w), Normalize(),
ToTensor()]),
'val': Compose([Resize(h, w), Normalize(),
ToTensor()]),
'test': Compose([Resize(h, w), Normalize(),
ToTensor()]),
}
class VQA(Dataset):
def __init__(self,
path,
bag_of_words,
ans_dict=None,
transfrom=transforms,
mode='train'):
self.path = path
self.ans_dict = ans_dict
def post_transforms():
return Compose([Normalize(), ToTensor()])
def main():
# check cuda available
assert torch.cuda.is_available() == True
# when the input dimension doesnot change, add this flag to speed up
cudnn.benchmark = True
num_classes = config.num_classes[config.problem_type]
# input are RGB images in size 3 * h * w
# output are binary
model = config.model(3, num_classes)
# data parallel
model = nn.DataParallel(model, device_ids=config.device_ids).cuda()
# loss function
if num_classes == 2:
loss = LossBinary(jaccard_weight=config.jaccard_weight)
valid_metric = validation_binary
else:
loss = LossMulti(num_classes=num_classes,
jaccard_weight=config.jaccard_weight)
valid_metric = validation_multi
# train/valid filenmaes
train_filenames, valid_filenames = trainval_split(config.fold)
print('num of train / validation files = {} / {}'.format(
len(train_filenames), len(valid_filenames)))
# trainset transform
train_transform = Compose([
Resize(height=config.train_height, width=config.train_width, p=1),
Normalize(p=1)
],
p=1)
# validset transform
valid_transform = Compose([
Resize(height=config.train_height, width=config.train_width, p=1),
Normalize(p=1)
],
p=1)
# train dataloader
train_loader = DataLoader(dataset=RobotSegDataset(
train_filenames, transform=train_transform),
shuffle=True,
num_workers=config.num_workers,
batch_size=config.batch_size,
pin_memory=True)
# valid dataloader
valid_loader = DataLoader(
dataset=RobotSegDataset(valid_filenames, transform=valid_transform),
shuffle=True,
num_workers=config.num_workers,
batch_size=len(
config.device_ids), # in valid time use one img for each dataset
pin_memory=True)
train(model=model,
loss_func=loss,
train_loader=train_loader,
valid_loader=valid_loader,
valid_metric=valid_metric,
fold=config.fold,
num_classes=num_classes)
