def save_picture_unlabel(pic, new_id, mask=True, generate=True): ###linux # save_path = r'E:\Radiomics\huaxi_jiang_yinjie\segmentation\out'##PVP save_path = r'E:\Radiomics\huaxi_jiang_yinjie\segmentation\AP_out'##AP if mask and not generate:###金标准 # print('groundtruth') # print(pic.shape) # print(pic.max()) pic = pic * 255 im = Image.fromarray(np.uint8(pic), mode='L') im.save(os.path.join(save_path, str(new_id)+'ground_truth.png')) elif mask and generate:##分割网络结果 # print('predict') # print(pic.shape) # print(pic.max()) pic = pic * 255 im = Image.fromarray(pic, mode='L') im.save(os.path.join(save_path, str(new_id)+'generater.png')) else:##原始图片 # print(pic.shape) # pic = pic.squeeze((0, 1)) # print(pic.shape) # print(pic.min()) # pic = pic * 255 # im = Image.fromarray(pic, mode='L') im = ToPILImage()(pic) im.save(os.path.join(save_path, str(new_id)+'img.png'))
def test(model, data_loader): print("Testing...") avg_psnr = 0 with torch.no_grad(): i = 0 for batch in data_loader: #input, target = batch[0].to (device), batch[1].to (device) input, target, input2, target2, input3, target3 = batch[ 0].requires_grad_().to(device), batch[1].requires_grad_().to( device), batch[2].requires_grad_().to( device), batch[3].requires_grad_().to( device), batch[4].requires_grad_().to( device), batch[5].requires_grad_().to(device) prediction, _, _ = model(input, input2, input3) if args.mode == "test": print("\n\n Resolve deblurred image...") prediction = prediction.clamp(0, 1) hr_image = ToPILImage()(prediction[0].data.cpu()) hr_image.save( "data/sharp_res/test/our_sharp/test_{}.png".format(i)) #psnr = compute_psnr(prediction, target) #avg_psnr += psnr i += 1
def save_result(info, pred, label, mask): # import ipdb; ipdb.set_trace() classes = pred.argmax(dim=1, keepdim=True) label = label.argmax(dim=1, keepdim=True) classes[~mask.unsqueeze(1).expand_as(classes).bool()] = 7 label[~mask.unsqueeze(1).expand_as(label).bool()] = 7 # classes = colorEncode(classes) # label = colorEncode(label) classes = classes.cpu() label = label.cpu() for i in range(classes.shape[0]): result_png = colorEncode(classes[i]) label_png = colorEncode(label[i]) result_png = ToPILImage()(result_png.float() / 255.) label_png = ToPILImage()(label_png.float() / 255.) img_name = info[i] # print(os.path.join(cfg.TEST.result, img_name.replace('.jpg', '.png'))) result_png.save( os.path.join(cfg.VAL.visualized_pred, img_name.replace('.jpg', '.png'))) label_png.save( os.path.join(cfg.VAL.visualized_label, img_name.replace('.jpg', '.png')))
def denoiseList(self): img = Image.open( 'Database/waterloo/pristine_images/00001.bmp').convert('RGB') img = CenterCrop((self.size, self.size))(img) img.save('outPic/src.bmp', 'bmp', quality=100) img = Image.open('Database/waterloo/distorted_images/%s/00001_%d.bmp' % (self.typeDir, 2)).convert('RGB') img = CenterCrop((self.size, self.size))(img) img.save('outPic/sorted.bmp', 'bmp', quality=100) for i in xrange(1, 23): input = Variable(ToTensor()(img)).view(1, -1, img.size[1], img.size[0]) input = input.cuda() if (self.load == 2): model = torch.load('%s/%sF_ALL.pth' % (self.dir, self.typeDir)) elif (self.load == 1): model = torch.load('%s/%sF.pth' % (self.dir, self.typeDir)) else: model = torch.load('%s/%s_%d.pth' % (self.dir, self.typeDir, i)) model = model.cuda() out_img = model(input) out_img = out_img.cpu() out_img = out_img.data[0] out_img.clamp_(0.0, 1.0) # out_img = self.clip(out_img) out_img = ToPILImage()(out_img) # out_img.save('outPic/%d.bmp'%i, 'bmp', quality=100) out_img.save('outPic/%d.bmp' % i, 'bmp', quality=100)
def main(cfg): video_name = cfg.video_name upscale_factor = cfg.upscale_factor use_gpu = cfg.gpu_mode test_set = TestsetLoader('data/'+ video_name, upscale_factor) test_loader = DataLoader(test_set, num_workers=1, batch_size=1, shuffle=False) net = SOFVSR(upscale_factor=upscale_factor) ckpt = torch.load('./log/SOFVSR_x' + str(upscale_factor) + '.pth') net.load_state_dict(ckpt) if use_gpu: net.cuda() for idx_iter, (LR_y_cube, SR_cb, SR_cr) in enumerate(test_loader): LR_y_cube = Variable(LR_y_cube) if use_gpu: LR_y_cube = LR_y_cube.cuda() SR_y = net(LR_y_cube) SR_y = np.array(SR_y.data) SR_y = SR_y[np.newaxis, :, :] SR_ycbcr = np.concatenate((SR_y, SR_cb, SR_cr), axis=0).transpose(1,2,0) SR_rgb = ycbcr2rgb(SR_ycbcr) * 255.0 SR_rgb = np.clip(SR_rgb, 0, 255) SR_rgb = ToPILImage()(SR_rgb.astype(np.uint8)) if not os.path.exists('results/' + video_name): os.mkdir('results/' + video_name) SR_rgb.save('results/'+video_name+'/sr_'+ str(idx_iter+2).rjust(2,'0') + '.png')
def tensor_to_image_to_byte_array(tensor): tensor = tensor.detach().cpu() image = ToPILImage(mode=None)(tensor) byte_io = io.BytesIO() image.save(byte_io, format="PNG") img_bytes = byte_io.getvalue() return np.void(img_bytes)
def defend_jpeg(input_tensor, image_mode, quality): pil_image = ToPILImage(mode=image_mode)(input_tensor) fd = BytesIO() pil_image.save(fd, format='jpeg', quality=quality) # quality level specified in paper jpeg_image = ToTensor()(PIL.Image.open(fd)) return jpeg_image
def Hess_all_BigGAN_optim(param): lr = 10 ** param[0, 0] wd = 10 ** param[0, 1] beta1 = 1 - 10 ** param[0, 2] # param[2] = log10(1 - beta1) beta2 = 1 - 10 ** param[0, 3] # param[3] = log10(1 - beta2) noise_init = torch.from_numpy(truncated_noise_sample(1, 128)).cuda() class_init = 0.06 * torch.randn(1, 128).cuda() latent_coef = (torch.cat((noise_init, class_init), dim=1) @ evc_all).detach().clone().requires_grad_(True) optim = Adam([latent_coef], lr=lr, weight_decay=wd, betas=(beta1, beta2)) # torch.optim.lr_scheduler scores_all = [] for step in range(300): optim.zero_grad() latent_code = latent_coef @ evc_all.T noise_vec = latent_code[:, :128] class_vec = latent_code[:, 128:] fitimg = BGAN.generator(latent_code, 0.7) fitimg = torch.clamp((1.0 + fitimg) / 2.0, 0, 1) dsim = alpha * ImDist(fitimg, target_tsr) + L1loss(fitimg, target_tsr) # dsim.backward() optim.step() scores_all.append(dsim.item()) if (step + 1) % 10 == 0: print("step%d loss %.2f norm: cls: %.2f nois: %.1f" % (step, dsim.item(), class_vec.norm(), noise_vec.norm())) imcmp = ToPILImage()(make_grid(torch.cat((fitimg, target_tsr)).cpu())) # imcmp.show() imcmp.save(join(savedir, "Hall%06d_%.3f.jpg" % (np.random.randint(1000000), dsim.item()))) plt.figure() plt.plot(scores_all) plt.title("lr %.E wd %.E beta1 %.3f beta2 %.3f"%(lr,wd,beta1,beta2)) plt.savefig(join(savedir, "traj_Hall%06d_%.3f.jpg" % (np.random.randint(1000000), dsim.item()))) return dsim.item() if not torch.isnan(dsim) else 1E6
def BigGAN_evol_exp(scorer, optimizer, G, steps=100, RND=None, label="", init_code=None, batchsize=20): init_code = np.concatenate((fixnoise, np.zeros((1, 128))), axis=1) # optim_cust = CholeskyCMAES(space_dimen=256, init_code=init_code, init_sigma=0.2) new_codes = init_code + np.random.randn(25, 256) * 0.06 scores_all = [] generations = [] for i in tqdm.trange(steps, desc="CMA steps"): imgs = G.visualize_batch_np(new_codes, B=batchsize) latent_code = torch.from_numpy(np.array(new_codes)).float() scores = scorer.score_tsr(imgs) print("step %d dsim %.3f (%.3f) (norm %.2f noise norm %.2f)" % ( i, scores.mean(), scores.std(), latent_code[:, 128:].norm(dim=1).mean(), latent_code[:, :128].norm(dim=1).mean())) new_codes = optimizer.step_simple(scores, new_codes, ) scores_all.extend(list(scores)) generations.extend([i] * len(scores)) scores_all = np.array(scores_all) generations = np.array(generations) mtg = ToPILImage()(make_grid(imgs, nrow=7)) mtg.save(join(savedir, "lastgen%s_%05d_score%.1f.jpg" % (methodlab, RND, scores.mean()))) np.savez(join(savedir, "scores%s_%05d.npz" % (methodlab, RND)), generations=generations, scores_all=scores_all, codes_fin=latent_code.cpu().numpy()) visualize_trajectory(scores_all, generations, title_str=methodlab).savefig( join(savedir, "traj%s_%05d_score%.1f.jpg" % (methodlab, RND, scores.mean())))
def save_image(tensor, num, dir): image = tensor.cpu().clone() # we clone the tensor to not do changes on it image = image.squeeze(0) # remove the fake batch dimension image = ToPILImage()(image) if not osp.exists(dir): os.makedirs(dir) image.save(dir + '/{}.png'.format(num))
def test(args, model): model.eval() input_image = Image.open(args.image).resize((256, 256)) input_transform = Compose([ ToTensor(), Normalize([.485, .456, .406], [.229, .224, .225]), ]) image = torch.unsqueeze(input_transform(input_image), 0) if args.cuda: image = image.cuda() label = model(image) color_transform = Colorize() label = color_transform(label[0].data.max(0)[1]) label = ToPILImage()(label) # label.show() # input_image.show() if args.resized_image: input_image.save(args.resized_image) label.save(args.label)
def Hess_sep_BigGAN_optim(param): lr1 = 10 ** param[0, 0] wd1 = 10 ** param[0, 1] lr2 = 10 ** param[0, 2] wd2 = 10 ** param[0, 3] noise_init = torch.from_numpy(truncated_noise_sample(1, 128)).cuda() class_init = 0.06 * torch.randn(1, 128).cuda() noise_coef = (noise_init @ evc_nois).detach().clone().requires_grad_(True) class_coef = (class_init @ evc_clas).detach().clone().requires_grad_(True) optim1 = Adam([noise_coef], lr=lr1, weight_decay=wd1, betas=(0.9, 0.999)) optim2 = Adam([class_coef], lr=lr2, weight_decay=wd2, betas=(0.9, 0.999)) # torch.optim.lr_scheduler for step in range(300): optim1.zero_grad() optim2.zero_grad() class_vec = class_coef @ evc_clas.T noise_vec = noise_coef @ evc_nois.T fitimg = BGAN.generator(torch.cat((noise_vec, class_vec), dim=1), 0.7) fitimg = torch.clamp((1.0 + fitimg) / 2.0, 0, 1) dsim = alpha * ImDist(fitimg, target_tsr) + L1loss(fitimg, target_tsr) # dsim.backward() optim1.step() optim2.step() if (step + 1) % 10 == 0: print("step%d loss %.2f norm: cls: %.2f nois: %.1f" % (step, dsim.item(), class_vec.norm(), noise_vec.norm())) imcmp = ToPILImage()(make_grid(torch.cat((fitimg, target_tsr)).cpu())) imcmp.show() imcmp.save(join(savedir, "Hsep%06d_%.3f.jpg" % (np.random.randint(1000000), dsim.item()))) return dsim.item() if not torch.isnan(dsim) else 1E6
def Apply_SRGAN(segmented_obj_names_ls, HOME_PATH_str): for segmented_image_name in segmented_obj_names_ls: print("This pipeline will apply SRGAN on single image.\n") parser = argparse.ArgumentParser(description='Test Single Image') parser.add_argument('--upscale_factor', default=4, type=int, help='super resolution upscale factor') parser.add_argument('--test_mode', default='CPU', type=str, choices=['GPU', 'CPU'], help='using GPU or CPU') parser.add_argument('--image_name', default=segmented_image_name, type=str, help='test low resolution image name') parser.add_argument('--model_name', default='netG_epoch_4_100.pth', type=str, help='generator model epoch name') parser.add_argument('--dataset', default='VOC2012', type=str, help='dataset name') opt = parser.parse_args() print('**Default arguments are: {0}**\n\n'.format(opt)) UPSCALE_FACTOR = opt.upscale_factor TEST_MODE = True if opt.test_mode == 'GPU' else False IMAGE_NAME = opt.image_name MODEL_NAME = opt.model_name dataset = opt.dataset SRGAN_PATH = HOME_PATH_str + 'Object-orientedDeblurringPipeline/srgan_master/' Pipeline_PATH = HOME_PATH_str + 'Object-orientedDeblurringPipeline/' model = Generator(UPSCALE_FACTOR).eval() if TEST_MODE: model.cuda() model.load_state_dict( torch.load(SRGAN_PATH + 'epochs/' + MODEL_NAME)) else: model.load_state_dict( torch.load(SRGAN_PATH + 'epochs/' + MODEL_NAME, map_location=lambda storage, loc: storage)) #Apply SRGAN image = Image.open(Pipeline_PATH + 'Images/' + IMAGE_NAME) image = Variable(ToTensor()(image), volatile=True).unsqueeze(0) if TEST_MODE: image = image.cuda() start = time.clock() out = model(image) elapsed = (time.clock() - start) print('cost' + str(elapsed) + 's') out_img = ToPILImage()(out[0].data.cpu()) out_img.save(Pipeline_PATH + 'Images/' + '_out_srf_' + str(UPSCALE_FACTOR) + '_' + IMAGE_NAME) print(IMAGE_NAME + 'DONE. \n **')
def denoiseList(self): src = Image.open( 'Database/waterloo/pristine_images/00001.bmp').convert('RGB') src = CenterCrop((self.size, self.size))(src) src.save('level_distortion/%s/%s/src.bmp' % (self.dir, self.typeDir), 'bmp', quality=100) src = Variable(ToTensor()(src)).view(1, -1, src.size[1], src.size[0]) stock_data = [[], [], [], []] for i in xrange(1, 11): print(' checking %dth...' % i) dis = Image.open('level_distortion/%s/%s/00001_%d.bmp' % (self.dir, self.typeDir, i)).convert('RGB') dis = CenterCrop((self.size, self.size))(dis) dis.save('level_distortion/%s/%s/dis_%d.bmp' % (self.dir, self.typeDir, i), 'bmp', quality=100) dis = Variable(ToTensor()(dis)).view(1, -1, dis.size[1], dis.size[0]) dis = dis.cpu() # print (input) res = self.model(dis) tmp = {} loss = self.criterion(src, dis) tmp[self.src_dis] = loss.data[0] stock_data[0].append(loss.data[0]) # self.experiment.add_scalar_value(self.src_dis, loss.data[0], i) loss = self.criterion(res, src) tmp[self.src_res] = loss.data[0] stock_data[1].append(loss.data[0]) # self.experiment.add_scalar_value(self.src_res, loss.data[0], i) loss = self.criterion(res, dis) tmp[self.dis_res] = loss.data[0] stock_data[2].append(loss.data[0]) # self.experiment.add_scalar_value(self.dis_res, loss.data[0], i) stock_data[3].append(stock_data[1][i - 1] + stock_data[2][i - 1]) self.experiment.add_scalar_dict(tmp) res = res.data[0] res.clamp_(0.0, 1.0) res = ToPILImage()(res) res.save('level_distortion/%s/%s/res_%d.bmp' % (self.dir, self.typeDir, i), 'bmp', quality=100) self.draw(stock_data) # tmp = self.dis_res_.get_scalar_names() # print(tmp) # tmp = self.dis_res_.get_scalar_values(self.dis_res) # print(tmp) # print (self.dis_res_.get_histogram_names()) # print (self.dis_res_.get_histogram_values(self.dis_res)) print('Done this work!\n\n')
def prepare_depth_estimates(self): self.model.eval() with torch.no_grad(): for inputs_val in tqdm(self.data_loader, total=len(self.data_loader)): batch_exists = True for f in inputs_val["filename"]: filename = self.build_filename(f) if not os.path.isfile(filename): batch_exists = False if batch_exists: continue for k, v in inputs_val.items(): if torch.is_tensor(v) and k == ("color", 0, 0): inputs_val[k] = v.to(self.device) mono_outputs = self.model.predict_test_disp(inputs_val) self.monodepth_loss_calculator.generate_depth_test_pred( mono_outputs) # depths = mono_outputs[("depth", 0, 0)].cpu() depths = mono_outputs[("disp", 0)].cpu() for subname, depth in zip(inputs_val["filename"], depths): filename = self.build_filename(subname) os.makedirs(os.path.dirname(filename), exist_ok=True) dmin = torch.min(depth) dmax = torch.max(depth) depth = torch.clamp(depth, dmin, dmax) depth = (depth - dmin) / (dmax - dmin) img = ToPILImage()(depth.squeeze_(0)) if not os.path.isfile(filename): img.save(filename)
def rgb2seg(rgb_names, number_of_workers): model = ERFNet(NUM_CLASSES) model = torch.nn.DataParallel(model) model = model.cuda() # Set ERFnet for segmentation print("LOAD ERFNet") def load_my_state_dict( model, state_dict ): #custom function to load model when not all dict elements own_state = model.state_dict() for name, param in state_dict.items(): if name not in own_state: continue own_state[name].copy_(param) return model model = load_my_state_dict( model, torch.load(os.path.join('trained_models/erfnet_pretrained.pth'))) model.eval() print("ERFNet and weights LOADED successfully") loader = DataLoader(CoIL(rgb_names, input_transform_cityscapes, target_transform_cityscapes), num_workers=number_of_workers, batch_size=1, shuffle=False) tmp = [] for step, (images, labels, filename, filenameGt) in enumerate(loader): # images = images.cuda() inputs = Variable(images) print("inputs ", inputs.shape) with torch.no_grad(): outputs = model(inputs) label = outputs[0].max(0)[1].byte().cpu().data print("label ", label.shape) #label_cityscapes = cityscapes_trainIds2labelIds(label.unsqueeze(0)) label_color = Colorize()(label.unsqueeze(0)) filenameSave = "./save_color/" + filename[0].split("CoILTrain/")[1] os.makedirs(os.path.dirname(filenameSave), exist_ok=True) #image_transform(label.byte()).save(filenameSave) label_save = ToPILImage()(label_color) label_save.save(filenameSave) print(step, filenameSave) tmp.append(label) tmp = torch.stack(tmp) print(tmp.shape) return tmp
def JPeg(image, quality): img = torch.clamp(image, 0, 1) img = ToPILImage()(img.cpu()) path = '/tmp/def_jpeg.jpeg' img.save(path, 'JPEG', quality=quality) img = Image.open(path) img = ToTensor()(img) return img
def _jpeg_compression(im): assert torch.is_tensor(im) im = ToPILImage()(im) savepath = BytesIO() im.save(savepath, 'JPEG', quality=75) im = Image.open(savepath) im = ToTensor()(im) return im
def for_loop(net, data_loader, train_optimizer): is_train = train_optimizer is not None net.train() if is_train else net.eval() total_loss, total_time, total_num, preds, targets = 0.0, 0.0, 0, [], [] data_bar = tqdm(data_loader, dynamic_ncols=True) with (torch.enable_grad() if is_train else torch.no_grad()): for data, target, grad, boundary, name in data_bar: data, target, grad, boundary = data.cuda(), target.cuda(), grad.cuda(), boundary.cuda() torch.cuda.synchronize() start_time = time.time() seg, edge = net(data, grad) prediction = torch.argmax(seg.detach(), dim=1) torch.cuda.synchronize() end_time = time.time() semantic_loss = semantic_criterion(seg, target) edge_loss = edge_criterion(edge, target, boundary) task_loss = task_criterion(seg, edge, target) loss = semantic_loss + 20 * edge_loss + task_loss if is_train: train_optimizer.zero_grad() loss.backward() train_optimizer.step() total_num += data.size(0) total_time += end_time - start_time total_loss += loss.item() * data.size(0) preds.append(prediction.cpu()) targets.append(target.cpu()) if not is_train: if data_loader.dataset.split == 'test': # revert train id to regular id for key in sorted(trainId2label.keys(), reverse=True): prediction[prediction == key] = trainId2label[key].id # save pred images save_root = '{}/{}_{}_{}/{}'.format(save_path, backbone_type, crop_h, crop_w, data_loader.dataset.split) if not os.path.exists(save_root): os.makedirs(save_root) for pred_tensor, pred_name in zip(prediction, name): pred_img = ToPILImage()(pred_tensor.unsqueeze(dim=0).byte().cpu()) if data_loader.dataset.split == 'val': pred_img.putpalette(get_palette()) pred_name = pred_name.replace('leftImg8bit', 'color') path = '{}/{}'.format(save_root, pred_name) pred_img.save(path) data_bar.set_description('{} Epoch: [{}/{}] Loss: {:.4f} FPS: {:.0f}' .format(data_loader.dataset.split.capitalize(), epoch, epochs, total_loss / total_num, total_num / total_time)) # compute metrics preds = torch.cat(preds, dim=0) targets = torch.cat(targets, dim=0) pa, mpa, class_iou, category_iou = compute_metrics(preds, targets) print('{} Epoch: [{}/{}] PA: {:.2f}% mPA: {:.2f}% Class_mIOU: {:.2f}% Category_mIOU: {:.2f}%' .format(data_loader.dataset.split.capitalize(), epoch, epochs, pa * 100, mpa * 100, class_iou * 100, category_iou * 100)) return total_loss / total_num, pa * 100, mpa * 100, class_iou * 100, category_iou * 100
def validate(self): self.model.eval() self.evaluator.reset() tbar = tqdm(self.val_loader, desc='\r') for i, (sample, image_name) in enumerate(tbar): if self.args.depth: image, depth, target = sample['image'], sample[ 'depth'], sample['label'] else: image, target = sample['image'], sample['label'] if self.args.cuda: image = image.cuda() if self.args.depth: depth = depth.cuda() start_time = time.time() with torch.no_grad(): if self.args.depth: output = self.model(image, depth) else: output = self.model(image) if self.args.cuda: torch.cuda.synchronize() if i != 0: fwt = time.time() - start_time self.time_train.append(fwt) print( "Forward time per img (bath size=%d): %.3f (Mean: %.3f)" % (self.args.val_batch_size, fwt / self.args.val_batch_size, sum(self.time_train) / len(self.time_train) / self.args.val_batch_size)) time.sleep(0.1) # to avoid overheating the GPU too much # pred colorize pre_colors = Colorize()(torch.max(output, 1)[1].detach().cpu().byte()) # save for i in range(pre_colors.shape[0]): label_name = os.path.join( self.args.label_save_path + self.args.weight_path.split('run/')[1], image_name[i].split('val\\')[1]) merge_label_name = os.path.join( self.args.merge_label_save_path + self.args.weight_path.split('run/')[1], image_name[i].split('val\\')[1]) os.makedirs(os.path.dirname(label_name), exist_ok=True) os.makedirs(os.path.dirname(merge_label_name), exist_ok=True) pre_color_image = ToPILImage()( pre_colors[i]) # pre_colors.dtype = float64 pre_color_image.save(label_name) if (self.args.merge): image_merge(image_name[i], pre_color_image, merge_label_name) print('save image: {}'.format(merge_label_name))
def save_image(self, epoch, doublets): images = [] for orig, rec in doublets: orig = orig.cpu().detach() rec = rec.cpu().detach() diff = 10 * abs(orig - rec) images.append(torch.cat((orig, rec, diff), dim=1)) log_image = ToPILImage()(torch.cat(images, dim=2)) log_image.save(os.path.join(self.path, f'{epoch}.jpg'))
def img2label(img, label, count): count += 1 img = np.array(img) label = np.array(label) for i in range(label.shape[0]): for j in range(label.shape[1]): if label[i, j] == 0: img[i, j, :] = 0 image = ToPILImage()(img) image.save('./results/imglabel_' + str(count) + '.jpg')
def generate_image(self): noise = self.get_noise() image_tensor = self.model(noise) image_tensor = (image_tensor.cpu() + 1) / 2 image = ToPILImage()(image_tensor[0]) image = image.resize((128, 128), resample=0) with io.BytesIO() as f: image.save(f, format='JPEG') img_byte_arr = f.getvalue() return img_byte_arr
def save_result(info, pred): classes = pred.argmax(dim=1, keepdim=True).cpu() for i in range(classes.shape[0]): result_png = ToPILImage()(classes[i].float() / 255.) img_name = info[i] # print(os.path.join(cfg.TEST.result, img_name.replace('.jpg', '.png'))) result_png.save( os.path.join(cfg.TEST.result, img_name.replace('.jpg', '.png')))
def api_model_layer_output_image(input_id, vis_id, layer_id, time, output_id): output_id = int(output_id) try: output = self.outputs[output_id] output = output.detach().cpu() pil_img = ToPILImage()(output) img_io = io.BytesIO() pil_img.save(img_io, 'JPEG', quality=70) img_io.seek(0) return send_file(img_io, mimetype='image/jpeg') except KeyError: return Response(status=500, response='Index not found.')
def jpeg_sub(imgs): """Input image of shape (n, 3, 224, 224)""" n, c, w, h = imgs.shape transformed = imgs.clone().cpu() for i in range(n): im = ToPILImage()(transformed[i]) savepath = BytesIO() im.save(savepath, 'JPEG', quality=quality) im = Image.open(savepath) im = ToTensor()(im) transformed[i] = im return transformed.cuda()
def generateSR(image_path, save_path, model): r""" :param: image_path: path of used image save_path: path of saved image upscale_factor: which model do you want to use. format :int """ image = Image.open(image_path) image = Variable(ToTensor()(image), volatile=True).unsqueeze(0).cuda() # image = Variable(ToTensor()(image), volatile=True).unsqueeze(0) out = model(image) out_img = ToPILImage()(out[0].data.cpu()) out_img.save(save_path)
def jpeg_sub(imgs): """Input image of shape (n, 3, 224, 224)""" n, c, w, h = imgs.shape transformed = imgs.copy() for i in range(n): im = torch.Tensor(imgs[i]) im = ToPILImage()(im) savepath = BytesIO() im.save(savepath, 'JPEG', quality=quality) im = Image.open(savepath) im = ToTensor()(im).numpy() transformed[i] = im return transformed
def evaluate_model(config, model_folder, image_folder, output_path, save_json=True): """ Evaluates a model by comparing input images with output images :param config: the model configuration :param model_folder: folder of the saved model :param image_folder: path images used to evaluate the model :param output_path: path where anonymized images should be stored :return: list of distances """ image_folder = Path(image_folder) output_path = Path(output_path) model = config.model(**config.model_params) model.load_model(Path(model_folder)) extractor = FaceExtractor(margin=0.05, mask_factor=10) print("The authors of the package recommend 0.6 as max distance for the same person.") scores = {} for image_file in image_folder.iterdir(): if image_file.is_dir(): continue print('#' * 10) print('Processing image:', image_file.name) input_image = Image.open(image_file) extracted_face, extracted_info = extractor(input_image) if extracted_face is None: print('Face could not be extracted') continue face_out = model.anonymize(extracted_face, extracted_info).squeeze(0) face_out = ToPILImage()(face_out.cpu().detach()) face_out = face_out.resize(extracted_face.size, resample=BICUBIC) try: face_out.save(output_path / ('anonymized_' + image_file.name.__str__())) score, sim, emo = Evaluator.evaluate_image_pair(extracted_face, face_out) scores[image_file.name] = {'score': score, 'sim': sim, 'emo': emo} except Exception as ex: print(ex) continue print('Current image score:', scores[image_file.name]) if save_json: with open(output_path / 'scores.json', 'w') as f: json.dump(scores, f) return scores
def main(args): # ========= Setup device and seed ============ np.random.seed(42) torch.manual_seed(42) if args.cuda: torch.cuda.manual_seed_all(42) device = 'cuda' if args.cuda else 'cpu' logger = Logger(pjoin(args.save_dir, args.model, 'test.log')) logger.write(f'\nTesting configs: {args}') # ================= Load processed data =================== val_dataset = VOC12(args.data_dir, img_size=args.img_size, split='test') val_loader = DataLoader(val_dataset, num_workers=8, batch_size=1) n_classes = val_dataset.n_classes # ================= Init model ==================== model = models.get_model(name=args.model, n_classes=n_classes) model = model.to(device) state = convert_state_dict(torch.load(args.model_path)["model_state"]) model.load_state_dict(state) model.eval() # ====================== Only one image ========================== if args.eval: with torch.no_grad(): img = Image.open(args.img_path) origin = img.size if args.img_size: img = img.resize( (val_dataset.img_size[0], val_dataset.img_size[1])) img = val_dataset.input_transform(img).unsqueeze(0).to(device) out = model(img) pred = np.squeeze(out.data.max(1)[1].cpu().numpy(), axis=0) decoded = val_dataset.decode_segmap(pred) img_out = ToPILImage()(decoded).resize(origin) img_out.save( pjoin(args.save_dir, args.model, f'eval_{args.img_size}.png')) return # ====================== Testing Many images ============================== with torch.no_grad(): for idx, (name, img) in enumerate(val_loader): img = img.to(device) out = model(img) pred = out.data.max(1)[1].squeeze_(1).squeeze_(0).cpu().numpy() decoded = val_dataset.decode_segmap(pred) ToPILImage()(decoded).save( pjoin(args.save_dir, args.model, f'{name[0]}_{args.img_size}.png'))