def test(contentpath, stylepath, multi=False):
'''一次前传得到风格化图像'''
if multi == False:
content_name = (contentpath.split('/')[-1]).split('.')[0]
style_name = (stylepath.split('/')[-1]).split('.')[0]
else:
content_name = (contentpath.split('\\')[-1]).split('.')[0]
style_name = (stylepath.split('\\')[-1]).split('.')[0]
transfer = test_transform(512)
contentimg = Image.open(str(contentpath)).convert('RGB')
styleimg = Image.open(str(stylepath)).convert('RGB')
if args.preserve_color: styleimg = change_color(styleimg, contentimg)
contentimg = transfer(contentimg).unsqueeze(0)
styleimg = transfer(styleimg).unsqueeze(0)
#if args.preserve_color: styleimg = coral(styleimg, contentimg)
decoder = Decoder().to(device).eval()
decoder.load_state_dict(torch.load(args.model_path))
fbnet = FPnet(decoder, True).to(device).eval()
output = fbnet(contentimg,
styleimg,
alpha=args.alpha,
lamda=args.lamda,
require_loss=False)
image_name = args.save_dir + '/' + content_name + '+' + style_name + '.jpg'
save_image(output.cpu(), image_name)
print('image saved as: ' + image_name)
contentimg.detach()
styleimg.detach()
def main():
parser = argparse.ArgumentParser(description='chainer implementation of pix2pix')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--img', '-i', help='Input image')
parser.add_argument('--out', '-o', default='result_dehighlight',
help='Directory to output the result')
args = parser.parse_args()
# Set up a neural network to train
enc = Encoder(in_ch=3)
dec = Decoder(out_ch=1)
chainer.serializers.load_npz(ENC_W, enc)
chainer.serializers.load_npz(DEC_W, dec)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
inimg = loadimg(args.img)
ch, h, w = inimg.shape
# add paddings so that input array has the size of mutiples of 256.
in_ary = np.zeros((ch,math.ceil(h/256)*256, math.ceil(w/256)*256), dtype="f")
in_ary[:,0:h,0:w] = inimg
x_in = in_ary[np.newaxis,:] # to fit into the minibatch shape
print(x_in.shape)
# x_in as an input image
x_in = chainer.Variable(x_in)
if args.gpu >= 0:
x_in.to_gpu()
st = time.time()
for i in range(10):
z = enc(x_in)
x_out = dec(z)
ts = time.time() - st
print("time:{:.2f}".format(ts/10.0))
if args.gpu >= 0:
out_ary = x_out.data.get()[0]
else:
out_ary = x_out.data[0]
#img_show = np.zeros((inimg.shape[0], inimg.shape[1], inimg.shape[2]*2))
#img_show[:,:,:inimg.shape[2]] = inimg
#img_show[:,:outimg.shape[1],inimg.shape[2]:inimg.shape[2]+outimg.shape[2]] = outimg
outimg = out_ary[:,0:h,0:w] # trim paddings
img_show = np.concatenate((inimg, outimg), axis=2)
bgrpic = to_bgr(img_show).copy()
cv2.putText(bgrpic,"input",(3,15),cv2.FONT_HERSHEY_DUPLEX, 0.5,(255,0,0))
cv2.putText(bgrpic,"output",(w+3,15),cv2.FONT_HERSHEY_DUPLEX, 0.5,(255,0,0))
cv2.imshow("result", bgrpic)
cv2.waitKey()
def main():
parser = argparse.ArgumentParser(description='chainer implementation of pix2pix')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--seed', type=int, default=0,
help='Random seed')
parser.add_argument('--model', '-m', default='',
help='model snapshot')
parser.add_argument('--enc', '-e', type=str, default='enc_iter_60000.npz', help='encoder snapshot')
parser.add_argument('--dec', '-d', type=str, default='dec_iter_60000.npz', help='decoder snapshot')
parser.add_argument('--out', '-o', type=str, default='out', help='output dir')
parser.add_argument('--input', '-i', default='sample.jpg', help='input jpg', required=True)
parser.add_argument('--contour', '-c', action='store_true', help='from contour image or not')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
enc = Encoder(in_ch=3)
dec = Decoder(out_ch=3)
dis = Discriminator(in_ch=3, out_ch=3)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
if args.model:
opt_enc = make_optimizer(enc)
opt_dec = make_optimizer(dec)
opt_dis = make_optimizer(dis)
# Set up a trainer
updater = FacadeUpdater(
models=(enc, dec, dis),
iterator={},
optimizer={
'enc': opt_enc, 'dec': opt_dec,
'dis': opt_dis},
device=args.gpu)
trainer = training.Trainer(updater, (200, 'epoch'), out='generate/')
chainer.serializers.load_npz(args.model, trainer)
elif args.enc and args.dec:
chainer.serializers.load_npz(args.enc, enc)
chainer.serializers.load_npz(args.dec, dec)
if not args.contour:
from make_contour import get_contour_image
get_contour_image(args.input)
generate_image_from_contour(args.input, enc, dec, args.out)
def main():
parser = argparse.ArgumentParser(
description='chainer implementation of pix2pix')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--dec', '-d', type=str, default='dec_model.npz',
help='decoder model')
parser.add_argument('--enc', '-e', type=str, default='enc_model.npz',
help='encoder model')
args = parser.parse_args()
enc = Encoder(in_ch=3)
dec = Decoder(out_ch=1)
chainer.serializers.load_npz(str(MODEL_PATH.joinpath(args.dec)), dec)
chainer.serializers.load_npz(str(MODEL_PATH.joinpath(args.enc)), enc)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
xp = enc.xp
branch_images = np.zeros((12, 256, 256), dtype=np.uint8)
plant_images = np.zeros((12, 256, 256, 3), dtype=np.uint8)
p2b_images = np.zeros((12, 256, 256), dtype=np.uint8)
for i in tqdm(range(1,12)):
branch_path = DATASET_PATH.joinpath('branch', str(i))
plant_path = DATASET_PATH.joinpath('plant', str(i))
name = random.choice([_ for _ in branch_path.glob('*.png')]).name
branch_image_path = branch_path.joinpath(name)
plant_image_path = plant_path.joinpath(name)
# open image
branch_image = np.asarray(Image.open(branch_image_path).convert('L'))
branch_images[i-1,:] = branch_image
plant_image = np.asarray(Image.open(plant_image_path).convert('RGB'))
plant_images[i-1,:] = plant_image
plant_image = xp.array(plant_image).astype("f").transpose(2, 0, 1) / 128.0-1.0
plant_image = plant_image.reshape(1, *plant_image.shape)
with chainer.no_backprop_mode(), chainer.using_config('train', False):
p2b_image = np.asarray(dec(enc(plant_image)).data.get())
p2b_image = np.asarray(np.clip(p2b_image * 128 + 128, 0.0, 255.0), dtype=np.uint8).reshape(256, 256)
p2b_images[i-1, :] = p2b_image
Image.fromarray(branch_images.reshape(3, 4, 256, 256).transpose(0, 2, 1, 3).reshape(3*256, 4*256))\
.save(str(RESULT_PATH.joinpath('branch_image.png')))
Image.fromarray(plant_images.reshape(3, 4, 256, 256, 3).transpose(0, 2, 1, 3, 4).reshape(3*256, 4*256, 3))\
.save(str(RESULT_PATH.joinpath('plant_image.png')))
Image.fromarray(p2b_images.reshape(3, 4, 256, 256).transpose(0, 2, 1, 3).reshape(3*256, 4*256))\
.save(str(RESULT_PATH.joinpath('p2b_image.png')))
def test(contentpath,stylepath,pixel,multi=False):
'''一次前传得到风格化图像'''
if multi==False:
content_name=(contentpath.split('/')[-1]).split('.')[0]
style_name=(stylepath.split('/')[-1]).split('.')[0]
else:
content_name=(contentpath.split('\\')[-1]).split('.')[0]
style_name=(stylepath.split('\\')[-1]).split('.')[0]
mytransfer=test_transform(pixel)
contentfile = open(str(contentpath),'rb')
stylefile = open(str(stylepath),'rb')
contentimg = Image.open(contentfile).convert('RGB')
styleimg = Image.open(stylefile).convert('RGB')
contentfile.close()
stylefile.close()
if args.preserve_color: styleimg = change_color(styleimg, contentimg)
#if args.preserve_color: contentimg,styleimg,contentH,contentS = lumi_only(contentimg,styleimg,mytransfer)
contentimg=mytransfer(contentimg).unsqueeze(0)
styleimg=mytransfer(styleimg).unsqueeze(0)
decoder=Decoder().to(device).eval()
decoder.load_state_dict(torch.load(args.model_path))
fbnet=FPnet(decoder,True).to(device).eval()
output=fbnet(contentimg,styleimg,alpha=args.alpha,lamda=args.lamda,require_loss=False)
#if args.preserve_color:output=recover_color(output,contentH,contentS)
image_name=args.save_dir+'/'+content_name+'+'+style_name+'-'+str(pixel)+'-'+str(args.alpha)+'.jpg'
save_image(output.cpu(),image_name)
print('image saved as: '+image_name)
contentimg.detach()
styleimg.detach()
output.detach()
def style_transfer():
enc = VGG19(input_shape)
decs = [Decoder(enc, i, name='decoder %d' % i) for i in indices]
sty_net = StyleTransfer(enc, decs)
X = T.tensor4('input')
Y = T.tensor4('style')
mon = nn.Monitor(current_folder=args.path_to_weight_files)
for idx, layer in enumerate(indices):
weights = mon.load('decoder-%d-final.npz' % layer)
nn.utils.numpy2shared(weights, decs[idx].params)
nn.set_training_off()
X_styled = sty_net(X, Y)
transfer = nn.function([X, Y], X_styled, name='transfer style')
if os.path.isfile(input_path_test) and os.path.isfile(style_path_test):
input = prep_image_test(misc.imread(input_path_test))
style = prep_image_test(misc.imread(style_path_test))
output = transfer(input, style)
mon.imwrite('test %s' % input_path_test[:-4], input)
mon.imwrite('test %s' % style_path_test[:-4], style)
mon.imwrite('test %s %s' % (input_path_test[:-4], style_path_test[:-4]), output)
elif os.path.isfile(input_path_test) and os.path.isdir(style_path_test):
input = prep_image_test(misc.imread(input_path_test))
style_files = os.listdir(style_path_test)
for style_file in style_files:
style = prep_image_test(misc.imread(os.path.join(style_path_test, style_file)))
output = transfer(input, style)
mon.imwrite('test %s' % style_file[:-4], style)
mon.imwrite('test %s %s' % (input_path_test[:-4], style_file[:-4]), output)
mon.imwrite('test %s' % input_path_test[:-4], input)
elif os.path.isdir(input_path_test) and os.path.isfile(style_path_test):
style = prep_image_test(misc.imread(style_path_test))
input_files = os.listdir(input_path_test)
for input_file in input_files:
input = prep_image_test(misc.imread(os.path.join(input_path_test, input_file)))
output = transfer(input, style)
mon.imwrite('test %s' % input_file[:-4], input)
mon.imwrite('test %s %s' % (input_file[:-4], style_path_test[:-4]), output)
mon.imwrite('test %s' % style_path_test[:-4], style)
else:
style_files = os.listdir(style_path_test)
input_files = os.listdir(input_path_test)
for style_file in style_files:
style = prep_image_test(misc.imread(os.path.join(style_path_test, style_file)))
for input_file in input_files:
input = prep_image_test(misc.imread(os.path.join(input_path_test, input_file)))
output = transfer(input, style)
mon.imwrite('test %s' % input_file[:-4], input)
mon.imwrite('test %s %s' % (input_file[:-4], style_file[:-4]), output)
mon.imwrite('test %s' % style_file[:-4], style)
mon.flush()
print('Testing finished!')
def train():
enc = VGG19(input_shape)
decs = [Decoder(enc, i, name='decoder %d' % i) for i in indices]
sty_net = StyleTransfer(enc, decs)
X = T.tensor4('input')
Y = T.tensor4('style')
idx = T.scalar('iter', 'int32')
X_ = nn.placeholder((bs,) + input_shape[1:], name='input_plhd')
Y_ = nn.placeholder((bs,) + input_shape[1:], name='style_plhd')
lr_ = nn.placeholder(value=lr, name='lr_plhd')
nn.set_training_on()
losses = [dec.cost(X) for dec in decs]
updates = [nn.adam(loss[0] + weight * loss[1], dec.trainable, lr) for loss, dec in zip(losses, decs)]
nn.anneal_learning_rate(lr_, idx, 'inverse', decay=decay)
trains = [nn.function([], [loss[0], loss[1], dec(X, True)], givens={X: X_}, updates=update, name='train decoder')
for loss, dec, update in zip(losses, decs, updates)]
nn.set_training_off()
X_styled = sty_net(X, Y)
transfer = nn.function([], X_styled, givens={X: X_, Y: Y_}, name='transfer style')
data_train = DataManager(X_, input_path_train, bs, n_epochs, True, num_val_imgs=num_val_imgs, input_shape=input_shape)
data_test = DataManagerStyleTransfer((X_, Y_), (input_path_val, style_path_val), bs, 1, input_shape=input_shape)
mon = nn.Monitor(model_name='WCT', valid_freq=print_freq)
print('Training...')
for it in data_train:
results = [train(it) for train in trains]
with mon:
for layer, res in zip(indices, results):
if np.isnan(res[0] + res[1]) or np.isinf(res[0] + res[1]):
raise ValueError('Training failed!')
mon.plot('pixel loss at layer %d' % layer, res[0])
mon.plot('feature loss at layer %d' % layer, res[1])
if it % val_freq == 0:
mon.imwrite('recon img at layer %d' % layer, res[2])
for i in data_test:
img = transfer()
mon.imwrite('stylized image %d' % i, img)
mon.imwrite('input %d' % i, X_.get_value())
mon.imwrite('style %d' % i, Y_.get_value())
for idx, dec in zip(indices, decs):
mon.dump(nn.utils.shared2numpy(dec.params), 'decoder-%d.npz' % idx, 5)
mon.flush()
for idx, dec in zip(indices, decs):
mon.dump(nn.utils.shared2numpy(dec.params), 'decoder-%d-final.npz' % idx)
print('Training finished!')
def main():
#定义数据加载器
transform = Transform()
content_set = CSDataset(transform=transform, root=args.content_dir)
style_set = CSDataset(transform=transform, root=args.style_dir)
content_loader = iter(data.DataLoader( content_set, batch_size=args.batch_size,sampler=RecurrentSampler(content_set), \
num_workers=args.n_threads,pin_memory=True,drop_last=True))
style_loader = iter(data.DataLoader( style_set, batch_size=args.batch_size,sampler=RecurrentSampler(style_set),\
num_workers=args.n_threads,pin_memory=True,drop_last=True))
#初始化模型
decoder = Decoder()
decoder = decoder.to(device)
decoder.zero_grad()
#训练网络
train(decoder, content_loader, style_loader)
def transfer(contentpath,
stylepath,
converted,
pixel=512,
model_path='static/20200522decoder100000_1.pth'):
'''一次前传得到风格化图像'''
mytransfer = test_transform(pixel)
contentfile = open(str(contentpath), 'rb')
stylefile = open(str(stylepath), 'rb')
contentimg = Image.open(contentfile).convert('RGB')
styleimg = Image.open(stylefile).convert('RGB')
contentfile.close()
stylefile.close()
contentimg = mytransfer(contentimg).unsqueeze(0)
styleimg = mytransfer(styleimg).unsqueeze(0)
# device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device = torch.device("cpu")
decoder = Decoder().to(device).eval()
decoder.load_state_dict(
torch.load(model_path, map_location=torch.device('cpu')))
# decoder = decoder.module
# decoder.load_state_dict(torch.load(model_path))
fbnet = FPnet(decoder, True).to(device).eval()
output = fbnet(contentimg,
styleimg,
alpha=1.0,
lamda=1.0,
require_loss=False)
save_image(output.cpu(), converted)
contentimg.detach()
styleimg.detach()
output.detach()
def main():
parser = argparse.ArgumentParser(
description='chainer implementation of pix2pix')
parser.add_argument('--batchsize',
'-b',
type=int,
default=1,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=200,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--enc-npz', default='', required=True)
parser.add_argument('--dec-npz', default='', required=True)
parser.add_argument('input')
args = parser.parse_args()
# Set up a neural network to train
enc = Encoder(in_ch=3)
dec = Decoder(out_ch=3)
chainer.serializers.load_npz(args.enc_npz, enc)
chainer.serializers.load_npz(args.dec_npz, dec)
# load image and predict
img = Image.open(args.input).convert('RGB')
img = np.asarray(img).astype(np.float32)
img /= 255.0
img = img.transpose(2, 0, 1).reshape((1, 3, 256, 256))
x = chainer.Variable(img)
z = enc(x)
y = dec(z) # (batchsize, ch, width, height)
y = y.data.reshape(3, 256, 256).transpose(1, 2, 0).clip(0, 1)
import matplotlib.pyplot as plt
plt.imshow(y)
plt.show()
if False:
import scipy.misc
scipy.misc.imsave("output.png", y)
def test_random():
enc = Encoder((None, ) + input_size, vgg_param_file)
dec = Decoder(enc.output_shape, dec_param_file)
X = T.tensor4('input')
Y = T.tensor4('style')
weights = [T.vector('weights') for i in range(len(vgg_info))]
nn.set_training_off()
X_styled = dec(enc((X, Y), weights))
test = nn.function([X, Y] + weights, X_styled, name='test generator')
style_folder = os.listdir(style_img_folder)
input_folder = os.listdir(input_img_folder)
time_list = []
if not os.path.exists('outputs'):
os.mkdir('outputs')
for style_file in style_folder:
sty_img = prep_image_test(
misc.imread(style_img_folder + '/' + style_file))
for input_file in input_folder:
try:
input_img = prep_image_test(
misc.imread(input_img_folder + '/' + input_file))
except ValueError:
continue
for i in range(num_styles):
start = time.time()
output = test(input_img, sty_img, *get_weights(vgg_info))
time_list.append(time.time() - start)
output = np.transpose(output[0], (1, 2, 0))
misc.imsave(
os.path.join(
'outputs', input_file[:-4] + '_' + style_file[:-4] +
'_%d.jpg' % i), output)
print('Took %f s/image' % np.mean(time_list))
print('Testing finished!')
def main():
parser = argparse.ArgumentParser(
description='chainer implementation of pix2pix')
parser.add_argument('--batchsize',
'-b',
type=int,
default=1,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=200,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--enc-npz', default='', required=True)
parser.add_argument('--dec-npz', default='', required=True)
args = parser.parse_args()
# Set up a neural network to train
enc = Encoder(in_ch=3)
dec = Decoder(out_ch=3)
chainer.serializers.load_npz(args.enc_npz, enc)
chainer.serializers.load_npz(args.dec_npz, dec)
# graph
input = np.zeros((1, 3, 256, 256), dtype=np.float32)
x = chainer.Variable(input)
z = enc(x)
y = dec(z)
graph = ChainerConverter().convert([x], [y])
exec_info = generate_descriptor("webassembly", graph)
exec_info.save(args.out)
def __init__(self):
super(Agent, self).__init__()
#self.config = config
self.action = Action()
self.dataset = Dataset()
self.device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu")
self.grad_clip = 5
embed_dim = 512 # dimension of word embeddings
decoder_dim = 512 # dimension of decoder RNN
dropout = 0.5
#batch_size = 32
self.n_epochs = 20
self.encoder = Encoder()
self.decoder = Decoder(embed_dim=embed_dim,
decoder_dim=decoder_dim,
vocab_size=self.dataset.get_word_map_len(),
dropout=dropout)
def main():
parser = argparse.ArgumentParser(
description='chainer implementation of pix2pix')
parser.add_argument('--batchsize', '-b', type=int, default=1,
help='Number of images in each mini-batch')
parser.add_argument('--epoch', '-e', type=int, default=200,
help='Number of sweeps over the dataset to train')
parser.add_argument('--device', '-d', type=str, default='-1',
help='Device specifier. Either ChainerX device '
'specifier or an integer. If non-negative integer, '
'CuPy arrays with specified device id are used. If '
'negative integer, NumPy arrays are used')
parser.add_argument('--dataset', '-i', default='./facade/base',
help='Directory of image files.')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--resume', '-r', type=str,
help='Resume the training from snapshot')
parser.add_argument('--seed', type=int, default=0,
help='Random seed')
parser.add_argument('--snapshot_interval', type=int, default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval', type=int, default=100,
help='Interval of displaying log to console')
group = parser.add_argument_group('deprecated arguments')
group.add_argument('--gpu', '-g', dest='device',
type=int, nargs='?', const=0,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
if chainer.get_dtype() == numpy.float16:
warnings.warn(
'This example may cause NaN in FP16 mode.', RuntimeWarning)
device = chainer.get_device(args.device)
if device.xp is chainerx:
sys.stderr.write('This example does not support ChainerX devices.\n')
sys.exit(1)
print('Device: {}'.format(device))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
device.use()
# Set up a neural network to train
enc = Encoder(in_ch=12)
dec = Decoder(out_ch=3)
dis = Discriminator(in_ch=12, out_ch=3)
enc.to_device(device)
dec.to_device(device)
dis.to_device(device)
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
opt_enc = make_optimizer(enc)
opt_dec = make_optimizer(dec)
opt_dis = make_optimizer(dis)
train_d = FacadeDataset(args.dataset, data_range=(1, 300))
test_d = FacadeDataset(args.dataset, data_range=(300, 379))
train_iter = chainer.iterators.SerialIterator(train_d, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_d, args.batchsize)
# Set up a trainer
updater = FacadeUpdater(
models=(enc, dec, dis),
iterator={
'main': train_iter,
'test': test_iter},
optimizer={
'enc': opt_enc, 'dec': opt_dec,
'dis': opt_dis},
device=device)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
trainer.extend(extensions.snapshot(
filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
enc, 'enc_iter_{.updater.iteration}.npz'), trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dec, 'dec_iter_{.updater.iteration}.npz'), trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_iter_{.updater.iteration}.npz'), trigger=snapshot_interval)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'enc/loss', 'dec/loss', 'dis/loss',
]), trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(
out_image(
updater, enc, dec,
5, 5, args.seed, args.out),
trigger=snapshot_interval)
if args.resume is not None:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
parser.add_argument('--seed', type=int, default=0,
help='Random seed')
parser.add_argument('--snapshot_interval', type=int, default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval', type=int, default=100,
help='Interval of displaying log to console')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train
enc = Encoder(in_ch=5)
dec = Decoder(out_ch=3)
dis = Discriminator(in_ch=5, out_ch=3)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
opt_enc = make_optimizer(enc)
return x
def _istft(y):
_, hop_length, win_length = _stft_parameters()
return librosa.istft(y, hop_length=hop_length, win_length=win_length)
def save_wav(wav, path):
wav *= 1 / max(0.01, np.max(np.abs(wav)))
librosa.output.write_wav(path, wav, hparams.sample_rate)
# Set up a neural network
enc = Encoder(in_ch=2)
dec = Decoder(out_ch=2)
# load terained models
chainer.serializers.load_npz(MODEL_DIR + "enc_iter_%d.npz" % ITER, enc)
chainer.serializers.load_npz(MODEL_DIR + "dec_iter_%d.npz" % ITER, dec)
#img = Image.open('../input/png/%d_ritsuko.png'%MUSIC_IDX)
#img = np.asarray(img).astype("f")/128.0-1.0
img = sp2.astype("f") / 128.0 - 1.0
h, w, c = img.shape
print(img.shape)
img = img.transpose(2, 0, 1)
img = img[:2, :, :]
img = img.reshape(1, 2, h, w)
print(img.shape)
def main():
parser = argparse.ArgumentParser(
description='chainer creating pictures of seat')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--data',
'-d',
default='./detect',
help='Directory of image files.')
parser.add_argument('--mask',
'-ma',
default='./mask',
help='Directory of image files.')
parser.add_argument('--out',
'-o',
default='./result',
help='Directory to output the result')
parser.add_argument('--seed', type=int, default=0, help='Random seed')
parser.add_argument('--model',
'-m',
default='snapshot_iter_83000.npz',
help='Loading model')
parser.add_argument('--batchsize',
'-b',
default=16,
type=int,
help='The same value as that of trainer')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('')
# Set up a neural network to train
enc = Encoder(in_ch=4)
dec = Decoder(out_ch=3)
if args.gpu >= 0:
cuda.get_device(args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
xp = cuda.cupy
# Setup an model
model = args.model
print('---Loading model---')
serializers.load_npz(model, enc, path='updater/model:enc/')
serializers.load_npz(model, dec, path='updater/model:dec/')
# Trun off a trainer
chainer.config.train = False
chainer.config.debug = False
chainer.config.enable_backprop = False
print('Setuped model!')
# Load datasets
print('---Loading datasets---')
data_path = args.data
data_sets = glob.glob(data_path + '/*.jpg')
data_mask = glob.glob(args.mask + '/*.jpg')
dataset = []
names = []
for data in data_sets:
d_name = os.path.basename(data)
d_name = d_name[:-4]
img = Image.open(data)
img = xp.asarray(img).transpose(2, 0, 1)
for _ in range(10):
mask = random.choice(data_mask)
mask = Image.open(mask)
mask = xp.asarray(mask)
mask = mask[xp.newaxis, :, :]
img_ = img + mask
img_ = xp.asarray(img_).astype('f') / 128.0 - 1.0
mask = xp.asarray(mask).astype('f') / 128.0 - 1.0
img_ = xp.concatenate([img_, mask], axis=0)
dataset.append(img_)
f_name = d_name + '_' + str(_)
names.append(f_name)
print('Setuped datasets!')
# Create picture
print('---Creating---')
in_ch = 4
in_h = 256
in_w = 256
out_put = 0
batch_size = args.batchsize
out_dir = args.out
if not (os.path.exists(out_dir)):
os.mkdir(out_dir)
_ = 0
for name, data in zip(names, dataset):
X_in = xp.zeros((batch_size, in_ch, in_h, in_w)).astype("f")
for i in range(batch_size):
X_in[i, :] = xp.asarray(data)
X_in = Variable(X_in)
z = enc(X_in)
X_out = dec(z)
out_put = xp.asarray(X_out.data)
out_put = out_put[0]
out_put += 1.0
out_put *= 128.0
xp.save(out_dir + '/' + name, out_put)
_ += 1
print('created {} / {}'.format(_, len(dataset)))
print('Finished all process!')
print('Numpy shape : ', out_put.shape)
print('Number of Numpy file : ', len(dataset))
def main():
parser = argparse.ArgumentParser(
description="chainer implementation of Unet")
parser.add_argument("--batchsize",
"-b",
type=int,
default=1,
help="Number of images in each mini-batch")
parser.add_argument("--epoch", "-e", type=int, default=200, help="epoch")
parser.add_argument("--gpu", "-g", type=int, default=-1, help="GPU ID")
parser.add_argument("--dataset",
"-i",
default="./train/",
help="Directory of image files")
parser.add_argument("--out",
"-o",
default="result/",
help="Directory to output the result")
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--seed', type=int, default=0, help='Random seed')
parser.add_argument('--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Only Encoder Decoder with Unet
enc = Encoder(in_ch=3) # in_ch => 3(YCbCr)
dec = Decoder(out_ch=3) # out_ch => 3(DCT)
# GPU set up
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
enc.to_gpu()
dec.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
opt_enc = make_optimizer(enc)
opt_dec = make_optimizer(dec)
train_d = ImgDCTDataset(args.dataset, data_range=(0, 1000))
test_d = ImgDCTDataset(args.dataset, data_range=(1000, 2000))
train_iter = chainer.iterators.SerialIterator(train_d, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_d, args.batchsize)
updater = FacadeUpdater(models=(enc, dec),
iterator={
'main': train_iter,
'test': test_iter
},
optimizer={
'enc': opt_enc,
'dec': opt_dec
},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
enc, 'enc_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dec, 'dec_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
# trainer.extend(extensions.snapshot_object(
# dis, 'dis_iter_{.updater.iteration}.npz'), trigger=snapshot_interval)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch',
'iteration',
'enc/loss',
'dec/loss',
]),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(
description='chainer implementation of pix2pix')
parser.add_argument('--batchsize',
'-b',
type=int,
default=1,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=200,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--dataset',
'-i',
default='./facade/base',
help='Directory of image files.')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--seed', type=int, default=0, help='Random seed')
parser.add_argument('--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console')
parser.add_argument(
'--n_processes',
type=int,
default=None,
help='processes of chainer.iterators.MultiprocessIterator')
parser.add_argument(
'--shared_mem',
type=int,
default=None,
help=
'shared memory per data, for chainer.iterators.MultiprocessIterator. None means auto ajust.'
)
parser.add_argument('--audio_dataset_second',
type=int,
default=None,
help='time length(second) of train audio data .')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
args.out = os.path.join(args.out, datetime.now().strftime("%Y%m%d_%H%M%S"))
util.audio_dataset_second = args.audio_dataset_second
if args.batchsize > 1:
assert util.audio_dataset_second != None, "when minibatch training (e.g. --batchsize > 1), --audio_dataset_second option is required."
# Set up a neural network to train
enc = Encoder(in_ch=2)
dec = Decoder(out_ch=2)
dis = Discriminator(in_ch=2, out_ch=2)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
opt_enc = make_optimizer(enc)
opt_dec = make_optimizer(dec)
opt_dis = make_optimizer(dis)
train_d = Vp2pDataset(args.dataset + "/train")
test_d = Vp2pDataset(args.dataset + "/test")
train_iter = chainer.iterators.MultiprocessIterator(
train_d,
args.batchsize,
n_processes=args.n_processes,
shared_mem=args.shared_mem)
test_iter = chainer.iterators.MultiprocessIterator(
test_d,
args.batchsize,
n_processes=args.n_processes,
shared_mem=args.shared_mem)
# train_iter = chainer.iterators.MultiprocessIterator(train_d, args.batchsize)
# test_iter = chainer.iterators.MultiprocessIterator(test_d, args.batchsize)
# Set up a trainer
updater = VoiceP2PUpdater(models=(enc, dec, dis),
iterator={
'main': train_iter,
'test': test_iter
},
optimizer={
'enc': opt_enc,
'dec': opt_dec,
'dis': opt_dis
},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
enc, 'enc_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dec, 'dec_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch',
'iteration',
'enc/loss',
'dec/loss',
'dis/loss',
]),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_image(updater, enc, dec, 5, 5, args.seed, args.out),
trigger=snapshot_interval)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(
description='chainer implementation of pix2pix')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--seed', type=int, default=0, help='Random seed')
parser.add_argument('--model', '-m', default='', help='model snapshot')
parser.add_argument('--input',
'-i',
default='../images/generate/sample.jpg',
help='input jpg')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
# Set up a neural network to train
enc = Encoder(in_ch=3)
dec = Decoder(out_ch=3)
dis = Discriminator(in_ch=3, out_ch=3)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
opt_enc = make_optimizer(enc)
opt_dec = make_optimizer(dec)
opt_dis = make_optimizer(dis)
if os.path.exists('generate_tmp'):
shutil.rmtree('generate_tmp')
os.mkdir('generate_tmp')
os.mkdir('generate_tmp/base')
os.mkdir('generate_tmp/label')
shutil.copyfile(args.input, 'generate_tmp/base/tmp.jpg')
shutil.copyfile(args.input, 'generate_tmp/label/tmp.jpg')
test_d = FacadeDataset('generate_tmp/')
test_iter = chainer.iterators.SerialIterator(test_d, 1)
# Set up a trainer
updater = FacadeUpdater(models=(enc, dec, dis),
iterator={},
optimizer={
'enc': opt_enc,
'dec': opt_dec,
'dis': opt_dis
},
device=args.gpu)
trainer = training.Trainer(updater, (200, 'epoch'),
out='../results/generate/')
chainer.serializers.load_npz(args.model, trainer)
out_image(updater, enc, dec, 1, 1, args.seed, '../results/generate/', True,
test_iter)(trainer)
def main():
args = arguments()
print(args)
if args.imgtype == "dcm":
from dataset_dicom import Dataset as Dataset
else:
from dataset_jpg import DatasetOutMem as Dataset
# CUDA
if not chainer.cuda.available:
print("CUDA required")
exit()
if len(args.gpu) == 1 and args.gpu[0] >= 0:
chainer.cuda.get_device_from_id(args.gpu[0]).use()
# Enable autotuner of cuDNN
chainer.config.autotune = True
chainer.config.dtype = dtypes[args.dtype]
chainer.print_runtime_info()
# Turn off type check
# chainer.config.type_check = False
# print('Chainer version: ', chainer.__version__)
# print('GPU availability:', chainer.cuda.available)
# print('cuDNN availablility:', chainer.cuda.cudnn_enabled)
## dataset iterator
print("Setting up data iterators...")
train_A_dataset = Dataset(path=os.path.join(args.root, 'trainA'),
args=args,
base=args.HU_baseA,
rang=args.HU_rangeA,
random=args.random_translate)
train_B_dataset = Dataset(path=os.path.join(args.root, 'trainB'),
args=args,
base=args.HU_baseB,
rang=args.HU_rangeB,
random=args.random_translate)
test_A_dataset = Dataset(path=os.path.join(args.root, 'testA'),
args=args,
base=args.HU_baseA,
rang=args.HU_rangeA,
random=0)
test_B_dataset = Dataset(path=os.path.join(args.root, 'testB'),
args=args,
base=args.HU_baseB,
rang=args.HU_rangeB,
random=0)
args.ch = train_A_dataset.ch
args.out_ch = train_B_dataset.ch
print("channels in A {}, channels in B {}".format(args.ch, args.out_ch))
# test_A_iter = chainer.iterators.SerialIterator(test_A_dataset, args.nvis_A, shuffle=False)
# test_B_iter = chainer.iterators.SerialIterator(test_B_dataset, args.nvis_B, shuffle=False)
test_A_iter = chainer.iterators.MultithreadIterator(test_A_dataset,
args.nvis_A,
shuffle=False,
n_threads=3)
test_B_iter = chainer.iterators.MultithreadIterator(test_B_dataset,
args.nvis_B,
shuffle=False,
n_threads=3)
train_A_iter = chainer.iterators.MultithreadIterator(train_A_dataset,
args.batch_size,
n_threads=3)
train_B_iter = chainer.iterators.MultithreadIterator(train_B_dataset,
args.batch_size,
n_threads=3)
# setup models
enc_x = Encoder(args)
enc_y = enc_x if args.single_encoder else Encoder(args)
dec_x = Decoder(args)
dec_y = Decoder(args)
dis_x = Discriminator(args)
dis_y = Discriminator(args)
dis_z = Discriminator(
args) if args.lambda_dis_z > 0 else chainer.links.Linear(1, 1)
models = {
'enc_x': enc_x,
'dec_x': dec_x,
'enc_y': enc_y,
'dec_y': dec_y,
'dis_x': dis_x,
'dis_y': dis_y,
'dis_z': dis_z
}
## load learnt models
if args.load_models:
for e in models:
m = args.load_models.replace('enc_x', e)
try:
serializers.load_npz(m, models[e])
print('model loaded: {}'.format(m))
except:
print("couldn't load {}".format(m))
pass
# select GPU
if len(args.gpu) == 1:
for e in models:
models[e].to_gpu()
print('using gpu {}, cuDNN {}'.format(args.gpu,
chainer.cuda.cudnn_enabled))
else:
print("mandatory GPU use: currently only a single GPU can be used")
exit()
# Setup optimisers
def make_optimizer(model, lr, opttype='Adam'):
# eps = 1e-5 if args.dtype==np.float16 else 1e-8
optimizer = optim[opttype](lr)
#from profiled_optimizer import create_marked_profile_optimizer
# optimizer = create_marked_profile_optimizer(optim[opttype](lr), sync=True, sync_level=2)
optimizer.setup(model)
if args.weight_decay > 0:
if opttype in ['Adam', 'AdaBound', 'Eve']:
optimizer.weight_decay_rate = args.weight_decay
else:
if args.weight_decay_norm == 'l2':
optimizer.add_hook(
chainer.optimizer.WeightDecay(args.weight_decay))
else:
optimizer.add_hook(
chainer.optimizer_hooks.Lasso(args.weight_decay))
return optimizer
opt_enc_x = make_optimizer(enc_x, args.learning_rate_g, args.optimizer)
opt_dec_x = make_optimizer(dec_x, args.learning_rate_g, args.optimizer)
opt_enc_y = make_optimizer(enc_y, args.learning_rate_g, args.optimizer)
opt_dec_y = make_optimizer(dec_y, args.learning_rate_g, args.optimizer)
opt_x = make_optimizer(dis_x, args.learning_rate_d, args.optimizer)
opt_y = make_optimizer(dis_y, args.learning_rate_d, args.optimizer)
opt_z = make_optimizer(dis_z, args.learning_rate_d, args.optimizer)
optimizers = {
'opt_enc_x': opt_enc_x,
'opt_dec_x': opt_dec_x,
'opt_enc_y': opt_enc_y,
'opt_dec_y': opt_dec_y,
'opt_x': opt_x,
'opt_y': opt_y,
'opt_z': opt_z
}
if args.load_optimizer:
for e in optimizers:
try:
m = args.load_models.replace('enc_x', e)
serializers.load_npz(m, optimizers[e])
print('optimiser loaded: {}'.format(m))
except:
print("couldn't load {}".format(m))
pass
# Set up an updater: TODO: multi gpu updater
print("Preparing updater...")
updater = Updater(models=(enc_x, dec_x, enc_y, dec_y, dis_x, dis_y, dis_z),
iterator={
'main': train_A_iter,
'train_B': train_B_iter,
},
optimizer=optimizers,
converter=convert.ConcatWithAsyncTransfer(),
device=args.gpu[0],
params={'args': args})
if args.snapinterval < 0:
args.snapinterval = args.lrdecay_start + args.lrdecay_period
log_interval = (200, 'iteration')
model_save_interval = (args.snapinterval, 'epoch')
plot_interval = (500, 'iteration')
# Set up a trainer
print("Preparing trainer...")
if args.iteration:
stop_trigger = (args.iteration, 'iteration')
else:
stop_trigger = (args.lrdecay_start + args.lrdecay_period, 'epoch')
trainer = training.Trainer(updater, stop_trigger, out=args.out)
for e in models:
trainer.extend(extensions.snapshot_object(models[e],
e + '{.updater.epoch}.npz'),
trigger=model_save_interval)
# trainer.extend(extensions.ParameterStatistics(models[e])) ## very slow
for e in optimizers:
trainer.extend(extensions.snapshot_object(optimizers[e],
e + '{.updater.epoch}.npz'),
trigger=model_save_interval)
log_keys = ['epoch', 'iteration', 'lr']
log_keys_cycle = [
'opt_enc_x/loss_cycle', 'opt_enc_y/loss_cycle', 'opt_dec_x/loss_cycle',
'opt_dec_y/loss_cycle', 'myval/cycle_x_l1', 'myval/cycle_y_l1'
]
log_keys_adv = [
'opt_enc_y/loss_adv', 'opt_dec_y/loss_adv', 'opt_enc_x/loss_adv',
'opt_dec_x/loss_adv'
]
log_keys_d = []
if args.lambda_reg > 0:
log_keys.extend(['opt_enc_x/loss_reg', 'opt_enc_y/loss_reg'])
if args.lambda_tv > 0:
log_keys.extend(['opt_dec_y/loss_tv'])
if args.lambda_air > 0:
log_keys.extend(['opt_dec_x/loss_air', 'opt_dec_y/loss_air'])
if args.lambda_grad > 0:
log_keys.extend(['opt_dec_x/loss_grad', 'opt_dec_y/loss_grad'])
if args.lambda_identity_x > 0: # perceptual
log_keys.extend(['opt_enc_x/loss_id', 'opt_enc_y/loss_id'])
if args.lambda_domain > 0:
log_keys_cycle.extend(['opt_dec_x/loss_dom', 'opt_dec_y/loss_dom'])
if args.dis_reg_weighting > 0:
log_keys_d.extend(
['opt_x/loss_reg', 'opt_y/loss_reg', 'opt_z/loss_reg'])
if args.dis_wgan:
log_keys_d.extend([
'opt_x/loss_dis', 'opt_x/loss_gp', 'opt_y/loss_dis',
'opt_y/loss_gp'
])
if args.lambda_dis_z > 0:
log_keys_d.extend(['opt_z/loss_dis', 'opt_z/loss_gp'])
else:
log_keys_d.extend([
'opt_x/loss_real', 'opt_x/loss_fake', 'opt_y/loss_real',
'opt_y/loss_fake'
])
if args.lambda_dis_z > 0:
log_keys_d.extend(['opt_z/loss_x', 'opt_z/loss_y'])
log_keys_all = log_keys + log_keys_d + log_keys_adv + log_keys_cycle
trainer.extend(
extensions.LogReport(keys=log_keys_all, trigger=log_interval))
trainer.extend(extensions.PrintReport(log_keys_all), trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=20))
trainer.extend(extensions.observe_lr(optimizer_name='opt_enc_x'),
trigger=log_interval)
# learning rate scheduling
decay_start_iter = len(train_A_dataset) * args.lrdecay_start
decay_end_iter = len(train_A_dataset) * (args.lrdecay_start +
args.lrdecay_period)
for e in [opt_enc_x, opt_enc_y, opt_dec_x, opt_dec_y]:
trainer.extend(
extensions.LinearShift('alpha', (args.learning_rate_g, 0),
(decay_start_iter, decay_end_iter),
optimizer=e))
for e in [opt_x, opt_y, opt_z]:
trainer.extend(
extensions.LinearShift('alpha', (args.learning_rate_d, 0),
(decay_start_iter, decay_end_iter),
optimizer=e))
## dump graph
if args.lambda_Az > 0:
trainer.extend(
extensions.dump_graph('opt_enc_x/loss_cycle', out_name='gen.dot'))
if args.lambda_dis_x > 0:
if args.dis_wgan:
trainer.extend(
extensions.dump_graph('opt_x/loss_dis', out_name='dis.dot'))
else:
trainer.extend(
extensions.dump_graph('opt_x/loss_fake', out_name='dis.dot'))
# ChainerUI
trainer.extend(CommandsExtension())
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(log_keys[3:],
'iteration',
trigger=plot_interval,
file_name='loss.png',
postprocess=plot_log))
trainer.extend(
extensions.PlotReport(log_keys_d,
'iteration',
trigger=plot_interval,
file_name='loss_d.png'))
trainer.extend(
extensions.PlotReport(log_keys_adv,
'iteration',
trigger=plot_interval,
file_name='loss_adv.png'))
trainer.extend(
extensions.PlotReport(log_keys_cycle,
'iteration',
trigger=plot_interval,
file_name='loss_cyc.png',
postprocess=plot_log))
## visualisation
vis_folder = os.path.join(args.out, "vis")
os.makedirs(vis_folder, exist_ok=True)
if not args.vis_freq:
args.vis_freq = len(train_A_dataset) // 2
s = [k for k in range(args.num_slices)
] if args.num_slices > 0 and args.imgtype == "dcm" else None
trainer.extend(VisEvaluator({
"testA": test_A_iter,
"testB": test_B_iter
}, {
"enc_x": enc_x,
"enc_y": enc_y,
"dec_x": dec_x,
"dec_y": dec_y
},
params={
'vis_out': vis_folder,
'slice': s,
'args': args
},
device=args.gpu[0]),
trigger=(args.vis_freq, 'iteration'))
## output filenames of training dataset
with open(os.path.join(args.out, 'trainA.txt'), 'w') as output:
for f in train_A_dataset.names:
output.writelines("\n".join(f))
output.writelines("\n")
with open(os.path.join(args.out, 'trainB.txt'), 'w') as output:
for f in train_B_dataset.names:
output.writelines("\n".join(f))
output.writelines("\n")
# archive the scripts
rundir = os.path.dirname(os.path.realpath(__file__))
import zipfile
with zipfile.ZipFile(os.path.join(args.out, 'script.zip'),
'w',
compression=zipfile.ZIP_DEFLATED) as new_zip:
for f in [
'train.py', 'net.py', 'updater.py', 'consts.py', 'losses.py',
'arguments.py', 'convert.py'
]:
new_zip.write(os.path.join(rundir, f), arcname=f)
# Run the training
print("\nresults are saved under: ", args.out)
save_args(args, args.out)
with open(os.path.join(args.out, "args.txt"), 'w') as fh:
fh.write(" ".join(sys.argv))
trainer.run()
def main():
parser = argparse.ArgumentParser(
description="chainer implementation of pix2pix")
parser.add_argument("--batchsize",
"-b",
type=int,
default=1,
help="Number of images in each mini-batch")
parser.add_argument("--epoch",
"-e",
type=int,
default=40000,
help="Number of sweeps over the dataset to train")
parser.add_argument("--gpu",
"-g",
type=int,
default=-1,
help="GPU ID (negative value indicates CPU)")
parser.add_argument("--dataset",
"-i",
default="./input/png/",
help="Directory of image files.")
parser.add_argument("--out",
"-o",
default="D:/output/imasUtaConverter/",
help="Directory to output the result")
parser.add_argument("--resume",
"-r",
default="",
help="Resume the training from snapshot")
parser.add_argument("--seed", type=int, default=0, help="Random seed")
parser.add_argument("--snapshot_interval",
type=int,
default=10000,
help="Interval of snapshot")
parser.add_argument("--display_interval",
type=int,
default=20,
help="Interval of displaying log to console")
args = parser.parse_args()
print("GPU: {}".format(args.gpu))
print("# Minibatch-size: {}".format(args.batchsize))
print("# epoch: {}".format(args.epoch))
print("")
# Set up a neural network to train
enc = Encoder(in_ch=2)
dec = Decoder(out_ch=2)
dis = Discriminator(in_ch=2, out_ch=2)
if args.gpu >= 0:
chainer.backends.cuda.get_device_from_id(
args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), "hook_dec")
return optimizer
opt_enc = make_optimizer(enc)
opt_dec = make_optimizer(dec)
opt_dis = make_optimizer(dis)
train_d = FacadeDataset(args.dataset, data_range=(0, 38))
test_d = FacadeDataset(args.dataset, data_range=(38, 40))
#train_iter = chainer.iterators.MultiprocessIterator(train_d, args.batchsize, n_processes=4)
#test_iter = chainer.iterators.MultiprocessIterator(test_d, args.batchsize, n_processes=4)
train_iter = chainer.iterators.SerialIterator(train_d, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_d, args.batchsize)
# Set up a trainer
updater = FacadeUpdater(models=(enc, dec, dis),
iterator={
"main": train_iter,
"test": test_iter
},
optimizer={
"enc": opt_enc,
"dec": opt_dec,
"dis": opt_dis
},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, "epoch"), out=args.out)
snapshot_interval = (args.snapshot_interval, "iteration")
display_interval = (args.display_interval, "iteration")
trainer.extend(
extensions.snapshot(filename="snapshot_iter_{.updater.iteration}.npz"),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
enc, "enc_iter_{.updater.iteration}.npz"),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dec, "dec_iter_{.updater.iteration}.npz"),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dis, "dis_iter_{.updater.iteration}.npz"),
trigger=snapshot_interval)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
"epoch",
"iteration",
"enc/loss",
"dec/loss",
"dis/loss",
]),
trigger=display_interval)
#trainer.extend(extensions.PlotReport(["enc/loss", "dis/loss"], x_key="epoch", file_name="loss.png"))
trainer.extend(extensions.ProgressBar(update_interval=20))
trainer.extend(out_image(updater, enc, dec, 1, 10, args.seed, args.out),
trigger=snapshot_interval)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(
description='chainer implementation of pix2pix')
parser.add_argument('--batchsize',
'-b',
type=int,
default=1,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=500,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result_dehighlight',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--seed', type=int, default=0, help='Random seed')
parser.add_argument('--snapshot_interval',
type=int,
default=10000,
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=10000,
help='Interval of displaying log to console')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train
enc = Encoder(in_ch=3)
dec = Decoder(out_ch=1)
dis = Discriminator(in_ch=3, out_ch=1)
gen = Generator(in_ch=3, out_ch=1)
serializers.load_npz("depro.npz", depro)
gen.encoder = enc
gen.decoder = dec
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
dis.to_gpu()
gen.to_gpu()
depro.disable_update()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
opt_enc = make_optimizer(enc)
opt_dec = make_optimizer(dec)
opt_dis = make_optimizer(dis)
#will fix
train_d = NyuDataset("E:/nyu_depth_v2_labeled.mat",
startnum=0,
endnum=1000)
test_d = NyuDataset("E:/nyu_depth_v2_labeled.mat",
startnum=1000,
endnum=1449)
#train_iter = chainer.iterators.MultiprocessIterator(train_d, args.batchsize, n_processes=4)
#test_iter = chainer.iterators.MultiprocessIterator(test_d, args.batchsize, n_processes=4)
train_iter = chainer.iterators.SerialIterator(train_d, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_d, args.batchsize)
test_iter2 = chainer.iterators.SerialIterator(test_d,
args.batchsize,
repeat=False,
shuffle=False)
# Set up a trainer
updater = PicUpdater(models=(enc, dec, dis),
iterator={
'main': train_iter,
'test': test_iter
},
optimizer={
'enc': opt_enc,
'dec': opt_dec,
'dis': opt_dis
},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
enc, 'enc_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dec, 'dec_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'enc/loss_enc', 'dec/loss_dec', 'dis/loss_dis',
"validation/main/loss"
]),
trigger=display_interval)
trainer.extend(extensions.Evaluator(test_iter2, gen, device=args.gpu))
trainer.extend(
extensions.PlotReport(['dec/loss_dec'],
x_key='iteration',
file_name='dec_loss.png',
trigger=display_interval))
trainer.extend(
extensions.PlotReport(['dis/loss_dis'],
x_key='iteration',
file_name='dis_loss.png',
trigger=display_interval))
trainer.extend(
extensions.PlotReport(["validation/main/loss"],
x_key='iteration',
file_name='gen_loss.png',
trigger=display_interval))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_image(updater, depro, enc, dec, 3, 3, args.seed,
args.out),
trigger=snapshot_interval)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='chainer implementation of pix2pix')
parser.add_argument('--batchsize', '-b', type=int, default=1,
help='Number of images in each mini-batch')
parser.add_argument('--epoch', '-e', type=int, default=200,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--dataset', '-i', default='./facade/base',
help='Directory of image files.')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
parser.add_argument('--seed', type=int, default=0,
help='Random seed')
parser.add_argument('--snapshot_interval', type=int, default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval', type=int, default=100,
help='Interval of displaying log to console')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train
enc = Encoder(in_ch=12)
dec = Decoder(out_ch=3)
dis = Discriminator(in_ch=12, out_ch=3)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
opt_enc = make_optimizer(enc)
opt_dec = make_optimizer(dec)
opt_dis = make_optimizer(dis)
train_d = FacadeDataset(args.dataset, data_range=(1,300))
test_d = FacadeDataset(args.dataset, data_range=(300,379))
#train_iter = chainer.iterators.MultiprocessIterator(train_d, args.batchsize, n_processes=4)
#test_iter = chainer.iterators.MultiprocessIterator(test_d, args.batchsize, n_processes=4)
train_iter = chainer.iterators.SerialIterator(train_d, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_d, args.batchsize)
# Set up a trainer
updater = FacadeUpdater(
models=(enc, dec, dis),
iterator={
'main': train_iter,
'test': test_iter},
optimizer={
'enc': opt_enc, 'dec': opt_dec,
'dis': opt_dis},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
trainer.extend(extensions.snapshot(
filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
enc, 'enc_iter_{.updater.iteration}.npz'), trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dec, 'dec_iter_{.updater.iteration}.npz'), trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_iter_{.updater.iteration}.npz'), trigger=snapshot_interval)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'enc/loss', 'dec/loss', 'dis/loss',
]), trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(
out_image(
updater, enc, dec,
5, 5, args.seed, args.out),
trigger=snapshot_interval)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='chainer implementation of pix2pix')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--img', '-i', help='Input image')
parser.add_argument('--out', '-o', default='result_dehighlight',
help='Directory to output the result')
args = parser.parse_args()
ENC_W = os.path.join(args.out, "enc_iter_2500000.npz")
#DEC_W = "trained_model/dec_iter_176000.npz"
# to avoid GitHub 100M limit, one .npz files are divided into two zip files.
DEC_Ws = [os.path.join(args.out, "dec_iter_2500000.npz")]
#shutil.copy("net.py", args.out)
# Set up a neural network to train
enc = Encoder(in_ch=3)
dec = Decoder(out_ch=3)
chainer.serializers.load_npz(ENC_W, enc)
# to avoid GitHub 100M limit, 1 .npz file is devided into 2 files
for npzfile in DEC_Ws:
with np.load(npzfile) as f:
d = NpzDeserializer(f, strict=False)
d.load(dec)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
inimg = loadimg(args.img)
ch, h, w = inimg.shape
# add paddings so that input array has the size of mutiples of 256.
in_ary = np.zeros((ch,math.ceil(h/256)*256, math.ceil(w/256)*256), dtype="f")
in_ary[:,0:h,0:w] = inimg
x_in = in_ary[np.newaxis,:] # to fit into the minibatch shape
print(x_in.shape)
# x_in as an input image
x_in = chainer.Variable(x_in)
if args.gpu >= 0:
x_in.to_gpu()
st = time.time()
for i in tqdm(range(10)):
z = enc(x_in)
x_out = dec(z)
ts = (time.time() - st)/10
print("mean estimation time:{:.2f}".format(ts))
with open(os.path.join(args.out, "time.txt"), "a") as f:
f.write("gpu:{}, time:{:.4f}, FPS:{:.4f}\n".format(args.gpu, ts, 1/ts))
if args.gpu >= 0:
out_ary = x_out.data.get()[0]
else:
out_ary = x_out.data[0]
#img_show = np.zeros((inimg.shape[0], inimg.shape[1], inimg.shape[2]*2))
#img_show[:,:,:inimg.shape[2]] = inimg
#img_show[:,:outimg.shape[1],inimg.shape[2]:inimg.shape[2]+outimg.shape[2]] = outimg
outimg = out_ary[:,0:h,0:w] # trim paddings
img_show = np.concatenate((inimg, outimg), axis=2)
bgrpic = to_bgr(img_show).copy()
cv2.putText(bgrpic,"input",(3,15),cv2.FONT_HERSHEY_DUPLEX, 0.5,(255,0,0))
cv2.putText(bgrpic,"output",(w+3,15),cv2.FONT_HERSHEY_DUPLEX, 0.5,(255,0,0))
cv2.imshow("result", bgrpic)
cv2.waitKey(0)
cv2.destroyAllWindows()
def main():
parser = argparse.ArgumentParser(
description='chainer implementation of pix2pix')
parser.add_argument('--batchsize',
'-b',
type=int,
default=1,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=200,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--dataset',
'-i',
default='./facade/base',
help='Directory of image files.')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--seed', type=int, default=0, help='Random seed')
parser.add_argument('--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train
enc = Encoder(in_ch=12)
dec = Decoder(out_ch=3)
dis = Discriminator(in_ch=12, out_ch=3)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
enc.to_gpu() # Copy the model to the GPU
dec.to_gpu()
dis.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
opt_enc = make_optimizer(enc)
opt_dec = make_optimizer(dec)
opt_dis = make_optimizer(dis)
train_d = FacadeDataset(args.dataset, data_range=(1, 300))
test_d = FacadeDataset(args.dataset, data_range=(300, 379))
#train_iter = chainer.iterators.MultiprocessIterator(train_d, args.batchsize, n_processes=4)
#test_iter = chainer.iterators.MultiprocessIterator(test_d, args.batchsize, n_processes=4)
train_iter = chainer.iterators.SerialIterator(train_d, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_d, args.batchsize)
# Set up a trainer
updater = FacadeUpdater(models=(enc, dec, dis),
iterator={
'main': train_iter,
'test': test_iter
},
optimizer={
'enc': opt_enc,
'dec': opt_dec,
'dis': opt_dis
},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
enc, 'enc_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dec, 'dec_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
dis, 'dis_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch',
'iteration',
'enc/loss',
'dec/loss',
'dis/loss',
]),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_image(updater, enc, dec, 5, 5, args.seed, args.out),
trigger=snapshot_interval)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
from net import Decoder
import torch
import matplotlib.pyplot as plt
input_data = torch.tensor([48.2976, -2.0373, -29.1018, 12.2312])
# input_data = torch.tensor([23.9500, -11.1840, 36.5084, -33.9963])
# input_data = torch.tensor([9.9927, -0.2395, -1.1840, -2.4094])
# input_data = torch.tensor([20.2314, -10.3747, 11.7729, -8.3415])
# input_data = torch.tensor([6.8456, 5.0325, -4.7677, -0.9231])
# input_data = torch.tensor([12.7765, -8.3813, 9.4535, -3.7266])
# input_data = torch.tensor([5.8932, 0.2757, -5.0638, 6.0578])
# input_data = torch.tensor([7.7216, 11.7913, 1.8647, -13.9440])
# input_data = torch.tensor([8.0073, -0.2398, 7.3321, -9.5089])
# input_data = torch.tensor([2.0922, 4.1933, -0.1578, -3.3220])
# input_data = (torch.randn(4))*50
print(input_data)
decoder = Decoder().eval()
model_dict = decoder.state_dict()
pretrained_dict = torch.load('model/net.pth')
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
model_dict.update(pretrained_dict)
decoder.load_state_dict(model_dict)
with torch.no_grad():
output = decoder(input_data)
plt.imshow(output[0], cmap='gray')
plt.show()
