def __init__(self):
# Variables to hold the description of the experiment
self.description = ""
# System dependent variable
self._workers = 10
self._multiprocessing = True
# Variables for comet.ml
self._project_name = "jpeg-deep"
self._workspace = "classification_lcrfat"
# Network variables
self._weights = None
self._network = late_concat_rfa_thinner()
# Training variables
self._epochs = 90
self._batch_size = 32
self._steps_per_epoch = 1281167 // self.batch_size
self._validation_steps = 50000 // self._batch_size
self.optimizer_parameters = {
"lr": 0.0125, "momentum": 0.9}
self._optimizer = SGD(**self.optimizer_parameters)
self._loss = categorical_crossentropy
self._metrics = ['accuracy', 'top_k_categorical_accuracy']
self.train_directory = join(
environ["DATASET_PATH_TRAIN"], "train")
self.validation_directory = join(
environ["DATASET_PATH_VAL"], "validation")
self.test_directory = join(
environ["DATASET_PATH_TEST"], "validation")
self.index_file = "data/imagenet_class_index.json"
# Defining the transformations that will be applied to the inputs.
self.train_transformations = [
SmallestMaxSize(256),
RandomCrop(224, 224),
HorizontalFlip()
]
self.validation_transformations = [
SmallestMaxSize(256), CenterCrop(224, 224)]
self.test_transformations = [SmallestMaxSize(256)]
# Keras stuff
self.reduce_lr_on_plateau = ReduceLROnPlateau(patience=5, verbose=1)
self.terminate_on_nan = TerminateOnNaN()
self.early_stopping = EarlyStopping(monitor='val_loss',
min_delta=0,
patience=11)
self._callbacks = [self.reduce_lr_on_plateau,
self.terminate_on_nan, self.early_stopping]
self._train_generator = None
self._validation_generator = None
self._test_generator = None
self._displayer = ImageNetDisplayer(self.index_file)
def train(model, cfg, model_cfg, start_epoch=0):
cfg.batch_size = 32 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 = NormalizedFocalLossSigmoid(alpha=0.5, gamma=2)
loss_cfg.instance_loss_weight = 1.0
loss_cfg.instance_aux_loss = SigmoidBinaryCrossEntropyLoss()
loss_cfg.instance_aux_loss_weight = 0.4
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='adam',
optimizer_params=optimizer_params,
lr_scheduler=lr_scheduler,
checkpoint_interval=5,
image_dump_interval=100,
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 main():
with open('config.yaml', 'r') as f:
config = yaml.load(f)
set_global_seed(SEED)
prepare_cudnn(deterministic=True, benchmark=True)
model = EfficientNet.from_name('efficientnet-b7',
override_params={'num_classes': 1})
state = torch.load(PRETRAINED_WEIGHTS_PATH,
map_location=lambda storage, loc: storage)
state.pop('_fc.weight')
state.pop('_fc.bias')
res = model.load_state_dict(state, strict=False)
assert set(res.missing_keys) == set(['_fc.weight', '_fc.bias'
]), 'issue loading pretrained weights'
for module in model.modules():
if isinstance(module, MBConvBlock):
if module._block_args.expand_ratio != 1:
expand_conv = module._expand_conv
seq_expand_conv = SeqExpandConv(expand_conv.in_channels,
expand_conv.out_channels,
len(TRAIN_INDICES))
seq_expand_conv.conv.weight.data[:, :, 0, :, :].copy_(
expand_conv.weight.data / 3)
seq_expand_conv.conv.weight.data[:, :, 1, :, :].copy_(
expand_conv.weight.data / 3)
seq_expand_conv.conv.weight.data[:, :, 2, :, :].copy_(
expand_conv.weight.data / 3)
module._expand_conv = seq_expand_conv
model = model.cuda()
normalize = Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
_, rand_augment, _ = transforms_imagenet_train(
(CROP_HEIGHT, CROP_WIDTH),
auto_augment='original-mstd0.5',
separate=True)
train_dataset = TrackPairDataset(
os.path.join(config['ARTIFACTS_PATH'], TRACKS_ROOT),
os.path.join(config['ARTIFACTS_PATH'], TRACK_PAIRS_FILE_NAME),
TRAIN_INDICES,
track_length=TRACK_LENGTH,
track_transform=TrackTransform(FPS_RANGE, SCALE_RANGE, CRF_RANGE,
TUNE_VALUES),
image_transform=Compose([
SmallestMaxSize(MIN_SIZE),
HorizontalFlip(),
RandomCrop(CROP_HEIGHT, CROP_WIDTH),
VisionTransform(rand_augment, p=0.5), normalize,
ToTensor()
]),
sequence_mode=True)
print('Train dataset size: {}.'.format(len(train_dataset)))
warmup_optimizer = torch.optim.SGD(model._fc.parameters(),
INITIAL_LR,
momentum=MOMENTUM,
weight_decay=WEIGHT_DECAY,
nesterov=True)
full_optimizer = torch.optim.SGD(model.parameters(),
INITIAL_LR,
momentum=MOMENTUM,
weight_decay=WEIGHT_DECAY,
nesterov=True)
full_lr_scheduler = torch.optim.lr_scheduler.LambdaLR(
full_optimizer, lambda iteration: (MAX_ITERS - iteration) / MAX_ITERS)
snapshots_root = os.path.join(config['ARTIFACTS_PATH'], SNAPSHOTS_ROOT,
OUTPUT_FOLDER_NAME)
os.makedirs(snapshots_root)
log_root = os.path.join(config['ARTIFACTS_PATH'], LOGS_ROOT,
OUTPUT_FOLDER_NAME)
os.makedirs(log_root)
writer = SummaryWriter(log_root)
iteration = 0
if iteration < NUM_WARMUP_ITERATIONS:
print('Start {} warmup iterations'.format(NUM_WARMUP_ITERATIONS))
model.eval()
model._fc.train()
for param in model.parameters():
param.requires_grad = False
for param in model._fc.parameters():
param.requires_grad = True
optimizer = warmup_optimizer
else:
print('Start without warmup iterations')
model.train()
optimizer = full_optimizer
max_lr = max(param_group["lr"]
for param_group in full_optimizer.param_groups)
writer.add_scalar('train/max_lr', max_lr, iteration)
epoch = 0
fake_prob_dist = distributions.beta.Beta(0.5, 0.5)
while True:
epoch += 1
print('Epoch {} is in progress'.format(epoch))
loader = DataLoader(train_dataset,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=NUM_WORKERS,
drop_last=True)
for samples in tqdm.tqdm(loader):
iteration += 1
fake_input_tensor = torch.stack(samples['fake']).transpose(
0, 1).cuda()
real_input_tensor = torch.stack(samples['real']).transpose(
0, 1).cuda()
target_fake_prob = fake_prob_dist.sample(
(len(fake_input_tensor), )).float().cuda()
fake_weight = target_fake_prob.view(-1, 1, 1, 1, 1)
input_tensor = (
1.0 - fake_weight
) * real_input_tensor + fake_weight * fake_input_tensor
pred = model(input_tensor.flatten(0, 1)).flatten()
loss = F.binary_cross_entropy_with_logits(
pred, target_fake_prob.repeat_interleave(len(TRAIN_INDICES)))
optimizer.zero_grad()
loss.backward()
optimizer.step()
if iteration > NUM_WARMUP_ITERATIONS:
full_lr_scheduler.step()
max_lr = max(param_group["lr"]
for param_group in full_optimizer.param_groups)
writer.add_scalar('train/max_lr', max_lr, iteration)
writer.add_scalar('train/loss', loss.item(), iteration)
if iteration == NUM_WARMUP_ITERATIONS:
print('Stop warmup iterations')
model.train()
for param in model.parameters():
param.requires_grad = True
optimizer = full_optimizer
if iteration % SNAPSHOT_FREQUENCY == 0:
snapshot_name = SNAPSHOT_NAME_TEMPLATE.format(iteration)
snapshot_path = os.path.join(snapshots_root, snapshot_name)
print('Saving snapshot to {}'.format(snapshot_path))
torch.save(model.state_dict(), snapshot_path)
if iteration >= MAX_ITERS:
print('Stop training due to maximum iteration exceeded')
return
from dataset import PoseNetDataset
from models import GoogleNet
from metrics import PosQtnMetricsProcessor, PoseNetLoss
base_dir = '/mnt/tb_storage/uprojects/posenet/dataset'
img_dir = os.path.join(base_dir, 'images')
csv_data = os.path.join(base_dir, 'info.csv')
BATCH_SIZE = 4
LEARN_LOSS = False
POS_WT = 0.5
QTN_WT = 0.5
augmentations = Compose([
RandomCrop(299, 299),
RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2),
RGBShift(),
RandomGamma(),
OneOf([IAAAdditiveGaussianNoise(p=1.),
GaussNoise(p=1.)], p=0.27),
OneOf([
MotionBlur(p=1.),
MedianBlur(blur_limit=3, p=1.),
Blur(blur_limit=3, p=1.)
],
p=0.27),
OneOf([
OpticalDistortion(p=1.),
GridDistortion(p=1.),
IAAPiecewiseAffine(p=1.)
def augmentate_val(img: np.ndarray):
res = RandomCrop(299, 299)(image=img)
return torch.from_numpy(
np.moveaxis(res['image'].astype(np.float32) / 255., -1, 0))
def build_test(self):
return Compose([
RandomCrop(self.height, self.width), # not fully conv, so need to limit img size
Normalize(mean=self.MEAN, std=self.STD),
ToTensor(),
])
from albumentations import Compose, Resize, RandomCrop, Flip, HorizontalFlip, VerticalFlip, Transpose, RandomRotate90, \
ShiftScaleRotate, OneOf, Blur
from albumentations.pytorch import ToTensor
train_aug = Compose([
RandomCrop(height=96, width=96, p=0.2),
OneOf([
VerticalFlip(p=0.2),
HorizontalFlip(p=0.3),
Transpose(p=0.2),
RandomRotate90(p=0.2),
],
p=0.3),
ShiftScaleRotate(p=0.2),
Blur(p=0.2),
Resize(128, 128, always_apply=True),
ToTensor()
])
valid_aug = Compose([Resize(128, 128, always_apply=True), ToTensor()])
class AlbuCompose:
"""
Converts to PyTorch compatible Transform
"""
def __init__(self,transforms):
self.transforms = transforms
def __call__(self, img):
img = np.array(img)
img = self.transforms(image=img)["image"]
return img
# Albumentations Transformations
transform_train_albu = Compose([
PadIfNeeded(value=4),
RandomCrop(height=32, width=32), #, always_apply=True
HorizontalFlip(), # p=0.2
VerticalFlip(), # p=0.0
IAAFliplr(p=0.2),
Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010), always_apply=True),
Cutout(num_holes=1, max_h_size=8, max_w_size=8, fill_value=[0.4914, 0.4822, 0.4465], p=0.3),
ToTensorV2(always_apply=True)
])
transform_test_albu = Compose([
#ToTensor(),
Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)),
ToTensorV2(always_apply=True)
])
def __crop(self):
return Compose([RandomCrop(self.patch_size, self.patch_size)], p=1.0)
def _FastRandAugment2d(img_size, set='general'):
_sets = {
'general': [
OneOf([
Blur(p=1),
GaussNoise(p=1),
MotionBlur(p=1),
MedianBlur(p=1),
]),
HorizontalFlip(p=1),
Compose([
PadIfNeeded(min_height=img_size * 2,
min_width=img_size * 2,
border_mode=cv2.BORDER_WRAP,
p=1),
RandomCrop(img_size, img_size, p=1),
],
p=1),
RandomBrightnessContrast(p=1),
InvertImg(p=1),
ToGray(p=1),
RGBShift(p=1),
OneOf([
GridDropout(holes_number_x=4,
holes_number_y=4,
random_offset=True,
ratio=r,
fill_value=i,
p=1) for i in _color_fill
for r in np.linspace(0.3, 0.7, 4)
],
p=1),
NoOp(p=1),
Equalize(p=1),
Rotate(45, border_mode=cv2.BORDER_WRAP, p=1),
ShiftScaleRotate(shift_limit=0.25,
scale_limit=0.2,
rotate_limit=45,
border_mode=cv2.BORDER_WRAP,
p=1),
Solarize(p=1),
Posterize(p=1),
IAAPerspective(p=1),
HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=50,
val_shift_limit=50,
p=1),
RandomGamma(p=1),
ChannelShuffle(p=1),
OneOf([
CoarseDropout(max_holes=1,
max_height=img_size // 2,
max_width=img_size // 2,
fill_value=i,
p=1) for i in _color_fill
],
p=1),
OneOf([
CLAHE(clip_limit=2),
IAASharpen(),
IAAEmboss(),
], p=1),
],
}
return _sets[set]