File size: 4,462 Bytes
6077218 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 | import torch
import torch.nn as nn
import numpy as np
from base import AbstractModel
from modules import TransformerEncoder, in_batch_negative_sampling, extract_axis_1
class SASRec(AbstractModel):
def __init__(self, config: dict):
super(AbstractModel, self).__init__()
self.config = config
self.load_item_embeddings()
# Initialize embeddings
self.positional_embeddings = nn.Embedding(
num_embeddings=config['max_seq_length'],
embedding_dim=config['hidden_size']
)
self.emb_dropout = nn.Dropout(config['dropout'])
# Initialize Transformer layers
self.layers = nn.ModuleList([
TransformerEncoder(config)
for _ in range(config['layer_num'])
])
# Initialize loss function
if config['loss_type'] == 'bce':
self.loss_func = nn.BCEWithLogitsLoss()
elif config['loss_type'] == "ce":
self.loss_func = nn.CrossEntropyLoss()
def load_item_embeddings(self):
self.item_embeddings = nn.Embedding(
num_embeddings=self.config['item_num'] + 1,
embedding_dim=self.config['hidden_size'],
padding_idx=0
)
nn.init.normal_(self.item_embeddings.weight, 0, 1)
def get_embeddings(self, items):
return self.item_embeddings(items)
def get_all_embeddings(self, device=None):
return self.item_embeddings.weight.data
def get_current_embeddings(self, device=None):
return self.item_embeddings.weight.data[self.config['select_pool'][0]:self.config['select_pool'][1]]
def get_representation(self, batch):
inputs_emb = self.get_embeddings(batch['item_seqs'])
inputs_emb += self.positional_embeddings(
torch.arange(self.config['max_seq_length']).to(inputs_emb.device)
)
seq = self.emb_dropout(inputs_emb)
mask = torch.ne(batch['item_seqs'], 0).float().unsqueeze(-1).to(inputs_emb.device)
for layer in self.layers:
seq = layer(seq, mask=mask)
state_hidden = extract_axis_1(seq, batch['seq_lengths'] - 1).squeeze()
return state_hidden
def forward(self, batch):
state_hidden = self.get_representation(batch)
labels_neg = self._generate_negative_samples(batch)
test_item_emb = self.get_all_embeddings(state_hidden.device)
if self.config['loss_type'] == 'bce':
labels_neg = labels_neg.view(-1, 1)
logits = torch.matmul(state_hidden, test_item_emb.transpose(0, 1))
pos_scores = torch.gather(logits, 1, batch['labels'].view(-1, 1))
neg_scores = torch.gather(logits, 1, labels_neg)
pos_labels = torch.ones((batch['labels'].view(-1).shape[0], 1))
neg_labels = torch.zeros((batch['labels'].view(-1).shape[0], 1))
scores = torch.cat((pos_scores, neg_scores), 0)
labels = torch.cat((pos_labels, neg_labels), 0)
labels = labels.to(state_hidden.device)
loss = self.loss_func(scores, labels)
elif self.config['loss_type'] == 'ce':
logits = torch.matmul(state_hidden, test_item_emb.transpose(0, 1))
loss = self.loss_func(logits, batch['labels'].view(-1))
return {'loss': loss}
def predict(self, batch, n_return_sequences=1):
state_hidden = self.get_representation(batch).view(-1, self.config['hidden_size'])
test_item_emb = self.get_all_embeddings(state_hidden.device)
scores = torch.matmul(state_hidden, test_item_emb.transpose(0, 1))[:,
self.config['select_pool'][0]: self.config['select_pool'][1]]
preds = scores.topk(n_return_sequences, dim=-1).indices + self.config['select_pool'][0]
return preds
def _generate_negative_samples(self, batch):
if self.config['sample_func'] == 'batch':
return in_batch_negative_sampling(batch['labels'])
labels_neg = []
for index in range(len(batch['labels'])):
import numpy as np
neg_samples = np.random.choice(range(self.config['select_pool'][0], self.config['select_pool'][1]), size=1,
replace=False)
neg_samples = neg_samples[neg_samples != batch['labels'][index]]
labels_neg.append(neg_samples.tolist())
return torch.LongTensor(labels_neg).to(batch['labels'].device).reshape(-1, 1)
|