def main():
print('===> Loading datasets')
test_set = get_eval_set(opt.data_dir, opt.test_dir, opt.sr_upscale_factor,
opt.num_classes)
test_loader = DataLoader(dataset=test_set,
num_workers=opt.threads,
batch_size=1,
shuffle=False)
print('Building SR model ', opt.sr_model_name)
if opt.sr_model_name == 'DBPN':
sr_model = DBPN(num_channels=3,
base_filter=64,
feat=256,
num_stages=7,
scale_factor=opt.sr_upscale_factor)
sr_model = torch.nn.DataParallel(sr_model, device_ids=gpus_list)
model_name = os.path.join(opt.models_dir, exp_name, opt.sr_model)
print(model_name)
sr_model.load_state_dict(
torch.load(model_name, map_location=lambda storage, loc: storage))
print('Pre-trained SR model is loaded.')
else:
sys.exit('Invalid SR network')
print('Building SemSeg model', opt.seg_model_name)
if opt.seg_model_name == 'segnet':
seg_model = segnet(num_classes=opt.num_classes, in_channels=3)
seg_model = torch.nn.DataParallel(seg_model, device_ids=gpus_list)
model_name = os.path.join(opt.models_dir, exp_name, opt.seg_model)
print(model_name)
seg_model.load_state_dict(torch.load(model_name))
print('Pre-trained SemSeg model is loaded.')
else:
sys.exit('Invalid Semantic segmentation network')
if cuda:
sr_model = sr_model.cuda(gpus_list[0])
seg_model = seg_model.cuda(gpus_list[0])
check_mkdir(os.path.join('Results'))
check_mkdir(os.path.join('Results', exp_name))
check_mkdir(os.path.join('Results', exp_name, 'segmentation'))
check_mkdir(os.path.join('Results', exp_name, 'super-resolution'))
check_mkdir(os.path.join('heat_maps'))
check_mkdir(os.path.join('heat_maps', exp_name))
test(test_loader, sr_model, seg_model)
def main():
sys.stdout = Logger(os.path.join(opt.save_test_log,'test_'+systime+'.txt'))
if not torch.cuda.is_available():
raise Exception('No Gpu found, please run with gpu')
else:
use_gpu = torch.cuda.is_available()
if use_gpu:
cudnn.benchmark = False
torch.cuda.manual_seed(opt.seed)
pin_memory = True if use_gpu else False
n_c = 128
n_b = opt.num_layers
rrn = RRN(opt.scale, n_c, n_b) # initial filter generate network
print(rrn)
print("Model size: {:.5f}M".format(sum(p.numel() for p in rrn.parameters())*4/1048576))
print('===> {}L model has been initialized'.format(n_b))
rrn = torch.nn.DataParallel(rrn, device_ids=gpus_list)
print('===> load pretrained model')
if os.path.isfile('./model/RRN-{}L.pth'.format(n_b)):
rrn.load_state_dict(torch.load('./model/RRN-{}L.pth'.format(n_b), map_location=lambda storage, loc: storage))
print('===> pretrained model is load')
else:
raise Exception('pretrain model is not exists')
if use_gpu:
rrn = rrn.cuda(gpus_list[0])
print('===> Loading test Datasets')
#scene_list = os.listdir(opt.test_dir)
scene_list = [opt.scene_name]
for scene_name in scene_list:
test_set = get_eval_set(opt.test_dir, opt.scale, scene_name)
test_loader = DataLoader(dataset=test_set, num_workers=opt.threads, batch_size=opt.testbatchsize, shuffle=False, pin_memory=pin_memory, drop_last=False)
print('===> DataLoading Finished')
test(test_loader, rrn, opt.scale, scene_name, n_c)
opt = parser.parse_args()
gpus_list = range(opt.gpus)
print(opt)
cuda = opt.gpu_mode
if cuda and not torch.cuda.is_available():
raise Exception("No GPU found, please run without --cuda")
torch.manual_seed(opt.seed)
if cuda:
torch.cuda.manual_seed(opt.seed)
print('===> Loading datasets')
test_set = get_eval_set(os.path.join(opt.input_dir, opt.test_dataset),
opt.upscale_factor)
testing_data_loader = DataLoader(dataset=test_set,
num_workers=opt.threads,
batch_size=opt.testBatchSize,
shuffle=False)
print('===> Building model')
if opt.model_type == 'DBPNLL':
model = DBPNLL(num_channels=3,
base_filter=64,
feat=256,
num_stages=10,
scale_factor=opt.upscale_factor) ###D-DBPN
elif opt.model_type == 'DBPN-RES-MR64-3':
model = DBPNITER(num_channels=3,
base_filter=64,
opt = parser.parse_args()
gpus_list = range(opt.gpus)
print(opt)
cuda = opt.gpu_mode
if cuda and not torch.cuda.is_available():
raise Exception("No GPU found, please run without --cuda")
torch.manual_seed(opt.seed)
if cuda:
torch.cuda.manual_seed(opt.seed)
print('===> Loading datasets')
test_set = get_eval_set(os.path.join(opt.input_dir, opt.test_dataset),
os.path.join(opt.input_dir, opt.test_rgb_dataset))
testing_data_loader = DataLoader(dataset=test_set,
num_workers=opt.threads,
batch_size=opt.testBatchSize,
shuffle=False)
print('===> Building model')
if opt.model_type == 'PMBAX8':
model = PMBAX8(num_channels=1,
base_filter=64,
feat=256,
num_stages=3,
scale_factor=opt.upscale_factor) ##For NTIRE2018
else:
model = PMBAX8(base_filter=64,
feat=256,
parser.add_argument('--bicubic', default=False, type = bool, help='if yes, generate bicubic images')
opt = parser.parse_args()
gpus_list = range(opt.gpus)
print(opt)
cuda = opt.gpu_mode
if cuda and not torch.cuda.is_available():
raise Exception("No GPU found, please run without --cuda")
torch.manual_seed(opt.seed)
if cuda:
torch.cuda.manual_seed(opt.seed)
print('===> Loading datasets')
test_set = get_eval_set(opt.input_dir+opt.test_dataset, opt.upscale_factor)
testing_data_loader = DataLoader(dataset=test_set, num_workers=opt.threads, batch_size=opt.testBatchSize, shuffle=False)
print('===> Building model')
if opt.model_type == 'DBPNLL':
model = DBPNLL(num_channels=3, base_filter=64, feat=256, num_stages=10,
scale_factor=opt.upscale_factor) ###D-DBPN
elif opt.model_type == 'DBPN-RES-MR64-3':
model = DBPNITER(num_channels=3, base_filter=64, feat=256, num_stages=3,
scale_factor=opt.upscale_factor) ###D-DBPN
else:
model = DBPN(num_channels=3, base_filter=64, feat=256, num_stages=7, scale_factor=opt.upscale_factor) ###D-DBPN
if cuda:
model = torch.nn.DataParallel(model, device_ids=gpus_list)
parser.add_argument('--epochs',
type=int,
default=20000,
help='number of epochs to train')
parser.add_argument('--model_name', default='_DAVSR_5', help='model to select')
args = parser.parse_args()
gpu_lists = [0]
# os.environ["CUDA_VISIBLE_DEVICES"] = "0"
torch.manual_seed(123)
torch.cuda.manual_seed(123)
save_model_path = '/home/qyn/qyn-prog/DASR/models/' + args.model_name + '/'
print('===> Loading datasets')
eval_set = get_eval_set(args.dataDir, args.eval_file_list, 5)
eval_data_loader = torch.utils.data.DataLoader(dataset=eval_set,
num_workers=args.nThreads,
batch_size=1,
shuffle=False)
train_set = get_training_set(args.dataDir, args.train_file_list, 5,
args.patchSize, args.scale, True)
training_data_loader = torch.utils.data.DataLoader(dataset=train_set,
num_workers=args.nThreads,
batch_size=args.batchSize,
shuffle=True)
model = DAVSR_5(args.nChannel, args.nFeat, args.scale)
model = nn.DataParallel(model, gpu_lists)
def main():
print('===> Loading datasets')
train_set = get_training_set(opt.data_dir, opt.train_dir, opt.patch_size,
opt.sr_patch_size, opt.sr_upscale_factor,
opt.num_classes, opt.sr_data_augmentation)
if opt.val_dir != None:
val_set = get_eval_set(opt.data_dir, opt.val_dir,
opt.sr_upscale_factor, opt.num_classes)
train_loader = DataLoader(dataset=train_set,
num_workers=opt.threads,
batch_size=opt.batch_size)
val_loader = DataLoader(dataset=val_set,
num_workers=opt.threads,
batch_size=1)
else:
# Creating data indices for training and validation splits:
validation_split = .2
dataset_size = len(train_set)
indices = list(range(dataset_size))
split = int(np.floor(validation_split * dataset_size))
np.random.seed(opt.seed)
np.random.shuffle(indices)
train_indices, val_indices = indices[split:], indices[:split]
train_sampler = SubsetRandomSampler(train_indices)
val_sampler = SubsetRandomSampler(val_indices)
train_loader = DataLoader(dataset=train_set,
num_workers=opt.threads,
batch_size=opt.batch_size,
sampler=train_sampler)
val_loader = DataLoader(dataset=train_set,
num_workers=opt.threads,
batch_size=1,
sampler=val_sampler)
print('Building SR model ', opt.sr_model_name)
if opt.sr_model_name == 'DBPN':
sr_model = DBPN(num_channels=3,
base_filter=64,
feat=256,
num_stages=7,
scale_factor=opt.sr_upscale_factor)
sr_model = torch.nn.DataParallel(sr_model, device_ids=gpus_list)
if opt.sr_pretrained:
model_name = os.path.join(opt.save_folder +
opt.sr_pretrained_model)
print(model_name)
sr_model.load_state_dict(
torch.load(model_name,
map_location=lambda storage, loc: storage))
print('Pre-trained SR model is loaded.')
else:
sys.exit('Invalid SR network')
print('Building SemSeg model', opt.seg_model_name)
if opt.seg_model_name == 'segnet':
seg_model = segnet(num_classes=opt.num_classes, in_channels=3)
if not opt.seg_pretrained:
seg_model.init_vgg16_params()
print('segnet params initialized')
seg_model = torch.nn.DataParallel(seg_model, device_ids=gpus_list)
if opt.seg_pretrained:
model_name = os.path.join(opt.save_folder +
opt.seg_pretrained_model)
print(model_name)
seg_model.load_state_dict(torch.load(model_name))
print('Pre-trained SemSeg model is loaded.')
seg_model = torch.nn.DataParallel(seg_model, device_ids=gpus_list)
sr_criterion = nn.L1Loss()
psnr_criterion = nn.MSELoss()
if cuda:
sr_model = sr_model.cuda(gpus_list[0])
seg_model = seg_model.cuda(gpus_list[0])
sr_criterion = sr_criterion.cuda(gpus_list[0])
psnr_criterion = psnr_criterion.cuda(gpus_list[0])
if 'grss' in opt.data_dir:
seg_criterion = CrossEntropyLoss2d(ignore_index=-1).cuda()
else:
seg_criterion = CrossEntropyLoss2d().cuda()
sr_optimizer = optim.Adam(sr_model.parameters(),
lr=opt.sr_lr,
betas=(0.9, 0.999),
eps=1e-8)
seg_optimizer = optim.Adam(seg_model.parameters(),
lr=opt.seg_lr,
weight_decay=opt.seg_weight_decay,
betas=(opt.seg_momentum, 0.99))
scheduler = ReduceLROnPlateau(seg_optimizer,
'min',
factor=0.5,
patience=opt.seg_lr_patience,
min_lr=2.5e-5,
verbose=True)
check_mkdir(os.path.join('outputs', exp_name))
check_mkdir(os.path.join('outputs', exp_name, 'segmentation'))
check_mkdir(os.path.join('outputs', exp_name, 'super-resolution'))
check_mkdir(os.path.join(opt.save_folder, exp_name))
#best_iou = 0
best_iou = val_results = validate(0, val_loader, sr_model, seg_model,
sr_criterion, psnr_criterion,
seg_criterion, sr_optimizer,
seg_optimizer)
#sys.exit()
#best_epoch = -1
best_epoch = 0
best_model = (sr_model, seg_model)
since_last_best = 0
for epoch in range(opt.start_iter, opt.epoch_num + 1):
train(epoch, train_loader, sr_model, seg_model, sr_criterion,
psnr_criterion, seg_criterion, sr_optimizer, seg_optimizer)
val_results = validate(epoch, val_loader, sr_model, seg_model,
sr_criterion, psnr_criterion, seg_criterion,
sr_optimizer, seg_optimizer)
if val_results > best_iou:
best_iou = val_results
best_epoch = epoch
print('New best iou ', best_iou)
best_model = (copy.deepcopy(sr_model), copy.deepcopy(seg_model))
since_last_best = 0
checkpoint(epoch, sr_model, seg_model, 'tmp_best')
else:
print('Best iou epoch: ', best_epoch, ':', best_iou)
scheduler.step(val_results)
if (epoch) % (opt.epoch_num / 2) == 0:
for param_group in sr_optimizer.param_groups:
param_group['lr'] /= 10.0
print('SR Learning rate decay: lr={}'.format(
sr_optimizer.param_groups[0]['lr']))
if (epoch) % (opt.snapshots) == 0:
checkpoint(epoch, sr_model, seg_model)
#since_last_best += 1
#if since_last_best == 20:
# checkpoint(epoch, best_model[0], best_model[1], 'tmp_best')
print('Saving final best model')
checkpoint(epoch, best_model[0], best_model[1], 'best')
print('Loading datasets!')
train_set = get_training_set(
opt.data_dir,
opt.hr_train_dataset,
opt.upscale_factor,
opt.patch_size,
opt.data_augmentation
)
training_data_loader = DataLoader(
dataset=train_set,
num_workers=opt.threads,
batch_size=opt.batchSize,
shuffle=True
)
test_set = get_eval_set(os.path.join(opt.data_dir,opt.hr_valid_dataset), opt.upscale_factor)
testing_data_loader = DataLoader(dataset=test_set, num_workers=0, batch_size=1, shuffle=False)
write_log('Buildind model!')
model = model = Srnet(
num_channels=opt.n_colors,
base_filter=opt.base_filter,
num_stages=opt.num_stages,
scale_factor=opt.upscale_factor
)
model = torch.nn.DataParallel(model, device_ids=gpus_list)
write_log('---------- Networks architecture -------------')
print('Saving config!')
write_log(model, refresh=True)
def main(not_parsed_args):
logging.info('Build dataset')
train_set = get_training_set(FLAGS.dataset_h, FLAGS.dataset_l,
FLAGS.frames, FLAGS.scale, True,
'filelist.txt', True, FLAGS.patch_size,
FLAGS.future_frame)
if FLAGS.dataset_val:
val_set = get_eval_set(FLAGS.dataset_val_h, FLAGS.dataset_val_l,
FLAGS.frames, FLAGS.scale, True, 'filelist.txt',
True, FLAGS.patch_size, FLAGS.future_frame)
logging.info('Build model')
model = RBPN()
model.summary()
last_epoch, last_step = load_weights(model)
model.compile(optimizer=optimizers.Adam(FLAGS.lr),
loss=losses.mae,
metrics=[psnr])
# checkpoint = ModelCheckpoint('models/model.hdf5', verbose=1)
tensorboard = TensorBoard(log_dir='./tf_logs',
batch_size=FLAGS.batch_size,
write_graph=False,
write_grads=True,
write_images=True,
update_freq='batch')
tensorboard.set_model(model)
logging.info('Training start')
for e in range(last_epoch, FLAGS.epochs):
tensorboard.on_epoch_begin(e)
for s in range(last_step + 1, len(train_set) // FLAGS.batch_size):
tensorboard.on_batch_begin(s)
x, y = train_set.batch(FLAGS.batch_size)
loss = model.train_on_batch(x, y)
print('Epoch %d step %d, loss %f psnr %f' %
(e, s, loss[0], loss[1]))
tensorboard.on_batch_end(s, named_logs(model, loss, s))
if FLAGS.dataset_val and s > 0 and s % FLAGS.val_interval == 0 or s == len(
train_set) // FLAGS.batch_size - 1:
logging.info('Validation start')
val_loss = 0
val_psnr = 0
for j in range(len(val_set)):
x_val, y_val = val_set.batch(1)
score = model.test_on_batch(x_val, y_val)
val_loss += score[0]
val_psnr += score[1]
val_loss /= len(val_set)
val_psnr /= len(val_set)
logging.info('Validation average loss %f psnr %f' %
(val_loss, val_psnr))
if s > 0 and s % FLAGS.save_interval == 0 or s == len(
train_set) // FLAGS.batch_size - 1:
logging.info('Saving model')
filename = 'model_%d_%d.h5' % (e, s)
path = os.path.join(FLAGS.model_dir, filename)
path_info = os.path.join(FLAGS.model_dir, 'info')
model.save_weights(path)
f = open(path_info, 'w')
f.write(filename)
f.close()
tensorboard.on_epoch_end(e)
last_step = -1
parser.add_argument('--lr_eval_dataset', type=str, default='val_low_bmp')
opt = parser.parse_args()
gpus_list = range(opt.gpus)
cuda = opt.gpu_mode
if cuda and not torch.cuda.is_available():
raise Exception("No GPU found, please run without --cuda")
torch.manual_seed(opt.seed)
if cuda:
torch.cuda.manual_seed(opt.seed)
print('===> Loading datasets')
eval_set = get_eval_set(opt.eval_dir, opt.hr_eval_dataset, opt.lr_eval_dataset,
opt.upscale_factor)
eval_data_loader = DataLoader(dataset=eval_set,
num_workers=opt.threads,
batch_size=opt.testBatchSize,
shuffle=False)
print('===> Building model ', opt.model_type)
if opt.model_type == 'WDSR':
model = WDSR(num_channels=3, feat=64, scale=opt.upscale_factor)
if cuda:
model = torch.nn.DataParallel(model, device_ids=gpus_list)
model.load_state_dict(
torch.load(opt.model, map_location=lambda storage, loc: storage))
print('Pre-trained SR model is loaded.')
