def test(self, name="test", options=None, fixed=False):
if options == None:
options = self.options
t = strfnow()
for option in options:
if fixed == True:
a, b, c, d = self.loader.tests[option]
else:
a, b, c, d = self.loader.next(set_option=option)
feed = {self.a: a,
self.b: b,
self.c: c,
self.d: d}
fname = "%s/%s_option:%s_time:%s.png" % (self.sample_dir, name, option, t)
g_img, g2_img, g3_img = self.sess.run([self.g1_img, self.g2_img, self.g3_img], feed_dict=feed)
imsave(fname, merge(a, b, c, d, g_img, g2_img, g3_img))
if args.hist_match == 1:
image_suffix = "_histogram_color.png"
mode = "RGB"
else:
image_suffix = "_original_color.png"
mode = "YCbCr"
image_path = os.path.splitext(args.generated_image)[0] + image_suffix
generated_image = imread(args.generated_image, mode="RGB")
img_width, img_height, _ = generated_image.shape
content_image = imread(args.content_image, mode=mode)
content_image = imresize(content_image, (img_width, img_height),
interp='bicubic')
mask_transfer = args.mask is not None
if mask_transfer:
mask_img = load_mask(args.mask, generated_image.shape)
else:
mask_img = None
img = original_color_transform(content_image,
generated_image,
mask_img,
args.hist_match,
mode=mode)
imsave(image_path, img)
print("Image saved at path : %s" % image_path)
def train(self, config):
# NOTE : if train, the nx, ny are ingnored
nx, ny = input_setup(config)
data_dir = checkpoint_dir(config)
input_, label_ = read_data(data_dir)
# Stochastic gradient descent with tself.des_block_ALLhe standard backpropagation
self.train_op = tf.train.AdamOptimizer(
learning_rate=config.learning_rate).minimize(self.loss)
tf.initialize_all_variables().run()
counter = 0
time_ = time.time()
self.load(config.checkpoint_dir)
# Train
if config.is_train:
print("Now Start Training...")
for ep in range(config.epoch):
# Run by batch images
batch_idxs = len(input_) // config.batch_size
for idx in range(0, batch_idxs):
batch_images = input_[idx * config.batch_size:(idx + 1) *
config.batch_size]
batch_labels = label_[idx * config.batch_size:(idx + 1) *
config.batch_size]
counter += 1
_, err = self.sess.run(
[self.train_op, self.loss],
feed_dict={
self.images:
batch_images,
self.labels:
batch_labels,
self.batch:
1,
self.deconv_output: [
self.batch_size, self.label_size,
self.label_size, 256
]
})
if counter % 10 == 0:
print(
"Epoch: [%2d], step: [%2d], time: [%4.4f], loss: [%.8f]"
% ((ep + 1), counter, time.time() - time_, err))
if counter % 500 == 0:
self.save(config.checkpoint_dir, counter)
# Test
else:
print("Now Start Testing...")
res = list()
for i in range(len(input_)):
result = self.pred.eval({
self.images:
input_[i].reshape(1, input_[i].shape[0],
input_[i].shape[1], 3),
self.deconv_output:
[1, self.label_size, self.label_size, 256]
})
# back to interval [0 , 1]
x = np.squeeze(result)
x = (x + 1) / 2
res.append(x)
res = np.asarray(res)
res = merge(res, [nx, ny], self.c_dim)
if self.test_img is "":
imsave(res, config.result_dir + '/result.png', config)
else:
string = self.test_img.split(".")
print(string)
imsave(res, config.result_dir + '/' + string[0] + '.png',
config)
if preserve_color and content is not None:
img = original_color_transform(content, img, mask=color_mask)
if not rescale_image:
img_ht = int(img_width * aspect_ratio)
print("Rescaling Image to (%d, %d)" % (img_width, img_ht))
img = imresize(img, (img_width, img_ht), interp=args.rescale_method)
if rescale_image:
print("Rescaling Image to (%d, %d)" % (img_WIDTH, img_HEIGHT))
img = imresize(img, (img_WIDTH, img_HEIGHT),
interp=args.rescale_method)
fname = result_prefix + "_at_iteration_%d.png" % (i + 1)
imsave(fname, img)
end_time = time.time()
print("Image saved as", fname)
print("Iteration %d completed in %ds" % (i + 1, end_time - start_time))
if improvement_threshold is not 0.0:
if improvement < improvement_threshold and improvement is not 0.0:
print(
"Improvement (%f) is less than improvement threshold (%f). Early stopping script."
% (improvement, improvement_threshold))
exit()
"""
python inetwork_tf.py "C:\\Users\\somsh\\OneDrive\\Pictures\\Album Art\\Ryogi-Shiki-small2.jpg" "C:\\Users\\somsh\\OneDrive\\Pictures\\
Art\\Blue Butterfly.jpg" "C:\\Users\\somsh\\Desktop\\Neural Art\\Ryogi" --image_size 400 --content_weight 0.025 --style_weight 1.0 --total_variation_weight 8.5E-05 --style_scale 1 --num_iter
10 --rescale_image "False" --rescale_method "bicubic" --maintain_aspect_ratio "True" --content_layer "conv5_2" --init_image "content" --pool_type "max" --preserve_color "False" --min_
improvement 0 --model "vgg16" --content_loss_type 0
def train(model,
train_loader,
test_loader,
mode='EDSR_Baseline',
save_image_every=50,
save_model_every=10,
test_model_every=1,
num_epochs=1000,
device=None,
refresh=True):
if device is None:
device = 'cuda' if torch.cuda.is_available() else 'cpu'
today = datetime.datetime.now().strftime('%Y.%m.%d')
result_dir = f'./results/{today}/{mode}'
weight_dir = f'./weights/{today}/{mode}'
logger_dir = f'./logger/{today}_{mode}'
csv = f'./hist_{today}_{mode}.csv'
if refresh:
try:
shutil.rmtree(result_dir)
shutil.rmtree(weight_dir)
shutil.rmtree(logger_dir)
except FileNotFoundError:
pass
os.makedirs(result_dir, exist_ok=True)
os.makedirs(weight_dir, exist_ok=True)
os.makedirs(logger_dir, exist_ok=True)
logger = SummaryWriter(log_dir=logger_dir, flush_secs=2)
model = model.to(device)
params = list(model.parameters())
optim = torch.optim.Adam(params, lr=1e-4)
scheduler = torch.optim.lr_scheduler.StepLR(optim,
step_size=1000,
gamma=0.99)
criterion = torch.nn.L1Loss()
######
pool = torch.nn.MaxPool2d(3).to(device)
pad1 = torch.nn.ZeroPad2d(1).to(device)
pad2 = torch.nn.ZeroPad2d(2).to(device)
######
start_time = time.time()
print(f'Training Start || Mode: {mode}')
step = 0
pfix = OrderedDict()
pfix_test = OrderedDict()
hist = dict()
hist['mode'] = f'{today}_{mode}'
for key in ['epoch', 'psnr', 'ssim', 'ms-ssim']:
hist[key] = []
for epoch in range(num_epochs):
if epoch == 0:
torch.save(model.state_dict(),
f'{weight_dir}/epoch_{epoch+1:04d}.pth')
if epoch == 0:
with torch.no_grad():
with tqdm(
test_loader,
desc=f'Warming Up || Test Epoch {epoch}/{num_epochs}',
position=0,
leave=True) as pbar_test:
psnrs = []
ssims = []
msssims = []
for lr, hr, fname in pbar_test:
lr = lr.to(device)
hr = hr.to(device)
sr, features = model(lr)
sr = quantize(sr)
psnr, ssim, msssim = evaluate(hr, sr)
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix_test['psnr'] = f'{psnr:.4f}'
pfix_test['ssim'] = f'{ssim:.4f}'
pfix_test['msssim'] = f'{msssim:.4f}'
pfix_test['psnr_mean'] = f'{psnr_mean:.4f}'
pfix_test['ssim_mean'] = f'{ssim_mean:.4f}'
pfix_test['msssim_mean'] = f'{msssim_mean:.4f}'
pbar_test.set_postfix(pfix_test)
if len(psnrs) > 1: break
with tqdm(train_loader,
desc=f'Epoch {epoch+1}/{num_epochs}',
position=0,
leave=True) as pbar:
psnrs = []
ssims = []
msssims = []
losses = []
for lr, hr, _ in pbar:
lr = lr.to(device)
hr = hr.to(device)
# prediction
sr, features = model(lr)
####
sr_pool, hr_pool = [], []
sr_pool.append(pool(sr))
hr_pool.append(pool(hr))
sr_pool.append(-pool(-sr))
hr_pool.append(-pool(-hr))
sr_pool.append(pool(pad1(sr)))
hr_pool.append(pool(pad1(hr)))
sr_pool.append(-pool(pad1(-sr)))
hr_pool.append(-pool(pad1(-hr)))
sr_pool.append(pool(pad2(sr)))
hr_pool.append(pool(pad2(hr)))
sr_pool.append(-pool(pad2(-sr)))
hr_pool.append(-pool(pad2(-hr)))
loss_pool = 0
for sr_, hr_ in zip(sr_pool, hr_pool):
loss_pool += criterion(sr_, hr_)
#####
# training
loss = criterion(hr, sr)
loss_tot = loss + loss_pool
optim.zero_grad()
loss_tot.backward()
optim.step()
scheduler.step()
# training history
elapsed_time = time.time() - start_time
elapsed = sec2time(elapsed_time)
pfix['Step'] = f'{step+1}'
pfix['Loss'] = f'{loss.item():.4f}'
pfix['Loss Pool'] = f'{loss_pool.item():.4f}'
sr = quantize(sr)
psnr, ssim, msssim = evaluate(hr, sr)
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix['PSNR'] = f'{psnr:.2f}'
pfix['SSIM'] = f'{ssim:.4f}'
# pfix['MSSSIM'] = f'{msssim:.4f}'
pfix['PSNR_mean'] = f'{psnr_mean:.2f}'
pfix['SSIM_mean'] = f'{ssim_mean:.4f}'
# pfix['MSSSIM_mean'] = f'{msssim_mean:.4f}'
free_gpu = get_gpu_memory()[0]
pfix['free GPU'] = f'{free_gpu}MiB'
pfix['Elapsed'] = f'{elapsed}'
pbar.set_postfix(pfix)
losses.append(loss.item())
if step % save_image_every == 0:
z = torch.zeros_like(lr[0])
xz = torch.cat((lr[0], z), dim=-2)
imsave([xz, sr[0], hr[0]],
f'{result_dir}/epoch_{epoch+1}_iter_{step:05d}.jpg')
step += 1
logger.add_scalar("Loss/train", np.array(losses).mean(), epoch + 1)
logger.add_scalar("PSNR/train", psnr_mean, epoch + 1)
logger.add_scalar("SSIM/train", ssim_mean, epoch + 1)
if (epoch + 1) % save_model_every == 0:
torch.save(model.state_dict(),
f'{weight_dir}/epoch_{epoch+1:04d}.pth')
if (epoch + 1) % test_model_every == 0:
with torch.no_grad():
with tqdm(test_loader,
desc=f'Test Epoch {epoch+1}/{num_epochs}',
position=0,
leave=True) as pbar_test:
psnrs = []
ssims = []
msssims = []
for lr, hr, fname in pbar_test:
fname = fname[0].split('/')[-1].split('.pt')[0]
lr = lr.to(device)
hr = hr.to(device)
sr, features = model(lr)
sr = quantize(sr)
psnr, ssim, msssim = evaluate(hr, sr)
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix_test['psnr'] = f'{psnr:.4f}'
pfix_test['ssim'] = f'{ssim:.4f}'
pfix_test['msssim'] = f'{msssim:.4f}'
pfix_test['psnr_mean'] = f'{psnr_mean:.4f}'
pfix_test['ssim_mean'] = f'{ssim_mean:.4f}'
pfix_test['msssim_mean'] = f'{msssim_mean:.4f}'
pbar_test.set_postfix(pfix_test)
z = torch.zeros_like(lr[0])
xz = torch.cat((lr[0], z), dim=-2)
imsave([xz, sr[0], hr[0]],
f'{result_dir}/{fname}.jpg')
hist['epoch'].append(epoch + 1)
hist['psnr'].append(psnr_mean)
hist['ssim'].append(ssim_mean)
hist['ms-ssim'].append(msssim_mean)
logger.add_scalar("PSNR/test", psnr_mean, epoch + 1)
logger.add_scalar("SSIM/test", ssim_mean, epoch + 1)
logger.add_scalar("MS-SSIM/test", msssim_mean,
epoch + 1)
df = pd.DataFrame(hist)
df.to_csv(csv)
def train(model, train_loader, test_loader, mode='EDSR_Baseline', save_image_every=50, save_model_every=10, test_model_every=1, epoch_start=0, num_epochs=1000, device=None, refresh=True, scale=2, today=None):
if device is None:
device = 'cuda' if torch.cuda.is_available() else 'cpu'
if today is None:
today = datetime.datetime.now().strftime('%Y.%m.%d')
result_dir = f'./results/{today}/{mode}'
weight_dir = f'./weights/{today}/{mode}'
logger_dir = f'./logger/{today}_{mode}'
csv = f'./hist_{today}_{mode}.csv'
if refresh:
try:
shutil.rmtree(result_dir)
shutil.rmtree(weight_dir)
shutil.rmtree(logger_dir)
except FileNotFoundError:
pass
os.makedirs(result_dir, exist_ok=True)
os.makedirs(weight_dir, exist_ok=True)
os.makedirs(logger_dir, exist_ok=True)
logger = SummaryWriter(log_dir=logger_dir, flush_secs=2)
model = model.to(device)
model.load_state_dict(torch.load('./weights/2021.03.10/HMNET_no_fea_REDS_JPEG_size_0/epoch_0025.pth'))
params = list(model.parameters())
optim = torch.optim.Adam(params, lr=1e-4)
scheduler = torch.optim.lr_scheduler.StepLR(optim, step_size=1000, gamma= 0.99)
# criterion = torch.nn.L1Loss()
criterion = torch.nn.MSELoss()
GMSD = GMSD_quality().to(device)
opening = Opening().to(device)
blur = Blur().to(device)
mshf = MSHF(3, 3).to(device)
downx2_bicubic = nn.Upsample(scale_factor=1/2, mode='bicubic', align_corners=False)
downx4_bicubic = nn.Upsample(scale_factor=1/4, mode='bicubic', align_corners=False)
padl = nn.ReflectionPad2d(10)
padh = nn.ReflectionPad2d(20)
start_time = time.time()
print(f'Training Start || Mode: {mode}')
step = 0
pfix = OrderedDict()
pfix_test = OrderedDict()
hist = dict()
hist['mode'] = f'{today}_{mode}'
for key in ['epoch', 'psnr', 'ssim', 'ms-ssim']:
hist[key] = []
soft_mask = False
# hf_kernel = get_hf_kernel(mode='high')
for epoch in range(epoch_start, epoch_start+num_epochs):
sigma = 0.0004 * (epoch+1)
if epoch == 0:
torch.save(model.state_dict(), f'{weight_dir}/epoch_{epoch+1:04d}.pth')
if epoch == 0:
with torch.no_grad():
with tqdm(test_loader, desc=f'{mode} || Warming Up || Test Epoch {epoch}/{num_epochs}', position=0, leave=True) as pbar_test:
psnrs = []
ssims = []
msssims = []
for lr, hr, fname in pbar_test:
lr = lr.to(device)
hr = hr.to(device)
sr, srx2, srx1 = model(hr)
sr = quantize(sr)
psnr, ssim, msssim = evaluate(hr, sr)
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix_test['psnr_mean'] = f'{psnr_mean:.4f}'
pfix_test['ssim_mean'] = f'{ssim_mean:.4f}'
pfix_test['msssim_mean'] = f'{msssim_mean:.4f}'
pbar_test.set_postfix(pfix_test)
if len(psnrs) > 1: break
with tqdm(train_loader, desc=f'{mode} || Epoch {epoch+1}/{num_epochs}', position=0, leave=True) as pbar:
psnrs = []
ssims = []
msssims = []
losses = []
for lr, hr, _ in pbar:
lr = lr.to(device)
hr = hr.to(device)
# prediction
sr, srx2, srx4 = model(lr)
gmsd = GMSD(hr, sr)
sr_ = quantize(sr)
psnr, ssim, msssim = evaluate(hr, sr_)
#hrx2 = downx2_bicubic(hr)
#hrx4 = downx4_bicubic(hr)
loss = criterion(sr, hr)
#lossx2 = criterion(srx2, hrx2)
#lossx4 = criterion(srx4, hrx4)
# training
loss_tot = loss# + 0.25 * lossx2 + 0.0625 * lossx4
optim.zero_grad()
loss_tot.backward()
optim.step()
scheduler.step()
# training history
elapsed_time = time.time() - start_time
elapsed = sec2time(elapsed_time)
pfix['Step'] = f'{step+1}'
pfix['Loss'] = f'{loss.item():.4f}'
pfix['Elapsed'] = f'{elapsed}'
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix['PSNR_mean'] = f'{psnr_mean:.2f}'
pfix['SSIM_mean'] = f'{ssim_mean:.4f}'
free_gpu = get_gpu_memory()[0]
pfix['free GPU'] = f'{free_gpu}MiB'
pbar.set_postfix(pfix)
losses.append(loss.item())
if step % save_image_every == 0:
imsave([lr[0], sr[0], hr[0], gmsd[0]], f'{result_dir}/epoch_{epoch+1}_iter_{step:05d}.jpg')
step += 1
logger.add_scalar("Loss/train", np.array(losses).mean(), epoch+1)
logger.add_scalar("PSNR/train", psnr_mean, epoch+1)
logger.add_scalar("SSIM/train", ssim_mean, epoch+1)
if (epoch+1) % save_model_every == 0:
torch.save(model.state_dict(), f'{weight_dir}/epoch_{epoch+1:04d}.pth')
if (epoch+1) % test_model_every == 0:
with torch.no_grad():
with tqdm(test_loader, desc=f'{mode} || Test Epoch {epoch+1}/{num_epochs}', position=0, leave=True) as pbar_test:
psnrs = []
ssims = []
msssims = []
for lr, hr, fname in pbar_test:
fname = fname[0].split('/')[-1].split('.pt')[0]
lr = lr.to(device)
hr = hr.to(device)
sr, _, _ = model(lr)
mshf_hr = mshf(hr)
mshf_sr = mshf(sr)
gmsd = GMSD(hr, sr)
sr = quantize(sr)
psnr, ssim, msssim = evaluate(hr, sr)
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix_test['psnr_mean'] = f'{psnr_mean:.4f}'
pfix_test['ssim_mean'] = f'{ssim_mean:.4f}'
pfix_test['msssim_mean'] = f'{msssim_mean:.4f}'
pbar_test.set_postfix(pfix_test)
imsave([lr[0], sr[0], hr[0], gmsd[0]], f'{result_dir}/{fname}.jpg')
mshf_vis = torch.cat((torch.cat([mshf_sr[:,i,:,:] for i in range(mshf_sr.shape[1])], dim=-1),
torch.cat([mshf_hr[:,i,:,:] for i in range(mshf_hr.shape[1])], dim=-1)), dim=-2)
imsave(mshf_vis, f'{result_dir}/MSHF_{fname}.jpg')
hist['epoch'].append(epoch+1)
hist['psnr'].append(psnr_mean)
hist['ssim'].append(ssim_mean)
hist['ms-ssim'].append(msssim_mean)
logger.add_scalar("PSNR/test", psnr_mean, epoch+1)
logger.add_scalar("SSIM/test", ssim_mean, epoch+1)
logger.add_scalar("MS-SSIM/test", msssim_mean, epoch+1)
df = pd.DataFrame(hist)
df.to_csv(csv)
def train(
date,
dataset='DAGM_8',
code_dim=100,
epochs=25,
use_cuda=True,
batch_size=128,
lr_g=.1,
lr_z=.1,
max_num_samples=100000,
init='pca',
n_pca=(64 * 64 * 3 * 2),
loss='lap_l1',
):
print(colors.BLUE+"====================start training===================="+colors.ENDL)
save_dir = 'results/'+dataset+'/'+date
if not os.path.exists(save_dir):
os.makedirs(save_dir)
# load datasets for training and validation set
if dataset == 'DAGM_10':
train_loader = utils.load(data_dir='../data/DAGM_10/mix',
batch_size=batch_size, img_size=128, convert='L')
val_loader = utils.load(data_dir='../data/DAGM_10/mix',
batch_size=8*8, img_size=128, convert='L')
elif dataset == 'DAGM_8':
train_loader = utils.load(data_dir='../data/DAGM_8/mix',
batch_size=batch_size, img_size=128, convert='L')
val_loader = utils.load(data_dir='../data/DAGM_8/mix',
batch_size=8*8, img_size=128, convert='L')
else:
raise Exception("No such dataset!!")
# we don't really have a validation set here, but for visualization let us
# just take the first couple images from the dataset
# =================================================================================================
# =========================================Train part==============================================
# =================================================================================================
# do droping in one-third of all epochs
epochs_d = round(epochs/3)
items_all = len(os.listdir('../data/'+dataset+'/mix'))
per_drop_num = round(0.1*items_all)
# do droping 3 times
cycle_d = 3
for cyc in range(cycle_d):
# initialize representation space:
train_loader = utils.load(data_dir='../data/DAGM_8/mix',
batch_size=batch_size, img_size=128, convert='L')
if init == 'pca':
from sklearn.decomposition import PCA
# first, take a subset of train set to fit the PCA
X_pca = np.vstack([
X.cpu().numpy().reshape(len(X), -1)
for i, (X, _, _)
in zip(tqdm(range(n_pca // train_loader.batch_size), 'collect data for PCA'),
train_loader)
])
print("perform PCA...")
pca = PCA(n_components=code_dim)
pca.fit(X_pca)
# then, initialize latent vectors to the pca projections of the complete dataset
Z = np.empty((len(train_loader.dataset), code_dim))
print(Z.shape)
for X, _, idx in tqdm(train_loader, 'pca projection'):
idx = idx.numpy()
Z[idx] = pca.transform(X.cpu().numpy().reshape(len(X), -1))
elif init == 'random':
Z = np.random.randn(len(train_loader.dataset), code_dim)
else:
raise Exception("-i : choices=[pca random]")
# project the latent vectors into a unit ball
Z = utils.project_l2_ball(Z)
# we use only 1 output channel
g = maybe_cuda(Generator_128(code_dim, out_channels=1))
loss_fn = LapLoss(max_levels=3)#if loss == 'lap_l1' else nn.MSELoss()
zi = maybe_cuda(torch.zeros((batch_size, code_dim)))
zi = Variable(zi, requires_grad=True)
optimizer = SGD([
{'params': g.parameters(), 'lr': lr_g},
{'params': zi, 'lr': lr_z}
])
val_loader = utils.load(data_dir='../data/'+dataset+'/mix', batch_size=8*8, img_size=128, convert='L')
Xi_val, _, idx_val = next(iter(val_loader))
save_drop_dir = save_dir+'/drop_%d'%(cyc+1)
if not os.path.exists(save_drop_dir):
os.makedirs(save_drop_dir)
utils.imsave(save_dir+'/target_%d.png'%(cyc+1),make_grid(Xi_val.cpu(),nrow=8,normalize=True,range=(0,1)).numpy().transpose(1,2,0))
overall_loss = []
for epoch in range(epochs_d):
losses= []
progress = tqdm(total=len(train_loader)-1, desc='epoch % 3d' %(epoch+1))
for i, (Xi, yi, idx) in enumerate(train_loader):
if i == train_loader.dataset.__len__() // batch_size:
break
Xi = Variable(maybe_cuda(Xi))
zi.data = maybe_cuda(torch.FloatTensor(Z[idx.numpy()]))
optimizer.zero_grad()
rec = g(zi)
loss = loss_fn(rec, Xi)
loss.backward()
optimizer.step()
Z[idx.numpy()] = utils.project_l2_ball(zi.data.cpu().numpy())
losses.append(loss.item())
progress.set_postfix({'loss_%d'%(cyc+1): np.mean(losses[-100:])})
progress.update()
overall_loss.append(np.mean(losses[:]))
progress.close()
# visualize reconstructions
rec = g(Variable(maybe_cuda(torch.FloatTensor(Z[idx_val.numpy()]))))
if ((epoch+1) % 10)==0 :
utils.imsave(save_dir+'/part%d_epoch_%03d.png' % (cyc+1, epoch+1),
make_grid(rec.data.cpu(),nrow=8,normalize=True,range=(0,1)).numpy().transpose(1,2,0))
utils.loss_plot(overall_loss, save_dir+'/train_loss.png')
print("save loss plot")
# save generator model
torch.save(g.state_dict(), os.path.join(save_dir,'model_epoch_'+str(epochs)+'.pth'))
print("generator model saved")
print("saving optimized latent code")
with open(save_dir+'/train_latent_code.csv', 'w') as f:
np.savetxt(f, Z, delimiter=' ')
print(colors.BLUE+"Part_%d training finished!"%(cyc+1)+colors.ENDL)
# =================================================================================================
# =====================================Test and Drop part==========================================
# =================================================================================================
# initialize representation space:
if init == 'pca':
from sklearn.decomposition import PCA
# first, take a subset of train set to fit the PCA
X_pca = np.vstack([X.cpu().numpy().reshape(len(X), -1)
for i, (X, _, _)
in zip(tqdm(range(n_pca // train_loader.batch_size), 'collect data for PCA'),
train_loader)
])
print("performing PCA...")
pca = PCA(n_components=code_dim)
pca.fit(X_pca)
# then, initialize latent vectors to the pca projections of the complete dataset
Z = np.empty((len(train_loader.dataset), code_dim))
print(Z.shape)
for X, _, idx in tqdm(train_loader, 'pca projection'):
idx = idx.numpy()
Z[idx] = pca.transform(X.cpu().numpy().reshape(len(X), -1))
elif init == 'random':
Z = np.random.randn(len(train_loader.dataset), code_dim)
# because we want to see the difference, so we don't project to unit ball
# but it will not show the convex property, so we still project it to unit ball
Z = utils.project_l2_ball(Z)
g = maybe_cuda(Generator_128(code_dim, out_channels=1))
pretrained_file = glob.glob(save_dir+'/*.pth')
g.load_state_dict(torch.load(pretrained_file[0]))
print("load pre-trained weights success!!")
loss_fn = LapLoss(max_levels=3)
#loss_fn = nn.MSELoss()
zi = maybe_cuda(torch.zeros((batch_size, code_dim)))
zi = Variable(zi, requires_grad=True)
optimizer = Adam([{'params': zi, 'lr': lr_z}])
#optimizer = SGD([{'params': zi, 'lr': lr_z}])
# fix the parameters of the generator
for param in g.parameters():
param.requires_grad = False
for i, (Xi, yi, idx) in enumerate(train_loader):
if i == (train_loader.dataset.__len__() // batch_size):
print(len(idx))
break
losses = []
progress = tqdm(total=epochs-1, desc='batch iter % 4d' % (i+1))
Xi = Variable(maybe_cuda(Xi))
zi.data = maybe_cuda(torch.FloatTensor(Z[idx.numpy()]))
epoch_start_time = time.time()
for epoch in range(epochs):
optimizer.zero_grad()
loss = loss_fn(g(zi), Xi)
loss.backward()
optimizer.step()
# we don't project back to unit ball in test stage
#Z[idx.numpy()] = zi.data.cpu().numpy()
Z[idx.numpy()] = utils.project_l2_ball(zi.data.cpu().numpy())
#print(Z[idx.numpy()])
losses.append(loss.item())
progress.set_postfix({'loss': np.mean(losses[-100:])})
progress.update()
progress.close()
print("saving optimized latent code")
with open(save_dir+'/test_latent_code.csv', 'w') as f:
np.savetxt(f, Z, delimiter=' ')
print(colors.BLUE+"Part_%d testing finished!"%(cyc+1)+colors.ENDL)
# Calculate the variance and drop bigger ones
# read latent codes from csv
train_csv = glob.glob(save_dir+'/test_latent_code.csv')
df_train = pd.read_csv(train_csv[0], header=None, delimiter=' ')
train_latent = df_train.values
# calculate variance and mean
train_mu = np.mean(train_latent, axis=1)
train_sigma = np.var(train_latent, axis=1)
mu = np.mean(train_mu)
ori_items = os.listdir('../data/'+dataset+'/mix')
dir_num = len(ori_items)
count_value_ok = 0
value_fid = np.zeros(dir_num)
print('total pictures in folder : %d' % dir_num)
for i in range(dir_num):
diff_fid = train_mu[i] - mu
value_fid[i] = diff_fid**2 + train_sigma[i]
# Find the first 10% large fid number
tmp_list = sorted(value_fid)
fid_threshold = tmp_list[(-1*per_drop_num)]
print('first 10 percent large num is : %.4f' % fid_threshold)
for j in range(dir_num):
if value_fid[j] >= fid_threshold:
shutil.move('../data/'+dataset+'/mix/'+ori_items[j], save_drop_dir+'/'+ori_items[j])
print(colors.BLUE+"Part_%d droping finished!"%(cyc+1)+colors.ENDL)
# Count
c1_ok, c1_ng = utils.count_ok(dataset, date, '/drop_1')
c2_ok, c2_ng = utils.count_ok(dataset, date, '/drop_2')
c3_ok, c3_ng = utils.count_ok(dataset, date, '/drop_3')
all_ok, all_ng = utils.count_ok_ori(dataset, 'mix')
print("+-----------+-----------+-----------+")
print("|First Drop|OK: %6d |NG: %6d|" %(c1_ok, c1_ng))
print("|-----------+-----------+-----------|")
print("|Second Drop|OK: %6d |NG: %6d|" %(c2_ok, c2_ng))
print("|-----------+-----------+-----------|")
print("|Third Drop|OK: %6d |NG: %6d|" %(c3_ok, c3_ng))
print("|-----------+-----------+-----------|")
print("|The OK Part|OK: %6d |NG: %6d|" %(all_ok, all_ng))
print("+-----------+-----------+-----------+")
print(colors.BLUE+"========================Droping Finish======================="+colors.ENDL)
def train(self, config):
if config.is_train:
input_setup(self.sess, config)
else:
nx, ny = input_setup(self.sess, config)
if config.is_train:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"train.h5")
else:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"test.h5")
train_data, train_label = read_data(data_dir)
# Stochastic gradient descent with the standard backpropagation
self.train_op = tf.train.GradientDescentOptimizer(
config.learning_rate).minimize(self.loss)
tf.initialize_all_variables().run()
counter = 0
start_time = time.time()
if load(self):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
if config.is_train:
print("Training...")
for ep in xrange(config.epoch):
# Run by batch images
batch_idxs = len(train_data) // config.batch_size
for idx in xrange(0, batch_idxs):
batch_images = train_data[idx *
config.batch_size:(idx + 1) *
config.batch_size]
batch_labels = train_label[idx *
config.batch_size:(idx + 1) *
config.batch_size]
counter += 1
_, err = self.sess.run([self.train_op, self.loss],
feed_dict={
self.images: batch_images,
self.labels: batch_labels
})
if counter % 10 == 0:
print("Epoch: [%2d], step: [%2d], time: [%4.4f], loss: [%.8f]" \
% ((ep+1), counter, time.time()-start_time, err))
if counter % 500 == 0:
self.save(config.checkpoint_dir, counter)
else:
print("Testing...")
result = self.pred.eval({
self.images: train_data,
self.labels: train_label
})
result = merge(result, [nx, ny])
result = result.squeeze()
image_path = os.path.join(os.getcwd(), config.sample_dir)
image_path = os.path.join(image_path, "test_image.png")
print(train_label.shape)
self.imshow(result)
imsave(result, image_path)
def main(_):
pp.pprint(flags.FLAGS.__flags)
if not os.path.exists(FLAGS.checkpoint_dir):
os.makedirs(FLAGS.checkpoint_dir)
if not os.path.exists(FLAGS.sample_dir):
os.makedirs(FLAGS.sample_dir)
if FLAGS.is_train:
with tf.Session(config=config_sess) as sess:
srcnn = SRCNN(sess,
image_size=FLAGS.image_size,
label_size=FLAGS.label_size,
batch_size=FLAGS.batch_size,
h0=FLAGS.h0,
w0=FLAGS.w0,
c_dim=FLAGS.c_dim,
checkpoint_dir=FLAGS.checkpoint_dir,
sample_dir=FLAGS.sample_dir)
srcnn.train(FLAGS)
#RMSE_tab.append(srcnn.train(FLAGS))
#sio.savemat(os.path.join(results_path, 'RMSE_tab.mat'), {'RMSE_tab':RMSE_tab})
else:
sio.savemat(os.path.join(results_path, 'configuration.mat'),{"data_path":data_path, "is_train":is_train,"checkpoint_path":checkpoint_path, "config":config})
data_dir = data_path
rgb_input_list =glob.glob(os.path.join(data_dir,'*_RGB.bmp'))
image_test=[]
RMSE_tab = []
print(f'The number of input images is {len(rgb_input_list)}')
for ide in range(0,len(rgb_input_list)):
image_test.append(np.float32(imageio.imread(rgb_input_list[ide])) / 255)
for idx in range(0,len(rgb_input_list)):
depth_input_down_image = glob.glob(os.path.join(data_dir,str(idx)+'_Df_down.mat'))
depth_label_list_image = glob.glob(os.path.join(data_dir,str(idx)+'_Df.mat'))
rgb_input_list_image = glob.glob(os.path.join(data_dir,str(idx)+'_RGB.bmp'))
print('PATH INPUT IMAGES')
print('index_image ='+str(idx))
print(depth_input_down_image)
print(depth_label_list_image)
print(rgb_input_list_image)
depth_up = sio.loadmat(depth_label_list_image[0])['I_up']
#image_path = os.path.join(os.getcwd(), 'sample')
image_path = results_path
image_path = os.path.join(image_path, str(idx)+"_up.png" )
imsave(depth_up, image_path)
[IMAGE_HEIGHT,IMAGE_WIDTH] = image_test[idx].shape
with tf.compat.v1.Session() as sess:
srcnn = SRCNN(sess,
image_size=FLAGS.image_size,
label_size=FLAGS.label_size,
batch_size=FLAGS.batch_size,
h0=IMAGE_HEIGHT,
w0=IMAGE_WIDTH,
c_dim=1,
i=idx,
checkpoint_dir=FLAGS.checkpoint_dir,
sample_dir=FLAGS.sample_dir,
test_dir=rgb_input_list_image[0],
test_depth=depth_input_down_image[0],
test_label=depth_label_list_image[0])
RMSE_tab.append(srcnn.train(FLAGS))
sio.savemat(os.path.join(results_path, 'RMSE_tab.mat'), {'RMSE_tab':RMSE_tab})
def train_multiple(generator, discriminator, opt, dataloader, writer, scale):
feature_extractor = FeatureExtractor(
torchvision.models.vgg19(pretrained=True))
content_criterion = nn.MSELoss()
adversarial_criterion = nn.BCELoss()
aesthetic_loss = AestheticLoss()
ones_const = Variable(torch.ones(opt.batchSize, 1))
if opt.cuda:
generator.cuda()
discriminator.cuda()
feature_extractor.cuda()
content_criterion.cuda()
adversarial_criterion.cuda()
ones_const = ones_const.cuda()
optimizer = optim.Adam(generator.parameters(), lr=opt.generatorLR)
optim_discriminator = optim.Adam(
discriminator.parameters(), lr=opt.discriminatorLR)
scheduler_gen = ReduceLROnPlateau(
optimizer, 'min', factor=0.7, patience=10, verbose=True)
scheduler_dis = ReduceLROnPlateau(
optim_discriminator, 'min', factor=0.7, patience=10, verbose=True)
curr_time = time.time()
inputs = torch.FloatTensor(opt.batchSize, 3, opt.imageSize, opt.imageSize)
# pretraining
for epoch in range(2):
mean_generator_content_loss = 0.0
inputs = torch.FloatTensor(
opt.batchSize, 3, opt.imageSize, opt.imageSize)
for batch_no, data in enumerate(dataloader['train']):
high_img, _ = data
# save_image(high_img, "test.png")
# time.sleep(10)
for j in range(opt.batchSize):
inputs[j] = scale(high_img[j])
high_img[j] = normalize(high_img[j])
# print(high_img[0].shape)
# print(inputs[0].shape)
# time.sleep(10)
if opt.cuda:
optimizer.zero_grad()
high_res_real = Variable(high_img.cuda())
high_res_fake = generator(Variable(inputs[0][np.newaxis, :]).cuda(), Variable(inputs[1][np.newaxis, :]).cuda(
), Variable(inputs[2][np.newaxis, :]).cuda(), Variable(inputs[3][np.newaxis, :]).cuda())
generator_content_loss = content_criterion(
high_res_fake, high_res_real)
mean_generator_content_loss += generator_content_loss.data.item()
generator_content_loss.backward()
optimizer.step()
sys.stdout.write('\r[%d/%d][%d/%d] Generator_MSE_Loss: %.4f' % (
epoch, 2, batch_no, len(dataloader['train']), generator_content_loss.data.item()))
# training
for epoch in range(opt.nEpochs):
for phase in ['train', 'test']:
if phase == 'test':
generator.train(False)
discriminator.train(False)
else:
generator.train(True)
discriminator.train(True)
mean_generator_content_loss = 0.0
mean_generator_adversarial_loss = 0.0
mean_generator_total_loss = 0.0
mean_discriminator_loss = 0.0
# mean_psnr = 0.0
# mean_msssim = 0.0
high_img = torch.FloatTensor(
opt.batchSize, 3, opt.imageSize, opt.imageSize)
inputs = torch.FloatTensor(
opt.batchSize, 3, opt.imageSize, opt.imageSize)
for batch_no, data in enumerate(dataloader[phase]):
high_img, _ = data
for j in range(opt.batchSize):
inputs[j] = scale(high_img[j])
high_img[j] = normalize(high_img[j])
if opt.cuda:
optimizer.zero_grad()
high_res_real = Variable(high_img.cuda())
high_res_fake = generator(Variable(inputs[0][np.newaxis, :]).cuda(), Variable(inputs[1][np.newaxis, :]).cuda(
), Variable(inputs[2][np.newaxis, :]).cuda(), Variable(inputs[3][np.newaxis, :]).cuda())
# save_image(high_res_real, "REAL.png")
# save_image(high_res_fake, "FAKE.png")
target_real = Variable(torch.rand(
opt.batchSize, 1) * 0.5 + 0.7).cuda()
target_fake = Variable(torch.rand(
opt.batchSize, 1) * 0.3).cuda()
discriminator.zero_grad()
discriminator_loss = adversarial_criterion(
discriminator(Variable(inputs[0][np.newaxis, :]).cuda(), Variable(inputs[1][np.newaxis, :]).cuda(),
Variable(inputs[2][np.newaxis, :]).cuda(), Variable(inputs[3][np.newaxis, :]).cuda()),
target_real) + \
adversarial_criterion(
discriminator(high_res_fake[0][np.newaxis, :], high_res_fake[1][np.newaxis, :], high_res_fake[2][np.newaxis, :],
high_res_fake[3][np.newaxis, :]), target_fake)
mean_discriminator_loss += discriminator_loss.data.item()
if phase == 'train':
discriminator_loss.backward(retain_graph=True)
optim_discriminator.step()
#high_res_fake_cat = torch.cat([ image for image in high_res_fake ], 0)
fake_features = feature_extractor(high_res_fake)
real_features = Variable(
feature_extractor(high_res_real).data)
# generator_content_loss = content_criterion(high_res_fake, high_res_real) + 0.006*content_criterion(fake_features, real_features)
generator_content_loss = content_criterion(high_res_fake,
high_res_real) + content_criterion(fake_features,
real_features)
mean_generator_content_loss += generator_content_loss.data.item()
generator_adversarial_loss = adversarial_criterion(discriminator(
high_res_fake[0][np.newaxis, :], high_res_fake[1][np.newaxis, :], high_res_fake[2][np.newaxis, :], high_res_fake[3][np.newaxis, :]), ones_const)
mean_generator_adversarial_loss += generator_adversarial_loss.data.item()
generator_total_loss = generator_content_loss + 1e-3 * generator_adversarial_loss
mean_generator_total_loss += generator_total_loss.data.item()
if phase == 'train':
generator_total_loss.backward()
optimizer.step()
if(batch_no % 10 == 0):
# print("phase {} batch no. {} generator_content_loss {} discriminator_loss {}".format(phase, batch_no, generator_content_loss, discriminator_loss))
sys.stdout.write('\rphase [%s] epoch [%d/%d] batch no. [%d/%d] Generator_content_Loss: %.4f discriminator_loss %.4f' % (
phase, epoch, opt.nEpochs, batch_no, len(dataloader[phase]), generator_content_loss, discriminator_loss))
if phase == 'train':
imsave(high_res_fake.cpu().data, train=True,
epoch=epoch, image_type='fake')
imsave(high_img, train=True, epoch=epoch, image_type='real')
imsave(inputs, train=True, epoch=epoch, image_type='low')
writer.add_scalar(phase + " per epoch/generator lr",
optimizer.param_groups[0]['lr'], epoch + 1)
writer.add_scalar(phase + " per epoch/discriminator lr", optim_discriminator.param_groups[0]['lr'],
epoch + 1)
scheduler_gen.step(
mean_generator_total_loss / len(dataloader[phase]))
scheduler_dis.step(mean_discriminator_loss /
len(dataloader[phase]))
else:
imsave(high_res_fake.cpu().data, train=False,
epoch=epoch, image_type='fake')
imsave(high_img, train=False, epoch=epoch, image_type='real')
imsave(inputs, train=False, epoch=epoch, image_type='low')
# import ipdb;
# ipdb.set_trace()
mssim = avg_msssim(high_res_real, high_res_fake)
psnr_val = psnr(un_normalize(high_res_real),
un_normalize(high_res_fake))
writer.add_scalar(phase + " per epoch/PSNR", psnr_val,
epoch + 1)
writer.add_scalar(phase+" per epoch/discriminator loss",
mean_discriminator_loss/len(dataloader[phase]), epoch+1)
writer.add_scalar(phase+" per epoch/generator loss",
mean_generator_total_loss/len(dataloader[phase]), epoch+1)
writer.add_scalar("per epoch/total time taken",
time.time()-curr_time, epoch+1)
writer.add_scalar(phase+" per epoch/avg_mssim", mssim, epoch+1)
# Do checkpointing
torch.save(generator.state_dict(), '%s/generator_final.pth' % opt.out)
torch.save(discriminator.state_dict(),
'%s/discriminator_final.pth' % opt.out)
def train_angres(AngRes, lflists, opt, writer):
content_criterion = nn.MSELoss()
aesthetic_criterion = AestheticLoss()
# fake_ang_res = torch.FloatTensor(
# 4, 3, opt.upSampling*opt.imageSize, opt.upSampling*opt.imageSize)
optimizer = optim.Adam(AngRes.parameters(), lr=opt.angResLR)
scheduler_angres = ReduceLROnPlateau(
optimizer, 'min', factor=0.1, patience=3, verbose=True)
curr_time = time.time()
if opt.cuda:
AngRes.cuda()
content_criterion.cuda()
AngRes.train(True)
for epoch in range(opt.continue_from, opt.nEpochs):
mean_loss = 0.0
count = 0
for lf_image in lflists:
i = j = -1
new_img = torch.FloatTensor(
4, 3, opt.upSampling*opt.imageSize, opt.upSampling*opt.imageSize)
while i < 14:
i += 1
j = -1
while j < 14:
j += 1
img1 = torch.Tensor(lf_image[i][j])
img2 = torch.Tensor(lf_image[i][j+2])
img3 = torch.Tensor(lf_image[i+2][j])
img4 = torch.Tensor(lf_image[i+2][j+2])
gt_center = torch.Tensor(lf_image[i+1][j+1])
gt_horizontaltop = torch.Tensor(lf_image[i][j + 1])
gt_verticalleft = torch.Tensor(lf_image[i + 1][j])
gt_horizontalbottom = torch.Tensor(lf_image[i + 2][j + 1])
gt_verticalright = torch.Tensor(lf_image[i + 1][j + 2])
img1 = torch.transpose(img1, 0, 2)
img2 = torch.transpose(img2, 0, 2)
img3 = torch.transpose(img3, 0, 2)
img4 = torch.transpose(img4, 0, 2)
gt_center = torch.transpose(gt_center, 0, 2)
gt_horizontaltop = torch.transpose(gt_horizontaltop, 0, 2)
gt_verticalleft = torch.transpose(gt_verticalleft, 0, 2)
gt_horizontalbottom = torch.transpose(
gt_horizontalbottom, 0, 2)
gt_verticalright = torch.transpose(gt_verticalright, 0, 2)
new_img[0] = torch.transpose(img1, 1, 2)
new_img[1] = torch.transpose(img2, 1, 2)
new_img[2] = torch.transpose(img3, 1, 2)
new_img[3] = torch.transpose(img4, 1, 2)
gt_center_img = torch.transpose(
gt_center, 1, 2).type(torch.FloatTensor)
gt_horizontaltop_img = torch.transpose(
gt_horizontaltop, 1, 2).type(torch.FloatTensor)
gt_verticalleft_img = torch.transpose(
gt_verticalleft, 1, 2).type(torch.FloatTensor)
gt_horizontalbottom_img = torch.transpose(
gt_horizontalbottom, 1, 2).type(torch.FloatTensor)
gt_verticalright_img = torch.transpose(
gt_verticalright, 1, 2).type(torch.FloatTensor)
if opt.cuda:
fake_img = AngRes(Variable(new_img[0][np.newaxis, :]).cuda(),
Variable(new_img[1][np.newaxis, :]).cuda(),
Variable(new_img[2][np.newaxis, :]).cuda(),
Variable(new_img[3][np.newaxis, :]).cuda())
out = [aesthetic_transform(fake_img[0].cpu().data.clone()).cuda(),
aesthetic_transform(fake_img[1].cpu().data.clone()).cuda(),
aesthetic_transform(fake_img[2].cpu().data.clone()).cuda(),
aesthetic_transform(fake_img[3].cpu().data.clone()).cuda(),
aesthetic_transform(fake_img[4].cpu().data.clone()).cuda()]
target = [aesthetic_transform(gt_center_img.clone()).cuda(),
aesthetic_transform(gt_horizontaltop_img.clone()).cuda(),
aesthetic_transform(gt_horizontalbottom_img.clone()).cuda(),
aesthetic_transform(gt_verticalleft_img.clone()).cuda(),
aesthetic_transform(gt_verticalright_img.clone()).cuda()]
aesthetic_loss = aesthetic_criterion(out, target)
center_loss = content_criterion(
fake_img[0], gt_center_img.cuda())
horizontaltop_loss = content_criterion(
fake_img[1], gt_horizontaltop_img.cuda())
horizontalbottom_loss = content_criterion(
fake_img[2], gt_horizontalbottom_img.cuda())
verticalleft_loss = content_criterion(
fake_img[3], gt_verticalleft_img.cuda())
verticalright_loss = content_criterion(
fake_img[4], gt_verticalright_img.cuda())
total_loss = center_loss + horizontaltop_loss + \
horizontalbottom_loss + verticalleft_loss + verticalright_loss + (aesthetic_loss * 1e5)
# print()
# print(total_loss)
mean_loss += total_loss
AngRes.zero_grad()
total_loss.backward()
optimizer.step()
if (j == 14):
if(opt.progress_images):
images = []
for x in range(0, 5):
images.append(display_transform(fake_img[x].cpu().data.clone().type(torch.ByteTensor)))
image = make_grid(images, padding=1)
save_image(image, "fake.png")
one = display_transform(
gt_center_img.clone().type(torch.ByteTensor))
two = display_transform(
gt_horizontaltop_img.clone().type(torch.ByteTensor))
three = display_transform(
gt_horizontalbottom_img.clone().type(torch.ByteTensor))
four = display_transform(
gt_verticalleft_img.clone().type(torch.ByteTensor))
five = display_transform(
gt_verticalright_img.clone().type(torch.ByteTensor))
real_image = make_grid(
[one, two, three, four, five], padding=1)
save_image(real_image, "real.png")
sys.stdout.write(
'\repoch [%d/%d][%.2f%%] content_Loss: %.4f' % (
epoch, opt.nEpochs, ((count * 14) + i)/(14 * len(lflists)) * 100, total_loss))
imsave(fake_img.cpu().data, train=True, epoch=count,
image_type='new', ang_res=True, row_ind=i, column_ind=j)
imsave(gt_center_img, train=True, epoch=count,
image_type='real_center', ang_res=True)
imsave(gt_horizontaltop_img, train=True, epoch=count,
image_type='real_horizontaltop', ang_res=True)
imsave(gt_horizontalbottom_img, train=True, epoch=count,
image_type='real_horizontalbottom', ang_res=True)
imsave(gt_verticalleft_img, train=True, epoch=count,
image_type='real_verticalleft', ang_res=True)
imsave(gt_verticalright_img, train=True, epoch=count,
image_type='real_verticalright', ang_res=True)
writer.add_scalar(" per epoch/angres lr",
optimizer.param_groups[0]['lr'], epoch + 1)
count += 1
# else:
# imsave(fake_img.cpu().data, train=False, epoch=epoch, image_type='new', ang_res=True)
# imsave(inputs, train=False, epoch=epoch, image_type='real', ang_res=True)
scheduler_angres.step(total_loss / len(lflists))
writer.add_scalar(" per epoch/angres loss", mean_loss / len(lflists),
epoch + 1)
writer.add_scalar("per epoch/total time taken",
time.time() - curr_time, epoch + 1)
# Do checkpointing
torch.save(AngRes.state_dict(), '%s/AngRes_final.pth' % opt.out)
def train(self, config):
if config.is_train:
input_setup(self.sess, config)
else:
nx, ny = input_setup(self.sess, config)
if config.is_train:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"train.h5")
else:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"test.h5")
train_data, train_label = read_data(data_dir)
# Stochastic gradient descent with the standard backpropagation
self.train_op = tf.train.GradientDescentOptimizer(
config.learning_rate).minimize(self.loss)
tf.initialize_all_variables().run()
counter = 0
start_time = time.time()
if self.load(self.checkpoint_dir):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
if config.is_train:
print("Training...")
for ep in xrange(config.epoch):
# Run by batch images
batch_idxs = len(train_data) // config.batch_size
for idx in xrange(0, batch_idxs):
batch_images = train_data[idx *
config.batch_size:(idx + 1) *
config.batch_size]
batch_labels = train_label[idx *
config.batch_size:(idx + 1) *
config.batch_size]
counter += 1
_, err = self.sess.run([self.train_op, self.loss],
feed_dict={
self.images: batch_images,
self.labels: batch_labels
})
if counter % 10 == 0:
print("Epoch: [%2d], step: [%2d], time: [%4.4f], loss: [%.8f]" \
% ((ep+1), counter, time.time()-start_time, err))
if counter % 500 == 0:
self.save(config.checkpoint_dir, counter)
else:
print("Testing...")
result = self.pred.eval({self.images: train_data})
result = merge(result, [nx, ny])
result = result.squeeze()
image_path = os.path.join(os.getcwd(), config.sample_dir)
image_path = os.path.join(image_path, "test_image.png")
imsave(result, image_path)
# Print PSNR
labelimg = merge(train_label, [nx, ny])
labelimg = labelimg.squeeze()
print("HR image size: (%d, %d)" %
(labelimg.shape[0], labelimg.shape[1]))
print("SR image size: (%d, %d)" %
(result.shape[0], result.shape[1]))
bicubic = scipy.ndimage.interpolation.zoom(labelimg,
(1. / config.scale),
prefilter=False)
bicubic = scipy.ndimage.interpolation.zoom(bicubic,
(config.scale / 1.),
prefilter=False)
print("LR image size: (%d, %d)" %
(bicubic.shape[0], bicubic.shape[1]))
psnr_sr = self.cal_psnr(result, labelimg)
psnr_bicubic = self.cal_psnr(bicubic, labelimg)
print("")
print("SR PSNR = %.3f" % psnr_sr)
print("Bicubic PSNR = %.3f" % psnr_bicubic)
def main(args):
def maybe_cuda(tensor):
return tensor.cuda() if args.gpu else tensor
Img_dir = 'Figs/'
if not os.path.exists(Img_dir):
os.makedirs(Img_dir)
Model_dir = 'Models/'
if not os.path.exists(Model_dir):
os.makedirs(Model_dir)
Data_dir = 'Data/'
if not os.path.exists(Data_dir):
os.makedirs(Data_dir)
train_set = utils.IndexedDataset(
LSUN(args.dir, classes=[args.cl+'_train'],
transform=transforms.Compose([
transforms.Resize(64),
transforms.CenterCrop(64),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
)
train_loader = torch.utils.data.DataLoader(
train_set, batch_size=args.batch_size,
shuffle=True, drop_last=True,
num_workers=8, pin_memory=args.gpu,
)
val_loader = torch.utils.data.DataLoader(train_set, shuffle=False, batch_size=8*8)
if args.n > 0:
train_set.base.length = args.n
train_set.base.indices = [args.n]
# initialize representation space:
if args.init == 'pca':
print('Check if PCA is already calculated...')
pca_path = 'Data/GLO_pca_init_{}_{}.pt'.format(
args.cl, args.d)
if os.path.isfile(pca_path):
print(
'[Latent Init] PCA already calculated before and saved at {}'.
format(pca_path))
Z = torch.load(pca_path)
else:
from sklearn.decomposition import PCA
# first, take a subset of train set to fit the PCA
X_pca = np.vstack([
X.cpu().numpy().reshape(len(X), -1)
for i, (X, _, _)
in zip(tqdm(range(args.n_pca // train_loader.batch_size), 'collect data for PCA'),
train_loader)
])
print("perform PCA...")
pca = PCA(n_components=args.d)
pca.fit(X_pca)
# then, initialize latent vectors to the pca projections of the complete dataset
Z = np.empty((len(train_loader.dataset), args.d))
for X, _, idx in tqdm(train_loader, 'pca projection'):
Z[idx] = pca.transform(X.cpu().numpy().reshape(len(X), -1))
elif args.init == 'random':
Z = np.random.randn(len(train_set), args.d)
Z = utils.project_l2_ball(Z)
model_generator = maybe_cuda(models.Generator(args.d))
loss_fn = utils.LapLoss(max_levels=3) if args.loss == 'lap_l1' else nn.MSELoss()
zi = maybe_cuda(torch.zeros((args.batch_size, args.d)))
zi = Variable(zi, requires_grad=True)
optimizer = SGD([
{'params': model_generator.parameters(), 'lr': args.lr_g},
{'params': zi, 'lr': args.lr_z}
])
Xi_val, _, idx_val = next(iter(val_loader))
utils.imsave(Img_dir+'target_%s_%s.png' % (args.cl,args.prfx),
make_grid(Xi_val.cpu() / 2. + 0.5, nrow=8).numpy().transpose(1, 2, 0))
for epoch in range(args.e):
losses = []
progress = tqdm(total=len(train_loader), desc='epoch % 3d' % epoch)
for i, (Xi, yi, idx) in enumerate(train_loader):
Xi = Variable(maybe_cuda(Xi))
zi.data = maybe_cuda(torch.FloatTensor(Z[idx.numpy()]))
optimizer.zero_grad()
rec = model_generator(zi)
loss = loss_fn(rec, Xi)
loss.backward()
optimizer.step()
Z[idx.numpy()] = utils.project_l2_ball(zi.data.cpu().numpy())
losses.append(loss.data[0])
progress.set_postfix({'loss': np.mean(losses[-100:])})
progress.update()
progress.close()
# visualize reconstructions
rec = model_generator(Variable(maybe_cuda(torch.FloatTensor(Z[idx_val.numpy()]))))
utils.imsave(Img_dir+'%s_%s_rec_epoch_%03d_%s.png' % (args.cl,args.prfx,epoch, args.init),
make_grid(rec.data.cpu() / 2. + 0.5, nrow=8).numpy().transpose(1, 2, 0))
print('Saving the model : epoch % 3d'%epoch)
utils.save_checkpoint({
'epoch': epoch + 1,
'state_dict': model_generator.state_dict(),
},
Model_dir + 'Glo_{}_z_{}_epch_{}_init_{}.pt'.format(args.cl,args.d, epoch, args.init))
def train(self, config):
if config.is_train: #判断是否训练
input_setup(config)
else:
input, label, _, _ = input_setup(config)
if config.is_train:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"train.h5")
train_data, train_label = read_data(data_dir)
#print(train_data.shape, train_label.shape)
# Stochastic gradient descent with the standard backpropagation
#self.train_op = tf.train.AdamOptimizer(config.learning_rate).minimize(self.loss)
var1 = tf.trainable_variables()[0:2] #w1,w2
var1 = var1 + tf.trainable_variables()[3:5] #b1,b2
var2 = tf.trainable_variables()[2] #w3
var2 = [var2, tf.trainable_variables()[5]] #b3
train_op1 = tf.train.AdamOptimizer(0.0001).minimize(self.loss,
var_list=var1)
train_op2 = tf.train.AdamOptimizer(0.00001).minimize(self.loss,
var_list=var2)
self.train_op = tf.group(train_op1, train_op2)
tf.global_variables_initializer().run()
counter = 0
start_time = time.time()
# if self.load(self.checkpoint_dir):
# print(" [*] Load SUCCESS")
# else:
# print(" [!] Load failed...")
if config.is_train:
print("Training...")
batch_idxs = len(train_data) // config.batch_size
#print(train_data[0 * config.batch_size: (0 + 1) * config.batch_size])
for ep in range(config.epoch):
# Run by batch images
#batch_idxs = len(train_data) // config.batch_size
for idx in range(0, batch_idxs):
batch_images = train_data[idx *
config.batch_size:(idx + 1) *
config.batch_size]
batch_labels = train_label[idx *
config.batch_size:(idx + 1) *
config.batch_size]
counter += 1
_, err = self.sess.run([self.train_op, self.loss],
feed_dict={
self.images: batch_images,
self.labels: batch_labels
})
if counter % 10 == 0:
print("Epoch: [%2d], step: [%2d], time: [%4.4f], loss: [%.8f]" \
% ((ep+1), counter, time.time()-start_time, err))
if counter % 400 == 0:
self.save(config.checkpoint_dir, counter)
#add term
else:
print("Testing...")
if self.load(self.checkpoint_dir):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
result = self.pred.eval(feed_dict={
self.images: input,
self.labels: label
})
#print(result.shape)
#result = merge(result*255, [nx, ny])
result = result.squeeze()
result = result * 255
image_path = os.path.join(os.getcwd(), config.sample_dir)
image_path = os.path.join(image_path, "test_image.png")
imsave(result, image_path)
def train():
data = load_data()
model = CGAN()
d_opt = tf.train.AdamOptimizer(learning_rate=conf.learning_rate).minimize(
model.d_loss, var_list=model.d_vars)
g_opt = tf.train.AdamOptimizer(learning_rate=conf.learning_rate).minimize(
model.g_loss, var_list=model.g_vars)
saver = tf.train.Saver()
counter = 0
start_time = time.time()
if not os.path.exists(conf.data_path + "/checkpoint"):
os.makedirs(conf.data_path + "/checkpoint")
if not os.path.exists(conf.output_path):
os.makedirs(conf.output_path)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
mpsnr_img = []
mpsnr_cond = []
with tf.Session(config=config) as sess:
if conf.model_path == "":
sess.run(tf.initialize_all_variables())
else:
saver.restore(sess, conf.model_path)
print conf.max_epoch
for epoch in xrange(conf.max_epoch):
train_data = data["train"]()
for img, cond, name in train_data:
img, cond = prepocess_train(img, cond)
_, m = sess.run([d_opt, model.d_loss],
feed_dict={
model.image: img,
model.cond: cond
})
_, m = sess.run([d_opt, model.d_loss],
feed_dict={
model.image: img,
model.cond: cond
})
_, M = sess.run([g_opt, model.g_loss],
feed_dict={
model.image: img,
model.cond: cond
})
counter += 1
print "Iterate [%d]: time: %4.4f, d_loss: %.8f, g_loss: %.8f" \
% (counter, time.time() - start_time, m, M)
if (epoch + 1) % conf.save_per_epoch == 0:
save_path = saver.save(
sess, conf.data_path + "/checkpoint/" + "model_%d.ckpt" %
(epoch + 1))
print "Model saved in file: %s" % save_path
mean_psnr_img = 0
mean_psnr_cond = 0
i = 0
test_data = data["test"]()
for img, cond, name in test_data:
pimg, pcond = prepocess_test(img, cond)
gen_img = sess.run(model.gen_img,
feed_dict={
model.image: pimg,
model.cond: pcond
})
gen_img = gen_img.reshape(gen_img.shape[1:])
gen_img = (gen_img + 1.) * 127.5
#print type(img), type(cond), type(gen_img), img.shape, cond.shape, gen_img.shape, img.dtype, cond.dtype, gen_img.dtype
mean_psnr_img = mean_psnr_img + skimage.measure.compare_psnr(
img, gen_img.astype(np.uint8))
mean_psnr_cond = mean_psnr_cond + skimage.measure.compare_psnr(
cond, gen_img.astype(np.uint8))
image = np.concatenate((gen_img, cond),
axis=1).astype(np.int)
i = i + 1
imsave(image, conf.output_path + "/%s" % name)
mean_psnr_img = mean_psnr_img / i
mpsnr_img.append(mean_psnr_img)
mean_psnr_cond = mean_psnr_cond / i
mpsnr_cond.append(mean_psnr_cond)
print mpsnr_cond
print mpsnr_img
plt.plot(mpsnr_cond)
plt.show()
def process_video(background_alpha=0.1, motion_thresh=0.5, skip_frames=0, fps_period_length=100):
utils.ensure_dir(config.experiment_data_frames)
utils.ensure_dir(config.experiment_output_frames, True)
mask = load_mask()
frames_list = os.listdir(config.experiment_data_frames)
frames_list.sort()
frames_list_to_store = frames_list
frames_list.reverse()
for i in xrange(skip_frames):
frames_list.pop()
background = np.flipud(mpimg.imread(os.path.join(config.experiment_data_frames, frames_list.pop()))).astype('int16')*mask
#background = np.mean(background,2)
#mask = np.mean(mask,2)
img_times = []
train_spotted = []
#prev = background
#prevs = []
fps_period_start = time.clock()
change_vals = []
count = 0
change_val = 0
while ( len(frames_list) > 0 ):# and count < 15400:
if count % fps_period_length == 0:
elapsed = (time.clock() - fps_period_start)
if elapsed > 0:
print('%d\t%.2f\t%.1f fps' % (count, change_val, fps_period_length/elapsed))
else:
print('Elapsed time should be positive but is %d' % (elapsed))
fps_period_start = time.clock()
img_filename = frames_list.pop()
img = np.flipud(mpimg.imread(os.path.join(config.experiment_data_frames, img_filename)))
img = img * mask
img_times.append(get_datetime_from_filename(img_filename))
#prevs.append(img)
#if len(prevs) > 10:
#prevs.pop()
#imshow(np.hstack((np.hstack((background, img)), img_without_background)))
img_without_background = abs(img.astype('float32') - background.astype('float32')) * mask
#diff = abs(img.astype('float32') - prev.astype('float32')) * mask
change_val = np.mean(img_without_background)#np.percentile(img_without_background.flatten(), 90)
change_vals.append(change_val)
if change_val > motion_thresh:
stacked_image = np.hstack((np.hstack((img, background)), img_without_background))
utils.imsave(os.path.join(config.experiment_output_frames, img_filename), stacked_image)
train_spotted.append(True)
else:
train_spotted.append(False)
# alternative update options in the following comments:
#if len(prevs) == 10: # update background
#beta = 1
#background_alpha_img = 1/(beta*(np.abs(background - img)**2) + 1/background_alpha) new
#background_alpha_img = 1/((beta*((background - img)**2) + 1)/background_alpha) old
#background_alpha_img = 1/((beta*((prevs[-1] - img)**2) + 1)/background_alpha)
#background = background*(1-background_alpha_img) + img*(background_alpha_img)
background = background*(1-background_alpha) + img*(background_alpha)
#prev = img
count += 1
if len(frames_list) == 0:
print('No more frames to process, unless we check and add some more')
datafile = shelve.open(os.path.join(config.experiment_output, 'shelve.data'))
datafile['img_times'] = img_times
datafile['train_spotted'] = train_spotted
datafile['change_vals'] = change_vals
datafile['frame_filenames'] = frames_list_to_store
datafile.close()
return datafile
def train(self, config):
if config.is_train:
input_setup(self.sess, config, "Train_ir")
input_setup(self.sess, config, "Train_vi")
# input_setup(self.sess, config,"Train_irtu")
# input_setup(self.sess,config,"Train_vitu")
input_setup(self.sess, config, "mask")
else:
nx_ir, ny_ir = input_setup(self.sess, config, "Test_ir")
nx_vi, ny_vi = input_setup(self.sess, config, "Test_vi")
nx_mask, ny_mask = input_setup(self.sess, config, "mask")
if config.is_train:
data_dir_ir = os.path.join('./{}'.format(config.checkpoint_dir),
"Train_ir", "train.h5")
data_dir_vi = os.path.join('./{}'.format(config.checkpoint_dir),
"Train_vi", "train.h5")
# data_dir_irtu = os.path.join('./{}'.format(config.checkpoint_dir), "Train_irtu","train.h5")
# data_dir_vitu = os.path.join('./{}'.format(config.checkpoint_dir), "Train_vitu","train.h5")
data_dir_mask = os.path.join('./{}'.format(config.checkpoint_dir),
"mask", "train.h5")
else:
data_dir_ir = os.path.join('./{}'.format(config.checkpoint_dir),
"Test_ir", "test.h5")
data_dir_vi = os.path.join('./{}'.format(config.checkpoint_dir),
"Test_vi", "test.h5")
data_dir_mask = os.path.join('./{}'.format(config.checkpoint_dir),
"mask", "test.h5")
train_data_ir, train_label_ir = read_data(data_dir_ir)
train_data_vi, train_label_vi = read_data(data_dir_vi)
# train_data_irtu, train_label_irtu = read_data(data_dir_irtu)
# train_data_vitu, train_label_vitu = read_data(data_dir_vitu)
train_data_mask, train_label_mask = read_data(data_dir_mask)
t_vars = tf.trainable_variables()
# self.d_vars = [var for var in t_vars if 'discriminator' in var.name]
# print(self.d_vars)
self.g_vars = [var for var in t_vars if 'fusion_model' in var.name]
print(self.g_vars)
with tf.name_scope('train_step'):
self.train_fusion_op = tf.train.AdamOptimizer(
config.learning_rate).minimize(self.g_loss,
var_list=self.g_vars)
# self.train_discriminator_op=tf.train.AdamOptimizer(config.learning_rate).minimize(self.d_loss,var_list=self.d_vars)
self.summary_op = tf.summary.merge_all()
self.train_writer = tf.summary.FileWriter(config.summary_dir +
'/train',
self.sess.graph,
flush_secs=60)
tf.initialize_all_variables().run()
counter = 0
start_time = time.time()
if config.is_train:
print("Training...")
for ep in xrange(config.epoch):
# Run by batch images
batch_idxs = len(train_data_ir) // config.batch_size
for idx in xrange(0, batch_idxs):
batch_images_ir = train_data_ir[idx *
config.batch_size:(idx +
1) *
config.batch_size]
batch_labels_ir = train_label_ir[idx *
config.batch_size:(idx +
1) *
config.batch_size]
batch_images_vi = train_data_vi[idx *
config.batch_size:(idx +
1) *
config.batch_size]
batch_labels_vi = train_label_vi[idx *
config.batch_size:(idx +
1) *
config.batch_size]
# batch_images_irtu = train_data_irtu[idx*config.batch_size : (idx+1)*config.batch_size]
# batch_labels_irtu = train_label_irtu[idx*config.batch_size : (idx+1)*config.batch_size]
# batch_images_vitu = train_data_vitu[idx*config.batch_size : (idx+1)*config.batch_size]
# batch_labels_vitu = train_label_vitu[idx*config.batch_size : (idx+1)*config.batch_size]
batch_images_mask = train_data_mask[idx *
config.batch_size:
(idx + 1) *
config.batch_size]
batch_labels_mask = train_label_mask[idx *
config.batch_size:
(idx + 1) *
config.batch_size]
counter += 1
# for i in range(2):
# _, err_d= self.sess.run([self.train_discriminator_op, self.d_loss], feed_dict={self.images_ir: batch_images_ir, self.images_vi: batch_images_vi,self.images_mask: batch_images_mask, self.labels_vi: batch_labels_vi,self.labels_ir:batch_labels_ir,self.labels_mask:batch_labels_mask})
_, err_g, summary_str = self.sess.run(
[self.train_fusion_op, self.g_loss, self.summary_op],
feed_dict={
self.images_ir: batch_images_ir,
self.images_vi: batch_images_vi,
self.images_mask: batch_images_mask,
self.labels_ir: batch_labels_ir,
self.labels_vi: batch_labels_vi,
self.labels_mask: batch_labels_mask
})
self.train_writer.add_summary(summary_str, counter)
if counter % 10 == 0:
print("Epoch: [%2d], step: [%2d], time: [%4.4f], loss_g:[%.8f]" \
% ((ep+1), counter, time.time()-start_time, err_g))
self.save(config.checkpoint_dir, ep)
else:
print("Testing...")
result = self.fusion_mask.eval(
feed_dict={
self.images_ir: train_data_ir,
self.labels_ir: train_label_ir,
self.images_vi: train_data_vi,
self.labels_vi: train_label_vi,
self.images_mask: train_data_mask,
self.labels_mask: train_label_mask
})
result = result * 127.5 + 127.5
result = merge(result, [nx_ir, ny_ir])
result = result.squeeze()
image_path = os.path.join(os.getcwd(), config.sample_dir)
image_path = os.path.join(image_path, "test_image.png")
imsave(result, image_path)
def train(self, config):
if config.is_train:
input_setup(self.sess, config)
else:
nx, ny = input_setup(self.sess, config)
if config.is_train:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"train.h5")
else:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"test.h5")
train_data, train_label = read_data(data_dir)
# Stochastic gradient descent with the standard backpropagation
self.train_op = tf.train.AdamOptimizer().minimize(self.loss)
tf.initialize_all_variables().run()
counter = 0
start_time = time.time()
if self.load(self.checkpoint_dir):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
if config.is_train:
print("Training...")
epoch_loss = 0
average_loss = 0
average_ssim = 0
for ep in xrange(config.epoch): #for each epoch
# Run by batch images
batch_idxs = len(
train_data
) // config.batch_size #TODO: check data loader of tensorflow and shuffle training data in each epoch
for idx in xrange(0, batch_idxs):
batch_images = train_data[idx *
config.batch_size:(idx + 1) *
config.batch_size]
batch_labels = train_label[idx *
config.batch_size:(idx + 1) *
config.batch_size]
counter += 1
_, err = self.sess.run([self.train_op, self.loss],
feed_dict={
self.images: batch_images,
self.labels: batch_labels
}) #update weights and biases
average_ssim += ssim(
self.pred.eval(feed_dict={
self.images: batch_images,
self.labels: batch_labels
})[:, 33:66, 33:66],
self.labels.eval(feed_dict={
self.images: batch_images,
self.labels: batch_labels
}),
multichannel=True) / batch_idxs
epoch_loss += err
average_loss = epoch_loss / float(batch_idxs)
PSNR = 10 * math.log10(1 / average_loss)
if counter % 10 == 0: #display training loss for every 10 batches
print("Epoch: [%2d], step: [%2d], time: [%4.4f], loss: [%.8f]" \
% ((ep+1), counter, time.time()-start_time, err))
if counter % (
batch_idxs * 10
) == 0: #save model for every 500 batches. Note: final model may not be saved!!!
self.save(config.checkpoint_dir, counter)
if counter % batch_idxs == 0:
with open('data.txt', 'a') as file:
file.write(
str(average_loss) + " , " + str(PSNR) + " , " +
str(average_ssim) + "\n")
#file.write(str(average_loss) + "\n")
epoch_loss = 0
average_loss = 0
average_ssim = 0
else:
print("Testing...")
result = self.pred.eval({
self.images: train_data,
self.labels: train_label
})
print(nx, ny)
result = merge(result, [nx, ny])
result = result.squeeze()
image_path = os.path.join(os.getcwd(), config.sample_dir)
image_path = os.path.join(image_path, "test_image.png")
imsave(result, image_path)
def train(self, config):
if config.is_train:
input_setup(self.sess, config)
else:
nx, ny = input_setup(self.sess, config)
if config.is_train:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"train.h5")
else:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"test.h5")
train_data, train_label = read_data(data_dir)
# Stochastic gradient descent with the standard backpropagation
self.train_op = tf.train.GradientDescentOptimizer(
config.learning_rate).minimize(self.loss)
tf.initialize_all_variables().run()
#For tf 0.12.1
#tf.global_variables_initializer()
counter = 0
start_time = time.time()
if self.load(self.checkpoint_dir):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
if config.is_train:
print("Training...")
for ep in xrange(config.epoch):
# Run by batch images
batch_idxs = len(train_data) // config.batch_size
for idx in xrange(0, batch_idxs):
batch_images = train_data[idx *
config.batch_size:(idx + 1) *
config.batch_size]
batch_labels = train_label[idx *
config.batch_size:(idx + 1) *
config.batch_size]
counter += 1
_, err = self.sess.run([self.train_op, self.loss],
feed_dict={
self.images: batch_images,
self.labels: batch_labels
})
if counter % 10 == 0:
print("Epoch: [%2d], step: [%2d], time: [%4.4f], loss: [%.8f]" \
% ((ep + 1), counter, time.time() - start_time, err))
if counter % 500 == 0:
self.save(config.checkpoint_dir, counter)
else:
print("Testing...")
print "Train data shape", train_data.shape
print "Train label shape", train_label.shape
result = self.pred.eval({
self.images: train_data,
self.labels: train_label
})
print "Result shape", result.shape
print "nx ny", nx, ny
image = merge(result, [nx, ny])
original_image = merge(train_label, [nx, ny])
interpolation = down_upscale(modcrop(original_image, config.scale),
scale=config.scale)
imsave(
original_image,
os.path.join(os.getcwd(), config.sample_dir, "original.bmp"),
config.is_RGB)
imsave(
interpolation,
os.path.join(os.getcwd(), config.sample_dir,
"interpolation.bmp"), config.is_RGB)
imsave(image,
os.path.join(os.getcwd(), config.sample_dir, "srcnn.bmp"),
config.is_RGB)
def train_network(args):
device = torch.device('cuda' if args.gpu_no >= 0 else 'cpu')
G_A2B = Generator().to(device).train()
G_B2A = Generator().to(device).train()
print("Load Generator", G_A2B)
D_A = Discriminator().to(device).train()
D_B = Discriminator().to(device).train()
print("Load Discriminator", D_A)
optimizer_G_A2B = torch.optim.Adam(G_A2B.parameters(),
lr=args.lr,
betas=(args.beta1, args.beta2))
optimizer_G_B2A = torch.optim.Adam(G_B2A.parameters(),
lr=args.lr,
betas=(args.beta1, args.beta2))
optimizer_D_A = torch.optim.Adam(D_A.parameters(),
lr=args.lr,
betas=(args.beta1, args.beta2))
optimizer_D_B = torch.optim.Adam(D_B.parameters(),
lr=args.lr,
betas=(args.beta1, args.beta2))
mse_criterion = nn.MSELoss()
l1_criterion = nn.L1Loss()
dataset = FacadeFolder(args.data_A, args.data_B, args.imsize,
args.cropsize, args.cencrop)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers)
loss_seq = {'G_A2B': [], 'G_B2A': [], 'D_A': [], 'D_B': [], 'Cycle': []}
buffer_fake_A = BufferN(50)
buffer_fake_B = BufferN(50)
for epoch in range(args.epoch):
"""
learning rate schedule
"""
for iteration, (item_A, item_B) in enumerate(dataloader, 1):
item_A, item_B = item_A.to(device), item_B.to(device)
"""
train discriminators
"""
with torch.no_grad():
fake_B = G_A2B(item_A)
fake_A = G_B2A(item_B)
buffer_fake_B.push(fake_B.detach())
N_fake_B_discrimination = D_B(
torch.cat(buffer_fake_B.get_buffer(), dim=0))
real_B_discrimination = D_B(item_B)
buffer_fake_A.push(fake_A.detach())
N_fake_A_discrimination = D_A(
torch.cat(buffer_fake_A.get_buffer(), dim=0))
real_A_discrimination = D_A(item_A)
loss_D_B_fake = mse_criterion(
N_fake_B_discrimination,
torch.zeros_like(N_fake_B_discrimination).to(device))
loss_D_B_real = mse_criterion(
real_B_discrimination,
torch.ones_like(real_B_discrimination).to(device))
loss_D_B = (loss_D_B_fake +
loss_D_B_real) * args.discriminator_weight
loss_seq['D_B'].append(loss_D_B.item())
loss_D_A_fake = mse_criterion(
N_fake_A_discrimination,
torch.zeros_like(N_fake_A_discrimination).to(device))
loss_D_A_real = mse_criterion(
real_A_discrimination,
torch.ones_like(real_A_discrimination).to(device))
loss_D_A = (loss_D_A_fake +
loss_D_A_real) * args.discriminator_weight
loss_seq['D_A'].append(loss_D_A.item())
optimizer_D_B.zero_grad()
loss_D_B.backward()
optimizer_D_B.step()
optimizer_D_A.zero_grad()
loss_D_A.backward()
optimizer_D_A.step()
"""
train generators
"""
fake_B = G_A2B(item_A)
fake_A = G_B2A(item_B)
fake_B_discrimination = D_B(fake_B)
fake_A_discrimination = D_A(fake_A)
B_from_fake_A = G_A2B(fake_A)
A_from_fake_B = G_B2A(fake_B)
loss_G_A2B_gan = mse_criterion(
fake_B_discrimination,
torch.ones_like(fake_B_discrimination).to(device))
loss_G_B2A_gan = mse_criterion(
fake_A_discrimination,
torch.ones_like(fake_A_discrimination).to(device))
loss_seq['G_A2B'].append(loss_G_A2B_gan.item())
loss_seq['G_B2A'].append(loss_G_B2A_gan.item())
loss_cyc = l1_criterion(B_from_fake_A, item_B) + l1_criterion(
A_from_fake_B, item_A)
loss_seq['Cycle'].append(loss_cyc.item())
loss_G = loss_G_A2B_gan + loss_G_B2A_gan + args.cyc_weight * loss_cyc
optimizer_G_A2B.zero_grad()
optimizer_G_B2A.zero_grad()
loss_G.backward()
optimizer_G_A2B.step()
optimizer_G_B2A.step()
"""
check training loss
"""
if iteration % args.check_iter == 0:
check_str = "%s: epoch:[%d/%d]\titeration:[%d/%d]" % (
time.ctime(), epoch, args.epoch, iteration,
len(dataloader))
for key, value in loss_seq.items():
check_str += "\t%s: %2.2f" % (
key, lastest_arverage_value(value))
print(check_str)
imsave(torch.cat([item_A, item_B, fake_B], dim=0),
args.save_path + 'training_image_A2B.jpg')
imsave(torch.cat([item_B, item_A, fake_A], dim=0),
args.save_path + 'training_image_B2A.jpg')
# save networks
torch.save(
{
'iteration': iteration,
'G_A2B_state_dict': G_A2B.state_dict(),
'G_B2A_state_dict': G_B2A.state_dict(),
'D_A_state_dict': D_A.state_dict(),
'D_B_state_dict': D_B.state_dict(),
'loss_seq': loss_seq
}, args.save_path + 'check_point.pth')
return None
def train(self, config):
# NOTE : if train, the nx, ny are ingnored
nx, ny = input_setup(config)
data_dir = checkpoint_dir(config)
input_, label_ = read_data(data_dir)
# Stochastic gradient descent with the standard backpropagation
# NOTE: learning rate decay
global_step = tf.Variable(0, trainable=False)
#learning_rate = tf.train.exponential_decay(config.learning_rate, global_step * config.batch_size, len(input_)*100, 0.1, staircase=True)
# NOTE: Clip gradient
opt = tf.train.AdamOptimizer(learning_rate=config.learning_rate)
grad_and_value = opt.compute_gradients(self.loss)
clip = tf.Variable(config.clip_grad, name='clip')
capped_gvs = [(tf.clip_by_value(grad, -(clip), clip), var)
for grad, var in grad_and_value]
self.train_op = opt.apply_gradients(capped_gvs,
global_step=global_step)
#self.train_op = tf.train.AdamOptimizer(learning_rate=config.learning_rate).minimize(self.loss)
tf.initialize_all_variables().run()
counter = 0
time_ = time.time()
self.load(config.checkpoint_dir)
# Train
if config.is_train:
print("Now Start Training...")
for ep in range(config.epoch):
# Run by batch images
batch_idxs = len(input_) // config.batch_size
for idx in range(0, batch_idxs):
batch_images = input_[idx * config.batch_size:(idx + 1) *
config.batch_size]
batch_labels = label_[idx * config.batch_size:(idx + 1) *
config.batch_size]
counter += 1
_, err = self.sess.run([self.train_op, self.loss],
feed_dict={
self.images: batch_images,
self.labels: batch_labels
})
if counter % 10 == 0:
print(
"Epoch: [%2d], step: [%2d], time: [%4.4f], loss: [%.8f]"
% ((ep + 1), counter, time.time() - time_, err))
if counter % 500 == 0:
self.save(config.checkpoint_dir, counter)
# Test
else:
print("Now Start Testing...")
result = self.pred.eval({self.images: input_}) + input_
image = merge(result, [nx, ny], self.c_dim)
checkimage(merge(result, [nx, ny], self.c_dim))
#checkimage(image_LR)
imsave(image, config.result_dir + '/result.png', config)
if args.gpu:
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
else:
DEVICE = torch.device('cpu')
print('selected device: '+str(DEVICE))
# import image
img = utils.imread(args.image_path, device=DEVICE)
# store image name
path = os.path.basename(args.image_path)
img_name = os.path.splitext(path)[0]
# add gaussian white noise
img_noisy = img + torch.tensor(args.stdv)*torch.randn(img.shape, device=DEVICE)
utils.imsave(img_name+'_noisy.png', img_noisy)
# extract patches
patch_size = [args.patch_size, args.patch_size]
patches = utils.im2pat(img_noisy, patch_size)
# create HDMI model
model = HDMI(patches, args.n_groups, args.stdv**2, device=DEVICE)
# run the EM algorithm
t = time.time()
print('run EM algorithm...')
for it in range(args.n_iter):
model.E_step()
model.M_step()
if args.verbose:
def train(model, train_loader, test_loader, mode='EDSR_Baseline', save_image_every=50, save_model_every=10, test_model_every=1, epoch_start=0, num_epochs=1000, device=None, refresh=True, scale=2):
if device is None:
device = 'cuda' if torch.cuda.is_available() else 'cpu'
today = datetime.datetime.now().strftime('%Y.%m.%d')
result_dir = f'./results/{today}/{mode}'
weight_dir = f'./weights/{today}/{mode}'
logger_dir = f'./logger/{today}_{mode}'
csv = f'./hist_{today}_{mode}.csv'
if refresh:
try:
shutil.rmtree(result_dir)
shutil.rmtree(weight_dir)
shutil.rmtree(logger_dir)
except FileNotFoundError:
pass
os.makedirs(result_dir, exist_ok=True)
os.makedirs(weight_dir, exist_ok=True)
os.makedirs(logger_dir, exist_ok=True)
logger = SummaryWriter(log_dir=logger_dir, flush_secs=2)
model = model.to(device)
params = list(model.parameters())
optim = torch.optim.Adam(params, lr=1e-4)
scheduler = torch.optim.lr_scheduler.StepLR(optim, step_size=1000, gamma= 0.99)
criterion = torch.nn.L1Loss()
GMSD = GMSD_quality().to(device)
mshf = MSHF(3, 3).to(device)
down = torch.nn.MaxPool2d(scale)
upnn = torch.nn.UpsamplingNearest2d(scale_factor=scale)
start_time = time.time()
print(f'Training Start || Mode: {mode}')
step = 0
pfix = OrderedDict()
pfix_test = OrderedDict()
hist = dict()
hist['mode'] = f'{today}_{mode}'
for key in ['epoch', 'psnr', 'ssim', 'ms-ssim']:
hist[key] = []
blurs = {}
ksizes = [3, 5, 7]
sigmas = [0.1, 0.2, 0.4, 0.8, 1.0]
for ksize in ksizes:
blurs[ksize] = {}
for sigma in sigmas:
blurs[ksize][sigma] = Blur(ksize=ksize, sigma=sigma).to(device)
noise_sigma = 0
for epoch in range(epoch_start, epoch_start+num_epochs):
if epoch == 0:
torch.save(model.state_dict(), f'{weight_dir}/epoch_{epoch+1:04d}.pth')
if epoch == 0:
with torch.no_grad():
with tqdm(test_loader, desc=f'{mode} || Warming Up || Test Epoch {epoch}/{num_epochs}', position=0, leave=True) as pbar_test:
psnrs = []
ssims = []
msssims = []
for lr, hr, fname in pbar_test:
# lr = lr.to(device)
hr = hr.to(device)
lr = upnn(down(hr))
blur = blurs[max(ksizes)][max(sigmas)]
lr_input = blur(lr)
lr_input = lr_input + torch.rand_like(lr, device=lr.device)*noise_sigma
_, features = model(lr_input)
dr = features[0]
# sr = quantize(sr)
psnr, ssim, msssim = evaluate(hr, dr)
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix_test['psnr'] = f'{psnr:.4f}'
pfix_test['ssim'] = f'{ssim:.4f}'
pfix_test['msssim'] = f'{msssim:.4f}'
pfix_test['psnr_mean'] = f'{psnr_mean:.4f}'
pfix_test['ssim_mean'] = f'{ssim_mean:.4f}'
pfix_test['msssim_mean'] = f'{msssim_mean:.4f}'
pbar_test.set_postfix(pfix_test)
if len(psnrs) > 1: break
with tqdm(train_loader, desc=f'{mode} || Epoch {epoch+1}/{num_epochs}', position=0, leave=True) as pbar:
psnrs = []
ssims = []
msssims = []
losses = []
for lr, hr, _ in pbar:
# lr = lr.to(device)
_, _, w, h = lr.shape
hr = hr[:,:,:w,:h].to(device)
lr = upnn(down(hr))
# prediction
ksize_ = random.choice(ksizes)
sigma_ = random.choice(sigmas)
blur = blurs[ksize_][sigma_]
# dnd = random.choice(['blur', 'noise', 'blur_and_noise'])
dnd = 'blur'
if dnd == 'blur':
lr_input = blur(lr)
elif dnd == 'noise':
lr_input = hr_nn + torch.rand_like(lr, device=lr.device)*noise_sigma
else:
lr_input = blur(lr)
lr_input = lr_input + torch.rand_like(lr, device=lr.device)*noise_sigma
_, features = model(lr_input)
dr = features[0]
gmsd = GMSD(hr, dr)
# training
loss = criterion(dr, hr)
loss_tot = loss
optim.zero_grad()
loss_tot.backward()
optim.step()
scheduler.step()
# training history
elapsed_time = time.time() - start_time
elapsed = sec2time(elapsed_time)
pfix['Step'] = f'{step+1}'
pfix['Loss'] = f'{loss.item():.4f}'
psnr, ssim, msssim = evaluate(hr, dr)
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix['PSNR'] = f'{psnr:.2f}'
pfix['SSIM'] = f'{ssim:.4f}'
# pfix['MSSSIM'] = f'{msssim:.4f}'
pfix['PSNR_mean'] = f'{psnr_mean:.2f}'
pfix['SSIM_mean'] = f'{ssim_mean:.4f}'
# pfix['MSSSIM_mean'] = f'{msssim_mean:.4f}'
free_gpu = get_gpu_memory()[0]
pfix['free GPU'] = f'{free_gpu}MiB'
pfix['Elapsed'] = f'{elapsed}'
pbar.set_postfix(pfix)
losses.append(loss.item())
if step % save_image_every == 0:
imsave([lr_input[0], dr[0], hr[0], gmsd[0]], f'{result_dir}/epoch_{epoch+1}_iter_{step:05d}.jpg')
step += 1
logger.add_scalar("Loss/train", np.array(losses).mean(), epoch+1)
logger.add_scalar("PSNR/train", psnr_mean, epoch+1)
logger.add_scalar("SSIM/train", ssim_mean, epoch+1)
if (epoch+1) % save_model_every == 0:
torch.save(model.state_dict(), f'{weight_dir}/epoch_{epoch+1:04d}.pth')
if (epoch+1) % test_model_every == 0:
with torch.no_grad():
with tqdm(test_loader, desc=f'{mode} || Test Epoch {epoch+1}/{num_epochs}', position=0, leave=True) as pbar_test:
psnrs = []
ssims = []
msssims = []
for lr, hr, fname in pbar_test:
fname = fname[0].split('/')[-1].split('.pt')[0]
# lr = lr.to(device)
hr = hr.to(device)
lr = upnn(down(hr))
blur = blurs[max(ksizes)][max(sigmas)]
lr_input = blur(lr)
lr_input = lr_input + torch.rand_like(lr, device=lr.device)*noise_sigma
_, features = model(lr_input)
dr = features[0]
mshf_lr = mshf(hr)
mshf_dr = mshf(dr)
gmsd = GMSD(hr, dr)
psnr, ssim, msssim = evaluate(hr, dr)
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix_test['psnr'] = f'{psnr:.4f}'
pfix_test['ssim'] = f'{ssim:.4f}'
pfix_test['msssim'] = f'{msssim:.4f}'
pfix_test['psnr_mean'] = f'{psnr_mean:.4f}'
pfix_test['ssim_mean'] = f'{ssim_mean:.4f}'
pfix_test['msssim_mean'] = f'{msssim_mean:.4f}'
pbar_test.set_postfix(pfix_test)
imsave([lr_input[0], dr[0], hr[0], gmsd[0]], f'{result_dir}/{fname}.jpg')
mshf_vis = torch.cat((torch.cat([mshf_dr[:,i,:,:] for i in range(mshf_dr.shape[1])], dim=-1),
torch.cat([mshf_lr[:,i,:,:] for i in range(mshf_lr.shape[1])], dim=-1)), dim=-2)
imsave(mshf_vis, f'{result_dir}/MSHF_{fname}.jpg')
hist['epoch'].append(epoch+1)
hist['psnr'].append(psnr_mean)
hist['ssim'].append(ssim_mean)
hist['ms-ssim'].append(msssim_mean)
logger.add_scalar("PSNR/test", psnr_mean, epoch+1)
logger.add_scalar("SSIM/test", ssim_mean, epoch+1)
logger.add_scalar("MS-SSIM/test", msssim_mean, epoch+1)
df = pd.DataFrame(hist)
df.to_csv(csv)
def train(self, config):
# NOTE : if train, the nx, ny are ingnored
#print("config.is_train:", config.is_train)
nx, ny, original_shape = input_setup(config)
#print("nx, ny, original_shape:", nx, ny, original_shape)
data_dir = checkpoint_dir(config)
print("reading data..")
input_, label_ = read_data(data_dir)
print("input_", input_.shape)
merged_summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter("./log/train_300") #, self.sess.graph)
#self.summary_writer = tf.summary.FileWriter("./log/", tf.get_default_graph())
# Stochastic gradient descent with the standard backpropagation
#self.train_op = tf.train.GradientDescentOptimizer(config.learning_rate).minimize(self.loss)
self.optimizer = tf.train.AdamOptimizer(learning_rate=config.learning_rate)
self.train_op = self.optimizer.minimize(self.loss)
#self.train_op = tf.train.AdamOptimizer(learning_rate=config.learning_rate).minimize(self.loss)
tf.initialize_all_variables().run()
counter = 0
time_ = time.time()
self.load(config.checkpoint_dir)
# Train
if config.is_train:
print("Now Start Training...")
#for ep in range(config.epoch):
for ep in range(300, 1000+1, 1):
#print("ep:", ep)
#sys.exit()
loss_summary_per_batch = []
# Run by batch images
batch_idxs = len(input_) // config.batch_size
for idx in range(0, batch_idxs):
batch_images = input_[idx * config.batch_size : (idx + 1) * config.batch_size]
batch_labels = label_[idx * config.batch_size : (idx + 1) * config.batch_size]
counter += 1
_, err, summary = self.sess.run([self.train_op, self.loss, merged_summary_op], feed_dict={self.images: batch_images, self.labels: batch_labels})
summary_pb = tf.summary.Summary()
summary_pb.ParseFromString(summary)
summaries = {}
for val in summary_pb.value:
summaries[val.tag] = val.simple_value
#print("summaries:", summaries)
loss_summary_per_batch.append(summaries['loss'])
summary_writer.add_summary(summary, (ep) * counter)
#self.summary_writer.add_summary(summary, (ep+1) * counter)
if counter % 1000 == 0:
print("Epoch: [%2d], step: [%2d], time: [%4.4f], loss: [%.8f]" % ((ep), counter, time.time()-time_, err))
#print(label_[1] - self.pred.eval({self.images: input_})[1],'loss:]',err)
#print("Epoch: [%2d], loss: [%.8f]", (ep+1), tf.reduce_mean(tf.square(label_ - self.pred.eval({self.images: input_}))))
#if counter % 500 == 0:
#if counter % 20 == 0:
# self.save(config.checkpoint_dir, counter)
if ep ==0 or ep % 10 == 0:
self.save(config.checkpoint_dir, ep)
###
'''
try:
config.is_train = False
nx_, ny_, original_shape_ = input_setup(config)
data_dir_ = checkpoint_dir(config)
input__, label__ = read_data(data_dir_)
print("Now Start Testing...")
result_ = self.pred.eval({self.images: input__})
image_ = merge(result_, [nx_, ny_], self.c_dim)
print("image after merge:", image_.shape)
print("[nx_, ny_]:", [nx_, ny_])
print("original_shape:", original_shape_)
print(type(image__), type(original_shape_[0]), type(original_shape_[1]))
cropped_img_ = crop_center(image, original_shape_[0], original_shape_[1])
print("cropped_img_:", cropped_img_.shape)
imsave(image_, config.result_dir + '/result-' + ep + '.png', config)
imsave(cropped_img_, config.result_dir + '/result_crop-' + ep + '.png', config)
except:
print("Unexpected error while evaluating image:", sys.exc_info()[0])
config.is_train = True
'''
###
print("loss per epoch[%d] loss: [%.8f]" % ((ep), np.mean(loss_summary_per_batch)))
summary_writer.add_summary(tf.Summary(value=[tf.Summary.Value(tag="loss per epoch", simple_value=np.mean(loss_summary_per_batch)),]), ((ep)))
summary_writer.add_summary(tf.Summary(value=[tf.Summary.Value(tag="learning rate", simple_value=self.optimizer._lr),]), ((ep)))
#print("learning rate:", self.optimizer._lr)
# Test
else:
print("Now Start Testing...")
#print("nx","ny",nx,ny)
result = self.pred.eval({self.images: input_})
print("result:", result.shape)
#print(label_[1] - result[1])
image = merge(result, [nx, ny], self.c_dim)
print("image after merge:", image.shape)
print("[nx, ny]:", [nx, ny])
print("original_shape:", original_shape)
print(type(image), type(original_shape[0]), type(original_shape[1]))
cropped_img = crop_center(image, original_shape[0], original_shape[1])
print("cropped_img:", cropped_img.shape)
#image_LR = merge(input_, [nx, ny], self.c_dim)
#checkimage(image_LR)
imsave(image, config.result_dir+'/result.png', config)
imsave(cropped_img, config.result_dir+'/result_crop.png', config)
def train():
data = load_data()
model = CGAN()
d_opt = tf.train.AdamOptimizer(learning_rate=conf.learning_rate).minimize(
model.d_loss, var_list=model.d_vars)
g_opt = tf.train.AdamOptimizer(learning_rate=conf.learning_rate).minimize(
model.g_loss, var_list=model.g_vars)
saver = tf.train.Saver()
start_time = time.time()
if not os.path.exists(conf.data_path + "/checkpoint"):
os.makedirs(conf.data_path + "/checkpoint")
if not os.path.exists(conf.output_path):
os.makedirs(conf.output_path)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
if conf.model_path_train == "":
sess.run(tf.global_variables_initializer())
else:
saver.restore(sess, conf.model_path_train)
for epoch in xrange(conf.max_epoch):
counter = 0
train_data = data["train"]()
for img, cond, name in train_data:
img, cond = prepocess_train(img, cond)
_, m = sess.run([d_opt, model.d_loss],
feed_dict={
model.image: img,
model.cond: cond
})
_, m = sess.run([d_opt, model.d_loss],
feed_dict={
model.image: img,
model.cond: cond
})
_, M = sess.run([g_opt, model.g_loss],
feed_dict={
model.image: img,
model.cond: cond
})
counter += 1
if counter % 50 == 0:
print "Epoch [%d], Iteration [%d]: time: %4.4f, d_loss: %.8f, g_loss: %.8f" \
% (epoch, counter, time.time() - start_time, m, M)
if (epoch + 1) % conf.save_per_epoch == 0:
save_path = saver.save(
sess, conf.data_path + "/checkpoint/" + "model_%d.ckpt" %
(epoch + 1))
print "Model saved in file: %s" % save_path
test_data = data["test"]()
for img, cond, name in test_data:
pimg, pcond = prepocess_test(img, cond)
gen_img = sess.run(model.gen_img,
feed_dict={
model.image: pimg,
model.cond: pcond
})
gen_img = gen_img.reshape(gen_img.shape[1:])
gen_img = (gen_img + 1.) * 127.5
image = np.concatenate((gen_img, cond),
axis=1).astype(np.int)
imsave(image, conf.output_path + "/%s" % name)
def train(self, config):
if config.is_train:
input_setup(self.sess, config)
else:
nx, ny, img_name = input_setup(self.sess, config)
if config.is_train:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"train.h5")
else:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"test.h5")
train_data, train_label = read_data(data_dir)
if self.load(self.checkpoint_dir):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
if config.is_train:
print("Training...")
# Stochastic gradient descent with the standard backpropagation
self.train_op = tf.train.GradientDescentOptimizer(
config.learning_rate).minimize(self.loss)
tf.initialize_all_variables().run()
counter = 0
start_time = time.time()
for ep in xrange(config.epoch):
# Run by batch images
batch_idxs = len(train_data) // config.batch_size
for idx in xrange(0, batch_idxs):
batch_images = train_data[idx *
config.batch_size:(idx + 1) *
config.batch_size]
batch_labels = train_label[idx *
config.batch_size:(idx + 1) *
config.batch_size]
counter += 1
_, err = self.sess.run([self.train_op, self.loss],
feed_dict={
self.images: batch_images,
self.labels: batch_labels
})
if counter % 10 == 0:
print("Epoch: [%2d], step: [%2d], time: [%4.4f], loss: [%.8f]" \
% ((ep+1), counter, time.time()-start_time, err))
if counter % 500 == 0:
self.save(config.checkpoint_dir, counter)
else:
print("Testing...")
print("shape:", train_data.shape)
result = self.pred.eval({
self.images: train_data,
self.labels: train_label
})
#print("res shape:", result.shape)
result = merge(result, [nx, ny])
result = result.squeeze()
result = (result * 65535.).astype(
np.uint16
) #added for writing tiff image and restore back the original color range
#print("res is:", result[0:5,0:5])
output_path = os.path.join(os.getcwd(), config.sample_dir)
image_path = os.path.join(output_path, "test_srcnn_" + img_name +
".tiff") #changed from png
imsave(result, image_path)
# this part added for directly comparing the PSNR
label_path = os.path.join(output_path,
"test_ori_" + img_name + ".tiff")
bicubic_path = os.path.join(output_path,
"test_bicubic_" + img_name + ".tiff")
bicubic_img = imread(bicubic_path, is_grayscale=True)
label_img = imread(label_path, is_grayscale=True)
output_img = imread(image_path, is_grayscale=True)
#compute psnr
bicubic_psnr = psnr(label_img, bicubic_img)
srcnn_psnr = psnr(label_img, output_img)
#bicubic_img = bicubic_img.astype(np.float)
#output_img = output_img.astype(np.float)
#label_img = label_img.astype(np.float)
#compute ssim
bicubic_ssim = ssim(label_img, bicubic_img)
srcnn_ssim = ssim(label_img, output_img)
print("bicubic PSNR for " + img_name +
": [{}]".format(bicubic_psnr))
print("SRCNN PSNR for " + img_name + ": [{}]".format(srcnn_psnr))
print("bicubic SSIM for " + img_name +
": [{}]".format(bicubic_ssim))
print("SRCNN SSIM for" + img_name + ": [{}]".format(srcnn_ssim))
def train(self, config):
if config.is_train:
input_setup(self.sess, config, "Train_ir")
input_setup(self.sess, config, "Train_vi")
else:
nx_ir, ny_ir = input_setup(self.sess, config, "Test_ir")
nx_vi, ny_vi = input_setup(self.sess, config, "Test_vi")
if config.is_train:
data_dir_ir = os.path.join('./{}'.format(config.checkpoint_dir),
"Train_ir", "train.h5")
data_dir_vi = os.path.join('./{}'.format(config.checkpoint_dir),
"Train_vi", "train.h5")
else:
data_dir_ir = os.path.join('./{}'.format(config.checkpoint_dir),
"Test_ir", "test.h5")
data_dir_vi = os.path.join('./{}'.format(config.checkpoint_dir),
"Test_vi", "test.h5")
train_data_ir, train_label_ir = read_data(data_dir_ir)
train_data_vi, train_label_vi = read_data(data_dir_vi)
#找训练时更新的变量组（判决器和生成器是分开训练的，所以要找到对应的变量）
t_vars = tf.trainable_variables()
self.d_vars = [var for var in t_vars if 'discriminator' in var.name]
print(self.d_vars)
self.g_vars = [var for var in t_vars if 'fusion_model' in var.name]
print(self.g_vars)
# clip_ops = []
# for var in self.d_vars:
# clip_bounds = [-.01, .01]
# clip_ops.append(
# tf.assign(
# var,
# tf.clip_by_value(var, clip_bounds[0], clip_bounds[1])
# )
# )
# self.clip_disc_weights = tf.group(*clip_ops)
# Stochastic gradient descent with the standard backpropagation
with tf.name_scope('train_step'):
self.train_fusion_op = tf.train.AdamOptimizer(
config.learning_rate).minimize(self.g_loss_total,
var_list=self.g_vars)
#self.train_discriminator_op=tf.train.AdamOptimizer(config.learning_rate).minimize(self.d_loss,var_list=self.d_vars)
#将所有统计的量合起来
self.summary_op = tf.summary.merge_all()
#生成日志文件
self.train_writer = tf.summary.FileWriter(config.summary_dir +
'/train',
self.sess.graph,
flush_secs=60)
tf.initialize_all_variables().run()
counter = 0
start_time = time.time()
# if self.load(self.checkpoint_dir):
# print(" [*] Load SUCCESS")
# else:
# print(" [!] Load failed...")
if config.is_train:
print("Training...")
for ep in xrange(config.epoch):
# Run by batch images
batch_idxs = len(train_data_ir) // config.batch_size
for idx in xrange(0, batch_idxs):
batch_images_ir = train_data_ir[idx *
config.batch_size:(idx +
1) *
config.batch_size]
batch_labels_ir = train_label_ir[idx *
config.batch_size:(idx +
1) *
config.batch_size]
batch_images_vi = train_data_vi[idx *
config.batch_size:(idx +
1) *
config.batch_size]
batch_labels_vi = train_label_vi[idx *
config.batch_size:(idx +
1) *
config.batch_size]
counter += 1
#for i in range(2):
# _, err_d= self.sess.run([self.train_discriminator_op, self.d_loss], feed_dict={self.images_ir: batch_images_ir, self.images_vi: batch_images_vi, self.labels_vi: batch_labels_vi,self.labels_ir:batch_labels_ir})
# self.sess.run(self.clip_disc_weights)
_, err_g, summary_str = self.sess.run(
[
self.train_fusion_op, self.g_loss_total,
self.summary_op
],
feed_dict={
self.images_ir: batch_images_ir,
self.images_vi: batch_images_vi,
self.labels_ir: batch_labels_ir,
self.labels_vi: batch_labels_vi
})
#将统计的量写到日志文件里
self.train_writer.add_summary(summary_str, counter)
if counter % 10 == 0:
print("Epoch: [%2d], step: [%2d], time: [%4.4f], loss_g:[%.8f]" \
% ((ep+1), counter, time.time()-start_time, err_g))
#print(a)
self.save(config.checkpoint_dir, ep)
else:
print("Testing...")
result = self.fusion_image.eval(
feed_dict={
self.images_ir: train_data_ir,
self.labels_ir: train_label_ir,
self.images_vi: train_data_vi,
self.labels_vi: train_label_vi
})
result = result * 127.5 + 127.5
result = merge(result, [nx_ir, ny_ir])
result = result.squeeze()
image_path = os.path.join(os.getcwd(), config.sample_dir)
image_path = os.path.join(image_path, "test_image.png")
imsave(result, image_path)
def train(self, config):
if config.is_train:
input_setup(self.sess, config) #读取图像并制作训练对，存储为.h5文件
else:
nx, ny = input_setup(self.sess, config) #读取图像，放大并减去多余边
if config.is_train:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"train.h5") #读取训练数据文件路径
else:
data_dir = os.path.join('./{}'.format(config.checkpoint_dir),
"test.h5")
train_data, train_label = read_data(data_dir) #读取训练数据
# Stochastic gradient descent with the standard backpropagation
self.train_op = tf.train.GradientDescentOptimizer(
config.learning_rate).minimize(self.loss)
tf.initialize_all_variables().run()
counter = 0
start_time = time.time()
if self.load(self.checkpoint_dir):
print(" [*] Load SUCCESS")
else:
print(" [!] Load failed...")
if config.is_train:
print("Training...")
for ep in xrange(config.epoch):
# Run by batch images
batch_idxs = len(train_data) // config.batch_size
for idx in xrange(0, batch_idxs):
batch_images = train_data[idx *
config.batch_size:(idx + 1) *
config.batch_size]
batch_labels = train_label[idx *
config.batch_size:(idx + 1) *
config.batch_size]
counter += 1
_, err = self.sess.run([self.train_op, self.loss],
feed_dict={
self.images: batch_images,
self.labels: batch_labels
})
if counter % 10 == 0:
print("Epoch: [%2d], step: [%2d], time: [%4.4f], loss: [%.8f]" \
% ((ep+1), counter, time.time()-start_time, err))
if counter % 500 == 0:
self.save(config.checkpoint_dir, counter)
#注意这个是测试过程，如果真实使用，应该用label（原图）进行计算（已更正）
else:
print("Testing...")
# result = self.pred.eval({self.images: train_data, self.labels: train_label})#源代码
result = self.pred.eval({self.images: train_data})
result = merge(result, [nx, ny])
result = result.squeeze()
# result = scipy.ndimage.interpolation.zoom(result, (2/1.), prefilter=False)
image_path = os.path.join(os.getcwd(),
config.sample_dir) #以下为存储结果图片
image_path = os.path.join(
image_path, "output" + str(config.image_index) + ".png")
imsave(result, image_path)
G.load_state_dict(
torch.load("Checkpoints/G_22.pt", map_location=torch.device('cpu')))
GR.load_state_dict(
torch.load("Checkpoints/GR_7.pt", map_location=torch.device('cpu')))
img = plt.imread(path_i)
faces = detect_face(img)
if len(faces) == 0:
print("No faces detected")
exit()
resz = cv2.resize(faces[0], (100, 100))
plt.imsave("out_ld.png", resz)
resz = resz.reshape(1, 100, 100, 3)
resz = np.transpose(resz, (0, 3, 1, 2))
resz = torch.from_numpy(resz)
resz = resz.float()
inp = scale(resz)
out1 = infer(G, inp)
out2 = infer(GR, inp)
inp = rescale(inp)
out1 = rescale(out1)
out2 = rescale(out2)
w = 0.5
out = out1 * w + out2 * (1 - w)
imsave(out[0], "out_hd.png")
def main():
parser = build_parser()
options = parser.parse_args()
# Check VGG path
if not os.path.isfile(options.network):
parser.error(
"Network %s does not exist. (Did you forget to download it?)" %
options.network)
# Load Content and styles images
# And resize the style to the content size
content = utils.imread(options.content)
if options.semantic_transfer:
masks = utils.maskread(options.masks)
sem_styles = [utils.imread(s) for s in options.semantic_styles]
for idx, img in enumerate(sem_styles):
sem_styles[idx] = scipy.misc.imresize(img, content.shape)
style = None
else:
style = utils.imread(options.style)
style = scipy.misc.imresize(style, content.shape)
masks = None
sem_styles = None
# Image initialisation: noise or content image?
initial = options.initial
if initial is not None:
initial = scipy.misc.imresize(utils.imread(initial), content.shape,
'bilinear')
else:
initial = None
# Checkpoint format
if options.checkpoint_output and "%s" not in options.checkpoint_output:
parser.error("To save intermediate images, the checkpoint output "
"parameter must contain `%s` (e.g. `foo%s.jpg`)")
# Begin optimization
for iteration, image in stylize(
network=options.network,
semantic_transfer=options.semantic_transfer,
initial=initial,
content=content,
style=style,
mask=masks,
sem_style_images=sem_styles,
gradient_capping=options.gradient_capping,
capped_objs=options.capped_objs,
auto_tuning=options.auto_tuning,
erosion=options.erosion,
preserve_colors=options.preserve_colors,
iterations=options.iterations,
content_weight=options.content_weight,
style_weight=options.style_weight,
tv_weight=options.tv_weight,
learning_rate=options.learning_rate,
print_iterations=options.print_iterations,
checkpoint_iterations=options.checkpoint_iterations):
output_file = None
combined_rgb = image
if iteration is not None:
if options.checkpoint_output:
output_file = options.checkpoint_output % iteration
else:
output_file = options.output
if output_file:
utils.imsave(output_file, combined_rgb)
def train(model,
train_loader,
test_loader,
mode='EDSR_Baseline',
save_image_every=50,
save_model_every=10,
test_model_every=1,
epoch_start=0,
num_epochs=1000,
device=None,
refresh=True,
scale=2):
if device is None:
device = 'cuda' if torch.cuda.is_available() else 'cpu'
today = datetime.datetime.now().strftime('%Y.%m.%d')
result_dir = f'./results/{today}/{mode}'
weight_dir = f'./weights/{today}/{mode}'
logger_dir = f'./logger/{today}_{mode}'
csv = f'./hist_{today}_{mode}.csv'
if refresh:
try:
shutil.rmtree(result_dir)
shutil.rmtree(weight_dir)
shutil.rmtree(logger_dir)
except FileNotFoundError:
pass
os.makedirs(result_dir, exist_ok=True)
os.makedirs(weight_dir, exist_ok=True)
os.makedirs(logger_dir, exist_ok=True)
logger = SummaryWriter(log_dir=logger_dir, flush_secs=2)
model = model.to(device)
params = list(model.parameters())
optim = torch.optim.Adam(params, lr=1e-4)
scheduler = torch.optim.lr_scheduler.StepLR(optim,
step_size=1000,
gamma=0.99)
criterion = torch.nn.L1Loss()
GMSD = GMSD_quality().to(device)
opening = Opening().to(device)
blur = Blur().to(device)
mshf = MSHF(3, 3).to(device)
start_time = time.time()
print(f'Training Start || Mode: {mode}')
step = 0
pfix = OrderedDict()
pfix_test = OrderedDict()
hist = dict()
hist['mode'] = f'{today}_{mode}'
for key in ['epoch', 'psnr', 'ssim', 'ms-ssim']:
hist[key] = []
soft_mask = False
# hf_kernel = get_hf_kernel(mode='high')
for epoch in range(epoch_start, epoch_start + num_epochs):
if epoch == 0:
torch.save(model.state_dict(),
f'{weight_dir}/epoch_{epoch+1:04d}.pth')
if epoch == 0:
with torch.no_grad():
with tqdm(
test_loader,
desc=
f'{mode} || Warming Up || Test Epoch {epoch}/{num_epochs}',
position=0,
leave=True) as pbar_test:
psnrs = []
ssims = []
msssims = []
for lr, lr_hf, hr, fname in pbar_test:
lr = lr.to(device)
hr = hr.to(device)
lr_hf = lr_hf.to(device)
sr, deep = model(lr, lr_hf)
sr = quantize(sr)
psnr, ssim, msssim = evaluate(hr, sr)
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix_test['psnr'] = f'{psnr:.4f}'
pfix_test['ssim'] = f'{ssim:.4f}'
pfix_test['msssim'] = f'{msssim:.4f}'
pfix_test['psnr_mean'] = f'{psnr_mean:.4f}'
pfix_test['ssim_mean'] = f'{ssim_mean:.4f}'
pfix_test['msssim_mean'] = f'{msssim_mean:.4f}'
pbar_test.set_postfix(pfix_test)
if len(psnrs) > 1: break
with tqdm(train_loader,
desc=f'{mode} || Epoch {epoch+1}/{num_epochs}',
position=0,
leave=True) as pbar:
psnrs = []
ssims = []
msssims = []
losses = []
for lr, lr_hf, hr, _ in pbar:
lr = lr.to(device)
hr = hr.to(device)
lr_hf = lr_hf.to(device)
# prediction
sr, deep = model(lr, lr_hf)
gmsd = GMSD(hr, sr)
sr_ = quantize(sr)
psnr, ssim, msssim = evaluate(hr, sr_)
if psnr >= 40 - 2 * scale:
soft_mask = True
else:
soft_mask = False
if soft_mask:
with torch.no_grad():
for _ in range(10):
gmsd = opening(gmsd)
gmask = gmsd / gmsd.max()
gmask = (gmask > 0.2) * 1.0
gmask = blur(gmask)
gmask = (gmask - gmask.min()) / (gmask.max() -
gmask.min() + 1e-7)
gmask = (gmask + 0.25) / 1.25
gmask = gmask.detach()
# training
loss = criterion(sr * gmask, hr * gmask)
else:
loss = criterion(sr, hr)
# training
loss = criterion(sr, hr)
loss_tot = loss
optim.zero_grad()
loss_tot.backward()
optim.step()
scheduler.step()
# training history
elapsed_time = time.time() - start_time
elapsed = sec2time(elapsed_time)
pfix['Step'] = f'{step+1}'
pfix['Loss'] = f'{loss.item():.4f}'
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix['PSNR'] = f'{psnr:.2f}'
pfix['SSIM'] = f'{ssim:.4f}'
# pfix['MSSSIM'] = f'{msssim:.4f}'
pfix['PSNR_mean'] = f'{psnr_mean:.2f}'
pfix['SSIM_mean'] = f'{ssim_mean:.4f}'
# pfix['MSSSIM_mean'] = f'{msssim_mean:.4f}'
free_gpu = get_gpu_memory()[0]
pfix['free GPU'] = f'{free_gpu}MiB'
pfix['Elapsed'] = f'{elapsed}'
pbar.set_postfix(pfix)
losses.append(loss.item())
if step % save_image_every == 0:
z = torch.zeros_like(lr[0])
_, _, llr, _ = lr.shape
_, _, hlr, _ = hr.shape
if hlr // 2 == llr:
xz = torch.cat((lr[0], z), dim=-2)
elif hlr // 4 == llr:
xz = torch.cat((lr[0], z, z, z), dim=-2)
imsave([xz, sr[0], hr[0], gmsd[0]],
f'{result_dir}/epoch_{epoch+1}_iter_{step:05d}.jpg')
step += 1
logger.add_scalar("Loss/train", np.array(losses).mean(), epoch + 1)
logger.add_scalar("PSNR/train", psnr_mean, epoch + 1)
logger.add_scalar("SSIM/train", ssim_mean, epoch + 1)
if (epoch + 1) % save_model_every == 0:
torch.save(model.state_dict(),
f'{weight_dir}/epoch_{epoch+1:04d}.pth')
if (epoch + 1) % test_model_every == 0:
with torch.no_grad():
with tqdm(
test_loader,
desc=f'{mode} || Test Epoch {epoch+1}/{num_epochs}',
position=0,
leave=True) as pbar_test:
psnrs = []
ssims = []
msssims = []
for lr, lr_hf, hr, fname in pbar_test:
fname = fname[0].split('/')[-1].split('.pt')[0]
lr = lr.to(device)
hr = hr.to(device)
lr_hf = lr_hf.to(device)
sr, deep = model(lr, lr_hf)
mshf_hr = mshf(hr)
mshf_sr = mshf(sr)
gmsd = GMSD(hr, sr)
sr = quantize(sr)
psnr, ssim, msssim = evaluate(hr, sr)
psnrs.append(psnr)
ssims.append(ssim)
msssims.append(msssim)
psnr_mean = np.array(psnrs).mean()
ssim_mean = np.array(ssims).mean()
msssim_mean = np.array(msssims).mean()
pfix_test['psnr'] = f'{psnr:.4f}'
pfix_test['ssim'] = f'{ssim:.4f}'
pfix_test['msssim'] = f'{msssim:.4f}'
pfix_test['psnr_mean'] = f'{psnr_mean:.4f}'
pfix_test['ssim_mean'] = f'{ssim_mean:.4f}'
pfix_test['msssim_mean'] = f'{msssim_mean:.4f}'
pbar_test.set_postfix(pfix_test)
z = torch.zeros_like(lr[0])
_, _, llr, _ = lr.shape
_, _, hlr, _ = hr.shape
if hlr // 2 == llr:
xz = torch.cat((lr[0], z), dim=-2)
elif hlr // 4 == llr:
xz = torch.cat((lr[0], z, z, z), dim=-2)
imsave([xz, sr[0], hr[0], gmsd[0]],
f'{result_dir}/{fname}.jpg')
mshf_vis = torch.cat(
(torch.cat([
mshf_sr[:, i, :, :]
for i in range(mshf_sr.shape[1])
],
dim=-1),
torch.cat([
mshf_hr[:, i, :, :]
for i in range(mshf_hr.shape[1])
],
dim=-1)),
dim=-2)
imsave(mshf_vis, f'{result_dir}/MSHF_{fname}.jpg')
hist['epoch'].append(epoch + 1)
hist['psnr'].append(psnr_mean)
hist['ssim'].append(ssim_mean)
hist['ms-ssim'].append(msssim_mean)
logger.add_scalar("PSNR/test", psnr_mean, epoch + 1)
logger.add_scalar("SSIM/test", ssim_mean, epoch + 1)
logger.add_scalar("MS-SSIM/test", msssim_mean,
epoch + 1)
df = pd.DataFrame(hist)
df.to_csv(csv)
# generated_img, feed_dict={
# content_input: content_batch,
# style_input: style_batch
# }
# )
test_inputs_gen = utils.single_inputs_generator(list(zip(test_content_filenames, test_style_filenames)),
CONTENT_DATA_PATH, STYLE_DATA_PATH, TEST_INPUT_CONSTRAINTED_SIZE)
for i, (test_contents, test_styles) in enumerate(test_inputs_gen):
# shape=[1, w, h, c] for contents and styles, so as to feed arbitrary sized test samples
paired_name = f"{osp.splitext(test_style_filenames[i])[0]}" \
f"+{osp.splitext(test_content_filenames[i])[0]}"
try:
# IMPROVE: tune alpha. a value smaller than 1.0 will keep more content and convert less style
result_images = style_transfer_model([test_contents, test_styles], is_train=False, alpha=1)
print(f"generated_img for test ({paired_name}): {result_images[0].shape}")
utils.imsave(osp.join(TEMP_IMAGE_PATH, f"{paired_name}_{step}.jpg"), result_images[0].numpy())
except Exception as e:
tl.logging.error(f"failed to encode or save test image, bypassed: {paired_name}")
if not is_last_step:
step += 1
print(f'One Epoch finished! ({step}steps)\n' if not is_last_step else f'All Epochs finished! ({step}steps)\n')
# """Done Training & Save the model"""
# TL1to2: weights save/lod -> use save_weights/load_weights
# tl.files.save_npz(stylized_dec_net.all_params, name=MODEL_SAVE_PATH + str(step) + '_model.npz')
# ... move into the loop, ref: is_last_step
except KeyboardInterrupt:
print('Interrupted by keyboard.')
try:
