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)