def testing_function_with_args(name, distance_measure=None, bilinear=None, display=False): """Function to test the models with arguments.""" # getting the customized configurations from the command-line arguments. args = KGEArgParser().get_args([]) # Preparing data and cache the data for later usage knowledge_graph = KnowledgeGraph(dataset=args.dataset_name, negative_sample=args.sampling) knowledge_graph.prepare_data() # Extracting the corresponding model config and definition from Importer(). config_def, model_def = Importer().import_model_config(name) config = config_def(args=args) config.epochs = 1 config.test_step = 1 config.test_num = 10 config.disp_result = display config.save_model = False model = model_def(config) # Create, Compile and Train the model. While training, several evaluation will be performed. trainer = Trainer(model=model, debug=True) trainer.build_model() trainer.train_model() tf.reset_default_graph()
def test(self): """Function to evaluate final model on testing set while training the model using best hyper-paramters on merged training and validation set.""" args = KGEArgParser().get_args([]) args.model = self.model args.dataset_name = self.dataset args.debug = self.debug # Preparing data and cache the data for later usage knowledge_graph = KnowledgeGraph(dataset=args.dataset_name) knowledge_graph.prepare_data() # Extracting the corresponding model config and definition from Importer(). config_def, model_def = Importer().import_model_config( args.model_name.lower()) config = config_def(args=args) # Update the config params with the golden hyperparameter for k, v in self.best.items(): config.__dict__[k] = v model = model_def(config) if self.debug: config.epochs = 1 # Create, Compile and Train the model. While training, several evaluation will be performed. trainer = Trainer(model=model) trainer.build_model() trainer.train_model()
def testing_function(name, distance_measure=None, bilinear=None, display=False): """Function to test the models.""" knowledge_graph = KnowledgeGraph(dataset="freebase15k", negative_sample="uniform") knowledge_graph.prepare_data() # Extracting the corresponding model config and definition from Importer(). config_def, model_def = Importer().import_model_config(name) config = config_def() config.epochs = 1 config.test_step = 1 config.test_num = 10 config.disp_result = display config.save_model = False if distance_measure is not None: config.distance_measure = distance_measure if bilinear is not None: config.bilinear = bilinear model = model_def(config) # Create, Compile and Train the model. While training, several evaluation will be performed. trainer = Trainer(model=model, debug=True) trainer.build_model() trainer.train_model() tf.reset_default_graph()
def test_generator_proje(): """Function to test the generator for ProjE algorithm.""" knowledge_graph = KnowledgeGraph(dataset="freebase15k", negative_sample="uniform") knowledge_graph.force_prepare_data() args = KGEArgParser().get_args([]) config = ProjE_pointwiseConfig(args=args) gen = iter(Generator(config=GeneratorConfig(data='train', algo='ProjE'), model_config=config)) for i in range(1000): data = list(next(gen)) print("----batch:", i) hr_hr = data[0] hr_t = data[1] tr_tr = data[2] tr_h = data[3] print("hr_hr:", hr_hr) print("hr_t:", hr_t) print("tr_tr:", tr_tr) print("tr_h:", tr_h) gen.stop()
def main(): # getting the customized configurations from the command-line arguments. args = KGEArgParser().get_args(sys.argv[1:]) # Preparing data and cache the data for later usage knowledge_graph = KnowledgeGraph(dataset=args.dataset_name, negative_sample=args.sampling, custom_dataset_path=args.dataset_path) knowledge_graph.prepare_data() # Extracting the corresponding model config and definition from Importer(). config_def, model_def = Importer().import_model_config( args.model_name.lower()) config = config_def(args=args) model = model_def(config) # Create, Compile and Train the model. While training, several evaluation will be performed. trainer = Trainer(model=model, debug=args.debug) trainer.build_model() trainer.train_model() #can perform all the inference here after training the model trainer.enter_interactive_mode() code.interact(local=locals()) trainer.exit_interactive_mode()
def test_generator_trane(): """Function to test the generator for Translation distance based algorithm.""" knowledge_graph = KnowledgeGraph(dataset="freebase15k", negative_sample="uniform") knowledge_graph.force_prepare_data() args = KGEArgParser().get_args([]) start_time = timeit.default_timer() config = TransEConfig(args) gen = Generator(config=GeneratorConfig(data='train', algo='transe'), model_config=config) print("----init time:", timeit.default_timer() - start_time) for i in range(10): start_time_batch = timeit.default_timer() data = list(next(gen)) h = data[0] r = data[1] t = data[2] # hr_t = data[3] # tr_h = data[4] print("----batch:", i, "----time:",timeit.default_timer() - start_time_batch) print(h,r,t) print("total time:", timeit.default_timer() - start_time) gen.stop()
def test_kgpipeline(): """Function to test the KGPipeline function.""" # Preparing data and cache the data for later usage knowledge_graph = KnowledgeGraph(dataset="Freebase15k") knowledge_graph.prepare_data() kg_pipeline = KGPipeline(model="transe", dataset="Freebase15k", debug=True) kg_pipeline.tune() kg_pipeline.test()
def testing_function_with_args(name, l1_flag, distance_measure=None, bilinear=None, display=False): """Function to test the models with arguments.""" tf.reset_default_graph() # getting the customized configurations from the command-line arguments. args = KGEArgParser().get_args([]) # Preparing data and cache the data for later usage knowledge_graph = KnowledgeGraph(dataset=args.dataset_name, negative_sample=args.sampling) knowledge_graph.prepare_data() # Extracting the corresponding model config and definition from Importer(). config_def, model_def = Importer().import_model_config(name) config = config_def(args=args) config.epochs = 1 config.test_step = 1 config.test_num = 10 config.disp_result = display config.save_model = True config.L1_flag = l1_flag model = model_def(config) # Create, Compile and Train the model. While training, several evaluation will be performed. trainer = Trainer(model=model, debug=True) trainer.build_model() trainer.train_model() #can perform all the inference here after training the model trainer.enter_interactive_mode() #takes head, relation tails = trainer.infer_tails(1, 10, topk=5) assert len(tails) == 5 #takes relation, tail heads = trainer.infer_heads(10, 20, topk=5) assert len(heads) == 5 #takes head, tail relations = trainer.infer_rels(1, 20, topk=5) assert len(relations) == 5 trainer.exit_interactive_mode()
def test_fb15k_meta(): """Function to test the the knowledge graph parse for Freebase and basic operations.""" knowledge_graph = KnowledgeGraph(dataset="freebase15k") knowledge_graph.force_prepare_data() knowledge_graph.dump() assert knowledge_graph.is_cache_exists() knowledge_graph.prepare_data() knowledge_graph.dataset.read_metadata() knowledge_graph.dataset.dump()
def __init__(self, args=None): """store the information of database""" if args.model.lower() in ["tucker", "tucker_v2", "conve", "convkb", "proje_pointwise"]: raise Exception("Model %s has not been supported in tuning hyperparameters!" % args.model) model_name = args.model.lower() self.args = args self.knowledge_graph = KnowledgeGraph(dataset=args.dataset_name, custom_dataset_path=args.dataset_path) hyper_params = None try: self.model_obj = getattr(importlib.import_module(model_path + ".%s" % moduleMap[model_name]), modelMap[model_name]) self.config_obj = getattr(importlib.import_module(config_path), configMap[model_name]) hyper_params = getattr(importlib.import_module(hyper_param_path), hypMap[model_name])() except ModuleNotFoundError: self._logger.error("%s not implemented! Select from: %s" % \ (model_name, ' '.join(map(str, modelMap.values())))) from pykg2vec.config.config import KGEArgParser kge_args = KGEArgParser().get_args([]) kge_args.dataset_name = args.dataset_name kge_args.debug = self.args.debug config = self.config_obj(kge_args) model = self.model_obj(config) self.trainer = Trainer(model) self.search_space = hyper_params.search_space self.max_evals = self.args.max_number_trials if not self.args.debug else 1
def __init__(self, args=None): """store the information of database""" model_name = args.model.lower() self.args = args self.knowledge_graph = KnowledgeGraph(dataset=args.dataset_name, negative_sample=args.sampling) hyper_params = None try: self.model_obj = getattr( importlib.import_module(model_path + ".%s" % modelMap[model_name]), modelMap[model_name]) self.config_obj = getattr(importlib.import_module(config_path), configMap[model_name]) hyper_params = getattr(importlib.import_module(hyper_param_path), hypMap[model_name])() except ModuleNotFoundError: print("%s not implemented! Select from: %s" % (model_name, ' '.join(map(str, modelMap.values())))) config = self.config_obj() config.data = args.dataset_name self.trainer = Trainer(model=self.model_obj(config), debug=self.args.debug, tuning=True) self.search_space = self.define_search_space(hyper_params) self.max_evals = self.args.max_number_trials if not self.args.debug else 1
def tunning_function(name): """Function to test the tuning of the models.""" knowledge_graph = KnowledgeGraph(dataset="freebase15k") knowledge_graph.prepare_data() # getting the customized configurations from the command-line arguments. args = KGETuneArgParser().get_args([]) # initializing bayesian optimizer and prepare data. args.debug = True args.model = name bays_opt = BaysOptimizer(args=args) bays_opt.trainer.config.test_num = 10 # perform the golden hyperparameter tuning. bays_opt.optimize()
def get_model(result_path_dir, configured_epochs, patience, config_key): args = KGEArgParser().get_args([]) knowledge_graph = KnowledgeGraph(dataset="Freebase15k") knowledge_graph.prepare_data() config_def, model_def = Importer().import_model_config(config_key) config = config_def(args=args) config.epochs = configured_epochs config.test_step = 1 config.test_num = 1 config.disp_result = False config.save_model = False config.path_result = result_path_dir config.debug = True config.patience = patience return model_def(config)
def main(): # getting the customized configurations from the command-line arguments. args = KGEArgParser().get_args(sys.argv[1:]) # Preparing data and cache the data for later usage knowledge_graph = KnowledgeGraph(dataset=args.dataset_name, custom_dataset_path=args.dataset_path) knowledge_graph.prepare_data() # Extracting the corresponding model config and definition from Importer(). config_def, model_def = Importer().import_model_config( args.model_name.lower()) config = config_def(args) model = model_def(config) # Create, Compile and Train the model. While training, several evaluation will be performed. trainer = Trainer(model=model) trainer.build_model() trainer.train_model()
def main(): # getting the customized configurations from the command-line arguments. args = KGEArgParser().get_args(sys.argv[1:]) knowledge_graph = KnowledgeGraph(dataset=args.dataset_name, negative_sample=args.sampling) knowledge_graph.prepare_data() # Extracting the corresponding model config and definition from Importer(). config_def, model_def = Importer().import_model_config( args.model_name.lower()) config = config_def(args=args) model = model_def(config) # Create, Compile and Train the model. While training, several evaluation will be performed. trainer = Trainer(model=model, debug=args.debug) trainer.build_model() trainer.load_model() trainer.export_embeddings()
def experiment(model_name): args = KGEArgParser().get_args([]) args.exp = True args.dataset_name = "fb15k" # Preparing data and cache the data for later usage knowledge_graph = KnowledgeGraph(dataset=args.dataset_name, negative_sample=args.sampling, custom_dataset_path=args.dataset_path) knowledge_graph.prepare_data() # Extracting the corresponding model config and definition from Importer(). config_def, model_def = Importer().import_model_config(model_name) config = config_def(args=args) model = model_def(config) # Create, Compile and Train the model. While training, several evaluation will be performed. trainer = Trainer(model=model) trainer.build_model() trainer.train_model()
def run_pykg2vec(): # getting the customized configurations from the command-line arguments. args = PyKG2VecArgParser().get_args(sys.argv[1:]) args.dataset_path = preprocess(args.triples_path, args.dataset_name) # Preparing data and cache the data for later usage knowledge_graph = KnowledgeGraph(dataset=args.dataset_name, negative_sample=args.sampling, custom_dataset_path=args.dataset_path) knowledge_graph.prepare_data() # Extracting the corresponding model config and definition from Importer(). config_def, model_def = Importer().import_model_config( args.model_name.lower()) config = config_def(args=args) model = model_def(config) # Create, Compile and Train the model. While training, several evaluation will be performed. trainer = Trainer(model=model, debug=args.debug) trainer.build_model() trainer.train_model()
def main(): args = KGEArgParser().get_args(sys.argv[1:]) if Path(args.dataset_path).exists(): kdl = KnowledgeDataLoader(data_dir=args.dataset_path, negative_sampling=args.sampling) kg = kdl.get_knowledge_graph() print('Successfully loaded {} triples from {}.'.format( len(kdl.triples), kdl.data_dir)) else: print('Unable to find dataset from path:', args.dataset_path) print( 'Default loading Freebase15k dataset with default hyperparameters...' ) kg = KnowledgeGraph() kg.prepare_data() kg.dump() # TODO: Not sure why new dataset isn't cached on subsequent hits... args.dataset_path = './data/' + kg.dataset_name args.dataset_name = kg.dataset_name # Add new model configurations to run. models = [TransE(transe_config(args=args))] for model in models: print('---- Training Model: {} ----'.format(model.model_name)) trainer = Trainer(model=model, debug=args.debug) trainer.build_model() trainer.train_model() tf.reset_default_graph()
def testing_function(name, distance_measure=None, bilinear=None, display=False, ent_hidden_size=None, rel_hidden_size=None, channels=None): """Function to test the models with arguments.""" # getting the customized configurations from the command-line arguments. args = KGEArgParser().get_args(['-exp', 'True']) # Preparing data and cache the data for later usage knowledge_graph = KnowledgeGraph(dataset=args.dataset_name) knowledge_graph.prepare_data() # Extracting the corresponding model config and definition from Importer(). config_def, model_def = Importer().import_model_config(name) config = config_def(args) config.epochs = 1 config.test_step = 1 config.test_num = 10 config.disp_result = display config.save_model = False config.debug = True if ent_hidden_size: config.ent_hidden_size = ent_hidden_size if rel_hidden_size: config.rel_hidden_size = rel_hidden_size if channels: config.channels = channels model = model_def(config) # Create, Compile and Train the model. While training, several evaluation will be performed. trainer = Trainer(model=model) trainer.build_model() trainer.train_model()
def main(): # getting the customized configurations from the command-line arguments. args = KGEArgParser().get_args(sys.argv[1:]) # Preparing data and cache the data for later usage knowledge_graph = KnowledgeGraph(dataset=args.dataset_name, negative_sample=args.sampling) knowledge_graph.prepare_data() sess_infer = tf.InteractiveSession() # Extracting the corresponding model config and definition from Importer(). config_def, model_def = Importer().import_model_config(args.model_name.lower()) config = config_def(args=args) model = model_def(config) # Create, Compile and Train the model. While training, several evaluation will be performed. trainer = Trainer(model=model, debug=args.debug) trainer.build_model() trainer.train_model() #can perform all the inference here after training the model #takes head, relation trainer.infer_tails(1,10,sess_infer,topk=5) #takes relation, tails trainer.infer_heads(10,20,sess_infer,topk=5) sess_infer.close()
def get_knowledge_graph(self): dataset_name = self.data_dir.stem if '.' not in self.data_dir.stem else self.data_dir.stem.split( '.')[0] custom_dataset_path = self.data_dir.parent / dataset_name if not custom_dataset_path.exists(): Path(custom_dataset_path).mkdir(parents=True, exist_ok=True) # Means directory is created, but split files don't exist if not custom_dataset_path.is_file(): self.__load() self.__split(write_path=custom_dataset_path, name=dataset_name) return KnowledgeGraph(dataset=dataset_name, negative_sample=self.negative_sampling, custom_dataset_path=custom_dataset_path)
def test_fb15k_manipulate(): """Function to test the the knowledge graph parse for Freebase and basic operations.""" knowledge_graph = KnowledgeGraph(dataset="freebase15k", negative_sample="bern") knowledge_graph.force_prepare_data() knowledge_graph.dump() knowledge_graph.read_cache_data('triplets_train') knowledge_graph.read_cache_data('triplets_test') knowledge_graph.read_cache_data('triplets_valid') knowledge_graph.read_cache_data('hr_t') knowledge_graph.read_cache_data('tr_h') knowledge_graph.read_cache_data('idx2entity') knowledge_graph.read_cache_data('idx2relation') knowledge_graph.read_cache_data('entity2idx') knowledge_graph.read_cache_data('relation2idx')
def test_userdefined_dataset(): custom_dataset_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'resource', 'custom_dataset') knowledge_graph = KnowledgeGraph(dataset="userdefineddataset", custom_dataset_path=custom_dataset_path) knowledge_graph.prepare_data() knowledge_graph.dump() knowledge_graph.read_cache_data('triplets_train') knowledge_graph.read_cache_data('triplets_test') knowledge_graph.read_cache_data('triplets_valid') knowledge_graph.read_cache_data('hr_t') knowledge_graph.read_cache_data('tr_h') knowledge_graph.read_cache_data('idx2entity') knowledge_graph.read_cache_data('idx2relation') knowledge_graph.read_cache_data('entity2idx') knowledge_graph.read_cache_data('relation2idx') knowledge_graph.dataset.read_metadata() knowledge_graph.dataset.dump() assert knowledge_graph.kg_meta.tot_train_triples == 1 assert knowledge_graph.kg_meta.tot_test_triples == 1 assert knowledge_graph.kg_meta.tot_valid_triples == 1 assert knowledge_graph.kg_meta.tot_entity == 6 assert knowledge_graph.kg_meta.tot_relation == 3
def test_dl50a(): """Function to test the the knowledge graph parse for Deep learning knowledge base.""" knowledge_graph = KnowledgeGraph(dataset="deeplearning50a", negative_sample="uniform") knowledge_graph.force_prepare_data() knowledge_graph.dump()
def test_fb15k(): """Function to test the the knowledge graph parse for Freebase.""" knowledge_graph = KnowledgeGraph(dataset="freebase15k", negative_sample="uniform") knowledge_graph.force_prepare_data() knowledge_graph.dump()
def test_yago(): """Function to test the the knowledge graph parse for Yago Dataset.""" knowledge_graph = KnowledgeGraph(dataset="yago3_10", negative_sample="uniform") knowledge_graph.force_prepare_data() knowledge_graph.dump()
def test_wn18rr(): """Function to test the the knowledge graph parse for Wordnet Dataset.""" knowledge_graph = KnowledgeGraph(dataset="wordnet18_rr", negative_sample="uniform") knowledge_graph.force_prepare_data() knowledge_graph.dump()
def test_benchmarks(dataset_name): """Function to test the the knowledge graph parse for Freebase.""" print("testing downloading from online sources of benchmarks and KG controller's handling.") knowledge_graph = KnowledgeGraph(dataset=dataset_name) knowledge_graph.force_prepare_data() knowledge_graph.dump()