def load_split_dataset(config):
"""Load split dataset.
Args:
config (dict): Dictionary of configuration
Returns:
train_data (DataFrame): Interaction for training.
valid_data list(DataFrame): List of interactions for validation.
test_data list(DataFrame): List of interactions for testing.
"""
print_dict_as_table(config["dataset"], tag="Dataset config")
dataset_mapping = {
"ml_100k": Movielens_100k,
"ml_1m": Movielens_1m,
"ml_25m": Movielens_25m,
"last_fm": LastFM,
"tafeng": Tafeng,
"epinions": Epinions,
"dunnhumby": Dunnhumby,
"instacart": Instacart,
"instacart_25": Instacart_25,
}
dataset = dataset_mapping[config["dataset"]["dataset"]](
root_dir=config["system"]["root_dir"])
return dataset.load_split(config["dataset"])
def test_eval_worker(testEngine, eval_data_df, prediction):
"""Start a worker for the evaluation during training.
Prediction and evaluation on the testing set.
"""
result_para = {
"run_time": [testEngine.config["run_time"]],
}
testEngine.n_worker += 1
for cfg in ["model", "dataset"]:
for col in testEngine.config[cfg]["result_col"]:
result_para[col] = [testEngine.config[cfg][col]]
test_result_dic = evaluate(eval_data_df, prediction, testEngine.metrics,
testEngine.k)
print_dict_as_table(
test_result_dic,
tag="performance on test",
columns=["metrics", "values"],
)
test_result_dic.update(result_para)
lock_test_eval.acquire() # need to be test
result_df = pd.DataFrame(test_result_dic)
save_to_csv(result_df, testEngine.config["system"]["result_file"])
lock_test_eval.release()
testEngine.n_worker -= 1
return test_result_dic
def __init__(self, config, gcn_config=None):
self.model = MLP(config)
print_dict_as_table(config, tag="MLP config")
self.gcn_config = gcn_config
super(MLPEngine, self).__init__(config)
self.model.to(self.device)
if gcn_config is not None:
self.load_pretrain_weights()
def __init__(self, config, gcn_config=None, mlp_config=None):
self.model = NeuMF(config)
print_dict_as_table(config, tag="Neumf config")
self.gcn_config = gcn_config
self.mlp_config = mlp_config
super(NeuMFEngine, self).__init__(config)
print(self.model)
if gcn_config is not None and mlp_config is not None:
self.load_pretrain_weights()
def __init__(self, config):
self.config = config
print_dict_as_table(config, tag="GCN config")
self.model = GCN_S(config)
self.regs = config["gcn_config"]["regs"] # reg is the regularisation
self.decay = self.regs[0]
self.batch_size = config["batch_size"]
self.num_batch = config["num_batch"]
self.user_fea_norm_adj = config["user_fea_norm_adj"]
self.item_fea_norm_adj = config["item_fea_norm_adj"]
super(GCN_SEngine, self).__init__(config)
def train_eval_worker(testEngine,
valid_df,
test_df,
valid_pred,
test_pred,
epoch,
top_k=10):
""" Thread worker for the evaluation during training
Args:
testEngine:
valid_df:
test_df:
valid_pred:
test_pred:
epoch:
top_k:
Returns:
"""
testEngine.n_worker += 1
valid_result = evaluate(valid_df, valid_pred, testEngine.metrics, top_k)
test_result = evaluate(test_df, test_pred, testEngine.metrics, top_k)
lock_train_eval.acquire() # need to be test
testEngine.record_performance(valid_result, test_result, epoch)
testEngine.expose_performance(valid_result, test_result)
if (valid_result[testEngine.config["validate_metric"]] >
testEngine.best_valid_performance):
testEngine.n_no_update = 0
print(
f"Current testEngine.best_valid_performance {testEngine.best_valid_performance}"
)
testEngine.best_valid_performance = valid_result[
testEngine.config["validate_metric"]]
print_dict_as_table(
valid_result,
tag=f"performance on validation at epoch {epoch}",
columns=["metrics", "values"],
)
print_dict_as_table(
test_result,
tag=f"performance on testing at epoch {epoch}",
columns=["metrics", "values"],
)
else:
testEngine.n_no_update += 1
print(f"number of epochs that have no update {testEngine.n_no_update}")
testEngine.n_worker -= 1
lock_train_eval.release()
# lock record and get best performance
return valid_result, test_result
def __init__(self, config):
self.config = config
print_dict_as_table(config["model"], tag="MF model config")
self.model = MF(config["model"])
self.reg = (config["model"]["reg"] if "reg" in config else 0.0
) # the regularization coefficient.
self.batch_size = config["model"]["batch_size"]
super(MFEngine, self).__init__(config)
self.model.to(self.device)
self.loss = (self.config["model"]["loss"]
if "loss" in self.config["model"] else "bpr")
print(f"using {self.loss} loss...")
def train_eval_worker(testEngine, valid_df, test_df, valid_pred, test_pred,
epoch):
"""Start a worker for the evaluation during training.
Args:
testEngine:
valid_df:
test_df:
valid_pred:
test_pred:
epoch (int):
Returns:
(dict,dict): dictionary with performances on validation and testing sets.
"""
testEngine.n_worker += 1
valid_result = evaluate(valid_df, valid_pred, testEngine.metrics,
testEngine.valid_k)
test_result = evaluate(test_df, test_pred, testEngine.metrics,
testEngine.valid_k)
lock_train_eval.acquire()
testEngine.record_performance(valid_result, test_result, epoch)
testEngine.expose_performance(valid_result, test_result)
if (valid_result[f"{testEngine.valid_metric}@{testEngine.valid_k}"] >
testEngine.best_valid_performance):
testEngine.n_no_update = 0
print(
f"Current testEngine.best_valid_performance {testEngine.best_valid_performance}"
)
testEngine.best_valid_performance = valid_result[
f"{testEngine.valid_metric}@{testEngine.valid_k}"]
print_dict_as_table(
valid_result,
tag=f"performance on validation at epoch {epoch}",
columns=["metrics", "values"],
)
print_dict_as_table(
test_result,
tag=f"performance on testing at epoch {epoch}",
columns=["metrics", "values"],
)
else:
testEngine.n_no_update += 1
print(f"number of epochs that have no update {testEngine.n_no_update}")
testEngine.n_worker -= 1
lock_train_eval.release()
# lock record and get best performance
return valid_result, test_result
def test_eval_worker(testEngine, eval_data_df, prediction, k_li=[5, 10, 20]):
"""
Prediction and evaluation on the testing set
"""
result_para = {
"model": [testEngine.config["model"]],
"dataset": [testEngine.config["dataset"]],
"data_split": [testEngine.config["data_split"]],
"emb_dim": [int(testEngine.config["emb_dim"])],
"lr": [testEngine.config["lr"]],
"batch_size": [int(testEngine.config["batch_size"])],
"optimizer": [testEngine.config["optimizer"]],
"max_epoch": [testEngine.config["max_epoch"]],
"model_run_id": [testEngine.config["model_run_id"]],
"run_time": [testEngine.config["run_time"]],
}
if "late_dim" in testEngine.config:
result_para["late_dim"] = [int(testEngine.config["late_dim"])]
if "remark" in testEngine.config:
result_para["remark"] = [testEngine.config["remark"]]
if "alpha" in testEngine.config:
result_para["alpha"] = [testEngine.config["alpha"]]
if "activator" in testEngine.config:
result_para["activator"] = [testEngine.config["activator"]]
if "item_fea_type" in testEngine.config:
result_para["item_fea_type"] = [testEngine.config["item_fea_type"]]
if "n_sample" in testEngine.config:
result_para["n_sample"] = [testEngine.config["n_sample"]]
if "time_step" in testEngine.config:
result_para["time_step"] = [testEngine.config["time_step"]]
test_result_dic = evaluate(eval_data_df, prediction, testEngine.metrics,
k_li)
print_dict_as_table(
test_result_dic,
tag=f"performance on test",
columns=["metrics", "values"],
)
test_result_dic.update(result_para)
lock_test_eval.acquire() # need to be test
result_df = pd.DataFrame(test_result_dic)
save_to_csv(result_df, testEngine.config["result_file"])
lock_test_eval.release()
return test_result_dic
def prepare_env(self):
"""Prepare running environment.
* Load parameters from json files.
* Initialize system folders, model name and the paths to be saved.
* Initialize resource monitor.
* Initialize random seed.
* Initialize logging.
"""
# Load config file from json
with open(self.args.config_file) as config_params:
print(f"loading config file {self.args.config_file}")
config = json.load(config_params)
# Update configs based on the received args from the command line .
update_args(config, self.args)
# obtain abspath for the project
config["system"]["root_dir"] = os.path.abspath(
config["system"]["root_dir"])
# construct unique model run id, which consist of model name, config id and a timestamp
timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
random_str = "".join(
[random.choice(string.ascii_lowercase) for n in range(6)])
config["system"]["model_run_id"] = (config["model"]["model"] + "_" +
config["model"]["config_id"] +
"_" + timestamp_str + "_" +
random_str)
# Initialize random seeds
set_seed(config["system"]["seed"] if "seed" in
config["system"] else 2020)
# Initialize working folders
self.initialize_folders(config)
config["system"]["process_dir"] = os.path.join(
config["system"]["root_dir"], config["system"]["process_dir"])
# Initialize log file
config["system"]["log_file"] = os.path.join(
config["system"]["root_dir"],
config["system"]["log_dir"],
config["system"]["model_run_id"],
)
logger.init_std_logger(config["system"]["log_file"])
print("Python version:", sys.version)
print("pytorch version:", torch.__version__)
# File paths to be saved
config["model"]["run_dir"] = os.path.join(
config["system"]["root_dir"],
config["system"]["run_dir"],
config["system"]["model_run_id"],
)
config["system"]["run_dir"] = config["model"]["run_dir"]
print(
"The intermediate running statuses will be reported in folder:",
config["system"]["run_dir"],
)
config["system"]["tune_dir"] = os.path.join(
config["system"]["root_dir"], config["system"]["tune_dir"])
def get_user_temp_dir():
tempdir = os.path.join(config["system"]["root_dir"], "tmp")
print(f"ray temp dir {tempdir}")
return tempdir
ray.utils.get_user_temp_dir = get_user_temp_dir
# Model checkpoints paths to be saved
config["system"]["model_save_dir"] = os.path.join(
config["system"]["root_dir"],
config["system"]["checkpoint_dir"],
config["system"]["model_run_id"],
)
ensureDir(config["system"]["model_save_dir"])
print("Model checkpoint will save in file:",
config["system"]["model_save_dir"])
config["system"]["result_file"] = os.path.join(
config["system"]["root_dir"],
config["system"]["result_dir"],
config["system"]["result_file"],
)
print("Performance result will save in file:",
config["system"]["result_file"])
print_dict_as_table(config["system"], "System configs")
return config
def prepare_env(config):
"""Prepare running environment
- Load parameters from json files.
- Initialize system folders, model name and the paths to be saved.
- Initialize resource monitor.
- Initialize random seed.
- Initialize logging.
Args:
config (dict): Global configs.
"""
# obtain abspath for the project
# You need specified it if it is running in the container.
if "root_dir" not in config:
file_dir = os.path.dirname(os.path.abspath(__file__))
config["root_dir"] = os.path.abspath(os.path.join(file_dir, ".."))
# load config file from json
with open(config["config_file"]) as config_params:
print("loading config file", config["config_file"])
json_config = json.load(config_params)
# update global parameters with these parameters received from the command line .
json_config.update(config)
config = json_config
# construct unique model run id, which consist of model name, config id and a timestamp
timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
random_str = "".join([random.choice(string.ascii_lowercase) for n in range(6)])
config["model_run_id"] = (
config["model"]
+ "_"
+ config["config_id"]
+ "_"
+ timestamp_str
+ "_"
+ random_str
)
set_seed(config["seed"] if "seed" in config else 2020)
initialize_folders(config["root_dir"])
# Initialize log file
config["log_file"] = os.path.join(
config["root_dir"], config["log_dir"], config["model_run_id"]
)
logger.init_std_logger(config["log_file"])
print("python version:", sys.version)
print("pytorch version:", torch.__version__)
# File paths to be saved
config["run_dir"] = os.path.join(
config["root_dir"], config["run_dir"], config["model_run_id"]
)
print(
"The intermediate running statuses will be reported in folder:",
config["run_dir"],
)
# Model checkpoints paths to be saved
config["model_save_dir"] = os.path.join(
config["root_dir"], config["checkpoint_dir"], config["model_run_id"]
)
ensureDir(config["model_save_dir"])
print("Model checkpoint will save in file:", config["model_save_dir"])
config["result_file"] = os.path.join(
config["root_dir"], config["result_dir"], config["result_file"]
)
print("Performance result will save in file:", config["result_file"])
# remove comments
print_dict_as_table(config, "Model configs")
return config
