def get_data_loaders(train_batch_size, val_batch_size):
normalize = transforms.Normalize(mean=torch.Tensor([0.5]),
std=torch.Tensor([0.2]))
train_transform = transforms.Compose([
transforms.RandomResizedCrop(256),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.ToTensor(),
transforms.MultiplicativeGaussianNoise(1, 0.01), normalize
])
val_transform = transforms.Compose(
[transforms.Resize((512, 512)),
transforms.ToTensor(), normalize])
train_loader = DataLoader(DWTDataset('dataset',
split='train',
transform=train_transform),
batch_size=train_batch_size,
shuffle=True)
val_loader = DataLoader(DWTDataset('dataset',
split='valid',
transform=val_transform),
batch_size=val_batch_size,
shuffle=False)
return train_loader, val_loader
def get_train_test_loader(
root, batch_size=2, augment=True, test_ratio=0.2, shuffle=True,
num_workers=4, collate_fn=utils.collate_fn, pin_memory=False):
train_transform = T.Compose([
T.ToTensor(),
T.RandomHorizontalFlip(),
T.RandomVerticalFlip(),
]) if augment else T.ToTensor()
train_dataset = UECFOOD100(root=root, transform=train_transform)
test_dataset = UECFOOD100(root=root)
size = len(train_dataset)
indices = list(range(size))
split = int(np.floor(test_ratio * size))
if shuffle:
np.random.shuffle(indices)
train_idx, test_idx = indices[split:], indices[:split]
train_sampler = SubsetRandomSampler(train_idx)
test_sampler = SubsetRandomSampler(test_idx)
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=batch_size, sampler=train_sampler,
num_workers=num_workers, collate_fn=collate_fn, pin_memory=pin_memory
)
test_loader = torch.utils.data.DataLoader(
test_dataset, batch_size=batch_size, sampler=test_sampler,
num_workers=num_workers, collate_fn=collate_fn, pin_memory=pin_memory
)
return train_loader, test_loader
def get_transform(is_aug):
transforms = []
transforms.append(T.ToTensor())
if is_aug:
transforms.append(T.RandomHorizontalFlip(0.5))
transforms.append(T.RandomVerticalFlip(0.5))
return T.Compose(transforms)
def get_transform(is_train):
transforms = []
if is_train:
transforms.append(T.RandomResizedCrop())
transforms.append(T.ToTensor())
if is_train:
transforms.append(T.RandomHorizontalFlip(0.5))
transforms.append(T.RandomVerticalFlip(0.5))
transforms.append(T.RandomRotation())
return T.Compose(transforms)
def __init__(self, base_size, crop_size, hflip_prob=0.5, vflip_prob=0.5,
mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)):
min_size = int(0.5 * base_size)
max_size = int(1.2 * base_size)
trans = [T.RandomResize(min_size, max_size)]
if hflip_prob > 0:
trans.append(T.RandomHorizontalFlip(hflip_prob))
if vflip_prob > 0:
trans.append(T.RandomVerticalFlip(vflip_prob))
trans.extend([
T.RandomCrop(crop_size),
T.ToTensor(),
T.Normalize(mean=mean, std=std),
])
self.transforms = T.Compose(trans)
def __init__(
self,
*,
# RandomResizeAndCrop params
crop_size,
min_scale=-0.2,
max_scale=0.5,
stretch_prob=0.8,
# AsymmetricColorJitter params
brightness=0.4,
contrast=0.4,
saturation=0.4,
hue=0.5 / 3.14,
# Random[H,V]Flip params
asymmetric_jitter_prob=0.2,
do_flip=True,
):
super().__init__()
transforms = [
T.PILToTensor(),
T.AsymmetricColorJitter(brightness=brightness,
contrast=contrast,
saturation=saturation,
hue=hue,
p=asymmetric_jitter_prob),
T.RandomResizeAndCrop(crop_size=crop_size,
min_scale=min_scale,
max_scale=max_scale,
stretch_prob=stretch_prob),
]
if do_flip:
transforms += [
T.RandomHorizontalFlip(p=0.5),
T.RandomVerticalFlip(p=0.1)
]
transforms += [
T.ConvertImageDtype(torch.float32),
T.Normalize(mean=0.5, std=0.5), # map [0, 1] into [-1, 1]
T.RandomErasing(max_erase=2),
T.MakeValidFlowMask(),
T.ValidateModelInput(),
]
self.transforms = T.Compose(transforms)
def get_transform(train):
base_size = 1000
crop_size = 768
min_size = int((0.5 if train else 1.0) * base_size)
max_size = int((2.0 if train else 1.0) * base_size)
transforms = []
transforms.append(T.RandomResize(min_size, max_size))
if train:
transforms.append(T.ColorJitter(0.5, 0.5, 0.5, 0.5))
transforms.append(T.RandomHorizontalFlip(0.5))
transforms.append(T.RandomVerticalFlip(0.5))
transforms.append(T.RandomCrop(crop_size))
transforms.append(T.ToTensor())
transforms.append(
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
return T.Compose(transforms)
type=bool,
default=True,
help='whether enable ssp')
args = parser.parse_args()
args.cuda = (not args.no_cuda) and torch.cuda.is_available()
# set gpu id used
os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
train_transform_list = [
transforms.RandomCrop(480, 608),
transforms.RandomColor(),
transforms.RandomVerticalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
]
train_transform = transforms.Compose(train_transform_list)
training_transforms = albu.Compose(
[
# Color augmentation
albu.OneOf([
albu.Compose([
albu.RandomBrightnessContrast(
brightness_limit=0.1, contrast_limit=0.1, p=0.5),
# albu.RandomGamma(gamma_limit=(80, 120), p=0.01),
albu.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=0,
def main():
SIZE_IMG = 224
# 224
global args
args = parser.parse_args()
# create model
if args.arch.startswith('resnet50'):
model = model_defs.resnet50_oneway(num_classes=2)
model = nn.DataParallel(model.model)
# dirty trick
# open log file
if args.train == 1:
log_dir = 'logs'
log_name = args.arch + '_new.csv'
if not os.path.isdir(log_dir):
os.mkdir(log_dir)
log_handle = get_file_handle(os.path.join(log_dir, log_name), 'wb+')
log_handle.write('Epoch, LearningRate, Momentum, WeightDecay,' + \
'Loss, Precision, Recall, Accuracy(IoU), FgWeight, BgWeight\n')
log_handle.close()
# check model directory
model_dir = 'models'
if not os.path.isdir(model_dir):
os.mkdir(model_dir)
# resume learning based on cmdline arguments
if ((args.start_epoch > 1) and (args.train == 1)):
load_epoch = args.start_epoch - 1
elif (args.train == 0):
load_epoch = args.load_epoch
else:
load_epoch = 0
if load_epoch > 0:
print("=> loading checkpoint for epoch = '{}'".format(load_epoch))
checkpoint_name = args.arch + '_ep_' + str(load_epoch) + '.pth.tar'
checkpoint = torch.load(os.path.join(model_dir, checkpoint_name))
model.load_state_dict(checkpoint['state_dict'])
# model = add_dropout2d(model);
model.cuda()
# transfer to cuda
print(model)
mean = load_pickle('./mean')
std = load_pickle('./std')
if args.train == 1:
train_data_dir, train_gt_dir = args.data, args.gt
train_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
train_data_dir,
train_gt_dir,
transform_joint=transforms.Compose_Joint([
transforms.RandomCrop(SIZE_IMG),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
]),
transform=transforms.Compose([
transforms.ColorJitter(0.3, 0.3, 0.3, 0),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=std),
]),
target_transform=transforms.Compose([
transforms.ToTensorTarget(),
]),
do_copy=True,
),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
weights = torch.from_numpy(np.array([1., 1.01])).float()
criterion = nn.CrossEntropyLoss(weights).cuda()
if args.optim == 'adam':
optimizer = torch.optim.Adam(model.parameters(),
lr=args.learning_rate,
weight_decay=args.weight_decay)
elif args.optim == 'sgd':
optimizer = torch.optim.SGD(model.parameters(),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
for epoch in range(args.start_epoch, args.end_epoch + 1):
# train for one epoch
stats_epoch = train(train_loader, model, criterion, optimizer,
epoch)
model_name = args.arch + '_ep_' + str(epoch) + '.pth.tar'
# get current parameters of optimizer
for param_group in optimizer.param_groups:
cur_lr = param_group['lr']
cur_wd = param_group['weight_decay']
if param_group.has_key('momentum'):
cur_momentum = param_group['momentum']
else:
cur_momentum = 'n/a'
break
# constant parameters throughout the network
if epoch % args.save_interval == 0:
state = {
'epoch': epoch,
'arch': args.arch,
'state_dict': model.state_dict(),
'learning_rate': cur_lr,
'moemntum': cur_momentum,
'weight_decay': cur_wd,
'fg_weight': weights[1],
'bg_weight': weights[0],
}
torch.save(state, os.path.join(model_dir, model_name))
# write logs using logHandle
log_handle = get_file_handle(os.path.join(log_dir, log_name), 'ab')
log_handle.write(
str(epoch) + ',' + str(cur_lr) + ',' + str(cur_momentum) +
',' + str(cur_wd) + ',' + str(stats_epoch['loss']) + ',' +
str(stats_epoch['prec']) + ',' + str(stats_epoch['recall']) +
',' + str(stats_epoch['acc']) + ',' + str(weights[1]) + ',' +
str(weights[0]) + '\n')
log_handle.close()
# adjust_learning_rate(optimizer, epoch, 10); # adjust learning rate
elif args.train == 0: # test
testdir = args.data
outdir = args.out
stride = args.test_stride
test_batch_size = args.test_batch_size
test_transformer = transforms.Compose([
# transforms.RandomHorizontalFlip(),
# transforms.RandomVerticalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=std),
])
# test(testdir, outdir, test_transformer, model, load_epoch, stride, SIZE_IMG);
test_batch_form(testdir, outdir, test_transformer, model, load_epoch,
stride, SIZE_IMG, test_batch_size)
def train(epochs):
device = torch.device('cuda')
param = {}
param['lr'] = 0.001
param['max_epoch'] = 60
param['total_epoch'] = epochs
param['lr_pow'] = 0.95
param['running_lr'] = param['lr']
train_file = 'Dataset05/train_file.txt'
gt_root = 'Dataset05/training_aug/groundtruth'
left_high_root = 'Dataset05/training_aug/left_high'
right_low_root = 'Dataset05/training_aug/right_low'
list_file = open(train_file)
image_names = [line.strip() for line in list_file]
crit = nn.L1Loss()
#crit = nn.BCELoss()
# model = SRNet().to(device)
model = DINetwok().to(device)
# model.load_state_dict(torch.load('model/2018-10-26 22:11:34/50000/snap_model.pth'))
# model = load_part_of_model_PSP_LSTM(model, param['pretrained_model'])
# model.load_state_dict(torch.load(param['pretrained_model']))
# optimizers = create_optimizers(nets, param)
optimizer = torch.optim.Adam(model.parameters(), lr=param['lr'])
model.train()
# model = load_part_of_model(model, 'checkpoint/model_epoch_5.pth')
dataset = EnhanceDataset(left_high_root,
right_low_root,
gt_root,
image_names,
transform=transforms.Compose([
transforms.RandomCrop(120),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.RandomRotation(),
transforms.ToTensor()
]))
training_data_loader = torch.utils.data.DataLoader(dataset,
batch_size=16,
shuffle=True,
num_workers=int(2))
time_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
for epoch in range(1, epochs + 1):
for iteration, (low, high, target) in enumerate(training_data_loader):
low = low.type(torch.cuda.FloatTensor)
high = high.type(torch.cuda.FloatTensor)
target = target.type(torch.cuda.FloatTensor)
final, lstm_branck = model(low, high)
loss = crit(final, target)
#loss_lstm = crit(lstm_branck, target)
#loss = 0.9 * loss + 0.1 * loss_lstm
optimizer.zero_grad()
loss.backward()
optimizer.step()
if iteration % 2 == 0:
print(
"===> Epoch[{}]({}/{}): Loss: {:.10f}; lr:{:.10f}".format(
epoch, iteration, len(training_data_loader),
loss.item(), param['running_lr']))
adjust_learning_rate(optimizer, epoch, param)
print("Epochs={}, lr={}".format(epoch,
optimizer.param_groups[0]["lr"]))
if epoch % 50 == 0:
save_checkpoint(model, epoch, time_str)
with open(config_file, "r") as ymlfile:
yml_file = yaml.safe_load(ymlfile)
cfg = Config(yml_file)
np.random.seed(0) # Deterministic random
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Set up dataset and dataloader
print('Loading dataset...')
train_dataset = LTSIDDataset(cfg.input_dir, cfg.truth_dir, preprocess=cfg.preprocess,
preprocess_dir=cfg.preprocess_dir, collection='train',
transforms=transforms.Compose([
trf.RandomCrop(cfg.patch_size),
trf.ToTensor(),
trf.RandomHorizontalFlip(p=0.5),
trf.RandomVerticalFlip(p=0.5),
trf.RandomTranspose(p=0.5),
]))
validation_dataset = LTSIDDataset(cfg.input_dir, cfg.truth_dir, preprocess=cfg.preprocess,
preprocess_dir=cfg.preprocess_dir, collection='validation',
transforms=transforms.Compose([
trf.RandomCrop(cfg.patch_size),
trf.ToTensor(),
trf.RandomHorizontalFlip(p=0.5),
trf.RandomVerticalFlip(p=0.5),
trf.RandomTranspose(p=0.5),
]))
train_loader = DataLoader(train_dataset, batch_size=cfg.batch_size, shuffle=True)
validation_loader = DataLoader(validation_dataset, batch_size=cfg.batch_size, shuffle=True,)
print('Dataset loaded!')