Download annotations/annotation_39/BASRec/GRU4Rec/src/main.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 9.17 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_39/BASRec/GRU4Rec/src/main.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_39/BASRec/GRU4Rec/src/main.py
-
curl -L -o main.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_39/BASRec/GRU4Rec/src/main.py
9.17 kB
| # -*- coding: utf-8 -*- | |
| import os | |
| import torch | |
| import argparse | |
| import numpy as np | |
| from datasets import SASRecDataset | |
| from trainers import SASRecTrainer | |
| from utils import EarlyStopping, get_user_seqs, check_path, set_seed | |
| from torch.utils.data import DataLoader, RandomSampler, SequentialSampler | |
| from models import GRU4Rec, OfflineItemSimilarity, OnlineItemSimilarity | |
| def show_args_info(args): | |
| print(f"--------------------Configure Info:------------") | |
| with open(args.log_file, 'a') as f: | |
| for arg in vars(args): | |
| info = f"{arg:<30} : {getattr(args, arg):>35}" | |
| print(info) | |
| f.write(info + '\n') | |
| def main(): | |
| parser = argparse.ArgumentParser() | |
| # system args | |
| parser.add_argument('--data_dir', default='../data/', type=str) | |
| parser.add_argument('--output_dir', default='output/', type=str) | |
| parser.add_argument('--data_name', default='Beauty', type=str) | |
| parser.add_argument('--do_eval', action='store_true') | |
| parser.add_argument('--load_pretrain', action='store_true') | |
| parser.add_argument('--model_idx', default=1, type=int, help="model idenfier 10, 20, 30...") | |
| parser.add_argument("--gpu_id", type=str, default="0", help="gpu_id") | |
| # data augmentation args (from CoSeRec) | |
| parser.add_argument('--noise_ratio', default=0.0, type=float, | |
| help="percentage of negative interactions in a sequence - robustness analysis") | |
| parser.add_argument('--training_data_ratio', default=1.0, type=float, | |
| help="percentage of training samples used for training - robustness analysis") | |
| parser.add_argument('--similarity_model_name', default='ItemCF_IUF', type=str, | |
| help="Method to generate item similarity score. choices: Random, ItemCF, ItemCF_IUF(Inverse user frequency), Item2Vec") | |
| parser.add_argument('--base_augment_type', default='random', type=str, | |
| help="default data augmentation types. Chosen from: reorder, substitute, random.") | |
| # model args | |
| parser.add_argument("--model_name", default='BASRec', type=str) | |
| parser.add_argument('--max_seq_length', default=50, type=int) | |
| parser.add_argument("--hidden_size", type=int, default=128, help="hidden size of model") | |
| parser.add_argument("--embedding_size", type=int, default=64, help="hidden size of model") | |
| parser.add_argument("--num_layers", type=int, default=1, help="number of layers") | |
| parser.add_argument("--dropout_prob", type=float, default=0.3) | |
| # train args | |
| parser.add_argument("--lr", type=float, default=0.001, help="learning rate of adam") | |
| parser.add_argument("--batch_size", type=int, default=256, help="number of batch_size") | |
| parser.add_argument("--no_cuda", action="store_true") | |
| parser.add_argument("--log_freq", type=int, default=1, help="per epoch print res") | |
| parser.add_argument("--seed", default=2024, type=int) | |
| # learning related | |
| parser.add_argument("--weight_decay", type=float, default=0.0, help="weight_decay of adam") | |
| parser.add_argument("--adam_beta1", type=float, default=0.9, help="adam first beta value") | |
| parser.add_argument("--adam_beta2", type=float, default=0.999, help="adam second beta value") | |
| # No use, we disable this module implemented by CoSeRec because is time-costing | |
| parser.add_argument("--augmentation_warm_up_epoches", type=float, default=500, | |
| help="number of epochs to switch from memory-based similarity model to hybrid similarity model.") | |
| ############################################ | |
| # need adjust (epoch) | |
| parser.add_argument("--epochs", type=int, default=200, help="number of epochs") | |
| parser.add_argument("--pretrain_epoch", default=0, type=int) | |
| parser.add_argument("--start_valid", default=100, type=int) | |
| parser.add_argument("--patience", type=int, default=20, help="early stop patience") | |
| # need adjust (parameter) | |
| parser.add_argument('--n_pairs', default=1, type=int, metavar='N', | |
| help='Number of augmented data for each sequence, one pair equals two augment sequences.') | |
| parser.add_argument('--n_whole_level', default=1, type=int, metavar='N', | |
| help='Number of whole level mix learning.') | |
| parser.add_argument("--wml_weight", type=float, default=1.0, help="weight of whole level mix learning task") | |
| parser.add_argument("--aml_weight", type=float, default=1.0, help="weight of augment sequence mix learning task") | |
| parser.add_argument("--rec_weight", type=float, default=1.0, help="weight of main recommendation task") | |
| parser.add_argument("--attention_probs_dropout_prob", type=float, default=0.2, help="attention dropout p") | |
| parser.add_argument("--hidden_dropout_prob", type=float, default=0.2, help="hidden dropout p") | |
| parser.add_argument("--beta", type=float, default=0.3, help="beta value distributions for beta") | |
| parser.add_argument("--rate_min", type=float, default=0.2, help="min ratio for two operators") | |
| parser.add_argument("--rate_max", type=float, default=0.51, help="max ratio for two operators") | |
| ############################################ | |
| args = parser.parse_args() | |
| set_seed(args.seed) | |
| check_path(args.output_dir) | |
| os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_id | |
| args.cuda_condition = torch.cuda.is_available() and not args.no_cuda | |
| print("Using Cuda:", torch.cuda.is_available()) | |
| args.data_file = args.data_dir + args.data_name + '.txt' | |
| user_seq, max_item, valid_rating_matrix, test_rating_matrix = get_user_seqs(args.data_file) | |
| args.item_size = max_item + 2 | |
| # save model args | |
| args_str = f'{args.model_name}-{args.data_name}-{args.model_idx}' | |
| args.log_file = os.path.join(args.output_dir, args_str + '.txt') | |
| show_args_info(args) | |
| with open(args.log_file, 'a') as f: | |
| f.write(str(args) + '\n') | |
| # set item score in train set to `0` in validation | |
| args.train_matrix = valid_rating_matrix | |
| # save model | |
| checkpoint = args_str + '.pt' | |
| args.checkpoint_path = os.path.join(args.output_dir, checkpoint) | |
| # ----------- pre-computation for item similarity ------------ # | |
| args.similarity_model_path = os.path.join(args.data_dir, | |
| args.data_name + '_' + args.similarity_model_name + '_similarity.pkl') | |
| offline_similarity_model = OfflineItemSimilarity(data_file=args.data_file, | |
| similarity_path=args.similarity_model_path, | |
| model_name=args.similarity_model_name, | |
| dataset_name=args.data_name) | |
| args.offline_similarity_model = offline_similarity_model | |
| # ----------- online based on shared item embedding for item similarity --------- # | |
| online_similarity_model = OnlineItemSimilarity(item_size=args.item_size) | |
| args.online_similarity_model = online_similarity_model | |
| # training data for node classification | |
| train_dataset = SASRecDataset(args, user_seq, data_type='train') | |
| train_sampler = RandomSampler(train_dataset) | |
| train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.batch_size) | |
| eval_dataset = SASRecDataset(args, user_seq, data_type='valid') | |
| eval_sampler = SequentialSampler(eval_dataset) | |
| eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.batch_size) | |
| test_dataset = SASRecDataset(args, user_seq, data_type='test') | |
| test_sampler = SequentialSampler(test_dataset) | |
| test_dataloader = DataLoader(test_dataset, sampler=test_sampler, batch_size=args.batch_size) | |
| model = GRU4Rec(args=args) | |
| if args.load_pretrain: | |
| model.load_state_dict(torch.load(args.data_dir + 'M4SRec-' + args.data_name + '-5.pt')) | |
| trainer = SASRecTrainer(model, train_dataloader, eval_dataloader, | |
| test_dataloader, args) | |
| if args.do_eval: | |
| trainer.args.train_matrix = test_rating_matrix | |
| trainer.load(args.checkpoint_path) | |
| print(f'Load model from {args.checkpoint_path} for test!') | |
| scores, result_info = trainer.test(0, full_sort=True) | |
| else: | |
| if args.load_pretrain: | |
| print('Performance of pre-trained model on the validation set:') | |
| trainer.valid(0, full_sort=True) | |
| early_stopping = EarlyStopping(args.checkpoint_path, patience=args.patience, verbose=True) | |
| for epoch in range(args.epochs): | |
| trainer.train(epoch) | |
| if epoch > args.start_valid: | |
| scores, _ = trainer.valid(epoch, full_sort=True) | |
| early_stopping(np.array(scores[-1:]), trainer.model) | |
| if early_stopping.early_stop: | |
| print("Early stopping") | |
| break | |
| trainer.args.train_matrix = test_rating_matrix | |
| # load the best model | |
| trainer.model.load_state_dict(torch.load(args.checkpoint_path)) | |
| scores, result_info = trainer.test(0, full_sort=True) | |
| with open(args.log_file, 'a') as f: | |
| f.write(args_str + '\n') | |
| f.write(result_info + '\n') | |
| main() | |