def __init__(self, opt):
super(CreateMixedDataset, self).__init__()
self.opt = opt
img_source_paths, self.img_source_size = make_dataset(
opt, opt.img_source_dir) # img_source_dir = '^/trainA'
lab_source_paths, self.lab_source_size = make_dataset(
opt, opt.lab_source_dir) # img_source_dir = '^/trainA_depth'
img_target_paths, self.img_target_size = make_dataset(
opt, opt.img_target_dir) # img_source_dir = '^/trainB'
lab_target_paths, self.lab_target_size = make_dataset(
opt, opt.lab_target_dir) # img_source_dir = '^/trainB_depth'
for i in img_target_paths:
img_source_paths.append(i)
for t in lab_target_paths:
lab_source_paths.append(t)
self.img_source_paths = img_source_paths
self.lab_source_paths = lab_source_paths
self.transform_augment = self._make_transform(opt, True)
self.transform_no_augment = self._make_transform(opt,
False) # for label
self.transform_no_augment_depth = self._make_transform(
opt, False, True) # for label
def random_image(self):
"""Random load the test image"""
# read random mask
if self.opt.mask_file != "none":
mask_paths, mask_size = make_dataset(self.opt.mask_file)
item = random.randint(0, mask_size - 1)
self.mname = mask_paths[item]
image_paths, image_size = make_dataset(self.opt.img_file)
item = random.randint(0, image_size - 1)
self.fname = image_paths[item]
self.showImage(self.fname)
def __init__(self, opt):
super(CreateUnlabeledDataset, self).__init__()
self.opt = opt
self.img_target_paths, self.img_target_size = make_dataset(
opt, opt.img_target_dir) # img_source_dir = '^/trainB'
self.lab_target_paths, self.lab_target_size = make_dataset(
opt, opt.lab_target_dir) # img_source_dir = '^/trainB_depth'
self.transform_augment = self._make_transform(opt, True)
self.transform_no_augment = self._make_transform(opt,
False) # for label
self.transform_no_augment_depth = self._make_transform(
opt, False, True) # for label
def initialize(self,opt):
self.opt = opt
self.root = opt.dataroot
self.dir_A = os.path.join(opt.dataroot,opt.phase + 'A')
self.dir_B = os.path.join(opt.dataroot,opt.phase + 'B')
self.A_paths = make_dataset(self.dir_A)
self.B_paths = make_dataset(self.dir_B)
self.A_paths = sorted(self.A_paths)
self.B_paths = sorted(self.B_paths)
self.A_size = len(self.A_paths)
self.B_size = len(self.B_paths)
self.transform_Image = get_transform(opt,True)
self.transform_depth = get_transform(opt,False)
def load_indoor_depth(file_path):
depths = []
dataset = make_dataset(file_path)
for data in dataset:
depth = Image.open(data)
depth = depth.resize((425, 425), Image.BICUBIC)
depth = np.array(depth)
depth = depth.astype(np.float32) / 255 * 8.0
depths.append(depth)
return depths
def __init__(self, opt):
super(CreateFullDataset, self).__init__()
self.opt = opt
self.img_source_paths, self.img_source_size = make_dataset(
opt, opt.img_source_dir) # img_source_dir = '^/trainA'
self.img_target_paths, self.img_target_size = make_dataset(
opt, opt.img_target_dir) # img_source_dir = '^/trainB'
self.lab_source_paths, self.lab_source_size = make_dataset(
opt, opt.lab_source_dir) # img_source_dir = '^/trainA_depth'
# for visual results, not for training
self.lab_target_paths, self.lab_target_size = make_dataset(
opt, opt.lab_target_dir) # img_source_dir = '^/trainB_depth'
if self.opt.isTrain:
self.lab_source_paths, self.lab_source_size = make_dataset(
opt, opt.lab_source_dir) # img_source_dir = '^/trainA_depth'
# for visual results, not for training
self.lab_target_paths, self.lab_target_size = make_dataset(
opt, opt.lab_target_dir) # img_source_dir = '^/trainB_depth'
self.transform_augment = self._make_transform(opt, True)
self.transform_no_augment = self._make_transform(opt,
False) # for label
self.transform_no_augment_depth = self._make_transform(
opt, False, True) # for label
def load_depth(file_path, split, max_depth):
depths = []
dataset, _ = make_dataset(file_path)
for data in dataset:
depth = Image.open(data)
if split == 'eigen':
depth = np.array(depth) #[:,:,0]
depth = depth.astype(np.float32) / 255 * max_depth
elif split == 'indoor':
depth = np.array(depth) #[:,:,0]
depth = depth.astype(np.float32) / 255 * max_depth
# depth = (depth - depth.mean()) / depth.std()
depths.append(depth)
return depths
def initialize(self, opt):
self.opt = opt
self.opt.sample_Ps = range(*opt.sample_Ps)
self.root = opt.dataroot
self.color_dir = os.path.join(opt.dataroot, 'color')
self.color_paths = make_dataset(self.color_dir)
self.color_paths = sorted(self.color_paths)
folder = ['line']
self.category = os.listdir(os.path.join(opt.dataroot, 'line'))
idx1 = 0
self.line_dir = dict()
self.line_paths = dict()
for key in self.category:
dir = os.path.join(folder[idx1], key)
self.line_dir[key] = os.path.join(opt.dataroot, dir)
self.line_paths[key] = make_dataset(self.line_dir[key])
self.line_paths[key] = sorted(self.line_paths[key])
self.transform = get_transform(opt)
if self.opt.hsv_aug > 0:
self.hsv_augmenter = transforms.ColorJitter(hue=(-self.opt.hsv_aug,
self.opt.hsv_aug))
def get_normalize_value(opt):
from tqdm import tqdm
opt = opt
root = opt.dataroot
color_dir = os.path.join(root, 'color/')
color_paths = make_dataset(color_dir)
color_paths = sorted(color_paths)
transform = transforms.ToTensor()
mean_ = []
min_ = []
max_ = []
for path in tqdm(color_paths):
color_img = Image.open(path).convert('RGB')
color_img = transform(color_img).unsqueeze(0)
numpy_img = color_img[0, :, :, :].numpy()
img_mean = np.mean(numpy_img, axis=(1, 2))
img_min = np.min(numpy_img, axis=(1, 2))
img_max = np.max(numpy_img, axis=(1, 2))
mean_.append(img_mean)
min_.append(img_min)
max_.append(img_max)
mean_ = np.array(mean_).mean(axis=0)
min_ = np.array(min_).min(axis=0)
max_ = np.array(max_).max(axis=0)
var_ = []
mean4var = np.reshape(mean_, (3, 1, 1))
for path in tqdm(color_paths):
color_img = Image.open(path).convert('RGB')
color_img = transform(color_img).unsqueeze(0)
numpy_img = util.rgb2lab(color_img, opt)[0, :, :, :].numpy()
# Should divide by N-1 for sample var, but just use N. N is large enough.
img_var = np.mean((numpy_img-mean4var)**2, axis=(1, 2))
var_.append(img_var)
std_ = np.sqrt(np.array(var_).mean(axis=0))
return mean_, std_, min_, max_
def random_image(self):
"""Random load the test image"""
value = self.comboBox.currentIndex()
if value == 0:
return
# read random mask
if self.opt.mask_file != "none":
mask_paths, mask_size = make_dataset(self.opt.mask_file)
item = random.randint(0, mask_size - 1)
self.mname = mask_paths[item]
item = random.randint(0, self.image_size - 1)
self.fname = self.image_paths[item]
if self.firstly:
#self.fname = './datasets/CUB_200_2011\\images/042.Vermilion_Flycatcher/Vermilion_Flycatcher_0045_42219.jpg'
self.fname = './datasets/CUB_200_2011\\images/169.Magnolia_Warbler/Magnolia_Warbler_0063_166121.jpg'
self.firstly = False
self.showImage(self.fname)
print(self.fname)
img_name = os.path.basename(self.fname)
caption = sorted(self.captions[img_name], key=lambda x: len(x))[-1]
self.textEdit.setText(caption)
def load_model(self):
"""Load different kind models for different datasets and mask types"""
value = self.comboBox.currentIndex()
if value == 0:
raise NotImplementedError("Please choose a model")
else:
# define the model type and dataset type
index = value - 1
self.opt.name = self.model_name[index]
self.opt.text_config = self.config_name[index]
self.opt.img_file = self.img_root + self.img_files[index % len(
self.img_files)]
self.model = create_model(self.opt)
self.image_paths, self.image_size = make_dataset(self.opt.img_file)
text_config = TextConfig(self.opt.text_config)
self.max_length = text_config.MAX_TEXT_LENGTH
if 'coco' in text_config.CAPTION.lower():
self.num_captions = 5
elif 'place' in text_config.CAPTION.lower():
self.num_captions = 1
else:
self.num_captions = 10
# load caption file
with open(text_config.CAPTION, 'r') as f:
self.captions = json.load(f)
with open(text_config.CATE_IMAGE_TRAIN, 'r') as f:
self.category_images_train = json.load(f)
with open(text_config.IMAGE_CATE_TRAIN, 'r') as f:
self.images_category = json.load(f)
x = pickle.load(open(text_config.VOCAB, 'rb'))
self.ixtoword = x[2]
self.wordtoix = x[3]
PSNR = 100
else:
PSNR = 20 * math.log10(255.0 / math.sqrt(mse))
# TV
gx = pre - np.roll(pre, -1, axis=1)
gy = pre - np.roll(pre, -1, axis=0)
grad_norm2 = gx**2 + gy**2
TV = np.mean(np.sqrt(grad_norm2))
return l1, PSNR, TV
if __name__ == "__main__":
gt_paths, gt_size = make_dataset(args.gt_path)
#pre_paths, pre_size = make_dataset(args.save_path)
# for i in range(20000):
# print(i)
# name = gt_paths[i].split("/")[-1]
# path = os.path.join(args.save_path,name)
# try:
# image = Image.open(path)
# except:
# print (path)
# assert gt_size == pre_size
#
iters = int(20000 / args.num_test)
PSNR = compare_psnr(ground_truth, pre, data_range=1)
SSIM = compare_ssim(ground_truth, pre, multichannel=True, data_range=pre.max()-pre.min(), sigma=1.5)
l1 = compare_mae(ground_truth, pre)
# TV
gx = pre - np.roll(pre, -1, axis=1)
gy = pre - np.roll(pre, -1, axis=0)
grad_norm2 = gx ** 2 + gy ** 2
TV = np.mean(np.sqrt(grad_norm2))
return l1, PSNR, TV, SSIM
if __name__ == "__main__":
ground_truth_paths, ground_truth_size = make_dataset(args.ground_truth_path)
iters = int(ground_truth_size/args.batch_test)
l1_loss = np.zeros(iters, np.float32)
PSNR = np.zeros(iters, np.float32)
TV = np.zeros(iters, np.float32)
SSIM = np.zeros(iters, np.float32)
for i in tqdm(range(0, iters)):
# calculate one batch of test data
l1_batch = np.zeros(args.batch_test, np.float32)
PSNR_batch = np.zeros(args.batch_test, np.float32)
TV_batch = np.zeros(args.batch_test, np.float32)
SSIM_batch = np.zeros(args.batch_test, np.float32)
# Now compute the mean kl-div
scores = []
for i in range(splits):
part = preds[(i * preds.shape[0] //
splits):((i + 1) * preds.shape[0] // splits), :]
kl = part * (np.log(part) -
np.log(np.expand_dims(np.mean(part, 0), 0)))
kl = np.mean(np.sum(kl, 1))
scores.append(np.exp(kl))
return np.mean(scores), np.std(scores)
if __name__ == '__main__':
img_paths, img_size = make_dataset(args.save_path)
iters = int(10000 / args.num_test)
u = np.zeros(iters, np.float32)
sigma = np.zeros(iters, np.float32)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
for i in range(iters):
all_samples = []
num = i * args.num_test
