def __init__(self, config, dataset): super(SRGNN, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] self.step = config['step'] self.device = config['device'] self.loss_type = config['loss_type'] # define layers and loss # item embedding self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) # define layers and loss self.gnn = GNN(self.embedding_size, self.step) self.linear_one = nn.Linear(self.embedding_size, self.embedding_size, bias=True) self.linear_two = nn.Linear(self.embedding_size, self.embedding_size, bias=True) self.linear_three = nn.Linear(self.embedding_size, 1, bias=False) self.linear_transform = nn.Linear(self.embedding_size * 2, self.embedding_size, bias=True) if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError("Make sure 'loss_type' in ['BPR', 'CE']!") # parameters initialization self._reset_parameters()
def __init__(self, config, dataset): super(NARM, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] self.hidden_size = config['hidden_size'] self.n_layers = config['n_layers'] self.dropout_probs = config['dropout_probs'] self.device = config['device'] # define layers and loss self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.emb_dropout = nn.Dropout(self.dropout_probs[0]) self.gru = nn.GRU(self.embedding_size, self.hidden_size, self.n_layers, bias=False, batch_first=True) self.a_1 = nn.Linear(self.hidden_size, self.hidden_size, bias=False) self.a_2 = nn.Linear(self.hidden_size, self.hidden_size, bias=False) self.v_t = nn.Linear(self.hidden_size, 1, bias=False) self.ct_dropout = nn.Dropout(self.dropout_probs[1]) self.b = nn.Linear(2*self.hidden_size, self.embedding_size, bias=False) self.loss_type = config['loss_type'] if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError("Make sure 'loss_type' in ['BPR', 'CE']!") # parameters initialization self.apply(self._init_weights)
def __init__(self, config, dataset): super(TransRecF, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] # load dataset info self.n_users = dataset.user_num self.user_embedding = nn.Embedding(self.n_users, self.embedding_size, padding_idx=0) self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.bias = nn.Embedding(self.n_items, 1, padding_idx=0) # Beta popularity bias self.T = nn.Parameter(torch.zeros(self.embedding_size)) # average user representation 'global' self.selected_features = config['selected_features'] self.hidden_dropout_prob = config['hidden_dropout_prob'] self.pooling_mode = config['pooling_mode'] self.dropout = nn.Dropout(self.hidden_dropout_prob) self.layer_norm_eps = config['layer_norm_eps'] self.device = config['device'] self.num_feature_field = len(config['selected_features']) self.bpr_loss = BPRLoss() self.emb_loss = EmbLoss() self.reg_loss = RegLoss() self.feature_embed_layer = FeatureSeqEmbLayer( dataset, self.embedding_size, self.selected_features, self.pooling_mode, self.device ) self.LayerNorm = nn.LayerNorm(self.embedding_size, eps=self.layer_norm_eps) self.concat_layer = nn.Linear(self.embedding_size * (1 + self.num_feature_field), self.embedding_size) # parameters initialization self.apply(xavier_normal_initialization)
def __init__(self, config, dataset): super(GRU4Rec, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] self.hidden_size = config['hidden_size'] self.loss_type = config['loss_type'] self.num_layers = config['num_layers'] self.dropout_prob = config['dropout_prob'] # define layers and loss self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.emb_dropout = nn.Dropout(self.dropout_prob) self.gru_layers = nn.GRU( input_size=self.embedding_size, hidden_size=self.hidden_size, num_layers=self.num_layers, bias=False, batch_first=True, ) self.dense = nn.Linear(self.hidden_size, self.embedding_size) if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError("Make sure 'loss_type' in ['BPR', 'CE']!") # parameters initialization self.apply(self._init_weights)
def __init__(self, config, dataset): super(FISMBPR, self).__init__(config, dataset) # load dataset info # get all users' history interaction information.the history item # matrix is padding by the maximum number of a user's interactions self.history_item_matrix, self.history_lens, self.mask_mat = self.get_history_info( dataset) # load parameters info self.embedding_size = config['embedding_size'] self.reg_weights = config['reg_weights'] self.alpha = config['alpha'] self.split_to = config['split_to'] # split the too large dataset into the specified pieces if self.split_to > 0: self.group = torch.chunk( torch.arange(self.n_items).to(self.device), self.split_to) # define layers and loss # construct source and destination item embedding matrix self.item_src_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.item_dst_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.user_bias = nn.Parameter(torch.zeros(self.n_users)) self.item_bias = nn.Parameter(torch.zeros(self.n_items)) self.bpr_loss = BPRLoss() # parameters initialization self.apply(self._init_weights)
def __init__(self, config, dataset): super(LightGCN, self).__init__(config, dataset) # load dataset info self.interaction_matrix = dataset.inter_matrix(form='coo').astype( np.float32) # load parameters info self.latent_dim = config[ 'embedding_size'] # int type:the embedding size of lightGCN self.n_layers = config[ 'n_layers'] # int type:the layer num of lightGCN self.reg_weight = config[ 'reg_weight'] # float32 type: the weight decay for l2 normalizaton # define layers and loss self.user_embedding = torch.nn.Embedding(num_embeddings=self.n_users, embedding_dim=self.latent_dim) self.item_embedding = torch.nn.Embedding(num_embeddings=self.n_items, embedding_dim=self.latent_dim) self.mf_loss = BPRLoss() self.reg_loss = EmbLoss() # storage variables for full sort evaluation acceleration self.restore_user_e = None self.restore_item_e = None # generate intermediate data self.norm_adj_matrix = self.get_norm_adj_mat().to(self.device) # parameters initialization self.apply(xavier_uniform_initialization)
def __init__(self, config, dataset): super(HRM, self).__init__(config, dataset) # load the dataset information self.n_user = dataset.num(self.USER_ID) self.device = config["device"] # load the parameters information self.embedding_size = config["embedding_size"] self.pooling_type_layer_1 = config["pooling_type_layer_1"] self.pooling_type_layer_2 = config["pooling_type_layer_2"] self.high_order = config["high_order"] assert self.high_order <= self.max_seq_length, "high_order can't longer than the max_seq_length" self.reg_weight = config["reg_weight"] self.dropout_prob = config["dropout_prob"] # define the layers and loss type self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.user_embedding = nn.Embedding(self.n_user, self.embedding_size) self.dropout = nn.Dropout(self.dropout_prob) self.loss_type = config['loss_type'] if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # init the parameters of the model self.apply(self._init_weights)
def __init__(self, config, dataset): super(NPE, self).__init__(config, dataset) # load the dataset information self.n_user = dataset.num(self.USER_ID) self.device = config["device"] # load the parameters information self.embedding_size = config["embedding_size"] self.reg_weight = config['reg_weight'] # define layers and loss type self.user_embedding = nn.Embedding(self.n_user, self.embedding_size) self.item_embedding = nn.Embedding(self.n_items, self.embedding_size) self.embedding_seq_item = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.relu = nn.ReLU() self.loss_type = config['loss_type'] if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # init the parameters of the module self.apply(self._init_weights)
def __init__(self, config, dataset): super(STAMP, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] # define layers and loss self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.w1 = nn.Linear(self.embedding_size, self.embedding_size, bias=False) self.w2 = nn.Linear(self.embedding_size, self.embedding_size, bias=False) self.w3 = nn.Linear(self.embedding_size, self.embedding_size, bias=False) self.w0 = nn.Linear(self.embedding_size, 1, bias=False) self.b_a = nn.Parameter(torch.zeros(self.embedding_size), requires_grad=True) self.mlp_a = nn.Linear(self.embedding_size, self.embedding_size, bias=True) self.mlp_b = nn.Linear(self.embedding_size, self.embedding_size, bias=True) self.sigmoid = nn.Sigmoid() self.tanh = nn.Tanh() self.loss_type = config['loss_type'] if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError("Make sure 'loss_type' in ['BPR', 'CE']!") # # parameters initialization self.apply(self._init_weights)
def __init__(self, config, dataset): super(TransRec, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] # load dataset info self.n_users = dataset.user_num self.user_embedding = nn.Embedding(self.n_users, self.embedding_size, padding_idx=0) self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.bias = nn.Embedding(self.n_items, 1, padding_idx=0) # Beta popularity bias self.T = nn.Parameter(torch.zeros( self.embedding_size)) # average user representation 'global' self.bpr_loss = BPRLoss() self.emb_loss = EmbLoss() self.reg_loss = RegLoss() # parameters initialization self.apply(xavier_normal_initialization)
def __init__(self, config, dataset): super(FOSSIL, self).__init__(config, dataset) # load the dataset information self.n_users = dataset.num(self.USER_ID) self.device = config['device'] # load the parameters self.embedding_size = config["embedding_size"] self.order_len = config["order_len"] self.reg_weight = config["reg_weight"] self.alpha = config["alpha"] # define the layers and loss type self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.user_lamda = nn.Embedding(self.n_users, self.order_len) self.lamda = nn.Parameter(torch.zeros(self.order_len)).to(self.device) self.loss_type = config['loss_type'] if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # init the parameters of the model self.apply(self.init_weights)
def __init__(self, config, dataset): super(SpectralCF, self).__init__(config, dataset) # load parameters info self.n_layers = config['n_layers'] self.emb_dim = config['embedding_size'] self.reg_weight = config['reg_weight'] # generate intermediate data # "A_hat = I + L" is equivalent to "A_hat = U U^T + U \Lambda U^T" self.interaction_matrix = dataset.inter_matrix( form='coo').astype(np.float32) I = self.get_eye_mat(self.n_items + self.n_users) L = self.get_laplacian_matrix() A_hat = I + L self.A_hat = A_hat.to(self.device) # define layers and loss self.user_embedding = torch.nn.Embedding( num_embeddings=self.n_users, embedding_dim=self.emb_dim) self.item_embedding = torch.nn.Embedding( num_embeddings=self.n_items, embedding_dim=self.emb_dim) self.filters = torch.nn.ParameterList( [torch.nn.Parameter(torch.normal(mean=0.01, std=0.02, size=(self.emb_dim, self.emb_dim)).to(self.device), requires_grad=True) for _ in range(self.n_layers)]) self.sigmoid = torch.nn.Sigmoid() self.mf_loss = BPRLoss() self.reg_loss = EmbLoss() self.restore_user_e = None self.restore_item_e = None # parameters initialization self.apply(xavier_uniform_initialization)
def __init__(self, config, dataset): super(NGCF, self).__init__(config, dataset) # load dataset info self.interaction_matrix = dataset.inter_matrix(form='coo').astype( np.float32) # load parameters info self.embedding_size = config['embedding_size'] self.hidden_size_list = config['hidden_size_list'] self.hidden_size_list = [self.embedding_size] + self.hidden_size_list self.node_dropout = config['node_dropout'] self.message_dropout = config['message_dropout'] self.reg_weight = config['reg_weight'] # define layers and loss self.user_embedding = nn.Embedding(self.n_users, self.embedding_size) self.item_embedding = nn.Embedding(self.n_items, self.embedding_size) self.GNNlayers = torch.nn.ModuleList() for idx, (input_size, output_size) in enumerate( zip(self.hidden_size_list[:-1], self.hidden_size_list[1:])): self.GNNlayers.append(BiGNNLayer(input_size, output_size)) self.mf_loss = BPRLoss() self.reg_loss = EmbLoss() # storage variables for full sort evaluation acceleration self.restore_user_e = None self.restore_item_e = None # generate intermediate data self.norm_adj_matrix = self.get_norm_adj_mat().to(self.device) self.eye_matrix = self.get_eye_mat().to(self.device) # parameters initialization self.apply(xavier_normal_initialization)
def __init__(self, config, dataset): super(KSR, self).__init__(config, dataset) # load dataset info self.ENTITY_ID = config['ENTITY_ID_FIELD'] self.RELATION_ID = config['RELATION_ID_FIELD'] self.n_entities = dataset.num(self.ENTITY_ID) self.n_relations = dataset.num(self.RELATION_ID) - 1 self.entity_embedding_matrix = dataset.get_preload_weight('ent_id') self.relation_embedding_matrix = dataset.get_preload_weight('rel_id') # load parameters info self.embedding_size = config['embedding_size'] self.hidden_size = config['hidden_size'] self.loss_type = config['loss_type'] self.num_layers = config['num_layers'] self.dropout_prob = config['dropout_prob'] self.gamma = config['gamma'] # Scaling factor self.device = config['device'] self.loss_type = config['loss_type'] self.freeze_kg = config['freeze_kg'] # define layers and loss self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.entity_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.entity_embedding.weight.requires_grad = not self.freeze_kg self.emb_dropout = nn.Dropout(self.dropout_prob) self.gru_layers = nn.GRU( input_size=self.embedding_size, hidden_size=self.hidden_size, num_layers=self.num_layers, bias=False, batch_first=True, ) self.dense = nn.Linear(self.hidden_size, self.embedding_size) self.dense_layer_u = nn.Linear(self.embedding_size * 2, self.embedding_size) self.dense_layer_i = nn.Linear(self.embedding_size * 2, self.embedding_size) if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # parameters initialization self.apply(self._init_weights) self.entity_embedding.weight.data.copy_( torch.from_numpy(self.entity_embedding_matrix[:self.n_items])) self.relation_Matrix = torch.from_numpy( self.relation_embedding_matrix[:self.n_relations]).to( self.device) # [R H]
def __init__(self, config, dataset): super(DGCF, self).__init__(config, dataset) # load dataset info self.interaction_matrix = dataset.inter_matrix(form='coo').astype( np.float32) # load parameters info self.embedding_size = config['embedding_size'] self.n_factors = config['n_factors'] self.n_iterations = config['n_iterations'] self.n_layers = config['n_layers'] self.reg_weight = config['reg_weight'] self.cor_weight = config['cor_weight'] n_batch = dataset.dataset.inter_num // self.batch_size + 1 self.cor_batch_size = int( max(self.n_users / n_batch, self.n_items / n_batch)) # ensure embedding can be divided into <n_factors> intent assert self.embedding_size % self.n_factors == 0 # generate intermediate data row = self.interaction_matrix.row.tolist() col = self.interaction_matrix.col.tolist() col = [item_index + self.n_users for item_index in col] all_h_list = row + col # row.extend(col) all_t_list = col + row # col.extend(row) num_edge = len(all_h_list) edge_ids = range(num_edge) self.all_h_list = torch.LongTensor(all_h_list).to(self.device) self.all_t_list = torch.LongTensor(all_t_list).to(self.device) self.edge2head = torch.LongTensor([all_h_list, edge_ids]).to(self.device) self.head2edge = torch.LongTensor([edge_ids, all_h_list]).to(self.device) self.tail2edge = torch.LongTensor([edge_ids, all_t_list]).to(self.device) val_one = torch.ones_like(self.all_h_list).float().to(self.device) num_node = self.n_users + self.n_items self.edge2head_mat = self._build_sparse_tensor(self.edge2head, val_one, (num_node, num_edge)) self.head2edge_mat = self._build_sparse_tensor(self.head2edge, val_one, (num_edge, num_node)) self.tail2edge_mat = self._build_sparse_tensor(self.tail2edge, val_one, (num_edge, num_node)) self.num_edge = num_edge self.num_node = num_node # define layers and loss self.user_embedding = nn.Embedding(self.n_users, self.embedding_size) self.item_embedding = nn.Embedding(self.n_items, self.embedding_size) self.softmax = torch.nn.Softmax(dim=1) self.mf_loss = BPRLoss() self.reg_loss = EmbLoss() self.restore_user_e = None self.restore_item_e = None # parameters initialization self.apply(xavier_normal_initialization)
def __init__(self, config, dataset): super(Caser, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] self.loss_type = config['loss_type'] self.n_h = config['nh'] self.n_v = config['nv'] self.dropout_prob = config['dropout_prob'] self.reg_weight = config['reg_weight'] # load dataset info self.n_users = dataset.user_num # define layers and loss self.user_embedding = nn.Embedding(self.n_users, self.embedding_size, padding_idx=0) self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) # vertical conv layer self.conv_v = nn.Conv2d(in_channels=1, out_channels=self.n_v, kernel_size=(self.max_seq_length, 1)) # horizontal conv layer lengths = [i + 1 for i in range(self.max_seq_length)] self.conv_h = nn.ModuleList([ nn.Conv2d(in_channels=1, out_channels=self.n_h, kernel_size=(i, self.embedding_size)) for i in lengths ]) # fully-connected layer self.fc1_dim_v = self.n_v * self.embedding_size self.fc1_dim_h = self.n_h * len(lengths) fc1_dim_in = self.fc1_dim_v + self.fc1_dim_h self.fc1 = nn.Linear(fc1_dim_in, self.embedding_size) self.fc2 = nn.Linear(self.embedding_size + self.embedding_size, self.embedding_size) self.dropout = nn.Dropout(self.dropout_prob) self.ac_conv = nn.ReLU() self.ac_fc = nn.ReLU() self.reg_loss = RegLoss() if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # parameters initialization self.apply(self._init_weights)
def __init__(self, config, dataset): super(KTUP, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] self.L1_flag = config['L1_flag'] self.use_st_gumbel = config['use_st_gumbel'] self.kg_weight = config['kg_weight'] self.align_weight = config['align_weight'] self.margin = config['margin'] # define layers and loss self.user_embedding = nn.Embedding(self.n_users, self.embedding_size) self.item_embedding = nn.Embedding(self.n_items, self.embedding_size) self.pref_embedding = nn.Embedding(self.n_relations, self.embedding_size) self.pref_norm_embedding = nn.Embedding(self.n_relations, self.embedding_size) self.entity_embedding = nn.Embedding(self.n_entities, self.embedding_size) self.relation_embedding = nn.Embedding(self.n_relations, self.embedding_size) self.relation_norm_embedding = nn.Embedding(self.n_relations, self.embedding_size) self.rec_loss = BPRLoss() self.kg_loss = nn.MarginRankingLoss(margin=self.margin) self.reg_loss = EmbMarginLoss() # parameters initialization self.apply(xavier_uniform_initialization) normalize_user_emb = F.normalize(self.user_embedding.weight.data, p=2, dim=1) normalize_item_emb = F.normalize(self.item_embedding.weight.data, p=2, dim=1) normalize_pref_emb = F.normalize(self.pref_embedding.weight.data, p=2, dim=1) normalize_pref_norm_emb = F.normalize( self.pref_norm_embedding.weight.data, p=2, dim=1) normalize_entity_emb = F.normalize(self.entity_embedding.weight.data, p=2, dim=1) normalize_rel_emb = F.normalize(self.relation_embedding.weight.data, p=2, dim=1) normalize_rel_norm_emb = F.normalize( self.relation_norm_embedding.weight.data, p=2, dim=1) self.user_embedding.weight.data = normalize_user_emb self.item_embedding.weight_data = normalize_item_emb self.pref_embedding.weight.data = normalize_pref_emb self.pref_norm_embedding.weight.data = normalize_pref_norm_emb self.entity_embedding.weight.data = normalize_entity_emb self.relation_embedding.weight.data = normalize_rel_emb self.relation_norm_embedding.weight.data = normalize_rel_norm_emb
def __init__(self, config, dataset): super(SHANF, self).__init__(config, dataset) # load the dataset information self.n_users = dataset.num(self.USER_ID) self.device = config['device'] self.selected_features = config['selected_features'] self.pooling_mode = config['pooling_mode'] self.device = config['device'] self.num_feature_field = len(config['selected_features']) # load the parameter information self.embedding_size = config["embedding_size"] self.short_item_length = config[ "short_item_length"] # the length of the short session items assert self.short_item_length <= self.max_seq_length, "short_item_length can't longer than the max_seq_length" self.reg_weight = config["reg_weight"] # define layers and loss self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.user_embedding = nn.Embedding(self.n_users, self.embedding_size) self.long_w = nn.Linear(self.embedding_size, self.embedding_size) self.long_b = nn.Parameter(uniform_( tensor=torch.zeros(self.embedding_size), a=-np.sqrt(3 / self.embedding_size), b=np.sqrt(3 / self.embedding_size)), requires_grad=True).to(self.device) self.long_short_w = nn.Linear(self.embedding_size, self.embedding_size) self.long_short_b = nn.Parameter(uniform_( tensor=torch.zeros(self.embedding_size), a=-np.sqrt(3 / self.embedding_size), b=np.sqrt(3 / self.embedding_size)), requires_grad=True).to(self.device) self.relu = nn.ReLU() self.feature_embed_layer = FeatureSeqEmbLayer(dataset, self.embedding_size, self.selected_features, self.pooling_mode, self.device) self.concat_layer = nn.Linear( self.embedding_size * (1 + self.num_feature_field), self.embedding_size) self.loss_type = config['loss_type'] if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # init the parameter of the model self.apply(self.init_weights)
def __init__(self, config, dataset): super(FDSA, self).__init__(config, dataset) # load parameters info self.n_layers = config['n_layers'] self.n_heads = config['n_heads'] self.hidden_size = config['hidden_size'] # same as embedding_size self.inner_size = config['inner_size'] # the dimensionality in feed-forward layer self.hidden_dropout_prob = config['hidden_dropout_prob'] self.attn_dropout_prob = config['attn_dropout_prob'] self.hidden_act = config['hidden_act'] self.layer_norm_eps = config['layer_norm_eps'] self.selected_features = config['selected_features'] self.pooling_mode = config['pooling_mode'] self.device = config['device'] self.num_feature_field = len(config['selected_features']) self.initializer_range = config['initializer_range'] self.loss_type = config['loss_type'] # define layers and loss self.item_embedding = nn.Embedding(self.n_items, self.hidden_size, padding_idx=0) self.position_embedding = nn.Embedding(self.max_seq_length, self.hidden_size) self.feature_embed_layer = FeatureSeqEmbLayer(dataset, self.hidden_size, self.selected_features, self.pooling_mode, self.device) self.item_trm_encoder = TransformerEncoder(n_layers=self.n_layers, n_heads=self.n_heads, hidden_size=self.hidden_size, inner_size=self.inner_size, hidden_dropout_prob=self.hidden_dropout_prob, attn_dropout_prob=self.attn_dropout_prob, hidden_act=self.hidden_act, layer_norm_eps=self.layer_norm_eps) self.feature_att_layer = VanillaAttention(self.hidden_size, self.hidden_size) # For simplicity, we use same architecture for item_trm and feature_trm self.feature_trm_encoder = TransformerEncoder(n_layers=self.n_layers, n_heads=self.n_heads, hidden_size=self.hidden_size, inner_size=self.inner_size, hidden_dropout_prob=self.hidden_dropout_prob, attn_dropout_prob=self.attn_dropout_prob, hidden_act=self.hidden_act, layer_norm_eps=self.layer_norm_eps) self.LayerNorm = nn.LayerNorm(self.hidden_size, eps=self.layer_norm_eps) self.dropout = nn.Dropout(self.hidden_dropout_prob) self.concat_layer = nn.Linear(self.hidden_size * 2, self.hidden_size) if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError("Make sure 'loss_type' in ['BPR', 'CE']!") # parameters initialization self.apply(self._init_weights)
def __init__(self, config, dataset): super(CKE, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] self.kg_embedding_size = config['kg_embedding_size'] self.reg_weights = config['reg_weights'] # define layers and loss self.user_embedding = nn.Embedding(self.n_users, self.embedding_size) self.item_embedding = nn.Embedding(self.n_items, self.embedding_size) self.entity_embedding = nn.Embedding(self.n_entities, self.embedding_size) self.relation_embedding = nn.Embedding(self.n_relations, self.kg_embedding_size) self.trans_w = nn.Embedding(self.n_relations, self.embedding_size * self.kg_embedding_size) self.rec_loss = BPRLoss() self.kg_loss = BPRLoss() self.reg_loss = EmbLoss() # parameters initialization self.apply(xavier_normal_initialization)
def __init__(self, config, dataset): super(RippleNet, self).__init__(config, dataset) # load dataset info self.LABEL = config['LABEL_FIELD'] # load parameters info self.embedding_size = config['embedding_size'] self.kg_weight = config['kg_weight'] self.reg_weight = config['reg_weight'] self.n_hop = config['n_hop'] self.n_memory = config['n_memory'] self.interaction_matrix = dataset.inter_matrix(form='coo').astype( np.float32) head_entities = dataset.head_entities.tolist() tail_entities = dataset.tail_entities.tolist() relations = dataset.relations.tolist() kg = {} for i in range(len(head_entities)): head_ent = head_entities[i] tail_ent = tail_entities[i] relation = relations[i] kg.setdefault(head_ent, []) kg[head_ent].append((tail_ent, relation)) self.kg = kg users = self.interaction_matrix.row.tolist() items = self.interaction_matrix.col.tolist() user_dict = {} for i in range(len(users)): user = users[i] item = items[i] user_dict.setdefault(user, []) user_dict[user].append(item) self.user_dict = user_dict self.ripple_set = self._build_ripple_set() # define layers and loss self.entity_embedding = nn.Embedding(self.n_entities, self.embedding_size) self.relation_embedding = nn.Embedding( self.n_relations, self.embedding_size * self.embedding_size) self.transform_matrix = nn.Linear(self.embedding_size, self.embedding_size, bias=False) self.softmax = torch.nn.Softmax(dim=1) self.sigmoid = torch.nn.Sigmoid() self.rec_loss = BPRLoss() self.l2_loss = EmbLoss() self.loss = nn.BCEWithLogitsLoss() # parameters initialization self.apply(xavier_normal_initialization) self.other_parameter_name = ['ripple_set']
def __init__(self, config, dataset): super(GRU4RecF, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] self.hidden_size = config['hidden_size'] self.num_layers = config['num_layers'] self.dropout_prob = config['dropout_prob'] self.selected_features = config['selected_features'] self.pooling_mode = config['pooling_mode'] self.device = config['device'] self.num_feature_field = len(config['selected_features']) self.loss_type = config['loss_type'] # define layers and loss self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.feature_embed_layer = FeatureSeqEmbLayer(dataset, self.embedding_size, self.selected_features, self.pooling_mode, self.device) self.item_gru_layers = nn.GRU( input_size=self.embedding_size, hidden_size=self.hidden_size, num_layers=self.num_layers, bias=False, batch_first=True, ) # For simplicity, we use same architecture for item_gru and feature_gru self.feature_gru_layers = nn.GRU( input_size=self.embedding_size * self.num_feature_field, hidden_size=self.hidden_size, num_layers=self.num_layers, bias=False, batch_first=True, ) self.dense_layer = nn.Linear(self.hidden_size * 2, self.embedding_size) self.dropout = nn.Dropout(self.dropout_prob) if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # parameters initialization self.apply(xavier_normal_initialization) self.other_parameter_name = ['feature_embed_layer']
def __init__(self, config, dataset): super(KGAT, self).__init__(config, dataset) # load dataset info self.ckg = dataset.ckg_graph(form='dgl', value_field='relation_id') self.all_hs = torch.LongTensor( dataset.ckg_graph(form='coo', value_field='relation_id').row).to(self.device) self.all_ts = torch.LongTensor( dataset.ckg_graph(form='coo', value_field='relation_id').col).to(self.device) self.all_rs = torch.LongTensor( dataset.ckg_graph(form='coo', value_field='relation_id').data).to(self.device) self.matrix_size = torch.Size( [self.n_users + self.n_entities, self.n_users + self.n_entities]) # load parameters info self.embedding_size = config['embedding_size'] self.kg_embedding_size = config['kg_embedding_size'] self.layers = [self.embedding_size] + config['layers'] self.aggregator_type = config['aggregator_type'] self.mess_dropout = config['mess_dropout'] self.reg_weight = config['reg_weight'] # generate intermediate data self.A_in = self.init_graph( ) # init the attention matrix by the structure of ckg # define layers and loss self.user_embedding = nn.Embedding(self.n_users, self.embedding_size) self.entity_embedding = nn.Embedding(self.n_entities, self.embedding_size) self.relation_embedding = nn.Embedding(self.n_relations, self.kg_embedding_size) self.trans_w = nn.Embedding( self.n_relations, self.embedding_size * self.kg_embedding_size) self.aggregator_layers = nn.ModuleList() for idx, (input_dim, output_dim) in enumerate( zip(self.layers[:-1], self.layers[1:])): self.aggregator_layers.append( Aggregator(input_dim, output_dim, self.mess_dropout, self.aggregator_type)) self.tanh = nn.Tanh() self.mf_loss = BPRLoss() self.reg_loss = EmbLoss() self.restore_user_e = None self.restore_entity_e = None # parameters initialization self.apply(xavier_normal_initialization) self.other_parameter_name = ['restore_user_e', 'restore_entity_e']
def __init__(self, config, dataset): super(BPR, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] # define layers and loss self.user_embedding = nn.Embedding(self.n_users, self.embedding_size) self.item_embedding = nn.Embedding(self.n_items, self.embedding_size) self.loss = BPRLoss() # parameters initialization self.apply(xavier_normal_initialization)
def __init__(self, config, dataset): super(LightSANs, self).__init__(config, dataset) # load parameters info self.n_layers = config['n_layers'] self.n_heads = config['n_heads'] self.k_interests = config['k_interests'] self.hidden_size = config['hidden_size'] # same as embedding_size self.inner_size = config[ 'inner_size'] # the dimensionality in feed-forward layer self.hidden_dropout_prob = config['hidden_dropout_prob'] self.attn_dropout_prob = config['attn_dropout_prob'] self.hidden_act = config['hidden_act'] self.layer_norm_eps = config['layer_norm_eps'] self.initializer_range = config['initializer_range'] self.loss_type = config['loss_type'] self.seq_len = self.max_seq_length # define layers and loss self.item_embedding = nn.Embedding(self.n_items, self.hidden_size, padding_idx=0) self.position_embedding = nn.Embedding(self.max_seq_length, self.hidden_size) self.trm_encoder = LightTransformerEncoder( n_layers=self.n_layers, n_heads=self.n_heads, k_interests=self.k_interests, hidden_size=self.hidden_size, seq_len=self.seq_len, inner_size=self.inner_size, hidden_dropout_prob=self.hidden_dropout_prob, attn_dropout_prob=self.attn_dropout_prob, hidden_act=self.hidden_act, layer_norm_eps=self.layer_norm_eps) self.LayerNorm = nn.LayerNorm(self.hidden_size, eps=self.layer_norm_eps) self.dropout = nn.Dropout(self.hidden_dropout_prob) if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # parameters initialization self.apply(self._init_weights)
def __init__(self, config, dataset): super(HGN, self).__init__(config, dataset) # load the dataset information self.n_user = dataset.num(self.USER_ID) self.device = config["device"] # load the parameter information self.embedding_size = config["embedding_size"] self.reg_weight = config["reg_weight"] self.pool_type = config["pooling_type"] if self.pool_type not in ["max", "average"]: raise NotImplementedError( "Make sure 'loss_type' in ['max', 'average']!") # define the layers and loss function self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.user_embedding = nn.Embedding(self.n_user, self.embedding_size) # define the module feature gating need self.w1 = nn.Linear(self.embedding_size, self.embedding_size) self.w2 = nn.Linear(self.embedding_size, self.embedding_size) self.b = nn.Parameter(torch.zeros(self.embedding_size), requires_grad=True).to(self.device) # define the module instance gating need self.w3 = nn.Linear(self.embedding_size, 1, bias=False) self.w4 = nn.Linear(self.embedding_size, self.max_seq_length, bias=False) # define item_embedding for prediction self.item_embedding_for_prediction = nn.Embedding( self.n_items, self.embedding_size) self.sigmoid = nn.Sigmoid() self.loss_type = config['loss_type'] if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # init the parameters of the model self.apply(self._init_weights)
def __init__(self, config, dataset): super(NARMFF, self).__init__(config, dataset) # load parameters info self.embedding_size = config['embedding_size'] self.hidden_size = config['hidden_size'] self.n_layers = config['n_layers'] self.dropout_probs = config['dropout_probs'] self.device = config['device'] self.selected_features = config['selected_features'] self.pooling_mode = config['pooling_mode'] self.device = config['device'] self.num_feature_field = len(config['selected_features']) self.loss_type = config['loss_type'] self.feature_embed_layer = FeatureSeqEmbLayer(dataset, self.hidden_size, self.selected_features, self.pooling_mode, self.device) # define layers and loss self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.emb_dropout = nn.Dropout(self.dropout_probs[0]) self.gru = nn.GRU(self.embedding_size * 3, self.hidden_size, self.n_layers, bias=False, batch_first=True) self.a_1 = nn.Linear(self.hidden_size, self.hidden_size, bias=False) self.a_2 = nn.Linear(self.hidden_size, self.hidden_size, bias=False) self.v_t = nn.Linear(self.hidden_size, 1, bias=False) self.ct_dropout = nn.Dropout(self.dropout_probs[1]) self.b = nn.Linear(2 * self.hidden_size, self.embedding_size, bias=False) self.concat_layer = nn.Linear( self.hidden_size * (1 + self.num_feature_field), self.hidden_size) if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # parameters initialization self.apply(self._init_weights)
def __init__(self, config, dataset): super(GRU4RecKG, self).__init__(config, dataset) # load dataset info self.entity_embedding_matrix = dataset.get_preload_weight('ent_id') # load parameters info self.embedding_size = config['embedding_size'] self.hidden_size = config['hidden_size'] self.num_layers = config['num_layers'] self.dropout = config['dropout_prob'] self.freeze_kg = config['freeze_kg'] self.loss_type = config['loss_type'] # define layers and loss self.item_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.entity_embedding = nn.Embedding(self.n_items, self.embedding_size, padding_idx=0) self.entity_embedding.weight.requires_grad = not self.freeze_kg self.item_gru_layers = nn.GRU( input_size=self.embedding_size, hidden_size=self.hidden_size, num_layers=self.num_layers, bias=False, batch_first=True, ) self.entity_gru_layers = nn.GRU( input_size=self.embedding_size, hidden_size=self.hidden_size, num_layers=self.num_layers, bias=False, batch_first=True, ) self.dense_layer = nn.Linear(self.hidden_size * 2, self.embedding_size) if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # parameters initialization self.apply(xavier_normal_initialization) self.entity_embedding.weight.data.copy_( torch.from_numpy(self.entity_embedding_matrix[:self.n_items]))
def __init__(self, config, dataset): super(NCL, self).__init__(config, dataset) # load dataset info self.interaction_matrix = dataset.inter_matrix(form='coo').astype( np.float32) # load parameters info self.latent_dim = config[ 'embedding_size'] # int type: the embedding size of the base model self.n_layers = config[ 'n_layers'] # int type: the layer num of the base model self.reg_weight = config[ 'reg_weight'] # float32 type: the weight decay for l2 normalization self.ssl_temp = config['ssl_temp'] self.ssl_reg = config['ssl_reg'] self.hyper_layers = config['hyper_layers'] self.alpha = config['alpha'] self.proto_reg = config['proto_reg'] self.k = config['num_clusters'] # define layers and loss self.user_embedding = torch.nn.Embedding(num_embeddings=self.n_users, embedding_dim=self.latent_dim) self.item_embedding = torch.nn.Embedding(num_embeddings=self.n_items, embedding_dim=self.latent_dim) self.mf_loss = BPRLoss() self.reg_loss = EmbLoss() # storage variables for full sort evaluation acceleration self.restore_user_e = None self.restore_item_e = None self.norm_adj_mat = self.get_norm_adj_mat().to(self.device) # parameters initialization self.apply(xavier_uniform_initialization) self.other_parameter_name = ['restore_user_e', 'restore_item_e'] self.user_centroids = None self.user_2cluster = None self.item_centroids = None self.item_2cluster = None
def __init__(self, config, dataset): super(GCSAN, self).__init__(config, dataset) # load parameters info self.n_layers = config['n_layers'] self.n_heads = config['n_heads'] self.hidden_size = config['hidden_size'] # same as embedding_size self.inner_size = config[ 'inner_size'] # the dimensionality in feed-forward layer self.hidden_dropout_prob = config['hidden_dropout_prob'] self.attn_dropout_prob = config['attn_dropout_prob'] self.hidden_act = config['hidden_act'] self.layer_norm_eps = config['layer_norm_eps'] self.step = config['step'] self.device = config['device'] self.weight = config['weight'] self.reg_weight = config['reg_weight'] self.loss_type = config['loss_type'] self.initializer_range = config['initializer_range'] # define layers and loss self.item_embedding = nn.Embedding(self.n_items, self.hidden_size, padding_idx=0) self.gnn = GNN(self.hidden_size, self.step) self.self_attention = TransformerEncoder( n_layers=self.n_layers, n_heads=self.n_heads, hidden_size=self.hidden_size, inner_size=self.inner_size, hidden_dropout_prob=self.hidden_dropout_prob, attn_dropout_prob=self.attn_dropout_prob, hidden_act=self.hidden_act, layer_norm_eps=self.layer_norm_eps) self.reg_loss = EmbLoss() if self.loss_type == 'BPR': self.loss_fct = BPRLoss() elif self.loss_type == 'CE': self.loss_fct = nn.CrossEntropyLoss() else: raise NotImplementedError( "Make sure 'loss_type' in ['BPR', 'CE']!") # parameters initialization self.apply(self._init_weights)