def evaluate(model, dataloader, epoch, writer, logger, data_name='val'): save_root = os.path.join(opt.result_dir, opt.tag, str(epoch), data_name) utils.try_make_dir(save_root) total_psnr = 0.0 total_ssim = 0.0 ct_num = 0 # print('Start testing ' + tag + '...') for i, sample in enumerate(dataloader): utils.progress_bar(i, len(dataloader), 'Eva... ') path = sample['path'] with torch.no_grad(): recovered = model(sample) if data_name == 'val': label = sample['label'] label = tensor2im(label) recovered = tensor2im(recovered) ct_num += 1 total_psnr += psnr(recovered, label, data_range=255) total_ssim += ski_ssim(recovered, label, data_range=255, multichannel=True) save_dst = os.path.join(save_root, utils.get_file_name(path[0]) + '.png') Image.fromarray(recovered).save(save_dst) elif data_name == 'test': pass else: raise Exception('Unknown dataset name: %s.' % data_name) # 保存结果 save_dst = os.path.join(save_root, utils.get_file_name(path[0]) + '.png') Image.fromarray(recovered).save(save_dst) if data_name == 'val': ave_psnr = total_psnr / float(ct_num) ave_ssim = total_ssim / float(ct_num) # write_loss(writer, f'val/{data_name}', 'psnr', total_psnr / float(ct_num), epochs) logger.info(f'Eva({data_name}) epoch {epoch}, psnr: {ave_psnr}.') logger.info(f'Eva({data_name}) epoch {epoch}, ssim: {ave_ssim}.') return f'{ave_ssim: .3f}' else: return ''
res[res < 0] = 0 res *= 255 res = res.astype(np.uint8) res = res.transpose((1, 2, 0)) label = label.numpy()[0] label *= 255 label = label.astype(np.uint8) label = label.transpose((1, 2, 0)) if YCRCB_jpeg: res = cv2.cvtColor(res, cv2.COLOR_RGB2YCR_CB)[:, :, 0] label = cv2.cvtColor(label, cv2.COLOR_RGB2YCR_CB)[:, :, 0] ave_psnr += psnr(res, label, data_range=255) ave_ssim += ski_ssim(res, label, data_range=255, multichannel=False) ct_num += 1 else: ave_psnr += psnr(res, label, data_range=255) ave_ssim += ski_ssim(res, label, data_range=255, multichannel=True) ct_num += 1 print('psnr_jpeg: ' + str(ave_psnr / float(ct_num)) + '.') print('ssim_jpeg: ' + str(ave_ssim / float(ct_num)) + '.') ave_psnr = 0.0 ave_ssim = 0.0 ct_num = 0 for test_iter, te_info in enumerate( open(test3_list_pth).read().splitlines()): te_pair_pth = testroot3 + te_info
for vi in range(v): ct_num += 1 hazy_vi = hazy[bi, vi] hazy_vi = hazy_vi.unsqueeze(dim=0) hazy_vi = Variable(hazy_vi, requires_grad=False).cuda() res = cleaner(hazy_vi) res = res.data.cpu().numpy()[0] res[res > 1] = 1 res[res < 0] = 0 res *= 255 res = res.astype(np.uint8) res = res.transpose((1, 2, 0)) ave_psnr += psnr(res, label_v, data_range=255) ave_ssim += ski_ssim(res, label_v, data_range=255, multichannel=True) Image.fromarray(res).save(show_dst + im_name[0].split('.')[0] + '_' + str(vi + 1) + '.png') elif data_name == 'DCPDNData': ct_num += 1 label = label.numpy()[0] label = label.transpose((1, 2, 0)) hazy = Variable(hazy, requires_grad=False).cuda() res = cleaner(hazy) res = res.data.cpu().numpy()[0] res[res > 1] = 1 res[res < 0] = 0 res = res.transpose((1, 2, 0)) ave_psnr += psnr(res, label, data_range=1)
def __call__(self, cgp, gpuID, epoch_num=150, gpu_num=1, result_file='results', rank=4, layer_num=1, steps=4, model_id=1): print('GPUID :', gpuID) print('epoch_num:', epoch_num) # define model torch.manual_seed(2018) torch.cuda.manual_seed(2018) torch.backends.cudnn.benchmark = True torch.backends.cudnn.enabled = True L1_loss = nn.L1Loss() L1_loss = L1_loss.cuda(gpuID) if model_id == 1: from model.OWAN import Network as Network1 model = Network1(16, layer_num, L1_loss, gpuID=gpuID, steps=steps) elif model_id == 2: from model.model_2order_ming import Network as Network2 model = Network2(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 3: from model.model_3order_ming import Network as Network3 model = Network3(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 4: from model.model_4order_ming import Network as Network4 model = Network4(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 5: from model.model_2order_ming_unshare import Network as Network5 model = Network5(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 6: from model.model_3order_ming_unshare import Network as Network6 model = Network6(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 7: from model.model_4order_ming_unshare import Network as Network7 model = Network7(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 8: from model.model_2order_tt import Network as Network8 model = Network8(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 9: from model.model_3order_tt import Network as Network9 model = Network9(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 10: from model.model_4order_tt import Network as Network10 model = Network10(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 11: from model.model_2order_tr_share import Network as Network11 model = Network11(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 12: from model.model_3order_tr_share import Network as Network12 model = Network12(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 13: from model.model_4order_tr_share import Network as Network13 model = Network13(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 14: from model.model_2order_tr_unshare import Network as Network14 model = Network14(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) elif model_id == 15: from model.model_3order_tr_unshare import Network as Network15 model = Network15(16, layer_num, L1_loss, gpuID=gpuID, steps=steps, rank=rank) if gpu_num > 1: device_ids = [i for i in range(gpu_num)] model = torch.nn.DataParallel(model, device_ids=device_ids) model = model.cuda(gpuID) logging.info("param size = %fMB", utils.count_parameters_in_MB(model)) print('Param:', utils.count_parameters_in_MB(model)) optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999)) # for output images if not os.path.exists(result_file): os.makedirs('./' + result_file + '/Inputs') os.makedirs('./' + result_file + '/Outputs') os.makedirs('./' + result_file + '/Targets') os.makedirs(result_file + '/Models') checkpoint_path = None model_dir = './' + result_file + '/Models/' model_list = os.listdir(model_dir) flag = 0 for num in range(100, 0, -1): for model_name in model_list: if str(num) in model_name: checkpoint_path = model_dir + model_name flag = 1 break if flag == 1: break model, optimizer, last_epoch = load_checkpoint(model, checkpoint_path, optimizer) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epoch_num) test_interval = 5 # Train loop for epoch in range(1, epoch_num + 1): scheduler.step() if epoch <= last_epoch: continue start_time = time.time() print('epoch', epoch) train_loss = 0 for module in model.children(): module.train(True) for ite, (input, target) in enumerate(self.dataloader): lr_patch = Variable(input, requires_grad=False).cuda(gpuID) hr_patch = Variable(target, requires_grad=False).cuda(gpuID) optimizer.zero_grad() output = model(lr_patch) l1_loss = L1_loss(output, hr_patch) l1_loss.backward() optimizer.step() train_loss += l1_loss.item() if ite % 500 == 0: vutils.save_image(lr_patch.data, './' + result_file + '/input_sample%d.png' % gpuID, normalize=False) vutils.save_image(hr_patch.data, './' + result_file + '/target_sample%d.png' % gpuID, normalize=False) vutils.save_image(output.data, './' + result_file + '/output_sample%d.png' % gpuID, normalize=False) print('Train set : Average loss: {:.4f}'.format(train_loss)) print('time ', time.time() - start_time) # check val/test performance if epoch % test_interval == 0: with torch.no_grad(): print('------------------------') for module in model.children(): module.train(False) # mild test_psnr = 0 test_ssim = 0 eps = 1e-10 test_ite = 0 for i, (input, target) in enumerate(self.val_loader): lr_patch = Variable(input.float(), requires_grad=False).cuda(gpuID) hr_patch = Variable(target.float(), requires_grad=False).cuda(gpuID) output = model(lr_patch) # save images vutils.save_image(output.data, './' + result_file + '/Outputs/%05d.png' % (int(i)), padding=0, normalize=False) vutils.save_image(lr_patch.data, './' + result_file + '/Inputs/%05d.png' % (int(i)), padding=0, normalize=False) vutils.save_image(hr_patch.data, './' + result_file + '/Targets/%05d.png' % (int(i)), padding=0, normalize=False) # Calculation of SSIM and PSNR values output = output.data.cpu().numpy()[0] output[output > 1] = 1 output[output < 0] = 0 output = output.transpose((1, 2, 0)) hr_patch = hr_patch.data.cpu().numpy()[0] hr_patch[hr_patch > 1] = 1 hr_patch[hr_patch < 0] = 0 hr_patch = hr_patch.transpose((1, 2, 0)) # SSIM test_ssim += ski_ssim(output, hr_patch, data_range=1, multichannel=True) # PSNR imdf = (output - hr_patch)**2 mse = np.mean(imdf) + eps test_psnr += 10 * math.log10(1.0 / mse) test_ite += 1 test_psnr /= (test_ite) test_ssim /= (test_ite) print('Valid PSNR: {:.4f}'.format(test_psnr)) print('Valid SSIM: {:.4f}'.format(test_ssim)) print('------------------------') torch.save( { 'epoch': epoch, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict() }, './' + result_file + '/Models/model_%d.pth.tar' % int(epoch)) return train_loss
clean_F = cleaner(img_C, img_M, img_F, task) img_C, img_M, img_F = ProcessResult(clean_F) clean_F = clean_F.data.cpu().numpy()[0] clean_F[clean_F > 1] = 1 clean_F[clean_F < 0] = 0 clean_F = clean_F * 255 clean_F = clean_F.astype(np.uint8) clean_F = clean_F.transpose((1, 2, 0)) if YCRCB_rain: clean_F = cv2.cvtColor(clean_F, cv2.COLOR_RGB2YCR_CB)[:, :, 0] label_F = cv2.cvtColor(label_F, cv2.COLOR_RGB2YCR_CB)[:, :, 0] ave_psnr += psnr(clean_F, label_F, data_range=255) ave_ssim += ski_ssim(clean_F, label_F, data_range=255, multichannel=False) ct_num += 1.0 else: ave_psnr += psnr(clean_F, label_F, data_range=255) ave_ssim += ski_ssim(clean_F, label_F, data_range=255, multichannel=True) ct_num += 1.0 print('Rain-PSNR: ' + str(ave_psnr / ct_num) + '.') print('Rain-SSIM: ' + str(ave_ssim / ct_num) + '.') # Jpeg ave_psnr = 0.0 ave_ssim = 0.0
def __call__(self, cgp, gpuID, epoch_num=150, gpu_num=1): print('GPUID :', gpuID) print('epoch_num:', epoch_num) # define model torch.manual_seed(2018) torch.cuda.manual_seed(2018) torch.backends.cudnn.benchmark = True torch.backends.cudnn.enabled = True L1_loss = nn.L1Loss() L1_loss = L1_loss.cuda(gpuID) model = Network(16, 10, L1_loss, gpuID=gpuID) if gpu_num > 1: device_ids = [i for i in range(gpu_num)] model = torch.nn.DataParallel(model, device_ids=device_ids) model = model.cuda(gpuID) logging.info("param size = %fMB", utils.count_parameters_in_MB(model)) print('Param:', utils.count_parameters_in_MB(model)) optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999)) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epoch_num) test_interval = 5 # for output images if not os.path.exists('./results'): os.makedirs('./results/Inputs') os.makedirs('./results/Outputs') os.makedirs('./results/Targets') # Train loop for epoch in range(1, epoch_num+1): scheduler.step() start_time = time.time() print('epoch', epoch) train_loss = 0 for module in model.children(): module.train(True) for ite, (input, target) in enumerate(self.dataloader): lr_patch = Variable(input, requires_grad=False).cuda(gpuID) hr_patch = Variable(target, requires_grad=False).cuda(gpuID) optimizer.zero_grad() output = model(lr_patch) l1_loss = L1_loss(output, hr_patch) l1_loss.backward() optimizer.step() train_loss += l1_loss.item() if ite % 500 == 0: vutils.save_image(lr_patch.data, './input_sample%d.png' % gpuID, normalize=False) vutils.save_image(hr_patch.data, './target_sample%d.png' % gpuID, normalize=False) vutils.save_image(output.data, './output_sample%d.png' % gpuID, normalize=False) print('Train set : Average loss: {:.4f}'.format(train_loss)) print('time ', time.time()-start_time) # check val/test performance if epoch % test_interval == 0: with torch.no_grad(): print('------------------------') for module in model.children(): module.train(False) test_psnr = 0 test_ssim = 0 eps = 1e-10 test_ite = 0 for _, (input, target) in enumerate(self.val_loader): lr_patch = Variable(input, requires_grad=False).cuda(gpuID) hr_patch = Variable(target, requires_grad=False).cuda(gpuID) output = model(lr_patch) # save images vutils.save_image(output.data, './results/Outputs/%05d.png' % (int(i)), padding=0, normalize=False) vutils.save_image(lr_patch.data, './results/Inputs/%05d.png' % (int(i)), padding=0, normalize=False) vutils.save_image(hr_patch.data, './results/Targets/%05d.png' % (int(i)), padding=0, normalize=False) # Calculation of SSIM and PSNR values output = output.data.cpu().numpy()[0] output[output>1] = 1 output[output<0] = 0 output = output.transpose((1,2,0)) hr_patch = hr_patch.data.cpu().numpy()[0] hr_patch[hr_patch>1] = 1 hr_patch[hr_patch<0] = 0 hr_patch = hr_patch.transpose((1,2,0)) # SSIM test_ssim+= ski_ssim(output, hr_patch, data_range=1, multichannel=True) # PSNR imdf = (output - hr_patch) ** 2 mse = np.mean(imdf) + eps test_psnr+= 10 * math.log10(1.0/mse) test_ite += 1 test_psnr /= (test_ite) test_ssim /= (test_ite) print('Valid PSNR: {:.4f}'.format(test_psnr)) print('Valid SSIM: {:.4f}'.format(test_ssim)) f = open('PSNR.txt', 'a') writer = csv.writer(f, lineterminator='\n') writer.writerow([epoch, test_psnr, test_ssim]) f.close() print('------------------------') torch.save(model.state_dict(), './model_%d.pth' % int(epoch)) return train_loss
def ssim(image, reference_image): r"""Compute the score of ``image`` regarding ``reference_image`` with the *Structural Similarity Index Measure* (SSIM) metric. See [1]_, [2]_, [3]_ and [4]_ for more information. The SSIM index is calculated on various windows of an image. The measure between two windows :math:`x` and :math:`y` of common size :math:`N.N` is: .. math:: \hbox{SSIM}(x,y) = \frac{(2\mu_x\mu_y + c_1)(2\sigma_{xy} + c_2)}{(\mu_x^2 + \mu_y^2 + c_1)(\sigma_x^2 + \sigma_y^2 + c_2)} with: * :math:`\scriptstyle\mu_x` the average of :math:`\scriptstyle x`; * :math:`\scriptstyle\mu_y` the average of :math:`\scriptstyle y`; * :math:`\scriptstyle\sigma_x^2` the variance of :math:`\scriptstyle x`; * :math:`\scriptstyle\sigma_y^2` the variance of :math:`\scriptstyle y`; * :math:`\scriptstyle \sigma_{xy}` the covariance of :math:`\scriptstyle x` and :math:`\scriptstyle y`; * :math:`\scriptstyle c_1 = (k_1L)^2`, :math:`\scriptstyle c_2 = (k_2L)^2` two variables to stabilize the division with weak denominator; * :math:`\scriptstyle L` the dynamic range of the pixel-values (typically this is :math:`\scriptstyle 2^{\#bits\ per\ pixel}-1`); * :math:`\scriptstyle k_1 = 0.01` and :math:`\scriptstyle k_2 = 0.03` by default. The SSIM index satisfies the condition of symmetry: .. math:: \text{SSIM}(x, y) = \text{SSIM}(y, x) Parameters ---------- image: 2D ndarray The cleaned image returned by the image cleanning algorithm to assess. reference_image: 2D ndarray The actual clean image (the best result that can be expected for the image cleaning algorithm). Returns ------- float The score of the image cleaning algorithm for the given image. References ---------- .. [1] Wang, Z., Bovik, A. C., Sheikh, H. R., & Simoncelli, E. P. (2004). Image quality assessment: From error visibility to structural similarity. IEEE Transactions on Image Processing, 13, 600-612. https://ece.uwaterloo.ca/~z70wang/publications/ssim.pdf, DOI:10.1.1.11.2477 .. [2] Avanaki, A. N. (2009). Exact global histogram specification optimized for structural similarity. Optical Review, 16, 613-621. http://arxiv.org/abs/0901.0065, DOI:10.1007/s10043-009-0119-z .. [3] http://scikit-image.org/docs/dev/api/skimage.measure.html#compare-ssim .. [4] https://en.wikipedia.org/wiki/Structural_similarity """ # Copy and cast images to prevent tricky bugs # See https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.astype.html#numpy-ndarray-astype image = image.astype('float64', copy=True) reference_image = reference_image.astype('float64', copy=True) # TODO: the following two lines may be wrong... image[np.isnan(image)] = 0 reference_image[np.isnan(reference_image)] = 0 ssim_val, ssim_image = ski_ssim(image, reference_image, full=True, gaussian_weights=True, sigma=0.5) return float(ssim_val)
for i, (input, target) in enumerate(test_dataloader): lr_patch = Variable(input.float(), requires_grad=False).cuda(gpuID) hr_patch = Variable(target.float(), requires_grad=False).cuda(gpuID) output = model(lr_patch) # Calculation of SSIM and PSNR values output = output.data.cpu().numpy() output[output > 1] = 1 output[output < 0] = 0 output = output.transpose((0, 2, 3, 1)) hr_patch = hr_patch.data.cpu().numpy() hr_patch[hr_patch > 1] = 1 hr_patch[hr_patch < 0] = 0 hr_patch = hr_patch.transpose((0, 2, 3, 1)) # SSIM for index in range(output.shape[0]): test_ssim += ski_ssim(output[index], hr_patch[index], data_range=1, multichannel=True) # PSNR for index in range(output.shape[0]): imdf = (output[index] - hr_patch[index])**2 mse = np.mean(imdf) + eps test_psnr += 10 * math.log10(1.0 / mse) test_ite += 1 test_psnr /= (test_ite) test_ssim /= (test_ite) print('Test PSNR: {:.4f}'.format(test_psnr)) print('Test SSIM: {:.4f}'.format(test_ssim)) print('------------------------')
normalize=False) vutils.save_image(lr_patch.data, './results/Inputs/%05d.png' % (int(i)), padding=0, normalize=False) vutils.save_image(hr_patch.data, './results/Targets/%05d.png' % (int(i)), padding=0, normalize=False) # SSIM and PSNR output = output.data.cpu().numpy()[0] output[output > 1] = 1 output[output < 0] = 0 output = output.transpose((1, 2, 0)) hr_patch = hr_patch.data.cpu().numpy()[0] hr_patch[hr_patch > 1] = 1 hr_patch[hr_patch < 0] = 0 hr_patch = hr_patch.transpose((1, 2, 0)) # SSIM test_ssim += ski_ssim(output, hr_patch, data_range=1, multichannel=True) # PSNR imdf = (output - hr_patch)**2 mse = np.mean(imdf) + eps test_psnr += 10 * math.log10(1.0 / mse) test_ite += 1 test_psnr /= (test_ite) test_ssim /= (test_ite) print('Test PSNR: {:.4f}'.format(test_psnr)) print('Test SSIM: {:.4f}'.format(test_ssim)) print('------------------------')