Upload 19 files

data/baby/test.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b890fa339aca21fac9c17c27a9f1ea163ff8df9a6e4caf353c7f7cf7d689c745
+size 347040

data/baby/train.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d4c495814d61a1ea84b756f11096d468cc07113d05aecbabcef8de9cf7a1387
+size 1896944

data/baby/valid.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:388bd7922d74311e6afc6fbc9f6299cc85b32310109f7d67939ef90e097babb2
+size 329072

data/clothing/test.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:272ba8177a70a973842bc30eafe0d7ae7d641c5117600a0f23b24319c7ad7a61
+size 659152

data/clothing/train.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:685fe396e4a8d3c6cf465a9e8421e1fa07b7d187e7fa1dc996578f11a7de896a
+size 3157536

data/clothing/valid.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f8c581fa0680e5886d4781a4a551868d47138c9b2d4d1cbe886d17cef3fedcd
+size 642528

data/sports/test.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9396ff247c58b918a915bc95f19574492c0cf3f8ae104b77ac2447b15f77970
+size 640592

data/sports/train.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1f8c7a04efd251941083dd25bff7c154e2e2ff7bc3ccc240d45bd11f906fbf2
+size 3494672

data/sports/valid.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a27b2d104aef08582fbf241dc3c77b9ce7fc0788962ec6f36eb9b8c0dafba649
+size 606512

main.py

@@ -0,0 +1,114 @@
+import os
+import torch
+import platform
+from time import time
+from tqdm import tqdm
+from trainer import train
+import torch.optim as optim
+from utils.parser import parse_args
+from utils.logger import init_logger
+from utils.configurator import Config
+from torch.utils.data import DataLoader
+from tensorboardX import SummaryWriter
+from utils.evaluator import evaluate_model
+from utils.data_loader import Load_dataset, Load_eval_dataset
+from utils.helper import early_stopping, plot_curve, res_output, stop_log, update_result, sele_para
+from model import REARM
+
+
+class Net:
+    def __init__(self, args):
+        # Complete initialization of all parameters (including random seeds)
+        self.config = Config(args)
+        # Use logger
+        self.logger = init_logger(self.config)
+        self.logger.info(self.config)
+        self.logger.info('██Server: \t' + platform.node())
+        self.logger.info('██Dir: \t' + os.getcwd() + '\n')
+        self.device = self.config.device
+        self.model_name = self.config.model_name
+        self.dataset_name = self.config.dataset
+        self.batch_size = self.config.batch_size
+        self.num_workers = self.config.num_workers
+        self.learning_rate = self.config.learning_rate
+        self.num_epoch = self.config.num_epoch
+        self.topk = self.config.topk
+        self.metrics = self.config.metrics
+        self.valid_metric = self.config.valid_metric
+        self.stopping_step = self.config.stopping_step
+        self.reg_weight = self.config.reg_weight
+        self.cur_step = 0
+        self.best_valid_score = -1
+        self.best_valid_result = {}
+        self.best_test_upon_valid = {}
+        # Writer will output to ./runs/ directory by default
+        self.writer = SummaryWriter() if self.config.writer else None
+
+        # Perform experimental configurations
+        Dataset = Load_dataset(self.config)
+        valid_dataset, test_dataset = Dataset.load_eval_data()
+        self.train_data = DataLoader(Dataset, batch_size=self.batch_size, shuffle=True,
+                                     num_workers=self.num_workers)
+
+        (self.valid_data, self.test_data) = (Load_eval_dataset("Validation", self.config, valid_dataset),
+                                             Load_eval_dataset("Testing", self.config, test_dataset))
+        self.model = REARM(self.config, Dataset).to(self.device)
+        self.optimizer = optim.AdamW(self.model.parameters(), self.learning_rate, weight_decay=self.reg_weight)
+        lr_scheduler = self.config.learning_rate_scheduler
+        fac = lambda epoch: lr_scheduler[0] ** (epoch / lr_scheduler[1])
+        scheduler = optim.lr_scheduler.LambdaLR(self.optimizer, lr_lambda=fac)
+        self.lr_scheduler = scheduler
+        self.logger.info(self.model)
+
+    def plot_train_loss(self):
+        plot_curve(self)
+
+    def run(self):
+        run_start_time = time()
+        for epoch_idx in tqdm(range(self.num_epoch)):
+            train_start_time = time()
+            train_loss = train(self, epoch_idx)
+            # Save if an exception occurs
+            if torch.isnan(train_loss[0]):
+                ret_value = {"Recall@20": -1} if self.best_test_upon_valid == {} else self.best_test_upon_valid
+                stop_output = '\n ' + str(self.config.dataset) + '  key parameter: ' + sele_para(self.config)
+                self.logger.info(stop_output)
+                self.logger.info('Loss is nan at epoch: {}; last value is {}Exiting.'.format(epoch_idx, ret_value))
+                return ret_value
+
+            self.lr_scheduler.step()
+
+            train_output = res_output(epoch_idx, train_start_time, time(), train_loss, "train")
+            self.logger.info(train_output)
+
+            # valid evaluate_model
+            valid_start_time = time()
+            valid_score, valid_result = evaluate_model(self, epoch_idx, self.valid_data, t_or_v="valid")
+
+            self.best_valid_score, self.cur_step, stop_flag, update_flag = early_stopping(
+                valid_score, self.best_valid_score, self.cur_step, self.stopping_step)
+
+            self.best_valid_result[epoch_idx] = self.best_valid_score
+            valid_output = res_output(epoch_idx, valid_start_time, time(), valid_result, t_or_v="valid")
+            self.logger.info(valid_output)
+
+            if update_flag:
+                # test evaluate_model
+                test_start_time = time()
+                _, test_result = evaluate_model(self, epoch_idx, self.test_data, t_or_v="test")
+                test_score_output = res_output(epoch_idx, test_start_time, time(), test_result, t_or_v="test")
+                self.logger.info(test_score_output)
+                update_result(self, test_result)
+
+            if stop_flag:
+                stop_log(self, epoch_idx, run_start_time)
+                break
+            else:
+                print('patience ==> %d' % (self.stopping_step - self.cur_step))
+        return self.best_test_upon_valid
+
+
+if __name__ == '__main__':
+    _args = parse_args()
+    model = Net(_args)
+    best_score = model.run()

model.py

@@ -0,0 +1,279 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from utils.helper import get_norm_adj_mat, ssl_loss, topk_sample, cal_diff_loss, propgt_info
+
+
+class REARM(nn.Module):
+    def __init__(self, config, dataset):
+        super(REARM, self).__init__()
+
+        self.n_users = dataset.n_users
+        self.n_items = dataset.n_items
+        self.n_nodes = self.n_users + self.n_items
+        self.i_v_feat = dataset.i_v_feat
+        self.i_t_feat = dataset.i_t_feat
+        self.embedding_dim = config.embedding_dim
+        self.feat_embed_dim = config.embedding_dim
+        self.dim_feat = self.feat_embed_dim
+        self.reg_weight = config.reg_weight
+        self.device = config.device
+        self.cl_tmp = config.cl_tmp
+        self.cl_loss_weight = config.cl_loss_weight
+        self.diff_loss_weight = config.diff_loss_weight
+        self.n_layers = config.n_layers
+        self.num_user_co = config.num_user_co
+        self.num_item_co = config.num_item_co
+        self.user_aggr_mode = config.user_aggr_mode
+        self.n_ii_layers = config.n_ii_layers
+        self.n_uu_layers = config.n_uu_layers
+        self.k = config.rank
+        self.uu_co_weight = config.uu_co_weight
+        self.ii_co_weight = config.ii_co_weight
+
+        # Load user and item graphs
+        self.topK_users = dataset.topK_users
+        self.topK_items = dataset.topK_items
+        self.dict_user_co_occ_graph = dataset.dict_user_co_occ_graph
+        self.dict_item_co_occ_graph = dataset.dict_item_co_occ_graph
+        self.topK_users_counts = dataset.topK_users_counts
+        self.topK_items_counts = dataset.topK_items_counts
+
+        self.s_drop = config.s_drop
+        self.m_drop = config.m_drop
+        self.ly_norm = nn.LayerNorm(self.feat_embed_dim)
+
+        self.self_i_attn1 = nn.MultiheadAttention(1, 1, dropout=self.s_drop, batch_first=True)
+        self.self_i_attn2 = nn.MultiheadAttention(1, 1, dropout=self.s_drop, batch_first=True)
+
+        self.mutual_i_attn1 = nn.MultiheadAttention(1, 1, dropout=self.m_drop, batch_first=True)
+        self.mutual_i_attn2 = nn.MultiheadAttention(1, 1, dropout=self.m_drop, batch_first=True)
+
+        self.user_id_embedding = nn.Embedding(self.n_users, self.embedding_dim).to(self.device)
+        self.item_id_embedding = nn.Embedding(self.n_items, self.embedding_dim).to(self.device)
+
+        self.prl = nn.PReLU().to(self.device)
+
+        self.cal_bpr = torch.tensor([[1.0], [-1.0]]).to(self.device)
+
+        # load dataset info
+        self.norm_adj = get_norm_adj_mat(self, dataset.sparse_inter_matrix(form='coo')).to(self.device)
+        # Process to obtain user co-occurrence matrix (n_users*num_user_co)
+        self.user_co_graph = topk_sample(self.n_users, self.dict_user_co_occ_graph, self.num_user_co,
+                                         self.topK_users, self.topK_users_counts, 'softmax',
+                                         self.device)
+
+        # Process to obtain user co-occurrence matrix (n_users*num_user_co)
+        self.item_co_graph = topk_sample(self.n_items, self.dict_item_co_occ_graph, self.num_item_co,
+                                         self.topK_items, self.topK_items_counts, 'softmax',
+                                         self.device)
+
+        # Process to obtain item similarity matrix (n_items* n_items )
+        self.i_mm_adj = dataset.i_mm_adj
+        # Process to obtain user similarity matrix (n_users* n_users)
+        self.u_mm_adj = dataset.u_mm_adj
+
+        # Strengthen ii and uu graphs
+        self.stre_ii_graph = self.ii_co_weight * self.item_co_graph + (1.0 - self.ii_co_weight) * self.i_mm_adj
+        self.stre_uu_graph = self.uu_co_weight * self.user_co_graph + (1.0 - self.uu_co_weight) * self.u_mm_adj
+
+        if self.i_v_feat is not None:
+            self.image_embedding = nn.Embedding.from_pretrained(self.i_v_feat, freeze=False).to(self.device)
+            self.image_i_trs = nn.Linear(self.i_v_feat.shape[1], self.feat_embed_dim)
+            self.user_v_prefer = torch.nn.Parameter(dataset.u_v_interest, requires_grad=True).to(self.device)
+            self.image_u_trs = nn.Linear(self.i_v_feat.shape[1], self.feat_embed_dim)
+
+        if self.i_t_feat is not None:
+            self.text_embedding = nn.Embedding.from_pretrained(self.i_t_feat, freeze=False).to(self.device)
+            self.text_i_trs = nn.Linear(self.i_t_feat.shape[1], self.feat_embed_dim)
+            self.user_t_prefer = torch.nn.Parameter(dataset.u_t_interest, requires_grad=True).to(self.device)
+            self.text_u_trs = nn.Linear(self.i_t_feat.shape[1], self.feat_embed_dim)
+
+        # MLP(input_dim, feature_dim, hidden_dim, output_dim)
+        self.mlp_u1 = MLP(self.feat_embed_dim, self.feat_embed_dim * self.k, self.feat_embed_dim * self.k, self.device)
+        self.mlp_u2 = MLP(self.feat_embed_dim, self.feat_embed_dim * self.k, self.feat_embed_dim * self.k, self.device)
+        self.mlp_i1 = MLP(self.feat_embed_dim, self.feat_embed_dim * self.k, self.feat_embed_dim * self.k, self.device)
+        self.mlp_i2 = MLP(self.feat_embed_dim, self.feat_embed_dim * self.k, self.feat_embed_dim * self.k, self.device)
+        self.meta_netu = nn.Linear(self.feat_embed_dim * 2, self.feat_embed_dim, bias=True)  # Knowledge compression
+        self.meta_neti = nn.Linear(self.feat_embed_dim * 2, self.feat_embed_dim, bias=True)  # Knowledge compression
+
+        self._reset_parameters()
+
+    def _reset_parameters(self):
+        nn.init.normal_(self.user_id_embedding.weight, std=0.1)
+        nn.init.normal_(self.item_id_embedding.weight, std=0.1)
+
+        nn.init.xavier_normal_(self.image_i_trs.weight)
+        nn.init.xavier_normal_(self.text_i_trs.weight)
+        nn.init.xavier_normal_(self.image_u_trs.weight)
+        nn.init.xavier_normal_(self.text_u_trs.weight)
+
+    def forward(self):
+        # Uniform feature dimensions for multi-modal feature information on item
+        trs_item_v_feat = self.image_i_trs(self.image_embedding.weight)
+        trs_item_t_feat = self.text_i_trs(self.text_embedding.weight)  # num_items * 64
+
+        trs_user_v_prefer = self.image_u_trs(self.user_v_prefer)
+        trs_user_t_prefer = self.text_u_trs(self.user_t_prefer)  # num_items * 64
+
+        # ====================================================================================
+        # Homography Relation Learning
+        # ====================================================================================
+        # Item homogeneous relational learning
+        item_v_t = torch.cat((trs_item_v_feat, trs_item_t_feat), dim=-1)
+        item_id_v_t = torch.cat((self.item_id_embedding.weight, item_v_t), dim=-1)
+        item_id_v_t = propgt_info(item_id_v_t, self.n_ii_layers, self.stre_ii_graph, last_layer=True)
+        item_id_v_t = F.normalize(item_id_v_t)
+
+        item_id_ii = item_id_v_t[:, :self.embedding_dim]
+        gnn_i_v_feat = item_id_v_t[:, self.feat_embed_dim:-self.feat_embed_dim]
+        gnn_i_t_feat = item_id_v_t[:, -self.feat_embed_dim:]
+
+        # User homogeneous relational learning
+        user_v_t = torch.cat((trs_user_v_prefer, trs_user_t_prefer), dim=-1)
+        user_id_v_t = torch.cat((self.user_id_embedding.weight, user_v_t), dim=-1)
+        user_id_v_t = propgt_info(user_id_v_t, self.n_uu_layers, self.stre_uu_graph, last_layer=True)
+
+        user_id_v_t = F.normalize(user_id_v_t)
+        user_id_uu = user_id_v_t[:, :self.embedding_dim]
+        gnn_u_v_prefer = user_id_v_t[:, self.embedding_dim:-self.feat_embed_dim]
+        gnn_u_t_prefer = user_id_v_t[:, -self.feat_embed_dim:]
+
+        # ====================================================================================
+        # Item Feature Attention Integration
+        # ====================================================================================
+        # Item visual features self-attention
+        item_v_feat, _ = self.self_i_attn1(gnn_i_v_feat.unsqueeze(2), gnn_i_v_feat.unsqueeze(2),
+                                           gnn_i_v_feat.unsqueeze(2), need_weights=False)
+        item_v_feat = self.ly_norm(gnn_i_v_feat + item_v_feat.squeeze())
+        item_v_feat = self.prl(item_v_feat)
+
+        # Item text features self-attention
+        item_t_feat, _ = self.self_i_attn2(gnn_i_t_feat.unsqueeze(2), gnn_i_t_feat.unsqueeze(2),
+                                           gnn_i_t_feat.unsqueeze(2), need_weights=False)
+        item_t_feat = self.ly_norm(gnn_i_t_feat + item_t_feat.squeeze())
+        item_t_feat = self.prl(item_t_feat)
+
+        # ---------------------------------------------------------------------------------------
+        # Item text to visual cross-attention
+        i_t2v_feat, _ = self.mutual_i_attn1(item_t_feat.unsqueeze(2), item_v_feat.unsqueeze(2),
+                                            item_v_feat.unsqueeze(2), need_weights=False)
+        item_t2v_feat = self.ly_norm(item_v_feat + i_t2v_feat.squeeze())
+        item_t2v_feat = self.prl(item_t2v_feat)
+
+        # Item visual to text cross-attention
+        i_v2t_feat, _ = self.mutual_i_attn2(item_v_feat.unsqueeze(2), item_t_feat.unsqueeze(2),
+                                            item_t_feat.unsqueeze(2), need_weights=False)
+        item_v2t_feat = self.ly_norm(item_t_feat.squeeze() + i_v2t_feat.squeeze())
+        item_v2t_feat = self.prl(item_v2t_feat)
+
+        user_v_prefer = self.prl(gnn_u_v_prefer)  # (num_items* 64)
+        user_t_prefer = self.prl(gnn_u_t_prefer)
+
+        # ====================================================================================
+        # Heterography Relation Learning
+        # ====================================================================================
+        # Item feature splicing with total attentions
+        item_v_t_feat = torch.cat((item_t2v_feat, item_v2t_feat), dim=-1)  # (num_items* 128)
+        user_v_t_prefer = torch.cat((user_v_prefer, user_t_prefer), dim=-1)  # (num_user* 128)
+        ego_feat_prefer = torch.cat((user_v_t_prefer, item_v_t_feat), dim=0)  # (num_users+num_items）* 128)
+        self.fin_feat_prefer = propgt_info(ego_feat_prefer, self.n_layers, self.norm_adj)
+
+        ego_id_embed = torch.cat((user_id_uu, item_id_ii), dim=0)  # (num_users+num_items）* 64)
+        fin_id_embed = propgt_info(ego_id_embed, self.n_layers, self.norm_adj)
+
+        share_knowldge = self.meta_extra_share(fin_id_embed, self.fin_feat_prefer)  # (num_users+num_items）* 64)
+
+        fin_v = self.prl(self.fin_feat_prefer[:, :self.embedding_dim]) + fin_id_embed
+        fin_t = self.prl(self.fin_feat_prefer[:, self.embedding_dim:]) + fin_id_embed
+        fin_share = self.prl(share_knowldge) + fin_id_embed
+
+        temp_full_feat_prefer = torch.cat((fin_v, fin_t), dim=-1)
+        representation = torch.cat((temp_full_feat_prefer, fin_share), dim=-1)
+
+        return representation
+
+    def loss(self, user_tensor, item_tensor):
+        user_tensor_flatten = user_tensor.view(-1)
+        item_tensor_flatten = item_tensor.view(-1)
+        out = self.forward()
+        user_rep = out[user_tensor_flatten]
+        item_rep = out[item_tensor_flatten]
+
+        score = torch.sum(user_rep * item_rep, dim=1).view(-1, 2)
+        bpr_score = torch.matmul(score, self.cal_bpr)
+        bpr_loss = -torch.mean(nn.LogSigmoid()(bpr_score))
+
+        # Loss of multi-modal feature contrasts
+        i_mul_vt_cl_loss = ssl_loss(self.fin_feat_prefer[:, :self.feat_embed_dim],
+                                    self.fin_feat_prefer[:, -self.feat_embed_dim:], item_tensor_flatten, self.cl_tmp)
+        u_mul_vt_cl_loss = ssl_loss(self.fin_feat_prefer[:, :self.feat_embed_dim],
+                                    self.fin_feat_prefer[:, -self.feat_embed_dim:], user_tensor_flatten, self.cl_tmp)
+        mul_vt_cl_loss = self.cl_loss_weight * (i_mul_vt_cl_loss + u_mul_vt_cl_loss)
+
+        # Modal-unique orthogonal constraint
+        mul_i_diff_loss = cal_diff_loss(self.fin_feat_prefer, user_tensor, self.feat_embed_dim)
+        mul_u_diff_loss = cal_diff_loss(self.fin_feat_prefer, item_tensor, self.feat_embed_dim)
+        mul_diff_loss = self.diff_loss_weight * (mul_i_diff_loss + mul_u_diff_loss)
+
+        reg_loss = 0  # Realized in AdamW
+        total_loss = bpr_loss + reg_loss + mul_vt_cl_loss + mul_diff_loss
+
+        return total_loss, bpr_loss, reg_loss, mul_vt_cl_loss, mul_diff_loss
+
+    def full_sort_predict(self, interaction):
+        user = interaction[0]
+        representation = self.forward()
+        u_reps, i_reps = torch.split(representation, [self.n_users, self.n_items], dim=0)
+        score_mat_ui = torch.matmul(u_reps[user], i_reps.t())
+        return score_mat_ui
+
+    def meta_extra_share(self, id_embed, prefer_or_feat):
+        u_id_embed = id_embed[:self.n_users, :]
+        i_id_embed = id_embed[self.n_users:, :]
+
+        u_v_t = prefer_or_feat[:self.n_users, :]
+        i_v_t = prefer_or_feat[self.n_users:, :]
+
+        # meta-knowlege extraction
+        u_knowldge = self.meta_netu(u_v_t).detach()
+        i_knowldge = self.meta_neti(i_v_t).detach()
+
+        """ Personalized transformation parameter matrix """
+        # Low rank matrix decomposition
+        metau1 = self.mlp_u1(u_knowldge).reshape(-1, self.feat_embed_dim, self.k)  # N_u*d*k    [19445, 64, 3]
+        metau2 = self.mlp_u2(u_knowldge).reshape(-1, self.k, self.feat_embed_dim)  # N_u*k*d   [19445, 3, 64]
+        metai1 = self.mlp_i1(i_knowldge).reshape(-1, self.feat_embed_dim, self.k)  # N_i*d*k   [7050, 64, 3]
+        metai2 = self.mlp_i2(i_knowldge).reshape(-1, self.k, self.feat_embed_dim)  # N_i*k*d   [7050, 3,64]
+        meta_biasu = torch.mean(metau1, dim=0)  # d*k [64, 3]
+        meta_biasu1 = torch.mean(metau2, dim=0)  # k*d    [3,64]
+        meta_biasi = torch.mean(metai1, dim=0)  # [64, 3]
+        meta_biasi1 = torch.mean(metai2, dim=0)  # [3, 64]
+        low_weightu1 = F.softmax(metau1 + meta_biasu, dim=1)
+        low_weightu2 = F.softmax(metau2 + meta_biasu1, dim=1)
+        low_weighti1 = F.softmax(metai1 + meta_biasi, dim=1)
+        low_weighti2 = F.softmax(metai2 + meta_biasi1, dim=1)
+
+        # The learned matrix as the weights of the transformed network Equal to a two-layer linear network;
+        u_middle_knowldge = torch.sum(torch.multiply(u_id_embed.unsqueeze(-1), low_weightu1), dim=1)
+        u_share_knowldge = torch.sum(torch.multiply(u_middle_knowldge.unsqueeze(-1), low_weightu2), dim=1)
+        i_middle_knowldge = torch.sum(torch.multiply(i_id_embed.unsqueeze(-1), low_weighti1), dim=1)
+        i_share_knowldge = torch.sum(torch.multiply(i_middle_knowldge.unsqueeze(-1), low_weighti2), dim=1)
+
+        share_knowldge = torch.cat((u_share_knowldge, i_share_knowldge), dim=0)
+        return share_knowldge
+
+
+class MLP(torch.nn.Module):
+    def __init__(self, input_dim, feature_dim, output_dim, device):
+        super(MLP, self).__init__()
+        self.device = device
+        self.linear_pre = nn.Linear(input_dim, feature_dim, bias=True)
+        self.prl = nn.PReLU().to(self.device)
+        self.linear_out = nn.Linear(feature_dim, output_dim, bias=True)
+
+    def forward(self, data):
+        x = self.prl(self.linear_pre(data))
+        x = self.linear_out(x)
+        x = F.normalize(x, p=2, dim=-1)
+        return x

trainer.py

@@ -0,0 +1,48 @@
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+from torch.nn.utils.clip_grad import clip_grad_norm_
+
+
+# def train(length, epoch, dataloader, model, optimizer, batch_size, writer=None):
+def train(self, epoch_idx):
+    self.model.train()
+    sum_loss = 0.0
+    sum_bpr_loss, sum_reg_loss = 0.0, 0.0
+    sum_diff_loss, sum_mul_vt_cl_loss = 0.0, 0.0
+
+    step = 0.0
+    # bar = tqdm(total=len(self.train_dataset))
+    # num_bar = 0  self_vt_cl_loss, mul_vt_cl_loss
+    for batch_idx, interactions in enumerate(self.train_data):
+        self.optimizer.zero_grad()
+        loss, bpr_loss, reg_loss, mul_vt_cl_loss, diff_loss = self.model.loss(interactions[0],
+                                                                                                 interactions[1])
+        if torch.isnan(loss):
+            self.logger.info('Loss is nan at epoch: {}, batch index: {}. Exiting.'.format(epoch_idx, batch_idx))
+            return loss, torch.tensor(0.0)
+
+        loss.backward()
+        self.optimizer.step() 
+
+        step += 1.0
+        sum_loss += loss
+        sum_bpr_loss += bpr_loss
+        sum_reg_loss += reg_loss
+        sum_mul_vt_cl_loss += mul_vt_cl_loss
+        sum_diff_loss += diff_loss
+    mean_loss = sum_loss / step
+    mean_bpr_loss = sum_bpr_loss / step
+    mean_reg_loss = sum_reg_loss / step
+    mean_mul_vt_cl_loss = sum_mul_vt_cl_loss / step
+    mean_diff_loss = sum_diff_loss / step
+
+    if self.writer is not None:
+        self.writer.add_scalar('loss/train', mean_loss, epoch_idx)
+        self.writer.add_scalar('loss/bpr_loss', mean_bpr_loss, epoch_idx)
+        self.writer.add_scalar('loss/reg_loss', mean_reg_loss, epoch_idx)
+        self.writer.add_scalar('loss/mul_vt_cl_loss', mean_mul_vt_cl_loss, epoch_idx)
+        self.writer.add_scalar('loss/diff_loss', mean_diff_loss, epoch_idx)
+
+    # bar.close()
+    return [mean_loss, mean_bpr_loss, mean_reg_loss,  mean_mul_vt_cl_loss, mean_diff_loss]

utils/configurator.py

@@ -0,0 +1,63 @@
+import os
+import torch
+import multiprocessing
+from utils.helper import init_seed
+
+
+class Config(object):
+    def __init__(self, args):
+        self.model_name = args.model_name
+        self.dataset = args.dataset
+        self.learning_rate = args.l_r
+        self.learning_rate_scheduler = args.learning_rate_scheduler
+        self.embedding_dim = args.embedding_dim
+        self.num_epoch = args.num_epoch
+        self.reg_weight = args.reg_weight
+        self.use_gpu = args.use_gpu
+        self.gpu_id = args.gpu_id
+        self.seed = args.seed
+
+        self.batch_size = args.batch_size
+        self.eval_batch_size = args.eval_batch_size
+        self.topk = args.topk
+        self.valid_metric = args.valid_metric
+        self.metrics = args.metrics
+        self.stopping_step = args.stopping_step
+        self.n_layers = args.num_layer
+
+        self.rank = args.rank
+        self.s_drop = args.s_drop
+        self.m_drop = args.m_drop
+        self.cl_tmp = args.cl_tmp
+        self.item_knn_k = args.item_knn_k
+        self.user_knn_k = args.user_knn_k
+        self.num_user_co = args.user_knn_k  # same as user_knn_k to compute
+        self.num_item_co = args.item_knn_k  # same as item_knn_k to compute
+        self.n_ii_layers = args.n_ii_layers
+        self.n_uu_layers = args.n_uu_layers
+        self.writer = args.with_tensorboard
+        self.uu_co_weight = args.uu_co_weight
+        self.ii_co_weight = args.ii_co_weight
+        self.cl_loss_weight = args.cl_loss_weight
+        self.user_aggr_mode = args.user_aggr_mode
+        self.i_mm_image_weight = args.i_mm_image_weight
+        self.u_mm_image_weight = args.u_mm_image_weight
+        self.diff_loss_weight = args.diff_loss_weight
+
+        self._init_device(args)
+        init_seed(self.seed)
+
+    def _init_device(self, args):
+        if self.use_gpu:
+            os.environ["CUDA_VISIBLE_DEVICES"] = str(self.gpu_id)
+        self.device = torch.device("cuda" if torch.cuda.is_available() and self.use_gpu else "cpu")
+
+        # Ensure that setting up multiple threads does not exceed
+        max_cpu_count = multiprocessing.cpu_count()
+        self.num_workers = max_cpu_count // 2 if max_cpu_count // 2 < args.num_workers else args.num_workers
+
+    def __str__(self):
+        args_info = '\nModel arguments: '
+        args_info += ',\n'.join(["{} = {}".format(arg, value) for arg, value in self.__dict__.items()])
+        args_info += '.\n'
+        return args_info

utils/data_loader.py

@@ -0,0 +1,209 @@
+import math
+from utils.helper import *
+from logging import getLogger
+from collections import defaultdict
+import torch.sparse as tsp
+
+
+class BaseDataset(object):
+    def __init__(self, config):
+        self.config = config
+        self.logger = getLogger("normal")
+        self.device = config.device
+        self.dataset_name = config.dataset
+        self.load_all_data()
+        self.processed_eval_data()
+        self.n_users = len(set(self.train_data[:, 0]) | set(self.valid_data[:, 0]) | set(self.test_data[:, 0]))
+        self.n_items = len(set(self.train_data[:, 1]) | set(self.valid_data[:, 1]) | set(self.test_data[:, 1]))
+        self.train_data[:, 1] += self.n_users  # Ensure that the ids are different
+        self.valid_data[:, 1] += self.n_users  # Ensure that the ids are different
+        self.test_data[:, 1] += self.n_users  # Ensure that the ids are different
+        self.dict_user_items()
+
+    def load_all_data(self):
+        dataset_path = str('./data/' + self.dataset_name)
+        self.train_dataset = np.load(dataset_path + '/train.npy', allow_pickle=True)  # [[1,2,3],[2,3,0]]
+        v_feat = np.load(dataset_path + '/image_feat.npy', allow_pickle=True)
+        self.i_v_feat = torch.from_numpy(v_feat).type(torch.FloatTensor).to(self.device)  # 4096
+        t_feat = np.load(dataset_path + '/text_feat.npy', allow_pickle=True)
+        self.i_t_feat = torch.from_numpy(t_feat).type(torch.FloatTensor).to(self.device)  # 384
+        self.valid_dataset = np.load(dataset_path + '/valid.npy', allow_pickle=True)  # [[1,2,3],[2,3,0]]
+        self.test_dataset = np.load(dataset_path + '/test.npy', allow_pickle=True)  # [[1,2,3],[2,3,0]]
+
+    def processed_eval_data(self):
+        self.train_data = self.train_dataset.transpose(1, 0).copy()
+        self.valid_data = self.valid_dataset.transpose(1, 0).copy()
+        self.test_data = self.test_dataset.transpose(1, 0).copy()
+
+    def load_eval_data(self):
+        return self.valid_data, self.test_data
+
+    def dict_user_items(self):
+        self.dict_train_u_i = update_dict("user", self.train_data, defaultdict(set))
+        self.dict_train_i_u = update_dict("item", self.train_data, defaultdict(set))
+        tmp_dict_u_i = update_dict("user", self.valid_data, self.dict_train_u_i)
+        self.user_items_dict = update_dict("user", self.test_data, tmp_dict_u_i)
+
+        # Process out the most interacted users
+        # (first sort by the number of users interacting with the user, and finally return the user values in descending order)
+        sort_itme_num = sorted(self.dict_train_u_i.items(), key=lambda item: len(item[1]), reverse=True)
+        self.topK_users = [temp[0] for temp in sort_itme_num]
+        self.topK_users_counts = [len(temp[1]) for temp in sort_itme_num]
+        # Process out the most interacted items
+        # (first sort by the number of users interacting with the item, and finally return the item values in descending order)
+        sort_user_num = sorted(self.dict_train_i_u.items(), key=lambda item: len(item[1]), reverse=True)
+        self.topK_items = [temp[0] - self.n_users for temp in sort_user_num]  # Guaranteed from 0
+        self.topK_items_counts = [len(temp[1]) for temp in sort_user_num]
+
+    def sparse_inter_matrix(self, form):
+        return cal_sparse_inter_matrix(self, form)
+
+    def log_info(self, name, interactions, list_u, list_i):
+        info = [self.dataset_name]
+        inter_num = len(interactions)
+        num_u = len(set(list_u))
+        num_i = len(set(list_i))
+        info.extend(['The number of users: {}'.format(num_u),
+                     'Average actions of users: {}'.format(inter_num / num_u)])
+        info.extend(['The number of items: {}'.format(num_i),
+                     'Average actions of items: {}'.format(inter_num / num_i)])
+        info.append('The number of inters: {}'.format(inter_num))
+        sparsity = 1 - inter_num / num_u / num_i
+        info.append('The sparsity of the dataset: {}%'.format(sparsity * 100))
+        self.logger.info('\n====' + name + '====\n' + str('\n'.join(info)))
+
+
+class Load_dataset(BaseDataset):
+    def __init__(self, config):
+        super().__init__(config)
+        self.item_knn_k = config.item_knn_k
+        self.user_knn_k = config.user_knn_k
+        self.i_mm_image_weight = config.i_mm_image_weight
+        self.u_mm_image_weight = config.u_mm_image_weight
+        self.all_set = set(range(self.n_users, self.n_users + self.n_items))
+        # Print statistical information
+        self.log_info("Training", self.train_data, self.train_data[:, 0], self.train_data[:, 1])
+
+        # ***************************************************************************************
+        # Prepare four graphs that will be needed later
+        # (user co-occurrence graph, user interest graph, item co-occurrence graph, item semantic graph)
+
+        # Construct a user co-occurrence matrix with several items of common interaction between all users
+        self.user_co_occ_matrix = load_or_create_matrix(self.logger, "User", " co-occurrence matrix",
+                                                        self.dataset_name, "user_co_occ_matrix", creat_co_occur_matrix,
+                                                        "user", self.train_data, 0, self.n_users)
+        # Construct an item co-occurrence matrix with several users who interact in common between all items
+        self.item_co_occ_matrix = load_or_create_matrix(self.logger, "Item", " co-occurrence matrix",
+                                                        self.dataset_name, "item_co_occ_matrix", creat_co_occur_matrix,
+                                                        "item", self.train_data, self.n_users, self.n_items)
+
+        # Construct a dictionary of user graphs, taking the first 200
+        self.dict_user_co_occ_graph = load_or_create_matrix(self.logger, "User", " co-occurrence dict graph",
+                                                            self.dataset_name, "dict_user_co_occ_graph",
+                                                            creat_dict_graph,
+                                                            self.user_co_occ_matrix, self.n_users)
+        # Construct a dictionary of item graphs, taking the first 200
+        self.dict_item_co_occ_graph = load_or_create_matrix(self.logger, "Item", " co-occurrence dict graph",
+                                                            self.dataset_name, "dict_item_co_occ_graph",
+                                                            creat_dict_graph,
+                                                            self.item_co_occ_matrix, self.n_items)
+        # ***************************************************************************************
+
+        # Get the sparse interaction matrix of the training set
+        sp_inter_m = sparse_mx_to_torch_sparse_tensor(self.sparse_inter_matrix(form='coo')).to(self.device)
+        # Construct a item weight graph
+        if self.i_v_feat is not None:  # 4096
+            # Construct user visual interest similarity graphs
+            self.u_v_interest = tsp.mm(sp_inter_m, self.i_v_feat) / tsp.sum(sp_inter_m, [1]).unsqueeze(dim=1).to_dense()
+            u_v_adj = get_knn_adj_mat(self.u_v_interest, self.user_knn_k, self.device)
+            i_v_adj = get_knn_adj_mat(self.i_v_feat, self.item_knn_k, self.device)
+            self.i_mm_adj = i_v_adj
+            self.u_mm_adj = u_v_adj
+        if self.i_t_feat is not None:  # 384
+            # Construct a user text interest similarity graph
+            self.u_t_interest = tsp.mm(sp_inter_m, self.i_t_feat) / tsp.sum(sp_inter_m, [1]).unsqueeze(dim=1).to_dense()
+            u_t_adj = get_knn_adj_mat(self.u_t_interest, self.user_knn_k, self.device)
+            i_t_adj = get_knn_adj_mat(self.i_t_feat, self.item_knn_k, self.device)
+            self.i_mm_adj = i_t_adj
+            self.u_mm_adj = u_t_adj
+        if self.i_v_feat is not None and self.i_t_feat is not None:
+            self.i_mm_adj = self.i_mm_image_weight * i_v_adj + (1.0 - self.i_mm_image_weight) * i_t_adj
+            self.u_mm_adj = self.u_mm_image_weight * u_v_adj + (1.0 - self.u_mm_image_weight) * u_t_adj
+            del i_t_adj, i_v_adj, u_t_adj, u_v_adj
+            torch.cuda.empty_cache()
+
+    # ***************************************************************************************
+    def __len__(self):
+        return len(self.train_data)
+
+    def __getitem__(self, index):
+        user, pos_item = self.train_data[index]
+        neg_item = random.sample(self.all_set - set(self.user_items_dict[user]), 1)[0]
+        return torch.LongTensor([user, user]), torch.LongTensor([pos_item, neg_item])
+
+
+class Load_eval_dataset(BaseDataset):
+    def __init__(self, v_or_t, config, eval_dataset):
+        super().__init__(config)
+        self.eval_dataset = eval_dataset
+        self.step = config.eval_batch_size
+        self.inter_pr = 0  # Markup of the number of interactions that have been computed
+        self.eval_items_per_u = []
+        self.eval_len_list = []
+        self.train_pos_len_list = []
+        self.eval_u = list(set(eval_dataset[:, 0]))  # Total users index
+        self.t_data = self.train_data
+        self.pos_items_per_u = self.train_items_per_u(self.eval_u)
+        self.evalute_items_per_u(self.eval_u)
+
+        self.s_idx = 0  # eval start index  s_idx=pr
+
+        self.eval_users = len(set(eval_dataset[:, 0]))
+        self.eval_items = len(set(eval_dataset[:, 1]))
+
+        self.n_inters = eval_dataset.shape[0]  # num_interactions  n_inters=pr_end
+        # Print statistical information
+        self.log_info(v_or_t, self.eval_dataset, eval_dataset[:, 0], eval_dataset[:, 1])
+
+    def __len__(self):
+        return math.ceil(self.n_inters / self.step)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.s_idx >= self.n_inters:
+            self.s_idx = 0
+            self.inter_pr = 0
+            raise StopIteration()
+        return self._next_batch_data()
+
+    def _next_batch_data(self):
+        # Calculate the total number of interactions between the training set from A to B
+        inter_cnt = sum(self.train_pos_len_list[self.s_idx: self.s_idx + self.step])
+        batch_users = self.eval_u[self.s_idx: self.s_idx + self.step]
+        batch_mask_matrix = self.pos_items_per_u[:, self.inter_pr: self.inter_pr + inter_cnt].clone()
+        # user_ids to index(Always keep the index value at 0-self.step in preparation for evaluating the mask later on)
+        batch_mask_matrix[0] -= self.s_idx
+        self.inter_pr += inter_cnt  # Update the starting index of the fetch data interaction data
+        self.s_idx += self.step  # Update the starting index of the fetching user before fetching the data interaction data
+
+        return [batch_users, batch_mask_matrix]
+
+    def train_items_per_u(self, eval_users):
+        u_ids, i_ids = list(), list()
+        for i, u in enumerate(eval_users):
+            # Search for the number of items the training set has interacted with in order
+            u_ls = self.t_data[np.where(self.t_data[:, 0] == u), 1][0]
+            i_len = len(u_ls)
+            self.train_pos_len_list.append(i_len)
+            u_ids.extend([i] * i_len)
+            i_ids.extend(u_ls)
+        return torch.tensor([u_ids, i_ids]).type(torch.LongTensor)
+
+    def evalute_items_per_u(self, eval_users):
+        for u in eval_users:
+            u_ls = self.eval_dataset[np.where(self.eval_dataset[:, 0] == u), 1][0]
+            self.eval_len_list.append(len(u_ls))
+            self.eval_items_per_u.append(u_ls - self.n_users)  # Items per user interaction
+        self.eval_len_list = np.asarray(self.eval_len_list)

utils/evaluator.py

@@ -0,0 +1,56 @@
+import torch
+import numpy as np
+from utils.metrics import metrics_dict
+
+
+def evaluate_model(self, epoch, eval_data, t_or_v):
+    self.model.eval()
+    with torch.no_grad():
+        batch_matrix_list = []
+        for batch_idx, batched_data in enumerate(eval_data):
+            scores = self.model.full_sort_predict(batched_data)
+            masked_items = batched_data[1]
+            scores[masked_items[0], masked_items[1] - self.model.n_users] = -1e10  # mask out pos items，restore ori_id
+            _, top_k_index = torch.topk(scores, max(self.topk), dim=-1)  # nusers x topk
+            batch_matrix_list.append(top_k_index)
+
+    pos_items = eval_data.eval_items_per_u
+    pos_len_list = eval_data.eval_len_list
+    top_k_index = torch.cat(batch_matrix_list, dim=0).cpu().numpy()
+    assert len(pos_len_list) == len(top_k_index)
+    bool_rec_matrix = []
+
+    for m, n in zip(pos_items, top_k_index):
+        bool_rec_matrix.append([True if i in m else False for i in n])
+    bool_rec_matrix = np.asarray(bool_rec_matrix)
+
+    # get metrics
+    metric_dict = {}
+    result_list = cal_metrics(self.metrics, pos_len_list, bool_rec_matrix)
+    list_key = []
+    for metric, value in zip(self.metrics, result_list):
+        for k in self.topk:
+            key = '{}@{}'.format(metric, k)
+            list_key.append(key) if k == self.topk[-1] else None
+            metric_dict[key] = round(value[k - 1], 4)  # Round to 4 decimal points
+    valid_score = metric_dict[self.valid_metric] if self.valid_metric else metric_dict['NDCG@20']
+    if self.writer is not None:
+        for idx in list_key:
+            self.writer.add_scalar(t_or_v + "_" + idx, metric_dict[idx], epoch)  # Precision@20,Recall@20,NDCG@20
+        self.writer.add_histogram(t_or_v + '_user_visual_distribution', self.model.user_v_prefer, epoch)
+        self.writer.add_histogram(t_or_v + '_user_textual_distribution', self.model.user_t_prefer, epoch)
+        self.writer.add_embedding(self.model.user_id_embedding.weight, global_step=epoch,
+                                  tag=t_or_v + "user_id_embedding")
+        self.writer.add_embedding(self.model.item_id_embedding.weight, global_step=epoch,
+                                  tag=t_or_v + "item_id_embedding")
+
+    return valid_score, metric_dict
+
+
+def cal_metrics(topk_metrics, pos_len_list, topk_index):
+    result_list = []
+    for metric in topk_metrics:
+        metric_fuc = metrics_dict[metric]
+        result = metric_fuc(topk_index, pos_len_list)
+        result_list.append(result)
+    return np.stack(result_list, axis=0)

utils/helper.py

@@ -0,0 +1,381 @@
+import os
+import torch
+import random
+import datetime
+import numpy as np
+import scipy.sparse as sp
+import matplotlib.pyplot as plt
+import torch.nn.functional as F
+from tqdm import tqdm
+from time import time
+from collections import defaultdict
+from scipy.sparse import coo_matrix
+from torch.nn.functional import cosine_similarity
+
+
+def update_dict(key_ui, dataset, edge_dict):
+    for edge in dataset:
+        user, item = edge
+        edge_dict[user].add(item) if key_ui == "user" else None
+        edge_dict[item].add(user) if key_ui == "item" else None
+    return edge_dict
+
+
+def get_local_time():
+    return datetime.datetime.now().strftime('%b-%d-%Y-%H-%M-%S')
+
+
+def cal_reg_loss(cal_embedding):
+    return (cal_embedding.norm(2).pow(2)) / cal_embedding.size()[0]
+
+
+def cal_cos_loss(user, item):
+    return 1 - cosine_similarity(user, item, dim=-1).mean()
+
+
+def init_seed(seed):
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.backends.cudnn.benchmark = False
+    torch.backends.cudnn.deterministic = True
+
+
+def early_stopping(value, best, cur_step, max_step):
+    stop_flag = False
+    update_flag = False
+
+    if value > best:
+        cur_step = 0
+        best = value
+        update_flag = True
+    else:
+        cur_step += 1
+        if cur_step > max_step:
+            stop_flag = True
+
+    return best, cur_step, stop_flag, update_flag
+
+
+def dict2str(result_dict):
+    result_str = ''
+    for metric, value in result_dict.items():
+        result_str += str(metric) + ': ' + '%.04f' % value + '    '
+    return result_str
+
+
+def res_output(epoch_idx, s_time, e_time, res, t_or_v):
+    _output = '\n epoch %d ' % epoch_idx + t_or_v + 'ing [time: %.2fs], ' % (e_time - s_time)
+    if t_or_v == "train":
+        _output += 'total_loss: {:.4f}, bpr_loss: {:.4f}, reg_loss:{:.4f}, mul_vt_cl_loss: {:.4f}, diff_loss: {:.4f}'.format(
+            res[0], res[1], res[2], res[3], res[4])
+    elif t_or_v == "valid":
+        _output += ' valid result: \n' + dict2str(res)
+    else:
+        _output += ' test result: \n' + dict2str(res)
+    return _output
+
+
+def get_parameter_number(self):
+    self.logger.info(self.model)
+    # Print the number of model parameters
+    total_num = sum(p.numel() for p in self.model.parameters())
+    trainable_num = sum(p.numel() for p in self.model.parameters() if p.requires_grad)
+    self.logger.info('Total parameters: {}, Trainable parameters: {}'.format(total_num, trainable_num))
+
+
+def get_norm_adj_mat(self, interaction_matrix):
+    adj_size = (self.n_users + self.n_items, self.n_users + self.n_items)
+    A = sp.dok_matrix(adj_size, dtype=np.float32)
+    inter_M = interaction_matrix
+    inter_M_t = interaction_matrix.transpose()
+    # {(userID,itemID):1,(userID,itemID):1}
+    data_dict = dict(zip(zip(inter_M.row, inter_M.col + self.n_users), [1] * inter_M.nnz))
+    data_dict.update(dict(zip(zip(inter_M_t.row + self.n_users, inter_M_t.col),
+                              [1] * inter_M_t.nnz)))
+    A._update(data_dict)  # Update to (n_users+n_items)*(n_users+n_items) sparse matrix
+    adj = sparse_mx_to_torch_sparse_tensor(A).to(self.device)
+    return torch_sparse_tensor_norm_adj(adj, adj, adj_size, self.device)
+
+
+def cal_sparse_inter_matrix(self, form='coo'):
+    src = self.train_dataset[0, :]
+    tgt = self.train_dataset[1, :]
+    data = np.ones(len(self.train_dataset.transpose(1, 0)))
+    mat = coo_matrix((data, (src, tgt)), shape=(self.n_users, self.n_items))
+
+    if form == 'coo':
+        return mat
+    elif form == 'csr':
+        return mat.tocsr()
+    else:
+        raise NotImplementedError('sparse matrix format [{}] has not been implemented.'.format(form))
+
+
+def ssl_loss(data1, data2, index, ssl_temp):
+    index = torch.unique(index)
+    embeddings1 = data1[index]
+    embeddings2 = data2[index]
+    norm_embeddings1 = F.normalize(embeddings1, p=2, dim=1)
+    norm_embeddings2 = F.normalize(embeddings2, p=2, dim=1)
+    pos_score_t = torch.sum(torch.mul(norm_embeddings1, norm_embeddings2), dim=1)
+    all_score = torch.mm(norm_embeddings1, norm_embeddings2.T)
+    pos_score = torch.exp(pos_score_t / ssl_temp)
+    all_score = torch.sum(torch.exp(all_score / ssl_temp), dim=1)
+    loss = (-torch.sum(torch.log(pos_score / all_score)) / (len(index)))
+    return loss
+
+
+def cal_diff_loss(feat, ui_index, dim):
+    """
+    :param feat: uv_ut  iv_it (n_users+n_items)*dim*2
+    :param ui_index: user or item index
+    :return: Squared Frobenius Norm Loss
+    """
+    input1 = feat[ui_index[:, 0], :dim]
+    input2 = feat[ui_index[:, 0], dim:]
+
+    # Zero mean
+    input1_mean = torch.mean(input1, dim=0, keepdims=True)
+    input2_mean = torch.mean(input2, dim=0, keepdims=True)
+
+    input1 = input1 - input1_mean
+    input2 = input2 - input2_mean
+
+    input1_l2_norm = torch.norm(input1, p=2, dim=1, keepdim=True).detach()
+    input1_l2 = input1.div(input1_l2_norm.expand_as(input1) + 1e-6)
+
+    input2_l2_norm = torch.norm(input2, p=2, dim=1, keepdim=True).detach()
+    input2_l2 = input2.div(input2_l2_norm.expand_as(input2) + 1e-6)
+
+    loss = torch.mean((input1_l2.t().mm(input2_l2)).pow(2))
+
+    return loss
+
+
+def sele_para(config):
+    res = "\n *****************************************************************"
+    res += "***************************************************************** \n"
+    res += "l_r: " + str(config.learning_rate) + ", reg_w: " + str(config.reg_weight)
+    res += ", n_l: " + str(config.n_layers) + ", emb_dim: " + str(config.embedding_dim)
+    res += ", s_drop : " + str(config.s_drop) + ", m_drop : " + str(config.m_drop)
+    res += ", u_mm_v_w: " + str(config.u_mm_image_weight) + ", i_mm_v_w: " + str(config.i_mm_image_weight)
+    res += ", uu_co_w: " + str(config.uu_co_weight) + ", ii_co_w: " + str(config.ii_co_weight)
+    res += ", u_knn_k: " + str(config.user_knn_k) + ", i_knn_k: " + str(config.item_knn_k)
+    res += ", n_uu_layers: " + str(config.n_uu_layers) + ", n_ii_layers: " + str(config.n_ii_layers)
+    res += ", cl_temp: " + str(config.cl_tmp) + ", rank: " + str(config.rank)
+    res += ", cl_loss_w: " + str(config.cl_loss_weight) + ", diff_loss_w: " + str(config.diff_loss_weight)
+    return res + "\n"
+
+
+def update_result(self, test_result):
+    update_output = ' 🏃 🏃 🏃 🏆🏆🏆 🏃 🏃 🏃      ' + self.model_name + "_" + self.dataset_name + '--Best validation results updated!!!'
+    self.logger.info(update_output)
+    self.best_test_upon_valid = test_result
+
+
+def stop_log(self, epoch_idx, run_start_time):
+    stop_output = 'Finished training, best eval result in epoch %d' % (epoch_idx - self.cur_step)
+    stop_output += "\n [total time: %.2fmins], " % ((time() - run_start_time) / 60)
+    stop_output += '\n ' + str(self.config.dataset) + '  key parameter: ' + sele_para(self.config)
+    stop_output += 'test result: \n' + dict2str(self.best_test_upon_valid)
+    self.logger.info(stop_output)
+
+
+def plot_curve(self, show=True, save_path=None):
+    epochs = list(self.train_loss_dict.keys())
+    epochs.sort()
+    train_loss_values = [float(self.train_loss_dict[epoch]) for epoch in epochs]
+    valid_result_values = [float(self.best_valid_result[epoch]) for epoch in epochs]
+    plt.plot(epochs, train_loss_values, label='train', color='red')
+    plt.plot(epochs, valid_result_values, label='valid', color='black')
+    plt.xticks(epochs)
+    plt.xlabel('Epoch')
+    plt.ylabel('Loss')
+    plt.title('Training loss and Validing result curves')
+    if show:
+        plt.show()
+    if save_path:
+        plt.savefig(save_path)
+
+
+# Generated user or item co-occurrence matrix
+def creat_co_occur_matrix(type_ui, all_edge, start_ui, num_ui):
+    """
+    :param type_ui: Types of created co-occurrence graphs, {user, item}
+    :param all_edge: train data np.array([[0, 6], [0, 11], [0, 8], [1, 7]])
+    :param start_ui: Minimum or starting user or item index
+    :param num_ui:Total number of users or items
+    :return:Generated user or item co-occurrence matrix
+    """
+    edge_dict = defaultdict(set)
+
+    for edge in all_edge:
+        user, item = edge
+        edge_dict[user].add(item) if type_ui == "user" else None
+        edge_dict[item].add(user) if type_ui == "item" else None
+
+    co_graph_matrix = torch.zeros(num_ui, num_ui)
+    key_list = sorted(list(edge_dict.keys()))
+    bar = tqdm(total=len(key_list))
+    for head in range(len(key_list)):
+        bar.update(1)
+        for rear in range(head + 1, len(key_list)):
+            head_key = key_list[head]
+            rear_key = key_list[rear]
+            ui_head = edge_dict[head_key]
+            ui_rear = edge_dict[rear_key]
+            inter_len = len(ui_head.intersection(ui_rear))
+            if inter_len > 0:
+                co_graph_matrix[head_key - start_ui][rear_key - start_ui] = inter_len
+                co_graph_matrix[rear_key - start_ui][head_key - start_ui] = inter_len
+    bar.close()
+    return co_graph_matrix
+
+
+def creat_dict_graph(co_graph_matrix, num_ui):
+    dict_graph = {}
+    for i in tqdm(range(num_ui)):
+        num_co_ui = len(torch.nonzero(co_graph_matrix[i]))
+
+        if num_co_ui <= 200:
+            topk_ui = torch.topk(co_graph_matrix[i], num_co_ui)
+            edge_list_i = topk_ui.indices.tolist()
+            edge_list_j = topk_ui.values.tolist()
+            edge_list = [edge_list_i, edge_list_j]
+            dict_graph[i] = edge_list
+        else:
+            topk_ui = torch.topk(co_graph_matrix[i], 200)
+            edge_list_i = topk_ui.indices.tolist()
+            edge_list_j = topk_ui.values.tolist()
+            edge_list = [edge_list_i, edge_list_j]
+            dict_graph[i] = edge_list
+    return dict_graph
+
+
+# Calculate item similarity, build similarity matrix
+def get_knn_adj_mat(mm_embeddings, knn_k, device):
+    # Standardize and calculate similarity
+    context_norm = F.normalize(mm_embeddings, dim=1)
+    final_sim = torch.mm(context_norm, context_norm.transpose(1, 0)).cpu()
+    sim_value, knn_ind = torch.topk(final_sim, knn_k, dim=-1)
+    adj_size = final_sim.size()
+    # Construct sparse adjacency matrices
+    indices0 = torch.arange(knn_ind.shape[0])
+    indices0 = torch.unsqueeze(indices0, 1)
+    indices0 = indices0.expand(-1, knn_k)
+    indices = torch.stack((torch.flatten(indices0), torch.flatten(knn_ind)), 0)
+    sim_adj = torch.sparse.FloatTensor(indices, sim_value.flatten(), adj_size).to(device)
+    degree_adj = torch.sparse.FloatTensor(indices, torch.ones(indices.shape[1]), adj_size)
+    return torch_sparse_tensor_norm_adj(sim_adj, degree_adj, adj_size, device)
+
+
+def torch_sparse_tensor_norm_adj(sim_adj, degree_adj, adj_size, device):
+    """
+    :param sim_adj: Tensor adjacency matrix (The value of 0 or 1 is degree normalised; the value of [0,1] is similarity normalised)
+    :param degree_adj: Tensor adjacency matrix (The value of 0 or 1 is degree normalised; the value of [0,1] is similarity normalised)
+    :param adj_size: Tensor size of adjacency matrix
+    :param device: cpu or gpu
+    :return: Laplace degree normalised adjacency matrix
+    """
+    # norm adj matrix,add epsilon to avoid Devide by zero Warning
+    row_sum = 1e-7 + torch.sparse.sum(degree_adj, -1).to_dense()
+    r_inv_sqrt = torch.pow(row_sum, -0.5)
+
+    col = torch.arange(adj_size[0])
+    row = torch.arange(adj_size[1])
+    sp_degree = torch.sparse.FloatTensor(torch.stack((col, row)).to(device), r_inv_sqrt.to(device))
+    return torch.spmm((torch.spmm(sp_degree, sim_adj)), sp_degree)
+
+
+def sparse_mx_to_torch_sparse_tensor(sparse_mx):
+    """Convert a scipy sparse matrix to a torch sparse tensor."""
+    if type(sparse_mx) != sp.coo_matrix:
+        sparse_mx = sparse_mx.tocoo().astype(np.float32)
+    indices = torch.from_numpy(
+        np.vstack((sparse_mx.row, sparse_mx.col)).astype(np.int64))
+    values = torch.from_numpy(sparse_mx.data).float()
+    shape = torch.Size(sparse_mx.shape)
+    return torch.sparse.FloatTensor(indices, values, shape)
+
+
+def topk_sample(n_ui, dict_graph, k, topK_ui, topK_ui_counts, aggr_mode, device):
+    ui_graph_index = []
+    user_weight_matrix = torch.zeros(len(dict_graph), k)
+    for i in range(len(dict_graph)):
+
+        if len(dict_graph[i][0]) < k:
+            if len(dict_graph[i][0]) != 0:
+
+                ui_graph_sample = dict_graph[i][0][:k]
+                ui_graph_weight = dict_graph[i][1][:k]
+                rand_index = np.random.randint(0, len(ui_graph_sample), size=k - len(ui_graph_sample))
+                ui_graph_sample += np.array(ui_graph_sample)[rand_index].tolist()
+                ui_graph_weight += np.array(ui_graph_weight)[rand_index].tolist()
+                ui_graph_index.append(ui_graph_sample)
+            else:
+                ui_graph_index.append(topK_ui[:k])
+                ui_graph_weight = (np.array(topK_ui_counts[:k]) / sum(topK_ui_counts[:k])).tolist()
+        else:
+            ui_graph_sample = dict_graph[i][0][:k]
+            ui_graph_weight = dict_graph[i][1][:k]
+            ui_graph_index.append(ui_graph_sample)
+
+        if aggr_mode == 'softmax':
+            user_weight_matrix[i] = F.softmax(torch.tensor(ui_graph_weight), dim=0)  # softmax
+        elif aggr_mode == 'mean':
+            user_weight_matrix[i] = torch.ones(k) / k  # mean
+
+    tmp_all_row = []
+    tmp_all_col = []
+    for i in range(n_ui):
+        row = torch.zeros(1, k) + i
+        tmp_all_row += row.flatten()
+        tmp_all_col += ui_graph_index[i]
+    tmp_all_row = torch.tensor(tmp_all_row).to(torch.int32)
+    tmp_all_col = torch.tensor(tmp_all_col).to(torch.int32)
+    values = user_weight_matrix.flatten().to(device)
+    indices = torch.stack((tmp_all_row, tmp_all_col)).to(device)
+    return torch.sparse_coo_tensor(indices, values, (n_ui, n_ui))
+
+
+def load_or_create_matrix(logger, matrix_type, des, dataset_name, file_name, create_function, *create_args):
+    """
+    Load a matrix from file if it exists; otherwise, create and save it.
+    :param logger: logger
+    :param matrix_type: str, type of the matrix (e.g., 'user', 'item').
+    :param des: str name of the matrix
+    :param dataset_name: str, dataset name used to define the file path.
+    :param file_name: str, name of the file to save or load the matrix.
+    :param create_function: function, function to call for matrix creation.
+    :param create_args: tuple, additional arguments for the create function.
+    :return: The loaded or created matrix.
+    """
+    file_path = os.path.join("data", dataset_name, file_name + ".pt")
+
+    if os.path.exists(file_path):
+        matrix = torch.load(file_path)
+        logger.info(f"{matrix_type.capitalize()} " + des + " has been loaded!")
+    else:
+        logger.info(f"{matrix_type.capitalize()} " + des + " does not exist, creating!")
+        matrix = create_function(*create_args)
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        torch.save(matrix, file_path)
+        logger.info(f"{matrix_type.capitalize()} " + des + " has been created and saved!")
+    return matrix
+
+
+def propgt_info(ego_feat, n_layers, sp_mat, last_layer=False):
+    all_feat = [ego_feat]
+    for _ in range(n_layers):
+        ego_feat = torch.sparse.mm(sp_mat, ego_feat)
+        all_feat += [ego_feat]
+    if last_layer:
+        return ego_feat
+
+    all_feat = torch.stack(all_feat, dim=1)
+    all_feat = all_feat.mean(dim=1, keepdim=False)
+    return all_feat

utils/logger.py

@@ -0,0 +1,46 @@
+import logging
+import os
+
+
+def init_logger(config):
+    """
+    A logger that can show a message on standard output and write it into the
+    file named `filename` simultaneously.
+    All the message that you want to log MUST be str.
+
+    Args:
+        config (Config): An instance object of Config, used to record parameter information.
+    """
+    LOGROOT = './log/'
+    dir_name = os.path.dirname(LOGROOT)
+    if not os.path.exists(dir_name):
+        os.makedirs(dir_name)
+
+    logger = logging.getLogger("normal")
+
+    name_ = "{}-{}-lr_{}-rww_{}-nl_{}-sdp_{}-mdp_{}-clt_{}-diffw_{}-semw_{}.log"
+    logfilename = name_.format(config.model_name, config.dataset, config.learning_rate,
+                               config.reg_weight, config.n_layers,
+                               config.s_drop, config.m_drop, config.cl_tmp,
+                               config.diff_loss_weight, config.cl_loss_weight)
+    logfilepath = os.path.join(LOGROOT, logfilename)
+    filefmt = "%(asctime)-15s %(message)s"
+    filedatefmt = "%a %d %b %Y %H:%M:%S"
+
+    fileformatter = logging.Formatter(filefmt, filedatefmt)
+
+    sfmt = u"%(asctime)-15s %(message)s"
+    sdatefmt = "%d %b %H:%M"
+    sformatter = logging.Formatter(sfmt, sdatefmt)
+
+    fh = logging.FileHandler(logfilepath, 'w', 'utf-8')
+    fh.setFormatter(fileformatter)
+
+    sh = logging.StreamHandler()
+    sh.setFormatter(sformatter)
+
+    logger.setLevel(logging.INFO)
+    logger.handlers = []
+    logger.addHandler(fh)
+    logger.addHandler(sh)
+    return logger

utils/metrics.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+
+def cal_recall(pos_index, pos_len):
+    rec_ret = np.cumsum(pos_index, axis=1) / pos_len.reshape(-1, 1)
+    return rec_ret.mean(axis=0)
+
+
+def cal_ndcg(pos_index, pos_len):
+    len_rank = np.full_like(pos_len, pos_index.shape[1])
+    idcg_len = np.where(pos_len > len_rank, len_rank, pos_len)
+
+    iranks = np.zeros_like(pos_index, dtype=float)
+    iranks[:, :] = np.arange(1, pos_index.shape[1] + 1)
+    idcg = np.cumsum(1.0 / np.log2(iranks + 1), axis=1)
+    for row, idx in enumerate(idcg_len):
+        idcg[row, idx:] = idcg[row, idx - 1]
+
+    ranks = np.zeros_like(pos_index, dtype=float)
+    ranks[:, :] = np.arange(1, pos_index.shape[1] + 1)
+    dcg = 1.0 / np.log2(ranks + 1)
+    dcg = np.cumsum(np.where(pos_index, dcg, 0), axis=1)
+
+    result = dcg / idcg
+    return result.mean(axis=0)
+
+
+def cal_map(pos_index, pos_len):
+    pre = pos_index.cumsum(axis=1) / np.arange(1, pos_index.shape[1] + 1)
+    sum_pre = np.cumsum(pre * pos_index.astype(float), axis=1)
+    len_rank = np.full_like(pos_len, pos_index.shape[1])
+    actual_len = np.where(pos_len > len_rank, len_rank, pos_len)
+    result = np.zeros_like(pos_index, dtype=float)
+    for row, lens in enumerate(actual_len):
+        ranges = np.arange(1, pos_index.shape[1] + 1)
+        ranges[lens:] = ranges[lens - 1]
+        result[row] = sum_pre[row] / ranges
+    return result.mean(axis=0)
+
+
+def cal_precision(pos_index, pos_len):
+    rec_ret = pos_index.cumsum(axis=1) / np.arange(1, pos_index.shape[1] + 1)
+    return rec_ret.mean(axis=0)
+
+
+"""Function name and function mapper.
+Useful when we have to serialize evaluation metric names
+and call the functions based on deserialized names
+"""
+metrics_dict = {
+    'Precision': cal_precision,
+    'Recall': cal_recall,
+    'NDCG': cal_ndcg,
+    'MAP': cal_map,
+}

utils/parser.py

@@ -0,0 +1,54 @@
+import argparse
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run REARM.")
+    parser.add_argument('--seed', type=int, default=2025, help='Seed init.')
+    parser.add_argument('--model_name', default='REARM', help='Model name.')
+    parser.add_argument('--use_gpu', type=bool, default=True, help='enable CUDA training.')
+    parser.add_argument('--gpu_id', type=int, default=0, help='The model of the device running the program')
+    parser.add_argument('--dataset', nargs='?', default='baby',
+                        help='Choose a dataset from {baby, sports, clothing}')
+    parser.add_argument('--batch_size', type=int, default=2048, help='Batch size.')
+    parser.add_argument('--eval_batch_size', type=int, default=8192, help='The data size of batch evaluation')
+    parser.add_argument('--metrics', type=list, default=["Precision", "Recall", "NDCG"],
+                        help='Choose some from {"Precision", "Recall", "NDCG", "MAP"}')
+    parser.add_argument('--topk', type=list, default=[10, 20], help='Metrics scale')
+    parser.add_argument('--embedding_dim', type=int, default=64, help='Latent dimension 64.')
+    parser.add_argument('--num_epoch', type=int, default=2000, help='Epoch number.')
+    parser.add_argument('--num_workers', type=int, default=8, help='Workers number.')
+    parser.add_argument('--stopping_step', type=int, default=20, help='early stopping strategy.')
+    parser.add_argument('--valid_metric', type=str, default="Recall@20", help='valid metric')
+    parser.add_argument('--with_tensorboard', action='store_true', default=False, help='with tensorboard analysis ')
+
+    parser.add_argument('--l_r', type=float, default=5e-5, help='Learning rate.')
+    parser.add_argument('--learning_rate_scheduler', type=list, default=[1.0, 50], help='learning rate scheduler.')
+    parser.add_argument('--reg_weight', type=float, default=5e-4, help='regularization weight.')
+    parser.add_argument('--num_layer', type=int, default=4, help='Layer number.')
+    parser.add_argument('--s_drop', type=float, default=0.4, help='self_attention_dropout.')
+    parser.add_argument('--m_drop', type=float, default=0.6, help='mutual_attention_dropout.')
+    parser.add_argument('--cl_tmp', type=float, default=0.6, help='Contrast learning temperature coefficient')
+    parser.add_argument('--cl_loss_weight', type=float, default=5e-6, help='contrast loss weight.')
+    parser.add_argument('--diff_loss_weight', type=float, default=1e-4, help='Structure contrast loss weight.')
+    parser.add_argument('--user_knn_k', type=int, default=40,
+                        help='Select the 10 users most similar to the target users to build the users graph')
+    parser.add_argument('--item_knn_k', type=int, default=10,
+                        help='Select the 10 items most similar to the target item to build the item graph')
+
+    parser.add_argument('--i_mm_image_weight', type=float, default=0,
+                        help='The proportion of visual feat in item graph.')
+    parser.add_argument('--u_mm_image_weight', type=float, default=0.2,
+                        help='The proportion of visual feat in user graph.')
+    parser.add_argument('--n_ii_layers', type=int, default=1,
+                        help='Number of layers of item feature propagation in the item graph')
+    parser.add_argument('--n_uu_layers', type=int, default=1,
+                        help='Number of layers of user feature propagation in the user graph')
+    parser.add_argument('--user_aggr_mode', type=str, default='softmax',
+                        help='Choose a modedataset from {softmax, mean}')
+
+    parser.add_argument('--rank', type=int, default=3, help='the dimension of low rank matrix decomposition')
+    parser.add_argument('--uu_co_weight', type=float, default=0.4,
+                        help='the proportion of user co-occurrence graphs to user homographs')
+    parser.add_argument('--ii_co_weight', type=float, default=0.2,
+                        help='the proportion of item co-occurrence graphs to user homographs')
+    return parser.parse_args()