help='model file to use')
parser.add_argument('--outputHR2',
type=str,
default='73_LapSRN_R_epochs100_HR2.tif',
help='where to save the output image')
parser.add_argument('--outputHR4',
type=str,
default='73_LapSRN_R_epochs100_HR4.tif',
help='where to save the output image')
parser.add_argument('--cuda', action='store_true', help='use cuda')
opt = parser.parse_args()
print(opt)
model_r = LapSRN().cuda()
model_g = LapSRN().cuda()
model_b = LapSRN().cuda()
optimizer_r = optim.Adagrad(model_r.parameters(), lr=1e-3, weight_decay=1e-5)
optimizer_g = optim.Adagrad(model_g.parameters(), lr=1e-3, weight_decay=1e-5)
optimizer_b = optim.Adagrad(model_b.parameters(), lr=1e-3, weight_decay=1e-5)
model_r, optimizer_r, epochs_r = load_model(model_r, optimizer_r, opt.model_r)
model_g, optimizer_g, epochs_g = load_model(model_g, optimizer_g, opt.model_g)
model_b, optimizer_b, epochs_b = load_model(model_b, optimizer_b, opt.model_b)
img = Image.open(opt.input).convert('RGB')
LR_r, LR_g, LR_b = img.split()
LR_r, LR_g, LR_b = pre_deal(LR_r, LR_g, LR_b)
help='whether to use cuda')
args = parser.parse_args()
if args.cuda and not torch.cuda.is_available():
raise Exception('No GPU found')
device = torch.device('cuda' if args.cuda else 'cpu')
print('Use device:', device)
filenames = os.listdir(args.img_dir)
image_filenames = [os.path.join(args.img_dir, x) for x in filenames \
if is_image_file(x)]
image_filenames = sorted(image_filenames)
model = LapSRN(img_channels=1,
upscale_factor=args.upscale_factor,
n_feat=10,
n_recursive=1,
local_residual='ns').to(device)
if args.cuda:
ckpt = torch.load(args.model)
else:
ckpt = torch.load(args.model, map_location='cpu')
model.load_state_dict(ckpt['model'])
res = {}
for i, f in enumerate(image_filenames):
# Read test image.
img = Image.open(f).convert('RGB')
width, height = img.size[0], img.size[1]
raise Exception("No GPU found, please run without --cuda")
torch.manual_seed(opt.seed)
if cuda:
torch.cuda.manual_seed(opt.seed)
device = torch.device("cuda" if opt.cuda else "cpu")
print('===> Loading datasets')
train_set = get_training_set(opt.dataset)
val_set = get_val_set(opt.dataset)
training_data_loader = DataLoader(dataset=train_set, batch_size=opt.batchSize, shuffle=True)
val_data_loader = DataLoader(dataset=val_set, batch_size=opt.valBatchSize, shuffle=False)
print('===> Building model')
model = LapSRN().to(device)
Loss = Loss()
criterion = nn.MSELoss()
if cuda:
Loss = Loss.cuda()
criterion = criterion.cuda()
def train(epoch):
epoch_loss = 0
for iteration, batch in enumerate(training_data_loader, 1):
LR, HR_2_target, HR_4_target = batch[0].to(device), batch[1].to(device), batch[2].to(device)
optimizer.zero_grad()
HR_2, HR_4 = model(LR)
help='upscaling factor')
parser.add_argument('--img_channels', type=int, required=True,
help='# of image channels (1 for Y, 3 for RGB)')
parser.add_argument('--input', type=str, required=True,
help='input image to super resolve')
parser.add_argument('--output', type=str, required=True,
help='where to save the output image')
args = parser.parse_args()
img = Image.open(args.input).convert('RGB')
if args.img_channels == 1:
img = _rgb2ycbcr(img)
img, cb, cr = img.split()
ckpt = torch.load(args.model, map_location='cpu')
model = LapSRN(img_channels=args.img_channels,
upscale_factor=args.upscale_factor)
model.load_state_dict(ckpt['model'])
input = ToTensor()(img).view(1, -1, img.size[1], img.size[0])
out = model(input)[-1]
out_img = out.detach().numpy().squeeze().transpose(1, 2, 0)
out_img *= 255.0
out_img = out_img.clip(0, 255)
print(out_img.shape)
if args.img_channels == 1:
out_img = Image.fromarray(np.uint8(out_img), mode='L')
out_img_cb = cb.resize(out_img.size, Image.BICUBIC)
out_img_cr = cr.resize(out_img.size, Image.BICUBIC)
out_img = Image.merge('YCbCr', [out_img, out_img_cb, out_img_cr])
out_img = _ycbcr2rgb(out_img)
raise Exception("No GPU found, please run without --cuda")
torch.manual_seed(opt.seed)
if cuda:
torch.cuda.manual_seed(opt.seed)
device = torch.device("cuda" if opt.cuda else "cpu")
print('===> Loading datasets')
train_set = get_training_set(opt.dataset)
val_set = get_val_set(opt.dataset)
training_data_loader = DataLoader(dataset=train_set, batch_size=opt.batchSize, shuffle=True)
val_data_loader = DataLoader(dataset=val_set, batch_size=opt.valBatchSize, shuffle=False)
print('===> Loading pre_train model and Building model')
model = LapSRN().to(device)
Loss = Loss()
criterion = nn.MSELoss()
if cuda:
Loss = Loss.cuda()
criterion = criterion.cuda()
def train(epoch):
epoch_loss = 0
for _, batch in enumerate(training_data_loader, 1):
LR, HR_2_target, HR_4_target = batch[0].to(device), batch[1].to(device), batch[2].to(device)
optimizer.zero_grad()
HR_2, HR_4 = model(LR)
def checkpoint(epoch):
model_out_r_path = "LapSRN_model_epoch_r_{}.pth".format(epoch)
state_r = {'model': model_r.state_dict(), 'optimizer': optimizer_r.state_dict(), 'epoch':epoch, 'lr':lr_r}
torch.save(state_r, model_out_r_path, _use_new_zipfile_serialization=False)
model_out_g_path = "LapSRN_model_epoch_g_{}.pth".format(epoch)
state_g = {'model': model_g.state_dict(), 'optimizer': optimizer_g.state_dict(), 'epoch':epoch, 'lr':lr_g}
torch.save(state_g, model_out_g_path, _use_new_zipfile_serialization=False)
print("Checkpoint saved to {} and {}".format(model_out_r_path, model_out_g_path))
if os.path.exists(opt.pre_model_r):
model_r = LapSRN().to(device)
checkpoints_r = torch.load(opt.pre_model_r)
model_r.load_state_dict(checkpoints_r['model'])
model_r.train()
epoch_continue_r = checkpoints_r['epoch']
optimizer_r = optim.Adagrad(model_r.parameters())
model_g = LapSRN().to(device)
checkpoints_g = torch.load(opt.pre_model_g)
model_g.load_state_dict(checkpoints_g['model'])
model_g.train()
epoch_continue_g = checkpoints_g['epoch']
optimizer_g = optim.Adagrad(model_g.parameters())
for epoch in range(epoch_continue_g + 1, opt.nEpochs + 1):
if cuda:
torch.cuda.manual_seed(opt.seed)
device = torch.device("cuda" if opt.cuda else "cpu")
print('===> Loading datasets')
train_set = get_training_set(opt.dataset)
val_set = get_val_set(opt.dataset)
training_data_loader = DataLoader(dataset=train_set,
batch_size=opt.batchSize,
shuffle=True)
val_data_loader = DataLoader(dataset=val_set,
batch_size=opt.valBatchSize,
shuffle=False)
print('===> Building model')
model_r = LapSRN().to(device)
Loss_r = Loss()
model_g = LapSRN().to(device)
Loss_g = Loss()
criterion = nn.MSELoss()
if cuda:
Loss_r = Loss_r.cuda()
Loss_g = Loss_g.cuda()
criterion = criterion.cuda()
def train(epoch):
epoch_loss_r, epoch_loss_g = 0, 0
for _, batch in enumerate(training_data_loader, 1):
img_channels=config['model']['img_channels'],
crop_size=config['data']['hr_crop_size'])
train_dataloader = DataLoader(dataset=train_set,
batch_size=config['training']['batch_size'],
shuffle=True)
val_set = get_val_set(img_dir=config['data']['test_root'],
upscale_factor=config['model']['upscale_factor'],
img_channels=config['model']['img_channels'])
val_dataloader = DataLoader(dataset=val_set, batch_size=1, shuffle=False)
print('===> Building model')
sys.stdout.flush()
model = LapSRN(img_channels=config['model']['img_channels'],
upscale_factor=config['model']['upscale_factor'],
n_feat=config['model']['n_feat'],
n_recursive=config['model']['n_recursive'],
local_residual=config['model']['local_residual']).to(device)
# criterion = nn.MSELoss()
criterion = L1_Charbonnier_loss()
optimizer = setup_optimizer(model, config)
scheduler = setup_scheduler(optimizer, config)
start_iter = 0
best_val_psnr = -1
if config['training']['resume'] != 'None':
print('===> Reloading model')
sys.stdout.flush()
ckpt = torch.load(config['training']['resume'])
model.load_state_dict(ckpt['model'])
help='model file to use')
parser.add_argument('--outputHR2',
type=str,
default='73_LapSRN_G_epochs100_HR2.tif',
help='where to save the output image')
parser.add_argument('--outputHR4',
type=str,
default='73_LapSRN_G_epochs100_HR4.tif',
help='where to save the output image')
parser.add_argument('--cuda', action='store_true', help='use cuda')
opt = parser.parse_args()
print(opt)
model = LapSRN().cuda()
optimizer = optim.Adagrad(model.parameters(), lr=1e-3, weight_decay=1e-5)
checkpoint = torch.load(opt.model)
model.load_state_dict(checkpoint['model'])
model.eval()
optimizer.load_state_dict(checkpoint['optimizer'])
epochs = checkpoint['epoch']
transform = Compose([
ToTensor(),
Lambda(lambda x: x.repeat(3, 1, 1)),
])
img = Image.open(opt.input).convert('RGB')
_, LR_g, _ = img.split()