mcy98's picture
Upload folder using huggingface_hub
6077218 verified
Raw History Blame Contribute Delete
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
@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()))