# -*- coding: utf-8 -*- import os import copy import math import torch import pickle import gensim import random import torch.nn as nn from tqdm import tqdm from torch.nn.init import xavier_uniform_, xavier_normal_ class GRU4Rec(nn.Module): def __init__(self, args): super(GRU4Rec, self).__init__() self.args = args # load dataset info self.max_seq_length = args.max_seq_length self.n_items = args.item_size # load parameters info self.embedding_size = args.embedding_size self.hidden_size = args.hidden_size self.num_layers = args.num_layers self.dropout_prob = args.dropout_prob # define layers and loss self.item_embeddings = 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) # parameters initialization self.apply(self._init_weights) def _init_weights(self, module): if isinstance(module, nn.Embedding): xavier_normal_(module.weight) elif isinstance(module, nn.GRU): xavier_uniform_(module.weight_hh_l0) xavier_uniform_(module.weight_ih_l0) def forward(self, item_seq, augment_sequence=None, alpha=None, perturbed=False): item_seq_emb = self.item_embeddings(item_seq) if augment_sequence is not None: item_embeddings_org = self.item_embeddings(item_seq) item_embeddings_aug = self.item_embeddings(augment_sequence) item_seq_emb = alpha * item_embeddings_org + (1 - alpha) * item_embeddings_aug item_seq_emb_dropout = self.emb_dropout(item_seq_emb) gru_output, _ = self.gru_layers(item_seq_emb_dropout) gru_output = self.dense(gru_output) return gru_output class OnlineItemSimilarity: def __init__(self, item_size): self.item_size = item_size self.item_embeddings = None self.cuda_condition = torch.cuda.is_available() self.device = torch.device("cuda" if self.cuda_condition else "cpu") self.total_item_list = torch.tensor([i for i in range(self.item_size)], dtype=torch.long).to(self.device) def update_embedding_matrix(self, item_embeddings): self.item_embeddings = copy.deepcopy(item_embeddings) self.base_embedding_matrix = self.item_embeddings(self.total_item_list) self.max_score, self.min_score = self.get_maximum_minimum_sim_scores() def get_maximum_minimum_sim_scores(self): max_score, min_score = -1, 100 for item_idx in range(1, self.item_size): try: item_vector = self.item_embeddings(torch.tensor(item_idx).to(self.device)).view(-1, 1) item_similarity = torch.mm(self.base_embedding_matrix, item_vector).view(-1) max_score = max(torch.max(item_similarity), max_score) min_score = min(torch.min(item_similarity), min_score) except: print("ssssss") continue return max_score, min_score def most_similar(self, item_idx, top_k=1, with_score=False): item_idx = torch.tensor(item_idx, dtype=torch.long).to(self.device) item_vector = self.item_embeddings(item_idx).view(-1, 1) item_similarity = torch.mm(self.base_embedding_matrix, item_vector).view(-1) item_similarity = (item_similarity - self.min_score) / (self.max_score - self.min_score) # remove item idx itself values, indices = item_similarity.topk(top_k + 1) if with_score: item_list = indices.tolist() score_list = values.tolist() if item_idx in item_list: idd = item_list.index(item_idx) item_list.remove(item_idx) score_list.pop(idd) return list(zip(item_list, score_list)) item_list = indices.tolist() if item_idx in item_list: item_list.remove(item_idx) return item_list class OfflineItemSimilarity: def __init__(self, data_file=None, similarity_path=None, model_name='ItemCF', \ dataset_name='Sports_and_Outdoors'): self.dataset_name = dataset_name self.similarity_path = similarity_path # train_data_list used for item2vec, train_data_dict used for itemCF and itemCF-IUF self.train_data_list, self.train_item_list, self.train_data_dict = self._load_train_data(data_file) self.model_name = model_name self.similarity_model = self.load_similarity_model(self.similarity_path) self.max_score, self.min_score = self.get_maximum_minimum_sim_scores() def get_maximum_minimum_sim_scores(self): max_score, min_score = -1, 100 for item in self.similarity_model.keys(): for neig in self.similarity_model[item]: sim_score = self.similarity_model[item][neig] max_score = max(max_score, sim_score) min_score = min(min_score, sim_score) return max_score, min_score def _convert_data_to_dict(self, data): """ split the data set testdata is a test data set traindata is a train set """ train_data_dict = {} for user, item, record in data: train_data_dict.setdefault(user, {}) train_data_dict[user][item] = record return train_data_dict def _save_dict(self, dict_data, save_path='./similarity.pkl'): print("saving data to ", save_path) with open(save_path, 'wb') as write_file: pickle.dump(dict_data, write_file) def _load_train_data(self, data_file=None): """ read the data from the data file which is a data set """ train_data = [] train_data_list = [] train_data_set_list = [] for line in open(data_file).readlines(): userid, items = line.strip().split(' ', 1) # only use training data items = items.split(' ')[:-3] train_data_list.append(items) train_data_set_list += items for itemid in items: train_data.append((userid, itemid, int(1))) return train_data_list, set(train_data_set_list), self._convert_data_to_dict(train_data) def _generate_item_similarity(self, train=None, save_path='./'): """ calculate co-rated users between items """ print("getting item similarity...") train = train or self.train_data_dict C = dict() N = dict() if self.model_name in ['ItemCF', 'ItemCF_IUF']: print("Step 1: Compute Statistics") data_iter = tqdm(enumerate(train.items()), total=len(train.items())) for idx, (u, items) in data_iter: if self.model_name == 'ItemCF': for i in items.keys(): N.setdefault(i, 0) N[i] += 1 for j in items.keys(): if i == j: continue C.setdefault(i, {}) C[i].setdefault(j, 0) C[i][j] += 1 elif self.model_name == 'ItemCF_IUF': for i in items.keys(): N.setdefault(i, 0) N[i] += 1 for j in items.keys(): if i == j: continue C.setdefault(i, {}) C[i].setdefault(j, 0) C[i][j] += 1 / math.log(1 + len(items) * 1.0) self.itemSimBest = dict() print("Step 2: Compute co-rate matrix") c_iter = tqdm(enumerate(C.items()), total=len(C.items())) for idx, (cur_item, related_items) in c_iter: self.itemSimBest.setdefault(cur_item, {}) for related_item, score in related_items.items(): self.itemSimBest[cur_item].setdefault(related_item, 0); self.itemSimBest[cur_item][related_item] = score / math.sqrt(N[cur_item] * N[related_item]) self._save_dict(self.itemSimBest, save_path=save_path) elif self.model_name == 'Item2Vec': # details here: https://github.com/RaRe-Technologies/gensim/blob/develop/gensim/models/word2vec.py print("Step 1: train item2vec model") item2vec_model = gensim.models.Word2Vec(sentences=self.train_data_list, vector_size=20, window=5, min_count=0, epochs=100) self.itemSimBest = dict() total_item_nums = len(item2vec_model.wv.index_to_key) print("Step 2: convert to item similarity dict") total_items = tqdm(item2vec_model.wv.index_to_key, total=total_item_nums) for cur_item in total_items: related_items = item2vec_model.wv.most_similar(positive=[cur_item], topn=20) self.itemSimBest.setdefault(cur_item, {}) for (related_item, score) in related_items: self.itemSimBest[cur_item].setdefault(related_item, 0) self.itemSimBest[cur_item][related_item] = score print("Item2Vec model saved to: ", save_path) def load_similarity_model(self, similarity_model_path): if not similarity_model_path: raise ValueError('invalid path') elif not os.path.exists(similarity_model_path): print("the similirity dict not exist, generating...") self._generate_item_similarity(save_path=self.similarity_path) if self.model_name in ['ItemCF', 'ItemCF_IUF', 'Item2Vec', 'LightGCN']: with open(similarity_model_path, 'rb') as read_file: similarity_dict = pickle.load(read_file) return similarity_dict elif self.model_name == 'Random': similarity_dict = self.train_item_list return similarity_dict def most_similar(self, item, top_k=1, with_score=False): if self.model_name in ['ItemCF', 'ItemCF_IUF', 'Item2Vec', 'LightGCN']: """TODO: handle case that item not in keys""" if str(item) in self.similarity_model: top_k_items_with_score = sorted(self.similarity_model[str(item)].items(), key=lambda x: x[1], \ reverse=True)[0:top_k] if with_score: return list( map(lambda x: (int(x[0]), (float(x[1]) - self.min_score) / (self.max_score - self.min_score)), top_k_items_with_score)) return list(map(lambda x: int(x[0]), top_k_items_with_score)) elif int(item) in self.similarity_model: top_k_items_with_score = sorted(self.similarity_model[int(item)].items(), key=lambda x: x[1], \ reverse=True)[0:top_k] if with_score: return list( map(lambda x: (int(x[0]), (float(x[1]) - self.min_score) / (self.max_score - self.min_score)), top_k_items_with_score)) return list(map(lambda x: int(x[0]), top_k_items_with_score)) else: item_list = list(self.similarity_model.keys()) random_items = random.sample(item_list, k=top_k) if with_score: return list(map(lambda x: (int(x), 0.0), random_items)) return list(map(lambda x: int(x), random_items)) elif self.model_name == 'Random': random_items = random.sample(self.similarity_model, k=top_k) if with_score: return list(map(lambda x: (int(x), 0.0), random_items)) return list(map(lambda x: int(x), random_items))