Download annotations/annotation_34/ELCRec/src/datasets.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 6.12 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_34/ELCRec/src/datasets.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_34/ELCRec/src/datasets.py
-
curl -L -o datasets.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_34/ELCRec/src/datasets.py
6.12 kB
| import copy | |
| import torch | |
| import random | |
| from utils import neg_sample, nCr | |
| from torch.utils.data import Dataset | |
| from data_augmentation import Crop, Mask, Reorder, Random | |
| class RecWithContrastiveLearningDataset(Dataset): | |
| def __init__(self, args, user_seq, test_neg_items=None, data_type="train"): | |
| self.args = args | |
| self.user_seq = user_seq | |
| self.test_neg_items = test_neg_items | |
| self.data_type = data_type | |
| self.max_len = args.max_seq_length | |
| self.augmentations = { | |
| "crop": Crop(tao=args.tao), | |
| "mask": Mask(gamma=args.gamma), | |
| "reorder": Reorder(beta=args.beta), | |
| "random": Random(tao=args.tao, gamma=args.gamma, beta=args.beta), | |
| } | |
| if self.args.augment_type not in self.augmentations: | |
| raise ValueError(f"augmentation type: '{self.args.augment_type}' is invalided") | |
| print(f"Creating Contrastive Learning Dataset using '{self.args.augment_type}' data augmentation") | |
| self.base_transform = self.augmentations[self.args.augment_type] | |
| self.n_views = self.args.n_views | |
| def _one_pair_data_augmentation(self, input_ids): | |
| augmented_seqs = [] | |
| for i in range(2): | |
| augmented_input_ids = self.base_transform(input_ids) | |
| pad_len = self.max_len - len(augmented_input_ids) | |
| augmented_input_ids = [0] * pad_len + augmented_input_ids | |
| augmented_input_ids = augmented_input_ids[-self.max_len :] | |
| assert len(augmented_input_ids) == self.max_len | |
| cur_tensors = torch.tensor(augmented_input_ids, dtype=torch.long) | |
| augmented_seqs.append(cur_tensors) | |
| return augmented_seqs | |
| def _process_sequence_label_signal(self, seq_label_signal): | |
| seq_class_label = torch.tensor(seq_label_signal, dtype=torch.long) | |
| return seq_class_label | |
| def _data_sample_rec_task(self, user_id, items, input_ids, target_pos, answer): | |
| copied_input_ids = copy.deepcopy(input_ids) | |
| target_neg = [] | |
| seq_set = set(items) | |
| for _ in copied_input_ids: | |
| target_neg.append(neg_sample(seq_set, self.args.item_size)) | |
| pad_len = self.max_len - len(copied_input_ids) | |
| copied_input_ids = [0] * pad_len + copied_input_ids | |
| target_pos = [0] * pad_len + target_pos | |
| target_neg = [0] * pad_len + target_neg | |
| copied_input_ids = copied_input_ids[-self.max_len :] | |
| target_pos = target_pos[-self.max_len :] | |
| target_neg = target_neg[-self.max_len :] | |
| assert len(copied_input_ids) == self.max_len | |
| assert len(target_pos) == self.max_len | |
| assert len(target_neg) == self.max_len | |
| if self.test_neg_items is not None: | |
| test_samples = self.test_neg_items[index] | |
| cur_rec_tensors = ( | |
| torch.tensor(user_id, dtype=torch.long), # user_id for testing | |
| torch.tensor(copied_input_ids, dtype=torch.long), | |
| torch.tensor(target_pos, dtype=torch.long), | |
| torch.tensor(target_neg, dtype=torch.long), | |
| torch.tensor(answer, dtype=torch.long), | |
| torch.tensor(test_samples, dtype=torch.long), | |
| ) | |
| else: | |
| cur_rec_tensors = ( | |
| torch.tensor(user_id, dtype=torch.long), # user_id for testing | |
| torch.tensor(copied_input_ids, dtype=torch.long), | |
| torch.tensor(target_pos, dtype=torch.long), | |
| torch.tensor(target_neg, dtype=torch.long), | |
| torch.tensor(answer, dtype=torch.long), | |
| ) | |
| return cur_rec_tensors | |
| def _add_noise_interactions(self, items): | |
| copied_sequence = copy.deepcopy(items) | |
| insert_nums = max(int(self.args.noise_ratio * len(copied_sequence)), 0) | |
| if insert_nums == 0: | |
| return copied_sequence | |
| insert_idx = random.choices([i for i in range(len(copied_sequence))], k=insert_nums) | |
| inserted_sequence = [] | |
| for index, item in enumerate(copied_sequence): | |
| if index in insert_idx: | |
| item_id = random.randint(1, self.args.item_size - 2) | |
| while item_id in copied_sequence: | |
| item_id = random.randint(1, self.args.item_size - 2) | |
| inserted_sequence += [item_id] | |
| inserted_sequence += [item] | |
| return inserted_sequence | |
| def __getitem__(self, index): | |
| user_id = index | |
| items = self.user_seq[index] | |
| assert self.data_type in {"train", "valid", "test"} | |
| if self.data_type == "train": | |
| input_ids = items[:-3] | |
| target_pos = items[1:-2] | |
| seq_label_signal = items[-2] | |
| answer = [0] # no use | |
| elif self.data_type == "valid": | |
| input_ids = items[:-2] | |
| target_pos = items[1:-1] | |
| answer = [items[-2]] | |
| else: | |
| items_with_noise = self._add_noise_interactions(items) | |
| input_ids = items_with_noise[:-1] | |
| target_pos = items_with_noise[1:] | |
| answer = [items_with_noise[-1]] | |
| if self.data_type == "train": | |
| cur_rec_tensors = self._data_sample_rec_task(user_id, items, input_ids, target_pos, answer) | |
| cf_tensors_list = [] | |
| total_augmentaion_pairs = nCr(self.n_views, 2) | |
| for i in range(total_augmentaion_pairs): | |
| cf_tensors_list.append(self._one_pair_data_augmentation(input_ids)) | |
| seq_class_label = self._process_sequence_label_signal(seq_label_signal) | |
| return (cur_rec_tensors, cf_tensors_list, seq_class_label) | |
| elif self.data_type == "valid": | |
| cur_rec_tensors = self._data_sample_rec_task(user_id, items, input_ids, target_pos, answer) | |
| return cur_rec_tensors | |
| else: | |
| cur_rec_tensors = self._data_sample_rec_task(user_id, items_with_noise, input_ids, target_pos, answer) | |
| return cur_rec_tensors | |
| def __len__(self): | |
| """ | |
| consider n_view of a single sequence as one sample | |
| """ | |
| return len(self.user_seq) | |