def build_model(self):
data_shape = [-1, 3, self.cfg.image_size, self.cfg.image_size]
image_real = fluid.layers.data(
name='image_real', shape=data_shape, dtype='float32')
label_org = fluid.layers.data(
name='label_org', shape=[self.cfg.c_dim], dtype='float32')
label_trg = fluid.layers.data(
name='label_trg', shape=[self.cfg.c_dim], dtype='float32')
gen_trainer = GTrainer(image_real, label_org, label_trg, self.cfg,
self.batch_num)
dis_trainer = DTrainer(image_real, label_org, label_trg, self.cfg,
self.batch_num)
# prepare environment
place = fluid.CUDAPlace(0) if self.cfg.use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
if self.cfg.init_model:
utility.init_checkpoints(self.cfg, exe, gen_trainer, "net_G")
utility.init_checkpoints(self.cfg, exe, dis_trainer, "net_D")
### memory optim
build_strategy = fluid.BuildStrategy()
build_strategy.enable_inplace = False
build_strategy.memory_optimize = False
gen_trainer_program = fluid.CompiledProgram(
gen_trainer.program).with_data_parallel(
loss_name=gen_trainer.g_loss.name,
build_strategy=build_strategy)
dis_trainer_program = fluid.CompiledProgram(
dis_trainer.program).with_data_parallel(
loss_name=dis_trainer.d_loss.name,
build_strategy=build_strategy)
t_time = 0
for epoch_id in range(self.cfg.epoch):
batch_id = 0
for i in range(self.batch_num):
image, label_org = next(self.train_reader())
label_trg = copy.deepcopy(label_org)
np.random.shuffle(label_trg)
tensor_img = fluid.LoDTensor()
tensor_label_org = fluid.LoDTensor()
tensor_label_trg = fluid.LoDTensor()
tensor_img.set(image, place)
tensor_label_org.set(label_org, place)
tensor_label_trg.set(label_trg, place)
s_time = time.time()
# optimize the discriminator network
d_loss_real, d_loss_fake, d_loss, d_loss_cls, d_loss_gp = exe.run(
dis_trainer_program,
fetch_list=[
dis_trainer.d_loss_real, dis_trainer.d_loss_fake,
dis_trainer.d_loss, dis_trainer.d_loss_cls,
dis_trainer.d_loss_gp
],
feed={
"image_real": tensor_img,
"label_org": tensor_label_org,
"label_trg": tensor_label_trg
})
# optimize the generator network
if (batch_id + 1) % self.cfg.n_critic == 0:
g_loss_fake, g_loss_rec, g_loss_cls, fake_img, rec_img = exe.run(
gen_trainer_program,
fetch_list=[
gen_trainer.g_loss_fake, gen_trainer.g_loss_rec,
gen_trainer.g_loss_cls, gen_trainer.fake_img,
gen_trainer.rec_img
],
feed={
"image_real": tensor_img,
"label_org": tensor_label_org,
"label_trg": tensor_label_trg
})
print("epoch{}: batch{}: \n\
g_loss_fake: {}; g_loss_rec: {}; g_loss_cls: {}"
.format(epoch_id, batch_id, g_loss_fake[0],
g_loss_rec[0], g_loss_cls[0]))
batch_time = time.time() - s_time
t_time += batch_time
if batch_id % self.cfg.print_freq == 0:
print("epoch{}: batch{}: \n\
d_loss_real: {}; d_loss_fake: {}; d_loss_cls: {}; d_loss_gp: {} \n\
Batch_time_cost: {:.2f}".format(
epoch_id, batch_id, d_loss_real[0], d_loss_fake[
0], d_loss_cls[0], d_loss_gp[0], batch_time))
sys.stdout.flush()
batch_id += 1
if self.cfg.run_test:
test_program = gen_trainer.infer_program
utility.save_test_image(epoch_id, self.cfg, exe, place,
test_program, gen_trainer,
self.test_reader)
if self.cfg.save_checkpoints:
utility.checkpoints(epoch_id, self.cfg, exe, gen_trainer,
"net_G")
utility.checkpoints(epoch_id, self.cfg, exe, dis_trainer,
"net_D")
def build_model(self):
data_shape = [-1, 3, self.cfg.crop_size, self.cfg.crop_size]
input_A = fluid.layers.data(
name='input_A', shape=data_shape, dtype='float32')
input_B = fluid.layers.data(
name='input_B', shape=data_shape, dtype='float32')
input_fake = fluid.layers.data(
name='input_fake', shape=data_shape, dtype='float32')
py_reader = fluid.io.PyReader(
feed_list=[input_A, input_B],
capacity=4, ## batch_size * 4
iterable=True,
use_double_buffer=True)
gen_trainer = GTrainer(input_A, input_B, self.cfg, self.batch_num)
dis_trainer = DTrainer(input_A, input_B, input_fake, self.cfg,
self.batch_num)
# prepare environment
place = fluid.CUDAPlace(0) if self.cfg.use_gpu else fluid.CPUPlace()
py_reader.decorate_batch_generator(self.train_reader, places=place)
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
if self.cfg.init_model:
utility.init_checkpoints(self.cfg, exe, gen_trainer, "net_G")
utility.init_checkpoints(self.cfg, exe, dis_trainer, "net_D")
### memory optim
build_strategy = fluid.BuildStrategy()
build_strategy.enable_inplace = False
gen_trainer_program = fluid.CompiledProgram(
gen_trainer.program).with_data_parallel(
loss_name=gen_trainer.g_loss.name,
build_strategy=build_strategy)
dis_trainer_program = fluid.CompiledProgram(
dis_trainer.program).with_data_parallel(
loss_name=dis_trainer.d_loss.name,
build_strategy=build_strategy)
t_time = 0
for epoch_id in range(self.cfg.epoch):
batch_id = 0
for tensor in py_reader():
s_time = time.time()
tensor_A, tensor_B = tensor[0]['input_A'], tensor[0]['input_B']
# optimize the generator network
g_loss_gan, g_loss_l1, fake_B_tmp = exe.run(
gen_trainer_program,
fetch_list=[
gen_trainer.g_loss_gan, gen_trainer.g_loss_L1,
gen_trainer.fake_B
],
feed=tensor)
# optimize the discriminator network
d_loss_real, d_loss_fake = exe.run(dis_trainer_program,
fetch_list=[
dis_trainer.d_loss_real,
dis_trainer.d_loss_fake
],
feed={
"input_A": tensor_A,
"input_B": tensor_B,
"input_fake": fake_B_tmp
})
batch_time = time.time() - s_time
t_time += batch_time
if batch_id % self.cfg.print_freq == 0:
print("epoch{}: batch{}: \n\
g_loss_gan: {}; g_loss_l1: {}; \n\
d_loss_real: {}; d_loss_fake: {}; \n\
Batch_time_cost: {}"
.format(epoch_id, batch_id, g_loss_gan[0], g_loss_l1[
0], d_loss_real[0], d_loss_fake[0], batch_time))
sys.stdout.flush()
batch_id += 1
if self.cfg.run_test:
image_name = fluid.layers.data(
name='image_name',
shape=[self.cfg.batch_size],
dtype="int32")
test_py_reader = fluid.io.PyReader(
feed_list=[input_A, input_B, image_name],
capacity=4, ## batch_size * 4
iterable=True,
use_double_buffer=True)
test_py_reader.decorate_batch_generator(
self.test_reader, places=place)
test_program = gen_trainer.infer_program
utility.save_test_image(
epoch_id,
self.cfg,
exe,
place,
test_program,
gen_trainer,
test_py_reader,
A_id2name=self.id2name)
if self.cfg.save_checkpoints:
utility.checkpoints(epoch_id, self.cfg, exe, gen_trainer,
"net_G")
utility.checkpoints(epoch_id, self.cfg, exe, dis_trainer,
"net_D")
def build_model(self):
img = fluid.layers.data(name='img', shape=[784], dtype='float32')
condition = fluid.layers.data(name='condition',
shape=[1],
dtype='float32')
noise = fluid.layers.data(name='noise',
shape=[self.cfg.noise_size],
dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='float32')
g_trainer = GTrainer(noise, condition, self.cfg)
d_trainer = DTrainer(img, condition, label, self.cfg)
# prepare environment
place = fluid.CUDAPlace(0) if self.cfg.use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
const_n = np.random.uniform(
low=-1.0,
high=1.0,
size=[self.cfg.batch_size, self.cfg.noise_size]).astype('float32')
if self.cfg.init_model:
utility.init_checkpoints(self.cfg, exe, g_trainer, "net_G")
utility.init_checkpoints(self.cfg, exe, d_trainer, "net_D")
### memory optim
build_strategy = fluid.BuildStrategy()
build_strategy.enable_inplace = True
g_trainer_program = fluid.CompiledProgram(
g_trainer.program).with_data_parallel(
loss_name=g_trainer.g_loss.name, build_strategy=build_strategy)
d_trainer_program = fluid.CompiledProgram(
d_trainer.program).with_data_parallel(
loss_name=d_trainer.d_loss.name, build_strategy=build_strategy)
t_time = 0
losses = [[], []]
for epoch_id in range(self.cfg.epoch):
for batch_id, data in enumerate(self.train_reader()):
if len(data) != self.cfg.batch_size:
continue
noise_data = np.random.uniform(
low=-1.0,
high=1.0,
size=[self.cfg.batch_size,
self.cfg.noise_size]).astype('float32')
real_image = np.array(list(map(lambda x: x[0], data))).reshape(
[-1, 784]).astype('float32')
condition_data = np.array([x[1] for x in data
]).reshape([-1,
1]).astype('float32')
real_label = np.ones(shape=[real_image.shape[0], 1],
dtype='float32')
fake_label = np.zeros(shape=[real_image.shape[0], 1],
dtype='float32')
s_time = time.time()
generate_image = exe.run(g_trainer.infer_program,
feed={
'noise': noise_data,
'condition': condition_data
},
fetch_list=[g_trainer.fake])
d_real_loss = exe.run(d_trainer_program,
feed={
'img': real_image,
'condition': condition_data,
'label': real_label
},
fetch_list=[d_trainer.d_loss])[0]
d_fake_loss = exe.run(d_trainer_program,
feed={
'img': generate_image,
'condition': condition_data,
'label': fake_label
},
fetch_list=[d_trainer.d_loss])[0]
d_loss = d_real_loss + d_fake_loss
losses[1].append(d_loss)
for _ in six.moves.xrange(self.cfg.num_generator_time):
g_loss = exe.run(g_trainer_program,
feed={
'noise': noise_data,
'condition': condition_data
},
fetch_list=[g_trainer.g_loss])[0]
losses[0].append(g_loss)
batch_time = time.time() - s_time
t_time += batch_time
if batch_id % self.cfg.print_freq == 0:
image_path = os.path.join(self.cfg.output, 'images')
if not os.path.exists(image_path):
os.makedirs(image_path)
generate_const_image = exe.run(g_trainer.infer_program,
feed={
'noise': const_n,
'condition':
condition_data
},
fetch_list=[g_trainer.fake
])[0]
generate_image_reshape = np.reshape(
generate_const_image, (self.cfg.batch_size, -1))
total_images = np.concatenate(
[real_image, generate_image_reshape])
fig = utility.plot(total_images)
print(
'Epoch ID: {} Batch ID: {} D_loss: {} G_loss: {} Batch_time_cost: {}'
.format(epoch_id, batch_id, d_loss[0], g_loss[0],
batch_time))
plt.title('Epoch ID={}, Batch ID={}'.format(
epoch_id, batch_id))
img_name = '{:04d}_{:04d}.png'.format(epoch_id, batch_id)
plt.savefig(os.path.join(image_path, img_name),
bbox_inches='tight')
plt.close(fig)
if self.cfg.save_checkpoints:
utility.checkpoints(epoch_id, self.cfg, exe, g_trainer,
"net_G")
utility.checkpoints(epoch_id, self.cfg, exe, d_trainer,
"net_D")
def build_model(self):
data_shape = [-1, 3, self.cfg.image_size, self.cfg.image_size]
image_real = fluid.layers.data(
name='image_real', shape=data_shape, dtype='float32')
label_org = fluid.layers.data(
name='label_org', shape=[self.cfg.c_dim], dtype='float32')
label_trg = fluid.layers.data(
name='label_trg', shape=[self.cfg.c_dim], dtype='float32')
py_reader = fluid.io.PyReader(
feed_list=[image_real, label_org, label_trg],
capacity=128,
iterable=True,
use_double_buffer=True)
gen_trainer = GTrainer(image_real, label_org, label_trg, self.cfg,
self.batch_num)
dis_trainer = DTrainer(image_real, label_org, label_trg, self.cfg,
self.batch_num)
# prepare environment
place = fluid.CUDAPlace(0) if self.cfg.use_gpu else fluid.CPUPlace()
py_reader.decorate_batch_generator(self.train_reader, places=place)
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
if self.cfg.init_model:
utility.init_checkpoints(self.cfg, exe, gen_trainer, "net_G")
utility.init_checkpoints(self.cfg, exe, dis_trainer, "net_D")
### memory optim
build_strategy = fluid.BuildStrategy()
build_strategy.enable_inplace = False
gen_trainer_program = fluid.CompiledProgram(
gen_trainer.program).with_data_parallel(
loss_name=gen_trainer.g_loss.name,
build_strategy=build_strategy)
dis_trainer_program = fluid.CompiledProgram(
dis_trainer.program).with_data_parallel(
loss_name=dis_trainer.d_loss.name,
build_strategy=build_strategy)
t_time = 0
for epoch_id in range(self.cfg.epoch):
batch_id = 0
for data in py_reader():
s_time = time.time()
d_loss_real, d_loss_fake, d_loss, d_loss_cls, d_loss_gp = exe.run(
dis_trainer_program,
fetch_list=[
dis_trainer.d_loss_real, dis_trainer.d_loss_fake,
dis_trainer.d_loss, dis_trainer.d_loss_cls,
dis_trainer.d_loss_gp
],
feed=data)
# optimize the generator network
if (batch_id + 1) % self.cfg.n_critic == 0:
g_loss_fake, g_loss_rec, g_loss_cls, fake_img, rec_img = exe.run(
gen_trainer_program,
fetch_list=[
gen_trainer.g_loss_fake, gen_trainer.g_loss_rec,
gen_trainer.g_loss_cls, gen_trainer.fake_img,
gen_trainer.rec_img
],
feed=data)
print("epoch{}: batch{}: \n\
g_loss_fake: {}; g_loss_rec: {}; g_loss_cls: {}"
.format(epoch_id, batch_id, g_loss_fake[0],
g_loss_rec[0], g_loss_cls[0]))
batch_time = time.time() - s_time
t_time += batch_time
if (batch_id + 1) % self.cfg.print_freq == 0:
print("epoch{}: batch{}: \n\
d_loss_real: {}; d_loss_fake: {}; d_loss_cls: {}; d_loss_gp: {} \n\
Batch_time_cost: {}".format(
epoch_id, batch_id, d_loss_real[0], d_loss_fake[
0], d_loss_cls[0], d_loss_gp[0], batch_time))
sys.stdout.flush()
batch_id += 1
if self.cfg.run_test:
image_name = fluid.layers.data(
name='image_name',
shape=[self.cfg.n_samples],
dtype='int32')
test_py_reader = fluid.io.PyReader(
feed_list=[image_real, label_org, label_trg, image_name],
capacity=32,
iterable=True,
use_double_buffer=True)
test_py_reader.decorate_batch_generator(
self.test_reader, places=place)
test_program = gen_trainer.infer_program
utility.save_test_image(epoch_id, self.cfg, exe, place,
test_program, gen_trainer,
test_py_reader)
if self.cfg.save_checkpoints:
utility.checkpoints(epoch_id, self.cfg, exe, gen_trainer,
"net_G")
utility.checkpoints(epoch_id, self.cfg, exe, dis_trainer,
"net_D")
def build_model(self):
data_shape = [None, 3, self.cfg.crop_height, self.cfg.crop_width]
label_shape = [
None, self.cfg.label_nc, self.cfg.crop_height, self.cfg.crop_width
]
edge_shape = [None, 1, self.cfg.crop_height, self.cfg.crop_width]
input_A = fluid.data(name='input_label',
shape=label_shape,
dtype='float32')
input_B = fluid.data(name='input_img',
shape=data_shape,
dtype='float32')
input_C = fluid.data(name='input_ins',
shape=edge_shape,
dtype='float32')
input_fake = fluid.data(name='input_fake',
shape=data_shape,
dtype='float32')
# used for continuous evaluation
if self.cfg.enable_ce:
fluid.default_startup_program().random_seed = 90
gen_trainer = GTrainer(input_A, input_B, input_C, self.cfg,
self.batch_num)
dis_trainer = DTrainer(input_A, input_B, input_C, input_fake, self.cfg,
self.batch_num)
loader = fluid.io.DataLoader.from_generator(
feed_list=[input_A, input_B, input_C],
capacity=4, ## batch_size * 4
iterable=True,
use_double_buffer=True)
loader.set_batch_generator(self.train_reader,
places=fluid.cuda_places()
if self.cfg.use_gpu else fluid.cpu_places())
# prepare environment
place = fluid.CUDAPlace(0) if self.cfg.use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
if not os.path.exists(self.cfg.vgg19_pretrain):
print(
"directory VGG19_pretrain NOT EXIST!!! Please download VGG19 first."
)
sys.exit(1)
gen_trainer.vgg.load_vars(exe, gen_trainer.program,
self.cfg.vgg19_pretrain)
if self.cfg.init_model:
utility.init_checkpoints(self.cfg, gen_trainer, "net_G")
utility.init_checkpoints(self.cfg, dis_trainer, "net_D")
### memory optim
build_strategy = fluid.BuildStrategy()
build_strategy.enable_inplace = True
build_strategy.sync_batch_norm = False
gen_trainer_program = fluid.CompiledProgram(
gen_trainer.program).with_data_parallel(
loss_name=gen_trainer.g_loss.name,
build_strategy=build_strategy)
dis_trainer_program = fluid.CompiledProgram(
dis_trainer.program).with_data_parallel(
loss_name=dis_trainer.d_loss.name,
build_strategy=build_strategy)
# used for continuous evaluation
if self.cfg.enable_ce:
gen_trainer_program.random_seed = 90
dis_trainer_program.random_seed = 90
t_time = 0
for epoch_id in range(self.cfg.epoch):
batch_id = 0
for tensor in loader():
data_A, data_B, data_C = tensor[0]['input_label'], tensor[0][
'input_img'], tensor[0]['input_ins']
s_time = time.time()
# optimize the generator network
g_loss_gan, g_loss_vgg, g_loss_feat, fake_B_tmp = exe.run(
gen_trainer_program,
fetch_list=[
gen_trainer.gan_loss, gen_trainer.vgg_loss,
gen_trainer.gan_feat_loss, gen_trainer.fake_B
],
feed={
"input_label": data_A,
"input_img": data_B,
"input_ins": data_C
})
# optimize the discriminator network
d_loss_real, d_loss_fake = exe.run(
dis_trainer_program,
fetch_list=[
dis_trainer.gan_loss_real, dis_trainer.gan_loss_fake
],
feed={
"input_label": data_A,
"input_img": data_B,
"input_ins": data_C,
"input_fake": fake_B_tmp
})
batch_time = time.time() - s_time
t_time += batch_time
if batch_id % self.cfg.print_freq == 0:
print("epoch{}: batch{}: \n\
g_loss_gan: {}; g_loss_vgg: {}; g_loss_feat: {} \n\
d_loss_real: {}; d_loss_fake: {}; \n\
Batch_time_cost: {:.2f}".format(
epoch_id, batch_id, g_loss_gan[0], g_loss_vgg[0],
g_loss_feat[0], d_loss_real[0], d_loss_fake[0],
batch_time))
sys.stdout.flush()
batch_id += 1
if self.cfg.run_test:
test_program = gen_trainer.infer_program
image_name = fluid.data(name='image_name',
shape=[None, self.cfg.batch_size],
dtype="int32")
test_loader = fluid.io.DataLoader.from_generator(
feed_list=[input_A, input_B, input_C, image_name],
capacity=4, ## batch_size * 4
iterable=True,
use_double_buffer=True)
test_loader.set_batch_generator(
self.test_reader,
places=fluid.cuda_places()
if self.cfg.use_gpu else fluid.cpu_places())
utility.save_test_image(epoch_id,
self.cfg,
exe,
place,
test_program,
gen_trainer,
test_loader,
A_id2name=self.id2name)
if self.cfg.save_checkpoints:
utility.checkpoints(epoch_id, self.cfg, gen_trainer, "net_G")
utility.checkpoints(epoch_id, self.cfg, dis_trainer, "net_D")
# used for continuous evaluation
if self.cfg.enable_ce:
device_num = fluid.core.get_cuda_device_count(
) if self.cfg.use_gpu else 1
print("kpis\tspade_g_loss_gan_card{}\t{}".format(
device_num, g_loss_gan[0]))
print("kpis\tspade_g_loss_vgg_card{}\t{}".format(
device_num, g_loss_vgg[0]))
print("kpis\tspade_g_loss_feat_card{}\t{}".format(
device_num, g_loss_feat[0]))
print("kpis\tspade_d_loss_real_card{}\t{}".format(
device_num, d_loss_real[0]))
print("kpis\tspade_d_loss_fake_card{}\t{}".format(
device_num, d_loss_fake[0]))
print("kpis\tspade_Batch_time_cost_card{}\t{}".format(
device_num, batch_time))
def build_model(self):
data_shape = [None, 3, self.cfg.crop_size, self.cfg.crop_size]
input_A = fluid.data(name='input_A', shape=data_shape, dtype='float32')
input_B = fluid.data(name='input_B', shape=data_shape, dtype='float32')
fake_pool_A = fluid.data(
name='fake_pool_A', shape=data_shape, dtype='float32')
fake_pool_B = fluid.data(
name='fake_pool_B', shape=data_shape, dtype='float32')
# used for continuous evaluation
if self.cfg.enable_ce:
fluid.default_startup_program().random_seed = 90
A_py_reader = fluid.io.PyReader(
feed_list=[input_A],
capacity=4,
iterable=True,
use_double_buffer=True)
B_py_reader = fluid.io.PyReader(
feed_list=[input_B],
capacity=4,
iterable=True,
use_double_buffer=True)
gen_trainer = GTrainer(input_A, input_B, self.cfg, self.batch_num)
d_A_trainer = DATrainer(input_B, fake_pool_B, self.cfg, self.batch_num)
d_B_trainer = DBTrainer(input_A, fake_pool_A, self.cfg, self.batch_num)
# prepare environment
place = fluid.CUDAPlace(0) if self.cfg.use_gpu else fluid.CPUPlace()
A_py_reader.decorate_batch_generator(
self.A_reader,
places=fluid.cuda_places()
if self.cfg.use_gpu else fluid.cpu_places())
B_py_reader.decorate_batch_generator(
self.B_reader,
places=fluid.cuda_places()
if self.cfg.use_gpu else fluid.cpu_places())
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
A_pool = utility.ImagePool()
B_pool = utility.ImagePool()
if self.cfg.init_model:
utility.init_checkpoints(self.cfg, exe, gen_trainer, "net_G")
utility.init_checkpoints(self.cfg, exe, d_A_trainer, "net_DA")
utility.init_checkpoints(self.cfg, exe, d_B_trainer, "net_DB")
### memory optim
build_strategy = fluid.BuildStrategy()
build_strategy.enable_inplace = True
gen_trainer_program = fluid.CompiledProgram(
gen_trainer.program).with_data_parallel(
loss_name=gen_trainer.g_loss.name,
build_strategy=build_strategy)
d_A_trainer_program = fluid.CompiledProgram(
d_A_trainer.program).with_data_parallel(
loss_name=d_A_trainer.d_loss_A.name,
build_strategy=build_strategy)
d_B_trainer_program = fluid.CompiledProgram(
d_B_trainer.program).with_data_parallel(
loss_name=d_B_trainer.d_loss_B.name,
build_strategy=build_strategy)
t_time = 0
for epoch_id in range(self.cfg.epoch):
batch_id = 0
for data_A, data_B in zip(A_py_reader(), B_py_reader()):
s_time = time.time()
tensor_A, tensor_B = data_A[0]['input_A'], data_B[0]['input_B']
## optimize the g_A network
g_A_loss, g_A_cyc_loss, g_A_idt_loss, g_B_loss, g_B_cyc_loss,\
g_B_idt_loss, fake_A_tmp, fake_B_tmp = exe.run(
gen_trainer_program,
fetch_list=[
gen_trainer.G_A, gen_trainer.cyc_A_loss,
gen_trainer.idt_loss_A, gen_trainer.G_B,
gen_trainer.cyc_B_loss, gen_trainer.idt_loss_B,
gen_trainer.fake_A, gen_trainer.fake_B
],
feed={"input_A": tensor_A,
"input_B": tensor_B})
fake_pool_B = B_pool.pool_image(fake_B_tmp)
fake_pool_A = A_pool.pool_image(fake_A_tmp)
if self.cfg.enable_ce:
fake_pool_B = fake_B_tmp
fake_pool_A = fake_A_tmp
# optimize the d_A network
d_A_loss = exe.run(
d_A_trainer_program,
fetch_list=[d_A_trainer.d_loss_A],
feed={"input_B": tensor_B,
"fake_pool_B": fake_pool_B})[0]
# optimize the d_B network
d_B_loss = exe.run(
d_B_trainer_program,
fetch_list=[d_B_trainer.d_loss_B],
feed={"input_A": tensor_A,
"fake_pool_A": fake_pool_A})[0]
batch_time = time.time() - s_time
t_time += batch_time
if batch_id % self.cfg.print_freq == 0:
print("epoch{}: batch{}: \n\
d_A_loss: {}; g_A_loss: {}; g_A_cyc_loss: {}; g_A_idt_loss: {}; \n\
d_B_loss: {}; g_B_loss: {}; g_B_cyc_loss: {}; g_B_idt_loss: {}; \n\
Batch_time_cost: {}".format(
epoch_id, batch_id, d_A_loss[0], g_A_loss[0],
g_A_cyc_loss[0], g_A_idt_loss[0], d_B_loss[0], g_B_loss[
0], g_B_cyc_loss[0], g_B_idt_loss[0], batch_time))
sys.stdout.flush()
batch_id += 1
# used for continuous evaluation
if self.cfg.enable_ce and batch_id == 10:
break
if self.cfg.run_test:
A_image_name = fluid.data(
name='A_image_name', shape=[None, 1], dtype='int32')
B_image_name = fluid.data(
name='B_image_name', shape=[None, 1], dtype='int32')
A_test_py_reader = fluid.io.PyReader(
feed_list=[input_A, A_image_name],
capacity=4,
iterable=True,
use_double_buffer=True)
B_test_py_reader = fluid.io.PyReader(
feed_list=[input_B, B_image_name],
capacity=4,
iterable=True,
use_double_buffer=True)
A_test_py_reader.decorate_batch_generator(
self.A_test_reader,
places=fluid.cuda_places()
if self.cfg.use_gpu else fluid.cpu_places())
B_test_py_reader.decorate_batch_generator(
self.B_test_reader,
places=fluid.cuda_places()
if self.cfg.use_gpu else fluid.cpu_places())
test_program = gen_trainer.infer_program
utility.save_test_image(
epoch_id,
self.cfg,
exe,
place,
test_program,
gen_trainer,
A_test_py_reader,
B_test_py_reader,
A_id2name=self.A_id2name,
B_id2name=self.B_id2name)
if self.cfg.save_checkpoints:
utility.checkpoints(epoch_id, self.cfg, exe, gen_trainer,
"net_G")
utility.checkpoints(epoch_id, self.cfg, exe, d_A_trainer,
"net_DA")
utility.checkpoints(epoch_id, self.cfg, exe, d_B_trainer,
"net_DB")
# used for continuous evaluation
if self.cfg.enable_ce:
device_num = fluid.core.get_cuda_device_count(
) if self.cfg.use_gpu else 1
print("kpis\tcyclegan_g_A_loss_card{}\t{}".format(device_num,
g_A_loss[0]))
print("kpis\tcyclegan_g_A_cyc_loss_card{}\t{}".format(
device_num, g_A_cyc_loss[0]))
print("kpis\tcyclegan_g_A_idt_loss_card{}\t{}".format(
device_num, g_A_idt_loss[0]))
print("kpis\tcyclegan_d_A_loss_card{}\t{}".format(device_num,
d_A_loss[0]))
print("kpis\tcyclegan_g_B_loss_card{}\t{}".format(device_num,
g_B_loss[0]))
print("kpis\tcyclegan_g_B_cyc_loss_card{}\t{}".format(
device_num, g_B_cyc_loss[0]))
print("kpis\tcyclegan_g_B_idt_loss_card{}\t{}".format(
device_num, g_B_idt_loss[0]))
print("kpis\tcyclegan_d_B_loss_card{}\t{}".format(device_num,
d_B_loss[0]))
print("kpis\tcyclegan_Batch_time_cost_card{}\t{}".format(
device_num, batch_time))
def build_model(self):
data_shape = [None, 3, self.cfg.image_size, self.cfg.image_size]
image_real = fluid.data(name='image_real',
shape=data_shape,
dtype='float32')
label_org = fluid.data(name='label_org',
shape=[None, self.cfg.c_dim],
dtype='float32')
label_trg = fluid.data(name='label_trg',
shape=[None, self.cfg.c_dim],
dtype='float32')
label_org_ = fluid.data(name='label_org_',
shape=[None, self.cfg.c_dim],
dtype='float32')
label_trg_ = fluid.data(name='label_trg_',
shape=[None, self.cfg.c_dim],
dtype='float32')
# used for continuous evaluation
if self.cfg.enable_ce:
fluid.default_startup_program().random_seed = 90
test_gen_trainer = GTrainer(image_real, label_org, label_org_,
label_trg, label_trg_, self.cfg,
self.batch_num)
loader = fluid.io.DataLoader.from_generator(
feed_list=[image_real, label_org, label_trg],
capacity=64,
iterable=True,
use_double_buffer=True)
label_org_ = (label_org * 2.0 - 1.0) * self.cfg.thres_int
label_trg_ = (label_trg * 2.0 - 1.0) * self.cfg.thres_int
gen_trainer = GTrainer(image_real, label_org, label_org_, label_trg,
label_trg_, self.cfg, self.batch_num)
dis_trainer = DTrainer(image_real, label_org, label_org_, label_trg,
label_trg_, self.cfg, self.batch_num)
# prepare environment
place = fluid.CUDAPlace(0) if self.cfg.use_gpu else fluid.CPUPlace()
loader.set_batch_generator(self.train_reader,
places=fluid.cuda_places()
if self.cfg.use_gpu else fluid.cpu_places())
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
if self.cfg.init_model:
utility.init_checkpoints(self.cfg, gen_trainer, "net_G")
utility.init_checkpoints(self.cfg, dis_trainer, "net_D")
### memory optim
build_strategy = fluid.BuildStrategy()
gen_trainer_program = fluid.CompiledProgram(
gen_trainer.program).with_data_parallel(
loss_name=gen_trainer.g_loss.name,
build_strategy=build_strategy)
dis_trainer_program = fluid.CompiledProgram(
dis_trainer.program).with_data_parallel(
loss_name=dis_trainer.d_loss.name,
build_strategy=build_strategy)
# used for continuous evaluation
if self.cfg.enable_ce:
gen_trainer_program.random_seed = 90
dis_trainer_program.random_seed = 90
t_time = 0
total_train_batch = 0 # used for benchmark
for epoch_id in range(self.cfg.epoch):
batch_id = 0
for data in loader():
if self.cfg.max_iter and total_train_batch == self.cfg.max_iter: # used for benchmark
return
s_time = time.time()
# optimize the discriminator network
fetches = [
dis_trainer.d_loss.name,
dis_trainer.d_loss_real.name,
dis_trainer.d_loss_fake.name,
dis_trainer.d_loss_cls.name,
dis_trainer.d_loss_gp.name,
]
d_loss, d_loss_real, d_loss_fake, d_loss_cls, d_loss_gp, = exe.run(
dis_trainer_program, fetch_list=fetches, feed=data)
if (batch_id + 1) % self.cfg.num_discriminator_time == 0:
# optimize the generator network
d_fetches = [
gen_trainer.g_loss_fake.name,
gen_trainer.g_loss_rec.name,
gen_trainer.g_loss_cls.name
]
g_loss_fake, g_loss_rec, g_loss_cls = exe.run(
gen_trainer_program, fetch_list=d_fetches, feed=data)
print("epoch{}: batch{}: \n\
g_loss_fake: {}; g_loss_rec: {}; g_loss_cls: {}".
format(epoch_id, batch_id, g_loss_fake[0],
g_loss_rec[0], g_loss_cls[0]))
batch_time = time.time() - s_time
t_time += batch_time
if (batch_id + 1) % self.cfg.print_freq == 0:
print("epoch{}: batch{}: \n\
d_loss: {}; d_loss_real: {}; d_loss_fake: {}; d_loss_cls: {}; d_loss_gp: {} \n\
Batch_time_cost: {}".format(epoch_id, batch_id,
d_loss[0], d_loss_real[0],
d_loss_fake[0],
d_loss_cls[0],
d_loss_gp[0], batch_time))
sys.stdout.flush()
batch_id += 1
if self.cfg.enable_ce and batch_id == 100:
break
total_train_batch += 1 # used for benchmark
# profiler tools
if self.cfg.profile and epoch_id == 0 and batch_id == self.cfg.print_freq:
profiler.reset_profiler()
elif self.cfg.profile and epoch_id == 0 and batch_id == self.cfg.print_freq + 5:
return
if self.cfg.run_test:
image_name = fluid.data(name='image_name',
shape=[None, self.cfg.n_samples],
dtype='int32')
test_loader = fluid.io.DataLoader.from_generator(
feed_list=[image_real, label_org, label_trg, image_name],
capacity=32,
iterable=True,
use_double_buffer=True)
test_loader.set_batch_generator(
self.test_reader,
places=fluid.cuda_places()
if self.cfg.use_gpu else fluid.cpu_places())
test_program = test_gen_trainer.infer_program
utility.save_test_image(epoch_id, self.cfg, exe, place,
test_program, test_gen_trainer,
test_loader)
if self.cfg.save_checkpoints:
utility.checkpoints(epoch_id, self.cfg, gen_trainer, "net_G")
utility.checkpoints(epoch_id, self.cfg, dis_trainer, "net_D")
# used for continuous evaluation
if self.cfg.enable_ce:
device_num = fluid.core.get_cuda_device_count(
) if self.cfg.use_gpu else 1
print("kpis\tstgan_g_loss_fake_card{}\t{}".format(
device_num, g_loss_fake[0]))
print("kpis\tstgan_g_loss_rec_card{}\t{}".format(
device_num, g_loss_rec[0]))
print("kpis\tstgan_g_loss_cls_card{}\t{}".format(
device_num, g_loss_cls[0]))
print("kpis\tstgan_d_loss_card{}\t{}".format(
device_num, d_loss[0]))
print("kpis\tstgan_d_loss_real_card{}\t{}".format(
device_num, d_loss_real[0]))
print("kpis\tstgan_d_loss_fake_card{}\t{}".format(
device_num, d_loss_fake[0]))
print("kpis\tstgan_d_loss_cls_card{}\t{}".format(
device_num, d_loss_cls[0]))
print("kpis\tstgan_d_loss_gp_card{}\t{}".format(
device_num, d_loss_gp[0]))
print("kpis\tstgan_Batch_time_cost_card{}\t{}".format(
device_num, batch_time))
def build_model(self):
data_shape = [None, 3, self.cfg.crop_size, self.cfg.crop_size]
input_A = fluid.data(name='input_A', shape=data_shape, dtype='float32')
input_B = fluid.data(name='input_B', shape=data_shape, dtype='float32')
input_fake = fluid.data(
name='input_fake', shape=data_shape, dtype='float32')
# used for continuous evaluation
if self.cfg.enable_ce:
fluid.default_startup_program().random_seed = 90
loader = fluid.io.DataLoader.from_generator(
feed_list=[input_A, input_B],
capacity=4,
iterable=True,
use_double_buffer=True)
gen_trainer = GTrainer(input_A, input_B, self.cfg, self.batch_num)
dis_trainer = DTrainer(input_A, input_B, input_fake, self.cfg,
self.batch_num)
# prepare environment
place = fluid.CUDAPlace(0) if self.cfg.use_gpu else fluid.CPUPlace()
loader.set_batch_generator(
self.train_reader,
places=fluid.cuda_places()
if self.cfg.use_gpu else fluid.cpu_places())
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
if self.cfg.init_model:
utility.init_checkpoints(self.cfg, gen_trainer, "net_G")
utility.init_checkpoints(self.cfg, dis_trainer, "net_D")
### memory optim
build_strategy = fluid.BuildStrategy()
gen_trainer_program = fluid.CompiledProgram(
gen_trainer.program).with_data_parallel(
loss_name=gen_trainer.g_loss.name,
build_strategy=build_strategy)
dis_trainer_program = fluid.CompiledProgram(
dis_trainer.program).with_data_parallel(
loss_name=dis_trainer.d_loss.name,
build_strategy=build_strategy)
t_time = 0
total_train_batch = 0 # used for benchmark
for epoch_id in range(self.cfg.epoch):
batch_id = 0
for tensor in loader():
if self.cfg.max_iter and total_train_batch == self.cfg.max_iter: # used for benchmark
return
s_time = time.time()
# optimize the generator network
g_loss_gan, g_loss_l1, fake_B_tmp = exe.run(
gen_trainer_program,
fetch_list=[
gen_trainer.g_loss_gan, gen_trainer.g_loss_L1,
gen_trainer.fake_B
],
feed=tensor)
devices_num = utility.get_device_num(self.cfg)
fake_per_device = int(len(fake_B_tmp) / devices_num)
for dev in range(devices_num):
tensor[dev]['input_fake'] = fake_B_tmp[dev * fake_per_device : (dev+1) * fake_per_device]
# optimize the discriminator network
d_loss_real, d_loss_fake = exe.run(dis_trainer_program,
fetch_list=[
dis_trainer.d_loss_real,
dis_trainer.d_loss_fake
],
feed=tensor)
batch_time = time.time() - s_time
t_time += batch_time
if batch_id % self.cfg.print_freq == 0:
print("epoch{}: batch{}: \n\
g_loss_gan: {}; g_loss_l1: {}; \n\
d_loss_real: {}; d_loss_fake: {}; \n\
Batch_time_cost: {}"
.format(epoch_id, batch_id, g_loss_gan[0], g_loss_l1[
0], d_loss_real[0], d_loss_fake[0], batch_time))
sys.stdout.flush()
batch_id += 1
total_train_batch += 1 # used for benchmark
# profiler tools
if self.cfg.profile and epoch_id == 0 and batch_id == self.cfg.print_freq:
profiler.reset_profiler()
elif self.cfg.profile and epoch_id == 0 and batch_id == self.cfg.print_freq + 5:
return
if self.cfg.run_test:
image_name = fluid.data(
name='image_name',
shape=[None, self.cfg.batch_size],
dtype="int32")
test_loader = fluid.io.DataLoader.from_generator(
feed_list=[input_A, input_B, image_name],
capacity=4,
iterable=True,
use_double_buffer=True)
test_loader.set_batch_generator(
self.test_reader,
places=fluid.cuda_places()
if self.cfg.use_gpu else fluid.cpu_places())
test_program = gen_trainer.infer_program
utility.save_test_image(
epoch_id,
self.cfg,
exe,
place,
test_program,
gen_trainer,
test_loader,
A_id2name=self.id2name)
if self.cfg.save_checkpoints:
utility.checkpoints(epoch_id, self.cfg, gen_trainer,
"net_G")
utility.checkpoints(epoch_id, self.cfg, dis_trainer,
"net_D")
if self.cfg.enable_ce:
device_num = fluid.core.get_cuda_device_count(
) if self.cfg.use_gpu else 1
print("kpis\tpix2pix_g_loss_gan_card{}\t{}".format(device_num,
g_loss_gan[0]))
print("kpis\tpix2pix_g_loss_l1_card{}\t{}".format(device_num,
g_loss_l1[0]))
print("kpis\tpix2pix_d_loss_real_card{}\t{}".format(device_num,
d_loss_real[0]))
print("kpis\tpix2pix_d_loss_fake_card{}\t{}".format(device_num,
d_loss_fake[0]))
print("kpis\tpix2pix_Batch_time_cost_card{}\t{}".format(device_num,
batch_time))
def build_model(self):
data_shape = [-1, 3, self.cfg.crop_size, self.cfg.crop_size]
input_A = fluid.layers.data(name='input_A',
shape=data_shape,
dtype='float32')
input_B = fluid.layers.data(name='input_B',
shape=data_shape,
dtype='float32')
fake_pool_A = fluid.layers.data(name='fake_pool_A',
shape=data_shape,
dtype='float32')
fake_pool_B = fluid.layers.data(name='fake_pool_B',
shape=data_shape,
dtype='float32')
gen_trainer = GTrainer(input_A, input_B, self.cfg, self.batch_num)
d_A_trainer = DATrainer(input_B, fake_pool_B, self.cfg, self.batch_num)
d_B_trainer = DBTrainer(input_A, fake_pool_A, self.cfg, self.batch_num)
# prepare environment
place = fluid.CUDAPlace(0) if self.cfg.use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
A_pool = utility.ImagePool()
B_pool = utility.ImagePool()
if self.cfg.init_model:
utility.init_checkpoints(self.cfg, exe, gen_trainer, "net_G")
utility.init_checkpoints(self.cfg, exe, d_A_trainer, "net_DA")
utility.init_checkpoints(self.cfg, exe, d_B_trainer, "net_DB")
### memory optim
build_strategy = fluid.BuildStrategy()
build_strategy.enable_inplace = False
build_strategy.memory_optimize = False
gen_trainer_program = fluid.CompiledProgram(
gen_trainer.program).with_data_parallel(
loss_name=gen_trainer.g_loss.name,
build_strategy=build_strategy)
d_A_trainer_program = fluid.CompiledProgram(
d_A_trainer.program).with_data_parallel(
loss_name=d_A_trainer.d_loss_A.name,
build_strategy=build_strategy)
d_B_trainer_program = fluid.CompiledProgram(
d_B_trainer.program).with_data_parallel(
loss_name=d_B_trainer.d_loss_B.name,
build_strategy=build_strategy)
losses = [[], []]
t_time = 0
for epoch_id in range(self.cfg.epoch):
batch_id = 0
for i in range(self.batch_num):
data_A = next(self.A_reader())
data_B = next(self.B_reader())
tensor_A = fluid.LoDTensor()
tensor_B = fluid.LoDTensor()
tensor_A.set(data_A, place)
tensor_B.set(data_B, place)
s_time = time.time()
# optimize the g_A network
g_A_loss, g_A_cyc_loss, g_A_idt_loss, g_B_loss, g_B_cyc_loss,\
g_B_idt_loss, fake_A_tmp, fake_B_tmp = exe.run(
gen_trainer_program,
fetch_list=[
gen_trainer.G_A, gen_trainer.cyc_A_loss,
gen_trainer.idt_loss_A, gen_trainer.G_B,
gen_trainer.cyc_B_loss, gen_trainer.idt_loss_B,
gen_trainer.fake_A, gen_trainer.fake_B
],
feed={"input_A": tensor_A,
"input_B": tensor_B})
fake_pool_B = B_pool.pool_image(fake_B_tmp)
fake_pool_A = A_pool.pool_image(fake_A_tmp)
# optimize the d_A network
d_A_loss = exe.run(d_A_trainer_program,
fetch_list=[d_A_trainer.d_loss_A],
feed={
"input_B": tensor_B,
"fake_pool_B": fake_pool_B
})[0]
# optimize the d_B network
d_B_loss = exe.run(d_B_trainer_program,
fetch_list=[d_B_trainer.d_loss_B],
feed={
"input_A": tensor_A,
"fake_pool_A": fake_pool_A
})[0]
batch_time = time.time() - s_time
t_time += batch_time
if batch_id % self.cfg.print_freq == 0:
print("epoch{}: batch{}: \n\
d_A_loss: {}; g_A_loss: {}; g_A_cyc_loss: {}; g_A_idt_loss: {}; \n\
d_B_loss: {}; g_B_loss: {}; g_B_cyc_loss: {}; g_B_idt_loss: {}; \n\
Batch_time_cost: {:.2f}".format(
epoch_id, batch_id, d_A_loss[0], g_A_loss[0],
g_A_cyc_loss[0], g_A_idt_loss[0], d_B_loss[0],
g_B_loss[0], g_B_cyc_loss[0], g_B_idt_loss[0],
batch_time))
losses[0].append(g_A_loss[0])
losses[1].append(d_A_loss[0])
sys.stdout.flush()
batch_id += 1
if self.cfg.run_test:
test_program = gen_trainer.infer_program
utility.save_test_image(epoch_id, self.cfg, exe, place,
test_program, gen_trainer,
self.A_test_reader, self.B_test_reader)
if self.cfg.save_checkpoints:
utility.checkpoints(epoch_id, self.cfg, exe, gen_trainer,
"net_G")
utility.checkpoints(epoch_id, self.cfg, exe, d_A_trainer,
"net_DA")
utility.checkpoints(epoch_id, self.cfg, exe, d_B_trainer,
"net_DB")
def build_model(self):
img = fluid.data(name='img', shape=[None, 784], dtype='float32')
noise = fluid.data(name='noise',
shape=[None, self.cfg.noise_size],
dtype='float32')
label = fluid.data(name='label', shape=[None, 1], dtype='float32')
# used for continuous evaluation
if self.cfg.enable_ce:
fluid.default_startup_program().random_seed = 90
random.seed(0)
np.random.seed(0)
g_trainer = GTrainer(noise, label, self.cfg)
d_trainer = DTrainer(img, label, self.cfg)
# prepare enviorment
place = fluid.CUDAPlace(0) if self.cfg.use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
const_n = np.random.uniform(
low=-1.0,
high=1.0,
size=[self.cfg.batch_size, self.cfg.noise_size]).astype('float32')
if self.cfg.init_model:
utility.init_checkpoints(self.cfg, g_trainer, "net_G")
utility.init_checkpoints(self.cfg, d_trainer, "net_D")
### memory optim
build_strategy = fluid.BuildStrategy()
build_strategy.enable_inplace = True
g_trainer_program = fluid.CompiledProgram(
g_trainer.program).with_data_parallel(
loss_name=g_trainer.g_loss.name, build_strategy=build_strategy)
d_trainer_program = fluid.CompiledProgram(
d_trainer.program).with_data_parallel(
loss_name=d_trainer.d_loss.name, build_strategy=build_strategy)
if self.cfg.run_test:
image_path = os.path.join(self.cfg.output, 'test')
if not os.path.exists(image_path):
os.makedirs(image_path)
t_time = 0
for epoch_id in range(self.cfg.epoch):
for batch_id, data in enumerate(self.train_reader()):
if len(data) != self.cfg.batch_size:
continue
noise_data = np.random.uniform(
low=-1.0,
high=1.0,
size=[self.cfg.batch_size,
self.cfg.noise_size]).astype('float32')
real_image = np.array(list(map(lambda x: x[0], data))).reshape(
[-1, 784]).astype('float32')
real_label = np.ones(shape=[real_image.shape[0], 1],
dtype='float32')
fake_label = np.zeros(shape=[real_image.shape[0], 1],
dtype='float32')
s_time = time.time()
generate_image = exe.run(g_trainer_program,
feed={'noise': noise_data},
fetch_list=[g_trainer.fake])
d_real_loss = exe.run(d_trainer_program,
feed={
'img': real_image,
'label': real_label
},
fetch_list=[d_trainer.d_loss])[0]
d_fake_loss = exe.run(d_trainer_program,
feed={
'img': generate_image[0],
'label': fake_label
},
fetch_list=[d_trainer.d_loss])[0]
d_loss = d_real_loss + d_fake_loss
for _ in six.moves.xrange(self.cfg.num_generator_time):
noise_data = np.random.uniform(
low=-1.0,
high=1.0,
size=[self.cfg.batch_size,
self.cfg.noise_size]).astype('float32')
g_loss = exe.run(g_trainer_program,
feed={'noise': noise_data},
fetch_list=[g_trainer.g_loss])[0]
batch_time = time.time() - s_time
if batch_id % self.cfg.print_freq == 0:
print(
'Epoch ID: {} Batch ID: {} D_loss: {} G_loss: {} Batch_time_cost: {}'
.format(epoch_id, batch_id, d_loss[0], g_loss[0],
batch_time))
t_time += batch_time
if self.cfg.run_test:
generate_const_image = exe.run(g_trainer.infer_program,
feed={'noise': const_n},
fetch_list=[g_trainer.fake
])[0]
generate_image_reshape = np.reshape(
generate_const_image, (self.cfg.batch_size, -1))
total_images = np.concatenate(
[real_image, generate_image_reshape])
fig = utility.plot(total_images)
plt.title('Epoch ID={}, Batch ID={}'.format(
epoch_id, batch_id))
img_name = '{:04d}_{:04d}.png'.format(epoch_id, batch_id)
plt.savefig(os.path.join(image_path, img_name),
bbox_inches='tight')
plt.close(fig)
if self.cfg.save_checkpoints:
utility.checkpoints(epoch_id, self.cfg, g_trainer, "net_G")
utility.checkpoints(epoch_id, self.cfg, d_trainer, "net_D")
# used for continuous evaluation
if self.cfg.enable_ce:
device_num = fluid.core.get_cuda_device_count(
) if self.cfg.use_gpu else 1
print("kpis\tdcgan_d_loss_card{}\t{}".format(
device_num, d_loss[0]))
print("kpis\tdcgan_g_loss_card{}\t{}".format(
device_num, g_loss[0]))
print("kpis\tdcgan_Batch_time_cost_card{}\t{}".format(
device_num, batch_time))
