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],