Download annotations/annotation_34/ELCRec/src/main.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 9.98 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_34/ELCRec/src/main.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_34/ELCRec/src/main.py
-
curl -L -o main.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_34/ELCRec/src/main.py
9.98 kB
| import os | |
| import torch | |
| import argparse | |
| import numpy as np | |
| from tqdm import tqdm | |
| from models import SASRecModel | |
| from trainers import ELCRecTrainer | |
| from utils import get_user_seqs, check_path, set_seed | |
| from datasets import RecWithContrastiveLearningDataset | |
| from torch.utils.data import DataLoader, RandomSampler, SequentialSampler | |
| from utils import EarlyStopping, get_user_seqs, get_item2attribute_json, check_path, set_seed | |
| def main(): | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--data_dir", default="../data/", type=str) | |
| parser.add_argument("--output_dir", default="output/", type=str) | |
| parser.add_argument("--data_name", default="Sports_and_Outdoors", type=str) | |
| parser.add_argument("--do_eval", action="store_true") | |
| parser.add_argument("--model_idx", default=0, type=int, help="model idenfier 10, 20, 30...") | |
| parser.add_argument("--gpu_id", type=str, default="0", help="gpu_id") | |
| 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( | |
| "--augment_type", | |
| default="random", | |
| type=str, | |
| help="default data augmentation types. Chosen from: \ | |
| mask, crop, reorder, substitute, insert, random, \ | |
| combinatorial_enumerate (for multi-view).", | |
| ) | |
| parser.add_argument("--tao", type=float, default=0.2, help="crop ratio for crop operator") | |
| parser.add_argument("--gamma", type=float, default=0.7, help="mask ratio for mask operator") | |
| parser.add_argument("--beta", type=float, default=0.2, help="reorder ratio for reorder operator") | |
| ## contrastive learning task args | |
| parser.add_argument( | |
| "--temperature", default=1.0, type=float, help="softmax temperature (default: 1.0) - not studied." | |
| ) | |
| parser.add_argument( | |
| "--n_views", default=2, type=int, metavar="N", help="Number of augmented data for each sequence - not studied." | |
| ) | |
| parser.add_argument( | |
| "--contrast_type", | |
| default="Hybrid", | |
| type=str, | |
| help="Ways to contrastive of. \ | |
| Support InstanceCL and ShortInterestCL, IntentCL, and Hybrid types.", | |
| ) | |
| parser.add_argument( | |
| "--num_intent_clusters", | |
| default="256", | |
| type=str, | |
| help="Number of cluster of intents. Activated only when using \ | |
| IntentCL or Hybrid types.", | |
| ) | |
| parser.add_argument( | |
| "--seq_representation_type", | |
| default="mean", | |
| type=str, | |
| help="operate of item representation overtime. Support types: \ | |
| mean, concatenate", | |
| ) | |
| parser.add_argument( | |
| "--seq_representation_instancecl_type", | |
| default="concatenate", | |
| type=str, | |
| help="operate of item representation overtime. Support types: \ | |
| mean, concatenate", | |
| ) | |
| parser.add_argument("--warm_up_epoches", type=float, default=0, help="number of epochs to start IntentCL.") | |
| parser.add_argument("--de_noise", action="store_true", help="whether to de-false negative pairs during learning.") | |
| # model args | |
| parser.add_argument("--model_name", default="ELCRec", type=str) | |
| parser.add_argument("--hidden_size", type=int, default=64, help="hidden size of transformer model") | |
| parser.add_argument("--num_hidden_layers", type=int, default=2, help="number of layers") | |
| parser.add_argument("--num_attention_heads", default=2, type=int) | |
| parser.add_argument("--hidden_act", default="gelu", type=str) # gelu relu | |
| parser.add_argument("--attention_probs_dropout_prob", type=float, default=0.5, help="attention dropout p") | |
| parser.add_argument("--hidden_dropout_prob", type=float, default=0.5, help="hidden dropout p") | |
| parser.add_argument("--initializer_range", type=float, default=0.02) | |
| parser.add_argument("--max_seq_length", default=50, type=int) | |
| # 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("--epochs", type=int, default=300, help="number of epochs") | |
| 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=1, type=int) | |
| parser.add_argument("--cf_weight", type=float, default=0.1, help="weight of contrastive learning task") | |
| parser.add_argument("--rec_weight", type=float, default=1.0, help="weight of contrastive learning task") | |
| parser.add_argument("--intent_cf_weight", type=float, default=0.3, help="weight of contrastive learning task") | |
| # 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") | |
| parser.add_argument("--wandb", action="store_true", default=False) | |
| # parser.add_argument("--wandb", action="store_true", default=True) | |
| args = parser.parse_args() | |
| set_seed(args.seed) | |
| check_path(args.output_dir) | |
| if args.data_name in ["Toys_and_Games", "Sports_and_Outdoors"]: | |
| args.num_intent_clusters = "512" | |
| elif args.data_name in ["Yelp", "Beauty", "ml-1m"]: | |
| args.num_intent_clusters = "256" | |
| if args.data_name in ["Toys_and_Games", "Sports_and_Outdoors"]: | |
| args.trade_off = 1 | |
| elif args.data_name in ["Yelp"]: | |
| args.trade_off = 0.1 | |
| elif args.data_name in ["Beauty"]: | |
| args.trade_off = 10 | |
| if args.data_name in ["Beauty"]: | |
| args.prototype = "shift" | |
| else: | |
| args.prototype = "concat" | |
| 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 | |
| args.mask_id = max_item + 1 | |
| args_str = f"{args.model_name}-{args.data_name}-{args.model_idx}" | |
| args.log_file = os.path.join(args.output_dir, args_str + ".txt") | |
| with open(args.log_file, "a") as f: | |
| f.write(str(args) + "\n") | |
| args.train_matrix = valid_rating_matrix | |
| checkpoint = args_str + ".pt" | |
| args.checkpoint_path = os.path.join(args.output_dir, checkpoint) | |
| cluster_dataset = RecWithContrastiveLearningDataset( | |
| args, user_seq[: int(len(user_seq) * args.training_data_ratio)], data_type="train" | |
| ) | |
| cluster_sampler = SequentialSampler(cluster_dataset) | |
| cluster_dataloader = DataLoader(cluster_dataset, sampler=cluster_sampler, batch_size=args.batch_size) | |
| train_dataset = RecWithContrastiveLearningDataset( | |
| args, user_seq[: int(len(user_seq) * args.training_data_ratio)], data_type="train" | |
| ) | |
| train_sampler = RandomSampler(train_dataset) | |
| train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.batch_size) | |
| eval_dataset = RecWithContrastiveLearningDataset(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 = RecWithContrastiveLearningDataset(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 = SASRecModel(args=args) | |
| trainer = ELCRecTrainer(model, train_dataloader, cluster_dataloader, eval_dataloader, test_dataloader, args) | |
| if args.wandb: | |
| import wandb | |
| wandb.init(config=args, | |
| project="rec", | |
| dir="./wandb/", | |
| name="best_cluster_cluster_{}-{}".format(args.num_intent_clusters, args.data_name), | |
| job_type="training", | |
| reinit=True) | |
| 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: | |
| print(f"Train ICLRec") | |
| early_stopping = EarlyStopping(args.checkpoint_path, patience=40, verbose=True) | |
| for epoch in tqdm(range(args.epochs)): | |
| rec_avg_loss, joint_avg_loss = trainer.train(epoch) | |
| scores, _ = trainer.valid(epoch, full_sort=True) | |
| if args.wandb: | |
| wandb.log({"epoch": epoch, "rec_avg_loss": rec_avg_loss, "joint_avg_loss": joint_avg_loss, | |
| "hit@5": scores[0], "ndgc@5": scores[1], | |
| "hit@10": float(scores[2]), "ndgc@10": float(scores[3]), | |
| "hit@20": float(scores[4]), "ndgc@20": float(scores[5])}) | |
| early_stopping(np.array(scores[-1:]), trainer.model) | |
| if early_stopping.early_stop: | |
| print("Early stopping") | |
| break | |
| trainer.args.train_matrix = test_rating_matrix | |
| print("---------------Change to test_rating_matrix!-------------------") | |
| trainer.model.load_state_dict(torch.load(args.checkpoint_path)) | |
| scores, result_info = trainer.test(0, full_sort=True) | |
| print(args_str) | |
| print(result_info) | |
| with open(args.log_file, "a") as f: | |
| f.write(args_str + "\n") | |
| f.write(result_info + "\n") | |
| main() | |