def run(self): # set random seeds random.seed(self.args.seed) torch.manual_seed(self.args.seed) np.random.seed(self.args.seed) self.log_dir = self.args.log_dir if not os.path.isdir(self.log_dir): os.makedirs(self.log_dir) self.log_dir = os.path.join(self.args.log_dir, self.suffix) self.descs_dir = os.path.join(self.log_dir, 'temp_descs') if self.test_on_w1bs: if not os.path.isdir(self.descs_dir): os.makedirs(self.descs_dir) logger, file_logger = None, None print("Creating Model") if(self.args.enable_logging): from Loggers import Logger, FileLogger logger = Logger(self.log_dir) #file_logger = FileLogger(./log/+self.suffix) print("Creating Loaders") train_loader, test_loaders = self.create_loaders(load_random_triplets = self.triplet_flag) print("Staring execution") self.execute(train_loader, test_loaders, self.model, logger, file_logger)
def init_loggers(): global loggers #loggers['Application'] = Logger('Application', logging.INFO, format_str="%(name)s - %(levelname)s - %(message)s") loggers['Application'] = SilentLogger() loggers['SignalSending'] = SilentLogger() #loggers['SignalSending'] = Logger('SignalSenging', logging.INFO) loggers['Debug'] = Logger( 'Debug', logging.DEBUG, format_str="%(name)s - %(levelname)s - %(message)s")
def train(self, epoch, doEval): logger = Logger("aaeInfo/log/") parameters_recon = list(self.encoder.parameters()) + list(self.decoder.parameters()) optimizer_recon = torch.optim.SGD(parameters_recon, lr=1e-6, momentum=0.9) optimizer_discr = torch.optim.SGD(self.discriminator.parameters(), lr=1e-6, momentum=0.1) optimizer_gener = torch.optim.SGD(self.encoder.parameters(), lr=1e-6, momentum=0.1) # optimizer_recon = torch.optim.Adam(parameters_recon, betas=(0.9, 0.999), lr=1e-5) # optimizer_discr = torch.optim.Adam(self.discriminator.parameters(), betas=(0.1, 0.001), lr=1e-4) # optimizer_gener = torch.optim.Adam(self.encoder.parameters(), betas=(0.1, 0.001), lr=1e-4) best_loss = float("Inf") for e in range(epoch): sys.stdout.flush() print("Epoch %d" % e) for i,x in enumerate(self.train_loader): x = x.cuda() optimizer_recon.zero_grad() recon_loss, recon_acc1, recon_acc2 = self.reconstruct_loss(x) recon_loss.backward() optimizer_recon.step() optimizer_discr.zero_grad() discr_loss, discr_acc = self.dicriminate_loss(x) discr_loss.backward() optimizer_discr.step() optimizer_gener.zero_grad() fool_loss, fool_acc = self.fool_loss(x) fool_loss.backward() optimizer_gener.step() print("Batch No: %d, recon_loss: %f, recon_acc1: %f, recon_acc2: %f, discr_loss: %f, discr_acc: %f, fool_loss: %f, fool_acc: %f" % (i+1, recon_loss, recon_acc1, recon_acc2, discr_loss, discr_acc, fool_loss, fool_acc)) sys.stdout.flush() if doEval: recon_loss, recon_acc1, recon_acc2, discri_loss, discr_acc, fool_loss, fool_acc = self.eval(self.train_loader, len(self.train_dataset)) print("Reconstruction Train Loss: %f, Rule Accuracy: %f, Mol Accuracy: %f" % (recon_loss, recon_acc1, recon_acc2)) print("Discrimination Train Loss: %f, Accuracy: %f" % (discri_loss, discr_acc)) print("Fool Train Loss: %f, Accuracy: %f" % (fool_loss, fool_acc)) recon_loss, recon_acc1, recon_acc2, discri_loss, discr_acc, fool_loss, fool_acc = self.eval(self.eval_loader, len(self.eval_dataset)) print("Reconstruction Valid Loss: %f, Rule Accuracy: %f, Mol Accuracy: %f" % (recon_loss, recon_acc1, recon_acc2)) print("Discrimination Valid Loss: %f, Accuracy: %f" % (discri_loss, discr_acc)) print("Fool Valid Loss: %f, Accuracy: %f" % (fool_loss, fool_acc)) self.log_info(logger, recon_loss, recon_acc1, recon_acc2, discri_loss, discr_acc, fool_loss, fool_acc) if recon_loss < best_loss: print("Save Model") best_loss = recon_loss self.save()
def train(self, epoch, doEval): logger = Logger("vaeInfo/log/") parameters = list(self.encoder.parameters()) + list( self.decoder.parameters()) optimizer = torch.optim.Adam(parameters, lr=1e-5) # optimizer = torch.optim.SGD(parameters, lr=1e-5, momentum=0.9) best_acc = 0 for e in range(epoch): sys.stdout.flush() print("Epoch %d" % e) for i, x in enumerate(self.train_loader): x = x.cuda() optimizer.zero_grad() batch_loss, recon_loss, kl_loss, acc1, acc2 = self.loss(x) batch_loss.backward() optimizer.step() # print("Batch No: %d, loss: %f, recon_loss: %f, kl_loss: %f, acc1: %f, acc2: %f" # % (i+1, batch_loss, recon_loss, kl_loss, acc1, acc2)) sys.stdout.flush() if doEval: all_loss, recon_loss, kl_loss, acc1, acc2 = self.eval( self.train_loader, len(self.train_dataset)) print("Overall Training Loss: %f" % all_loss) print("Recontruction Training Loss: %f" % recon_loss) print("KL Training Loss: %f" % kl_loss) print("Rule Accuracy Training: %f" % acc1) print("Mol Accuracy Training: %f" % acc2) all_loss, recon_loss, kl_loss, acc1, acc2 = self.eval( self.eval_loader, len(self.eval_dataset)) print("Overall Validation Loss: %f" % all_loss) print("Recontruction Validation Loss: %f" % recon_loss) print("KL Validation Loss: %f" % kl_loss) print("Rule Accuracy Validation: %f" % acc1) print("Mol Accuracy Validation: %f" % acc2) self.log_info(logger, all_loss, recon_loss, kl_loss, acc1, acc2) if acc2 > best_acc: print("Save Model") best_acc = acc2 self.save()
def play_one_game(board: Board, model: Model, logger: Logger): color = CROSS while True: policy = model.infer(board.data(color)) pos = choice_move_with_epsilon(policy, board) if pos is False: logger.info("*** Move Choice Error ***") exit() board.put(pos, color) logger.debug("\n" + board.string_board()) if board.is_finished: break color = turn_color(color) if board.result == CROSS: result = "X Win" elif board.result == CYCLE: result = "O win" else: result = "DRAW" logger.info("result is {}".format(result))
descs_to_draw=[desc_name], logger=file_logger, tensor_logger = logger) else: w1bs.draw_and_save_plots(DESC_DIR=DESCS_DIR, OUT_DIR=OUT_DIR, methods=["SNN_ratio"], descs_to_draw=[desc_name]) #randomize train loader batches train_loader, test_loaders2 = create_loaders(load_random_triplets=triplet_flag) ''' print('i am here') if __name__ == '__main__': LOG_DIR = args.log_dir if not os.path.isdir(LOG_DIR): os.makedirs(LOG_DIR) LOG_DIR = os.path.join(args.log_dir, suffix) DESCS_DIR = os.path.join(LOG_DIR, 'temp_descs') if TEST_ON_W1BS: if not os.path.isdir(DESCS_DIR): os.makedirs(DESCS_DIR) logger, file_logger = None, None model = HardNet() if(args.enable_logging): from Loggers import Logger, FileLogger logger = Logger(LOG_DIR) #file_logger = FileLogger(./log/+suffix) train_loader, test_loaders = create_loaders(load_random_triplets = triplet_flag) main(train_loader, test_loaders, model, logger, file_logger)
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(label_place_holder, 1)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) print('done constructing model') restorer = tf.train.Saver(variables_to_restore) sess.run(tf.global_variables_initializer()) if args.base_network == 'InceptionV1': restorer.restore(sess, args.base_network_file) print('done initializing') if not os.path.isdir(args.log_dir): os.makedirs(args.log_dir + args.dataset) logger = Logger(args.log_dir + args.dataset + '/' + suffix) if not os.path.isdir('{}/{}/{}/'.format(args.model_dir, args.dataset, suffix)): os.makedirs('{}/{}/{}/'.format(args.model_dir, args.dataset, suffix)) saver = tf.train.Saver() #learn one epoch to heat up the bn parameter ptr = 0 random_ind = np.random.permutation(num_training_sample) for step in tqdm(range(int(num_training_sample / training_batch_size) + 1)): real_size = min(training_batch_size, num_training_sample - ptr) if real_size <= 0: break img = np.zeros((real_size, default_image_size,\ default_image_size, 3), dtype = np.float32)
for x in dic['pred'][0][:, :, :, :, :] ])) ] cp_models_path = os.path.join( os.path.abspath(os.path.dirname(__file__)), "models", "weights-improvement-{epoch:02d}-{val_loss:.2f}.hdf5") model = create_model(train_config) tf.set_random_seed(0) sess = tf.keras.backend.get_session() with sess.as_default(): tb = TensorBoard(log_dir='./logs') logging.info("Start Training") model.fit_generator(generator=train_generator(), validation_data=[validation_data, validation_data_y], epochs=train_config['epochs'], steps_per_epoch=int(training_elements / train_config['batchsize']), callbacks=[ tb, Logger(tb_logs=tb_writers), ModelCheckpoint(cp_models_path, save_best_only=True) ]) model.save(train_config['model_output']) data_queue.close() for p in processes: p.terminate()
import os ; os.environ['KERAS_BACKEND']='theano' else: import os ; os.environ['KERAS_BACKEND']='tensorflow' logging.getLogger('keras').setLevel(logging.INFO) if args.mode == 'nlIB': suffix = '{}_encoder{}_beta{:1.1f}'.format(args.mode,args.encoder,args.beta) else: suffix = '{}_encoder{}'.format(args.mode,args.encoder) LOG_DIR = args.log_dir if not os.path.isdir(LOG_DIR): os.makedirs(LOG_DIR) LOG_DIR = args.log_dir + suffix logger = Logger(LOG_DIR) import reporting import buildmodel import keras.callbacks arg_dict = vars(args) VALIDATE_ON_TEST = True #arg_dict['noise_logvar_trainable'] = True trn, tst = buildmodel.get_mnist(args.trainN, args.testN) # *************************** arg_dict['INPUT_DIM'] = trn.X.shape[1] print('# ARGS:', arg_dict)
suffix = suffix + '_ln' if args.label_smoothing: suffix = suffix + '_ls' if args.norm_weights: suffix = suffix + '_nw' if args.bn: suffix = suffix + '_bn' args.alpha = args.alpha / np.sqrt(args.embedding_dim) if args.heat_up: suffix = suffix + '_heat' LOG_DIR = args.log_dir if not os.path.isdir(LOG_DIR): os.makedirs(LOG_DIR) LOG_DIR = args.log_dir + suffix logger = Logger(LOG_DIR) # Parameters learning_rate = args.learning_rate training_epochs = args.nb_epoch batch_size = 20 display_step = 10 # Network Parameters n_input = 28 # MNIST data input (img shape: 28*28) n_classes = 5 # MNIST total classes (0-4 digits) config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config)
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(label_place_holder, 1)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) print('done constructing model') print('initialize variables') config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) sess.run(tf.global_variables_initializer()) print('done initializing') if not os.path.isdir(args.log_dir): os.makedirs(args.log_dir) logger = Logger(args.log_dir + suffix) global_step = 0 log_step = 0 for epoch in range(args.nb_epoch): ptr = 0 for step in tqdm(range(int(num_training_sample / training_batch_size) + 1)): real_size = min(training_batch_size, num_training_sample - ptr) if real_size <= 0: break if args.data_augment: img = np.zeros((real_size, default_image_size,\ default_image_size, 3), dtype = np.float32) flip_flag = np.random.randint(2, size=real_size)
np.random.seed(args.seed) if not os.path.isdir(args.log_dir): os.makedirs(args.log_dir) log_dir = os.path.join(args.log_dir, suffix) DESCS_DIR = os.path.join(log_dir, 'temp_descs') if TEST_ON_W1BS: if not os.path.isdir(DESCS_DIR): os.makedirs(DESCS_DIR) logger, file_logger = None, None if args.use_srn: from models.HardNet_SRN import HardNet_SRN model = HardNet_SRN(args.use_smooth) else: from models.HardNet import HardNet model = HardNet(args.use_arf, args.orientation) if (args.enable_logging): from Loggers import Logger, FileLogger logger = Logger( log_dir) # remove all the file in LOG_DIR and begin log file_logger = FileLogger(os.path.join(args.log_dir, suffix)) # load_random_triplets=False, the return data is (anchor, positive) # no negative patch, the negative patch is generated on-the-fly train_loader = create_loaders(load_random_triplets=triplet_flag) test_loaders = create_loaders(load_random_triplets=triplet_flag, train=False) main(train_loader, test_loaders, model, logger, file_logger)