def one2one_identity(self, im1, im2): normalized_im1 = T.normalize(im1, mean=self.mean, std=self.std) scale_im1, scale_ratio1 = T.scale(normalized_im1, short_size=self.base_size) input_im1 = T.center_crop(scale_im1, crop_size=self.crop_size) normalized_im2 = T.normalize(im2, mean=self.mean, std=self.std) scale_im2, scale_ratio2 = T.scale(normalized_im2, short_size=self.base_size) input_im2 = T.center_crop(scale_im2, crop_size=self.crop_size) batch = np.asarray([input_im1, input_im2], dtype=np.float32) scores = self.inference(batch, output_layer=self.prob_layer) return M.cosine_similarity(scores[0], scores[1])
def __call__(self, img, idx): target_ar = self.idx2ar[idx] if target_ar < 1: w = int(self.target_size / target_ar) size = (w // 8 * 8, self.target_size) else: h = int(self.target_size * target_ar) size = (self.target_size, h // 8 * 8) return transforms.center_crop(img, size)
def cls_batch(self, batch_ims): input_ims = [] for im in batch_ims: im = im.astype(np.float32, copy=True) normalized_im = T.normalize(im, mean=self.mean, std=self.std) scale_im, scale_ratio = T.scale(normalized_im, short_size=self.base_size) input_ims.append(T.center_crop(scale_im, crop_size=self.crop_size)) scores = self.inference(np.asarray(input_ims, dtype=np.float32), output_layer=self.prob_layer) return scores
def cls_im(self, im): im = im.astype(np.float32, copy=True) normalized_im = T.normalize(im, mean=self.mean, std=self.std) scale_im, scale_ratio = T.scale(normalized_im, short_size=self.base_size) crop_ims = [] if self.crop_type == 'center' or self.crop_type == 'single': # for single crop crop_ims.append(T.center_crop(scale_im, crop_size=self.crop_size)) elif self.crop_type == 'mirror' or self.crop_type == 'multi': # for 10 crops crop_ims.extend(T.mirror_crop(scale_im, crop_size=self.crop_size)) else: crop_ims.append(scale_im) scores = self.inference(np.asarray(crop_ims, dtype=np.float32), output_layer=self.prob_layer) return np.sum(scores, axis=0)
def forward(self, k, m): x = ifft2(k) x = x.permute(0, 3, 1, 2) m = m[..., None] m = m.expand_as(k).float() m = m.permute(0, 3, 1, 2) k = k.permute(0, 3, 1, 2) for i in range(self.nc): x_cnn = self.conv_blocks[i](x) x = x + x_cnn x = self.dcs[i].perform(x, k, m) x = x.permute(0, 2, 3, 1) # equivalent of taking the module of the image x = complex_abs(x) x = center_crop(x, (320, 320)) return x
def __call__(self, target, attrs, fname, slice): """ Args: target (numpy.array): Target image attrs (dict): Acquisition related information stored in the HDF5 object. fname (str): File name slice (int): Serial number of the slice. Returns: (tuple): tuple containing: image (torch.Tensor): Zero-filled input image. target (torch.Tensor): Target image converted to a torch Tensor. mean (float): Mean value used for normalization. std (float): Standard deviation value used for normalization. norm (float): L2 norm of the entire volume. Additionally returns the used acceleration and center fraction for evaluation purposes. Changed from original: now starting from GT RSS, which makes more sense if doing singlecoil. """ # Obtain full kspace from ground truth target = transforms.to_tensor(target) target = transforms.center_crop(target, (self.resolution, self.resolution)) kspace = transforms.rfft2(target) seed = None if not self.use_seed else tuple(map(ord, fname)) masked_kspace, mask = transforms.apply_mask(kspace, self.mask_func, seed) # Inverse Fourier Transform to get zero filled solution zf = transforms.ifft2(masked_kspace) # Take complex abs to get a real image zf = transforms.complex_abs(zf) # Normalize input zf, zf_mean, zf_std = transforms.normalize_instance(zf, eps=1e-11) zf = zf.clamp(-6, 6) # # Normalize target # target = transforms.normalize(target, mean, std, eps=1e-11) target, gt_mean, gt_std = transforms.normalize_instance(target, eps=1e-11) target = target.clamp(-6, 6) # Need to return kspace and mask information when doing active learning, since we are # acquiring frequencies and updating the mask for a data point during an AL loop. return kspace, masked_kspace, mask, zf, target, gt_mean, gt_std, fname, slice
def eval_batch(): eval_len = len(SET_DICT) accuracy = np.zeros(len(args.top_k)) start_time = datetime.datetime.now() for i in xrange(eval_len - args.skip_num): im = cv2.imread(SET_DICT[i + args.skip_num]['path']) im = T.bgr2rgb(im) scale_im = T.pil_resize(Image.fromarray(im), args.base_size) normalized_im = T.normalize(np.asarray(scale_im) / 255.0, mean=PIXEL_MEANS, std=PIXEL_STDS) crop_ims = [] if args.crop_type == 'center': # for single crop crop_ims.append(T.center_crop(normalized_im, crop_size=args.crop_size)) elif args.crop_type == 'multi': # for 10 crops crop_ims.extend(T.mirror_crop(normalized_im, crop_size=args.crop_size)) else: crop_ims.append(normalized_im) score_vec = np.zeros(args.class_num, dtype=np.float32) iter_num = int(len(crop_ims) / args.batch_size) timer_pt1 = datetime.datetime.now() for j in xrange(iter_num): input_data = np.asarray(crop_ims, dtype=np.float32)[j * args.batch_size:(j + 1) * args.batch_size] input_data = input_data.transpose(0, 3, 1, 2) input_data = torch.autograd.Variable(torch.from_numpy(input_data).cuda(), volatile=True) outputs = MODEL(input_data) scores = outputs.data.cpu().numpy() score_vec += np.sum(scores, axis=0) score_index = (-score_vec / len(crop_ims)).argsort() - 1 timer_pt2 = datetime.datetime.now() SET_DICT[i + args.skip_num]['evaluated'] = True SET_DICT[i + args.skip_num]['score_vec'] = score_vec / len(crop_ims) print 'Testing image: {}/{} {} {}/{} {}s' \ .format(str(i + 1), str(eval_len - args.skip_num), str(SET_DICT[i + args.skip_num]['path'].split('/')[-1]), str(score_index[0]), str(SET_DICT[i + args.skip_num]['gt']), str((timer_pt2 - timer_pt1).microseconds / 1e6 + (timer_pt2 - timer_pt1).seconds)), for j in xrange(len(args.top_k)): if SET_DICT[i + args.skip_num]['gt'] in score_index[:args.top_k[j]]: accuracy[j] += 1 tmp_acc = float(accuracy[j]) / float(i + 1) if args.top_k[j] == 1: print '\ttop_' + str(args.top_k[j]) + ':' + str(tmp_acc), else: print 'top_' + str(args.top_k[j]) + ':' + str(tmp_acc) end_time = datetime.datetime.now() w = open(LOG_PTH, 'w') s1 = 'Evaluation process ends at: {}. \nTime cost is: {}. '.format(str(end_time), str(end_time - start_time)) s2 = '\nThe model is: {}. \nThe val file is: {}. \n{} images has been tested, crop_type is: {}, base_size is: {}, ' \ 'crop_size is: {}.'.format(args.model_weights, args.val_file, str(eval_len - args.skip_num), args.crop_type, str(args.base_size), str(args.crop_size)) s3 = '\nThe PIXEL_MEANS is: ({}, {}, {}), PIXEL_STDS is : ({}, {}, {}).' \ .format(str(PIXEL_MEANS[0]), str(PIXEL_MEANS[1]), str(PIXEL_MEANS[2]), str(PIXEL_STDS[0]), str(PIXEL_STDS[1]), str(PIXEL_STDS[2])) s4 = '' for i in xrange(len(args.top_k)): _acc = float(accuracy[i]) / float(eval_len - args.skip_num) s4 += '\nAccuracy of top_{} is: {}; correct num is {}.'.format(str(args.top_k[i]), str(_acc), str(int(accuracy[i]))) print s1, s2, s3, s4 w.write(s1 + s2 + s3 + s4) w.close() if args.save_score_vec: w = open(LOG_PTH.replace('.txt', 'scorevec.txt'), 'w') for i in xrange(eval_len - args.skip_num): w.write(SET_DICT[i + args.skip_num]['score_vec']) w.close() print('DONE!')
def eval_batch(): # shuffle_conv1_channel() eval_len = len(SET_DICT) # eval_len = 1000 accuracy = np.zeros(len(args.top_k)) start_time = datetime.datetime.now() for i in xrange(eval_len - args.skip_num): im = cv2.imread(SET_DICT[i + args.skip_num]['path']) if (PIXEL_MEANS == np.array([103.52, 116.28, 123.675])).all() and \ (PIXEL_STDS == np.array([57.375, 57.12, 58.395])).all(): scale_im = T.pil_scale(Image.fromarray(im), args.base_size) scale_im = np.asarray(scale_im) else: scale_im, _ = T.scale(im, short_size=args.base_size) input_im = T.normalize(scale_im, mean=PIXEL_MEANS, std=PIXEL_STDS) crop_ims = [] if args.crop_type == 'center': # for single crop crop_ims.append(T.center_crop(input_im, crop_size=args.crop_size)) elif args.crop_type == 'multi': # for 10 crops crop_ims.extend(T.mirror_crop(input_im, crop_size=args.crop_size)) else: crop_ims.append(input_im) score_vec = np.zeros(args.class_num, dtype=np.float32) iter_num = int(len(crop_ims) / args.batch_size) timer_pt1 = datetime.datetime.now() for j in xrange(iter_num): scores = CLS.inference( np.asarray(crop_ims, dtype=np.float32)[j * args.batch_size:(j + 1) * args.batch_size], output_layer=args.prob_layer ) score_vec += np.sum(scores, axis=0) score_index = (-score_vec / len(crop_ims)).argsort() timer_pt2 = datetime.datetime.now() SET_DICT[i + args.skip_num]['evaluated'] = True SET_DICT[i + args.skip_num]['score_vec'] = score_vec / len(crop_ims) print 'Testing image: {}/{} {} {}/{} {}s' \ .format(str(i + 1), str(eval_len - args.skip_num), str(SET_DICT[i + args.skip_num]['path'].split('/')[-1]), str(score_index[0]), str(SET_DICT[i + args.skip_num]['gt']), str((timer_pt2 - timer_pt1).microseconds / 1e6 + (timer_pt2 - timer_pt1).seconds)), for j in xrange(len(args.top_k)): if SET_DICT[i + args.skip_num]['gt'] in score_index[:args.top_k[j]]: accuracy[j] += 1 tmp_acc = float(accuracy[j]) / float(i + 1) if args.top_k[j] == 1: print '\ttop_' + str(args.top_k[j]) + ':' + str(tmp_acc), else: print 'top_' + str(args.top_k[j]) + ':' + str(tmp_acc) end_time = datetime.datetime.now() w = open(LOG_PTH, 'w') s1 = 'Evaluation process ends at: {}. \nTime cost is: {}. '.format(str(end_time), str(end_time - start_time)) s2 = '\nThe model is: {}. \nThe val file is: {}. \n{} images has been tested, crop_type is: {}, base_size is: {}, ' \ 'crop_size is: {}.'.format(args.model_weights, args.val_file, str(eval_len - args.skip_num), args.crop_type, str(args.base_size), str(args.crop_size)) s3 = '\nThe PIXEL_MEANS is: ({}, {}, {}), PIXEL_STDS is : ({}, {}, {}).' \ .format(str(PIXEL_MEANS[0]), str(PIXEL_MEANS[1]), str(PIXEL_MEANS[2]), str(PIXEL_STDS[0]), str(PIXEL_STDS[1]), str(PIXEL_STDS[2])) s4 = '' for i in xrange(len(args.top_k)): _acc = float(accuracy[i]) / float(eval_len - args.skip_num) s4 += '\nAccuracy of top_{} is: {}; correct num is {}.'.format(str(args.top_k[i]), str(_acc), str(int(accuracy[i]))) print s1, s2, s3, s4 w.write(s1 + s2 + s3 + s4) w.close() if args.save_score_vec: w = open(LOG_PTH.replace('.txt', 'scorevec.txt'), 'w') for i in xrange(eval_len - args.skip_num): w.write(SET_DICT[i + args.skip_num]['score_vec']) w.close() print('DONE!')
def __call__(self, img): """Apply manipulations to image. Args: img (PIL Image): Image to be manipulated. Returns: PIL Image: Anchor Image (128x128) PIL Image: Manipulated Image (128x128) """ cfg = self.config anchor = transforms.center_crop(img, 128).copy() # flipping if np.random.rand() < cfg["p_horizontal_flip"]: img = transforms.hflip(img) if np.random.rand() < cfg["p_vertical_flip"]: img = transforms.vflip(img) # perspective if "perspective_range" in cfg: width, height = img.size startpoints = np.array([(0, 0), (0, height), (width, height), (width, 0)]) rho = np.random.randint(*cfg["perspective_range"], startpoints.shape) endpoints = startpoints + rho img = transforms.perspective(img, startpoints, endpoints) # affine if "affine" in cfg: scale = np.random.uniform(*cfg["affine"]["scale_range"]) rotation = np.random.uniform(*cfg["affine"]["rotation_range"]) translate = list(np.random.uniform(*cfg["affine"]["translation_range"], 2)) img = transforms.affine(img, rotation, translate, scale, shear=0) # gamma if "gamma_range" in cfg: img = transforms.adjust_gamma(img, np.random.uniform(*cfg["gamma_range"])) # hue if "hue" in cfg: img = transforms.adjust_hue(img, np.random.uniform(*cfg["hue_range"])) # brightness if "brightness_range" in cfg: img = transforms.adjust_brightness( img, np.random.uniform(*cfg["brightness_range"]) ) # contrast if "contrast_range" in cfg: img = transforms.adjust_contrast( img, np.random.uniform(*cfg["contrast_range"]) ) if "p_global_hist" in cfg and np.random.rand() < cfg["p_global_hist"]: img = (exposure.equalize_hist(np.array(img)) * 255).astype(np.uint8) img = Image.fromarray(img) elif "p_local_hist" in cfg and np.random.rand() < cfg["p_local_hist"]: selem = disk(10) img = (rank.equalize(np.array(img), selem=selem) * 255).astype(np.uint8) img = Image.fromarray(img) if np.random.rand() < cfg["p_invert"]: img = ImageOps.invert(img) if "p_blur" in cfg and np.random.rand() < cfg["p_blur"]: img = img.filter(ImageFilter.GaussianBlur(radius=2)) if "p_jpeg" in cfg and np.random.rand() < cfg["p_jpeg"]: buffer = io.BytesIO() img.save(buffer, "JPEG", quality=50) img = Image.open(buffer) if "p_noise" in cfg and np.random.rand() < cfg["p_noise"]: img = np.array(img) img = img + np.random.normal(loc=0, scale=16, size=img.shape) img = np.clip(img, 0, 255).astype(np.uint8) img = Image.fromarray(img) # grayscale if "grayscale" in cfg: img = transforms.to_grayscale(img, num_output_channels=cfg["grayscale"]) anchor = transforms.to_grayscale( anchor, num_output_channels=cfg["grayscale"] ) img = transforms.center_crop(img, 128) return anchor, img