mcy98's picture
Upload folder using huggingface_hub
e89a301 verified
Raw History Blame Contribute Delete
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)