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)