import random from collections import defaultdict import numpy as np import scipy.sparse as sp import torch import torch.nn as nn import torch.nn.functional as F from base.graph_recommender import GraphRecommender from base.torch_interface import TorchGraphInterface from util.conf import OptionConf from util.loss_torch import InfoNCE_FRGCF from util.loss_torch import InfoNCE class FRGCF(GraphRecommender): """ Feedback Reciprocal Graph Collaborative Filtering (FRGCF) Notes for this version: - Keep the paper-consistent Joint(A_IF, A_IU) definition. - Do NOT materialize the whole Joint sparse tensor on GPU. - Compute Eq.(13) only for the current batch nodes by row-chunk slicing: E_imp_batch = Joint[batch_nodes, :] @ E0 This is mathematically equivalent to first computing Joint @ E0 on the whole graph and then selecting the same rows, while using much less GPU memory. """ def __init__(self, conf, training_set, test_set): super(FRGCF, self).__init__(conf, training_set, test_set) args = OptionConf(self.config['FRGCF']) self.n_layers = int(args['-n_layer']) self.temp = float(args['-temp']) self.lambda_1 = float(args['-lambda1']) # frcl self.lambda_2 = float(args['-lambda2']) # macro self.lambda_3 = float(args['-lambda3']) # dis self.mu = float(args['-mu']) # item weight in macro loss self.cluster_num = int(args['-cluster_num']) self.rating_threshold = float(args['-rating_threshold']) if args.contain('-rating_threshold') else 4.0 self.partition_mode = args['-partition_mode'] if args.contain('-partition_mode') else 'standard' self.seed = int(args['-seed']) if args.contain('-seed') else 2026 self.decay = 1e-4 self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') random.seed(self.seed) np.random.seed(self.seed) torch.manual_seed(self.seed) if torch.cuda.is_available(): torch.cuda.manual_seed_all(self.seed) # Build feedback-partitioned data structures directly from the raw training set. self.if_edges, self.iu_edges = self._split_feedback_edges(training_set) self.if_user_pos = self._build_user_pos_dict(self.if_edges) self.iu_user_pos = self._build_user_pos_dict(self.iu_edges) self.norm_adj_if, self.norm_adj_iu = self._build_partition_norm_adj(self.if_edges, self.iu_edges) self.joint_if_iu = self._build_joint_matrix(self.norm_adj_if, self.norm_adj_iu).tocsr() self.encoder_if = FRGCFEncoder( user_num=self.data.user_num, item_num=self.data.item_num, emb_size=self.emb_size, n_layers=self.n_layers, norm_adj=self.norm_adj_if, ) self.encoder_iu = FRGCFEncoder( user_num=self.data.user_num, item_num=self.data.item_num, emb_size=self.emb_size, n_layers=self.n_layers, norm_adj=self.norm_adj_iu, ) self.best_user_emb = None self.best_item_emb = None # ------------------------------------------------------------------ # data construction # ------------------------------------------------------------------ def _split_feedback_edges(self, training_set): """ Split raw interactions into IF and IU by rating threshold. Expected record format in Douban / ml-1M style: [user, item, rating] """ if_edges, iu_edges = [], [] for rec in training_set: u_raw, i_raw, rating = self._parse_record(rec) u = self._resolve_user_index(u_raw) i = self._resolve_item_index(i_raw) if u is None or i is None: continue rating = float(rating) if self.partition_mode == 'douban_45_proxy': if rating >= 5.0: if_edges.append((u, i, rating)) elif rating >= 4.0: iu_edges.append((u, i, rating)) else: continue else: if rating >= self.rating_threshold: if_edges.append((u, i, rating)) else: iu_edges.append((u, i, rating)) if len(if_edges) == 0 or len(iu_edges) == 0: raise ValueError( "FRGCF requires both IF and IU interactions. " "Please check whether the dataset contains ratings and whether " "the threshold produces two non-empty partitions." ) return if_edges, iu_edges def _parse_record(self, rec): if isinstance(rec, (list, tuple)): if len(rec) >= 3: return rec[0], rec[1], rec[2] raise ValueError(f"Training record must have at least 3 fields, got: {rec}") raise TypeError(f"Unsupported training record type: {type(rec)}") def _resolve_user_index(self, u_raw): if isinstance(u_raw, (int, np.integer)) and 0 <= int(u_raw) < self.data.user_num: return int(u_raw) if hasattr(self.data, 'user') and u_raw in self.data.user: return self.data.user[u_raw] if hasattr(self.data, 'user_id') and u_raw in self.data.user_id: return self.data.user_id[u_raw] try: u = int(u_raw) if 0 <= u < self.data.user_num: return u except Exception: pass return None def _resolve_item_index(self, i_raw): if isinstance(i_raw, (int, np.integer)) and 0 <= int(i_raw) < self.data.item_num: return int(i_raw) if hasattr(self.data, 'item') and i_raw in self.data.item: return self.data.item[i_raw] if hasattr(self.data, 'item_id') and i_raw in self.data.item_id: return self.data.item_id[i_raw] try: i = int(i_raw) if 0 <= i < self.data.item_num: return i except Exception: pass return None def _build_user_pos_dict(self, edges): user_pos = defaultdict(set) for u, i, _ in edges: user_pos[u].add(i) return user_pos def _build_partition_norm_adj(self, if_edges, iu_edges): user_num, item_num = self.data.user_num, self.data.item_num norm_if = self._edges_to_norm_adj(if_edges, user_num, item_num) norm_iu = self._edges_to_norm_adj(iu_edges, user_num, item_num) return norm_if, norm_iu def _edges_to_norm_adj(self, edges, user_num, item_num): rows, cols, vals = [], [], [] for u, i, _ in edges: rows.append(u) cols.append(i) vals.append(1.0) r = sp.coo_matrix((vals, (rows, cols)), shape=(user_num, item_num), dtype=np.float32) upper_left = sp.csr_matrix((user_num, user_num), dtype=np.float32) lower_right = sp.csr_matrix((item_num, item_num), dtype=np.float32) a = sp.vstack([ sp.hstack([upper_left, r], format='csr'), sp.hstack([r.T, lower_right], format='csr') ], format='csr') deg = np.array(a.sum(axis=1)).flatten() deg[deg == 0.0] = 1.0 deg_inv_sqrt = np.power(deg, -0.5) d_inv_sqrt = sp.diags(deg_inv_sqrt) norm_adj = d_inv_sqrt.dot(a).dot(d_inv_sqrt).tocsr() return norm_adj def _build_joint_matrix(self, norm_adj_if, norm_adj_iu): """ Equation (12) in the paper: Joint(A_IF, A_IU) = (sum_{k=0}^2 A_IF^k) * (sum_{k=0}^2 A_IU^k) """ n = norm_adj_if.shape[0] eye = sp.eye(n, dtype=np.float32, format='csr') sum_if = eye + norm_adj_if + norm_adj_if.dot(norm_adj_if) sum_iu = eye + norm_adj_iu + norm_adj_iu.dot(norm_adj_iu) joint = sum_if.dot(sum_iu).tocsr() return joint # ------------------------------------------------------------------ # training # ------------------------------------------------------------------ def train(self): self.encoder_if = self.encoder_if.to(self.device) self.encoder_iu = self.encoder_iu.to(self.device) optimizer = torch.optim.Adam( list(self.encoder_if.parameters()) + list(self.encoder_iu.parameters()), lr=self.lRate ) steps_per_epoch = max( int(np.ceil(len(self.if_edges) / self.batch_size)), int(np.ceil(len(self.iu_edges) / self.batch_size)) ) for epoch in range(self.maxEpoch): self.encoder_if.train() self.encoder_iu.train() epoch_loss = 0.0 for _ in range(steps_per_epoch): batch_if = self._sample_pairwise_batch(self.if_user_pos, self.batch_size) batch_iu = self._sample_pairwise_batch(self.iu_user_pos, self.batch_size) out_if = self.encoder_if() out_iu = self.encoder_iu() bpr_if = self._bpr_branch_loss(out_if['user_final'], out_if['item_final'], batch_if) bpr_iu = self._bpr_branch_loss(out_iu['user_final'], out_iu['item_final'], batch_iu) frcl_loss = self._feedback_reciprocal_contrastive_loss(out_if, out_iu, batch_if, batch_iu) macro_loss = self._macro_feedback_modeling_loss(out_if, out_iu, batch_if, batch_iu) dis_loss = self._distance_regularization(out_if['V'], out_iu['V']) reg_loss = self._l2_regularization(out_if, out_iu, batch_if, batch_iu) loss = ( bpr_if + bpr_iu + self.lambda_1 * frcl_loss + self.lambda_2 * macro_loss + self.lambda_3 * dis_loss + reg_loss ) optimizer.zero_grad() loss.backward() optimizer.step() epoch_loss += loss.item() with torch.no_grad(): self.encoder_if.eval() final_if = self.encoder_if() self.user_emb = final_if['user_final'] self.item_emb = final_if['item_final'] self.fast_evaluation(epoch) self.user_emb, self.item_emb = self.best_user_emb, self.best_item_emb def _sample_pairwise_batch(self, user_pos_dict, batch_size): users = list(user_pos_dict.keys()) sampled_users = random.choices(users, k=batch_size) pos_items, neg_items = [], [] for u in sampled_users: pos = random.choice(list(user_pos_dict[u])) neg = random.randint(0, self.data.item_num - 1) while neg in user_pos_dict[u]: neg = random.randint(0, self.data.item_num - 1) pos_items.append(pos) neg_items.append(neg) users = torch.tensor(sampled_users, dtype=torch.long, device=self.device) pos_items = torch.tensor(pos_items, dtype=torch.long, device=self.device) neg_items = torch.tensor(neg_items, dtype=torch.long, device=self.device) return users, pos_items, neg_items def _bpr_branch_loss(self, user_emb, item_emb, batch): users, pos_items, neg_items = batch u = user_emb[users] i = item_emb[pos_items] j = item_emb[neg_items] pos_scores = torch.sum(u * i, dim=1) neg_scores = torch.sum(u * j, dim=1) return -torch.mean(F.logsigmoid(pos_scores - neg_scores)) # ------------------------------------------------------------------ # FRCL: exact row-batched Eq.(13) # ------------------------------------------------------------------ def _feedback_reciprocal_contrastive_loss(self, out_if, out_iu, batch_if, batch_iu): """ Exact-memory-friendly FRCL. Original full-graph form: E_imp = Joint @ E0 then select batch users/items for InfoNCE_FRGCF This implementation computes only the required rows: E_imp_batch = Joint[batch_nodes, :] @ E0 Because matrix multiplication is row-separable, this is mathematically equivalent to full-graph computation followed by row selection, while avoiding materializing the whole Joint tensor on GPU. """ users = torch.unique(torch.cat([batch_if[0], batch_iu[0]], dim=0)) items = torch.unique(torch.cat([batch_if[1], batch_iu[1]], dim=0)) # Build node ids in the concatenated [users; items] space. item_nodes = items + self.data.user_num batch_nodes = torch.unique(torch.cat([users, item_nodes], dim=0)) # Compute only the required rows of Joint @ E0 for both branches. e_imp_if_batch = self._joint_left_multiply_rows(batch_nodes, out_if['E0']) e_imp_iu_batch = self._joint_left_multiply_rows(batch_nodes, out_iu['E0']) # Recover user/item positions inside the batch_nodes output order. is_user = batch_nodes < self.data.user_num user_pos = torch.nonzero(is_user, as_tuple=False).squeeze(1) item_pos = torch.nonzero(~is_user, as_tuple=False).squeeze(1) u_imp_if = e_imp_if_batch[user_pos] u_imp_iu = e_imp_iu_batch[user_pos] i_imp_if = e_imp_if_batch[item_pos] i_imp_iu = e_imp_iu_batch[item_pos] user_loss = InfoNCE_FRGCF(u_imp_if, u_imp_iu, self.temp) item_loss = InfoNCE_FRGCF(i_imp_if, i_imp_iu, self.temp) return user_loss + item_loss def _joint_left_multiply_rows(self, row_idx, dense_rhs): """ Compute Joint[row_idx, :] @ dense_rhs exactly. row_idx: 1-D torch.LongTensor on any device, with ids in [0, M+N) dense_rhs: torch.Tensor of shape (M+N, d) on self.device Returns: torch.Tensor of shape (len(row_idx), d) on self.device """ # scipy csr slicing on CPU row_idx_cpu = row_idx.detach().cpu().numpy().astype(np.int64) joint_rows = self.joint_if_iu[row_idx_cpu, :] # exact row slice # convert sparse slice to GPU tensor only for current rows joint_rows_tensor = TorchGraphInterface.convert_sparse_mat_to_tensor(joint_rows).to(self.device) # exact row-block matmul return torch.sparse.mm(joint_rows_tensor, dense_rhs) # ------------------------------------------------------------------ # Macro / regularization # ------------------------------------------------------------------ def _macro_feedback_modeling_loss(self, out_if, out_iu, batch_if, batch_iu): macro_if = self._build_macro_embeddings(out_if) macro_iu = self._build_macro_embeddings(out_iu) users = torch.unique(torch.cat([batch_if[0], batch_iu[0]], dim=0)) items = torch.unique(torch.cat([batch_if[1], batch_iu[1]], dim=0)) eK_if_u = out_if['user_last'][users] eK_if_i = out_if['item_last'][items] eK_iu_u = out_iu['user_last'][users] eK_iu_i = out_iu['item_last'][items] macro_if_u = macro_if['user_macro'][users] macro_if_i = macro_if['item_macro'][items] macro_iu_u = macro_iu['user_macro'][users] macro_iu_i = macro_iu['item_macro'][items] l_if = InfoNCE(eK_if_u, macro_if_u, self.temp) + self.mu * InfoNCE(eK_if_i, macro_if_i, self.temp) l_iu = InfoNCE(eK_iu_u, macro_iu_u, self.temp) + self.mu * InfoNCE(eK_iu_i, macro_iu_i, self.temp) return l_if + l_iu def _build_macro_embeddings(self, out): e0_user = out['user_e0'] e0_item = out['item_e0'] V = out['V'] c_user = self._kmeans_centroids(e0_user, self.cluster_num) c_item = self._kmeans_centroids(e0_item, self.cluster_num) C = torch.cat([c_user, c_item], dim=0) # C_x in paper H = torch.matmul(V, C.t()) W = H / (torch.norm(H, dim=1, keepdim=True) + 1e-12) e_macro = out['E0'] + torch.matmul(W, C) / C.shape[0] user_macro, item_macro = torch.split(e_macro, [self.data.user_num, self.data.item_num], dim=0) return { 'user_macro': user_macro, 'item_macro': item_macro, } def _kmeans_centroids(self, embeddings, n_clusters): from sklearn.cluster import KMeans x = embeddings.detach().cpu().numpy() n_clusters = min(n_clusters, x.shape[0]) if n_clusters <= 1: centroid = np.mean(x, axis=0, keepdims=True) return torch.tensor(centroid, dtype=embeddings.dtype, device=embeddings.device) model = KMeans(n_clusters=n_clusters, random_state=self.seed, n_init=10) model.fit(x) centers = torch.tensor(model.cluster_centers_, dtype=embeddings.dtype, device=embeddings.device) return centers def _distance_regularization(self, V_if, V_iu): return -self._jsd(V_if, V_iu) def _jsd(self, p_logits, q_logits): p = F.softmax(p_logits, dim=-1) q = F.softmax(q_logits, dim=-1) m = 0.5 * (p + q) kl_pm = torch.sum(p * (torch.log(p + 1e-12) - torch.log(m + 1e-12)), dim=-1) kl_qm = torch.sum(q * (torch.log(q + 1e-12) - torch.log(m + 1e-12)), dim=-1) return 0.5 * (kl_pm.mean() + kl_qm.mean()) def _l2_regularization(self, out_if, out_iu, batch_if, batch_iu): users_if, pos_if, neg_if = batch_if users_iu, pos_iu, neg_iu = batch_iu reg = 0.0 reg += torch.norm(out_if['user_e0'][users_if]) ** 2 reg += torch.norm(out_if['item_e0'][pos_if]) ** 2 reg += torch.norm(out_if['item_e0'][neg_if]) ** 2 reg += torch.norm(out_iu['user_e0'][users_iu]) ** 2 reg += torch.norm(out_iu['item_e0'][pos_iu]) ** 2 reg += torch.norm(out_iu['item_e0'][neg_iu]) ** 2 return self.reg * self.decay * reg / (2.0 * self.batch_size) def save(self): with torch.no_grad(): self.encoder_if.eval() final_if = self.encoder_if() self.best_user_emb = final_if['user_final'] self.best_item_emb = final_if['item_final'] def predict(self, u): # Paper inference: use IF-side model only. u = self.data.get_user_id(u) score = torch.matmul(self.user_emb[u], self.item_emb.transpose(0, 1)) return score.detach().cpu().numpy() class FRGCFEncoder(nn.Module): def __init__(self, user_num, item_num, emb_size, n_layers, norm_adj): super(FRGCFEncoder, self).__init__() self.user_num = user_num self.item_num = item_num self.emb_size = emb_size self.n_layers = n_layers self.norm_adj = norm_adj self.embedding_dict = self._init_model() self.sparse_norm_adj = None def _init_model(self): initializer = nn.init.xavier_uniform_ return nn.ParameterDict({ 'user_emb': nn.Parameter(initializer(torch.empty(self.user_num, self.emb_size))), 'item_emb': nn.Parameter(initializer(torch.empty(self.item_num, self.emb_size))), }) def _get_sparse_adj(self, device): if self.sparse_norm_adj is None: self.sparse_norm_adj = TorchGraphInterface.convert_sparse_mat_to_tensor(self.norm_adj) return self.sparse_norm_adj.to(device) def forward(self): device = self.embedding_dict['user_emb'].device sparse_adj = self._get_sparse_adj(device) e0 = torch.cat([self.embedding_dict['user_emb'], self.embedding_dict['item_emb']], dim=0) layer_outputs = [e0] ego = e0 for _ in range(self.n_layers): ego = torch.sparse.mm(sparse_adj, ego) layer_outputs.append(ego) last = layer_outputs[-1] if self.n_layers > 0: all_propagated = torch.stack(layer_outputs[1:], dim=1) final = torch.mean(all_propagated, dim=1) diffs = [] for i in range(self.n_layers): diffs.append(layer_outputs[i + 1] - layer_outputs[i]) V = torch.stack(diffs, dim=1).mean(dim=1) else: final = e0 V = torch.zeros_like(e0) user_final, item_final = torch.split(final, [self.user_num, self.item_num], dim=0) user_e0, item_e0 = torch.split(e0, [self.user_num, self.item_num], dim=0) user_last, item_last = torch.split(last, [self.user_num, self.item_num], dim=0) return { 'E0': e0, 'E_last': last, 'V': V, 'user_final': user_final, 'item_final': item_final, 'user_e0': user_e0, 'item_e0': item_e0, 'user_last': user_last, 'item_last': item_last, }