def get_cancer_prediction(image_bytes): with torch.no_grad(): img = get_image(image_bytes) imwidth, imheight = img.size plist = crop(img, 256, 256, 200) outlist = [] for rlist in plist: out = [] for i in range(len(rlist)): rlist[i] = ToTensor()(rlist[i]) rlist[i] = TF.normalize(rlist[i], normMean, normStd) if is_cuda: rlist[i] = rlist[i].unsqueeze(0).cuda() image = rlist[i] output = net(image) output = ToPILImage()(output.cpu().squeeze(0)) out.append(output) outlist.append(out) outimg = attach(outlist, 200, imwidth, imheight) outimg = np.array(outimg) outimg = cv2.resize(outimg, (imwidth, imheight)) low_conf_pixels = outimg[outimg > 65] low_conf_pixels = low_conf_pixels[low_conf_pixels < 190] low_conf_pixels_count = len(low_conf_pixels) confidence = 1 - (low_conf_pixels_count / imwidth * imheight) _, outimg = cv2.threshold(outimg, 127, 255, cv2.THRESH_BINARY) flag = 1 # Criterion for presence of lesion if len(outimg == 255) < 100: flag == 0 superimposed = superimpose(img, outimg) superimposed = Image.fromarray(superimposed.astype('uint8')) return superimposed, confidence, flag
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 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 __getitem__(self, index): hr_image = Image.open(self.image_filenames[index]) w, h = hr_image.size crop_size = calculate_valid_crop_size_2(min(w, h), 32) if crop_size > self.crop_size: hr_image_ = CenterCrop(crop_size)(hr_image) hr_image = ToTensor()(hr_image_) hr_image_gray = gray(hr_image) hr_image = Variable(hr_image_gray) hr_image = hr_image.unsqueeze(0) # if torch.cuda.is_available(): # hr_image = hr_image.cuda() output = self.model(hr_image) output = output.squeeze(0) output = output.data output = output.cpu() output = ToPILImage(output) x = random.randint(0, crop_size - self.crop_size) y = random.randint(0, crop_size - self.crop_size) Crop_Image = Crop(x, y, self.crop_size) hr_image = Crop_Image(hr_image_gray) lr_image = Crop_Image(output) return ToTensor()(lr_image).unsqueeze(0).unsqueeze(1), ToTensor()(hr_image).unsqueeze(0).unsqueeze(1) else: hr_image = Image.open(self.image_filenames[1]) w, h = hr_image.size crop_size = calculate_valid_crop_size_2(min(w, h), 32) hr_image_ = CenterCrop(crop_size)(hr_image) hr_image = ToTensor()(hr_image_) hr_image = Variable(hr_image) # if torch.cuda.is_available(): # hr_image = hr_image.cuda() output = self.model(hr_image) output = output.data output = output.cpu() output = ToPILImage(output) x = random.randint(0, crop_size - self.crop_size) y = random.randint(0, crop_size - self.crop_size) Crop_Image = Crop(x, y, self.crop_size) hr_image = Crop_Image(hr_image_) lr_image = Crop_Image(output) return ToTensor()(lr_image), ToTensor()(hr_image)
def augment_images(images, targets, preds): augmented_images = [] for img, target, pred in zip(images, targets, preds): img = ToPILImage()(img.cpu()) img1 = ImageDraw.Draw(img) for bb in target['boxes']: bb = bb.cpu().numpy() img1.rectangle([bb[0], bb[1], bb[2], bb[3]], fill=None, outline="green", width=5) for bb in pred['boxes']: img1.rectangle([bb[0], bb[1], bb[2], bb[3]], fill=None, outline="blue", width=5) #img1.rectangle([10, 10, 40, 40], fill =None, outline ="green", width=5) augmented_images.append(ToTensor()(img.resize((256, 256)))) return augmented_images
def __call__(self, image): """ Merges an anonymized face on the scene :param image: PIL image :return: PIL image """ constructed_image = None # Extract face extracted_face, extracted_information = self.extractor(image) if extracted_face is not None: face_out = self.model.anonymize(extracted_face, extracted_information).squeeze(0) # get it back to the cpu and get the data face_out = ToPILImage()(face_out.cpu().detach()) # scale to original resolution face_out = face_out.resize(extracted_face.size, resample=BICUBIC) # Constructed scene with new face constructed_image = self.reconstructor(face_out, extracted_information) return constructed_image
def validate(args, epoch, net, validLoader, optimizer, criterion): net.eval() tqdm.write("VALIDATING...") valid_loss = 0 incorrect = 0 logs['epoch_tags']['image'] = [] pbar = tqdm(validLoader) with torch.no_grad(): for data, targets in pbar: for img_, target_ in zip(data, targets): img = ToPILImage()(img_) imwidth, imheight = img.size plist = crop(img, imwidth // args.patch_ratio, imheight // args.patch_ratio) outlist = [] for rlist in plist: out = [] for i in range(len(rlist)): rlist[i] = ToTensor()(rlist[i]) if args.cuda: rlist[i] = rlist[i].unsqueeze(0).cuda() image = rlist[i] output = net(image) output = ToPILImage()(output.cpu().squeeze(0)) out.append(output) print(count) outlist.append(out) newimg = attach(outlist, imwidth // args.patch_ratio, imheight // args.patch_ratio, imwidth, imheight) logs['epoch_tags']['image'].append( (unorm(img_.cpu()), unorm(target_.cpu()), unorm(ToTensor()(newimg)))) valid_loss += criterion(target_, ToTensor()(newimg)) valid_loss /= len( validLoader) # loss function already averages over batch size logs['epoch_tags']['score'] = (1.0 - round(valid_loss.item(), 3)) for callback in callbacks: callback.on_val_end(logs)
def create_image(net, loader, name, upscaling=2, multiscale=False): patch_size = 30 patches = np.array( [[85, 90, 85 + patch_size, 90 + patch_size], [160, 140, 160 + patch_size, 140 + patch_size], [350, 80, 350 + patch_size, 80 + patch_size]]) fig = plt.figure(figsize=(15, 18), dpi=100) gs = fig.add_gridspec(4, 3, wspace=0.01, hspace=0.3, left=0.05, top=0.95, bottom=0.02, right=0.95) highres, lowres = loader[0] lowres = lowres.to(torch.device("cuda:0")) lowres = lowres.view([1] + list(lowres.size())) net.eval() with torch.no_grad(): if (multiscale): superres = net(lowres, upscaling) else: superres = net(lowres) lowres = ToImage()(lowres.cpu().view(lowres.size()[1:])) superres = ToImage()(superres.cpu().view(superres.size()[1:])) highres = ToImage()(highres.cpu().view(highres.size()[1:])) lowres_draw = lowres.copy() draw = ImageDraw.Draw(lowres_draw) draw.rectangle(list(patches[0]), outline='white') draw.rectangle(list(patches[1]), outline='white') draw.rectangle(list(patches[2]), outline='white') lowres = lowres.resize((lowres.size[0] * upscaling, lowres.size[1] * upscaling), Image.BICUBIC) psnr_low, psnr_super, ssim_low, ssim_super = compute_metrics( net, DataLoader(loader), upscaling, multiscale) lowres_title = "Low-resolution image" +\ "\nAverage PSNR over the dataset: {:.2f}\n".format(psnr_low) +\ "Average SSIM over the dataset: {:.4f}".format(ssim_low) superres_title = "Reconstructed image\n" +\ "Average PSNR over the dataset: {:.2f}\n".format(psnr_super) +\ "Average SSIM over the dataset: {:.4f}".format(ssim_super) fig.add_subplot(gs[0, 0], xticks=[], yticks=[], ylabel=f"Image", title=lowres_title) plt.imshow(np.array(lowres_draw)) fig.add_subplot(gs[0, 1], xticks=[], yticks=[], title=superres_title) plt.imshow(np.array(superres)) fig.add_subplot(gs[0, 2], xticks=[], yticks=[], title="High-resolution image") plt.imshow(np.array(highres)) ylabels = ["Patch 1", "Patch 2", "Patch 3"] for i in range(3): print(lowres.size, highres.size, superres.size) lowres_patch = lowres.crop(patches[i] * upscaling) highres_patch = highres.crop(patches[i] * upscaling) superres_patch = superres.crop(patches[i] * upscaling) fig.add_subplot(gs[1 + i, 0], xticks=[], yticks=[], ylabel=ylabels[i]) plt.imshow(np.array(lowres_patch)) fig.add_subplot(gs[1 + i, 1], xticks=[], yticks=[]) plt.imshow(np.array(superres_patch)) fig.add_subplot(gs[1 + i, 2], xticks=[], yticks=[]) plt.imshow(np.array(highres_patch)) plt.savefig(name)
def resize(m, target_shape): m = ToPILImage()(m.cpu().to(torch.float32)) m = Resize(target_shape)(m) m = ToTensor()(m) return m.cuda()
def resize(x, target_shape): x = ToPILImage()(x.cpu().to(torch.float32)) x = Resize(target_shape)(x) x = ToTensor()(x) return x.cuda()
print 'cover: ', valing_results['psnr'], valing_results['ssim'] # print meas, cover_o, meas_o g_loss = mse_loss(cover_o, cover) meas_real = Variable(torch.zeros(meas.shape).cuda()+meas.data) meas_loss = mse_loss(meas_o, meas_real) running_results['g_loss'] += g_loss.data[0] * batch_size running_results['meas_loss'] += meas_loss.data[0] * batch_size train_bar.set_description(desc='[%d/%d] Loss_G: %.5f Loss_Meas: %.5f' % ( epoch, NUM_EPOCHS, running_results['g_loss'] / running_results['batch_sizes'], running_results['meas_loss'] / running_results['batch_sizes'])) cover_o_ = ToPILImage()(cover_o.cpu()[0,:,:,:].data) cover_o_.save(save_dir+'/'+str(img_id)+'_container'+'.png') cover_o = ToPILImage()(torch.abs(cover_o.cpu()[0,:,:,:].data - data[0,:,:,:])*10) cover_o.save(save_dir+'/'+str(img_id)+'_diff_cover_container'+'.png') # elif stage == 2: secret_o = netG(cover, secret, 2) batch_mse = ((secret_o - secret) ** 2).data.mean() valing_results2['mse'] += batch_mse * batch_size batch_ssim = pytorch_ssim.ssim(secret_o, secret).data[0] valing_results2['ssims'] += batch_ssim * batch_size valing_results2['psnr'] = 10 * log10(1 / (valing_results2['mse'] / valing_results2['batch_sizes'])) valing_results2['ssim'] = valing_results2['ssims'] / valing_results2['batch_sizes'] print 'secret: ', valing_results2['psnr'], valing_results2['ssim'] g_loss = mse_loss(secret_o, secret)