def __init__(self, args, ckp):
super(Model, self).__init__()
print('Making model...')
self.scale = args.scale
self.idx_scale = 0
self.self_ensemble = args.self_ensemble
self.chop = args.chop
self.precision = args.precision
self.cpu = args.cpu
self.device = torch.device('cuda')
self.n_GPUs = args.n_GPUs
self.save_models = args.save_models
self.kernel = fspecial('gaussian', 15, 2.6)
self.k = single2tensor3(np.expand_dims(np.float32(self.kernel),
axis=2)).unsqueeze(0)
self.noise_level = np.random.randint(0, 25) / 255.0
self.sigma = torch.tensor(self.noise_level).float().view([1, 1, 1, 1])
self.k = (self.k).to(self.device)
self.sigma = (self.sigma).to(self.device)
# 1020后续添加选择模型的接口
from model import tiny_demo2 as module
self.model = module.make_model().to(self.device)
if args.precision == 'half':
self.model.half()
self.load(ckp.dir,
pre_train=args.pre_train,
resume=args.resume,
cpu=args.cpu)
print(self.model, file=ckp.log_file)
def get_kernel_sigma():
noise_level_img = 2 # noise level for LR image, 0.5~3 for clean images
kernel_width_default_x1234 = [
0.4, 0.7, 1.5, 2.0
] # default Gaussian kernel widths of clean/sharp images for x1, x2, x3, x4
noise_level_model = noise_level_img / 255. # noise level of model
kernel_width = kernel_width_default_x1234[sf - 1]
k = utils_deblur.fspecial('gaussian', 25, kernel_width)
k = sr.shift_pixel(k, sf) # shift the kernel
k /= np.sum(k)
kernel = util.single2tensor4(k[..., np.newaxis])
sigma = torch.tensor(noise_level_model).float().view([1, 1, 1, 1])
return kernel, sigma
def __getitem__(self, index):
# 从文件中读出HR图片，返回HR、LR图片对
HR_path, LR_path = None, None
HR_path = self.HR_paths[index]
img_HR = util.read_img_(HR_path, self.n_colors)
# 归一化
img_HR = util.unit2single(img_HR)
img_HR = util.modcrop(img_HR, self.scale)
kernel = fspecial('gaussian', 15, 2.6)
H, W, _ = img_HR.shape
img_LR = util.srmd_degradation(img_HR, kernel, self.scale)
if self.opt.phase == 'train':
patch_H, patch_L = util.paired_random_crop(img_HR, img_LR,
self.patch_size,
self.scale)
# augmentation - flip, rotate
img_HR, img_LR = util.augment([patch_H, patch_L],
self.opt.use_flip, self.opt.use_rot)
img_HR = util.img_single2tensor(img_HR)
img_LR = util.img_single2tensor(img_LR)
if random.random() < 0.1:
noise_level = torch.zeros(1).float()
else:
noise_level = torch.FloatTensor([
np.random.uniform(self.sigma_min, self.sigma_max)
]) / 255.0
else:
img_HR = util.img_single2tensor(img_HR)
img_LR = util.img_single2tensor(img_LR)
noise_level = torch.FloatTensor([self.sigma_test])
noise = torch.randn(img_LR.size()).mul_(noise_level).float()
img_LR.add_(noise)
kernel = util.single2tensor3(np.expand_dims(np.float32(kernel),
axis=2))
noise_level = torch.FloatTensor([noise_level]).view([1, 1, 1])
if LR_path is None:
LR_path = HR_path
return {
'LR': img_LR,
'HR': img_HR,
'k': kernel,
'sigma': noise_level,
'sf': self.scale,
'LR_path': LR_path,
'HR_path': HR_path
}
def main():
"""
# ----------------------------------------------------------------------------------
# In real applications, you should set proper
# - "noise_level_img": from [3, 25], set 3 for clean image, try 15 for very noisy LR images
# - "k" (or "kernel_width"): blur kernel is very important!!! kernel_width from [0.6, 3.0]
# to get the best performance.
# ----------------------------------------------------------------------------------
"""
##############################################################################
testset_name = 'Set3C' # set test set, 'set5' | 'srbsd68'
noise_level_img = 3 # set noise level of image, from [3, 25], set 3 for clean image
model_name = 'drunet_color' # 'ircnn_color' # set denoiser, | 'drunet_color' | 'ircnn_gray' | 'drunet_gray' | 'ircnn_color'
sf = 2 # set scale factor, 1, 2, 3, 4
iter_num = 24 # set number of iterations, default: 24 for SISR
# --------------------------------
# set blur kernel
# --------------------------------
kernel_width_default_x1234 = [
0.6, 0.9, 1.7, 2.2
] # Gaussian kernel widths for x1, x2, x3, x4
noise_level_model = noise_level_img / 255. # noise level of model
kernel_width = kernel_width_default_x1234[sf - 1]
"""
# set your own kernel width !!!!!!!!!!
"""
# kernel_width = 1.0
k = utils_deblur.fspecial('gaussian', 25, kernel_width)
k = sr.shift_pixel(k, sf) # shift the kernel
k /= np.sum(k)
##############################################################################
show_img = False
util.surf(k) if show_img else None
x8 = True # default: False, x8 to boost performance
modelSigma1 = 49 # set sigma_1, default: 49
modelSigma2 = max(sf, noise_level_model * 255.)
classical_degradation = True # set classical degradation or bicubic degradation
task_current = 'sr' # 'sr' for super-resolution
n_channels = 1 if 'gray' in model_name else 3 # fixed
model_zoo = 'model_zoo' # fixed
testsets = 'testsets' # fixed
results = 'results' # fixed
result_name = testset_name + '_realapplications_' + task_current + '_' + model_name
model_path = os.path.join(model_zoo, model_name + '.pth')
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
torch.cuda.empty_cache()
# ----------------------------------------
# L_path, E_path, H_path
# ----------------------------------------
L_path = os.path.join(testsets,
testset_name) # L_path, for Low-quality images
E_path = os.path.join(results, result_name) # E_path, for Estimated images
util.mkdir(E_path)
logger_name = result_name
utils_logger.logger_info(logger_name,
log_path=os.path.join(E_path,
logger_name + '.log'))
logger = logging.getLogger(logger_name)
# ----------------------------------------
# load model
# ----------------------------------------
if 'drunet' in model_name:
from models.network_unet import UNetRes as net
model = net(in_nc=n_channels + 1,
out_nc=n_channels,
nc=[64, 128, 256, 512],
nb=4,
act_mode='R',
downsample_mode="strideconv",
upsample_mode="convtranspose")
model.load_state_dict(torch.load(model_path), strict=True)
model.eval()
for _, v in model.named_parameters():
v.requires_grad = False
model = model.to(device)
elif 'ircnn' in model_name:
from models.network_dncnn import IRCNN as net
model = net(in_nc=n_channels, out_nc=n_channels, nc=64)
model25 = torch.load(model_path)
former_idx = 0
logger.info('model_name:{}, image sigma:{:.3f}, model sigma:{:.3f}'.format(
model_name, noise_level_img, noise_level_model))
logger.info('Model path: {:s}'.format(model_path))
logger.info(L_path)
L_paths = util.get_image_paths(L_path)
for idx, img in enumerate(L_paths):
# --------------------------------
# (1) get img_L
# --------------------------------
logger.info('Model path: {:s} Image: {:s}'.format(model_path, img))
img_name, ext = os.path.splitext(os.path.basename(img))
img_L = util.imread_uint(img, n_channels=n_channels)
img_L = util.uint2single(img_L)
img_L = util.modcrop(img_L, 8) # modcrop
# --------------------------------
# (2) get rhos and sigmas
# --------------------------------
rhos, sigmas = pnp.get_rho_sigma(sigma=max(0.255 / 255.,
noise_level_model),
iter_num=iter_num,
modelSigma1=modelSigma1,
modelSigma2=modelSigma2,
w=1)
rhos, sigmas = torch.tensor(rhos).to(device), torch.tensor(sigmas).to(
device)
# --------------------------------
# (3) initialize x, and pre-calculation
# --------------------------------
x = cv2.resize(img_L, (img_L.shape[1] * sf, img_L.shape[0] * sf),
interpolation=cv2.INTER_CUBIC)
if np.ndim(x) == 2:
x = x[..., None]
if classical_degradation:
x = sr.shift_pixel(x, sf)
x = util.single2tensor4(x).to(device)
img_L_tensor, k_tensor = util.single2tensor4(
img_L), util.single2tensor4(np.expand_dims(k, 2))
[k_tensor, img_L_tensor] = util.todevice([k_tensor, img_L_tensor],
device)
FB, FBC, F2B, FBFy = sr.pre_calculate(img_L_tensor, k_tensor, sf)
# --------------------------------
# (4) main iterations
# --------------------------------
for i in range(iter_num):
print('Iter: {} / {}'.format(i, iter_num))
# --------------------------------
# step 1, FFT
# --------------------------------
tau = rhos[i].float().repeat(1, 1, 1, 1)
x = sr.data_solution(x, FB, FBC, F2B, FBFy, tau, sf)
if 'ircnn' in model_name:
current_idx = np.int(
np.ceil(sigmas[i].cpu().numpy() * 255. / 2.) - 1)
if current_idx != former_idx:
model.load_state_dict(model25[str(current_idx)],
strict=True)
model.eval()
for _, v in model.named_parameters():
v.requires_grad = False
model = model.to(device)
former_idx = current_idx
# --------------------------------
# step 2, denoiser
# --------------------------------
if x8:
x = util.augment_img_tensor4(x, i % 8)
if 'drunet' in model_name:
x = torch.cat(
(x, sigmas[i].repeat(1, 1, x.shape[2], x.shape[3])), dim=1)
x = utils_model.test_mode(model,
x,
mode=2,
refield=64,
min_size=256,
modulo=16)
elif 'ircnn' in model_name:
x = model(x)
if x8:
if i % 8 == 3 or i % 8 == 5:
x = util.augment_img_tensor4(x, 8 - i % 8)
else:
x = util.augment_img_tensor4(x, i % 8)
# --------------------------------
# (3) img_E
# --------------------------------
img_E = util.tensor2uint(x)
util.imsave(
img_E,
os.path.join(E_path, img_name + '_x' + str(sf) + '_' + model_name +
'.png'))
def main():
# ----------------------------------------
# Preparation
# ----------------------------------------
noise_level_img = 0 # default: 0, noise level for LR image
noise_level_model = noise_level_img # noise level for model
model_name = 'srmdnf_x4' # 'srmd_x2' | 'srmd_x3' | 'srmd_x4' | 'srmdnf_x2' | 'srmdnf_x3' | 'srmdnf_x4'
testset_name = 'set5' # test set, 'set5' | 'srbsd68'
sf = [int(s) for s in re.findall(r'\d+', model_name)][0] # scale factor
x8 = False # default: False, x8 to boost performance
need_degradation = True # default: True, use degradation model to generate LR image
show_img = False # default: False
srmd_pca_path = os.path.join('kernels', 'srmd_pca_matlab.mat')
task_current = 'sr' # 'dn' for denoising | 'sr' for super-resolution
n_channels = 3 # fixed
in_nc = 18 if 'nf' in model_name else 19
nc = 128 # fixed, number of channels
nb = 12 # fixed, number of conv layers
model_pool = 'model_zoo' # fixed
testsets = 'testsets' # fixed
results = 'results' # fixed
result_name = testset_name + '_' + model_name
border = sf if task_current == 'sr' else 0 # shave boader to calculate PSNR and SSIM
model_path = os.path.join(model_pool, model_name + '.pth')
# ----------------------------------------
# L_path, E_path, H_path
# ----------------------------------------
L_path = os.path.join(testsets,
testset_name) # L_path, for Low-quality images
H_path = L_path # H_path, for High-quality images
E_path = os.path.join(results, result_name) # E_path, for Estimated images
util.mkdir(E_path)
if H_path == L_path:
need_degradation = True
logger_name = result_name
utils_logger.logger_info(logger_name,
log_path=os.path.join(E_path,
logger_name + '.log'))
logger = logging.getLogger(logger_name)
need_H = True if H_path is not None else False
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# ----------------------------------------
# load model
# ----------------------------------------
from models.network_srmd import SRMD as net
model = net(in_nc=in_nc,
out_nc=n_channels,
nc=nc,
nb=nb,
upscale=sf,
act_mode='R',
upsample_mode='pixelshuffle')
model.load_state_dict(torch.load(model_path), strict=False)
model.eval()
for k, v in model.named_parameters():
v.requires_grad = False
model = model.to(device)
logger.info('Model path: {:s}'.format(model_path))
number_parameters = sum(map(lambda x: x.numel(), model.parameters()))
logger.info('Params number: {}'.format(number_parameters))
test_results = OrderedDict()
test_results['psnr'] = []
test_results['ssim'] = []
test_results['psnr_y'] = []
test_results['ssim_y'] = []
logger.info('model_name:{}, model sigma:{}, image sigma:{}'.format(
model_name, noise_level_img, noise_level_model))
logger.info(L_path)
L_paths = util.get_image_paths(L_path)
H_paths = util.get_image_paths(H_path) if need_H else None
# ----------------------------------------
# kernel and PCA reduced feature
# ----------------------------------------
# kernel = sr.anisotropic_Gaussian(ksize=15, theta=np.pi, l1=4, l2=4)
kernel = utils_deblur.fspecial('gaussian', 15,
0.01) # Gaussian kernel, delta kernel 0.01
P = loadmat(srmd_pca_path)['P']
degradation_vector = np.dot(P, np.reshape(kernel, (-1), order="F"))
if 'nf' not in model_name: # noise-free SR
degradation_vector = np.append(degradation_vector,
noise_level_model / 255.)
degradation_vector = torch.from_numpy(degradation_vector).view(
1, -1, 1, 1).float()
for idx, img in enumerate(L_paths):
# ------------------------------------
# (1) img_L
# ------------------------------------
img_name, ext = os.path.splitext(os.path.basename(img))
# logger.info('{:->4d}--> {:>10s}'.format(idx+1, img_name+ext))
img_L = util.imread_uint(img, n_channels=n_channels)
img_L = util.uint2single(img_L)
# degradation process, blur + bicubic downsampling + Gaussian noise
if need_degradation:
img_L = util.modcrop(img_L, sf)
img_L = sr.srmd_degradation(
img_L, kernel, sf
) # equivalent to bicubic degradation if kernel is a delta kernel
np.random.seed(seed=0) # for reproducibility
img_L += np.random.normal(0, noise_level_img / 255., img_L.shape)
util.imshow(util.single2uint(img_L),
title='LR image with noise level {}'.format(
noise_level_img)) if show_img else None
img_L = util.single2tensor4(img_L)
degradation_map = degradation_vector.repeat(1, 1, img_L.size(-2),
img_L.size(-1))
img_L = torch.cat((img_L, degradation_map), dim=1)
img_L = img_L.to(device)
# ------------------------------------
# (2) img_E
# ------------------------------------
if not x8:
img_E = model(img_L)
else:
img_E = utils_model.test_mode(model, img_L, mode=3, sf=sf)
img_E = util.tensor2uint(img_E)
if need_H:
# --------------------------------
# (3) img_H
# --------------------------------
img_H = util.imread_uint(H_paths[idx], n_channels=n_channels)
img_H = img_H.squeeze()
img_H = util.modcrop(img_H, sf)
# --------------------------------
# PSNR and SSIM
# --------------------------------
psnr = util.calculate_psnr(img_E, img_H, border=border)
ssim = util.calculate_ssim(img_E, img_H, border=border)
test_results['psnr'].append(psnr)
test_results['ssim'].append(ssim)
logger.info('{:s} - PSNR: {:.2f} dB; SSIM: {:.4f}.'.format(
img_name + ext, psnr, ssim))
util.imshow(np.concatenate([img_E, img_H], axis=1),
title='Recovered / Ground-truth') if show_img else None
if np.ndim(img_H) == 3: # RGB image
img_E_y = util.rgb2ycbcr(img_E, only_y=True)
img_H_y = util.rgb2ycbcr(img_H, only_y=True)
psnr_y = util.calculate_psnr(img_E_y, img_H_y, border=border)
ssim_y = util.calculate_ssim(img_E_y, img_H_y, border=border)
test_results['psnr_y'].append(psnr_y)
test_results['ssim_y'].append(ssim_y)
# ------------------------------------
# save results
# ------------------------------------
util.imsave(img_E, os.path.join(E_path, img_name + '.png'))
if need_H:
ave_psnr = sum(test_results['psnr']) / len(test_results['psnr'])
ave_ssim = sum(test_results['ssim']) / len(test_results['ssim'])
logger.info(
'Average PSNR/SSIM(RGB) - {} - x{} --PSNR: {:.2f} dB; SSIM: {:.4f}'
.format(result_name, sf, ave_psnr, ave_ssim))
if np.ndim(img_H) == 3:
ave_psnr_y = sum(test_results['psnr_y']) / len(
test_results['psnr_y'])
ave_ssim_y = sum(test_results['ssim_y']) / len(
test_results['ssim_y'])
logger.info(
'Average PSNR/SSIM( Y ) - {} - x{} - PSNR: {:.2f} dB; SSIM: {:.4f}'
.format(result_name, sf, ave_psnr_y, ave_ssim_y))
def main():
# ----------------------------------------
# Preparation
# ----------------------------------------
model_name = 'usrnet' # 'usrgan' | 'usrnet' | 'usrgan_tiny' | 'usrnet_tiny'
testset_name = 'set_real' # test set, 'set_real'
test_image = 'chip.png' # 'chip.png', 'comic.png'
#test_image = 'comic.png'
sf = 4 # scale factor, only from {1, 2, 3, 4}
show_img = False # default: False
save_E = True # save estimated image
save_LE = True # save zoomed LR, Estimated images
# ----------------------------------------
# set noise level and kernel
# ----------------------------------------
if 'chip' in test_image:
noise_level_img = 15 # noise level for LR image, 15 for chip
kernel_width_default_x1234 = [0.6, 0.9, 1.7, 2.2] # Gaussian kernel widths for x1, x2, x3, x4
else:
noise_level_img = 2 # noise level for LR image, 0.5~3 for clean images
kernel_width_default_x1234 = [0.4, 0.7, 1.5, 2.0] # default Gaussian kernel widths of clean/sharp images for x1, x2, x3, x4
noise_level_model = noise_level_img/255. # noise level of model
kernel_width = kernel_width_default_x1234[sf-1]
# set your own kernel width
# kernel_width = 2.2
k = utils_deblur.fspecial('gaussian', 25, kernel_width)
k = sr.shift_pixel(k, sf) # shift the kernel
k /= np.sum(k)
util.surf(k) if show_img else None
# scio.savemat('kernel_realapplication.mat', {'kernel':k})
# load approximated bicubic kernels
#kernels = hdf5storage.loadmat(os.path.join('kernels', 'kernel_bicubicx234.mat'))['kernels']
# kernels = loadmat(os.path.join('kernels', 'kernel_bicubicx234.mat'))['kernels']
# kernel = kernels[0, sf-2].astype(np.float64)
kernel = util.single2tensor4(k[..., np.newaxis])
n_channels = 1 if 'gray' in model_name else 3 # 3 for color image, 1 for grayscale image
model_pool = 'model_zoo' # fixed
testsets = 'testsets' # fixed
results = 'results' # fixed
result_name = testset_name + '_' + model_name
model_path = os.path.join(model_pool, model_name+'.pth')
# ----------------------------------------
# L_path, E_path
# ----------------------------------------
L_path = os.path.join(testsets, testset_name) # L_path, fixed, for Low-quality images
E_path = os.path.join(results, result_name) # E_path, fixed, for Estimated images
util.mkdir(E_path)
logger_name = result_name
utils_logger.logger_info(logger_name, log_path=os.path.join(E_path, logger_name+'.log'))
logger = logging.getLogger(logger_name)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# ----------------------------------------
# load model
# ----------------------------------------
if 'tiny' in model_name:
model = net(n_iter=6, h_nc=32, in_nc=4, out_nc=3, nc=[16, 32, 64, 64],
nb=2, act_mode="R", downsample_mode='strideconv', upsample_mode="convtranspose")
else:
model = net(n_iter=8, h_nc=64, in_nc=4, out_nc=3, nc=[64, 128, 256, 512],
nb=2, act_mode="R", downsample_mode='strideconv', upsample_mode="convtranspose")
model.load_state_dict(torch.load(model_path), strict=True)
model.eval()
for key, v in model.named_parameters():
v.requires_grad = False
number_parameters = sum(map(lambda x: x.numel(), model.parameters()))
logger.info('Params number: {}'.format(number_parameters))
model = model.to(device)
logger.info('Model path: {:s}'.format(model_path))
logger.info('model_name:{}, image sigma:{}'.format(model_name, noise_level_img))
logger.info(L_path)
img = os.path.join(L_path, test_image)
# ------------------------------------
# (1) img_L
# ------------------------------------
img_name, ext = os.path.splitext(os.path.basename(img))
img_L = util.imread_uint(img, n_channels=n_channels)
img_L = util.uint2single(img_L)
util.imshow(img_L) if show_img else None
w, h = img_L.shape[:2]
logger.info('{:>10s}--> ({:>4d}x{:<4d})'.format(img_name+ext, w, h))
# boundary handling
boarder = 8 # default setting for kernel size 25x25
img = cv2.resize(img_L, (sf*h, sf*w), interpolation=cv2.INTER_NEAREST)
img = utils_deblur.wrap_boundary_liu(img, [int(np.ceil(sf*w/boarder+2)*boarder), int(np.ceil(sf*h/boarder+2)*boarder)])
img_wrap = sr.downsample_np(img, sf, center=False)
img_wrap[:w, :h, :] = img_L
img_L = img_wrap
util.imshow(util.single2uint(img_L), title='LR image with noise level {}'.format(noise_level_img)) if show_img else None
img_L = util.single2tensor4(img_L)
img_L = img_L.to(device)
# ------------------------------------
# (2) img_E
# ------------------------------------
sigma = torch.tensor(noise_level_model).float().view([1, 1, 1, 1])
[img_L, kernel, sigma] = [el.to(device) for el in [img_L, kernel, sigma]]
img_E = model(img_L, kernel, sf, sigma)
img_E = util.tensor2uint(img_E)[:sf*w, :sf*h, ...]
if save_E:
util.imsave(img_E, os.path.join(E_path, img_name+'_x'+str(sf)+'_'+model_name+'.png'))
# --------------------------------
# (3) save img_LE
# --------------------------------
if save_LE:
k_v = k/np.max(k)*1.2
k_v = util.single2uint(np.tile(k_v[..., np.newaxis], [1, 1, 3]))
k_factor = 3
k_v = cv2.resize(k_v, (k_factor*k_v.shape[1], k_factor*k_v.shape[0]), interpolation=cv2.INTER_NEAREST)
img_L = util.tensor2uint(img_L)[:w, :h, ...]
img_I = cv2.resize(img_L, (sf*img_L.shape[1], sf*img_L.shape[0]), interpolation=cv2.INTER_NEAREST)
img_I[:k_v.shape[0], :k_v.shape[1], :] = k_v
util.imshow(np.concatenate([img_I, img_E], axis=1), title='LR / Recovered') if show_img else None
util.imsave(np.concatenate([img_I, img_E], axis=1), os.path.join(E_path, img_name+'_x'+str(sf)+'_'+model_name+'_LE.png'))
def main():
model_name = 'msrresnet_x4_psnr' # 'msrresnet_x4_gan' | 'msrresnet_x4_psnr'
testset_name = 'Set14' # test set, 'set5' | 'srbsd68'
need_degradation = True # default: True
x8 = False # default: False, x8 to boost performance, default: False
sf = [int(s) for s in re.findall(r'\d+', model_name)][0] # scale factor
show_img = False # default: False
task_current = 'sr' # 'dn' for denoising | 'sr' for super-resolution
n_channels = 3 # fixed
model_pool = 'model_zoo' # fixed
testsets = 'testsets' # fixed
results = 'results' # fixed
noise_level_img = 0 # fixed: 0, noise level for LR image
result_name = testset_name + '_' + model_name
border = sf if task_current == 'sr' else 0 # shave boader to calculate PSNR and SSIM
model_path = os.path.join(model_pool, model_name + '.pth')
# ----------------------------------------
# L_path, E_path, H_path
# ----------------------------------------
L_path = os.path.join(testsets,
testset_name) # L_path, for Low-quality images
H_path = L_path # H_path, for High-quality images
E_path = os.path.join(results, result_name) # E_path, for Estimated images
util.mkdir(E_path)
if H_path == L_path:
need_degradation = True
logger_name = result_name
utils_logger.logger_info(logger_name,
log_path=os.path.join(E_path,
logger_name + '.log'))
logger = logging.getLogger(logger_name)
need_H = True if H_path is not None else False
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# ----------------------------------------
# load model
# ----------------------------------------
from models.network_msrresnet import MSRResNet1 as net
model = net(in_nc=n_channels, out_nc=n_channels, nc=64, nb=16, upscale=4)
model.load_state_dict(torch.load(model_path), strict=True)
model.eval()
for k, v in model.named_parameters():
v.requires_grad = False
model = model.to(device)
logger.info('Model path: {:s}'.format(model_path))
number_parameters = sum(map(lambda x: x.numel(), model.parameters()))
logger.info('Params number: {}'.format(number_parameters))
test_results = OrderedDict()
test_results['psnr'] = []
test_results['ssim'] = []
test_results['psnr_y'] = []
test_results['ssim_y'] = []
logger.info('model_name:{}, image sigma:{}'.format(model_name,
noise_level_img))
logger.info(L_path)
L_paths = util.get_image_paths(L_path)
H_paths = util.get_image_paths(H_path) if need_H else None
for idx, img in enumerate(H_paths):
# ------------------------------------
# (1) img_L
# ------------------------------------
img_name, ext = os.path.splitext(os.path.basename(img))
# logger.info('{:->4d}--> {:>10s}'.format(idx+1, img_name+ext))
img_H = util.imread_uint(img, n_channels=n_channels)
img_H = util.uint2single(img_H)
# degradation process, bicubic downsampling
if need_degradation:
img_H = util.modcrop(img_H, sf)
# img_L = util.imresize_np(img_L, 1/sf)
kernel = fspecial('gaussian', 15, 2.6)
img_L = utils_sisr.srmd_degradation(img_H, kernel, sf)
# img_L = util.uint2single(util.single2uint(img_L))
# np.random.seed(seed=0) # for reproducibility
# img_L += np.random.normal(0, noise_level_img/255., img_L.shape)
# util.imshow(util.single2uint(img_L), title='LR image with noise level {}'.format(noise_level_img)) if show_img else None
img_L = util.single2tensor4(img_L)
img_L = img_L.to(device)
# ------------------------------------
# (2) img_E
# ------------------------------------
if not x8:
img_E = model(img_L)
else:
img_E = utils_model.test_mode(model, img_L, mode=3, sf=sf)
img_E = util.tensor2uint(img_E)
if need_H:
# --------------------------------
# (3) img_H
# --------------------------------
img_H = util.imread_uint(H_paths[idx], n_channels=n_channels)
img_H = img_H.squeeze()
img_H = util.modcrop(img_H, sf)
# --------------------------------
# PSNR and SSIM
# --------------------------------
psnr = util.calculate_psnr(img_E, img_H, border=border)
ssim = util.calculate_ssim(img_E, img_H, border=border)
test_results['psnr'].append(psnr)
test_results['ssim'].append(ssim)
logger.info('{:s} - PSNR: {:.2f} dB; SSIM: {:.4f}.'.format(
img_name + ext, psnr, ssim))
util.imshow(np.concatenate([img_E, img_H], axis=1),
title='Recovered / Ground-truth') if show_img else None
if np.ndim(img_H) == 3: # RGB image
img_E_y = util.rgb2ycbcr(img_E, only_y=True)
img_H_y = util.rgb2ycbcr(img_H, only_y=True)
psnr_y = util.calculate_psnr(img_E_y, img_H_y, border=border)
ssim_y = util.calculate_ssim(img_E_y, img_H_y, border=border)
test_results['psnr_y'].append(psnr_y)
test_results['ssim_y'].append(ssim_y)
# ------------------------------------
# save results
# ------------------------------------
util.imsave(img_E, os.path.join(E_path, img_name + '.png'))
if need_H:
ave_psnr = sum(test_results['psnr']) / len(test_results['psnr'])
ave_ssim = sum(test_results['ssim']) / len(test_results['ssim'])
logger.info(
'Average PSNR/SSIM(RGB) - {} - x{} --PSNR: {:.3f} dB; SSIM: {:.4f}'
.format(result_name, sf, ave_psnr, ave_ssim))
if np.ndim(img_H) == 3:
ave_psnr_y = sum(test_results['psnr_y']) / len(
test_results['psnr_y'])
ave_ssim_y = sum(test_results['ssim_y']) / len(
test_results['ssim_y'])
logger.info(
'Average PSNR/SSIM( Y ) - {} - x{} - PSNR: {:.2f} dB; SSIM: {:.4f}'
.format(result_name, sf, ave_psnr_y, ave_ssim_y))
def main():
# --------------------------------
# let's start!
# --------------------------------
utils_logger.logger_info('test_dpsr_real', log_path='test_dpsr_real.log')
logger = logging.getLogger('test_dpsr_real')
global arg
arg = parser.parse_args()
# basic setting
# ================================================
sf = arg.sf
show_img = False
noise_level_img = 8. / 255.
#testsets = '/home/share2/wutong/DPSR/testsets/test/'
#im = '0000115_01031_d_0000082.jpg' # chip.png colour.png
# if 'chip' in im:
# noise_level_img = 8./255.
# elif 'colour' in im:
#noise_level_img = 0.5/255.
use_srganplus = False
if use_srganplus and sf == 4:
model_prefix = 'DPSRGAN'
save_suffix = 'dpsrgan'
else:
model_prefix = 'DPSR'
save_suffix = 'dpsr'
model_path = os.path.join('DPSR_models', model_prefix + 'x%01d.pth' % (sf))
iter_num = 15 # number of iterations
n_channels = 3 # only color images, fixed
# ================================================
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# --------------------------------
# (1) load trained model
# --------------------------------
model = SRResNet(in_nc=4,
out_nc=3,
nc=96,
nb=16,
upscale=sf,
act_mode='R',
upsample_mode='pixelshuffle')
model.load_state_dict(torch.load(model_path), strict=True)
model.eval()
for k, v in model.named_parameters():
v.requires_grad = False
model = model.to(device)
logger.info('Model path {:s}. Testing...'.format(model_path))
# --------------------------------
# (2) L_folder, E_folder
# --------------------------------
# --1--> L_folder, folder of Low-quality images
L_folder = os.path.join(arg.load) # L: Low quality
# --2--> E_folder, folder of Estimated images
E_folder = os.path.join(arg.save)
util.mkdir(E_folder)
logger.info(L_folder)
# for im in os.listdir(os.path.join(L_folder)):
# if (im.endswith('.jpg') or im.endswith('.bmp') or im.endswith('.png')) and 'kernel' not in im:
# --------------------------------
# (3) load low-resolution image
# --------------------------------
img_list = os.listdir(L_folder)
for im in img_list:
img_path, ext = os.path.splitext(im)
img_name = img_path.split('/')[-1]
img = util.imread_uint(os.path.join(L_folder, im),
n_channels=n_channels)
h, w = img.shape[:2]
util.imshow(img, title='Low-resolution image') if show_img else None
img = util.unit2single(img)
# --------------------------------
# (4) load blur kernel
# --------------------------------
# if os.path.exists(os.path.join(L_folder, img_name+'_kernel.mat')):
# k = loadmat(os.path.join(L_folder, img_name+'.mat'))['kernel']
# k = k.astype(np.float64)
# k /= k.sum()
# elif os.path.exists(os.path.join(L_folder, img_name+'_kernel.png')):
# k = cv2.imread(os.path.join(L_folder, img_name+'_kernel.png'), 0)
# k = np.float64(k) # float64 !
# k /= k.sum()
#else:
k = utils_deblur.fspecial('gaussian', 5, 0.25)
iter_num = 5
# --------------------------------
# (5) handle boundary
# --------------------------------
img = utils_deblur.wrap_boundary_liu(
img,
utils_deblur.opt_fft_size(
[img.shape[0] + k.shape[0] + 1,
img.shape[1] + k.shape[1] + 1]))
# --------------------------------
# (6) get upperleft, denominator
# --------------------------------
upperleft, denominator = utils_deblur.get_uperleft_denominator(img, k)
# --------------------------------
# (7) get rhos and sigmas
# --------------------------------
rhos, sigmas = utils_deblur.get_rho_sigma(sigma=max(
0.255 / 255.0, noise_level_img),
iter_num=iter_num)
# --------------------------------
# (8) main iteration
# --------------------------------
z = img
rhos = np.float32(rhos)
sigmas = np.float32(sigmas)
for i in range(iter_num):
logger.info('Iter: {:->4d}--> {}'.format(i + 1, im))
# --------------------------------
# step 1, Eq. (9) // FFT
# --------------------------------
rho = rhos[i]
if i != 0:
z = util.imresize_np(z, 1 / sf, True)
z = np.real(
np.fft.ifft2((upperleft + rho * np.fft.fft2(z, axes=(0, 1))) /
(denominator + rho),
axes=(0, 1)))
# --------------------------------
# step 2, Eq. (12) // super-resolver
# --------------------------------
sigma = torch.from_numpy(np.array(sigmas[i]))
img_L = util.single2tensor4(z)
noise_level_map = torch.ones((1, 1, img_L.size(2), img_L.size(3)),
dtype=torch.float).mul_(sigma)
img_L = torch.cat((img_L, noise_level_map), dim=1)
img_L = img_L.to(device)
# with torch.no_grad():
z = model(img_L)
z = util.tensor2single(z)
# --------------------------------
# (9) img_E
# --------------------------------
img_E = util.single2uint(
z[:h * sf, :w * sf]) # np.uint8((z[:h*sf, :w*sf] * 255.0).round())
logger.info('saving: sf = {}, {}.'.format(
sf, img_name + '_x{}'.format(sf) + ext))
util.imsave(img_E, os.path.join(E_folder, img_name + ext))
util.imshow(img_E, title='Recovered image') if show_img else None
def main():
# ----------------------------------------
# Preparation
# ----------------------------------------
if noise_level_model == -1:
model_name = 'srmdnf_x' + str(sf)
else:
model_name = 'srmd_x' + str(sf)
model_path = os.path.join(model_pool, model_name+'.pth')
in_nc = 18 if 'nf' in model_name else 19
# ----------------------------------------
# L_path, E_path, H_path
# ----------------------------------------
L_path = sources # L_path, for Low-quality images
E_path = results # E_path, for Estimated images
if not os.path.splitext(E_path)[1]:
util.mkdir(E_path)
device = torch.device(using_device)
# ----------------------------------------
# load model
# ----------------------------------------
from utils.network_srmd import SRMD as net
model = net(in_nc=in_nc, out_nc=n_channels, nc=nc, nb=nb,
upscale=sf, act_mode='R', upsample_mode='pixelshuffle')
model.load_state_dict(torch.load(model_path), strict=False)
model.eval()
for _, v in model.named_parameters():
v.requires_grad = False
model = model.to(device)
if os.path.isfile(L_path):
L_paths = [L_path]
else:
L_paths = util.get_image_paths(L_path)
# ----------------------------------------
# kernel and PCA reduced feature
# ----------------------------------------
# Gaussian kernel, delta kernel 0.01
kernel = utils_deblur.fspecial('gaussian', 15, 0.01)
P = loadmat(srmd_pca_path)['P']
degradation_vector = np.dot(P, np.reshape(kernel, (-1), order="F"))
if 'nf' not in model_name: # noise-free SR
degradation_vector = np.append(
degradation_vector, noise_level_model/255.)
degradation_vector = torch.from_numpy(
degradation_vector).view(1, -1, 1, 1).float()
for _, img in enumerate(L_paths):
img_name, _ = os.path.splitext(os.path.basename(img))
try:
# ------------------------------------
# (1) img_L
# ------------------------------------
img_L, alpha = util.imread_uint_alpha(img, n_channels=n_channels)
# Bicubic to handle alpha channel if the intended picture is supposed to have.
if not alpha is None and picture_format == "png":
alpha = util.uint2tensor4(alpha)
alpha = torch.nn.functional.interpolate(
alpha, scale_factor=sf, mode='bicubic', align_corners=False)
alpha = alpha.to(device)
alpha = torch.clamp(alpha, 0, 255)
alpha = util.tensor2uint(alpha)
img_L = util.uint2tensor4(img_L)
degradation_map = degradation_vector.repeat(
1, 1, img_L.size(-2), img_L.size(-1))
img_L = torch.cat((img_L, degradation_map), dim=1)
img_L = img_L.to(device)
# ------------------------------------
# (2) img_E
# ------------------------------------
if not x8:
img_E = model(img_L)
else:
img_E = utils_model.test_mode(model, img_L, mode=3, sf=sf)
img_E = util.tensor2uint(img_E)
if not alpha is None and picture_format == "png":
alpha = alpha.reshape((alpha.shape[0], alpha.shape[1], 1))
img_E = np.concatenate((img_E, alpha), axis=2)
elif not alpha is None:
print("Warning! You lost your alpha channel for this picture!")
# ------------------------------------
# save results
# ------------------------------------
if os.path.splitext(E_path)[1]:
util.imsave(img_E, E_path)
else:
util.imsave(img_E, os.path.join(
E_path, img_name+'.' + picture_format))
print(os.path.basename(img) + " successfully saved to disk!")
except Exception:
traceback.print_exc()
print(os.path.basename(img) + " failed!")
def main():
# ----------------------------------------
# Preparation
# ----------------------------------------
model_name = 'usrnet_tiny' # 'usrgan' | 'usrnet' | 'usrgan_tiny' | 'usrnet_tiny'
testset_name = 'srcvte' # test set, 'set5' | 'srbsd68' | 'srcvte'
test_sf = [
4
] # if 'gan' in model_name else [2, 3, 4] # scale factor, from {1,2,3,4}
load_kernels = False
show_img = False # default: False
save_L = False # save LR image
save_E = True # save estimated image
save_LEH = False # save zoomed LR, E and H images
# ----------------------------------------
# load testing kernels
# ----------------------------------------
# kernels = hdf5storage.loadmat(os.path.join('kernels', 'kernels.mat'))['kernels']
kernels = loadmat(os.path.join(
'kernels', 'kernels_12.mat'))['kernels'] if load_kernels else None
n_channels = 1 if 'gray' in model_name else 3 # 3 for color image, 1 for grayscale image
model_pool = '/home/dengzeshuai/pretrained_models/USRnet/' # fixed
testsets = '/home/datasets/sr/' # fixed
results = 'results' # fixed
noise_level_img = 0 # fixed: 0, noise level for LR image
noise_level_model = noise_level_img # fixed, noise level of model, default 0
result_name = testset_name + '_' + model_name + '_blur'
model_path = os.path.join(model_pool, model_name + '.pth')
# ----------------------------------------
# L_path = H_path, E_path, logger
# ----------------------------------------
L_path = os.path.join(
testsets,
testset_name) # L_path and H_path, fixed, for Low-quality images
if testset_name == 'srcvte':
L_path = os.path.join(testsets, testset_name, 'LR_val')
H_path = os.path.join(testsets, testset_name, 'HR_val')
video_names = os.listdir(H_path)
E_path = os.path.join(results,
result_name) # E_path, fixed, for Estimated images
util.mkdir(E_path)
logger_name = result_name
utils_logger.logger_info(logger_name,
log_path=os.path.join(E_path,
logger_name + '.log'))
logger = logging.getLogger(logger_name)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# ----------------------------------------
# load model
# ----------------------------------------
if 'tiny' in model_name:
model = net(n_iter=6,
h_nc=32,
in_nc=4,
out_nc=3,
nc=[16, 32, 64, 64],
nb=2,
act_mode="R",
downsample_mode='strideconv',
upsample_mode="convtranspose")
else:
model = net(n_iter=8,
h_nc=64,
in_nc=4,
out_nc=3,
nc=[64, 128, 256, 512],
nb=2,
act_mode="R",
downsample_mode='strideconv',
upsample_mode="convtranspose")
model.load_state_dict(torch.load(model_path), strict=True)
model.eval()
for key, v in model.named_parameters():
v.requires_grad = False
number_parameters = sum(map(lambda x: x.numel(), model.parameters()))
model = model.to(device)
logger.info('Model path: {:s}'.format(model_path))
logger.info('Params number: {}'.format(number_parameters))
logger.info('Model_name:{}, image sigma:{}'.format(model_name,
noise_level_img))
logger.info(L_path)
L_paths = util.get_image_paths(L_path)
need_H = True if H_path is not None else False
H_paths = util.get_image_paths(H_path) if need_H else None
# --------------------------------
# read images
# --------------------------------
test_results_ave = OrderedDict()
test_results_ave['psnr_sf_k'] = []
test_results_ave['ssim_sf_k'] = []
test_results_ave['psnr_y_sf_k'] = []
test_results_ave['ssim_y_sf_k'] = []
for sf in test_sf:
loop = kernels.shape[1] if load_kernels else 1
for k_index in range(loop):
test_results = OrderedDict()
test_results['psnr'] = []
test_results['ssim'] = []
test_results['psnr_y'] = []
test_results['ssim_y'] = []
if load_kernels:
kernel = kernels[0, k_index].astype(np.float64)
else:
## other kernels
# kernel = utils_deblur.blurkernel_synthesis(h=25) # motion kernel
kernel = utils_deblur.fspecial('gaussian', 25,
1.6) # Gaussian kernel
kernel = sr.shift_pixel(kernel, sf) # pixel shift; optional
kernel /= np.sum(kernel)
util.surf(kernel) if show_img else None
# idx = 0
for idx, img in enumerate(L_paths):
# --------------------------------
# (1) classical degradation, img_L
# --------------------------------
img_name, ext = os.path.splitext(os.path.basename(img))
if testset_name == 'srcvte':
video_name = os.path.basename(os.path.dirname(img))
img_L = util.imread_uint(img, n_channels=n_channels)
img_L = util.uint2single(img_L)
# generate degraded LR image
# img_L = ndimage.filters.convolve(img_H, kernel[..., np.newaxis], mode='wrap') # blur
# img_L = sr.downsample_np(img_L, sf, center=False) # downsample, standard s-fold downsampler
# img_L = util.uint2single(img_L) # uint2single
# np.random.seed(seed=0) # for reproducibility
# img_L += np.random.normal(0, noise_level_img, img_L.shape) # add AWGN
util.imshow(util.single2uint(img_L)) if show_img else None
x = util.single2tensor4(img_L)
k = util.single2tensor4(kernel[..., np.newaxis])
sigma = torch.tensor(noise_level_model).float().view(
[1, 1, 1, 1])
[x, k, sigma] = [el.to(device) for el in [x, k, sigma]]
# --------------------------------
# (2) inference
# --------------------------------
x = model(x, k, sf, sigma)
# --------------------------------
# (3) img_E
# --------------------------------
img_E = util.tensor2uint(x)
if save_E:
if testset_name == 'srcvte':
save_path = os.path.join(E_path, video_name)
util.mkdir(save_path)
# util.imsave(img_E, os.path.join(save_path, img_name+'_k'+str(k_index+1)+'.png'))
util.imsave(img_E,
os.path.join(save_path, img_name + '.png'))
else:
util.imsave(
img_E,
os.path.join(
E_path, img_name + '_x' + str(sf) + '_k' +
str(k_index + 1) + '_' + model_name + '.png'))
# --------------------------------
# (4) img_H
# --------------------------------
if need_H:
img_H = util.imread_uint(H_paths[idx],
n_channels=n_channels)
img_H = img_H.squeeze()
img_H = util.modcrop(img_H, sf)
psnr = util.calculate_psnr(
img_E, img_H, border=sf) # change with your own border
ssim = util.calculate_ssim(img_E, img_H, border=sf)
test_results['psnr'].append(psnr)
test_results['ssim'].append(ssim)
if np.ndim(img_H) == 3: # RGB image
img_E_y = util.rgb2ycbcr(img_E, only_y=True)
img_H_y = util.rgb2ycbcr(img_H, only_y=True)
psnr_y = util.calculate_psnr(img_E_y,
img_H_y,
border=sf)
ssim_y = util.calculate_ssim(img_E_y,
img_H_y,
border=sf)
test_results['psnr_y'].append(psnr_y)
test_results['ssim_y'].append(ssim_y)
logger.info(
'{:->4d} --> {:>4s}--> {:>10s} -- x{:>2d} --k{:>2d} PSNR: {:.2f}dB SSIM: {:.4f}'
.format(idx, video_name, img_name + ext, sf,
k_index, psnr_y, ssim_y))
else:
logger.info(
'{:->4d} --> {:>4s}--> {:>10s} -- x{:>2d} --k{:>2d} PSNR: {:.2f}dB SSIM: {:.4f}'
.format(idx, video_name, img_name + ext, sf,
k_index, psnr, ssim))
if need_H:
ave_psnr = sum(test_results['psnr']) / len(
test_results['psnr'])
ave_ssim = sum(test_results['ssim']) / len(
test_results['ssim'])
logger.info(
'Average PSNR/SSIM(RGB) - {} - x{} --PSNR: {:.2f} dB; SSIM: {:.4f}'
.format(result_name, sf, ave_psnr, ave_ssim))
logger.info(
'------> Average PSNR(RGB) - {} - x{}, kernel:{} sigma:{} --PSNR: {:.2f} dB; SSIM: {:.4f}'
.format(testset_name, sf, k_index + 1, noise_level_model,
ave_psnr, ave_ssim))
if np.ndim(img_H) == 3:
ave_psnr_y = sum(test_results['psnr_y']) / len(
test_results['psnr_y'])
ave_ssim_y = sum(test_results['ssim_y']) / len(
test_results['ssim_y'])
logger.info(
'------> Average PSNR(Y) - {} - x{}, kernel:{} sigma:{} --PSNR: {:.2f} dB; SSIM: {:.4f}'
.format(testset_name, sf, k_index + 1,
noise_level_model, ave_psnr_y, ave_ssim_y))
test_results_ave['psnr_sf_k'].append(ave_psnr)
test_results_ave['ssim_sf_k'].append(ave_ssim)
if np.ndim(img_H) == 3:
test_results_ave['psnr_y_sf_k'].append(ave_psnr_y)
test_results_ave['ssim_y_sf_k'].append(ave_ssim_y)
logger.info(test_results_ave['psnr_sf_k'])
logger.info(test_results_ave['ssim_sf_k'])
if np.ndim(img_H) == 3:
logger.info(test_results_ave['psnr_y_sf_k'])
logger.info(test_results_ave['ssim_y_sf_k'])