def run(only_forward=False): if FLAGS.seed != 0: random.seed(FLAGS.seed) torch.manual_seed(FLAGS.seed) # set visualization vis = None if FLAGS.has_visualization: vis = Visualizer(env=FLAGS.experiment_name, port=FLAGS.visualization_port) vis.log(json.dumps(FLAGS.FlagValuesDict(), indent=4, sort_keys=True), win_name="Parameter") # set logger log_file = os.path.join(FLAGS.log_path, FLAGS.experiment_name + ".log") logger = logging.getLogger() log_level = logging.DEBUG if FLAGS.log_level == "debug" else logging.INFO logger.setLevel(level=log_level) # Formatter formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') # FileHandler file_handler = logging.FileHandler(log_file) file_handler.setFormatter(formatter) logger.addHandler(file_handler) # StreamHandler stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) logger.info("Flag Values:\n" + json.dumps(FLAGS.FlagValuesDict(), indent=4, sort_keys=True)) # load data dataset_path = os.path.join(FLAGS.data_path, FLAGS.dataset) rec_eval_files = [] kg_eval_files = [] if FLAGS.rec_test_files is not None: rec_eval_files = FLAGS.rec_test_files.split(':') if FLAGS.kg_test_files is not None: kg_eval_files = FLAGS.kg_test_files.split(':') rating_train_dataset, rating_eval_datasets, u_map, i_map, triple_train_dataset, triple_eval_datasets, e_map, r_map, ikg_map = load_data( dataset_path, rec_eval_files, kg_eval_files, FLAGS.batch_size, negtive_samples=FLAGS.negtive_samples, logger=logger) rating_train_iter, rating_train_total, rating_train_list, rating_train_dict = rating_train_dataset triple_train_iter, triple_train_total, triple_train_list, triple_train_head_dict, triple_train_tail_dict = triple_train_dataset user_total = len(u_map) item_total = len(i_map) entity_total = len(e_map) relation_total = len(r_map) if FLAGS.share_embeddings: item_entity_total = len(ikg_map) entity_total = item_entity_total item_total = item_entity_total joint_model = init_model(FLAGS, user_total, item_total, entity_total, relation_total, logger, i_map=i_map, e_map=e_map, new_map=ikg_map) triple_epoch_length = math.ceil( float(triple_train_total) / (1 - FLAGS.joint_ratio) / FLAGS.batch_size) rating_epoch_length = math.ceil( float(rating_train_total) / FLAGS.joint_ratio / FLAGS.batch_size) epoch_length = max(triple_epoch_length, rating_epoch_length) trainer = ModelTrainer(joint_model, logger, epoch_length, FLAGS) if FLAGS.load_ckpt_file is not None and FLAGS.share_embeddings: load_ckpt_files = FLAGS.load_ckpt_file.split(':') for filename in load_ckpt_files: trainer.loadEmbedding(os.path.join(FLAGS.log_path, filename), joint_model.state_dict(), e_remap=e_map, i_remap=i_map) joint_model.is_pretrained = True elif FLAGS.load_ckpt_file is not None: load_ckpt_files = FLAGS.load_ckpt_file.split(':') for filename in load_ckpt_files: trainer.loadEmbedding(os.path.join(FLAGS.log_path, filename), joint_model.state_dict()) joint_model.is_pretrained = True # Do an evaluation-only run. if only_forward: for i, eval_data in enumerate(rating_eval_datasets): all_dicts = None if FLAGS.filter_wrong_corrupted: all_dicts = [rating_train_dict] + [ tmp_data[3] for j, tmp_data in enumerate(rating_eval_datasets) if j != i ] evaluateRec( FLAGS, joint_model, eval_data[0], eval_data[3], all_dicts, i_map, logger, eval_descending=True if trainer.model_target == 1 else False, is_report=FLAGS.is_report) # head_iter, tail_iter, eval_total, eval_list, eval_head_dict, eval_tail_dict for i, eval_data in enumerate(triple_eval_datasets): all_head_dicts = None all_tail_dicts = None if FLAGS.filter_wrong_corrupted: all_head_dicts = [triple_train_head_dict] + [ tmp_data[4] for j, tmp_data in enumerate(triple_eval_datasets) if j != i ] all_tail_dicts = [triple_train_tail_dict] + [ tmp_data[5] for j, tmp_data in enumerate(triple_eval_datasets) if j != i ] evaluateKG(FLAGS, joint_model, eval_data[0], eval_data[1], eval_data[4], eval_data[5], all_head_dicts, all_tail_dicts, e_map, logger, eval_descending=False, is_report=FLAGS.is_report) else: train_loop(FLAGS, joint_model, trainer, rating_train_dataset, triple_train_dataset, rating_eval_datasets, triple_eval_datasets, e_map, i_map, ikg_map, logger, vis=vis, is_report=False) if vis is not None: vis.log("Finish!", win_name="Best Performances")
from jTransUP.utils.visuliazer import Visualizer import random import visdom vis = Visualizer() for i in range(100): x = random.random() vis.plot_many_stack({'x': x}, win_name="train_loss", options={ 'height': 10, 'width': 10 }) y = random.random() z = random.random() vis.plot_many_stack({ 'y': y, 'z': z }, win_name="valid_loss", options={ 'height': 300, 'width': 400 }) ''' vis = visdom.Visdom() trace = dict(x=[1, 2, 3], y=[4, 5, 6], mode="markers+lines", type='custom', marker={'color': 'red', 'symbol': 104, 'size': "10"}, text=["one", "two", "three"], name='1st Trace')
def run(only_forward=False): if FLAGS.seed != 0: random.seed(FLAGS.seed) torch.manual_seed(FLAGS.seed) # set visualization vis = None if FLAGS.has_visualization: vis = Visualizer(env=FLAGS.experiment_name, port=FLAGS.visualization_port) vis.log(json.dumps(FLAGS.FlagValuesDict(), indent=4, sort_keys=True), win_name="Parameter") # set logger log_file = os.path.join(FLAGS.log_path, FLAGS.experiment_name + ".log") logger = logging.getLogger() log_level = logging.DEBUG if FLAGS.log_level == "debug" else logging.INFO logger.setLevel(level=log_level) # Formatter formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') # FileHandler file_handler = logging.FileHandler(log_file) file_handler.setFormatter(formatter) logger.addHandler(file_handler) # StreamHandler stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) logger.info("Flag Values:\n" + json.dumps(FLAGS.FlagValuesDict(), indent=4, sort_keys=True)) # load data kg_path = os.path.join(os.path.join(FLAGS.data_path, FLAGS.dataset), 'kg') eval_files = FLAGS.kg_test_files.split(':') train_dataset, eval_datasets, e_map, r_map = load_data( kg_path, eval_files, FLAGS.batch_size, logger=logger, negtive_samples=FLAGS.negtive_samples) entity_total = len(e_map) relation_total = len(r_map) train_iter, train_total, train_list, train_head_dict, train_tail_dict = train_dataset model = init_model(FLAGS, 0, 0, entity_total, relation_total, logger) epoch_length = math.ceil(train_total / FLAGS.batch_size) trainer = ModelTrainer(model, logger, epoch_length, FLAGS) # todo : load ckpt full path if FLAGS.load_ckpt_file is not None: trainer.loadEmbedding(os.path.join(FLAGS.log_path, FLAGS.load_ckpt_file), model.state_dict(), cpu=not USE_CUDA) model.is_pretrained = True # Do an evaluation-only run. if only_forward: # head_iter, tail_iter, eval_total, eval_list, eval_head_dict, eval_tail_dict for i, eval_data in enumerate(eval_datasets): all_head_dicts = None all_tail_dicts = None if FLAGS.filter_wrong_corrupted: all_head_dicts = [train_head_dict] + [ tmp_data[4] for j, tmp_data in enumerate(eval_datasets) if j != i ] all_tail_dicts = [train_tail_dict] + [ tmp_data[5] for j, tmp_data in enumerate(eval_datasets) if j != i ] evaluate(FLAGS, model, entity_total, relation_total, eval_data[0], eval_data[1], eval_data[4], eval_data[5], all_head_dicts, all_tail_dicts, logger, eval_descending=False, is_report=FLAGS.is_report) else: train_loop(FLAGS, model, trainer, train_dataset, eval_datasets, entity_total, relation_total, logger, vis=vis, is_report=False) if vis is not None: vis.log("Finish!", win_name="Best Performances")
def run(only_forward=False): if FLAGS.seed != 0: random.seed(FLAGS.seed) torch.manual_seed(FLAGS.seed) # set visualization vis = None if FLAGS.has_visualization: vis = Visualizer(env=FLAGS.experiment_name, port=FLAGS.visualization_port) vis.log(json.dumps(FLAGS.FlagValuesDict(), indent=4, sort_keys=True), win_name="Parameter") # set logger log_file = os.path.join(FLAGS.log_path, FLAGS.experiment_name + ".log") logger = logging.getLogger() log_level = logging.DEBUG if FLAGS.log_level == "debug" else logging.INFO logger.setLevel(level=log_level) # Formatter formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') # FileHandler file_handler = logging.FileHandler(log_file) file_handler.setFormatter(formatter) logger.addHandler(file_handler) # StreamHandler stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) logger.info("Flag Values:\n" + json.dumps(FLAGS.FlagValuesDict(), indent=4, sort_keys=True)) # load data dataset_path = os.path.join(FLAGS.data_path, FLAGS.dataset) eval_files = FLAGS.rec_test_files.split( ':') if FLAGS.rec_test_files else [] train_dataset, eval_datasets, u_map, i_map = load_data( dataset_path, eval_files, FLAGS.batch_size, logger=logger, negtive_samples=FLAGS.negtive_samples) train_iter, train_total, train_list, train_dict = train_dataset user_total = max(len(u_map), max(u_map.values())) item_total = max(len(i_map), max(i_map.values())) model = init_model(FLAGS, user_total, item_total, 0, 0, logger) epoch_length = math.ceil(train_total / FLAGS.batch_size) trainer = ModelTrainer(model, logger, epoch_length, FLAGS) if FLAGS.load_ckpt_file is not None: trainer.loadEmbedding(os.path.join(FLAGS.log_path, FLAGS.load_ckpt_file), model.state_dict(), cpu=not USE_CUDA) model.is_pretrained = True # Do an evaluation-only run. if only_forward: for i, eval_data in enumerate(eval_datasets): all_dicts = None if FLAGS.filter_wrong_corrupted: all_dicts = [train_dict] + [ tmp_data[3] for j, tmp_data in enumerate(eval_datasets) if j != i ] evaluate( FLAGS, model, eval_data[0], eval_data[3], all_dicts, logger, eval_descending=True if trainer.model_target == 1 else False, is_report=FLAGS.is_report) else: train_loop(FLAGS, model, trainer, train_dataset, eval_datasets, user_total, item_total, logger, vis=vis, is_report=False) if vis is not None: vis.log("Finish!", win_name="Best Performances") torch.save( model.state_dict(), './embedding/transup-{data:s}-{embed_dim:d}-{lr:f}-{batch_size:d}-{negtive_samples:d}-{lrdecay:f}-no_early_stop_steps-{steps:d}.emb' .format( negtive_samples=FLAGS.negtive_samples, batch_size=FLAGS.batch_size, data=FLAGS.dataset, embed_dim=FLAGS.embedding_size, lr=FLAGS.learning_rate, lrdecay=FLAGS.learning_rate_decay_when_no_progress, # early_stop_steps=FLAGS.early_stopping_steps_to_wait, steps=FLAGS.training_steps, ))