def train_wgan(generator, critic, noise_dim, data_dim, nbEpochs, nbBatchPerEpochs, batchSize, eta_critic, clip):
epoch_size = nbBatchPerEpochs * batchSize
GAN = get_GAN(generator, critic, noise_dim, data_dim)
generator.compile(loss='mse', optimizer=RMSprop())
critic.trainable = False
GAN.compile(loss=wassertein_distance, optimizer=RMSprop())
critic.trainable = True
critic.compile(loss=wassertein_distance, optimizer=RMSprop())
for i_epoch in range(nbEpochs):
progbar = Progbar(epoch_size)
start = time.time()
for i_batch in range(nbBatchPerEpochs):
list_critic_real_loss, list_critic_gen_loss = [], []
for i_critic in range(eta_critic):
clip_weights(critic, -clip, clip)
real_batch = batch_real_distribution(batchSize, i_batch, data_dim)
gen_batch = batch_generated_distribution(generator, batchSize, noise_dim)
critic_real_loss = critic.train_on_batch(real_batch, -np.ones(real_batch.shape[0]))
critic_gen_loss = critic.train_on_batch(gen_batch, np.ones(gen_batch.shape[0]))
list_critic_real_loss.append(critic_real_loss)
list_critic_gen_loss.append(critic_gen_loss)
noise = get_noise(noise_dim, batchSize)
# When we train the GAN, we want to train the weights that belong to
# the generator, not to the critic
critic.trainable = False
gen_loss = GAN.train_on_batch(noise, -np.ones(noise.shape[0]))
critic.trainable = True
progbar.add(batchSize, values=[("Loss_D", -np.mean(list_critic_real_loss) - np.mean(list_critic_gen_loss)),
("Loss_D_real", -np.mean(list_critic_real_loss)),
("Loss_D_gen", np.mean(list_critic_gen_loss)),
("Loss_G", -gen_loss)])
print('\nEpoch %s/%s, Time: %s' % (i_epoch + 1, nbEpochs, time.time() - start))
def train(self, examples, snapshot=False):
"""
Trains the model on the 'examples' dataset.
"""
print("\n\nStarting training of GAN")
if snapshot:
print(
"Models will be saved along the training in the 'models' folder"
)
else:
print(
"/!\ Snapshot option is disabled : no intermediate model will be saved.\nTo activate snapshot, use the -sn (or --snapshot) option"
)
BATCH_SIZE = self.batch_size * self.n_critic
MINIBATCH_SIZE = self.batch_size
NB_BATCH = examples.shape[0] // BATCH_SIZE
EPOCH_SIZE = NB_BATCH * BATCH_SIZE # we dump the eventual non-complete batch at the end
dummy = np.zeros((MINIBATCH_SIZE, 1), dtype=np.float32
) #given to the gradient penalty loss, but not used
start_time = time()
for i_epoch in range(self.starting_epoch, self.nb_epochs):
epoch_time = time()
np.random.shuffle(examples)
progbar = Progbar(EPOCH_SIZE)
print("Epoch {}/{} :".format(i_epoch + 1, self.nb_epochs))
for i_batch in range(NB_BATCH):
batch = self.get_batch(examples, i_batch, BATCH_SIZE)
critic_loss = []
generator_loss = []
for i_minibatch in range(self.n_critic):
labels_for_real = self.get_label((MINIBATCH_SIZE, 1))
labels_for_generated = -self.get_label((MINIBATCH_SIZE, 1))
minibatch = self.get_batch(batch, i_minibatch,
MINIBATCH_SIZE)
loss = self.crit_trainer.train_on_batch(
[minibatch, self.get_noise(MINIBATCH_SIZE)],
[labels_for_real, labels_for_generated, dummy])
critic_loss.append(loss)
loss = self.gen_trainer.train_on_batch(
self.get_noise(MINIBATCH_SIZE),
self.get_label((MINIBATCH_SIZE, 1)))
generator_loss.append(loss)
progbar.add(BATCH_SIZE,
values=[("Loss_critic", np.mean(critic_loss) -
np.mean(generator_loss)),
("Loss_generator",
-np.mean(generator_loss))])
print("Time: %.2fs, Total time : %.2fs\n" %
(time() - epoch_time, time() - start_time))
self.take_snapshot(i_epoch + 1, snapshot=snapshot, tiled=True)
print("Training complete")
def predict(self, X):
bar = Progbar(len(X))
pred_proba = []
for i in range(len(X)):
if self.verbose: bar.add(1)
ordered_dists = dist(self.X, X[i])
ordered_dists = sorted(zip(ordered_dists,
range(len(ordered_dists))),
key=lambda x: x[0])
k_indexes = [x[1] for x in ordered_dists[:self.k]]
votes = np.zeros(self.y.shape[1])
for p, x in enumerate(k_indexes):
votes[self.y[x].argmax()] += self.vote_func(
ordered_dists[p][0])
pred_proba.append(votes)
return to_categorical(np.array(pred_proba).argmax(axis=1))
def generate_train_batch(num_steps):
input_boards = []
target_pis = []
target_vs = []
board = Board()
game = Game()
heuristicPlayer = HeuristicPlayer()
player = 1
print("generate_train_batch")
progbar = Progbar(num_steps)
for x in range(num_steps):
progbar.add(1)
encoded_state = board.get_encoded_state()
canonical_form = game.getCanonicalForm(encoded_state, player)
best_action = heuristicPlayer.play(canonical_form)
game_ended = game.getGameEnded(encoded_state, player)
if game_ended == 0:
input_board = game.getCanonicalForm(copy.deepcopy(encoded_state),
player)
encoded_state = board.execute_move(best_action, player)
score = board.get_players_scores()[player]
action_onehot = number_to_onehot(best_action, Board.action_size)
win_probability = float(score) / float(WIN_SCORE)
player *= -1
input_boards.append(input_board)
target_pis.append(action_onehot)
target_vs.append(win_probability)
# print("\n")
# print(parse_encoded_state(input_board))
# print("best_action " + str(best_action))
else:
player == 1
board = Board() # no valid actions or game ended, reset board
encoded_state = board.get_encoded_state()
return input_boards, target_pis, target_vs
def fit(self,
x,
y,
labels,
batch_size=None,
epochs=1,
validation_split=None):
if batch_size is None:
batch_size = 32
num_steps = float(len(x)) / batch_size
num_steps = math.ceil(num_steps)
if validation_split is None:
x_train = x
y_train = y
labels_train = labels
else:
num_validation = int(len(x) * validation_split)
if isinstance(x, list):
x_train = [arr[:-num_validation] for arr in x]
else:
x_train = x[:-num_validation]
if isinstance(y, list):
y_train = [arr[:-num_validation] for arr in y]
else:
y_train = y[:-num_validation]
labels_train = [l[:-num_validation] for l in labels]
for epoch in range(epochs):
print('Epoch {}'.format(epoch + 1))
pbar = Progbar(len(x_train))
for i in range(0, len(x_train), batch_size):
x_batch = x_train[i:i + batch_size]
y_batch = y_train[i:i + batch_size]
labels_batch = [l[i:i + batch_size] for l in labels_train]
self.train_on_batch(x_batch, y_batch, labels_batch)
pbar.add(len(x_batch))
if validation_split is not None:
x_test = x[-num_validation:]
y_test = y[-num_validation:]
labels_test = [l[-num_validation:] for l in labels]
task_result = self.inference_model.evaluate(x_test, y_test)
bias = get_bias(self.morpher.predict(x_test), labels_test)
return task_result, bias
def _get_embeddings(model, gallery_iter, query_iter):
gallery_embs = []
query_embs = []
print('Computing gallery embeddings...')
gallery_progbar = Progbar(len(gallery_iter.files_arr))
for it in gallery_iter:
e = model.predict(it)
gallery_embs.append(e)
gallery_progbar.add(len(e))
print('Computing query embeddings...')
query_progbar = Progbar(len(query_iter.files_arr))
for it in query_iter:
e = model.predict(it)
query_embs.append(e)
query_progbar.add(len(e))
return np.stack(gallery_embs), np.stack(query_embs)
def train(csv_path,
tag,
gpu_id,
epochs,
steps_per_epoch,
batch_size,
int_steps,
vel_resize,
ti_flow,
sample_weights,
lr,
beta_1,
beta_2,
epsilon,
prior_lambda,
enc_nf,
dec_nf,
cri_base_nf,
gen_loss_weights,
cri_loss_weights,
cri_steps,
cri_retune_freq,
cri_retune_steps,
valid_freq,
valid_steps):
"""
model training function
:param csv_path: path to data csv (img paths, labels)
:param tag: tag for the run, added to run_dir
:param gpu_id: integer specifying the gpu to use
:param lr: learning rate
:param epochs: number of training iterations
:param steps_per_epoch: frequency with which to save models
:param batch_size: Optional, default of 1. can be larger, depends on GPU memory and volume size
:param prior_lambda: the prior_lambda, the scalar in front of the smoothing laplacian, in MICCAI paper
"""
model_config = locals()
# gpu handling
gpu = '/gpu:%d' % 0 # gpu_id
os.environ["CUDA_VISIBLE_DEVICES"] = gpu_id
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
set_session(tf.Session(config=config))
vol_shape = (80, 96, 80)
print('input vol_shape is {}'.format(vol_shape))
assert os.path.isfile(csv_path), 'csv not found at {}'.format(csv_path)
csv_path = os.path.abspath(csv_path)
model_config['csv_path'] = csv_path
model_dir = 'runs/'
model_dir += 'gan_{:%Y%m%d_%H%M}'.format(datetime.now())
model_dir += '_gpu={}'.format(str(gpu_id))
model_dir += '_bs={}'.format(batch_size)
model_dir += '_enc={}'.format(enc_nf)
model_dir += '_dec={}'.format(dec_nf)
model_dir += '_cbn={}'.format(cri_base_nf)
model_dir += '_lr={}'.format(lr)
model_dir += '_b1={}'.format(beta_1)
model_dir += '_b2={}'.format(beta_2)
model_dir += '_ep={}'.format(epsilon)
model_dir += '_pl={}'.format(prior_lambda)
model_dir += '_vr={}'.format(vel_resize)
model_dir += '_ti={}'.format(ti_flow)
model_dir += '_is={}'.format(int_steps)
model_dir += '_cs={}'.format(cri_steps)
model_dir += '_rf={}'.format(cri_retune_freq)
model_dir += '_rs={}'.format(cri_retune_steps)
model_dir += '_sw={}'.format(sample_weights is not None)
model_dir += '_glw={}'.format(gen_loss_weights)
model_dir += '_clw={}'.format(cri_loss_weights)
model_dir += '_tag={}'.format(tag) if tag != '' else ''
model_dir = model_dir.replace(' ', '')
model_dir = model_dir.replace(',', '_')
print('model_dir is {}'.format(model_dir))
flow_shape = tuple(int(d * vel_resize) for d in vol_shape)
valid_dir = os.path.join(model_dir, 'eval')
# prepare model folder
if not os.path.isdir(model_dir):
os.mkdir(model_dir)
if not os.path.isdir(valid_dir):
os.mkdir(valid_dir)
# prepare the model
with tf.device(gpu):
# load models
loss_class = losses.GANLosses(prior_lambda=prior_lambda, flow_shape=flow_shape)
cri_optimizer = Adam(lr=lr, beta_1=beta_1, beta_2=beta_2, epsilon=epsilon)
gen_optimizer = Adam(lr=lr, beta_1=beta_1, beta_2=beta_2, epsilon=epsilon)
cri_model, gen_model = networks.gan_models(
vol_shape, batch_size, loss_class,
cri_loss_weights=cri_loss_weights,
cri_optimizer=cri_optimizer,
gen_loss_weights=gen_loss_weights,
gen_optimizer=gen_optimizer,
enc_nf=enc_nf, dec_nf=dec_nf,
cri_base_nf=cri_base_nf,
vel_resize=vel_resize,
ti_flow=ti_flow,
int_steps=int_steps)
cri_model_save_path = os.path.join(model_dir, 'cri_{:03d}.h5')
gen_model_save_path = os.path.join(model_dir, 'gen_{:03d}.h5')
# save inital models
cri_model.save(cri_model_save_path.format(0))
gen_model.save(gen_model_save_path.format(0))
# data generator
num_gpus = len(gpu_id.split(','))
assert np.mod(batch_size, num_gpus) == 0, \
'batch_size should be a multiple of the nr. of gpus. ' + \
'Got batch_size %d, %d gpus' % (batch_size, num_gpus)
# load csv
csv = pd.read_csv(csv_path)
# get max_delta from csv and store in config
# max_delta and int_steps determine the resolution of the flow integration
# e.g. max_delta=6, int_steps=5 results in a resolution of about 5 weeks
# max_steps = 2**(int_steps+1)-1 = 63, 6 years = 72 months
max_delta = csv['delta_t'].max()
model_config['max_delta'] = max_delta
# csv columns for img paths and labels
img_keys = ['img_path_0', 'img_path_1']
lbl_keys = ['delta_t']
# datagens for training and validation
train_csv_data = datagenerators.csv_gen(csv_path, img_keys=img_keys,
lbl_keys=lbl_keys, batch_size=batch_size,
sample=True, weights=sample_weights, split='train')
valid_csv_data = datagenerators.csv_gen(csv_path, img_keys=img_keys,
lbl_keys=lbl_keys, batch_size=batch_size,
sample=True, weights=sample_weights, split='eval')
# convert the delta to channel (for critic) and bin_repr (for ss in gen)
train_data = datagenerators.gan_gen(train_csv_data, max_delta, int_steps)
valid_data = datagenerators.gan_gen(valid_csv_data, max_delta, int_steps)
# write model_config to run_dir
config_path = os.path.join(model_dir, 'config.pkl')
pickle.dump(model_config, open(config_path, 'wb'))
# labels for train/predict
# dummy tensor for kl loss, must have correct flow shape
kl_dummy = np.zeros((batch_size, *flow_shape, len(vol_shape)-1))
# labels for critic ws loss
real = np.ones((batch_size, 1)) * (-1) # real labels
fake = np.ones((batch_size, 1)) # fake labels
avgd = np.ones((batch_size, 1)) # dummy labels for gradient penalty
# tboard callbacks
tboard_train = TensorBoardExt(log_dir=model_dir)
tboard_train.set_model(gen_model)
tboard_valid = TensorBoardVal(log_dir=valid_dir, data=valid_data,
cri_model=cri_model, gen_model=gen_model,
freq=valid_freq, steps=valid_steps,
batch_size=batch_size, kl_dummy=kl_dummy)
tboard_valid.set_model(gen_model)
# fit generator
with tf.device(gpu):
abs_step = 0
for epoch in range(epochs):
print('epoch {}/{}'.format(epoch, epochs))
cri_steps_ep = cri_steps
# check if retune epoch, if so adjust critic steps
if epoch % cri_retune_freq == 0:
cri_steps_ep = cri_retune_steps
print('retuning critic')
progress_bar = Progbar(target=steps_per_epoch)
for step in range(steps_per_epoch):
# train critic
for c_step in range(cri_steps_ep):
imgs, lbls = next(train_data)
cri_in = [imgs[0], imgs[1], lbls[0], lbls[1]] # xr, yr, dr, db
cri_true = [real, fake, avgd]
cri_logs = cri_model.train_on_batch(cri_in, cri_true)
imgs, lbls = next(train_data)
gen_in = [imgs[0], lbls[0], lbls[1]] # xr, dr, db
gen_true = [imgs[0], kl_dummy, kl_dummy, real]
# train generator
gen_logs = gen_model.train_on_batch(gen_in, gen_true)
# update tensorboard
tboard_train.on_epoch_end(abs_step, cri_logs, gen_logs)
tboard_valid.on_epoch_end(abs_step)
#tensorboard_summaries(tboard_train, abs_step, cri_logs, gen_logs)
abs_step += 1
progress_bar.add(1)
if epoch % 5 == 0:
cri_model.save(cri_model_save_path.format(epoch))
gen_model.save(gen_model_save_path.format(epoch))
def train(csv_path,
tag,
gpu_id,
epochs,
steps_per_epoch,
batch_size,
vol_shape,
int_steps,
vel_resize,
sample_weights,
lr,
beta_1,
beta_2,
epsilon,
prior_lambda,
batchnorm,
leaky,
split_col,
split_train,
split_eval,
reg_model_file,
clf_model_file,
cri_base_nf,
gen_loss_weights,
cri_loss_weights,
cri_steps,
cri_retune_freq,
cri_retune_steps,
valid_freq,
valid_steps):
"""
model training function
:param csv_path: path to data csv (img paths, labels)
:param tag: tag for the run, added to run_dir
:param gpu_id: integer specifying the gpu to use
:param lr: learning rate
:param epochs: number of training iterations
:param steps_per_epoch: frequency with which to save models
:param batch_size: Optional, default of 1. can be larger, depends on GPU memory and volume size
:param prior_lambda: the prior_lambda, the scalar in front of the smoothing laplacian, in MICCAI paper
"""
# grab config (all local variables at this point)
model_config = locals()
# claim gpu, do early so we fail early if it's occupied
gpu = '/gpu:%d' % 0 # gpu_id
os.environ["CUDA_VISIBLE_DEVICES"] = gpu_id
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
set_session(tf.Session(config=config))
# convert vol_shape (is list)
vol_shape = tuple(vol_shape)
model_config['vol_shape'] = vol_shape
print('input vol_shape is {}'.format(vol_shape))
# check csv exists
assert os.path.isfile(csv_path), 'csv not found at {}'.format(csv_path)
# add csv path to config
csv_path = os.path.abspath(csv_path)
model_config['csv_path'] = csv_path
# check regressor model file exists
if reg_model_file:
msg = 'reg model file not found at {}'.format(reg_model_file)
assert os.path.isfile(reg_model_file), msg
reg_model_file = os.path.abspath(reg_model_file)
model_config['reg_model_file'] = reg_model_file
# check classifier model file exists
if clf_model_file:
msg = 'clf model file not found at {}'.format(clf_model_file)
assert os.path.isfile(clf_model_file), msg
clf_model_file = os.path.abspath(clf_model_file)
model_config['clf_model_file'] = clf_model_file
# stitch together run_dir name
run_dir = 'runs/'
run_dir += 'gan_{:%Y%m%d_%H%M}'.format(datetime.now())
run_dir += '_gpu={}'.format(str(gpu_id))
run_dir += '_bs={}'.format(batch_size)
run_dir += '_cl={}'.format(cri_base_nf)
run_dir += '_lr={}'.format(lr)
run_dir += '_b1={}'.format(beta_1)
run_dir += '_b2={}'.format(beta_2)
run_dir += '_ep={}'.format(epsilon)
run_dir += '_pl={}'.format(prior_lambda)
run_dir += '_lk={}'.format(leaky)
run_dir += '_bn={}'.format(batchnorm)
run_dir += '_vr={}'.format(vel_resize)
run_dir += '_is={}'.format(int_steps)
run_dir += '_cs={}'.format(cri_steps)
run_dir += '_rf={}'.format(cri_retune_freq)
run_dir += '_rs={}'.format(cri_retune_steps)
run_dir += '_sw={}'.format(sample_weights is not None)
run_dir += '_reg={}'.format(reg_model_file is not None)
run_dir += '_clf={}'.format(clf_model_file is not None)
run_dir += '_glw={}'.format(gen_loss_weights)
run_dir += '_clw={}'.format(cri_loss_weights)
run_dir += '_tag={}'.format(tag) if tag != '' else ''
run_dir = run_dir.replace(' ', '')
run_dir = run_dir.replace(',', '_')
print('run_dir is {}'.format(run_dir))
# calculate flow_shape given the resize param
flow_shape = tuple(int(d * vel_resize) for d in vol_shape)
# create run dirs
if not os.path.isdir(run_dir):
os.mkdir(run_dir)
valid_dir = os.path.join(run_dir, 'eval')
if not os.path.isdir(valid_dir):
os.mkdir(valid_dir)
# prepare the model
with tf.device(gpu):
# load models
loss_class = losses.GANLosses(prior_lambda=prior_lambda, flow_shape=flow_shape)
cri_optimizer = Adam(lr=lr, beta_1=beta_1, beta_2=beta_2, epsilon=epsilon)
gen_optimizer = Adam(lr=lr, beta_1=beta_1, beta_2=beta_2, epsilon=epsilon)
cri_model, gen_model = networks.gan_models(
vol_shape, batch_size, loss_class,
cri_loss_weights=cri_loss_weights,
cri_optimizer=cri_optimizer,
cri_base_nf=cri_base_nf,
gen_loss_weights=gen_loss_weights,
gen_optimizer=gen_optimizer,
vel_resize=vel_resize,
int_steps=int_steps,
reg_model_file=reg_model_file,
clf_model_file=clf_model_file,
batchnorm=batchnorm,
leaky=leaky)
cri_model_save_path = os.path.join(run_dir, 'cri_{:03d}.h5')
gen_model_save_path = os.path.join(run_dir, 'gen_{:03d}.h5')
# save inital models
cri_model.save(cri_model_save_path.format(0))
gen_model.save(gen_model_save_path.format(0))
# load csv
csv = pd.read_csv(csv_path)
# get max_delta from csv and store in config
# max_delta and int_steps determine the resolution of the flow integration
# e.g. max_delta=6y, int_steps=5 results in a resolution of about 5 weeks
# max_steps = 2**(int_steps+1)-1 = 63, 6 years = 72 months
max_delta = csv['delta_t'].max()
model_config['max_delta'] = max_delta
# csv columns for img paths and labels
img_keys = ['img_path_0', 'img_path_1']
lbl_keys = ['delta_t', 'pat_dx_1']
# datagens for training and validation
train_csv_data = datagenerators.csv_gen(csv_path, img_keys=img_keys,
lbl_keys=lbl_keys, batch_size=batch_size,
sample=True, weights=sample_weights,
split=(split_col, split_train))
valid_csv_data = datagenerators.csv_gen(csv_path, img_keys=img_keys,
lbl_keys=lbl_keys, batch_size=batch_size,
sample=True, weights=sample_weights,
split=(split_col, split_eval))
use_reg = reg_model_file is not None
use_clf = clf_model_file is not None
cri_train_data, gen_train_data = datagenerators.gan_generators(
csv_gen=train_csv_data, vol_shape=vol_shape,
flow_shape=flow_shape, max_delta=max_delta,
int_steps=int_steps, use_reg=use_reg,
use_clf=use_clf)
cri_valid_data, gen_valid_data = datagenerators.gan_generators(
csv_gen=valid_csv_data, vol_shape=vol_shape,
flow_shape=flow_shape, max_delta=max_delta,
int_steps=int_steps, use_reg=use_reg,
use_clf=use_clf)
# write model_config to run_dir
config_path = os.path.join(run_dir, 'config.pkl')
pickle.dump(model_config, open(config_path, 'wb'))
print('model_config:')
print(model_config)
# tboard callbacks
tboard_train = TensorBoardExt(log_dir=run_dir, use_reg=use_reg, use_clf=use_clf)
tboard_train.set_model(gen_model)
tboard_valid = TensorBoardVal(log_dir=valid_dir, use_reg=use_reg, use_clf=use_clf,
cri_data=cri_valid_data, gen_data=gen_valid_data,
cri_model=cri_model, gen_model=gen_model,
freq=valid_freq, steps=valid_steps)
tboard_valid.set_model(gen_model)
# fit generator
with tf.device(gpu):
abs_step = 0
for epoch in range(epochs):
print('epoch {}/{}'.format(epoch, epochs))
cri_steps_ep = cri_steps
# check if retune epoch, if so adjust critic steps
if epoch % cri_retune_freq == 0:
cri_steps_ep = cri_retune_steps
print('retuning critic')
progress_bar = Progbar(target=steps_per_epoch)
for step in range(steps_per_epoch):
# train critic
for c_step in range(cri_steps_ep):
inputs, labels, _ = next(cri_train_data)
cri_logs = cri_model.train_on_batch(inputs, labels)
inputs, labels, _ = next(gen_train_data)
# train generator
gen_logs = gen_model.train_on_batch(inputs, labels)
# update tensorboard
tboard_train.on_epoch_end(abs_step, cri_logs, gen_logs)
tboard_valid.on_epoch_end(abs_step)
abs_step += 1
progress_bar.add(1)
if epoch % 5 == 0:
cri_model.save(cri_model_save_path.format(epoch))
gen_model.save(gen_model_save_path.format(epoch))
nargs="+",
help="--tile <nb_lines> <nb_columns>\n\
Tile the output images in the provided pattern")
args = parser.parse_args()
Gan = GAN(args.model)
progbar = Progbar(args.nb_image)
output_name = args.model.split("/")[-1].split(".")[0]
if args.tile:
assert len(args.tile) == 2
nx, ny = int(args.tile[0]), int(args.tile[1])
output = []
for i in range(args.nb_image):
output.append(Gan.generate())
progbar.add(1)
tiled = Image.tile_images(output, (nx, ny))
tiled.exportAsPng("output/{}_tile.png".format(output_name))
else:
for i in range(args.nb_image):
img = Gan.generate()
if args.png:
img_name = "output/{}_{}.png".format(output_name, i)
img.exportAsPng(img_name)
elif args.vox:
img_name = "output/{}_{}.vox".format(output_name, i)
img.exportAsVox(img_name)
else:
img_name = "output/{}_{}.gslib".format(output_name, i)
img.exportAsGslib(img_name)
progbar.add(1)
def main(args):
# =====================================
# Preparation (load dataset and create
# a directory which saves results)
# =====================================
input_paths = utils.make_paths_from_directory(args.dataset)
random.shuffle(input_paths)
border = int(len(input_paths) * 0.8)
train_paths, test_paths = input_paths[:border], input_paths[border:]
if os.path.exists(args.result) == False:
os.makedirs(args.result)
save_config(os.path.join(args.result, 'config.txt'), args)
# =====================================
# Instantiate models
# =====================================
xgen = models.create_xgenerater()
zgen = models.create_zgenerater()
disc = models.create_discriminater()
opt_d = Adam(lr=args.lr, beta_1=args.beta_1, beta_2=args.beta_2)
opt_g = Adam(lr=args.lr, beta_1=args.beta_1, beta_2=args.beta_2)
xgen.trainable = False
zgen.trainable = False
gan_d = models.create_gan(xgen, zgen, disc)
gan_d.compile(optimizer=opt_d, loss=d_lossfun)
xgen.trainable = True
zgen.trainable = True
disc.trainable = False
gan_g = models.create_gan(xgen, zgen, disc)
gan_g.compile(optimizer=opt_g, loss=g_lossfun)
# =====================================
# Training Loop
# =====================================
num_train = len(train_paths)
for epoch in range(args.epochs):
print('Epochs %d/%d' % (epoch+1, args.epochs))
pbar = Progbar(num_train)
for i in range(0, num_train, args.batch_size):
x = utils.make_arrays_from_paths(
train_paths[i:i+args.batch_size],
preprocess=utils.preprocess_input,
target_size=(32,32))
z = np.random.normal(size=(len(x), 1, 1, 64))
# train discriminater
d_loss = gan_d.train_on_batch([x, z], np.zeros((len(x), 1, 1, 2)))
# train generaters
g_loss = gan_g.train_on_batch([x, z], np.zeros((len(x), 1, 1, 2)))
# update progress bar
pbar.add(len(x), values=[
('d_loss', d_loss),
('g_loss', g_loss),
])
if (epoch+1) % args.snap_freq == 0:
# ===========================================
# Save result
# ===========================================
# Make a directory which stores learning results
# at each (args.frequency)epochs
dirname = 'epochs%d' % (epoch+1)
path = os.path.join(args.result, dirname)
if os.path.exists(path) == False:
os.makedirs(path)
# Save generaters' weights
xgen.save_weights(os.path.join(path, 'xgen_weights.h5'))
zgen.save_weights(os.path.join(path, 'zgen_weights.h5'))
# Save generated images
img = utils.generate_img(xgen)
img.save(os.path.join(path, 'generated.png'))
# Save reconstructed images
x = utils.make_arrays_from_paths(
test_paths,
preprocess=None,
target_size=(32,32))
img = utils.reconstruct_img(x, xgen, zgen)
img.save(os.path.join(path, 'reconstructed.png'))
list_test_mean_loss = []
max_test_accuracy = 0
progbar_train = Progbar(training_step)
log.write("Epoch: " +str(epoch) +"\n")
for i in range(training_step):
X_train, y_train = next(train_generator)
print("\nTrain shape: ", X_train.shape)
progbar_train.add(1)
if i == 0 and epoch == 1:
#imputer trained only on first iteration
imp.fit(X_train)
#impute missing data
X_train_imp =imp.fit_transform(X_train)
#normalize
X_train = preprocessing.normalize(X_train_imp)
train_metrics = classifier.train_on_batch(X_train,
y_train
)
def _evaluate_metrics(gallery_embs, query_embs, gallery_data, query_data, rank, compute_mAP):
# if test_dict is None or test_files is None or query_files is None:
# test_dict, test_files = _get_data('test')
# _, query_files = _get_data('query')
gallery_idts = np.array([p[1] for p in gallery_data.files_arr])
gallery_cams = np.array([p[2] for p in gallery_data.files_arr])
if rank is not None:
correct = np.array([0] * len(rank))
test_iter = np.array([0] * len(rank))
AP = []
progbar = Progbar(len(query_data.files_arr))
for q in range(len(query_data.files_arr)):
idt, camera = int(query_data.files_arr[q][1]), int(query_data.files_arr[q][2])
b = np.logical_or(gallery_cams != camera, gallery_idts != idt)
i = 0
for _, idt_t, cam_t in np.array(gallery_data.files_arr)[b]:
if idt == int(idt_t) and camera != int(cam_t):
i += 1
if i == 0:
print('missing')
continue
if len(gallery_data.files_dict[idt].keys()) > 1:
q_emb = query_embs[q]
distance_vectors = np.power(np.squeeze(np.abs(gallery_embs[b] - q_emb)), 2)
distance = np.sqrt(np.sum(distance_vectors, axis=1))
top_inds = distance.argsort()
output_classes = gallery_idts[b][top_inds]
# Calculate rank
for r in range(len(rank)):
r_top_inds = top_inds[:rank[r]]
r_output_classes = gallery_idts[b][r_top_inds]
if np.where(r_output_classes == idt)[0].shape[0] > 0:
correct[r] += 1
test_iter[r] += 1
if compute_mAP:
precision = []
correct_old = 0
for t in range(distance.shape[0]):
if idt == output_classes[t]:
precision.append(float(correct_old + 1) / (t + 1))
correct_old += 1
AP.append(np.mean(np.array(precision)))
progbar.add(1)
# metrics = {}
# if rank is not None:
# metrics['rank'] = correct.astype(np.float32) / test_iter
# if mAP:
# metrics['mAP'] = np.array(AP).mean()
rank_score = correct.astype(np.float32) / test_iter
mAP = np.mean(AP)
return rank_score, mAP
import tensorflow as tf
from train import *
from get_data import *
from Config import *
EPOCHS = train_config.EPOCHS
import matplotlib.pyplot as plt
from keras.utils import Progbar
for epoch in range(EPOCHS):
tf.print("{}/{}".format(epoch + 1, EPOCHS))
pbar = Progbar(target=60000, unit_name="CGAN")
for x, y in train_images_dataset:
dis_loss, gen_loss = train_step(x, y)
values = [("Critic Loss", np.round(dis_loss.numpy(), 4)),
("Generator Loss", np.round(gen_loss.numpy(), 4))]
pbar.add(x.shape[0], values=values)
if epoch % 5 == 0:
generate_and_save_images(cgan.generator, epoch + 1)
def __init__(self, im):
width = im.size[0]
height = im.size[1]
kk = Progbar(target=(width - 2) * (height - 2))
data = list(im.getdata(0))
lastNode = None
self.start = None
self.end = None
# Top row buffer
topnodes = [None] * width
count = 0
# Start row
for x in range(1, width - 1):
if data[x] > 0:
self.start = Maze.Node((0, x))
topnodes[x] = self.start
count += 1
break
for y in range(1, height - 1):
#print ("row", str(y)) # Uncomment this line to keep a track of row progress
rowoffset = y * width
rowaboveoffset = rowoffset - width
rowbelowoffset = rowoffset + width
# Initialise previous, current and next values
prv = False
cur = False
nxt = data[rowoffset + 1] > 0
leftnode = None
for x in range(1, width - 1):
kk.add(1)
# Move prev, current and next onwards. This way we read from the image once per pixel, marginal optimisation
prv = cur
cur = nxt
nxt = data[rowoffset + x + 1] > 0
n = None
if cur == False:
# ON WALL - No action
continue
if prv == True:
if nxt == True:
# PATH PATH PATH
# Create node only if paths above or below
if data[rowaboveoffset +
x] > 0 or data[rowbelowoffset + x] > 0:
n = Maze.Node((y, x))
leftnode.Neighbours[1] = n
n.Neighbours[3] = leftnode
leftnode = n
lastNode = n
else:
# PATH PATH WALL
# Create path at end of corridor
n = Maze.Node((y, x))
leftnode.Neighbours[1] = n
n.Neighbours[3] = leftnode
leftnode = None
lastNode = n
else:
if nxt == True:
# WALL PATH PATH
# Create path at start of corridor
n = Maze.Node((y, x))
leftnode = n
lastNode = n
else:
# WALL PATH WALL
# Create node only if in dead end
if (data[rowaboveoffset + x]
== 0) or (data[rowbelowoffset + x] == 0):
#print ("Create Node in dead end")
n = Maze.Node((y, x))
lastNode = n
# If node isn't none, we can assume we can connect N-S somewhere
if n != None:
# Clear above, connect to waiting top node
if (data[rowaboveoffset + x] > 0):
t = topnodes[x]
t.Neighbours[2] = n
n.Neighbours[0] = t
# If clear below, put this new node in the top row for the next connection
if (data[rowbelowoffset + x] > 0):
topnodes[x] = n
else:
topnodes[x] = None
count += 1
self.NodeList = []
templist = [lastNode]
visited = [lastNode.Position]
kk = Progbar(target=(np.sum(np.array(im)) * 1.5) // 255)
#fig=plt.figure()?
while templist != []:
node = templist.pop()
kk.add(1)
for neigh in [
k for k in node.Neighbours if k != None and (
k.Position not in visited) and (k not in templist)
]:
templist.append(neigh)
visited.append(neigh.Position)
self.NodeList.append((node.Position, node))
self.NodeList = dict(self.NodeList)
self.count = count
self.width = width
self.height = height
def main():
args = parseargs()
"""
if args.output is not None:
with open(args.output, 'w') as fout:
for output in outputs:
print(output, file=fout)
"""
twitterVoc = Vocab("twitter")
# Put proper location of file here
tokenizedTweets, tokenizedLabels, weights = load_tweets(
args.train, Voc=twitterVoc, initVoc=True
)
if args.classifier == "LSTM":
classifier = LSTM(
twitterVoc.num_words, args.emb_size, args.hid_size, args.num_layers, args.dropout
)
elif args.classifier == "CNN":
classifier = CNN(
twitterVoc.num_words, args.emb_size, args.hidden_sizes, args.kernel_sizes, args.dropout
)
else:
raise ValueError("Please pick CNN or LSTM")
print(twitterVoc.to_word(4))
print(twitterVoc.to_index("this"))
print(twitterVoc.num_words)
opt = torch.optim.Adam(classifier.parameters(), lr=args.lr)
loss_fn = torch.nn.CrossEntropyLoss(reduction="none")
dataset = DataLoader(
TensorDataset(tokenizedTweets, tokenizedLabels, weights), batch_size=args.batch_size
)
print(classifier)
print(f"Number of parameters: {sum(p.numel() for p in classifier.parameters())}")
classifier.train()
for i in range(args.epochs):
p = Progbar(len(dataset))
for batchidx, (x, y, w) in enumerate(dataset):
opt.zero_grad()
outputs = classifier(x)
if args.weight:
lossVal = loss_fn(outputs, y) * w
else:
lossVal = loss_fn(outputs, y)
lossVal = lossVal.mean()
stateful_metrics = []
stateful_metrics.append((f"Train Loss on epoch {i}", lossVal.item()))
lossVal.backward()
opt.step()
p.add(1, stateful_metrics)
# torch.save(ourLSTM.state_dict(), f'./models/{args.classifier}_run.model')
classifier.eval()
for test in args.test:
tokTestTweets, tokTestLabels, _ = load_tweets(test, twitterVoc)
with torch.no_grad():
predVal = classifier(tokTestTweets).argmax(dim=-1)
prec, conf, neg_F1, pos_F1, F1 = validate(tokTestLabels, predVal)
if args.classifier == "LSTM":
print(
f"On {test} we have Precision with classifier[{args.classifier}], weight[{args.weight}], epochs[{args.epochs}], emb_size[{args.emb_size}], hid_size[{args.hid_size}], layers[{args.num_layers}], dropout[{args.dropout}], batch_size[{args.batch_size}], and learning rate[{args.lr}]: {prec}\nF1: {F1}\nNegF1: {neg_F1}\nPosF1: {pos_F1}"
)
elif args.classifier == "CNN":
print(
f"On {test} we have Precision with classifier[{args.classifier}], weight[{args.weight}], epochs[{args.epochs}], emb_size[{args.emb_size}], hidden_size(s)[{args.hidden_sizes}], kernel_size(s)[{args.kernel_sizes}], dropout[{args.dropout}], batch_size[{args.batch_size}], and learning rate[{args.lr}]: {prec}\nF1: {F1}\nNegF1: {neg_F1}\nPosF1: {pos_F1}"
)
