import heapq import json import os import time from typing import Any import click import numpy as np import polars as pl import scipy.sparse as sp import torch from sansa import SANSA, ICFGramianFactorizerConfig, SANSAConfig, UMRUnitLowerTriangleInverterConfig from tqdm import tqdm from yambda.constants import Constants from yambda.evaluation import metrics, ranking from yambda.processing import timesplit RANDOM_SEED = 42 @click.command() @click.option( '--data_dir', required=True, type=str, default="../../data/flat", show_default=True, help="Expects flat data" ) @click.option( '--size', required=True, type=click.Choice(['50m', '500m']), default="50m", multiple=False, show_default=True, ) @click.option( '--interaction', required=True, type=click.Choice(['likes', 'listens']), default="likes", multiple=False, show_default=True, ) @click.option('--report_metrics', required=True, type=str, default=Constants.METRICS, multiple=True, show_default=True) @click.option('--device', required=True, type=str, default="cuda:0", show_default=True) def main( data_dir: str, size: str, interaction: str, report_metrics: list[str], device: str, ): print(f"REPORT METRICS: {report_metrics}") print(f"SIZE {size}, INTERACTION {interaction}") result = train_sansa_model( data_dir, size=size, dataset_type=interaction, device=device, report_metrics=report_metrics, ) print(json.dumps(result, indent=2)) def train_sansa_model( data_path: str, size: str, dataset_type: str, device: str, report_metrics: list[str], ) -> dict[str, Any]: np.random.seed(RANDOM_SEED) curr_time = time.time() print() print(curr_time) print(f"Size: {size}, Dataset: {dataset_type}") df, grouped_test, train, test = get_train_val_test_matrices( data_path=data_path, size=size, dataset_type=dataset_type, ) data_finished = time.time() print(f"Data is loaded in {data_finished - curr_time} seconds") model = get_sansa_model() model.fit(train) train_finished = time.time() print(f"Model is trained in {train_finished - data_finished}") print(model) if report_metrics: calculated_metrics = evaluate_sansa( df=df, model=model, device=device, report_metrics=report_metrics, grouped_test=grouped_test, sparse_train=train, sparse_test=test, ) print(f"Model is evaluated in {time.time() - train_finished}") return calculated_metrics return {} def get_train_val_test_matrices( data_path: str, size: str = "50m", dataset_type: str = "likes", ) -> tuple[pl.LazyFrame, pl.LazyFrame, sp.csr_matrix, sp.csr_matrix]: df = pl.scan_parquet(os.path.join(os.path.join(data_path, size, f"{dataset_type}.parquet"))) if dataset_type == "listens": df = df.filter(pl.col("played_ratio_pct") >= Constants.TRACK_LISTEN_THRESHOLD) flat_train, _, flat_test = timesplit.flat_split_train_val_test( df, val_size=0, test_timestamp=Constants.TEST_TIMESTAMP ) all_uids = set(flat_train.collect().get_column("uid").to_list()) all_items = set(flat_train.collect().get_column("item_id").to_list()) print(f"Dataset, users_num: {len(all_uids)}, items_num: {len(all_items)}") # Create mapping to create sparse matrix uid_to_idx = {uid: i for i, uid in enumerate(all_uids)} item_id_to_idx = {item_id: i for i, item_id in enumerate(all_items)} sparse_train, _ = get_sparse_data(flat_train, uid_to_idx, item_id_to_idx) sparse_test, grouped_test = get_sparse_data(flat_test, uid_to_idx, item_id_to_idx) print(f"Sparse train shape: {sparse_train.shape}, test shape: {sparse_test.shape}") return df, grouped_test, sparse_train, sparse_test def get_sparse_data( df: pl.LazyFrame, uid_to_idx: dict[int, int], item_id_to_idx: dict[int, int] ) -> tuple[sp.csr_matrix, pl.LazyFrame]: df = df.with_columns( pl.col("uid").replace_strict(uid_to_idx).alias("uid"), pl.col("item_id").replace_strict(item_id_to_idx, default=len(item_id_to_idx)).alias("item_id"), pl.lit(1).alias("action"), ) grouped_df = df.group_by('uid', maintain_order=True).agg( [pl.col('item_id').alias('item_id'), pl.col('action').alias('actions')] ) rows = [] cols = [] values = [] for user_id, item_ids, actions in tqdm(grouped_df.select('uid', 'item_id', 'actions').collect().rows()): rows.extend([user_id] * len(item_ids)) cols.extend(item_ids) values.extend(actions) user_item_data = sp.csr_matrix( (values, (rows, cols)), dtype=np.float32, shape=(len(uid_to_idx), len(item_id_to_idx) + 1), # +1 for default unknown test items ) return user_item_data, grouped_df def get_sansa_model() -> SANSA: factorizer_config = ICFGramianFactorizerConfig( # reordering_use_long=True, factorization_shift_step=1e-3, # initial diagonal shift if incomplete factorization fails factorization_shift_multiplier=2.0, # multiplier for the shift for subsequent attempts ) inverter_config = UMRUnitLowerTriangleInverterConfig( scans=1, # number of scans through all columns of the matrix finetune_steps=15, # number of finetuning steps, targeting worst columns ) config = SANSAConfig( l2=10.0, # regularization strength weight_matrix_density=5e-5, # desired density of weights gramian_factorizer_config=factorizer_config, # factorizer configuration lower_triangle_inverter_config=inverter_config, # inverter configuration ) print(config) model = SANSA(config) return model def evaluate_sansa( df: pl.LazyFrame, model: SANSA, device: str, report_metrics: list[str], grouped_test: pl.LazyFrame, sparse_train: sp.csr_matrix, sparse_test: sp.csr_matrix, ) -> dict[str, Any]: num_items_for_metrics = len(set(df.collect().get_column("item_id").to_list())) print(num_items_for_metrics) test_targets = ranking.Targets.from_sequential(grouped_test, device=device) print(len(test_targets.user_ids)) # to free some RAM del df, grouped_test train_pred_sparse = model.forward(sparse_train) print(f"Train prediction shape: {train_pred_sparse.shape}") A = train_pred_sparse num_users = A.shape[0] num_items_k = 150 # 0 if there is no such item top_items_idx = np.full((num_users, num_items_k), 0, dtype=int) # -1 score if there is no such item top_items_score = np.full((num_users, num_items_k), -1, dtype=A.data.dtype) for row in tqdm(range(num_users)): start, end = A.indptr[row], A.indptr[row + 1] row_scores = A.data[start:end] row_cols = A.indices[start:end] if len(row_scores) == 0: continue k_here = min(num_items_k, len(row_scores)) top_k = heapq.nlargest(k_here, zip(row_scores, row_cols), key=lambda x: x[0]) # Fill in for i, (score, idx) in enumerate(top_k): top_items_idx[row, i] = idx top_items_score[row, i] = score user_ids = torch.arange(top_items_idx.shape[0], dtype=torch.int32, device="cpu") print(user_ids.shape) scores = torch.as_tensor(top_items_score, dtype=torch.float32, device="cpu") print(scores.shape) scores_indices = torch.as_tensor(top_items_idx, dtype=torch.long, device="cpu") print(scores_indices.shape) targets = torch.as_tensor(sparse_test.toarray(), dtype=torch.bool, device="cpu") print(targets.shape) targets = targets.to(dtype=torch.bool, device=device) not_zero_user_indices = targets.any(dim=1) print(torch.sum(not_zero_user_indices)) not_zero_user_indices = not_zero_user_indices.to(dtype=torch.bool, device="cpu") user_ids = user_ids[not_zero_user_indices] scores = scores[not_zero_user_indices] print(f"After removing zero users scores shape: {scores.shape}, targets shape: {targets.shape}") scores_indices = scores_indices[not_zero_user_indices] print(scores_indices.shape) test_ranked = ranking.Ranked( user_ids=user_ids.to(device), scores=scores.to(device), item_ids=scores_indices.to(device), num_item_ids=num_items_for_metrics, ) calculated_metrics = metrics.calc_metrics(test_ranked, test_targets, report_metrics) print(calculated_metrics) return calculated_metrics if __name__ == "__main__": main()