'%s_%s' % (opt.phase, opt.which_epoch))
webpage = html.HTML(
web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' %
(opt.name, opt.phase, opt.which_epoch))
# statistics
psnrs = np.zeros((opt.how_many, S))
entrs = np.zeros((opt.how_many, S))
# pp dataset_loader.dataset.imgs
# ['./datasets/val/100APPLE/IMG_0429.png',
# './datasets/val/100APPLE/IMG_0791.png']
for i, data_raw in enumerate(dataset_loader):
data_raw = data_raw.cuda()
data_raw = util.crop_mult(data_raw, mult=8)
# pdb.set_trace();
# (Pdb) pp data_raw.size()
# torch.Size([1, 3, 256, 256])
# with no points
for (pp, sample_p) in enumerate(sample_ps):
xxx = '%08d_%.3f' % (i, sample_p)
img_path = [xxx.replace('.', 'p')]
data = util.get_colorization_data(data_raw,
opt,
ab_thresh=0.,
p=sample_p)
# create website
web_dir = os.path.join(opt.results_dir, opt.name,
'%s_%s' % (opt.phase, opt.which_epoch))
webpage = html.HTML(
web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' %
(opt.name, opt.phase, opt.which_epoch))
# statistics
psnrs = np.zeros((opt.how_many, S))
entrs = np.zeros((opt.how_many, S))
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
for i, data_raw in enumerate(dataset_loader):
data_raw[0] = data_raw[0].to(device)
data_raw[0] = util.crop_mult(data_raw[0], mult=8)
data = {}
A = []
B = []
HintB = []
MaskB = []
for f in range(0, data_raw[0].shape[1] * opt.n_frames, 3):
# print(data_raw[:,f:f+3].shape)
d = util.get_colorization_data(data_raw[0], opt, p=opt.sample_p)
A.append(d["A"])
B.append(d["B"])
HintB.append(d["hint_B"])
MaskB.append(d["mask_B"])
data["A"] = torch.cat(A, 1)
data["B"] = torch.cat(B, 1)
model = create_model(opt)
model.setup(opt)
model.eval()
# create website
web_dir = os.path.join(opt.results_dir, opt.name, opt.test_name, '%s_%s' % (opt.phase, opt.which_epoch))
webpage = html.HTML(web_dir, 'Experiment = %s, TestSet= %s, Phase = %s, Epoch = %s' % (opt.name, opt.test_name, opt.phase, opt.which_epoch))
# statistics
psnrs = np.zeros((opt.how_many, S))
entrs = np.zeros((opt.how_many, S))
for i, data_raw in enumerate(dataset_loader):
data_raw[0] = data_raw[0].cuda()
data_raw[0] = util.crop_mult(data_raw[0], mult=8, HWmax=[4096, 4096])
# with no points
for (pp, sample_p) in enumerate(sample_ps):
img_path = [('%08d_%.3f' % (i, sample_p)).replace('.', 'p')]
data = util.get_colorization_data(data_raw, opt, ab_thresh=0., p=sample_p)
model.set_input(data)
model.test(True) # True means that losses will be computed
visuals = util.get_subset_dict(model.get_current_visuals(), to_visualize)
psnrs[i, pp] = util.calculate_psnr_np(util.tensor2im(visuals['real']), util.tensor2im(visuals['fake_reg']))
entrs[i, pp] = model.get_current_losses()['G_entr']
save_images(webpage, visuals, img_path, aspect_ratio=opt.aspect_ratio, width=opt.display_winsize)
net = network.Colorization(4,True)
# net = siggraph.SIGGRAPHGenerator(4,2)
net.load_state_dict(torch.load(state_dict_name))
net.eval()
net.to(device)
if len(gpu_ids)>1:
net = nn.DataParallel(net,device_ids=[int(item) for item in gpu_ids.split(',')]) # list of int
train_datasets = ImageFolder(os.path.join(root,phase),transform=transforms.Compose([
transforms.Resize((opt.loadSize, opt.loadSize)),
transforms.ToTensor()]))
lens = len(train_datasets)
print('test datasets is [{}] '.format(lens))
dataloader = torch.utils.data.DataLoader(train_datasets,batch_size=batch_size,shuffle=False)
for index , data in enumerate(dataloader):
data[0] = util.crop_mult(data[0], mult=8)
data = util.get_colorization_data(data,opt,ab_thresh=0,p=opt.sample_p)
if(data is None):
continue
input = torch.cat((data['A'],data['hint_B'],data['mask_B']),dim=1)
input = input.to(device)
outputclass,outputreg = net(input)
realclass = util.encode_ab_ind(data['B'][:,:,::4,::4],opt).to(device)
lossreg = L1oss(outputreg,data['B'].to(device))
lossclass = CEloss(outputclass.type(torch.cuda.FloatTensor),realclass[:,0,:,:].type(torch.cuda.LongTensor))
image_fake = util.lab2rgb(torch.cat([data['A'].type(torch.cuda.FloatTensor),outputreg.type(torch.cuda.FloatTensor)],dim=1),opt)
print(' images [{}/{}] loss is [reg: {:.5}/[class: {:.5}]], '.
format((index+1)*data['A'].shape[0],lens,lossreg.item()*10,lossclass.item()))
# torchvision.utils.save_image(image_fake,'hemin.png')
if index %loss_fre == 0:
}
# with torch.no_grad():
self.model.set_input(data)
self.model.forward()
fake_reg = torch.cat((self.model.real_A, self.model.fake_B_reg), dim=1)
return fake_reg
image_path = "./large.JPG"
image = Image.open(image_path)
image = transforms.Compose([
transforms.Resize(512),
transforms.ToTensor(),
])(image)
image = image.view(1, *image.shape)
image = util.crop_mult(image, mult=8, HWmax=[4032, 4032])
transforms.ToPILImage()(image[0]).show(command='fim')
data = util.get_colorization_data([image], opt, ab_thresh=0., p=0.125)
img = torch.cat((data["A"], data["B"]), dim=1)
hint = torch.cat((data["hint_B"], data["mask_B"]), dim=1)
# print(data["mask_B"], data["hint_B"])
# data["hint_B"] = torch.zeros_like(data["hint_B"])
# data["mask_B"] = torch.zeros_like(data["mask_B"])
# model = Colorization()
with torch.no_grad():
model = Colorization()
model.eval()
for param in model.parameters():
param.requires_grad = False
