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