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}" )