dicee.static_funcs

Functions

create_recipriocal_triples(x)	Add inverse triples into dask dataframe
get_er_vocab(data[, file_path])
get_re_vocab(data[, file_path])
get_ee_vocab(data[, file_path])
timeit(func)
save_pickle(*[, data, file_path])
load_pickle([file_path])
select_model(args[, is_continual_training, storage_path])
load_model(→ Tuple[object, Tuple[dict, dict]])	Load weights and initialize pytorch module from namespace arguments
load_model_ensemble(...)	Construct Ensemble Of weights and initialize pytorch module from namespace arguments
save_numpy_ndarray(*, data, file_path)
numpy_data_type_changer(→ numpy.ndarray)	Detect most efficient data type for a given triples
save_checkpoint_model(→ None)	Store Pytorch model into disk
store(→ None)	Store trained_model model and save embeddings into csv file.
add_noisy_triples(→ pandas.DataFrame)	Add randomly constructed triples
read_or_load_kg(args, cls)
intialize_model(→ Tuple[object, str])
load_json(→ dict)
save_embeddings(→ None)	Save it as CSV if memory allows.
random_prediction(pre_trained_kge)
deploy_triple_prediction(pre_trained_kge, str_subject, ...)
deploy_tail_entity_prediction(pre_trained_kge, ...)
deploy_head_entity_prediction(pre_trained_kge, ...)
deploy_relation_prediction(pre_trained_kge, ...)
vocab_to_parquet(vocab_to_idx, name, ...)
create_experiment_folder([folder_name])
continual_training_setup_executor(→ None)	storage_path:str A path leading to a parent directory, where a subdirectory containing KGE related data
exponential_function(→ torch.FloatTensor)
load_numpy(→ numpy.ndarray)
evaluate(entity_to_idx, scores, easy_answers, hard_answers)	# @TODO: CD: Renamed this function
download_file(url[, destination_folder])
download_files_from_url(→ None)
download_pretrained_model(→ str)

Module Contents

dicee.static_funcs.create_recipriocal_triples(x)

Add inverse triples into dask dataframe :param x: :return:

dicee.static_funcs.get_er_vocab(data, file_path: str = None)

dicee.static_funcs.get_re_vocab(data, file_path: str = None)

dicee.static_funcs.get_ee_vocab(data, file_path: str = None)

dicee.static_funcs.timeit(func)

dicee.static_funcs.save_pickle(*, data: object = None, file_path=str)

dicee.static_funcs.load_pickle(file_path=str)

dicee.static_funcs.select_model(args: dict, is_continual_training: bool = None, storage_path: str = None)

dicee.static_funcs.load_model(path_of_experiment_folder: str, model_name='model.pt', verbose=0) → Tuple[object, Tuple[dict, dict]]

Load weights and initialize pytorch module from namespace arguments

dicee.static_funcs.load_model_ensemble(path_of_experiment_folder: str) → Tuple[dicee.models.base_model.BaseKGE, Tuple[pandas.DataFrame, pandas.DataFrame]]

Construct Ensemble Of weights and initialize pytorch module from namespace arguments

1. Detect models under given path

2. Accumulate parameters of detected models

3. Normalize parameters

4. Insert (3) into model.

dicee.static_funcs.save_numpy_ndarray(*, data: numpy.ndarray, file_path: str)

dicee.static_funcs.numpy_data_type_changer(train_set: numpy.ndarray, num: int) → numpy.ndarray

Detect most efficient data type for a given triples :param train_set: :param num: :return:

dicee.static_funcs.save_checkpoint_model(model, path: str) → None

Store Pytorch model into disk

dicee.static_funcs.store(trainer, trained_model, model_name: str = 'model', full_storage_path: str = None, save_embeddings_as_csv=False) → None

Store trained_model model and save embeddings into csv file. :param trainer: an instance of trainer class :param full_storage_path: path to save parameters. :param model_name: string representation of the name of the model. :param trained_model: an instance of BaseKGE see core.models.base_model . :param save_embeddings_as_csv: for easy access of embeddings. :return:

dicee.static_funcs.add_noisy_triples(train_set: pandas.DataFrame, add_noise_rate: float) → pandas.DataFrame

Add randomly constructed triples :param train_set: :param add_noise_rate: :return:

dicee.static_funcs.read_or_load_kg(args, cls)

dicee.static_funcs.intialize_model(args: dict, verbose=0) → Tuple[object, str]

dicee.static_funcs.load_json(p: str) → dict

dicee.static_funcs.save_embeddings(embeddings: numpy.ndarray, indexes, path: str) → None

Save it as CSV if memory allows. :param embeddings: :param indexes: :param path: :return:

dicee.static_funcs.random_prediction(pre_trained_kge)

dicee.static_funcs.deploy_triple_prediction(pre_trained_kge, str_subject, str_predicate, str_object)

dicee.static_funcs.deploy_tail_entity_prediction(pre_trained_kge, str_subject, str_predicate, top_k)

dicee.static_funcs.deploy_head_entity_prediction(pre_trained_kge, str_object, str_predicate, top_k)

dicee.static_funcs.deploy_relation_prediction(pre_trained_kge, str_subject, str_object, top_k)

dicee.static_funcs.vocab_to_parquet(vocab_to_idx, name, path_for_serialization, print_into)

dicee.static_funcs.create_experiment_folder(folder_name='Experiments')

dicee.static_funcs.continual_training_setup_executor(executor) → None

storage_path:str A path leading to a parent directory, where a subdirectory containing KGE related data

full_storage_path:str A path leading to a subdirectory containing KGE related data

dicee.static_funcs.exponential_function(x: numpy.ndarray, lam: float, ascending_order=True) → torch.FloatTensor

dicee.static_funcs.load_numpy(path) → numpy.ndarray

dicee.static_funcs.evaluate(entity_to_idx, scores, easy_answers, hard_answers)

# @TODO: CD: Renamed this function Evaluate multi hop query answering on different query types

dicee.static_funcs.download_file(url, destination_folder='.')

dicee.static_funcs.download_files_from_url(base_url: str, destination_folder='.') → None

Parameters:

• base_url (e.g. “https://files.dice-research.org/projects/DiceEmbeddings/KINSHIP-Keci-dim128-epoch256-KvsAll”)

• destination_folder (e.g. "KINSHIP-Keci-dim128-epoch256-KvsAll")

dicee.static_funcs.download_pretrained_model(url: str) → str