import numpy as np import pandas as pd import time import torch import torch.nn as nn import torch.nn.functional as F from .base.abstract_model import AbstractModel from .base.abstract_RS import AbstractRS from .base.abstract_data import AbstractData, helper_load, helper_load_train from tqdm import tqdm from .base.evaluator import ProxyEvaluator from .base.utils import * from functools import partial class _AlphaRecCore(AbstractModel): """ Core AlphaRec implementation: - Loads frozen LM embeddings for users/items. - Projection: linear ('homo') or 2-layer MLP ('mlp') with LeakyReLU. - LightGCN propagation. - InfoNCE utilities. """ def __init__(self, args, data) -> None: super().__init__(args, data) self.tau = getattr(args, 'tau', 0.1) self.embed_size = args.hidden_size self.lm_model = getattr(args, 'lm_model', 'v3') self.model_version = getattr(args, 'model_version', 'homo') # Flags from AbstractModel/args (already set in parent, but cache for safety) self.n_layers = getattr(args, 'n_layers', 0) self.train_norm = getattr(args, 'train_norm', False) self.pred_norm = getattr(args, 'pred_norm', False) # Cache frozen LM embeddings (numpy -> torch), do NOT register as buffers to align state_dict with canonical user_cf = torch.tensor(data.user_cf_embeds, dtype=torch.float32, device=self.device) item_cf = torch.tensor(data.item_cf_embeds, dtype=torch.float32, device=self.device) self.init_user_cf_embeds = user_cf # not a buffer self.init_item_cf_embeds = item_cf # not a buffer self.init_embed_dim = self.init_user_cf_embeds.shape[1] self.init_embed_shape = self.init_embed_dim # align with canonical attribute naming # Projection layer: linear ('homo') or 2-layer MLP ('mlp') if self.model_version == 'homo': # canonical: bias=False self.mlp = nn.Sequential(nn.Linear(self.init_embed_dim, self.embed_size, bias=False)) else: # canonical hidden dimension multiplier by lm_model multiplier_dict = { 'bert': 8, 'roberta': 8, 'v2': 2, 'v3': 1/2, 'v3_shuffle': 1/2, } multiplier = multiplier_dict.get(self.lm_model, 9/32) hidden_dim = int(multiplier * self.init_embed_dim) self.mlp = nn.Sequential( nn.Linear(self.init_embed_dim, hidden_dim), nn.LeakyReLU(), nn.Linear(hidden_dim, self.embed_size) ) # Graph from data (sparse normalized adjacency) self.Graph = self.data.getSparseGraph() def init_embedding(self): # Placeholder to keep interface consistency with AbstractModel # AlphaRec uses frozen LM embeddings instead of trainable ID embeddings. pass def compute(self): """ Project LM embeddings and perform LightGCN propagation. Returns: users: [n_users, d] items: [n_items, d] """ users_cf_emb = self.mlp(self.init_user_cf_embeds) items_cf_emb = self.mlp(self.init_item_cf_embeds) all_emb = torch.cat([users_cf_emb, items_cf_emb], dim=0) embs = [all_emb] for _ in range(self.n_layers): all_emb = torch.sparse.mm(self.Graph, all_emb) embs.append(all_emb) embs = torch.stack(embs, dim=1) # [n_users+n_items, K+1, d] light_out = torch.mean(embs, dim=1) # layer-wise average users, items = torch.split(light_out, [self.data.n_users, self.data.n_items], dim=0) return users, items def _gather_batch_embeddings(self, users_idx, pos_idx, neg_idx=None): all_users, all_items = self.compute() u = all_users[users_idx] pos = all_items[pos_idx] if neg_idx is not None: neg = all_items[neg_idx] # shape [B, Nneg, d] if neg_idx is 2D else: neg = None return u, pos, neg def _info_nce(self, u_emb, pos_emb, neg_emb): """ u_emb: [B, d] pos_emb: [B, d] neg_emb: [B, Nneg, d] """ if self.train_norm: u_emb = F.normalize(u_emb, dim=-1) pos_emb = F.normalize(pos_emb, dim=-1) neg_emb = F.normalize(neg_emb, dim=-1) pos_scores = torch.sum(u_emb * pos_emb, dim=-1) # [B] neg_scores = torch.einsum('bd,bnd->bn', u_emb, neg_emb) # [B, Nneg] num = torch.exp(pos_scores / self.tau) den = num + torch.sum(torch.exp(neg_scores / self.tau), dim=1) loss = torch.mean(torch.negative(torch.log(num / den))) return loss @torch.no_grad() def predict(self, users, items=None): """ Compute cosine similarity (dot on normalized if pred_norm) for ranking. Inputs: users: list[int] or tensor [B] items: optional list[int] or tensor [M]; if None, score against all items. Output: score_matrix: numpy array [B, M] """ all_users, all_items = self.compute() if not torch.is_tensor(users): users = torch.tensor(users, dtype=torch.long, device=self.device) else: users = users.to(self.device) if items is None: item_emb = all_items else: if not torch.is_tensor(items): items = torch.tensor(items, dtype=torch.long, device=self.device) else: items = items.to(self.device) item_emb = all_items[items] user_emb = all_users[users] if self.pred_norm: user_emb = F.normalize(user_emb, dim=-1) item_emb = F.normalize(item_emb, dim=-1) scores = torch.matmul(user_emb, item_emb.transpose(0, 1)) return scores.detach().cpu().numpy() class AlphaRec(_AlphaRecCore): """ AlphaRec with sampled negatives (standard InfoNCE). """ def __init__(self, args, data) -> None: super().__init__(args, data) def forward(self, users, pos_items, neg_items): """ Compute InfoNCE loss for a batch with sampled negatives. Inputs: users: [B] pos_items: [B] neg_items: [B, Nneg] or [B] if Nneg=1 Output: loss: scalar tensor """ # Ensure neg_items shape [B, Nneg] if neg_items.dim() == 1: neg_items = neg_items.unsqueeze(1) u_emb, pos_emb, neg_emb = self._gather_batch_embeddings(users, pos_items, neg_items) return self._info_nce(u_emb, pos_emb, neg_emb) class AlphaRec_batch(_AlphaRecCore): """ AlphaRec with in-batch negatives (neg_sample == -1), i.e., InfoNCE without explicit sampled negatives. Other positives in the batch serve as negatives. """ def __init__(self, args, data) -> None: super().__init__(args, data) def forward(self, users, pos_items, neg_items=None): """ In-batch InfoNCE: - Build similarity matrix between u_emb and all pos_emb in batch. - Diagonal entries are positives; off-diagonals are negatives. """ all_users, all_items = self.compute() u_emb = all_users[users] pos_emb = all_items[pos_items] if self.train_norm: u_emb = F.normalize(u_emb, dim=-1) pos_emb = F.normalize(pos_emb, dim=-1) # Similarity matrix S: [B, B] logits = torch.matmul(u_emb, pos_emb.t()) # cosine if normalized logits = logits / self.tau labels = torch.arange(logits.size(0), device=logits.device) loss = F.cross_entropy(logits, labels) return loss class AlphaRec_RS(AbstractRS): def __init__(self, args, special_args) -> None: super().__init__(args, special_args) def train_one_epoch(self, epoch): running_loss, num_batches = 0, 0 pbar = tqdm(enumerate(self.data.train_loader), mininterval=2, total = len(self.data.train_loader)) for batch_i, batch in pbar: batch = [x.cuda(self.device) for x in batch] users, pos_items, users_pop, pos_items_pop = batch[0], batch[1], batch[2], batch[3] # In in-batch setting (infonce==1 and neg_sample==-1), neg_items not provided if self.args.infonce == 0 or self.args.neg_sample != -1: neg_items = batch[4] neg_items_pop = batch[5] else: neg_items = None self.model.train() if neg_items is None: loss = self.model(users, pos_items) # AlphaRec_batch ignores neg_items else: loss = self.model(users, pos_items, neg_items) self.optimizer.zero_grad() loss.backward() self.optimizer.step() running_loss += loss.detach().item() num_batches += 1 return [running_loss/num_batches] class AlphaRec_Data(AbstractData): def __init__(self, args): super().__init__(args) def add_special_model_attr(self, args): self.lm_model = args.lm_model loading_path = args.data_path + args.dataset + '/item_info/' embedding_path_dict = { 'bert': 'item_cf_embeds_bert_array.npy', 'roberta': 'item_cf_embeds_roberta_array.npy', 'v2': 'item_cf_embeds_array.npy', 'v3': 'item_cf_embeds_large3_array.npy', 'v3_shuffle': "item_cf_embeds_large3_array_shuffle.npy", 'llama2_7b': 'item_cf_embeds_llama2_7b_array.npy', 'llama3_7b': 'item_cf_embeds_llama3_7b_instruct_array.npy', 'mistral_7b': 'item_cf_embeds_Norm_Mistral-7B-v0.1_array.npy', 'SFR': 'item_cf_embeds_Norm_SFR-Embedding-Mistral_7b_array.npy', 'GritLM_7b': 'item_cf_embeds_Norm_GritLM-7B_array.npy', 'e5_7b': 'item_cf_embeds_Norm_e5-mistral-7b-instruct_array.npy', 'echo_7b': 'item_cf_embeds_Norm_echo-mistral-7b-instruct-lasttoken_array.npy', } self.item_cf_embeds = np.load(loading_path + embedding_path_dict[self.lm_model]) def group_agg(group_data, embedding_dict, key='item_id'): ids = group_data[key].values embeds = [embedding_dict[id] for id in ids] embeds = np.array(embeds) return embeds.mean(axis=0) # self.train_user_list pairs = [] for u, v in self.train_user_list.items(): for i in v: pairs.append((u, i)) pairs = pd.DataFrame(pairs, columns=['user_id', 'item_id']) # User CF Embedding: the average of item embeddings groups = pairs.groupby('user_id') item_cf_embeds_dict = {i:self.item_cf_embeds[i] for i in range(len(self.item_cf_embeds))} user_cf_embeds = groups.apply(group_agg, embedding_dict=item_cf_embeds_dict, key='item_id') user_cf_embeds_dict = user_cf_embeds.to_dict() user_cf_embeds_dict = dict(sorted(user_cf_embeds_dict.items(), key=lambda item: item[0])) self.user_cf_embeds = np.array(list(user_cf_embeds_dict.values()))