Download annotations/annotation_39/BASRec/GRU4Rec/src/models.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 12.4 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_39/BASRec/GRU4Rec/src/models.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_39/BASRec/GRU4Rec/src/models.py
-
curl -L -o models.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_39/BASRec/GRU4Rec/src/models.py
12.4 kB
| # -*- 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)) | |