def get_data(): df = pd.read_csv('./data/ml-100k/u.data', sep='\t', names=['user', 'item', 'rating', 'timestamp']) df, idx_to_user = reindex_col(df, 'user') df, idx_to_item = reindex_col(df, 'item') test_df = df.groupby( ["user"], as_index=False, group_keys=False).apply(lambda x: x.nlargest(1, ["timestamp"])) train_df = df[~df.index.isin(test_df.index.values)] train_rows = train_df.user.values train_cols = train_df.item.values train_data = np.ones_like(train_rows) train_sparse = csr_matrix((train_data, (train_rows, train_cols)), shape=(len(train_rows), len(train_cols))) # test_rows = test_df.user.values # test_cols = test_df.item.values # test_data = np.ones_like(test_rows) # test_sparse = csr_matrix((test_data, (test_rows, test_cols)), shape=(len(test_rows), len(test_cols))) train = Interactions(user_ids=train_df.user.values, item_ids=train_df.item.values) test = Interactions(user_ids=test_df.user.values, item_ids=test_df.item.values) return df, train, test, train_sparse # , test_sparse
def user_based_train_test_split(interactions, test_percentage=0.2, random_state=None): """ Split interactions between a train and a test set based on user ids, so that a given user's entire interaction history is either in the train, or the test set. Parameters ---------- interactions: :class:`spotlight.interactions.Interactions` The interactions to shuffle. test_percentage: float, optional The fraction of users to place in the test set. random_state: np.random.RandomState, optional The random state used for the shuffle. Returns ------- (train, test): (:class:`spotlight.interactions.Interactions`, :class:`spotlight.interactions.Interactions`) A tuple of (train data, test data) """ if random_state is None: random_state = np.random.RandomState() minint = np.iinfo(np.uint32).min maxint = np.iinfo(np.uint32).max seed = random_state.randint(minint, maxint, dtype=np.int64) in_test = ( (murmurhash3_32(interactions.user_ids, seed=seed, positive=True) % 100 / 100.0) < test_percentage) in_train = np.logical_not(in_test) train = Interactions(interactions.user_ids[in_train], interactions.item_ids[in_train], ratings=_index_or_none(interactions.ratings, in_train), timestamps=_index_or_none(interactions.timestamps, in_train), weights=_index_or_none(interactions.weights, in_train), num_users=interactions.num_users, num_items=interactions.num_items) test = Interactions(interactions.user_ids[in_test], interactions.item_ids[in_test], ratings=_index_or_none(interactions.ratings, in_test), timestamps=_index_or_none(interactions.timestamps, in_test), weights=_index_or_none(interactions.weights, in_test), num_users=interactions.num_users, num_items=interactions.num_items) return train, test
def timestamp_based_train_test_split(interactions, test_percentage=0.2): """ Split interactions between a train and a test set based on user ids, so that a given user's entire interaction history is either in the train, or the test set. Parameters ---------- interactions: :class:`spotlight.interactions.Interactions` The interactions to shuffle. test_percentage: float, optional The fraction of users to place in the test set. random_state: np.random.RandomState, optional The random state used for the shuffle. Returns ------- (train, test): (:class:`spotlight.interactions.Interactions`, :class:`spotlight.interactions.Interactions`) A tuple of (train data, test data) """ in_test = np.zeros(len(interactions.user_ids), dtype=int) user_ids, indices = np.unique(interactions.user_ids, return_index=True) for u in user_ids: start_idx = indices[u] end_idx = None if u == user_ids[-1] else indices[u + 1] user_timestamps = interactions.timestamps[start_idx:end_idx] time_threshold = np.floor(user_timestamps[-1] * (1 - test_percentage)) in_test[start_idx:end_idx][user_timestamps > time_threshold] = 1 in_test = in_test.astype(bool) in_train = np.logical_not(in_test) train = Interactions(interactions.user_ids[in_train], interactions.item_ids[in_train], ratings=_index_or_none(interactions.ratings, in_train), timestamps=_index_or_none(interactions.timestamps, in_train), weights=_index_or_none(interactions.weights, in_train), num_users=interactions.num_users, num_items=interactions.num_items) test = Interactions(interactions.user_ids[in_test], interactions.item_ids[in_test], ratings=_index_or_none(interactions.ratings, in_test), timestamps=_index_or_none(interactions.timestamps, in_test), weights=_index_or_none(interactions.weights, in_test), num_users=interactions.num_users, num_items=interactions.num_items) return train, test
def random_train_test_split(interactions, test_percentage=0.2, random_state=None): """ Randomly split interactions between training and testing. Parameters ---------- interactions: :class:`spotlight.interactions.Interactions` The interactions to shuffle. test_percentage: float, optional The fraction of interactions to place in the test set. random_state: np.random.RandomState, optional The random state used for the shuffle. Returns ------- (train, test): (:class:`spotlight.interactions.Interactions`, :class:`spotlight.interactions.Interactions`) A tuple of (train data, test data) """ interactions = shuffle_interactions(interactions, random_state=random_state) cutoff = int((1.0 - test_percentage) * len(interactions)) train_idx = slice(None, cutoff) test_idx = slice(cutoff, None) train = Interactions(interactions.user_ids[train_idx], interactions.item_ids[train_idx], ratings=_index_or_none(interactions.ratings, train_idx), timestamps=_index_or_none(interactions.timestamps, train_idx), weights=_index_or_none(interactions.weights, train_idx), num_users=interactions.num_users, num_items=interactions.num_items) test = Interactions(interactions.user_ids[test_idx], interactions.item_ids[test_idx], ratings=_index_or_none(interactions.ratings, test_idx), timestamps=_index_or_none(interactions.timestamps, test_idx), weights=_index_or_none(interactions.weights, test_idx), num_users=interactions.num_users, num_items=interactions.num_items) return train, test
def test_known_output_step_1(): interactions = Interactions(np.zeros(5), np.arange(5) + 1, timestamps=np.arange(5)) sequences = interactions.to_sequence(max_sequence_length=5, step_size=1).sequences expected = np.array([[1, 2, 3, 4, 5], [0, 1, 2, 3, 4], [0, 0, 1, 2, 3], [0, 0, 0, 1, 2], [0, 0, 0, 0, 1]]) assert np.all(sequences == expected)
def obtener_interacciones_gui(self, ruta_ratings, sep_ratings, encoding_ratings): """ Método obtener_interacciones_gui. Obtiene las interacciones necesarias para la creación de los modelos de Spotlight. Este método solo se utiliza en la interfaz web. Parameters ---------- ruta_ratings: str ruta del archivo que contiene las valoraciones. sep_ratings: str separador utilizado en el archivo de valoraiones. encoding_ratings: str encoding utilizado en el archivo de valoraciones. """ global train, test # Se obtiene el dataframe de valoraciones ratings_df = Entrada.leer_csv(ruta_ratings, sep_ratings, encoding_ratings) ratings_df.sort_values([ratings_df.columns.values[0], ratings_df.columns.values[1]], inplace=True) # Se obtienen arrays con los ids de los usuarios y de los ítems users_ids = np.asarray(ratings_df[ratings_df.columns.values[0]].tolist(), dtype=np.int32) items_ids = np.asarray(ratings_df[ratings_df.columns.values[1]].tolist(), dtype=np.int32) # Se transforma el dataframe de valoraciones en interacciones que puedan ser utilzadas por los modelos if self.opcion_time == 1: timestamps = np.asarray(ratings_df[ratings_df.columns.values[3]].tolist(), dtype=np.int32) if self.opcion_modelo == 1: ratings = np.asarray(ratings_df[ratings_df.columns.values[2]].tolist(), dtype=np.float32) interacciones = Interactions(users_ids, items_ids, ratings=ratings, timestamps=timestamps) train, test = random_train_test_split(interacciones) else: interacciones = Interactions(users_ids, items_ids, timestamps=timestamps) train, test = random_train_test_split(interacciones) if self.opcion_modelo == 3: train = train.to_sequence() test = test.to_sequence() else: if self.opcion_modelo == 1: ratings = np.asarray(ratings_df[ratings_df.columns.values[2]].tolist(), dtype=np.float32) interacciones = Interactions(users_ids, items_ids, ratings=ratings) else: interacciones = Interactions(users_ids, items_ids) train, test = random_train_test_split(interacciones) # Se guardan las interacciones de entrenamiento y test print("Guarda las interacciones de train") guardar_datos_pickle(train, 'las interacciones de entrenamiento') print("Guarda las interacciones de test") guardar_datos_pickle(test, 'las interacciones de test')
def time_based_train_test_split(interactions, test_percentage=0.2, test_drop_unknown=True): assert interactions.timestamps is not None cutoff = int((1.0 - test_percentage) * len(interactions)) indices = np.argsort(interactions.timestamps) train_idx = slice(None, cutoff) test_idx = slice(cutoff, None) train = Interactions(interactions.user_ids[indices][train_idx], interactions.item_ids[indices][train_idx], ratings=_index_or_none(interactions.ratings, train_idx, indices), timestamps=_index_or_none(interactions.timestamps, train_idx, indices), weights=_index_or_none(interactions.weights, train_idx, indices), num_users=interactions.num_users, num_items=interactions.num_items) unkown_item_ids = np.setdiff1d(interactions.item_ids[indices][test_idx], interactions.item_ids[indices][train_idx]) if test_drop_unknown: mask = np.empty(interactions.item_ids[indices][test_idx].shape[0], dtype=bool) i = 0 for x in np.nditer(interactions.item_ids[indices][test_idx]): mask[i] = not np.any(unkown_item_ids == x) i += 1 else: mask = np.ones(interactions.item_ids[indices][test_idx].shape[0], dtype=bool) test = Interactions(interactions.user_ids[indices][test_idx][mask], interactions.item_ids[indices][test_idx][mask], ratings=_index_or_none( _index_or_none(interactions.ratings, test_idx, indices), mask), timestamps=_index_or_none( _index_or_none(interactions.timestamps, test_idx, indices), mask), weights=_index_or_none( _index_or_none(interactions.weights, test_idx, indices), mask), num_users=interactions.num_users, num_items=interactions.num_items) return train, test
def test_known_output_step_2(): interactions = Interactions(np.zeros(5), np.arange(5) + 1, timestamps=np.arange(5)) sequences = interactions.to_sequence(max_sequence_length=5, step_size=2).sequences expected = np.array([ [1, 2, 3, 4, 5], [0, 0, 1, 2, 3], [0, 0, 0, 0, 1], ]) assert np.all(sequences == expected)
def get_movielens_dataset(variant='100K'): """ Download and return one of the Movielens datasets. Parameters ---------- variant: string, optional String specifying which of the Movielens datasets to download. One of ('100K', '1M', '10M', '20M'). Returns ------- Interactions: :class:`spotlight.interactions.Interactions` instance of the interactions class """ if variant not in VARIANTS: raise ValueError('Variant must be one of {}, ' 'got {}.'.format(VARIANTS, variant)) url = 'movielens_{}'.format(variant) return Interactions(*_get_movielens(url))
def shuffle_interactions(interactions, random_state=None): """ Shuffle interactions. Parameters ---------- interactions: :class:`spotlight.interactions.Interactions` The interactions to shuffle. random_state: np.random.RandomState, optional The random state used for the shuffle. Returns ------- interactions: :class:`spotlight.interactions.Interactions` The shuffled interactions. """ if random_state is None: random_state = np.random.RandomState() shuffle_indices = np.arange(len(interactions.user_ids)) random_state.shuffle(shuffle_indices) return Interactions(interactions.user_ids[shuffle_indices], interactions.item_ids[shuffle_indices], ratings=_index_or_none(interactions.ratings, shuffle_indices), timestamps=_index_or_none(interactions.timestamps, shuffle_indices), weights=_index_or_none(interactions.weights, shuffle_indices), num_users=interactions.num_users, num_items=interactions.num_items)
def build_interactions_object(self, df_interactions: pd.DataFrame, df_timestamps: pd.DataFrame, df_weights: pd.DataFrame) -> Interactions: """Builds a matrix of interactions between user and cashtag item. Takes as params a number of pandas.DataFrame which contains mappings between user-cashtag interactions, associated timestamps, normalised weights for interactions and builds a matrix for input to a Spotlight model. Args: df_interactions (pandas.DataFrame): User-Item interactions DataFrame consisting of user and item IDs. df_timestamps (pandas.DataFrame): Timestamps DataFrame consisting of timestamps associated with mappings in df_interactions. df_weights (pandas.DataFrame): Weights DataFrame consisting of weights associated with mappings in df_interactions, that is, the number of times a user has interacted with a particular item. Returns: spotlight.interactions.Interactions: Returns Spotlight interactions matrix. """ logger = logging.getLogger() user_ids = df_interactions['user_id'].values.astype(int) cashtag_ids = df_interactions['item_tag_ids'].values.astype(int) timestamps, weights = df_timestamps.values, np.array(df_weights['count'].values) normalise = lambda v: v / np.sqrt(np.sum(v**2)) normalised_weights = normalise(weights) # THIS IS NOT CORRECT, NORMALISES BY ALL INSTEAD OF BY ID interactions = Interactions( user_ids=user_ids, item_ids=cashtag_ids, timestamps=np.array([int(x[0]) for x in timestamps]), weights=normalised_weights ) logger.info("Build interactions object: {}".format(interactions)) return interactions
def get_test(myfile): """ returns testing set appropriate for spotlight.interactions.Interactions """ # return testing set as spotlight.interactions return Interactions(*test_load(myfile))
def get_train(myfile): """ returns training set appropriate for spotlight.interactions.Interactions """ # return training set as spotlight.interactions return Interactions(*train_load(myfile))
def individual_predictions(df, model): num_users = len(df['user_id'].unique()) num_items = len(df['item_id'].unique()) predictions = np.zeros(shape=(num_users, num_items + 1)) dataset = Interactions(user_ids=np.array(df['user_id'], dtype='int32'), item_ids=np.array(df['item_id'], dtype='int32'), timestamps=df['entry_at']) sequences = dataset.to_sequence(max_sequence_length=15) user_id = 0 for user, sequence in zip(sequences.user_ids, sequences.sequences): if user == user_id: predictions[user] = model.predict(sequence) user_id += 1 return predictions
def create_input_for_spotlight(user_id, movie_id, ratings): """ :param user_id: a list containing the id of users :param movie_id: a list containing the id of movies :param ratings: a list containing the corresponding ratings :return: Interaction Object (a useful object containing users, movies and ratings) """ return Interactions(user_id, movie_id, ratings)
def obtener_interacciones(self): """ Método obtener_interacciones. Obtiene las interacciones necesarias por los modelos de Spotlight. Este método solo se utiliza en la interfaz de texto. """ global train, test # Se obtiene el dataframe de valoraciones Entrada.obtener_datos() ratings_df = Entrada.ratings_df # Se obtienen arrays con los ids de los usuarios y de los ítems users_ids = np.asarray(ratings_df[ratings_df.columns.values[0]].tolist(), dtype=np.int32) items_ids = np.asarray(ratings_df[ratings_df.columns.values[1]].tolist(), dtype=np.int32) # Se transforma el dataframe de valoraciones en interacciones que puedan ser utilzadas por los modelos if self.opcion_time == 1: timestamps = np.asarray(ratings_df[ratings_df.columns.values[3]].tolist(), dtype=np.int32) if self.opcion_modelo == 1: ratings = np.asarray(ratings_df[ratings_df.columns.values[2]].tolist(), dtype=np.float32) interacciones = Interactions(users_ids, items_ids, ratings=ratings, timestamps=timestamps) train, test = random_train_test_split(interacciones) else: interacciones = Interactions(users_ids, items_ids, timestamps=timestamps) train, test = random_train_test_split(interacciones) if self.opcion_modelo == 3: train = train.to_sequence() test = test.to_sequence() else: if self.opcion_modelo == 1: ratings = np.asarray(ratings_df[ratings_df.columns.values[2]].tolist(), dtype=np.float32) interacciones = Interactions(users_ids, items_ids, ratings=ratings) else: interacciones = Interactions(users_ids, items_ids) train, test = random_train_test_split(interacciones) # Se guardan las interacciones de entrenamiento y test print("Guarda las interacciones de train") guardar_datos_pickle(train, 'las interacciones de entrenamiento') print("Guarda las interacciones de test") guardar_datos_pickle(test, 'las interacciones de test')
def build_interactions_object(self, df_interactions: pd.DataFrame, df_timestamps: pd.DataFrame) -> Interactions: user_ids = df_interactions['user_id'].values.astype(int) cashtag_ids = df_interactions['tag_id'].values.astype(int) timestamps, weights = df_timestamps.values, np.array(df_interactions['count'].values) interactions = Interactions( user_ids=user_ids, item_ids=cashtag_ids, timestamps=np.array([x for x in timestamps]) if self.filter is 'hybrid' else None, weights=weights ) return interactions
def spotlight_algo(train, test, model, verbose=True): # Explicitly convert into datatypes needed by spotlight models user_tr = np.array(train.User, dtype=np.int32) movie_tr = np.array(train.Movie, dtype=np.int32) rating_tr = np.array(train.Rating, dtype=np.float32) user_te = np.array(test.User, dtype=np.int32) movie_te = np.array(test.Movie, dtype=np.int32) train_data = Interactions(user_ids=user_tr, item_ids=movie_tr, ratings=rating_tr) test_data = Interactions(user_ids=user_te, item_ids=movie_te) model.fit(train_data, verbose=verbose) # predict predictions = model.predict(user_te, movie_te) predictions_df = pd.DataFrame() predictions_df['User'] = user_te predictions_df['Movie'] = movie_te predictions_df['Rating'] = predictions return predictions_df
def sparsify(interactions, drop_fraction, random_state=None): if random_state is None: random_state = np.random.RandomState() indices = random_state.rand(len(interactions)) > drop_fraction it = interactions return Interactions(it.user_ids[indices], it.item_ids[indices], timestamps=it.timestamps[indices], num_users=it.num_users, num_items=it.num_items)
def train(user_ids, item_ids, ratings, num_dimensions, verbose): dataset = Interactions(np.array(user_ids, dtype=np.int32), np.array(item_ids, dtype=np.int32), ratings=np.array(ratings, dtype=np.float32)) is_cuda_available = False if device.type == 'cpu' else True m = ExplicitFactorizationModel(loss='logistic', use_cuda=is_cuda_available, embedding_dim=num_dimensions) m.fit(dataset, verbose=verbose) user_embeddings = m._net.user_embeddings.weight.detach().cpu().numpy() return user_embeddings
def get_goodbooks_dataset(): """ Download and return the goodbooks-10K dataset [2]_. Returns ------- Interactions: :class:`spotlight.interactions.Interactions` instance of the interactions class References ---------- .. [2] https://github.com/zygmuntz/goodbooks-10k """ return Interactions(*_get_dataset())
def load_interactions(path): try: df = pd.read_csv(path) interactions = Interactions( user_ids=df['user_id'].astype(np.int32).values, item_ids=df['item_id'].astype(np.int32).values, timestamps=df['timestamp'].astype(np.int32).values, weights=df['weight'].astype(np.int32).values) reloaded_time = int(os.path.basename(path).split('.')[0]) user_indexer = Indexer(dumped_filepath=os.path.join( mrecsys.__dataset_path__, 'dicts/user_to_index/{}.json'.format( reloaded_time))) item_indexer = Indexer(dumped_filepath=os.path.join( mrecsys.__dataset_path__, 'dicts/item_to_index/{}.json'.format( reloaded_time))) return interactions, reloaded_time, user_indexer, item_indexer except: return None
def preprocess_rsc15(density_value = 1.0, limit_train = None, limit_test = None): """ Return index normalized sequences for train and test. density_value: randomly filter out events (0.0-1.0, 1:keep all) limit_train = limit_train #limit in number of rows or None limit_test = limit_test #limit in number of rows or None """ data_path = 'ludewig/data/rsc15/single/' file_prefix = 'rsc15-clicks' density_value = density_value if density_value else 1.0 remove_imdups = False train, test = loader.load_data(data_path, file_prefix, rows_train=limit_train, rows_test=limit_test, density=density_value) for dat in train, test: dat.columns = ['sessionId','itemId','time'] ind2val, val2ind = {}, {} for col in ['sessionId','itemId']: vals = np.unique(np.concatenate((train[col].values, test[col].values))) ind2val[col] = {idx+1 : id for idx, id in enumerate(vals)} val2ind[col] = {val : key for key, val in ind2val[col].items()} for df in [train, test]: df[col+"_idx"] = df[col].map(lambda x: val2ind[col][x]) #train = train.to_sequence() #test = test.to_sequence() dat = {'train' : train, 'test' : test} # Transform into sequence interaction object dat_seq = {} for name, df in dat.items(): dat_seq[name] = Interactions(user_ids=df.sessionId_idx.values, item_ids=df.itemId_idx.values, timestamps=df.time.values).to_sequence(max_sequence_length = 10) return dat, dat_seq , ind2val
def train_model(df, hyperparams): # Fix random_state seed = 42 set_seed(seed) random_state = np.random.RandomState(seed) max_sequence_length = 15 min_sequence_length = 2 step_size = 1 # create dataset using interactions dataframe and timestamps dataset = Interactions(user_ids=np.array(df['user_id'], dtype='int32'), item_ids=np.array(df['item_id'], dtype='int32'), timestamps=df['entry_at']) # create training and test sets using a 80/20 split train, test = user_based_train_test_split(dataset, test_percentage=0.2, random_state=random_state) # convert to sequences train = train.to_sequence(max_sequence_length=max_sequence_length, min_sequence_length=min_sequence_length, step_size=step_size) test = test.to_sequence(max_sequence_length=max_sequence_length, min_sequence_length=min_sequence_length, step_size=step_size) print('data: {}'.format(train)) # initialize and train model model = ImplicitSequenceModel(**hyperparams, use_cuda=CUDA, random_state=random_state) model.fit(train, verbose=True) # compute mrr score on test set test_mrr = sequence_mrr_score(model, test).mean() print('MRR score on test set: {}'.format(test_mrr)) return model
def _interactions_sequence_from_obs(self, obs, timestamp_col='first_timestamp', max_sequence_length=10, min_sequence_length=None, step_size=None, **kwargs): obs.timestamp_col = timestamp_col return Interactions( user_ids=self.sparse_mat_builder.uid_encoder. transform(obs.user_ids.astype(str)).astype('int32'), item_ids=self.sparse_mat_builder.iid_encoder. transform(obs.item_ids.astype(str)).astype('int32') + 1, ratings=obs.ratings, timestamps=obs.timestamps ). \ to_sequence( max_sequence_length=max_sequence_length, min_sequence_length=min_sequence_length, step_size=step_size )
'gender': 'Sender_gender', 'index': 'Sender_index' }, inplace=True) finder_decisions = finder_decisions.merge(users, how='left', left_on='Receiver_id', right_index=True) finder_decisions.rename(columns={ 'age': 'Receiver_age', 'gender': 'Receiver_gender', 'index': 'Receiver_index' }, inplace=True) ratings = np.ones(len(finder_decisions)) ratings[finder_decisions['Decision'] == 'skip'] = -1 ratings = ratings.astype(np.float32) dataset = Interactions(finder_decisions['Sender_index'].values, finder_decisions['Receiver_index'].values, ratings) from spotlight.cross_validation import random_train_test_split train, test = random_train_test_split(dataset, random_state=np.random.RandomState(42)) spotlight_model = torch.load('spotlight.model') predictions = spotlight_model.predict(test.user_ids, test.item_ids) print((predictions == test.ratings).sum() / len(predictions))
train_dataset = "./datas/data_train.csv" test_dataset = "./datas/sampleSubmission.csv" train = load_dataset(train_dataset) test = load_dataset(test_dataset) # Explicitly convert into datatypes needed by spotlight models user_tr = np.array(train.User, dtype=np.int32) movie_tr = np.array(train.Movie, dtype=np.int32) rating_tr = np.array(train.Rating, dtype=np.float32) user_te = np.array(train.User, dtype=np.int32) movie_te = np.array(train.Movie, dtype=np.int32) # Transform into Spotlight interactions train_data = Interactions(user_ids=user_tr, item_ids=movie_tr, ratings=rating_tr) test_data = Interactions(user_ids=user_tr, item_ids=movie_te) loss = ['regression', 'logistic', 'poisson'] n_iter = [50, 100, 200] batch_size = [256, 512, 1024, 2048, 4096] l2 = np.logspace(-10, -3, 8) learning_rate = np.logspace(-10, -3, 8) embedding_dim = [20, 50, 100, 150, 200] def best_params_spotlight(losses, n_iters, batch_sizes, l2s,
def spotlight_interactions_from_sparse(sp_mat): sp_mat = sp_mat.tocoo() return Interactions(user_ids=sp_mat.row, item_ids=sp_mat.col, ratings=sp_mat.data)
hit_ratio, ndcg = -1, -1 logging.info( '******** [Epoch {}] Embs NDCG {:.4f}, Hit Ratio: {:.4f}, NDCG: {:.4f}' .format(epoch_num, pairs_ndcg, hit_ratio, ndcg)) torch.save(net, model_store_dir + "/" + model_alias + "-" + str(epoch_num)) num_users = len(original_train_data["uindex"].unique()) num_items = len(original_train_data["vindex"].unique()) train_data = original_train_data.sample(frac=train_sample) interactions = Interactions( train_data["uindex"].to_numpy(), train_data["vindex"].to_numpy(), train_data["pct_cvt"].to_numpy(), train_data["latest_watch_time"].to_numpy(), num_users=len(original_train_data["uindex"].unique()), num_items=len(original_train_data["vindex"].unique())) if "-" in net_conf: args = net_conf.split("-") config = { "factor_size": int(args[0]), "num_layers": int(args[1]), "loss_type": args[2], "model_type": args[3], "num_users": num_users, "num_items": num_items, }
def interactions_to_sequence(f_train: Interactions, f_test: Interactions): train, test = f_train.to_sequence(), f_test.to_sequence() return train, test
target_pos_y = ui.pos().y() + ui.textbox.pos().y() mouse.position = (target_pos_x, target_pos_y) mouse.click(Button.left) mouse.position = mouse_pos_before def tray_icon_activated(reason): if reason == tray.Trigger: # tray.Trigger is left click show_ui() song_queue = SongQueue() image_queue = ImageQueue() # creates the interactions object interactions = Interactions(sp, token_info, sp_oauth, exit_app, song_queue) # UI ui = Ui(interactions, sp) # Create icon icon = QIcon(f"{ASSETS_DIR}img{sep}logo_small.png") # Create tray tray = QSystemTrayIcon() tray.setIcon(icon) tray.setVisible(True) tray.setToolTip("Spotlightify") # Create menu menu = QMenu()