import torch import faiss import torch.nn as nn from modules import Encoder, LayerNorm class KMeans(object): def __init__(self, num_cluster, seed, hidden_size, gpu_id=0, device="cpu"): """ Args: k: number of clusters """ self.seed = seed self.num_cluster = num_cluster self.max_points_per_centroid = 4096 self.min_points_per_centroid = 0 self.gpu_id = 0 self.device = device self.first_batch = True self.hidden_size = hidden_size self.clus, self.index = self.__init_cluster(self.hidden_size) self.centroids = [] def __init_cluster( self, hidden_size, verbose=False, niter=20, nredo=5, max_points_per_centroid=4096, min_points_per_centroid=0 ): print(" cluster train iterations:", niter) clus = faiss.Clustering(hidden_size, self.num_cluster) clus.verbose = verbose clus.niter = niter clus.nredo = nredo clus.seed = self.seed clus.max_points_per_centroid = max_points_per_centroid clus.min_points_per_centroid = min_points_per_centroid index = faiss.IndexFlatL2(hidden_size) return clus, index def train(self, x): if x.shape[0] > self.num_cluster: self.clus.train(x, self.index) centroids = faiss.vector_to_array(self.clus.centroids).reshape(self.num_cluster, self.hidden_size) centroids = torch.tensor(centroids, requires_grad=True).to(self.device) self.centroids = nn.functional.normalize(centroids, p=2, dim=1) def query(self, x): D, I = self.index.search(x, 1) seq2cluster = [int(n[0]) for n in I] seq2cluster = torch.LongTensor(seq2cluster).to(self.device) return seq2cluster, self.centroids[seq2cluster] class SASRecModel(nn.Module): def __init__(self, args): super(SASRecModel, self).__init__() self.item_embeddings = nn.Embedding(args.item_size, args.hidden_size, padding_idx=0) self.position_embeddings = nn.Embedding(args.max_seq_length, args.hidden_size) self.item_encoder = Encoder(args) self.LayerNorm = LayerNorm(args.hidden_size, eps=1e-12) self.dropout = nn.Dropout(args.hidden_dropout_prob) self.args = args self.cluster_centers = nn.Parameter(torch.Tensor(int(args.num_intent_clusters), int(args.hidden_size))) self.criterion = nn.BCELoss(reduction="none") self.apply(self.init_weights) def add_position_embedding(self, sequence): seq_length = sequence.size(1) position_ids = torch.arange(seq_length, dtype=torch.long, device=sequence.device) position_ids = position_ids.unsqueeze(0).expand_as(sequence) item_embeddings = self.item_embeddings(sequence) position_embeddings = self.position_embeddings(position_ids) sequence_emb = item_embeddings + position_embeddings sequence_emb = self.LayerNorm(sequence_emb) sequence_emb = self.dropout(sequence_emb) return sequence_emb def forward(self, input_ids): attention_mask = (input_ids > 0).long() extended_attention_mask = attention_mask.unsqueeze(1).unsqueeze(2) # torch.int64 max_len = attention_mask.size(-1) attn_shape = (1, max_len, max_len) subsequent_mask = torch.triu(torch.ones(attn_shape), diagonal=1) # torch.uint8 subsequent_mask = (subsequent_mask == 0).unsqueeze(1) subsequent_mask = subsequent_mask.long() if self.args.cuda_condition: subsequent_mask = subsequent_mask.cuda() extended_attention_mask = extended_attention_mask * subsequent_mask extended_attention_mask = extended_attention_mask.to(dtype=next(self.parameters()).dtype) # fp16 compatibility extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0 sequence_emb = self.add_position_embedding(input_ids) item_encoded_layers = self.item_encoder(sequence_emb, extended_attention_mask, output_all_encoded_layers=True) sequence_output = item_encoded_layers[-1] return sequence_output def init_weights(self, module): if isinstance(module, (nn.Linear, nn.Embedding)): module.weight.data.normal_(mean=0.0, std=self.args.initializer_range) elif isinstance(module, LayerNorm): module.bias.data.zero_() module.weight.data.fill_(1.0) if isinstance(module, nn.Linear) and module.bias is not None: module.bias.data.zero_()