def load_data_dict_zip(splitted_data_path, file_name_prefix):
UCM_DICT = {}
ICM_DICT = {}
dataIO = DataIO(folder_path=splitted_data_path)
URM_DICT = dataIO.load_data(file_name=file_name_prefix + "URM_dict")
if URM_DICT["__UCM_available"]:
UCM_DICT = dataIO.load_data(file_name=file_name_prefix + "UCM_dict")
del URM_DICT["__UCM_available"]
if URM_DICT["__ICM_available"]:
ICM_DICT = dataIO.load_data(file_name=file_name_prefix + "ICM_dict")
del URM_DICT["__ICM_available"]
loaded_data_dict = {
"URM_DICT": URM_DICT,
"UCM_DICT": UCM_DICT,
"ICM_DICT": ICM_DICT,
}
return loaded_data_dict
def load_data(self, save_folder_path):
dataIO = DataIO(folder_path = save_folder_path)
global_attributes_dict = dataIO.load_data(file_name = "dataset_global_attributes")
for attrib_name, attrib_object in global_attributes_dict.items():
self.__setattr__(attrib_name, attrib_object)
self.URM_train_av = dataIO.load_data(file_name = "dataset_URM_train")
self.URM_validation_av = dataIO.load_data(file_name = "dataset_URM_validation")
self.URM_test_av = dataIO.load_data(file_name = "dataset_URM_test")
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path +
file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
self.__setattr__(attrib_name, data_dict[attrib_name])
tf.reset_default_graph()
self.vae = MultiVAE(self.p_dims, lam=0.0)
self.saver, self.logits_var, self.loss_var, self.train_op_var, self.merged_var = self.vae.build_graph(
)
self.sess = tf.Session()
self.sess.run(tf.global_variables_initializer())
self.saver.restore(self.sess, folder_path + file_name + "_session")
self.summary_writer = tf.summary.FileWriter(
self.log_dir, graph=tf.get_default_graph())
self._print("Loading complete")
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path +
file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
if attrib_name == "W_sparse_Cold_P3Alpha":
self.Recommender_cold.RP3beta.W_sparse = data_dict[attrib_name]
elif attrib_name == "W_sparse_Cold_itemKNNCBF":
self.Recommender_cold.itemKNNCBF.W_sparse = data_dict[
attrib_name]
elif attrib_name == "alpha_Cold":
self.Recommender_cold.alpha = data_dict[attrib_name]
elif attrib_name == "norm_scores_Cold":
self.Recommender_cold.norm_scores = data_dict[attrib_name]
elif attrib_name == "W_sparse_Warm_P3Alpha":
self.Recommender_warm.RP3beta.W_sparse = data_dict[attrib_name]
elif attrib_name == "W_sparse_Warm_itemKNNCBF":
self.Recommender_warm.itemKNNCBF.W_sparse = data_dict[
attrib_name]
elif attrib_name == "alpha_Warm":
self.Recommender_warm.alpha = data_dict[attrib_name]
elif attrib_name == "norm_scores_Warm":
self.Recommender_warm.norm_scores = data_dict[attrib_name]
elif attrib_name == "threshold":
self.threshold = data_dict[attrib_name]
self._print("Loading complete")
def _get_algorithm_metadata_to_print_list(result_folder_path,
algorithm_list,
KNN_similarity_list=None,
ICM_names_list=None,
UCM_names_list=None):
dataIO = DataIO(folder_path=result_folder_path)
algorithm_file_name_list = _get_algorithm_file_name_list(
algorithm_list=algorithm_list,
KNN_similarity_list=KNN_similarity_list,
ICM_names_list=ICM_names_list,
UCM_names_list=UCM_names_list)
algorithm_metadata_to_print_list = []
for algorithm_file_dict in algorithm_file_name_list:
if algorithm_file_dict is None:
algorithm_metadata_to_print_list.append(None)
continue
algorithm_file_name = algorithm_file_dict["algorithm_file_name"]
search_metadata = None
if algorithm_file_name is not None:
try:
search_metadata = dataIO.load_data(
f"{algorithm_file_name}_metadata")
except FileNotFoundError:
pass
algorithm_file_dict["search_metadata"] = search_metadata
algorithm_metadata_to_print_list.append(algorithm_file_dict)
return algorithm_metadata_to_print_list
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path +
file_name))
# Reload the attributes dictionary
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
self.__setattr__(attrib_name, data_dict[attrib_name])
self.model = get_model(self.n_users, self.n_items, self.num_factors,
[e * self.k for e in self.layers],
self.reg_layers, self.reg_mf)
if self.learner.lower() == "adagrad":
self.model.compile(optimizer=Adagrad(lr=self.learning_rate),
loss="binary_crossentropy")
elif self.learner.lower() == "rmsprop":
self.model.compile(optimizer=RMSprop(lr=self.learning_rate),
loss="binary_crossentropy")
elif self.learner.lower() == "adam":
self.model.compile(optimizer=Adam(lr=self.learning_rate),
loss="binary_crossentropy")
else:
self.model.compile(optimizer=SGD(lr=self.learning_rate),
loss="binary_crossentropy")
self.model.load_weights(folder_path + file_name + "_weights")
self._print("Loading complete")
def load_model(self, folder_path, file_name = None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path + file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
self.__setattr__(attrib_name, data_dict[attrib_name])
self._init_model()
self.model = get_model(self.n_users, self.n_items, self.path_nums, self.timestamps, self.length, self.layers, self.reg_layes, self.latent_dim, self.reg_latent)
self.model.compile(optimizer = Adam(lr = self.learning_rate, decay = 1e-4),
loss = 'binary_crossentropy')
self.model.load_weights(folder_path + file_name + "_weights")
self._print("Loading complete")
def get_parameter_values_for_algorithm(algorithm_file_name):
experiment_subfolder_to_parameters_dict = {}
parameters_list = None
for experiment_subfolder in experiment_subfolder_list:
try:
dataIO = DataIO(folder_path=result_folder_path +
algorithm_name + "_" + experiment_subfolder +
"/")
search_metadata = dataIO.load_data(algorithm_file_name +
"_metadata")
search_metadata = search_metadata["hyperparameters_best"]
if parameters_list is None:
parameters_list = list(search_metadata.keys())
else:
assert set(parameters_list) == set(search_metadata.keys(
)), "n_parameters {}, len(parameters_dict) {}".format(
parameters_list, list(search_metadata.keys()))
except:
search_metadata = None
experiment_subfolder_to_parameters_dict[
experiment_subfolder] = search_metadata
return experiment_subfolder_to_parameters_dict, parameters_list
def load_data(self, save_folder_path):
dataIO = DataIO(folder_path=save_folder_path)
global_attributes_dict = dataIO.load_data(
file_name="dataset_global_attributes")
for attrib_name, attrib_object in global_attributes_dict.items():
self.__setattr__(attrib_name, attrib_object)
self.AVAILABLE_URM = dataIO.load_data(file_name="dataset_URM")
if self._HAS_ICM > 0:
self.AVAILABLE_ICM = dataIO.load_data(file_name="dataset_ICM")
self.AVAILABLE_ICM_feature_mapper = dataIO.load_data(
file_name="dataset_ICM_mappers")
if self._HAS_UCM > 0:
self.AVAILABLE_UCM = dataIO.load_data(file_name="dataset_UCM")
self.AVAILABLE_UCM_feature_mapper = dataIO.load_data(
file_name="dataset_UCM_mappers")
if self._HAS_additional_mapper:
self.dataset_additional_mappers = dataIO.load_data(
file_name="dataset_additional_mappers")
def _load_from_saved_sparse_matrix(self, save_folder_path):
"""
Loads all URM and ICM
:return:
"""
dataIO = DataIO(folder_path=save_folder_path)
self._LOADED_GLOBAL_MAPPER_DICT = dataIO.load_data(
file_name="dataset_global_mappers")
self._LOADED_URM_DICT = dataIO.load_data(file_name="dataset_URM")
if len(self.get_loaded_ICM_names()) > 0:
self._LOADED_ICM_DICT = dataIO.load_data(file_name="dataset_ICM")
self._LOADED_ICM_MAPPER_DICT = dataIO.load_data(
file_name="dataset_ICM_mappers")
def _init_factors_saved(self):
dataIO = DataIO(
folder_path="SavedModels\\IALS_num_factors=2400_alpha=25\\")
data_dict = dataIO.load_data(file_name="Jan14_13-52-40")
for attrib_name in data_dict.keys():
if attrib_name == "USER_factors":
self.USER_factors = data_dict[attrib_name]
elif attrib_name == "ITEM_factors":
self.ITEM_factors = data_dict[attrib_name]
self._print("Loading complete")
def _load_previously_built_split_and_attributes(self, save_folder_path):
"""
Loads all URM and ICM
:return:
"""
if self.use_validation_set:
validation_set_suffix = "use_validation_set"
else:
validation_set_suffix = "no_validation_set"
if self.allow_cold_users:
allow_cold_users_suffix = "allow_cold_users"
else:
allow_cold_users_suffix = "only_warm_users"
name_suffix = "_{}_{}".format(allow_cold_users_suffix,
validation_set_suffix)
dataIO = DataIO(folder_path=save_folder_path)
split_parameters_dict = dataIO.load_data(file_name="split_parameters" +
name_suffix)
for attrib_name in split_parameters_dict.keys():
self.__setattr__(attrib_name, split_parameters_dict[attrib_name])
self.SPLIT_GLOBAL_MAPPER_DICT = dataIO.load_data(
file_name="split_mappers" + name_suffix)
self.SPLIT_URM_DICT = dataIO.load_data(file_name="split_URM" +
name_suffix)
if len(self.dataReader_object.get_loaded_ICM_names()) > 0:
self.SPLIT_ICM_DICT = dataIO.load_data(file_name="split_ICM" +
name_suffix)
self.SPLIT_ICM_MAPPER_DICT = dataIO.load_data(
file_name="split_ICM_mappers" + name_suffix)
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path + file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
self.__setattr__(attrib_name, data_dict[attrib_name])
self._print("Loading complete")
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path +
file_name))
# Reload the attributes dictionary
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
self.__setattr__(attrib_name, data_dict[attrib_name])
# score_model = nn_scoremodel((embed_len,), embed_len, score_act=None)
score_model = inner_prod_scoremodel((self.embed_len, ),
score_rep_norm=False)
# score_model = fm_scoremodel((embed_len,), score_rep_norm=False, score_act=None)
loss = max_margin_loss
self.model = NetworkRS(self.n_users,
self.n_items,
self.embed_len,
score_model,
self.topK,
self.topK,
embed_regularizer=l2(5e-7),
directed=self.directed,
mem_filt_alpha=self.fliter_theta,
mem_agg_alpha=self.aggre_theta,
user_mask=None)
self.model.first_model.load_weights(folder_path + file_name +
"_first_model_weights")
self.model.second_model.load_weights(folder_path + file_name +
"_second_model_weights")
self.model.triplet_model.load_weights(folder_path + file_name +
"_triplet_model_weights")
self.model.triplet_model.compile(loss=loss, optimizer='adam')
self.batchGenerator = TripletGenerator(self.G_user, self.model,
self.G_ui, self.G_item)
self.item_rep = self.get_item_rep()
self.user_rep = self.get_user_rep()
self._print("Loading complete")
def run_train_with_early_stopping(dataset_name, URM_train, URM_validation,
UCM_CoupledCF, ICM_CoupledCF,
evaluator_validation, evaluator_test,
metric_to_optimize, result_folder_path,
map_mode):
if not os.path.exists(result_folder_path):
os.makedirs(result_folder_path)
article_hyperparameters = get_hyperparameters_for_dataset(dataset_name)
article_hyperparameters["map_mode"] = map_mode
earlystopping_hyperparameters = {
"validation_every_n": 5,
"stop_on_validation": True,
"lower_validations_allowed": 5,
"evaluator_object": evaluator_validation,
"validation_metric": metric_to_optimize
}
parameterSearch = SearchSingleCase(
CoupledCF_RecommenderWrapper,
evaluator_validation=evaluator_validation,
evaluator_test=evaluator_test)
recommender_input_args = SearchInputRecommenderArgs(
CONSTRUCTOR_POSITIONAL_ARGS=[URM_train, UCM_CoupledCF, ICM_CoupledCF],
FIT_KEYWORD_ARGS=earlystopping_hyperparameters)
recommender_input_args_last_test = recommender_input_args.copy()
recommender_input_args_last_test.CONSTRUCTOR_POSITIONAL_ARGS[
0] = URM_train + URM_validation
parameterSearch.search(
recommender_input_args,
recommender_input_args_last_test=recommender_input_args_last_test,
fit_hyperparameters_values=article_hyperparameters,
output_folder_path=result_folder_path,
output_file_name_root=CoupledCF_RecommenderWrapper.RECOMMENDER_NAME,
save_model="last",
resume_from_saved=True,
evaluate_on_test="last")
dataIO = DataIO(result_folder_path)
search_metadata = dataIO.load_data(
file_name=CoupledCF_RecommenderWrapper.RECOMMENDER_NAME +
"_metadata.zip")
return search_metadata
def run_evaluation_ablation(recommender_class, recommender_input_args,
evaluator_test, input_folder_path,
result_folder_path, map_mode):
recommender_object = recommender_class(
*recommender_input_args.CONSTRUCTOR_POSITIONAL_ARGS)
file_name_input = recommender_object.RECOMMENDER_NAME + "_best_model_last"
file_name_output = recommender_object.RECOMMENDER_NAME
if os.path.exists(result_folder_path + file_name_output + "_metadata.zip"):
return
result_folder_path_temp = result_folder_path + "__temp_model/"
# If directory does not exist, create
if not os.path.exists(result_folder_path_temp):
os.makedirs(result_folder_path_temp)
recommender_object.load_model(input_folder_path, file_name_input)
recommender_object.save_model(result_folder_path_temp, file_name_output)
# Alter saved object to force in the desired map mode
dataIO = DataIO(folder_path=result_folder_path_temp)
data_dict = dataIO.load_data(file_name=file_name_output)
data_dict["map_mode"] = map_mode
dataIO.save_data(file_name=file_name_output, data_dict_to_save=data_dict)
recommender_object = recommender_class(
*recommender_input_args.CONSTRUCTOR_POSITIONAL_ARGS)
recommender_object.load_model(result_folder_path_temp,
file_name=file_name_output)
results_dict, results_run_string = evaluator_test.evaluateRecommender(
recommender_object)
shutil.rmtree(result_folder_path_temp, ignore_errors=True)
result_file = open(result_folder_path + file_name_output + ".txt", "w")
result_file.write(results_run_string)
result_file.close()
results_dict = {"result_on_last": results_dict}
dataIO = DataIO(folder_path=result_folder_path)
dataIO.save_data(file_name=file_name_output + "_metadata",
data_dict_to_save=results_dict)
def run_permutation_pretrained_FM(URM_train_full, CFM_data_class_full, pretrained_model_folder_path, result_folder_path, permutation_index, permutation):
result_folder_path_permutation = result_folder_path + "{}/{}_{}/".format("FM", "FM", permutation_index)
# Read the pretraining data and put the permutation in it
recommender_object = FM_Wrapper(URM_train_full, CFM_data_class_full)
file_name_input = recommender_object.RECOMMENDER_NAME + "_best_model_last"
file_name_output = recommender_object.RECOMMENDER_NAME
if os.path.exists(result_folder_path_permutation + file_name_output + "_metadata.zip"):
return
result_folder_path_temp = result_folder_path_permutation + "__temp_model/"
# If directory does not exist, create
if not os.path.exists(result_folder_path_temp):
os.makedirs(result_folder_path_temp)
recommender_object.load_model(pretrained_model_folder_path, file_name_input)
recommender_object.save_model(result_folder_path_temp, file_name_output)
# Alter saved object to force in the desired permutation
dataIO = DataIO(folder_path = result_folder_path_temp)
data_dict = dataIO.load_data(file_name = file_name_output)
data_dict["permutation"] = permutation
dataIO.save_data(file_name = file_name_output, data_dict_to_save = data_dict)
recommender_object = FM_Wrapper(URM_train_full, CFM_data_class_full)
recommender_object.load_model(result_folder_path_temp,
file_name=file_name_output)
results_dict, results_run_string = evaluator_test.evaluateRecommender(recommender_object)
shutil.rmtree(result_folder_path_temp, ignore_errors=True)
result_file = open(result_folder_path_permutation + file_name_output + ".txt", "w")
result_file.write(results_run_string)
result_file.close()
results_dict = {"result_on_last": results_dict}
dataIO = DataIO(folder_path = result_folder_path_permutation)
dataIO.save_data(file_name = file_name_output + "_metadata",
data_dict_to_save = results_dict)
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path +
file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
self.args = ArgsInterface()
for attrib_name in data_dict.keys():
#
# if attrib_name == "global_var":
# MF_BPR._K, MF_BPR._feed_dict,\
# MF_BPR._output, MF_BPR._user_exclude_validation = data_dict[attrib_name]
if attrib_name.startswith("_args_"):
data_dict_key = attrib_name
attrib_name = attrib_name[len("_args_"):]
setattr(self.args, attrib_name, data_dict[data_dict_key])
else:
self.__setattr__(attrib_name, data_dict[attrib_name])
self.dataset = DatasetInterface(URM_train=self.URM_train)
MF_BPR.tf.reset_default_graph()
# saver = MF_BPR.tf.train.Saver()
self.sess = MF_BPR.tf.Session()
# saver.restore(self.sess, folder_path + file_name + "_session")
MF_BPR._sess = self.sess
# initialize models
self.model_GMF = MF_BPR.GMF(self.dataset.num_users,
self.dataset.num_items, self.args)
self.model_GMF.build_graph()
self.model_GMF.load_parameter_MF(
self.sess, folder_path + file_name + "_latent_factors.npy")
self._print("Loading complete")
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path +
file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
self.args = ArgsInterface()
for attrib_name in data_dict.keys():
if attrib_name.startswith("_args_"):
data_dict_key = attrib_name
attrib_name = attrib_name[len("_args_"):]
setattr(self.args, attrib_name, data_dict[data_dict_key])
else:
self.__setattr__(attrib_name, data_dict[attrib_name])
self.dataset = DatasetInterface(URM_train=self.URM_train)
ConvNCF.tf.reset_default_graph()
self.sess = ConvNCF.tf.Session()
ConvNCF.TRAIN_KEEP_PROB = self.args.keep
self.model = ConvNCF.ConvNCF(self.dataset.num_users,
self.dataset.num_items,
self.args,
map_mode=self.map_mode)
self.model.build_graph()
ConvNCF.initialize(self.model, self.dataset, self.args)
ConvNCF._model = self.model
saver = ConvNCF.tf.train.Saver()
self.sess = ConvNCF.tf.Session()
saver.restore(self.sess, folder_path + file_name + "_session")
ConvNCF._sess = self.sess
self._print("Loading complete")
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path +
file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
self.__setattr__(attrib_name, data_dict[attrib_name])
tf.reset_default_graph()
self.train_arr = self.train.toarray()
self.input_user = tf.placeholder(tf.int32, [None, 1])
self.input_item = tf.placeholder(tf.int32, [None, 1])
self.output = tf.placeholder(tf.float32, [None, 1])
self.rating_matrix = tf.placeholder(tf.float32,
shape=(self.num_users,
self.num_items))
user_input, item_input, labels = get_train_instances(
self.train, self.num_negatives)
self.batch_len = len(user_input) // self.batch_size
NMFs = {"EF": NMF_attention_EF, 'MLP': NMF_attention_MLP}
NMF = NMFs[self.model_type]
self.model = NMF.Model(self.input_user, self.input_item, self.output,
self.num_users, self.num_items,
self.rating_matrix, self.layers, self.batch_len)
gpu_options = tf.GPUOptions(allow_growth=True)
self.sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
self.sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(self.sess, folder_path + file_name + "_session")
self._print("Loading complete")
def load_model(self, folder_path, file_name = None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path + file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
self.__setattr__(attrib_name, data_dict[attrib_name])
self.model = NeuCF_get_model(self.n_users, self.n_items, self.mf_dim, self.layers, self.reg_layers, self.reg_mf)
self.model.load_weights(folder_path + file_name + "_weights")
self._print("Loading complete")
def load_model(self, folder_path, file_name = None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path + file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
if attrib_name == "W_sparse_itemKNNCF":
self.itemKNNCF.W_sparse = data_dict[attrib_name]
elif attrib_name == "W_sparse_itemKNNCBF":
self.itemKNNCBF.W_sparse = data_dict[attrib_name]
elif attrib_name == "alpha":
self.alpha = data_dict[attrib_name]
elif attrib_name == "norm_scores":
self.norm_scores = data_dict[attrib_name]
self._print("Loading complete")
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
print("Loading model from file '{}'".format(folder_path + file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
# initialize the model
self.fm = FM(self.data, self.user_field_M, self.item_field_M,
data_dict['pretrain_flag'], None,
data_dict['hidden_factor'], data_dict['loss_type'],
data_dict['epoch'], data_dict['batch_size'],
data_dict['learning_rate'], data_dict['lamda_bilinear'],
data_dict['keep'], data_dict['optimizer_type'],
data_dict['batch_norm'], data_dict['verbose'],
data_dict['permutation'], data_dict['random_seed'])
# reload weights
self.fm.saver.restore(self.fm.sess, folder_path + file_name)
self._print("Loading complete")
def load_model(self, folder_path, file_name = None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path + file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
self.__setattr__(attrib_name, data_dict[attrib_name])
tf.reset_default_graph()
self.data_generator = Data(self.URM_train, batch_size=self.batch_size)
self.model = SpectralCF(K=self.k,
graph = self.URM_train.toarray(),
n_users = self.n_users,
n_items = self.n_items,
emb_dim = self.embedding_size,
lr = self.learning_rate,
decay = self.decay,
batch_size = self.batch_size)
self.model.compute_eigenvalues()
self.model.build_graph()
saver = tf.train.Saver()
self.sess = tf.Session()
saver.restore(self.sess, folder_path + file_name + "_session")
self._print("Loading complete")
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path +
file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
self.__setattr__(attrib_name, data_dict[attrib_name])
print("{}: Loading keras model".format(self.RECOMMENDER_NAME))
self.init_model()
# self.model = models.load_model(folder_path + file_name + "_keras_model.h5")
self.model.load_weights(folder_path + file_name + "_keras_model.h5",
by_name=True)
self._print("Loading complete")
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path +
file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
if attrib_name == "cmn_config_dict":
self.cmn_config = CMN_Config(**data_dict[attrib_name])
self.cmn_config_clone = self.cmn_config.get_deepcopy()
self.__setattr__(attrib_name, data_dict[attrib_name])
tf.reset_default_graph()
self.model = CollaborativeMemoryNetwork(self.cmn_config)
self.sv = tf.train.Supervisor(logdir=None,
save_model_secs=60 * 10,
save_summaries_secs=0)
self.sess = self.sv.prepare_or_wait_for_session(config=tf.ConfigProto(
gpu_options=tf.GPUOptions(allow_growth=True)))
self.sess.graph._unsafe_unfinalize()
saver = tf.train.Saver()
saver.restore(self.sess, folder_path + file_name + "_session")
self._print("Loading complete")
def load_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Loading model from file '{}'".format(folder_path +
file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
for attrib_name in data_dict.keys():
if attrib_name == "W_sparse_P3Alpha":
self.P3alpha.W_sparse = data_dict[attrib_name]
elif attrib_name == "Item_Factors_svd":
self.svd.ITEM_factors = data_dict[attrib_name]
elif attrib_name == "User_Factors_svd":
self.svd.USER_factors = data_dict[attrib_name]
elif attrib_name == "alpha":
self.alpha = data_dict[attrib_name]
elif attrib_name == "norm_scores":
self.norm_scores = data_dict[attrib_name]
self._print("Loading complete")
def load_model(self, folder_path, file_name=None, force_map_mode=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
print("Loading model from file '{}'".format(folder_path + file_name))
dataIO = DataIO(folder_path=folder_path)
data_dict = dataIO.load_data(file_name=file_name)
# initialize the model
self.cfm = CFM(
data=self.data,
user_field_M=self.user_field_M,
item_field_M=self.item_field_M,
pretrain_flag=data_dict['pretrain_flag'],
pretrained_FM_folder_path=data_dict['pretrained_FM_folder_path'],
hidden_factor=data_dict['hidden_factor'],
num_field=data_dict['num_field'],
batch_size=data_dict['batch_size'],
learning_rate=data_dict['learning_rate'],
lamda_bilinear=data_dict['lamda_bilinear'],
keep=data_dict['keep'],
optimizer_type=data_dict['optimizer_type'],
batch_norm=data_dict['batch_norm'],
verbose=data_dict['verbose'],
regs=data_dict['regs'],
attention_size=data_dict['attention_size'],
attentive_pooling=data_dict['attentive_pooling'],
net_channel=data_dict['net_channel'],
map_mode=data_dict['map_mode']
if force_map_mode is None else force_map_mode,
permutation=data_dict['permutation'],
random_seed=data_dict['random_seed'])
# reload weights
self.cfm.saver.restore(self.cfm.sess, folder_path + file_name)
self._print("Loading complete")
def _load_previously_built_split_and_attributes(self, save_folder_path):
"""
Loads all URM and ICM
:return:
"""
self.__save_folder_path = save_folder_path
dataIO = DataIO(folder_path=save_folder_path)
split_parameters_dict = dataIO.load_data(file_name="split_parameters")
for attrib_name in split_parameters_dict.keys():
self.__setattr__(attrib_name, split_parameters_dict[attrib_name])
self.FOLD_DATA_SPLITTER_LIST = [None] * self.n_folds
for fold_index in range(self.n_folds):
dataSplitter_object = self._load_previously_built_split_and_attributes_fold(
save_folder_path, fold_index)
if self.preload_all:
self.FOLD_DATA_SPLITTER_LIST[fold_index] = dataSplitter_object
pool = multiprocessing.Pool(processes=3, maxtasksperchild=1)
pool.map(hyperparameter_search_collaborative_partial, collaborative_algorithm_list)
pool.close()
pool.join()
n_test_users = np.sum(np.ediff1d(URM_test.indptr)>=1)
file_name = "{}..//{}_{}_".format(result_baselines_folder_path, ALGORITHM_NAME, input_flags.dataset_name)
KNN_similarity_to_report_list = ["cosine", "dice", "jaccard", "asymmetric", "tversky"]
# Put results for the CNN algorithm in the baseline folder for it to be subsequently loaded
dataIO = DataIO(folder_path = output_folder_path + "fit_ablation_all_map/all_map_0/" )
search_metadata = dataIO.load_data(CoupledCF_RecommenderWrapper.RECOMMENDER_NAME + "_metadata")
dataIO = DataIO(folder_path = result_baselines_folder_path)
dataIO.save_data(CoupledCF_RecommenderWrapper.RECOMMENDER_NAME + "_metadata", search_metadata)
result_loader = ResultFolderLoader(result_baselines_folder_path,
base_algorithm_list = None,
other_algorithm_list = [CoupledCF_RecommenderWrapper],
KNN_similarity_list = KNN_similarity_to_report_list,
ICM_names_list = None,
UCM_names_list = None)
result_loader.generate_latex_results(file_name + "{}_latex_results.txt".format("article_metrics"),
metrics_list = ["HIT_RATE", "NDCG"],
cutoffs_list = [1, 5, 10],
