Download annotations/annotation_37/AlphaRec/models/General/AlphaRec.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 11.2 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_37/AlphaRec/models/General/AlphaRec.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_37/AlphaRec/models/General/AlphaRec.py
-
curl -L -o AlphaRec.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_37/AlphaRec/models/General/AlphaRec.py
11.2 kB
| 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 | |
| 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())) |