def test_without_changes():
"""
Plots the rectangles on top of the image, without converting to a 5-D representation. Useful only for debugging
of the 5-D transform
Returns:
"""
path = "../debug_dataset" # Only add a couple of pictures to this path
images, pos_rectangles, neg_rectangles = load_data(path)
df = pd.DataFrame(columns=["filenames", "p1", "p2", "p3", "p4"])
for filename in pos_rectangles.filenames.unique():
points = pos_rectangles[pos_rectangles["filenames"] == filename]
points = points.loc[:, ['x', 'y']]
for i in range(0, len(points), 4):
x1, y1 = points.iloc[i][0], points.iloc[i][1]
x2, y2 = points.iloc[i + 1][0], points.iloc[i + 1][1]
x3, y3 = points.iloc[i + 2][0], points.iloc[i + 2][1]
x4, y4 = points.iloc[i + 3][0], points.iloc[i + 3][1]
new_row = [
filename,
np.asarray([int(x1), int(y1)]),
np.asarray([int(x2), int(y2)]),
np.asarray([int(x3), int(y3)]),
np.asarray([int(x4), int(y4)])
]
df.loc[len(df)] = new_row
print(df)
for i, j in images.iterrows():
rectangles = df[df["filenames"] == j["filenames"]]
plot(j["images"], j["filenames"], rectangles)
def test():
"""
Plots the rectangles on top of the image. To see if the 5-D transformation works well.
Returns:
"""
path = "../debug_dataset" # Only add a couple of pictures to this path
images, pos_rectangles, neg_rectangles = load_data(path)
pos_rectangles = to_five_dimensional(pos_rectangles)
replicated_imgs = replicate_images(images, pos_rectangles)
x_train, y_train, x_test, y_test = split_train_test_data(
replicated_imgs, pos_rectangles)
df = to_four_points(pos_rectangles)
for i, j in x_test.iterrows():
rectangles = df[df.filenames == j["filenames"]]
plot(j["images"], j["filenames"], rectangles)
def infer():
exe = fluid.Executor(fluid.CPUPlace())
if args.use_gpu:
exe = fluid.Executor(fluid.CUDAPlace(0))
exe.run(fluid.default_startup_program())
noise_data = np.random.uniform(low=-1.0,
high=1.0,
size=[args.batch_size,
NOISE_SIZE]).astype('float32')
save_path = 'freeze_model'
[infer_program, feeded_var_names,
target_var] = fluid.io.load_inference_model(dirname=save_path,
executor=exe)
generated_image = exe.run(infer_program,
feed={feeded_var_names[0]: noise_data},
fetch_list=target_var)[0]
if not os.path.exists(args.output):
os.makedirs(args.output)
total_images = generated_image
fig = plot(total_images)
plt.savefig('{}/generated_image.png'.format(args.output),
bbox_inches='tight')
plt.close(fig)
def train_straight_DDPG(episodes, agent):
# Currently we need one action output that will be
# amount of acceleration of straight vehicle
# Shape is the number of neural inputs or output
action_space = 1
state_space = 1
# Currently we didn't resize the Radar data to (4, len(radar))
# as we have to flatten it anyway
radar_space = 600
# Get the first state (speed, distance from junction)
# Create model
straight_model = md.DDPG(action_space, state_space, radar_space,
'Straight_Model')
# Update rate of target
tau = 0.005
# To store reward history of each episode
ep_reward_list = []
# To store average reward history of last few episodes
avg_reward_list = []
# To store actor and critic loss
actor_loss = []
critic_loss = []
for epi in range(episodes):
try:
radar_state_prev = agent.reset(False)
time.sleep(1)
radar_state_prev = np.reshape(radar_state_prev, (1, radar_space))
start_state = [0]
state = np.reshape(start_state, (1, state_space))
score = 0
max_step = 5_000
actor_loss_epi = []
critic_loss_epi = []
length_epi = []
for i in range(max_step):
choice = straight_model.policy(radar_state_prev, state)
action = choose_action_straight(choice)
print(
f"action----{action}-----epsilon----{straight_model.epsilon}"
)
radar_state_next, next_state, reward, done, length_traversed = agent.step_straight(
action, 1)
time.sleep(0.5)
score += reward
next_state = np.reshape(next_state, (1, state_space))
straight_model.remember(radar_state_prev, radar_state_next,
state, choice, reward, next_state,
done)
state = next_state
radar_state_prev = np.reshape(radar_state_next,
(1, radar_space))
# This is back-prop, updating weights
lossActor, lossCritic = straight_model.replay()
actor_loss_epi.append(lossActor)
critic_loss_epi.append(lossCritic)
# Update the target model, we do it slowly as it keep things stable, SOFT VERSION
straight_model.update_target(tau, epi)
if done:
length_epi.append(length_traversed)
break
actor_loss.append(np.mean(actor_loss_epi))
critic_loss.append(np.mean(critic_loss_epi))
# Will do a HARD update now, setting it to critic and actor, set tau=1
straight_model.update_target(0.01, epi)
ep_reward_list.append(score)
print("\nepisode: {}/{}, score: {}".format(epi, episodes, score))
avg_reward = np.mean(ep_reward_list[-AGGREGATE_STATS_EVERY:])
avg_length = np.mean(length_epi[-AGGREGATE_STATS_EVERY:])
print(
"\nEpisode * {} * Avg Reward is ==> {} Avg Length is ==> {}\n".
format(epi, avg_reward, avg_length))
avg_reward_list.append(avg_reward)
# Update log stats (every given number of episodes)
min_reward = min(ep_reward_list[-AGGREGATE_STATS_EVERY:])
max_reward = max(ep_reward_list[-AGGREGATE_STATS_EVERY:])
# straight_model.tensorboard.update_stats(reward_avg=avg_reward, reward_min=min_reward, reward_max=max_reward, epsilon=straight_model.epsilon)
straight_model.tensorboard.update_stats(
reward_avg=[None, avg_reward],
critic_loss=[None, np.mean(critic_loss_epi)],
actor_loss=[None, np.mean(actor_loss_epi)],
lenght_covered=[None, np.mean(avg_length)])
if (epi % 100 == 0 and epi > 0):
x_label = 'Episodes'
y_label = 'Actor Loss'
ut.plot(actor_loss, x_label, y_label, epi)
time.sleep(1)
y_label = 'Critic Loss'
ut.plot(critic_loss, x_label, y_label, epi)
time.sleep(1)
finally:
print(f"Task Completed! Episode {epi}")
straight_model.save_model()
if agent != None:
agent.destroy()
time.sleep(1)
return actor_loss, critic_loss
print('Here')
agent.step([0.5, 0.0, 0.0, False])
time.sleep(0.5)
count=count+1
agent.step([0.0, 0.0, 1.0, False])
time.sleep(5)
finally:
agent.destroy()
time.sleep(5)
"""
if __name__ == '__main__':
"""
Main function
"""
agent = env.CarlaVehicle()
#Code to train the models
episodes = 5_000
actor_Loss, critic_Loss = train_straight_DDPG(episodes, agent)
print("\n\n--We need to Maxmise Actor Loss--Minimise Critic Loss--\n\n")
x_label = 'Episodes'
y_label = 'Actor Loss'
ut.plot(actor_Loss, x_label, y_label)
y_label = 'Critic Loss'
ut.plot(critic_Loss, x_label, y_label)
#Code for Manual Control
#manual_control()
def train_rightturn_DDPG(episodes, agent):
# Two action choice for output
# amount of acceleration of straight vehicle
# Shape is the number of neural inputs or output
action_space = 1
state_space = 2
radar_space = 400
# Get the first state (speed, distance from junction)
# Create model
rightturn_model = md.DDPG(action_space, state_space, radar_space,
'Right_Turn_Model')
# Update rate of target
tau = 0.005
# To store reward history of each episode
ep_reward_list = []
# To store average reward history of last few episodes
avg_reward_list = []
# To store actor and critic loss
actor_loss = []
critic_loss = []
#For debugging the reward function
epi_count = 150
epirange = 200
for epi in range(episodes):
try:
loc = random.randint(30, 130)
print(f'--------Spawn Succeded RightTurn-----------')
radar_state_prev = agent.reset(False, loc)
radar_state_prev = np.reshape(radar_state_prev, (1, radar_space))
start_state = [50, 90]
state = np.reshape(start_state, (1, state_space))
score = 0
max_step = 5_00
actor_loss_epi = []
critic_loss_epi = []
for i in range(max_step):
choice = rightturn_model.policy(radar_state_prev, state)
action = choose_action_rightturn(choice)
# print(f'action1------------{action}')
# if(epi>=epi_count and epi_count<epirange):
# action = choose_action_rightturn(0.2)
# choice = 0.2
print(
f'action----{action}-------epsilon----{rightturn_model.epsilon}'
)
radar_state_next, next_state, reward, done, _ = agent.step_rightturn(
action, 1)
# print(f'next_state-----{next_state}-----reward---{next_state}----{done}')
time.sleep(0.2)
score += reward
next_state = np.reshape(next_state, (1, state_space))
rightturn_model.remember(radar_state_prev, radar_state_next,
state, choice, reward, next_state,
done)
state = next_state
radar_state_prev = np.reshape(radar_state_next,
(1, radar_space))
# This is back-prop, updating weights
lossActor, lossCritic = rightturn_model.replay()
actor_loss_epi.append(lossActor)
critic_loss_epi.append(lossCritic)
# Update the target model, we do it slowly as it keep things stable, SOFT VERSION
rightturn_model.update_target(tau)
if done:
break
actor_loss.append(np.mean(actor_loss_epi))
critic_loss.append(np.mean(critic_loss_epi))
# Will do a HARD update now, setting it to critic and actor, set tau=1
rightturn_model.update_target(0.01)
ep_reward_list.append(score)
print("\nepisode: {}/{}, score: {}".format(epi, episodes, score))
avg_reward = np.mean(ep_reward_list[-AGGREGATE_STATS_EVERY:])
print("\nEpisode * {} * Avg Reward is ==> {}\n".format(
epi, avg_reward))
avg_reward_list.append(avg_reward)
# Update log stats (every given number of episodes)
min_reward = min(ep_reward_list[-AGGREGATE_STATS_EVERY:])
max_reward = max(ep_reward_list[-AGGREGATE_STATS_EVERY:])
# straight_model.tensorboard.update_stats(reward_avg=avg_reward, reward_min=min_reward, reward_max=max_reward, epsilon=straight_model.epsilon)
rightturn_model.tensorboard.update_stats(
reward_avg=avg_reward,
critic_loss=np.mean(critic_loss_epi),
actor_loss=np.mean(actor_loss_epi))
if (epi % 100 == 0 and epi > 1):
x_label = 'Episodes'
y_label = 'Actor Loss'
ut.plot(actor_loss, x_label, y_label, epi)
y_label = 'Critic Loss'
ut.plot(critic_loss, x_label, y_label, epi)
# # Average score of last 100 episode
# if avg_reward > 500:
# print('\n Task Completed! \n')
# break
finally:
print(f"Task Completed! Episode {epi}")
rightturn_model.save_model()
if agent != None:
agent.destroy()
time.sleep(1)
return actor_loss, critic_loss
def run_model_run(dataset=None, *, session="s7"):
try:
train_transforms, test_transforms = train_test_dataloader.define_train_test_transformers(
session=session)
train_data, test_data = train_test_dataloader.download_data(
dataset_name=utility.get_dataset_name(session=session),
train_transforms=train_transforms,
test_transforms=test_transforms)
train_loader, test_loader = train_test_dataloader.get_train_test_dataloaders(
train_data=train_data,
test_data=test_data,
data_loader_args=utility.get_dataloader_args())
all_regularizations_list, tracker = utility.get_combos_and_trackers()
device = utility.get_device()
# utility.get_all_models_summary()
loss_fn = nn.functional.nll_loss
model = None
for combo in all_regularizations_list:
print("\nRunning for: ", combo)
if dataset and dataset.lower() == "mnist":
if CONSTANTS.GBN in combo.lower():
model = basic_mnist.GBNNet().to(device)
else:
model = basic_mnist.S6_MNIST().to(device)
elif "s7" in session.lower() or dataset.lower() == "cifar10":
model = cifar10_groups_dws_s7_model.S7_CIFAR10()
model = model.to(device)
loss_fn = nn.CrossEntropyLoss()
optimizer = utility.get_optimizer(model=model)
scheduler = utility.get_scheduler(optimizer=optimizer)
utility.show_model_summary(
title=model.__doc__,
model=model,
input_size=utility.get_input_size(
dataset=utility.get_dataset_name(session=session)))
train_test.train_test(
model=model,
device=device,
train_loader=train_loader,
optimizer=optimizer,
epochs=int(utility.get_config_details()[CONSTANTS.MODEL_CONFIG]
[CONSTANTS.EPOCHS]),
scheduler=scheduler,
test=True,
test_loader=test_loader,
type_=combo,
tracker=tracker,
loss_fn=loss_fn)
for plot_type in utility.get_config_details()[CONSTANTS.PLOTS][
CONSTANTS.TO_PLOT].strip().split(','):
utility.plot(title="Plot is for:" + plot_type,
x_label='Epochs',
y_label=plot_type.lower(),
tracker=tracker,
category=plot_type)
except Exception as e:
print(traceback.format_exc(e))
agent.destroy() time.sleep(5) # ============================================================================== # -- Manual Method------------------------------------------------------------ # -- Call function train_agent_name(episodes,agent) to train ------------------ # -- Call function manual_control() to see the task --------------------------- # -- Call function nn_control() to test the nn agents -------------------------- # ============================================================================== if __name__ == '__main__': """ Main function """ agent = env.CarlaVehicle() #Code to train the models episodes = 500 loss = train_hierarchical_dqn(episodes,agent) ut.plot(loss) #nn_lane_change() #Code for Manual Control #manual_control() #lane_control() #left_turn() #right_lane_control() #nn_right_lane_change()
def train(args):
if args.run_ce:
np.random.seed(10)
fluid.default_startup_program().random_seed = 90
d_program = fluid.Program()
dg_program = fluid.Program()
with fluid.program_guard(d_program):
img = fluid.layers.data(name='img', shape=[784], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='float32')
d_logit = D(img)
d_loss = loss(d_logit, label)
with fluid.program_guard(dg_program):
noise = fluid.layers.data(
name='noise', shape=[NOISE_SIZE], dtype='float32')
g_img = G(x=noise)
g_program = dg_program.clone()
g_program_test = dg_program.clone(for_test=True)
dg_logit = D(g_img)
dg_loss = loss(
dg_logit,
fluid.layers.fill_constant_batch_size_like(
input=noise, dtype='float32', shape=[-1, 1], value=1.0))
opt = fluid.optimizer.Adam(learning_rate=LEARNING_RATE)
opt.minimize(loss=d_loss)
parameters = [p.name for p in g_program.global_block().all_parameters()]
opt.minimize(loss=dg_loss, parameter_list=parameters)
exe = fluid.Executor(fluid.CPUPlace())
if args.use_gpu:
exe = fluid.Executor(fluid.CUDAPlace(0))
exe.run(fluid.default_startup_program())
if args.run_ce:
train_reader = paddle.batch(
paddle.dataset.mnist.train(),
batch_size=args.batch_size)
else:
train_reader = paddle.batch(
paddle.reader.shuffle(
paddle.dataset.mnist.train(), buf_size=60000),
batch_size=args.batch_size)
NUM_TRAIN_TIMES_OF_DG = 2
const_n = np.random.uniform(
low=-1.0, high=1.0,
size=[args.batch_size, NOISE_SIZE]).astype('float32')
t_time = 0
losses = [[], []]
for pass_id in range(args.epoch):
for batch_id, data in enumerate(train_reader()):
if len(data) != args.batch_size:
continue
noise_data = np.random.uniform(
low=-1.0, high=1.0,
size=[args.batch_size, NOISE_SIZE]).astype('float32')
real_image = np.array(list(map(lambda x: x[0], data))).reshape(
-1, 784).astype('float32')
real_labels = np.ones(
shape=[real_image.shape[0], 1], dtype='float32')
fake_labels = np.zeros(
shape=[real_image.shape[0], 1], dtype='float32')
total_label = np.concatenate([real_labels, fake_labels])
s_time = time.time()
generated_image = exe.run(g_program,
feed={'noise': noise_data},
fetch_list={g_img})[0]
total_images = np.concatenate([real_image, generated_image])
d_loss_1 = exe.run(d_program,
feed={
'img': generated_image,
'label': fake_labels,
},
fetch_list={d_loss})[0][0]
d_loss_2 = exe.run(d_program,
feed={
'img': real_image,
'label': real_labels,
},
fetch_list={d_loss})[0][0]
d_loss_n = d_loss_1 + d_loss_2
losses[0].append(d_loss_n)
for _ in six.moves.xrange(NUM_TRAIN_TIMES_OF_DG):
noise_data = np.random.uniform(
low=-1.0, high=1.0,
size=[args.batch_size, NOISE_SIZE]).astype('float32')
dg_loss_n = exe.run(dg_program,
feed={'noise': noise_data},
fetch_list={dg_loss})[0][0]
losses[1].append(dg_loss_n)
t_time += (time.time() - s_time)
if batch_id % 10 == 0 and not args.run_ce:
if not os.path.exists(args.output):
os.makedirs(args.output)
# generate image each batch
generated_images = exe.run(g_program_test,
feed={'noise': const_n},
fetch_list={g_img})[0]
total_images = np.concatenate([real_image, generated_images])
fig = plot(total_images)
msg = "Epoch ID={0} Batch ID={1} D-Loss={2} DG-Loss={3}\n gen={4}".format(
pass_id, batch_id,
d_loss_n, dg_loss_n, check(generated_images))
print(msg)
plt.title(msg)
plt.savefig(
'{}/{:04d}_{:04d}.png'.format(args.output, pass_id,
batch_id),
bbox_inches='tight')
plt.close(fig)
if args.run_ce:
print("kpis,dcgan_d_train_cost,{}".format(np.mean(losses[0])))
print("kpis,dcgan_g_train_cost,{}".format(np.mean(losses[1])))
print("kpis,dcgan_duration,{}".format(t_time / args.epoch))
agent_levels_list[i] = level_target
# calculate the least square difference of count change
loss = np.sum((count_levels_combined_copy - count_levels_combined)**2)
# update state variable(s)
# count_levels_combined[:] = count_levels_combined_copy[:]
count_levels_combined = count_levels_combined_copy
return loss
if __name__ == '__main__':
setup()
print("Started... ")
utility.plot(num_levels, num_classes, count_levels_list,
count_levels_combined) #initial
import time
start_time = time.time()
loss = epsilon + 1
epoch = 0
while loss > epsilon and epoch < epoch_max:
loss = turtle()
print("Epoch " + str(epoch) + " Loss: " + str(loss))
epoch += 1
# util.plot(num_levels,num_classes, count_levels_list,count_levels_combined)
# util.plot_wealth(count_levels_combined,"Count Levels Plot")
util.plot(num_levels, num_classes, count_levels_list,
count_levels_combined)
print("Converged after " + str(epoch) + " epoches. ")
def train(args):
d_program = fluid.Program()
dg_program = fluid.Program()
#image = fluid.layers.data(name='image', shape=[3, 32, 32], dtype='float32')
with fluid.program_guard(d_program):
img = fluid.layers.data(name='img',
shape=[IMG_SIZE * IMG_SIZE],
dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='float32')
d_logit = D(img)
################################################################
d_loss = loss(d_logit, label)
################################################################
with fluid.program_guard(dg_program):
noise = fluid.layers.data(name='noise',
shape=[NOISE_SIZE, 1, 1],
dtype='float32')
g_img = G(x=noise) #generate fake image
g_program = dg_program.clone()
g_program_test = dg_program.clone(for_test=True)
dg_logit = D(g_img)
################################################################
dg_loss = loss(
dg_logit,
fluid.layers.fill_constant_batch_size_like(input=noise,
dtype='float32',
shape=[-1, 1],
value=1.0))
################################################################
opt = fluid.optimizer.Adam(learning_rate=LEARNING_RATE, beta1=0.5)
opt.minimize(loss=d_loss)
parameters = [p.name for p in g_program.global_block().all_parameters()]
opt.minimize(loss=dg_loss, parameter_list=parameters)
exe = fluid.Executor(fluid.CPUPlace())
if args.use_gpu:
exe = fluid.Executor(fluid.CUDAPlace(0))
exe.run(fluid.default_startup_program())
#download data
data_dir = os.path.join(BASE_DIR, 'data')
if not os.path.exists(data_dir):
os.mkdir(data_dir)
data_dir = os.path.join(data_dir, 'data65')
if not os.path.exists(data_dir):
os.mkdir(data_dir)
print("start to download image data...")
image_filename = os.path.join(BASE_DIR,
'data/data65/train-images-idx3-ubyte.gz')
if not os.path.exists(image_filename):
r = requests.get(
'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz')
with open(image_filename, 'wb') as f:
f.write(r.content)
print("start to downlaod image data...")
label_filename = os.path.join(BASE_DIR,
'data/data65/train-labels-idx1-ubyte.gz')
if not os.path.exists(label_filename):
r = requests.get(
'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz')
with open(label_filename, 'wb') as f:
f.write(r.content)
print("finished download")
train_reader = reader_creator(image_filename, label_filename, 500)
train_reader = batch(train_reader, args.batch_size, drop_last=False)
NUM_TRAIN_TIMES_OF_DG = 2
const_n = np.random.uniform(low=-1.0,
high=1.0,
size=[args.batch_size, NOISE_SIZE, 1,
1]).astype('float32')
t_time = 0
losses = [[], []]
for pass_id in range(args.epoch):
for batch_id, data in enumerate(train_reader()):
if len(data) != args.batch_size:
continue
noise_data = np.random.uniform(
low=-1.0, high=1.0, size=[args.batch_size, NOISE_SIZE, 1,
1]).astype('float32')
real_image = np.array(list(map(lambda x: x[0], data))).reshape(
-1, IMG_SIZE * IMG_SIZE).astype('float32')
real_labels = np.ones(shape=[real_image.shape[0], 1],
dtype='float32')
fake_labels = np.zeros(shape=[real_image.shape[0], 1],
dtype='float32')
total_label = np.concatenate([real_labels, fake_labels])
s_time = time.time()
generated_image = exe.run(g_program,
feed={'noise': noise_data},
fetch_list=[g_img
])[0] #generate fake image
total_images = np.concatenate([real_image, generated_image])
d_loss_1 = exe.run(d_program,
feed={
'img': generated_image,
'label': fake_labels,
},
fetch_list=[d_loss])[0][0] #tell fake images
d_loss_2 = exe.run(d_program,
feed={
'img': real_image,
'label': real_labels,
},
fetch_list=[d_loss])[0][0] #tell real image
##############two losses above to trian D
d_loss_n = d_loss_1 + d_loss_2
losses[0].append(d_loss_n)
for _ in six.moves.xrange(NUM_TRAIN_TIMES_OF_DG):
noise_data = np.random.uniform(
low=-1.0,
high=1.0,
size=[args.batch_size, NOISE_SIZE, 1, 1]).astype('float32')
dg_loss_n = exe.run(dg_program,
feed={'noise': noise_data},
fetch_list=[dg_loss])[0][0] ### G_loss
losses[1].append(dg_loss_n)
t_time += (time.time() - s_time)
if batch_id % 200 == 0 and not args.run_ce:
# if not os.path.exists(args.output):
# os.makedirs(args.output)
# generate image each batch
generated_images = exe.run(g_program_test,
feed={'noise': const_n},
fetch_list=[g_img])[0]
total_images = np.concatenate([real_image, generated_images])
fig = plot(total_images)
msg = "Epoch ID={0} Batch ID={1} D-Loss={2} DG-Loss={3}\n gen={4}".format(
pass_id, batch_id, d_loss_n, dg_loss_n,
check(generated_images))
print(msg)
#plt.title(msg)
#plt.savefig(
# os.path.join(BASE_DIR, 'result/dcgan/{:04d}_{:04d}.png'.format(pass_id,
# batch_id)),
# bbox_inches='tight')
#plt.close(fig)
#save_path = os.path.join(BASE_DIR, 'model/dcgan_model')
# delete old model file
#shutil.rmtree(save_path, ignore_errors=True)
#os.makedirs(save_path)
# save prediction model
#fluid.io.save_inference_model(main_program=g_program_test, dirname=save_path, feeded_var_names=['noise'], target_vars=g_img, executor=exe)
if args.run_ce:
print("kpis,dcgan_d_train_cost,{}".format(np.mean(losses[0])))
print("kpis,dcgan_g_train_cost,{}".format(np.mean(losses[1])))
print("kpis,dcgan_duration,{}".format(t_time / args.epoch))
result_dir = os.path.join(BASE_DIR, 'result')
if not os.path.exists(result_dir):
os.mkdir(result_dir)
RESULT_FILE = os.path.join(result_dir, 'results_dcgan.txt')
with open(RESULT_FILE, 'a') as f:
f.write('\n\n\n\ dcgan results:\n')
f.write("kpis,dcgan_d_train_cost,{}".format(np.mean(losses[0])))
f.write("kpis,dcgan_g_train_cost,{}".format(np.mean(losses[1])))
f.write("kpis,dcgan_duration,{}".format(t_time))
index = 0
while os.path.exists(
os.path.join(
result_dir,
'minst_dcgan_tf_epoch_{}_{}.png'.format(args.epoch, index))):
index += 1
imgname = os.path.join(
result_dir, 'minst_dcgan_tf_epoch_{}_{}.png'.format(args.epoch, index))
generated_images = exe.run(g_program_test,
feed={'noise': const_n},
fetch_list=[g_img])[0]
total_images = np.concatenate([real_image, generated_images])
fig = plot(total_images)
plt.savefig(imgname, bbox_inches='tight')
plt.close(fig)
