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 save_model(self, folder_path, file_name=None): #https://cv-tricks.com/tensorflow-tutorial/save-restore-tensorflow-models-quick-complete-tutorial/ if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) saver = tf.train.Saver() saver.save(self.sess, folder_path + file_name + "_session") data_dict_to_save = { "n_users": self.n_users, "n_items": self.n_items, "batch_size": self.batch_size, "total_anneal_steps": self.total_anneal_steps, "anneal_cap": self.anneal_cap, "update_count": self.update_count, "p_dims": self.p_dims, "batches_per_epoch": self.batches_per_epoch, "log_dir": self.log_dir, "chkpt_dir": self.chkpt_dir, } dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save=data_dict_to_save) self._print("Saving complete")
def save_model(self, folder_path, file_name = None): if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) data_dict_to_save = {"k": self.k, "embedding_size": self.embedding_size, "learning_rate": self.learning_rate, "decay": self.decay, "batch_size": self.batch_size, # "model_lamda": self.model_lamda, # "model_U": self.model_U, } dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save = data_dict_to_save) saver = tf.train.Saver() saver.save(self.sess, folder_path + file_name + "_session") self._print("Saving 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 save_model(self, folder_path, file_name=None): if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) data_dict_to_save = { 'layers': self.layers, 'reg_layers': self.reg_layers, 'num_negatives': self.num_negatives, 'learner': self.learner, 'learning_rate': self.learning_rate, 'batch_size': self.batch_size, 'predictive_factors': self.predictive_factors, } dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save=data_dict_to_save) saver = tf.train.Saver() saver.save(self.sess, folder_path + file_name + "_session") self._print("Saving complete")
def _split_data_from_original_dataset(self, save_folder_path): # Perform k random splits. self.FOLD_DATA_SPLITTER_LIST = [None] * self.n_folds # If save_folder_path is None use default if save_folder_path is None and not save_folder_path == False: save_folder_path = self._get_default_save_path() for fold_index in range(self.n_folds): dataSplitter_object_fold = self._split_data_from_original_dataset_fold( save_folder_path, fold_index) if self.preload_all: self.FOLD_DATA_SPLITTER_LIST[ fold_index] = dataSplitter_object_fold if save_folder_path: split_parameters_dict = { "n_folds": self.n_folds, } dataIO = DataIO(folder_path=save_folder_path) dataIO.save_data(data_dict_to_save=split_parameters_dict, file_name="split_parameters") self._print("Split 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 save_model(self, folder_path, file_name=None): if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) data_dict_to_save = { "W_sparse_Cold_itemKNNCBF": self.Recommender_cold.itemKNNCBF.W_sparse, "norm_scores_Cold": self.Recommender_cold.norm_scores, "W_sparse_Cold_P3Alpha": self.Recommender_cold.RP3beta.W_sparse, "alpha_Cold": self.Recommender_cold.alpha, "W_sparse_Warm_itemKNNCBF": self.Recommender_warm.itemKNNCBF.W_sparse, "norm_scores_Warm": self.Recommender_warm.norm_scores, "W_sparse_Warm_P3Alpha": self.Recommender_warm.RP3beta.W_sparse, "alpha_Warm": self.Recommender_warm.alpha, "threshold": self.threshold } dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save=data_dict_to_save) self._print("Saving complete")
def save_model(self, folder_path, file_name = None): if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save = {}) self._print("Saving complete")
def save_model(self, folder_path, file_name=None): if file_name is None: file_name = self.RECOMMENDER_NAME print("Saving model in file '{}'".format(folder_path + file_name)) # save graph weights self.fm.save_session(folder_path + file_name) #Â save model params data_dict_to_save = { 'pretrain_flag': self.fm.pretrain_flag, 'hidden_factor': self.fm.hidden_factor, 'loss_type': 'log_loss', 'epoch': self.fm.epoch, 'batch_size': self.fm.batch_size, 'learning_rate': self.fm.learning_rate, 'lamda_bilinear': self.fm.lamda_bilinear, 'keep': self.fm.keep, 'optimizer_type': self.fm.optimizer_type, 'batch_norm': self.fm.batch_norm, 'permutation': self.fm.permutation, 'verbose': self.fm.verbose, 'random_seed': self.fm.random_seed, } dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save=data_dict_to_save) self._print("Saving complete")
def save_model(self, folder_path, file_name=None): if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) self.mf_recommender.save_model(folder_path, file_name=file_name + "_warm_users") data_dict_to_save = { "_cold_user_KNN_model_flag": self._cold_user_KNN_model_flag, "_cold_user_KNN_estimated_factors_flag": self._cold_user_KNN_estimated_factors_flag } if self._cold_user_KNN_model_flag: self._ItemKNNRecommender.save_model(folder_path, file_name=file_name + "_cold_users") dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save=data_dict_to_save) self._print("Saving complete")
def save_model(self, folder_path, file_name=None): if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) data_dict_to_save = { 'learning_rate': self.learning_rate, 'num_epochs': self.num_epochs, 'num_negatives': self.num_negatives, 'dataset_name': self.dataset_name, 'number_model': self.number_model, 'plot_model': self.plot_model, 'current_epoch': self.current_epoch, 'map_mode': self.map_mode, 'permutation': self.permutation, 'verbose': self.verbose, } dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save=data_dict_to_save) # # self.model.save(folder_path + file_name + "_keras_model.h5") self.model.save_weights(folder_path + file_name + "_keras_model.h5", overwrite=True) self._print("Saving 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 save_model(self, folder_path, file_name=None): #https://cv-tricks.com/tensorflow-tutorial/save-restore-tensorflow-models-quick-complete-tutorial/ if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) data_dict_to_save = { "n_users": self.n_users, "n_items": self.n_items, "cmn_config_dict": self.cmn_config_clone.get_dict() } dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save=data_dict_to_save) saver = tf.train.Saver() saver.save(self.sess, folder_path + file_name + "_session") self._print("Saving complete")
def save_model(self, folder_path, file_name = None): if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) self.model.save_weights(folder_path + file_name + "_weights", overwrite=True) data_dict_to_save = { "n_users": self.n_users, "n_items": self.n_items, "path_nums": self.path_nums, "timestamps": self.timestamps, "length": self.length, "layers": self.layers, "reg_layes": self.reg_layes, "latent_dim": self.latent_dim, "reg_latent": self.reg_latent, "learning_rate": self.learning_rate, } dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save = data_dict_to_save) self._print("Saving complete")
def save_model(self, folder_path, file_name=None): if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) self.model.save_weights(folder_path + file_name + "_weights", overwrite=True) data_dict_to_save = { "n_users": self.n_users, "n_items": self.n_items, "mf_dim": self.mf_dim, "layers": self.layers, "reg_layers": self.reg_layers, "reg_mf": self.reg_mf, } dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save=data_dict_to_save) self._print("Saving complete")
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 save_model(self, folder_path, file_name=None): if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) self.model.save_weights(folder_path + file_name + "_weights") data_dict_to_save = { "n_users": self.n_users, "n_items": self.n_items, "epochs": self.epochs, "batch_size": self.batch_size, "num_factors": self.num_factors, "layers": self.layers, "reg_mf": self.reg_mf, "reg_layers": self.reg_layers, "num_negatives": self.num_negatives, "learning_rate": self.learning_rate, "learner": self.learner, "k": self.k, } # Do not change this dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save=data_dict_to_save) self._print("Saving 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 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 _set_search_attributes( self, recommender_input_args, recommender_input_args_last_test, metric_to_optimize, output_folder_path, output_file_name_root, resume_from_saved, save_metadata, save_model, evaluate_on_test_each_best_solution, n_cases, ): if save_model not in self._SAVE_MODEL_VALUES: raise ValueError( "{}: parameter save_model must be in '{}', provided was '{}'.". format(self.ALGORITHM_NAME, self._SAVE_MODEL_VALUES, save_model)) self.output_folder_path = output_folder_path self.output_file_name_root = output_file_name_root # If directory does not exist, create if not os.path.exists(self.output_folder_path): os.makedirs(self.output_folder_path) self.log_file = open( self.output_folder_path + self.output_file_name_root + "_{}.txt".format(self.ALGORITHM_NAME), "a", ) if save_model == "last" and recommender_input_args_last_test is None: self._write_log( "{}: parameter save_model is 'last' but no recommender_input_args_last_test provided, saving best model on train data alone." .format(self.ALGORITHM_NAME)) save_model = "best" self.recommender_input_args = recommender_input_args self.recommender_input_args_last_test = recommender_input_args_last_test self.metric_to_optimize = metric_to_optimize self.save_model = save_model self.resume_from_saved = resume_from_saved self.save_metadata = save_metadata self.evaluate_on_test_each_best_solution = evaluate_on_test_each_best_solution self.model_counter = 0 self._init_metadata_dict(n_cases=n_cases) if self.save_metadata: self.dataIO = DataIO(folder_path=self.output_folder_path)
def saveModel(self, folder_path, file_name = None): if file_name is None: file_name = self.RECOMMENDER_NAME print("{}: Saving model in file '{}'".format(self.RECOMMENDER_NAME, folder_path + file_name)) data_dict_to_save = {"item_pop": self.item_pop} dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save = data_dict_to_save) print("{}: Saving complete".format(self.RECOMMENDER_NAME))
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 save_model(self, folder_path, file_name = None): if file_name is None: file_name = self.RECOMMENDER_NAME self._print("Saving model in file '{}'".format(folder_path + file_name)) data_dict_to_save = {"W_sparse_itemKNNCBF": self.itemKNNCBF.W_sparse, "norm_scores": self.norm_scores, "W_sparse_itemKNNCF": self.itemKNNCF.W_sparse, "alpha": self.alpha} dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save = data_dict_to_save) self._print("Saving 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 save_model(self, folder_path, file_name=None): if file_name is None: file_name = self.RECOMMENDER_NAME logger.info(f"Saving model in file '{folder_path + file_name}'") data_dict_to_save = {"item_pop": self.item_pop} dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save=data_dict_to_save) self._print("Saving 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._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_epoch(self, num_epoch): # fit user factors # VV = n_factors x n_factors VV = self.ITEM_factors.T.dot(self.ITEM_factors) for user_id in self.warm_users: # get (positive i.e. non-zero scored) items for user start_pos = self.C.indptr[user_id] end_pos = self.C.indptr[user_id + 1] user_profile = self.C.indices[start_pos:end_pos] user_confidence = self.C.data[start_pos:end_pos] self.USER_factors[user_id, :] = self._update_row( user_profile, user_confidence, self.ITEM_factors, VV) # fit item factors # UU = n_factors x n_factors UU = self.USER_factors.T.dot(self.USER_factors) for item_id in self.warm_items: start_pos = self.C_csc.indptr[item_id] end_pos = self.C_csc.indptr[item_id + 1] item_profile = self.C_csc.indices[start_pos:end_pos] item_confidence = self.C_csc.data[start_pos:end_pos] self.ITEM_factors[item_id, :] = self._update_row( item_profile, item_confidence, self.USER_factors, UU) folder_path = "SavedModels\\IALS_num_factors=2400_alpha=25\\" file_name = datetime.now().strftime('%b%d_%H-%M-%S') self._print("Saving model in file '{}'".format(folder_path + file_name)) data_dict_to_save = { "USER_factors": self.USER_factors, "ITEM_factors": self.ITEM_factors, } dataIO = DataIO(folder_path=folder_path) dataIO.save_data(file_name=file_name, data_dict_to_save=data_dict_to_save) self._print("Saving complete")