Upload 101 files

.gitattributes

@@ -57,3 +57,36 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+HealthRec/Benchmarks/EB_NeRD/EB-NERD_behavior.tsv filter=lfs diff=lfs merge=lfs -text
+HealthRec/Benchmarks/QB/QB_data.xlsx filter=lfs diff=lfs merge=lfs -text
+HealthRec/Benchmarks/TN/TN_data.xlsx filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/NERD/prediction_health_NERD_BERT4Rec.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/NERD/prediction_health_NERD_BERT4Rec+.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/NERD/prediction_health_NERD_GRU4Rec.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/NERD/prediction_health_NERD_GRU4Rec+.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/NERD/prediction_health_NERD_NARM.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/NERD/prediction_health_NERD_NARM+.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/QB/prediction_health_QB_BERT4Rec.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/QB/prediction_health_QB_BERT4Rec+.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/QB/prediction_health_QB_GRU4Rec.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/QB/prediction_health_QB_GRU4Rec+.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/QB/prediction_health_QB_NARM.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/QB/prediction_health_QB_NARM+.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/TN/prediction_health_TN_BERT4Rec.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/TN/prediction_health_TN_BERT4Rec+.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/TN/prediction_health_TN_GRU4Rec.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/TN/prediction_health_TN_GRU4Rec+.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/TN/prediction_health_TN_NARM.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthinessMetrics/datasets/TN/prediction_health_TN_NARM+.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/BERT4Rec/BERTHealth/NERD/test.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/BERT4Rec/BERTHealth/NERD/train.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/BERT4Rec/BERTHealth/QB/train.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/BERT4Rec/BERTHealth/TN/train.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/NERD/test.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/NERD/train.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/QB/train.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/TN/train.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/NARM/datasetsHealth/NERD/test.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/NARM/datasetsHealth/NERD/train.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/NARM/datasetsHealth/QB/train.txt filter=lfs diff=lfs merge=lfs -text
+HealthRec/HealthRec_code/NARM/datasetsHealth/TN/train.txt filter=lfs diff=lfs merge=lfs -text

HealthRec/Benchmarks/EB_NeRD/EB-NERD_behavior.tsv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40cdbabced8035877274a7be00b5d12ce437aba1e65f089606f588a7e99c084b
+size 33969603

HealthRec/Benchmarks/QB/QB_data.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:170573963f5f65f27008db20a26c15877e8c647992c02c17bd7cc2e0ade1c117
+size 1140243

HealthRec/Benchmarks/TN/TN_data.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5268afb665917d3613268a451572c65cf5bda9f31c9e1c5cf60d566779a1ce03
+size 735550

HealthRec/Benchmarks/readme.md

@@ -0,0 +1,32 @@
+#### Investigating Recommender Systems from the Healthiness Perspective: Benchmarks, Warnings and Enhancement
+
+This contains the constructed Datasets, TN, QB and EB-NeRD for our work "Investigating Recommender Systems from the Healthiness Perspective: Benchmarks, Warnings and Enhancement" which aims to investigate recommender systems from a healthiness perspective.
+
+These three datasets are enriched from existing content recommendation datasets, where we add healthiness-related information into the original datasets, including healthiness tag (healthy or harmful), and corresponding reasons that provide justifications for the assigned tags.
+
+#### Item content information
+
+TN_data.xlsx, QB_data.xlsx and EB_NERD_data.xlsx are item content information which mainly contains:
+
+asin: original item ID.
+
+tag: A binary label that classifies content as either healthy or harmful. 0 indicates harmful, and 1 indicates healthy.
+
+reason: A textual explanation that provides the detailed reason supporting the healthiness classification.  
+
+title: item title information.
+
+title_english: English title information.
+
+abstract: item abstract information.
+
+abstract_english: English abstract information.
+
+#### User behavior data
+
+TN_behaviour.tsv, QB_behaviour.tsv and EB-NERD_behavior.tsv are user behavior data, that is, user-item interaction record, which follows the following format:
+
+User_ID, Item_ID, Item_ID, ..., Item_ID
+
+it indicates that a user (User_ID) has interacted with the following items.
+

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/NERD/H_neg_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f8abe18978a3deec718b230960d48084285fdf16ef777f645fe9d3fa2ab77b9
+size 3200

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/NERD/H_pos_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dde3f20ab1ee7b4d323c8c8a8af58ef19148a2f439b67c675c004777b6274a6
+size 3200

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/NERD/H_reason_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8758eb8e206047fbdf707cf36202577d679e62b5ec4cc7a54d15c695fedefa2b
+size 8263328

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/NERD/H_title_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5706ac3c6e8273608204edde9ff8df523719c5bfbf7d79d8d49044d63689d1c6
+size 8263328

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/NERD/test.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1af0f054e9fe068851e078f4946ae0bcbe363f7d215ace4d175ade5f9c1facaa
+size 711525

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/NERD/train.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01030665e746b1da26a4cfe598e5cbba77e09db14cc8f694f0b282dc0cb341a7
+size 6429180

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/QB/H_neg_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f8abe18978a3deec718b230960d48084285fdf16ef777f645fe9d3fa2ab77b9
+size 3200

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/QB/H_pos_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dde3f20ab1ee7b4d323c8c8a8af58ef19148a2f439b67c675c004777b6274a6
+size 3200

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/QB/H_reason_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e48330dbc4c2fca6d95ac7e17a181e5824bb602cf2c93996670642254eee26a5
+size 4751328

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/QB/H_title_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6adfa8e769d49b084bb341b2f4c9b7af25c25beb9fb79e5eaeab46a134b8a646
+size 4751328

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/QB/train.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f42bce183da5fad8fe7479527e80bb4749611122fc39657393173a65744921d8
+size 526672

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/TN/H_neg_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f8abe18978a3deec718b230960d48084285fdf16ef777f645fe9d3fa2ab77b9
+size 3200

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/TN/H_pos_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dde3f20ab1ee7b4d323c8c8a8af58ef19148a2f439b67c675c004777b6274a6
+size 3200

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/TN/H_reason_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfb9acc77f001da4f778233a7713e34355df5b809841dff3a5229b2e0815f53b
+size 2604128

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/TN/H_title_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:818d7d4cb5d306c1d8d6ceb4b13efee47d2686e5d6d8a71df44ce89fc5ffe658
+size 2604128

HealthRec/HealthRec_code/BERT4Rec/BERTHealth/TN/train.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6046fc536c91e604d7e5fcc0aa7fd4f8c0dd2e5026a35bf007e32d465203e6a4
+size 520159

HealthRec/HealthRec_code/BERT4Rec/Bert4Rec.py

@@ -0,0 +1,763 @@
+import torch
+import torch.nn.functional as F
+import torch.nn as nn
+from torch.optim.optimizer import Optimizer
+import math
+import random
+import numpy as np
+import pandas as pd
+from torch.utils.data import Dataset
+import tqdm
+from matplotlib import pyplot as plt
+import torch.backends.cudnn as cudnn
+from copy import deepcopy
+import os
+import datetime
+import pickle
+
+
+
+# seed = 1
+# random.seed(seed)
+# torch.manual_seed(seed)
+# torch.cuda.manual_seed_all(seed)
+# np.random.seed(seed)
+cudnn.deterministic = True
+cudnn.benchmark = False
+device = torch.device("cuda")
+# device = torch.device("cpu")
+
+session_length = 20
+batch_size = 512 #512
+plot_num = 5000
+epochs = 30
+
+
+class SessionData(object):
+    def __init__(self, session_index, session_id, items_indexes):
+        self.session_index = session_index
+        self.session_id = session_id
+        self.item_list = items_indexes
+
+    def generate_seq_datas(self, session_length, padding_idx=0, predict_length=1):
+        sessions = []
+        if len(self.item_list) < 2:
+            self.item_list.append[self.item_list[0]]
+        if predict_length == 1:
+            for i in range(len(self.item_list) - 1):
+                if i < session_length:
+                    train_data = [0 for _ in range(session_length - i - 1)]
+                    train_data.extend(self.item_list[:i + 1])
+                    train_data.append(self.item_list[i + 1])
+                else:
+                    train_data = self.item_list[i + 1 - session_length:i + 1]
+                    train_data.append(self.item_list[i + 1])
+                sessions.append(train_data)
+        else:
+            pass
+        return self.session_index, sessions
+
+    def __str__(self):
+        info = " session index = {}\n session id = {} \n the length of item list= {} \n the fisrt item index in item list is {}".format(
+            self.session_index, self.session_id, len(self.item_list), self.item_list[0])
+        return info
+
+
+class SessionDataSet(object):
+    def __init__(self, train_file, test_file, padding_idx=0):
+        super(SessionDataSet, self).__init__()
+        self.index_count = 0
+        self.session_count = 0
+        self.train_count = 0
+        self.test_count = 0
+        self.max_session_length = 0
+
+        self.padding_idx = padding_idx
+        self.item2index = dict()
+        self.index2item = dict()
+        self.session2index = dict()
+        self.index2session = dict()
+        self.item_total_num = dict()
+        self.item2index["<pad>"] = padding_idx
+        self.index2item[padding_idx] = "<pad>"
+        self.train_data = self.load_data(train_file)
+        print("training set is loaded, # index: ", len(self.item2index.keys()))
+        self.train_count = self.session_count
+        print("train_session_num", self.train_count)
+        self.test_data = self.load_data(test_file)
+        print("testing set is loaded, # index: ", len(self.index2item.keys()))
+        print("# item", self.index_count)
+        self.test_count = self.session_count - self.train_count
+        print("# test session:", self.test_count)
+        self.all_training_data = []
+        self.all_testing_data = []
+        self.all_meta_training_data = []
+        self.all_meta_testing_data = []
+        self.train_session_length = 0
+        self.test_session_length = 0
+
+    def load_data(self, file_path):
+        data = pickle.load(open(file_path, 'rb'))
+        session_ids = data[0]
+        session_data = data[1]
+        session_label = data[2]
+
+        result_data = []
+        lenth = len(session_ids)
+        print("# session", lenth)
+
+        last_session_id = session_ids[0]
+
+        session_item_indexes = []
+
+        for item_id in session_data[0]:
+            if item_id not in self.item2index.keys():
+                self.index_count += 1
+                self.item2index[item_id] = self.index_count
+                self.index2item[self.index_count] = item_id
+                self.item_total_num[self.index_count] = 0
+            session_item_indexes.append(self.item2index[item_id])
+            self.item_total_num[self.item2index[item_id]] += 1
+        target_item = session_label[0]
+        if target_item not in self.item2index.keys():
+            self.index_count += 1
+            self.item2index[target_item] = self.index_count
+            self.index2item[self.index_count] = target_item
+            self.item_total_num[self.index_count] = 0
+        session_item_indexes.append(self.item2index[target_item])
+        self.item_total_num[self.item2index[target_item]] += 1
+
+        for session_id, items, target_item in zip(session_ids, session_data, session_label):
+            if session_id != last_session_id:
+
+                self.session_count += 1
+                self.session2index[last_session_id] = self.session_count
+                self.index2session[self.session_count] = last_session_id
+                if len(session_item_indexes) > self.max_session_length:
+                    self.max_session_length = len(session_item_indexes)
+                new_session = SessionData(self.session_count, last_session_id, session_item_indexes)
+                result_data.append(new_session)
+                last_session_id = session_id
+                session_item_indexes = []
+                for item_id in items:
+                    if item_id not in self.item2index.keys():
+                        self.index_count += 1
+                        self.item2index[item_id] = self.index_count
+                        self.index2item[self.index_count] = item_id
+                        self.item_total_num[self.index_count] = 0
+                    session_item_indexes.append(self.item2index[item_id])
+                    self.item_total_num[self.item2index[item_id]] += 1
+                if target_item not in self.item2index.keys():
+                    self.index_count += 1
+                    self.item2index[target_item] = self.index_count
+                    self.index2item[self.index_count] = target_item
+                    self.item_total_num[self.index_count] = 0
+                session_item_indexes.append(self.item2index[target_item])
+                self.item_total_num[self.item2index[target_item]] += 1
+            else:
+                continue
+
+        self.session_count += 1
+        self.session2index[last_session_id] = self.session_count
+        new_session = SessionData(self.session_count, last_session_id, session_item_indexes)
+        result_data.append(new_session)
+        print("loaded")
+        print(new_session)
+
+        return result_data
+
+    def get_batch(self, batch_size, session_length=10, predict_length=1, all_data=None, phase="train", neg_num=1,
+                  sampling_mathod="random"):
+
+        if phase == "train":
+            if all_data is None:
+                all_data = self.get_all_training_data(session_length)
+            indexes = np.random.permutation(all_data.shape[0])
+            all_data = all_data[indexes]
+        else:
+            if all_data is None:
+                all_data = self.get_all_testing_data(session_length)
+
+        sindex = 0
+        eindex = batch_size
+        while eindex < all_data.shape[0]:
+            batch = all_data[sindex: eindex]
+
+            temp = eindex
+            eindex = eindex + batch_size
+            sindex = temp
+            if phase == "train":
+                batch = self.divid_and_extend_negative_samples(batch, session_length=session_length,
+                                                               predict_length=predict_length, neg_num=neg_num,
+                                                               method=sampling_mathod)
+            else:
+                batch = [batch[:, :session_length], batch[:, session_length:]]
+            yield batch
+
+        if eindex >= all_data.shape[0]:
+            batch = all_data[sindex:]
+            if phase == "train":
+                batch = self.divid_and_extend_negative_samples(batch, session_length=session_length,
+                                                               predict_length=predict_length, neg_num=neg_num,
+                                                               method=sampling_mathod)
+            else:
+                batch = [batch[:, :session_length], batch[:, session_length:]]
+            yield batch
+
+    def get_batch_with_neg(self, batch_size, session_length=10, predict_length=1, all_data=None, phase="train",
+                           neg_num=1, sampling_mathod="random"):
+        if phase == "train":
+            all_data = self.get_all_training_data_with_neg(session_length, neg_num)
+            indexes = np.random.permutation(all_data.shape[0])
+            all_data = all_data[indexes]
+        else:
+            all_data = self.get_all_testing_data_with_neg(session_length, neg_num)
+
+        sindex = 0
+        eindex = batch_size
+        while eindex < all_data.shape[0]:
+            batch = all_data[sindex: eindex]
+
+            temp = eindex
+            eindex = eindex + batch_size
+            sindex = temp
+            if phase == "train":
+                batch = [batch[:, :session_length], batch[:, session_length:session_length + predict_length],
+                         batch[:, -neg_num:]]
+            else:
+                batch = [batch[:, :session_length], batch[:, session_length:]]
+            yield batch
+
+        if eindex >= all_data.shape[0]:
+            batch = all_data[sindex:]
+            if phase == "train":
+                batch = [batch[:, :session_length], batch[:, session_length:session_length + predict_length],
+                         batch[:, -neg_num:]]
+            else:
+                batch = [batch[:, :session_length], batch[:, session_length:]]
+            yield batch
+
+    def get_batch_tasks_with_neg(self, batch_size, session_length=10, predict_length=1, all_data=None, phase="train",
+                                 neg_num=1, sampling_mathod="random"):
+        if phase == "train":
+            all_data = self.get_all_meta_training_data_with_neg(session_length, neg_num)
+            random.shuffle(all_data)
+        else:
+            all_data = self.get_all_meta_testing_data_with_neg(session_length, neg_num)
+        sindex = 0
+        eindex = batch_size
+        while eindex < len(all_data):
+            batch = all_data[sindex: eindex]
+
+            temp = eindex
+            eindex = eindex + batch_size
+            sindex = temp
+
+            session_items = [batch[i][:, :session_length] for i in range(len(batch))]
+
+            target_item = [batch[i][:, session_length:session_length + predict_length] for i in range(len(batch))]
+
+            neg_item = [batch[i][:, -neg_num:] for i in range(len(batch))]
+            batch = [session_items, target_item, neg_item]
+            yield batch
+
+        if eindex >= len(all_data):
+            batch = all_data[sindex:]
+            session_items = [batch[i][:, :session_length] for i in range(len(batch))]
+
+            target_item = [batch[i][:, session_length:session_length + predict_length] for i in range(len(batch))]
+
+            neg_item = [batch[i][:, -neg_num:] for i in range(len(batch))]
+            batch = [session_items, target_item, neg_item]
+            yield batch
+
+    def divid_and_extend_negative_samples(self, batch_data, session_length, predict_length=1, neg_num=1,
+                                          method="random"):
+        """
+        divid and extend negative samples
+        """
+        neg_items = []
+        if method == "random":
+            for session_and_target in batch_data:
+                neg_item = []
+                for i in range(neg_num):
+                    rand_item = random.randint(1, self.index_count)
+                    while rand_item in session_and_target or rand_item in neg_item:
+                        rand_item = random.randint(1, self.index_count)
+                    neg_item.append(rand_item)
+                neg_items.append(neg_item)
+        else:
+
+            total_list = set()
+            for session in batch_data:
+                for i in session:
+                    total_list.add(i)
+            total_list = list(total_list)
+            total_list = sorted(total_list, key=lambda item: self.item_total_num[item], reverse=True)
+            for i, session in enumerate(batch_data):
+                np.random.choice(total_list)
+        session_items = batch_data[:, :session_length]
+        target_item = batch_data[:, session_length:]
+        neg_items = np.array(neg_items)
+        return [session_items, target_item, neg_items]
+
+    def get_all_training_data(self, session_length, predict_length=1):
+        if len(self.all_training_data) != 0 and self.train_session_length == session_length:
+            return self.all_training_data
+        print("Start building the all training dataset")
+        all_sessions = []
+        for session_data in self.train_data:
+            session_index, sessions = session_data.generate_seq_datas(session_length, padding_idx=self.padding_idx)
+            if sessions is not None:
+                all_sessions.extend(sessions)
+        all_sessions = np.array(all_sessions)
+        self.all_training_data = all_sessions
+        self.train_session_length = session_length
+        print("The total number of training samples is", all_sessions.shape)
+        return all_sessions
+
+    def get_all_testing_data(self, session_length, predict_length=1):
+        if len(self.all_testing_data) != 0 and self.test_session_length == session_length:
+            return self.all_testing_data
+        all_sessions = []
+        for session_data in self.test_data:
+            session_index, sessions = session_data.generate_seq_datas(session_length, padding_idx=self.padding_idx)
+            if sessions is not None:
+                all_sessions.extend(sessions)
+        all_sessions = np.array(all_sessions)
+        self.all_testing_data = all_sessions
+        self.test_session_length = session_length
+        print("The total number of testing samples is", all_sessions.shape)
+        return all_sessions
+
+    def __getitem__(self, idx):
+        pass
+
+    def __len__(self):
+        pass
+
+
+def bpr_loss(r):
+    return torch.sum(-torch.log(torch.sigmoid(r)))
+
+
+def get_hit_num(pred, y_truth):
+    """
+        pred: numpy type(batch_size,k)
+        y_truth: list type (batch_size,groudtruth_num)
+    """
+
+    hit_num = 0
+    for i in range(len(y_truth)):
+        for value in y_truth[i]:
+            hit_num += np.sum(pred[i] == value)
+    return hit_num
+
+
+def get_rr(pred, y_truth):
+    rr = 0.
+    for i in range(len(y_truth)):
+        for value in y_truth[i]:
+            hit_indexes = np.where(pred[i] == value)[0]
+            for hit_index in hit_indexes:
+                rr += 1 / (hit_index + 1)
+    return rr
+
+
+def get_dcg(pred, y_truth):
+    y_pred_score = np.zeros_like(pred)
+
+    for i in range(len(y_truth)):
+
+        for j, y_pred in enumerate(pred[i]):
+            if y_pred == y_truth[i][0]:
+                y_pred_score[i][j] = 1
+    gain = 2 ** y_pred_score - 1
+    discounts = np.tile(np.log2(np.arange(pred.shape[1]) + 2), (len(y_truth), 1))
+    dcg = np.sum(gain / discounts, axis=1)
+    return dcg
+
+
+def get_ndcg(pred, y_truth):
+    dcg = get_dcg(pred, y_truth)
+    idcg = get_dcg(np.concatenate((y_truth, np.zeros_like(pred)[:, :-1] - 1), axis=1), y_truth)
+    ndcg = np.sum(dcg / idcg)
+
+    return ndcg
+
+
+def dcg_score(y_pre, y_true, k):
+    y_pre_score = np.zeros(k)
+    if len(y_pre) > k:
+        y_pre = y_pre[:k]
+    for i in range(len(y_pre)):
+        pre_tag = y_pre[i]
+        if pre_tag in y_true:
+            y_pre_score[i] = 1
+    gain = 2 ** y_pre_score - 1
+    discounts = np.log2(np.arange(k) + 2)
+    return np.sum(gain / discounts)
+
+
+def ndcg_score(y_pre, y_true, k=5):
+    dcg = dcg_score(y_pre, y_true, k)
+    idcg = dcg_score(y_true, y_true, k)
+    return dcg / idcg
+
+
+loss_function = torch.nn.CrossEntropyLoss()
+
+
+class MultiHeadSelfAttention(torch.nn.Module):
+    def __init__(self, hidden_size, activate="relu", head_num=2, dropout=0, initializer_range=0.02):
+        super(MultiHeadSelfAttention, self).__init__()
+        self.config = list()
+
+        self.hidden_size = hidden_size
+
+        self.head_num = head_num
+        if (self.hidden_size) % head_num != 0:
+            raise ValueError(self.head_num, "error")
+        self.head_dim = self.hidden_size // self.head_num
+
+        self.query = torch.nn.Linear(self.hidden_size, self.hidden_size)
+        self.key = torch.nn.Linear(self.hidden_size, self.hidden_size)
+        self.value = torch.nn.Linear(self.hidden_size, self.hidden_size)
+        self.concat_weight = torch.nn.Linear(self.hidden_size, self.hidden_size, bias=False)
+        torch.nn.init.normal_(self.query.weight, 0, initializer_range)
+        torch.nn.init.normal_(self.key.weight, 0, initializer_range)
+        torch.nn.init.normal_(self.value.weight, 0, initializer_range)
+        torch.nn.init.normal_(self.concat_weight.weight, 0, initializer_range)
+        self.dropout = torch.nn.Dropout(dropout)
+
+    def dot_score(self, encoder_output):
+        query = self.dropout(self.query(encoder_output))
+        key = self.dropout(self.key(encoder_output))
+        # head_num * batch_size * session_length * head_dim
+        querys = torch.stack(query.chunk(self.head_num, -1), 0)
+        keys = torch.stack(key.chunk(self.head_num, -1), 0)
+        # head_num * batch_size * session_length * session_length
+        dots = querys.matmul(keys.permute(0, 1, 3, 2)) / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float))
+        #         print(len(dots),dots[0].shape)
+        return dots
+
+    def forward(self, encoder_outputs, mask=None):
+        attention_energies = self.dot_score(encoder_outputs)
+        value = self.dropout(self.value(encoder_outputs))
+
+        values = torch.stack(value.chunk(self.head_num, -1))
+
+        if mask is not None:
+            eye = torch.eye(mask.shape[-1]).to(device)
+            new_mask = torch.clamp_max((1 - (1 - mask.float()).unsqueeze(1).permute(0, 2, 1).bmm(
+                (1 - mask.float()).unsqueeze(1))) + eye, 1)
+            attention_energies = attention_energies - new_mask * 1e12
+            weights = F.softmax(attention_energies, dim=-1)
+            weights = weights * (1 - new_mask)
+        else:
+            weights = F.softmax(attention_energies, dim=2)
+
+        # head_num * batch_size * session_length * head_dim
+        outputs = weights.matmul(values)
+        # batch_size * session_length * hidden_size
+        outputs = torch.cat([outputs[i] for i in range(outputs.shape[0])], dim=-1)
+        outputs = self.dropout(self.concat_weight(outputs))
+
+        return outputs
+
+
+class PositionWiseFeedForward(torch.nn.Module):
+    def __init__(self, hidden_size, initializer_range=0.02):
+        super(PositionWiseFeedForward, self).__init__()
+        self.final1 = torch.nn.Linear(hidden_size, hidden_size * 4, bias=True)
+        self.final2 = torch.nn.Linear(hidden_size * 4, hidden_size, bias=True)
+        torch.nn.init.normal_(self.final1.weight, 0, initializer_range)
+        torch.nn.init.normal_(self.final2.weight, 0, initializer_range)
+
+    def forward(self, x):
+        x = F.gelu(self.final1(x))
+        x = self.final2(x)
+        return x
+
+
+class TransformerLayer(torch.nn.Module):
+    def __init__(self, hidden_size, activate="relu", head_num=2, dropout=0, attention_dropout=0,
+                 initializer_range=0.02):
+        super(TransformerLayer, self).__init__()
+        self.dropout = torch.nn.Dropout(dropout)
+        self.mh = MultiHeadSelfAttention(hidden_size=hidden_size, activate=activate, head_num=head_num,
+                                         dropout=attention_dropout, initializer_range=initializer_range)
+        self.pffn = PositionWiseFeedForward(hidden_size, initializer_range=initializer_range)
+        self.layer_norm = torch.nn.LayerNorm(hidden_size)
+        self.dropout = torch.nn.Dropout(dropout)
+
+    def forward(self, encoder_outputs, mask=None):
+        encoder_outputs = self.layer_norm(encoder_outputs + self.dropout(self.mh(encoder_outputs, mask)))
+        encoder_outputs = self.layer_norm(encoder_outputs + self.dropout(self.pffn(encoder_outputs)))
+        return encoder_outputs
+
+
+class BERT(torch.nn.Module):
+    def __init__(self, hidden_size=100, itemNum=0, posNum=0, padding_idx=0, dropout=0.5, attention_dropout=0,
+                 head_num=2, sa_layer_num=1,
+                 activate="relu", initializer_range=0.02):
+        super(BERT, self).__init__()
+        self.hidden_size = hidden_size
+        self.head_num = head_num
+        self.session_length = session_length
+        self.sa_layer_num = sa_layer_num
+        self.transformers = torch.nn.ModuleList([TransformerLayer(hidden_size, head_num=head_num, dropout=dropout,
+                                                                  attention_dropout=attention_dropout,
+                                                                  initializer_range=initializer_range) for _ in
+                                                 range(sa_layer_num)])
+
+    def forward(self, compute_output, attention_mask):
+        for sa_i in range(self.sa_layer_num):
+            compute_output = self.transformers[sa_i](compute_output, attention_mask)
+        return compute_output
+
+
+class BERT4Rec(torch.nn.Module):
+    def __init__(self, hidden_size=64, itemNum=0, posNum=0, padding_idx=0, dropout=0.5, attention_dropout=0, head_num=2,
+                 sa_layer_num=1,
+                 activate="relu", initializer_range=0.02):
+        super(BERT4Rec, self).__init__()
+        self.padding_idx = padding_idx
+        self.hidden_size = hidden_size
+        self.head_num = head_num
+        self.session_length = session_length
+        self.sa_layer_num = sa_layer_num
+        self.activate = torch.relu
+        self.dropout = torch.nn.Dropout(dropout)
+
+        self.mask_index = torch.tensor(itemNum + 1).to(device)
+        self.mask_position = torch.tensor(posNum + 1).to(device)
+        self.item_embedding = torch.nn.Embedding(itemNum + 2, hidden_size, padding_idx=self.padding_idx)
+        self.position_embedding = torch.nn.Embedding(posNum + 2, hidden_size, padding_idx=self.padding_idx)
+        self.bert = BERT(hidden_size=hidden_size, dropout=dropout, attention_dropout=attention_dropout,
+                         head_num=head_num, sa_layer_num=sa_layer_num,
+                         activate=activate, initializer_range=initializer_range)
+
+        # text_emb_path = './BERTHealth/QB/H_title_emb100.npy'
+        # textWeights = np.load(text_emb_path)
+        # self.item_embedding.weight.data.copy_(torch.from_numpy(textWeights))
+
+        torch.nn.init.normal_(self.item_embedding.weight, 0, initializer_range)
+        torch.nn.init.constant_(self.item_embedding.weight[0], 0)
+        torch.nn.init.normal_(self.position_embedding.weight, 0, initializer_range)
+        torch.nn.init.constant_(self.position_embedding.weight[0], 0)
+        self.projection = torch.nn.Linear(hidden_size, hidden_size, bias=True)
+        torch.nn.init.normal_(self.projection.weight, 0, initializer_range)
+        self.output_bias = torch.nn.Parameter(torch.zeros(itemNum, ))
+        self.layer_norm = torch.nn.LayerNorm(hidden_size)
+
+    def forward(self, session, mask_indexes=None):
+
+        mask = (session != 0).float()
+
+        mask = mask.unsqueeze(2).repeat((1, 1, self.hidden_size))
+        session_item_embeddings = self.item_embedding(session) * mask
+        positions = torch.arange(0, session.shape[1]).unsqueeze(0).repeat((session.shape[0], 1)).to(device)
+        session_position_embeddings = self.position_embedding(positions) * mask
+        session_item_vecs = self.dropout(self.layer_norm(session_item_embeddings + session_position_embeddings))
+        attention_mask = (session == self.padding_idx)
+        if mask_indexes is not None:
+            compute_output = self.dropout(self.bert(session_item_vecs, attention_mask).gather(1, mask_indexes))
+        else:
+            compute_output = self.dropout(self.bert(session_item_vecs, attention_mask)[:, -1, :])
+        compute_output = F.gelu(self.dropout(self.projection(compute_output)))
+        result = torch.matmul(compute_output, self.item_embedding.weight[1:-1].t()) + self.output_bias
+        return result
+
+    def predict_top_k(self, session, k=20):
+        result = self.forward(session)
+        result = torch.topk(result, k, dim=1)[1]
+
+        return result
+
+
+
+
+
+def train(args):
+    hidden_size = args["hidden_size"] if "hidden_size" in args.keys() else 100
+    attention_dropout = args["attention_dropout"] if "attention_dropout" in args.keys() else 0.2
+    dropout = args["dropout"] if "dropout" in args.keys() else 0.5
+    lr = args["lr"] if "lr" in args.keys() else 5e-4
+    sa_layer_num = args["sa_layer_num"] if "sa_layer_num" in args.keys() else 1
+    amsgrad = args["amsgrad"] if "amsgrad" in args.keys() else True
+    session_length = args["session_length"] if "session_length" in args.keys() else 200
+    head_num = args["head_num"] if "head_num" in args.keys() else 1
+    model = BERT4Rec(hidden_size=hidden_size, itemNum=dataset.index_count, posNum=session_length, padding_idx=0,
+                     dropout=dropout,
+                     activate="selu", attention_dropout=attention_dropout, head_num=head_num,
+                     sa_layer_num=sa_layer_num).to(device)
+    opti = torch.optim.Adam(model.parameters(), lr=lr)
+    patience = args["patience"] if "patience" in args.keys() else 5
+    best_model_hr = 0.0
+    best_model_mrr = 0.0
+    best_r1m = 0.0
+    best_model = None
+    predict_nums = [1, 5, 10, 20]
+    no_improvement_epoch = 0
+    start_train_time = datetime.datetime.now()
+    for epoch in range(epochs):
+        batch_losses = []
+        epoch_losses = []
+        model.train()
+        for i, batch_data in enumerate(dataset.get_batch(batch_size, session_length, phase="train")):
+            mask_item = torch.ones_like(torch.tensor(batch_data[1])) * dataset.index_count + 1
+            sessions = torch.cat([torch.tensor(batch_data[0]), mask_item], dim=-1)
+            target_items = torch.tensor(batch_data[1]).squeeze().to(device) - 1
+            result_pos = model(sessions.to(device))
+            loss = loss_function(result_pos, target_items)
+            opti.zero_grad()
+            loss.backward()
+            opti.step()
+            batch_losses.append(loss.cpu().detach().numpy())
+            epoch_losses.append(loss.cpu().detach().numpy())
+            if i % plot_num == 0:
+                time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                print("[%s] [%d/%d] %d mean_batch_loss : %0.6f" % (time, epoch + 1, epochs, i, np.mean(batch_losses)))
+                batch_losses = []
+
+        model.eval()
+        with torch.no_grad():
+            start_test_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            print("Start predicting", start_test_time)
+            rrs = [0 for _ in range(len(predict_nums))]
+            hit_nums = [0 for _ in range(len(predict_nums))]
+            ndcgs = [0 for _ in range(len(predict_nums))]
+            seq_save = []
+            label_save = []
+            pre_save = []
+            for i, batch_data in enumerate(dataset.get_batch(batch_size, session_length, phase="test")):
+                mask_item = torch.ones_like(torch.tensor(batch_data[1])) * dataset.index_count + 1
+                sessions = torch.cat([torch.tensor(batch_data[0]), mask_item], dim=-1).to(device)
+
+                target_items = np.array(batch_data[1]) - 1
+                y_pred = model.predict_top_k(sessions, 20).cpu().numpy()
+
+                # top-k item ID number
+                pre_k = y_pred + 1
+                seq_temp = sessions.tolist()
+                seq_save += seq_temp
+                label_save += np.array(batch_data[1]).flatten().tolist()
+                pre_save += pre_k.tolist()
+
+                for j, predict_num in enumerate(predict_nums):
+                    hit_nums[j] += get_hit_num(y_pred[:, :predict_num], target_items)
+                    rrs[j] += get_rr(y_pred[:, :predict_num], target_items)
+                    ndcgs[j] += get_ndcg(y_pred[:, :predict_num], target_items)
+
+            end_test_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+            hrs = [hit_num / len(dataset.all_testing_data) for hit_num in hit_nums]
+            mrrs = [rr / len(dataset.all_testing_data) for rr in rrs]
+            mndcgs = [ndcg / len(dataset.all_testing_data) for ndcg in ndcgs]
+            if hrs[-1] + mrrs[-1] > best_r1m:
+                # print("change best")
+                best_model = deepcopy(model)
+                # best_model_hr = hrs[-1]
+                # best_model_mrr = mrrs[-1]
+                # best_r1m = hrs[-1] + mrrs[-1]
+                best_model_hr = hrs
+                best_model_mrr = mrrs
+                best_model_ndcg = mndcgs
+                best_r1m = hrs[-1] + mrrs[-1]
+                no_improvement_epoch = 0
+                pre_save_path = "./BERTHealth/" + dataset_name + "/prediction_health.txt"
+                res_pre = (seq_save, label_save, pre_save)
+                pickle.dump(res_pre, open(pre_save_path, 'wb'))
+            else:
+                no_improvement_epoch += 1
+            print("testing finish [%s] " % end_test_time)
+            for k, predict_num in enumerate(predict_nums):
+                print("\tHR@%d=%.5f  MRR@%d=%.5f  NDCG@%d=%.5f" % (
+                    predict_num, hrs[k], predict_num, mrrs[k], predict_num, mndcgs[k]))
+        if no_improvement_epoch >= patience:
+            print("early stopping")
+            break
+    end_train_time = datetime.datetime.now()
+
+
+
+    print("training and testting over, Total time", end_train_time - start_train_time)
+    return best_model, best_model_hr, best_model_mrr, best_model_ndcg
+
+os.environ["CUDA_VISIBLE_DEVICES"] = "1"
+# TN/QB/NERD
+dataset_name = 'TN'
+train_path = './BERTHealth/' + dataset_name + '/train.txt'
+test_path = './BERTHealth/' + dataset_name + '/test.txt'
+dataset = SessionDataSet(train_file=train_path, test_file=test_path)
+# torch.cuda.set_device(1)
+epochs = 50
+hidden_sizes = [100]  # rr:100 dn:100
+dropouts = [0.3]  # rr:0.3 dn:0.3
+attention_dropouts = [0]  # rr:0 dn:0
+lrs = [1e-3]  # rr:1e-3 dn:5e-4
+session_lengths = [50]  # rr:50 dn:50
+sa_layer_nums = [4]  # rr:4 dn:4
+patience = 10
+head_nums = [2]  # rr:2 dn:4, 32 dimension each head
+amsgrads = [True]
+best_params = ""
+best_all_model = 0.0
+best_all_hr = 0.0
+best_all_mrr = 0.0
+best_all_r1m = 0.0
+print('datasets: ',dataset_name)
+for session_length in session_lengths:
+    for hidden_size, head_num in zip(hidden_sizes, head_nums):
+        for amsgrad in amsgrads:
+            for attention_dropout in attention_dropouts:
+                for dropout in dropouts:
+                    for lr in lrs:
+                        for sa_layer_num in sa_layer_nums:
+                            # for head_num in head_nums:
+                            args = {}
+                            print(
+                                "current model hyper-parameters: session_length=%d, hidden_size=%d, lr=%.4f,head_num=%d, amsgrad=%s, attention_dropout=%.2f, dropout=%.2f, sa_layer_num=%d. \n" % (
+                                    session_length, hidden_size, lr, head_num, str(amsgrad), attention_dropout,
+                                    dropout,
+                                    sa_layer_num))
+                            args["session_length"] = session_length
+                            args["hidden_size"] = hidden_size
+                            args["amsgrad"] = amsgrad
+                            args["attention_dropout"] = attention_dropout
+                            args["dropout"] = dropout
+                            args["sa_layer_num"] = sa_layer_num
+                            args["lr"] = lr
+                            args["head_num"] = head_num
+                            args["patience"] = patience
+                            best_model, best_model_hr, best_model_mrr, best_model_ndcg = train(args)
+                            # if best_model_hr + best_model_mrr > best_all_r1m:
+                            #     print("best model change")
+                            #     best_all_r1m = best_model_hr + best_model_mrr
+                            #     best_all_hr = best_model_hr
+                            #     best_all_mrr = best_model_mrr
+                            #     best_all_model = best_model
+                            #     best_params = "session_length-%d, hidden_size-%d, lr-%.4f,head_num=%d, amsgrad-%s, attention_dropout-%.2f, dropout-%.2f, sa_layer_num-%d" % (
+                            #         session_length, hidden_size, lr, head_num, str(amsgrad), attention_dropout,
+                            #         dropout,
+                            #         sa_layer_num)
+                            # best_model = None
+                            # print(
+                            #     "current model hyper-parameters: session_length=%d, hidden_size=%d, lr=%.4f,head_num=%d, amsgrad=%s, attention_dropout=%.2f, dropout=%.2f, sa_layer_num=%d. \n" % (
+                            #         session_length, hidden_size, lr, head_num, str(amsgrad), attention_dropout,
+                            #         dropout,
+                            #         sa_layer_num))
+                            print("current model hyper-parameters: session_length=%d, hidden_size=%d, head_num=%d, sa_layer_num=%d. \n" % (session_length, hidden_size,  head_num, sa_layer_num))
+                            # print("current model HR@20=%.5f  MRR@20=%.5f." % (best_model_hr, best_model_mrr))
+                            print('P@1\tP@5\tM@5\tN@5\tP@10\tM@10\tN@10\tP@20\tM@20\tN@20\t')
+                            print("%.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f" % (
+                                best_model_hr[0]*100, best_model_hr[1]*100, best_model_mrr[1]*100, best_model_ndcg[1]*100, best_model_hr[2]*100, best_model_mrr[2]*100, best_model_ndcg[2]*100, best_model_hr[3]*100, best_model_mrr[3]*100, best_model_ndcg[3]*100))
+
+
+                            # CKLLM 存储训练好的item embs,padding 0
+                            # save_path = './BERTCKLLM/' + dataset_name + '/item_embs.pth'
+                            # torch.save(best_model.item_embedding.state_dict(), save_path)
+# print("The best result HR@20=%.5f  MRR@20=%.5f, hyper-parameters: %s. " % (best_all_hr, best_all_mrr, best_params))
+print(dataset_name)
+print("over.")

HealthRec/HealthRec_code/BERT4Rec/Bert4RecHealth.py

@@ -0,0 +1,932 @@
+import torch
+import torch.nn.functional as F
+import torch.nn as nn
+from torch.optim.optimizer import Optimizer
+import math
+import random
+import numpy as np
+import pandas as pd
+from torch.utils.data import Dataset
+import tqdm
+from matplotlib import pyplot as plt
+import torch.backends.cudnn as cudnn
+from copy import deepcopy
+import os
+import datetime
+import pickle
+
+
+
+# seed = 1
+# random.seed(seed)
+# torch.manual_seed(seed)
+# torch.cuda.manual_seed_all(seed)
+# np.random.seed(seed)
+cudnn.deterministic = True
+cudnn.benchmark = False
+device = torch.device("cuda")
+# device = torch.device("cpu")
+
+session_length = 20
+batch_size = 512 #512
+plot_num = 5000
+epochs = 30
+
+
+class SessionData(object):
+    def __init__(self, session_index, session_id, items_indexes):
+        self.session_index = session_index
+        self.session_id = session_id
+        self.item_list = items_indexes
+
+    def generate_seq_datas(self, session_length, padding_idx=0, predict_length=1):
+        sessions = []
+        if len(self.item_list) < 2:
+            self.item_list.append[self.item_list[0]]
+        if predict_length == 1:
+            for i in range(len(self.item_list) - 1):
+                if i < session_length:
+                    train_data = [0 for _ in range(session_length - i - 1)]
+                    train_data.extend(self.item_list[:i + 1])
+                    train_data.append(self.item_list[i + 1])
+                else:
+                    train_data = self.item_list[i + 1 - session_length:i + 1]
+                    train_data.append(self.item_list[i + 1])
+                sessions.append(train_data)
+        else:
+            pass
+        return self.session_index, sessions
+
+    def __str__(self):
+        info = " session index = {}\n session id = {} \n the length of item list= {} \n the fisrt item index in item list is {}".format(
+            self.session_index, self.session_id, len(self.item_list), self.item_list[0])
+        return info
+
+
+class SessionDataSet(object):
+    def __init__(self, train_file, test_file, padding_idx=0):
+        super(SessionDataSet, self).__init__()
+        self.index_count = 0
+        self.session_count = 0
+        self.train_count = 0
+        self.test_count = 0
+        self.max_session_length = 0
+
+        self.padding_idx = padding_idx
+        self.item2index = dict()
+        self.index2item = dict()
+        self.session2index = dict()
+        self.index2session = dict()
+        self.item_total_num = dict()
+        self.item2index["<pad>"] = padding_idx
+        self.index2item[padding_idx] = "<pad>"
+        self.train_data = self.load_data(train_file)
+        print("training set is loaded, # index: ", len(self.item2index.keys()))
+        self.train_count = self.session_count
+        print("train_session_num", self.train_count)
+        self.test_data = self.load_data(test_file)
+        print("testing set is loaded, # index: ", len(self.index2item.keys()))
+        print("# item", self.index_count)
+        self.test_count = self.session_count - self.train_count
+        print("# test session:", self.test_count)
+        self.all_training_data = []
+        self.all_testing_data = []
+        self.all_meta_training_data = []
+        self.all_meta_testing_data = []
+        self.train_session_length = 0
+        self.test_session_length = 0
+
+    def load_data(self, file_path):
+        data = pickle.load(open(file_path, 'rb'))
+        session_ids = data[0]
+        session_data = data[1]
+        session_label = data[2]
+
+        result_data = []
+        lenth = len(session_ids)
+        print("# session", lenth)
+
+        last_session_id = session_ids[0]
+
+        session_item_indexes = []
+
+        for item_id in session_data[0]:
+            if item_id not in self.item2index.keys():
+                self.index_count += 1
+                self.item2index[item_id] = self.index_count
+                self.index2item[self.index_count] = item_id
+                self.item_total_num[self.index_count] = 0
+            session_item_indexes.append(self.item2index[item_id])
+            self.item_total_num[self.item2index[item_id]] += 1
+        target_item = session_label[0]
+        if target_item not in self.item2index.keys():
+            self.index_count += 1
+            self.item2index[target_item] = self.index_count
+            self.index2item[self.index_count] = target_item
+            self.item_total_num[self.index_count] = 0
+        session_item_indexes.append(self.item2index[target_item])
+        self.item_total_num[self.item2index[target_item]] += 1
+
+        for session_id, items, target_item in zip(session_ids, session_data, session_label):
+            if session_id != last_session_id:
+
+                self.session_count += 1
+                self.session2index[last_session_id] = self.session_count
+                self.index2session[self.session_count] = last_session_id
+                if len(session_item_indexes) > self.max_session_length:
+                    self.max_session_length = len(session_item_indexes)
+                new_session = SessionData(self.session_count, last_session_id, session_item_indexes)
+                result_data.append(new_session)
+                last_session_id = session_id
+                session_item_indexes = []
+                for item_id in items:
+                    if item_id not in self.item2index.keys():
+                        self.index_count += 1
+                        self.item2index[item_id] = self.index_count
+                        self.index2item[self.index_count] = item_id
+                        self.item_total_num[self.index_count] = 0
+                    session_item_indexes.append(self.item2index[item_id])
+                    self.item_total_num[self.item2index[item_id]] += 1
+                if target_item not in self.item2index.keys():
+                    self.index_count += 1
+                    self.item2index[target_item] = self.index_count
+                    self.index2item[self.index_count] = target_item
+                    self.item_total_num[self.index_count] = 0
+                session_item_indexes.append(self.item2index[target_item])
+                self.item_total_num[self.item2index[target_item]] += 1
+            else:
+                continue
+
+        self.session_count += 1
+        self.session2index[last_session_id] = self.session_count
+        new_session = SessionData(self.session_count, last_session_id, session_item_indexes)
+        result_data.append(new_session)
+        print("loaded")
+        print(new_session)
+
+        return result_data
+
+    def get_batch(self, batch_size, session_length=10, predict_length=1, all_data=None, phase="train", neg_num=1,
+                  sampling_mathod="random"):
+
+        if phase == "train":
+            if all_data is None:
+                all_data = self.get_all_training_data(session_length)
+            indexes = np.random.permutation(all_data.shape[0])
+            all_data = all_data[indexes]
+        else:
+            if all_data is None:
+                all_data = self.get_all_testing_data(session_length)
+
+        sindex = 0
+        eindex = batch_size
+        while eindex < all_data.shape[0]:
+            batch = all_data[sindex: eindex]
+
+            temp = eindex
+            eindex = eindex + batch_size
+            sindex = temp
+            if phase == "train":
+                batch = self.divid_and_extend_negative_samples(batch, session_length=session_length,
+                                                               predict_length=predict_length, neg_num=neg_num,
+                                                               method=sampling_mathod)
+            else:
+                batch = [batch[:, :session_length], batch[:, session_length:]]
+            yield batch
+
+        if eindex >= all_data.shape[0]:
+            batch = all_data[sindex:]
+            if phase == "train":
+                batch = self.divid_and_extend_negative_samples(batch, session_length=session_length,
+                                                               predict_length=predict_length, neg_num=neg_num,
+                                                               method=sampling_mathod)
+            else:
+                batch = [batch[:, :session_length], batch[:, session_length:]]
+            yield batch
+
+    def get_batch_with_neg(self, batch_size, session_length=10, predict_length=1, all_data=None, phase="train",
+                           neg_num=1, sampling_mathod="random"):
+        if phase == "train":
+            all_data = self.get_all_training_data_with_neg(session_length, neg_num)
+            indexes = np.random.permutation(all_data.shape[0])
+            all_data = all_data[indexes]
+        else:
+            all_data = self.get_all_testing_data_with_neg(session_length, neg_num)
+
+        sindex = 0
+        eindex = batch_size
+        while eindex < all_data.shape[0]:
+            batch = all_data[sindex: eindex]
+
+            temp = eindex
+            eindex = eindex + batch_size
+            sindex = temp
+            if phase == "train":
+                batch = [batch[:, :session_length], batch[:, session_length:session_length + predict_length],
+                         batch[:, -neg_num:]]
+            else:
+                batch = [batch[:, :session_length], batch[:, session_length:]]
+            yield batch
+
+        if eindex >= all_data.shape[0]:
+            batch = all_data[sindex:]
+            if phase == "train":
+                batch = [batch[:, :session_length], batch[:, session_length:session_length + predict_length],
+                         batch[:, -neg_num:]]
+            else:
+                batch = [batch[:, :session_length], batch[:, session_length:]]
+            yield batch
+
+    def get_batch_tasks_with_neg(self, batch_size, session_length=10, predict_length=1, all_data=None, phase="train",
+                                 neg_num=1, sampling_mathod="random"):
+        if phase == "train":
+            all_data = self.get_all_meta_training_data_with_neg(session_length, neg_num)
+            random.shuffle(all_data)
+        else:
+            all_data = self.get_all_meta_testing_data_with_neg(session_length, neg_num)
+        sindex = 0
+        eindex = batch_size
+        while eindex < len(all_data):
+            batch = all_data[sindex: eindex]
+
+            temp = eindex
+            eindex = eindex + batch_size
+            sindex = temp
+
+            session_items = [batch[i][:, :session_length] for i in range(len(batch))]
+
+            target_item = [batch[i][:, session_length:session_length + predict_length] for i in range(len(batch))]
+
+            neg_item = [batch[i][:, -neg_num:] for i in range(len(batch))]
+            batch = [session_items, target_item, neg_item]
+            yield batch
+
+        if eindex >= len(all_data):
+            batch = all_data[sindex:]
+            session_items = [batch[i][:, :session_length] for i in range(len(batch))]
+
+            target_item = [batch[i][:, session_length:session_length + predict_length] for i in range(len(batch))]
+
+            neg_item = [batch[i][:, -neg_num:] for i in range(len(batch))]
+            batch = [session_items, target_item, neg_item]
+            yield batch
+
+    def divid_and_extend_negative_samples(self, batch_data, session_length, predict_length=1, neg_num=1,
+                                          method="random"):
+        """
+        divid and extend negative samples
+        """
+        neg_items = []
+        if method == "random":
+            for session_and_target in batch_data:
+                neg_item = []
+                for i in range(neg_num):
+                    rand_item = random.randint(1, self.index_count)
+                    while rand_item in session_and_target or rand_item in neg_item:
+                        rand_item = random.randint(1, self.index_count)
+                    neg_item.append(rand_item)
+                neg_items.append(neg_item)
+        else:
+
+            total_list = set()
+            for session in batch_data:
+                for i in session:
+                    total_list.add(i)
+            total_list = list(total_list)
+            total_list = sorted(total_list, key=lambda item: self.item_total_num[item], reverse=True)
+            for i, session in enumerate(batch_data):
+                np.random.choice(total_list)
+        session_items = batch_data[:, :session_length]
+        target_item = batch_data[:, session_length:]
+        neg_items = np.array(neg_items)
+        return [session_items, target_item, neg_items]
+
+    def get_all_training_data(self, session_length, predict_length=1):
+        if len(self.all_training_data) != 0 and self.train_session_length == session_length:
+            return self.all_training_data
+        print("Start building the all training dataset")
+        all_sessions = []
+        for session_data in self.train_data:
+            session_index, sessions = session_data.generate_seq_datas(session_length, padding_idx=self.padding_idx)
+            if sessions is not None:
+                all_sessions.extend(sessions)
+        all_sessions = np.array(all_sessions)
+        self.all_training_data = all_sessions
+        self.train_session_length = session_length
+        print("The total number of training samples is", all_sessions.shape)
+        return all_sessions
+
+    def get_all_testing_data(self, session_length, predict_length=1):
+        if len(self.all_testing_data) != 0 and self.test_session_length == session_length:
+            return self.all_testing_data
+        all_sessions = []
+        for session_data in self.test_data:
+            session_index, sessions = session_data.generate_seq_datas(session_length, padding_idx=self.padding_idx)
+            if sessions is not None:
+                all_sessions.extend(sessions)
+        all_sessions = np.array(all_sessions)
+        self.all_testing_data = all_sessions
+        self.test_session_length = session_length
+        print("The total number of testing samples is", all_sessions.shape)
+        return all_sessions
+
+    def __getitem__(self, idx):
+        pass
+
+    def __len__(self):
+        pass
+
+
+def bpr_loss(r):
+    return torch.sum(-torch.log(torch.sigmoid(r)))
+
+
+def get_hit_num(pred, y_truth):
+    """
+        pred: numpy type(batch_size,k)
+        y_truth: list type (batch_size,groudtruth_num)
+    """
+
+    hit_num = 0
+    for i in range(len(y_truth)):
+        for value in y_truth[i]:
+            hit_num += np.sum(pred[i] == value)
+    return hit_num
+
+
+def get_rr(pred, y_truth):
+    rr = 0.
+    for i in range(len(y_truth)):
+        for value in y_truth[i]:
+            hit_indexes = np.where(pred[i] == value)[0]
+            for hit_index in hit_indexes:
+                rr += 1 / (hit_index + 1)
+    return rr
+
+
+def get_dcg(pred, y_truth):
+    y_pred_score = np.zeros_like(pred)
+
+    for i in range(len(y_truth)):
+
+        for j, y_pred in enumerate(pred[i]):
+            if y_pred == y_truth[i][0]:
+                y_pred_score[i][j] = 1
+    gain = 2 ** y_pred_score - 1
+    discounts = np.tile(np.log2(np.arange(pred.shape[1]) + 2), (len(y_truth), 1))
+    dcg = np.sum(gain / discounts, axis=1)
+    return dcg
+
+
+def get_ndcg(pred, y_truth):
+    dcg = get_dcg(pred, y_truth)
+    idcg = get_dcg(np.concatenate((y_truth, np.zeros_like(pred)[:, :-1] - 1), axis=1), y_truth)
+    ndcg = np.sum(dcg / idcg)
+
+    return ndcg
+
+
+def dcg_score(y_pre, y_true, k):
+    y_pre_score = np.zeros(k)
+    if len(y_pre) > k:
+        y_pre = y_pre[:k]
+    for i in range(len(y_pre)):
+        pre_tag = y_pre[i]
+        if pre_tag in y_true:
+            y_pre_score[i] = 1
+    gain = 2 ** y_pre_score - 1
+    discounts = np.log2(np.arange(k) + 2)
+    return np.sum(gain / discounts)
+
+
+def ndcg_score(y_pre, y_true, k=5):
+    dcg = dcg_score(y_pre, y_true, k)
+    idcg = dcg_score(y_true, y_true, k)
+    return dcg / idcg
+
+
+loss_function = torch.nn.CrossEntropyLoss()
+
+
+class MultiHeadSelfAttention(torch.nn.Module):
+    def __init__(self, hidden_size, activate="relu", head_num=2, dropout=0, initializer_range=0.02):
+        super(MultiHeadSelfAttention, self).__init__()
+        self.config = list()
+
+        self.hidden_size = hidden_size
+
+        self.head_num = head_num
+        if (self.hidden_size) % head_num != 0:
+            raise ValueError(self.head_num, "error")
+        self.head_dim = self.hidden_size // self.head_num
+
+        self.query = torch.nn.Linear(self.hidden_size, self.hidden_size)
+        self.key = torch.nn.Linear(self.hidden_size, self.hidden_size)
+        self.value = torch.nn.Linear(self.hidden_size, self.hidden_size)
+        self.concat_weight = torch.nn.Linear(self.hidden_size, self.hidden_size, bias=False)
+        torch.nn.init.normal_(self.query.weight, 0, initializer_range)
+        torch.nn.init.normal_(self.key.weight, 0, initializer_range)
+        torch.nn.init.normal_(self.value.weight, 0, initializer_range)
+        torch.nn.init.normal_(self.concat_weight.weight, 0, initializer_range)
+        self.dropout = torch.nn.Dropout(dropout)
+
+    def dot_score(self, encoder_output):
+        query = self.dropout(self.query(encoder_output))
+        key = self.dropout(self.key(encoder_output))
+        # head_num * batch_size * session_length * head_dim
+        querys = torch.stack(query.chunk(self.head_num, -1), 0)
+        keys = torch.stack(key.chunk(self.head_num, -1), 0)
+        # head_num * batch_size * session_length * session_length
+        dots = querys.matmul(keys.permute(0, 1, 3, 2)) / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float))
+        #         print(len(dots),dots[0].shape)
+        return dots
+
+    def forward(self, encoder_outputs, mask=None):
+        attention_energies = self.dot_score(encoder_outputs)
+        value = self.dropout(self.value(encoder_outputs))
+
+        values = torch.stack(value.chunk(self.head_num, -1))
+
+        if mask is not None:
+            eye = torch.eye(mask.shape[-1]).to(device)
+            new_mask = torch.clamp_max((1 - (1 - mask.float()).unsqueeze(1).permute(0, 2, 1).bmm(
+                (1 - mask.float()).unsqueeze(1))) + eye, 1)
+            attention_energies = attention_energies - new_mask * 1e12
+            weights = F.softmax(attention_energies, dim=-1)
+            weights = weights * (1 - new_mask)
+        else:
+            weights = F.softmax(attention_energies, dim=2)
+
+        # head_num * batch_size * session_length * head_dim
+        outputs = weights.matmul(values)
+        # batch_size * session_length * hidden_size
+        outputs = torch.cat([outputs[i] for i in range(outputs.shape[0])], dim=-1)
+        outputs = self.dropout(self.concat_weight(outputs))
+
+        return outputs
+
+
+class PositionWiseFeedForward(torch.nn.Module):
+    def __init__(self, hidden_size, initializer_range=0.02):
+        super(PositionWiseFeedForward, self).__init__()
+        self.final1 = torch.nn.Linear(hidden_size, hidden_size * 4, bias=True)
+        self.final2 = torch.nn.Linear(hidden_size * 4, hidden_size, bias=True)
+        torch.nn.init.normal_(self.final1.weight, 0, initializer_range)
+        torch.nn.init.normal_(self.final2.weight, 0, initializer_range)
+
+    def forward(self, x):
+        x = F.gelu(self.final1(x))
+        x = self.final2(x)
+        return x
+
+
+class TransformerLayer(torch.nn.Module):
+    def __init__(self, hidden_size, activate="relu", head_num=2, dropout=0, attention_dropout=0,
+                 initializer_range=0.02):
+        super(TransformerLayer, self).__init__()
+        self.dropout = torch.nn.Dropout(dropout)
+        self.mh = MultiHeadSelfAttention(hidden_size=hidden_size, activate=activate, head_num=head_num,
+                                         dropout=attention_dropout, initializer_range=initializer_range)
+        self.pffn = PositionWiseFeedForward(hidden_size, initializer_range=initializer_range)
+        self.layer_norm = torch.nn.LayerNorm(hidden_size)
+        self.dropout = torch.nn.Dropout(dropout)
+
+    def forward(self, encoder_outputs, mask=None):
+        encoder_outputs = self.layer_norm(encoder_outputs + self.dropout(self.mh(encoder_outputs, mask)))
+        encoder_outputs = self.layer_norm(encoder_outputs + self.dropout(self.pffn(encoder_outputs)))
+        return encoder_outputs
+
+
+class BERT(torch.nn.Module):
+    def __init__(self, hidden_size=100, itemNum=0, posNum=0, padding_idx=0, dropout=0.5, attention_dropout=0,
+                 head_num=2, sa_layer_num=1,
+                 activate="relu", initializer_range=0.02):
+        super(BERT, self).__init__()
+        self.hidden_size = hidden_size
+        self.head_num = head_num
+        self.session_length = session_length
+        self.sa_layer_num = sa_layer_num
+        self.transformers = torch.nn.ModuleList([TransformerLayer(hidden_size, head_num=head_num, dropout=dropout,
+                                                                  attention_dropout=attention_dropout,
+                                                                  initializer_range=initializer_range) for _ in
+                                                 range(sa_layer_num)])
+
+    def forward(self, compute_output, attention_mask):
+        for sa_i in range(self.sa_layer_num):
+            compute_output = self.transformers[sa_i](compute_output, attention_mask)
+        return compute_output
+
+
+class BERT4Rec(torch.nn.Module):
+    def __init__(self, hidden_size=64, itemNum=0, posNum=0, padding_idx=0, dropout=0.5, attention_dropout=0, head_num=2,
+                 sa_layer_num=1, datasets = "TN", h_lamdba=0.05,
+                 activate="relu", initializer_range=0.02):
+        super(BERT4Rec, self).__init__()
+        self.padding_idx = padding_idx
+        self.hidden_size = hidden_size
+        self.head_num = head_num
+        self.session_length = session_length
+        self.sa_layer_num = sa_layer_num
+        self.activate = torch.relu
+        self.dropout = torch.nn.Dropout(dropout)
+
+        self.n_items = itemNum +2
+
+        self.h_lamdba = h_lamdba
+
+        self.mask_index = torch.tensor(itemNum + 1).to(device)
+        self.mask_position = torch.tensor(posNum + 1).to(device)
+        self.item_embedding = torch.nn.Embedding(itemNum + 2, hidden_size, padding_idx=self.padding_idx)
+        self.position_embedding = torch.nn.Embedding(posNum + 2, hidden_size, padding_idx=self.padding_idx)
+        self.bert = BERT(hidden_size=hidden_size, dropout=dropout, attention_dropout=attention_dropout,
+                         head_num=head_num, sa_layer_num=sa_layer_num,
+                         activate=activate, initializer_range=initializer_range)
+
+        # torch.nn.init.normal_(self.item_embedding.weight, 0, initializer_range)
+        # torch.nn.init.constant_(self.item_embedding.weight[0], 0)
+
+        text_emb_path = './BERTHealth/' + datasets + '/H_title_emb100.npy'
+        textWeights = np.load(text_emb_path)
+        if datasets == 'NERD':
+            textWeights = np.vstack((textWeights, np.zeros(hidden_size)))
+        self.item_embedding.weight.data.copy_(torch.from_numpy(textWeights))
+
+        self.emb_healthy = nn.Embedding(2, 768, padding_idx=0)
+        self.emb_harmful = nn.Embedding(2, 768, padding_idx=0)
+        self.emb_reason = nn.Embedding(itemNum + 2, hidden_size, padding_idx=0)
+
+        reason_emb_path = './BERTHealth/' + datasets + '/H_reason_emb100.npy'
+        reasonWeights = np.load(reason_emb_path)
+        if datasets == 'NERD':
+            reasonWeights = np.vstack((reasonWeights, np.zeros(hidden_size)))
+        self.emb_reason.weight.data.copy_(torch.from_numpy(reasonWeights))
+
+        self.emb_reason.weight.requires_grad = False
+
+        health_emb_path = './BERTHealth/' + datasets + '/H_pos_emb100.npy'
+        healWeights = np.load(health_emb_path)
+        self.emb_healthy.weight.data.copy_(torch.from_numpy(healWeights))
+        self.emb_healthy.weight.requires_grad = False
+
+        harm_emb_path = './BERTHealth/' + datasets + '/H_neg_emb100.npy'
+        harmWeights = np.load(harm_emb_path)
+        self.emb_harmful.weight.data.copy_(torch.from_numpy(harmWeights))
+        self.emb_harmful.weight.requires_grad = False
+
+        self.dense_text_health = nn.Linear(768, hidden_size)
+        self.dense_text_harm = nn.Linear(768, hidden_size)
+
+        self.cos_sim = nn.CosineSimilarity(dim=-1)
+        self.ul_W1 = nn.Linear(hidden_size, hidden_size)
+        self.ul_W2 = nn.Linear(hidden_size, hidden_size)
+        self.ul_W3 = nn.Linear(hidden_size, hidden_size)
+
+        # self_attention
+        num_heads = 4
+        if hidden_size % num_heads != 0:  # 整除
+            raise ValueError(
+                "The hidden size (%d) is not a multiple of the number of attention "
+                "heads (%d)" % (hidden_size, num_heads))
+            # 参数定义
+        self.num_heads = num_heads  # 4
+        self.attention_head_size = int(hidden_size / self.num_heads)  # 16  每个注意力头的维度
+        self.all_head_size = int(self.num_heads * self.attention_head_size)
+        # query, key, value 的线性变换（上述公式2）
+        self.query = nn.Linear(hidden_size, hidden_size)  # 128, 128
+        self.key = nn.Linear(hidden_size, hidden_size)
+        self.value = nn.Linear(hidden_size, hidden_size)
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+        torch.nn.init.normal_(self.position_embedding.weight, 0, initializer_range)
+        torch.nn.init.constant_(self.position_embedding.weight[0], 0)
+        self.projection = torch.nn.Linear(hidden_size, hidden_size, bias=True)
+        torch.nn.init.normal_(self.projection.weight, 0, initializer_range)
+        self.output_bias = torch.nn.Parameter(torch.zeros(itemNum, ))
+        self.layer_norm = torch.nn.LayerNorm(hidden_size)
+
+    def transpose_for_scores(self, x, attention_head_size):
+        # INPUT:  x'shape = [bs, seqlen, hid_size]  假设hid_size=128
+        new_x_shape = x.size()[:-1] + (self.num_heads, attention_head_size)  # [bs, seqlen, 8, 16]
+        x = x.view(*new_x_shape)  #
+        return x.permute(0, 2, 1, 3)
+
+    def user_loss(self, user_emb, health_emb, harm_emb):
+        # health_sim = self.cos_sim(self.ul_W1(user_emb), self.ul_W2(health_emb))
+        # harm_sim = self.cos_sim(self.ul_W1(user_emb), self.ul_W3(harm_emb))
+
+        health_sim = self.ul_W1(user_emb) * self.ul_W2(health_emb)
+        health_sim = torch.sum(health_sim, -1)
+        harm_sim = self.ul_W1(user_emb) * self.ul_W3(harm_emb)
+        harm_sim = torch.sum(harm_sim, -1)
+
+        # health_sim = user_emb * health_emb
+        # health_sim = torch.sum(health_sim, -1)
+        # harm_sim = user_emb + harm_emb
+        # harm_sim = torch.sum(harm_sim, -1)
+
+        ssl_loss = torch.log10(torch.exp(health_sim)) - torch.log10(torch.exp(health_sim) + torch.exp(harm_sim))
+        ssl_loss = torch.sum(ssl_loss, 0)
+        return -ssl_loss
+
+    def forward(self, session, mask_indexes=None):
+
+        mask = (session != 0).float()
+
+        mask = mask.unsqueeze(2).repeat((1, 1, self.hidden_size))
+        session_item_embeddings = self.item_embedding(session) * mask
+        positions = torch.arange(0, session.shape[1]).unsqueeze(0).repeat((session.shape[0], 1)).to(device)
+        session_position_embeddings = self.position_embedding(positions) * mask
+        session_item_vecs = self.dropout(self.layer_norm(session_item_embeddings + session_position_embeddings))
+        attention_mask = (session == self.padding_idx)
+        if mask_indexes is not None:
+            compute_output = self.dropout(self.bert(session_item_vecs, attention_mask).gather(1, mask_indexes))
+        else:
+            compute_output = self.dropout(self.bert(session_item_vecs, attention_mask)[:, -1, :])
+        compute_output = F.gelu(self.dropout(self.projection(compute_output)))
+        scores = torch.matmul(compute_output, self.item_embedding.weight[1:-1].t()) + self.output_bias
+
+        # health
+        seq = session
+        # Self-attention healthy
+        mask = torch.where(seq > 0, torch.tensor([1.], device=self.device),
+                           torch.tensor([0.], device=self.device))
+        mask_h = mask.float().unsqueeze(-1)
+        attention_mask = mask_h.permute(0, 2, 1).unsqueeze(1)  # [bs, 1, 1, seqlen] 增加维度
+        attention_mask = (1.0 - attention_mask) * -10000.0
+
+        seq_h = seq
+        item_f = self.emb_reason(seq_h)
+        K_emb = item_f
+        V_emb = item_f
+        all_health = torch.cuda.LongTensor(list(K_emb.shape)[0], list(K_emb.shape)[1]).fill_(1)
+        Q_emb = self.emb_healthy(all_health)
+        Q_emb = self.dense_text_health(Q_emb)
+
+        mixed_query_layer = self.query(Q_emb)  # [bs, seqlen, hid_size]
+        mixed_key_layer = self.key(K_emb)  # [bs, seqlen, hid_size]
+        mixed_value_layer = self.value(V_emb)  # [bs, seqlen, hid_size]
+
+        attention_head_size = int(hidden_size / self.num_heads)
+        query_layer = self.transpose_for_scores(mixed_query_layer, attention_head_size)  # [bs, 8, seqlen, 16]
+        key_layer = self.transpose_for_scores(mixed_key_layer, attention_head_size)
+        value_layer = self.transpose_for_scores(mixed_value_layer, attention_head_size)  # [bs, 8, seqlen, 16]
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+        # [bs, 8, seqlen, 16]*[bs, 8, 16, seqlen]  ==> [bs, 8, seqlen, seqlen]
+        attention_scores = attention_scores / math.sqrt(attention_head_size)  # [bs, 8, seqlen, seqlen]
+        attention_scores = attention_scores + attention_mask
+        attention_probs = nn.Softmax(dim=-1)(attention_scores)  # [bs, 8, seqlen, seqlen]
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+
+        # 矩阵相乘，[bs, 8, seqlen, seqlen]*[bs, 8, seqlen, 16] = [bs, 8, seqlen, 16]
+        context_layer = torch.matmul(attention_probs, value_layer)  # [bs, 8, seqlen, 16]
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()  # [bs, seqlen, 8, 16]
+        new_context_layer_shape = context_layer.size()[:-2] + (hidden_size,)  # [bs, seqlen, 128]
+        sa_result = context_layer.view(*new_context_layer_shape)
+        # last hidden state
+        mask_h = mask.long().unsqueeze(-1)
+        item_pos = torch.tensor(range(1, V_emb.size()[1] + 1), device='cuda')
+        item_pos = item_pos.unsqueeze(0).expand_as(seq_h)
+        item_pos = item_pos * mask_h.squeeze(2)
+        item_last_num = torch.max(item_pos, 1)[0].unsqueeze(1).expand_as(item_pos)
+        last_pos_t = torch.where(item_pos - item_last_num >= 0, torch.tensor([1.0], device='cuda'),
+                                 torch.tensor([0.0], device='cuda'))
+        as_last_unit = last_pos_t.unsqueeze(2).expand_as(sa_result) * sa_result
+        user_h = torch.sum(as_last_unit, 1)
+
+        # item_embs_health = self.emb_reason(torch.arange(self.n_items).to(self.device))
+        # scores_health = torch.matmul(user_h, item_embs_health.permute(1, 0))
+        # scores = scores_rec + self.h_lambda*scores_health
+
+        item_embs_reason = self.emb_reason.weight[1:-1]
+
+        item_merge = item_embs_reason
+
+        user_health = torch.cuda.LongTensor(list(user_h.shape)[0]).fill_(1)
+        user_health_emb = self.emb_healthy(user_health)
+        user_health_emb = self.dense_text_health(user_health_emb)
+
+        scores_ui = torch.matmul(user_h, item_merge.permute(1, 0))
+        scores_item = torch.matmul(user_health_emb, item_merge.permute(1, 0))
+        # scores = scores_rec
+        # scores = self.sf(scores)
+
+        # ssl loss
+
+        u_index = torch.cuda.LongTensor(list(user_h.shape)[0]).fill_(1)
+
+        u_health_emb = self.emb_healthy(u_index)
+        u_health_emb = self.dense_text_health(u_health_emb)
+
+        u_harm_emb = self.emb_harmful(u_index)
+        u_harm_emb = self.dense_text_harm(u_harm_emb)
+
+        ssl_loss = self.user_loss(user_h, u_health_emb, u_harm_emb)
+
+
+        return scores, ssl_loss, self.h_lamdba * (scores_item + scores_ui)
+
+    def predict_top_k(self, session, k=20):
+        result, ssl_loss, health_loss = self.forward(session)
+        result = torch.topk(result+health_loss, k, dim=1)[1]
+
+        return result
+
+
+
+
+
+def train(args):
+    hidden_size = args["hidden_size"] if "hidden_size" in args.keys() else 100
+    attention_dropout = args["attention_dropout"] if "attention_dropout" in args.keys() else 0.2
+    dropout = args["dropout"] if "dropout" in args.keys() else 0.5
+    lr = args["lr"] if "lr" in args.keys() else 5e-4
+    sa_layer_num = args["sa_layer_num"] if "sa_layer_num" in args.keys() else 1
+    amsgrad = args["amsgrad"] if "amsgrad" in args.keys() else True
+    session_length = args["session_length"] if "session_length" in args.keys() else 200
+    head_num = args["head_num"] if "head_num" in args.keys() else 1
+    datasets_name = args["datasets"] if "datasets" in args.keys() else "TN"
+    h_lamdba = args["lamdba"] if "lamdba" in args.keys() else 0.05
+    model = BERT4Rec(hidden_size=hidden_size, itemNum=dataset.index_count, posNum=session_length, padding_idx=0,
+                     dropout=dropout,
+                     activate="selu", attention_dropout=attention_dropout, head_num=head_num,
+                     sa_layer_num=sa_layer_num, datasets=datasets_name, h_lamdba=h_lamdba).to(device)
+    opti = torch.optim.Adam(model.parameters(), lr=lr)
+    patience = args["patience"] if "patience" in args.keys() else 5
+    best_model_hr = 0.0
+    best_model_mrr = 0.0
+    best_r1m = 0.0
+    best_model = None
+    predict_nums = [1, 5, 10, 20]
+    no_improvement_epoch = 0
+    start_train_time = datetime.datetime.now()
+    for epoch in range(epochs):
+        batch_losses = []
+        epoch_losses = []
+        model.train()
+        for i, batch_data in enumerate(dataset.get_batch(batch_size, session_length, phase="train")):
+            mask_item = torch.ones_like(torch.tensor(batch_data[1])) * dataset.index_count + 1
+            sessions = torch.cat([torch.tensor(batch_data[0]), mask_item], dim=-1)
+            target_items = torch.tensor(batch_data[1]).squeeze().to(device) - 1
+            result_pos, ssl_loss, health_loss = model(sessions.to(device))
+            loss = loss_function(result_pos, target_items) + ssl_loss
+            opti.zero_grad()
+            loss.backward()
+            opti.step()
+            batch_losses.append(loss.cpu().detach().numpy())
+            epoch_losses.append(loss.cpu().detach().numpy())
+            if i % plot_num == 0:
+                time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                print("[%s] [%d/%d] %d mean_batch_loss : %0.6f" % (time, epoch + 1, epochs, i, np.mean(batch_losses)))
+                batch_losses = []
+
+        model.eval()
+        with torch.no_grad():
+            start_test_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            print("Start predicting", start_test_time)
+            rrs = [0 for _ in range(len(predict_nums))]
+            hit_nums = [0 for _ in range(len(predict_nums))]
+            ndcgs = [0 for _ in range(len(predict_nums))]
+            seq_save = []
+            label_save = []
+            pre_save = []
+            for i, batch_data in enumerate(dataset.get_batch(batch_size, session_length, phase="test")):
+                mask_item = torch.ones_like(torch.tensor(batch_data[1])) * dataset.index_count + 1
+                sessions = torch.cat([torch.tensor(batch_data[0]), mask_item], dim=-1).to(device)
+
+                target_items = np.array(batch_data[1]) - 1
+                y_pred = model.predict_top_k(sessions, 20).cpu().numpy()
+
+                # top-k item ID number
+                pre_k = y_pred + 1
+                seq_temp = sessions.tolist()
+                seq_save += seq_temp
+                label_save += np.array(batch_data[1]).flatten().tolist()
+                pre_save += pre_k.tolist()
+
+                for j, predict_num in enumerate(predict_nums):
+                    hit_nums[j] += get_hit_num(y_pred[:, :predict_num], target_items)
+                    rrs[j] += get_rr(y_pred[:, :predict_num], target_items)
+                    ndcgs[j] += get_ndcg(y_pred[:, :predict_num], target_items)
+
+            end_test_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+            hrs = [hit_num / len(dataset.all_testing_data) for hit_num in hit_nums]
+            mrrs = [rr / len(dataset.all_testing_data) for rr in rrs]
+            mndcgs = [ndcg / len(dataset.all_testing_data) for ndcg in ndcgs]
+            if hrs[-1] + mrrs[-1] > best_r1m:
+                # print("change best")
+                best_model = deepcopy(model)
+                # best_model_hr = hrs[-1]
+                # best_model_mrr = mrrs[-1]
+                # best_r1m = hrs[-1] + mrrs[-1]
+                best_model_hr = hrs
+                best_model_mrr = mrrs
+                best_model_ndcg = mndcgs
+                best_r1m = hrs[-1] + mrrs[-1]
+                no_improvement_epoch = 0
+
+                pre_save_path = "./BERTHealth/" + dataset_name + "/prediction_health.txt"
+                # res_pre = (seq_save, label_save, pre_save)
+                res_pre = (label_save, label_save, pre_save)
+                pickle.dump(res_pre, open(pre_save_path, 'wb'))
+            else:
+                no_improvement_epoch += 1
+            print("testing finish [%s] " % end_test_time)
+            for k, predict_num in enumerate(predict_nums):
+                print("\tHR@%d=%.5f  MRR@%d=%.5f  NDCG@%d=%.5f" % (
+                    predict_num, hrs[k], predict_num, mrrs[k], predict_num, mndcgs[k]))
+        if no_improvement_epoch >= patience:
+            print("early stopping")
+            break
+    end_train_time = datetime.datetime.now()
+
+
+
+    print("training and testting over, Total time", end_train_time - start_train_time)
+    return best_model, best_model_hr, best_model_mrr, best_model_ndcg
+
+os.environ["CUDA_VISIBLE_DEVICES"] = "1"
+# TN/QB/NERD
+dataset_name = 'TN'
+train_path = './BERTHealth/' + dataset_name + '/train.txt'
+test_path = './BERTHealth/' + dataset_name + '/test.txt'
+dataset = SessionDataSet(train_file=train_path, test_file=test_path)
+# torch.cuda.set_device(1)
+epochs = 50
+hidden_sizes = [100]  # rr:100 dn:100
+dropouts = [0.3]  # rr:0.3 dn:0.3
+attention_dropouts = [0]  # rr:0 dn:0
+lrs = [1e-3]  # rr:1e-3 dn:5e-4
+session_lengths = [50]  # rr:50 dn:50
+sa_layer_nums = [4]  # rr:4 dn:4
+
+# lambda balances user interest and content healthiness
+h_lamdba = 0.01
+
+patience = 10
+head_nums = [2]  # rr:2 dn:4, 32 dimension each head
+amsgrads = [True]
+best_params = ""
+best_all_model = 0.0
+best_all_hr = 0.0
+best_all_mrr = 0.0
+best_all_r1m = 0.0
+print('datasets: ',dataset_name)
+for session_length in session_lengths:
+    for hidden_size, head_num in zip(hidden_sizes, head_nums):
+        for amsgrad in amsgrads:
+            for attention_dropout in attention_dropouts:
+                for dropout in dropouts:
+                    for lr in lrs:
+                        for sa_layer_num in sa_layer_nums:
+                            # for head_num in head_nums:
+                            args = {}
+                            print(
+                                "current model hyper-parameters: session_length=%d, hidden_size=%d, lr=%.4f,head_num=%d, amsgrad=%s, attention_dropout=%.2f, dropout=%.2f, sa_layer_num=%d. \n" % (
+                                    session_length, hidden_size, lr, head_num, str(amsgrad), attention_dropout,
+                                    dropout,
+                                    sa_layer_num))
+                            args["session_length"] = session_length
+                            args["hidden_size"] = hidden_size
+                            args["amsgrad"] = amsgrad
+                            args["attention_dropout"] = attention_dropout
+                            args["dropout"] = dropout
+                            args["sa_layer_num"] = sa_layer_num
+                            args["lr"] = lr
+                            args["head_num"] = head_num
+                            args["patience"] = patience
+                            args["datasets"] = dataset_name
+                            args["lamdba"] = h_lamdba
+                            best_model, best_model_hr, best_model_mrr, best_model_ndcg = train(args)
+                            # if best_model_hr + best_model_mrr > best_all_r1m:
+                            #     print("best model change")
+                            #     best_all_r1m = best_model_hr + best_model_mrr
+                            #     best_all_hr = best_model_hr
+                            #     best_all_mrr = best_model_mrr
+                            #     best_all_model = best_model
+                            #     best_params = "session_length-%d, hidden_size-%d, lr-%.4f,head_num=%d, amsgrad-%s, attention_dropout-%.2f, dropout-%.2f, sa_layer_num-%d" % (
+                            #         session_length, hidden_size, lr, head_num, str(amsgrad), attention_dropout,
+                            #         dropout,
+                            #         sa_layer_num)
+                            # best_model = None
+                            # print(
+                            #     "current model hyper-parameters: session_length=%d, hidden_size=%d, lr=%.4f,head_num=%d, amsgrad=%s, attention_dropout=%.2f, dropout=%.2f, sa_layer_num=%d. \n" % (
+                            #         session_length, hidden_size, lr, head_num, str(amsgrad), attention_dropout,
+                            #         dropout,
+                            #         sa_layer_num))
+                            print("current model hyper-parameters: session_length=%d, hidden_size=%d, head_num=%d, sa_layer_num=%d. \n" % (session_length, hidden_size,  head_num, sa_layer_num))
+                            # print("current model HR@20=%.5f  MRR@20=%.5f." % (best_model_hr, best_model_mrr))
+                            print('P@1\tP@5\tM@5\tN@5\tP@10\tM@10\tN@10\tP@20\tM@20\tN@20\t')
+                            print("%.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f" % (
+                                best_model_hr[0]*100, best_model_hr[1]*100, best_model_mrr[1]*100, best_model_ndcg[1]*100, best_model_hr[2]*100, best_model_mrr[2]*100, best_model_ndcg[2]*100, best_model_hr[3]*100, best_model_mrr[3]*100, best_model_ndcg[3]*100))
+
+
+                            # CKLLM 存储训练好的item embs,padding 0
+                            # save_path = './BERTCKLLM/' + dataset_name + '/item_embs.pth'
+                            # torch.save(best_model.item_embedding.state_dict(), save_path)
+# print("The best result HR@20=%.5f  MRR@20=%.5f, hyper-parameters: %s. " % (best_all_hr, best_all_mrr, best_params))
+print(dataset_name)
+print("over.")

HealthRec/HealthRec_code/BERT4Rec/environment.yml

@@ -0,0 +1,88 @@
+name: DSAN
+channels:
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=4.5=1_gnu
+  - _pytorch_select=0.1=cpu_0
+  - blas=1.0=mkl
+  - bottleneck=1.3.2=py39hdd57654_1
+  - brotli=1.0.9=he6710b0_2
+  - ca-certificates=2021.10.26=h06a4308_2
+  - certifi=2021.10.8=py39h06a4308_0
+  - cffi=1.14.6=py39h400218f_0
+  - cycler=0.10.0=py39h06a4308_0
+  - dbus=1.13.18=hb2f20db_0
+  - expat=2.4.1=h2531618_2
+  - fontconfig=2.13.1=h6c09931_0
+  - fonttools=4.25.0=pyhd3eb1b0_0
+  - freetype=2.11.0=h70c0345_0
+  - giflib=5.2.1=h7b6447c_0
+  - glib=2.69.1=h5202010_0
+  - gst-plugins-base=1.14.0=h8213a91_2
+  - gstreamer=1.14.0=h28cd5cc_2
+  - icu=58.2=he6710b0_3
+  - intel-openmp=2019.4=243
+  - jpeg=9d=h7f8727e_0
+  - kiwisolver=1.3.1=py39h2531618_0
+  - lcms2=2.12=h3be6417_0
+  - ld_impl_linux-64=2.35.1=h7274673_9
+  - libffi=3.3=he6710b0_2
+  - libgcc-ng=9.1.0=hdf63c60_0
+  - libgomp=9.3.0=h5101ec6_17
+  - libmklml=2019.0.5=0
+  - libpng=1.6.37=hbc83047_0
+  - libstdcxx-ng=9.1.0=hdf63c60_0
+  - libtiff=4.2.0=h85742a9_0
+  - libuuid=1.0.3=h7f8727e_2
+  - libwebp=1.2.0=h89dd481_0
+  - libwebp-base=1.2.0=h27cfd23_0
+  - libxcb=1.14=h7b6447c_0
+  - libxml2=2.9.10=hb55368b_3
+  - lz4-c=1.9.3=h295c915_1
+  - matplotlib=3.4.3=py39h06a4308_0
+  - matplotlib-base=3.4.3=py39hbbc1b5f_0
+  - mkl=2020.2=256
+  - mkl-service=2.3.0=py39he8ac12f_0
+  - mkl_fft=1.3.0=py39h54f3939_0
+  - mkl_random=1.0.2=py39h63df603_0
+  - munkres=1.1.4=py_0
+  - ncurses=6.3=h7f8727e_2
+  - ninja=1.10.2=py39hd09550d_3
+  - numexpr=2.7.3=py39hb2eb853_0
+  - numpy=1.19.2=py39h89c1606_0
+  - numpy-base=1.19.2=py39h2ae0177_0
+  - olefile=0.46=pyhd3eb1b0_0
+  - openssl=1.1.1l=h7f8727e_0
+  - pandas=1.3.4=py39h8c16a72_0
+  - pcre=8.45=h295c915_0
+  - pillow=8.4.0=py39h5aabda8_0
+  - pip=21.2.4=py39h06a4308_0
+  - pycparser=2.21=pyhd3eb1b0_0
+  - pyparsing=3.0.4=pyhd3eb1b0_0
+  - pyqt=5.9.2=py39h2531618_6
+  - python=3.9.7=h12debd9_1
+  - python-dateutil=2.8.2=pyhd3eb1b0_0
+  - pytz=2021.3=pyhd3eb1b0_0
+  - qt=5.9.7=h5867ecd_1
+  - readline=8.1=h27cfd23_0
+  - setuptools=58.0.4=py39h06a4308_0
+  - sip=4.19.13=py39h2531618_0
+  - six=1.16.0=pyhd3eb1b0_0
+  - sqlite=3.36.0=hc218d9a_0
+  - tk=8.6.11=h1ccaba5_0
+  - tornado=6.1=py39h27cfd23_0
+  - tqdm=4.62.3=pyhd3eb1b0_1
+  - typing-extensions=3.10.0.2=hd3eb1b0_0
+  - typing_extensions=3.10.0.2=pyh06a4308_0
+  - tzdata=2021e=hda174b7_0
+  - wheel=0.37.0=pyhd3eb1b0_1
+  - xz=5.2.5=h7b6447c_0
+  - zlib=1.2.11=h7b6447c_3
+  - zstd=1.4.9=haebb681_0
+  - pip:
+    - torch==1.8.0+cu111
+    - torchaudio==0.8.0
+    - torchvision==0.9.0+cu111
+prefix: /home/dutir923/zhangxiaokun/anaconda3/envs/DSAN
+

HealthRec/HealthRec_code/GRU4Rec/dataset.py

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+"""
+create on 18 Sep, 2019
+
+@author: wangshuo
+
+Reference: https://github.com/lijingsdu/sessionRec_NARM/blob/master/data_process.py
+"""
+
+import pickle
+import torch
+from torch.utils.data import Dataset
+import numpy as np
+
+
+def load_data(root, valid_portion=0.1, maxlen=200, sort_by_len=False, test_lab='text.txt'):
+    '''Loads the dataset
+
+    :type path: String
+    :param path: The path to the dataset (here RSC2015)
+    :type n_items: int
+    :param n_items: The number of items.
+    :type valid_portion: float
+    :param valid_portion: The proportion of the full train set used for
+        the validation set.
+    :type maxlen: None or positive int
+    :param maxlen: the max sequence length we use in the train/valid set.
+    :type sort_by_len: bool
+    :name sort_by_len: Sort by the sequence lenght for the train,
+        valid and test set. This allow faster execution as it cause
+        less padding per minibatch. Another mechanism must be used to
+        shuffle the train set at each epoch.
+
+    '''
+
+    # Load the dataset
+    path_train_data = root + 'train.txt'
+    path_test_data = root + test_lab
+    with open(path_train_data, 'rb') as f1:
+        train_set = pickle.load(f1)
+
+    with open(path_test_data, 'rb') as f2:
+        test_set = pickle.load(f2)
+
+    if maxlen:
+        new_train_set_x = []
+        new_train_set_y = []
+        for x, y in zip(train_set[0], train_set[1]):
+            # dawn
+            if len(x) <= maxlen:
+                new_train_set_x.append(x)
+                new_train_set_y.append(y)
+            else:
+                new_train_set_x.append(x[:maxlen])
+                new_train_set_y.append(x[maxlen])
+            # if len(x) < maxlen:
+            #     new_train_set_x.append(x)
+            #     new_train_set_y.append(y)
+            # else:
+            #     new_train_set_x.append(x[:maxlen])
+            #     new_train_set_y.append(y)
+        train_set = (new_train_set_x, new_train_set_y)
+        del new_train_set_x, new_train_set_y
+
+        new_test_set_x = []
+        new_test_set_y = []
+        for xx, yy in zip(test_set[0], test_set[1]):
+            # dawn
+            if len(xx) <= maxlen:
+                new_test_set_x.append(xx)
+                new_test_set_y.append(yy)
+            else:
+                new_test_set_x.append(xx[:maxlen])
+                new_test_set_y.append(xx[maxlen])
+            # if len(xx) < maxlen:
+            #     new_test_set_x.append(xx)
+            #     new_test_set_y.append(yy)
+            # else:
+            #     new_test_set_x.append(xx[:maxlen])
+            #     new_test_set_y.append(yy)
+        test_set = (new_test_set_x, new_test_set_y)
+        del new_test_set_x, new_test_set_y
+
+    # split training set into validation set
+    train_set_x, train_set_y = train_set
+    n_samples = len(train_set_x)
+    sidx = np.arange(n_samples, dtype='int32')
+    np.random.shuffle(sidx)
+    n_train = int(np.round(n_samples * (1. - valid_portion)))
+    valid_set_x = [train_set_x[s] for s in sidx[n_train:]]
+    valid_set_y = [train_set_y[s] for s in sidx[n_train:]]
+    train_set_x = [train_set_x[s] for s in sidx[:n_train]]
+    train_set_y = [train_set_y[s] for s in sidx[:n_train]]
+
+    (test_set_x, test_set_y) = test_set
+
+    def len_argsort(seq):
+        return sorted(range(len(seq)), key=lambda x: len(seq[x]))
+
+    if sort_by_len:
+        sorted_index = len_argsort(test_set_x)
+        test_set_x = [test_set_x[i] for i in sorted_index]
+        test_set_y = [test_set_y[i] for i in sorted_index]
+
+        sorted_index = len_argsort(valid_set_x)
+        valid_set_x = [valid_set_x[i] for i in sorted_index]
+        valid_set_y = [valid_set_y[i] for i in sorted_index]
+
+    train = (train_set_x, train_set_y)
+    valid = (valid_set_x, valid_set_y)
+    test = (test_set_x, test_set_y)
+
+    return train, valid, test
+
+
+class RecSysDataset(Dataset):
+    """define the pytorch Dataset class for yoochoose and diginetica datasets.
+    """
+    def __init__(self, data):
+        self.data = data
+        print('-'*50)
+        print('Dataset info:')
+        print('Number of sessions: {}'.format(len(data[0])))
+        print('-'*50)
+        
+    def __getitem__(self, index):
+        session_items = self.data[0][index]
+        target_item = self.data[1][index]
+        return session_items, target_item-1
+
+    def __len__(self):
+        return len(self.data[0])

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/NERD/H_neg_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f8abe18978a3deec718b230960d48084285fdf16ef777f645fe9d3fa2ab77b9
+size 3200

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/NERD/H_pos_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dde3f20ab1ee7b4d323c8c8a8af58ef19148a2f439b67c675c004777b6274a6
+size 3200

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/NERD/H_reason_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8758eb8e206047fbdf707cf36202577d679e62b5ec4cc7a54d15c695fedefa2b
+size 8263328

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/NERD/H_title_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5706ac3c6e8273608204edde9ff8df523719c5bfbf7d79d8d49044d63689d1c6
+size 8263328

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/NERD/test.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed13fb2f8febb707372b1f7956608ad5c8981eca18d70743712ceff3fe63d68b
+size 699182

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/NERD/train.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b733a5ff31d947af67df8408c7557a02c35c1f9d2cee25cfc4e8c861a4801e30
+size 6312423

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/QB/H_neg_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f8abe18978a3deec718b230960d48084285fdf16ef777f645fe9d3fa2ab77b9
+size 3200

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/QB/H_pos_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dde3f20ab1ee7b4d323c8c8a8af58ef19148a2f439b67c675c004777b6274a6
+size 3200

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/QB/H_reason_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e48330dbc4c2fca6d95ac7e17a181e5824bb602cf2c93996670642254eee26a5
+size 4751328

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/QB/H_title_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6adfa8e769d49b084bb341b2f4c9b7af25c25beb9fb79e5eaeab46a134b8a646
+size 4751328

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/QB/train.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ea60f4f6f5dff12f719addac67ba58232dcbf8c365ebe31988f1e60d65c04b6
+size 416072

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/TN/H_neg_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f8abe18978a3deec718b230960d48084285fdf16ef777f645fe9d3fa2ab77b9
+size 3200

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/TN/H_pos_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dde3f20ab1ee7b4d323c8c8a8af58ef19148a2f439b67c675c004777b6274a6
+size 3200

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/TN/H_reason_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfb9acc77f001da4f778233a7713e34355df5b809841dff3a5229b2e0815f53b
+size 2604128

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/TN/H_title_emb100.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:818d7d4cb5d306c1d8d6ceb4b13efee47d2686e5d6d8a71df44ce89fc5ffe658
+size 2604128

HealthRec/HealthRec_code/GRU4Rec/datasetsHealth/TN/train.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45f7052b0cb6052986ce5a5f3cf87011f08290f09f2f48f310ad459a568e3ce7
+size 393873

HealthRec/HealthRec_code/GRU4Rec/gru4rec.py

@@ -0,0 +1,59 @@
+import torch
+import numpy as np
+import torch.nn as nn
+
+import torch.nn.functional as F
+from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
+
+
+class GRU4Rec(nn.Module):
+    """
+        n_items(int): the number of items
+        hidden_size(int): the hidden size of gru
+        embedding_dim(int): the dimension of item embedding
+        batch_size(int):
+        n_layers(int): the number of gru layers
+    """
+
+    def __init__(self, n_items, hidden_size, embedding_dim, batch_size, datasets, n_layers=1):
+        super(GRU4Rec, self).__init__()
+        self.n_items = n_items
+        self.hidden_size = hidden_size
+        self.batch_size = batch_size
+        self.n_layers = n_layers
+        self.embedding_dim = embedding_dim
+        self.emb = nn.Embedding(self.n_items, self.embedding_dim, padding_idx=0)
+        text_emb_path = './datasetsHealth/' + datasets + '/H_title_emb100.npy'
+        textWeights = np.load(text_emb_path)
+        self.emb.weight.data.copy_(torch.from_numpy(textWeights))
+        self.emb_dropout = nn.Dropout(0.25)
+        self.gru = nn.GRU(self.embedding_dim, self.hidden_size, self.n_layers)
+        self.a_1 = nn.Linear(self.hidden_size, self.hidden_size, bias=False)
+        self.a_2 = nn.Linear(self.hidden_size, self.hidden_size, bias=False)
+        self.v_t = nn.Linear(self.hidden_size, 1, bias=False)
+        self.ct_dropout = nn.Dropout(0.5)
+        self.b = nn.Linear(self.embedding_dim, 2 * self.hidden_size, bias=False)
+        self.sf = nn.Softmax()
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    def forward(self, seq, lengths):
+        hidden = self.init_hidden(seq.size(1))
+        embs = self.emb_dropout(self.emb(seq))
+        embs = pack_padded_sequence(embs, lengths)
+        gru_out, hidden = self.gru(embs, hidden)
+        gru_out, lengths = pad_packed_sequence(gru_out)
+
+        # fetch the last hidden state of last timestamp
+        ht = hidden[-1]
+        gru_out = gru_out.permute(1, 0, 2)
+
+        c_global = ht
+
+        item_embs = self.emb(torch.arange(self.n_items).to(self.device))
+        scores = torch.matmul(c_global, item_embs.permute(1, 0))
+        # scores = self.sf(scores)
+
+        return scores
+
+    def init_hidden(self, batch_size):
+        return torch.zeros((self.n_layers, batch_size, self.hidden_size), requires_grad=True).to(self.device)

HealthRec/HealthRec_code/GRU4Rec/healthRec.py

@@ -0,0 +1,215 @@
+import math
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
+
+
+
+class healthRec(nn.Module):
+
+    def __init__(self, n_items, hidden_size, embedding_dim, batch_size, datasets, ui_lambda, item_lambda, user_lambda, n_layers=1):
+        super(healthRec, self).__init__()
+        self.n_items = n_items
+        self.hidden_size = hidden_size
+        self.batch_size = batch_size
+        self.n_layers = n_layers
+        self.embedding_dim = embedding_dim
+        self.emb = nn.Embedding(self.n_items, self.embedding_dim, padding_idx=0)
+
+        self.emb_healthy = nn.Embedding(2, 768, padding_idx=0)
+        self.emb_harmful = nn.Embedding(2, 768, padding_idx=0)
+        self.emb_reason = nn.Embedding(self.n_items, self.embedding_dim, padding_idx=0)
+
+        self.ui_lambda = ui_lambda
+        self.item_lambda = item_lambda
+        self.user_lambda = user_lambda
+
+        text_emb_path = './datasetsHealth/' + datasets + '/H_title_emb100.npy'
+        textWeights = np.load(text_emb_path)
+        self.emb.weight.data.copy_(torch.from_numpy(textWeights))
+
+        reason_emb_path = './datasetsHealth/' + datasets + '/H_reason_emb100.npy'
+        reasonWeights = np.load(reason_emb_path)
+        self.emb_reason.weight.data.copy_(torch.from_numpy(reasonWeights))
+
+        self.emb_reason.weight.requires_grad = False
+
+        health_emb_path = './datasetsHealth/' + datasets + '/H_pos_emb100.npy'
+        healWeights = np.load(health_emb_path)
+        self.emb_healthy.weight.data.copy_(torch.from_numpy(healWeights))
+
+        self.emb_healthy.weight.requires_grad = False
+
+        harm_emb_path = './datasetsHealth/' + datasets + '/H_neg_emb100.npy'
+        harmWeights = np.load(harm_emb_path)
+        self.emb_harmful.weight.data.copy_(torch.from_numpy(harmWeights))
+
+        self.emb_harmful.weight.requires_grad = False
+
+        self.dense_text_health = nn.Linear(768, self.embedding_dim)
+        self.dense_text_harm = nn.Linear(768, self.embedding_dim)
+
+        self.cos_sim = nn.CosineSimilarity(dim=-1)
+        self.ul_W1 = nn.Linear(self.embedding_dim, self.embedding_dim)
+        self.ul_W2 = nn.Linear(self.embedding_dim, self.embedding_dim)
+        self.ul_W3 = nn.Linear(self.embedding_dim, self.embedding_dim)
+
+        self.merge_item = nn.Linear(self.embedding_dim, self.embedding_dim)
+
+        # self_attention
+        num_heads = 4
+        if self.embedding_dim % num_heads != 0:  # 整除
+            raise ValueError(
+                "The hidden size (%d) is not a multiple of the number of attention "
+                "heads (%d)" % (self.embedding_dim, num_heads))
+            # 参数定义
+        self.num_heads = num_heads  # 4
+        self.attention_head_size = int(self.embedding_dim / self.num_heads)  # 16  每个注意力头的维度
+        self.all_head_size = int(self.num_heads * self.attention_head_size)
+        # query, key, value 的线性变换（上述公式2）
+        self.query = nn.Linear(self.embedding_dim, self.embedding_dim)  # 128, 128
+        self.key = nn.Linear(self.embedding_dim, self.embedding_dim)
+        self.value = nn.Linear(self.embedding_dim, self.embedding_dim)
+
+
+        self.emb_dropout = nn.Dropout(0.25)
+        self.dropout = nn.Dropout(0.1)
+
+        self.gru = nn.GRU(self.embedding_dim, self.hidden_size, self.n_layers)
+        self.a_1 = nn.Linear(self.hidden_size, self.hidden_size, bias=False)
+        self.a_2 = nn.Linear(self.hidden_size, self.hidden_size, bias=False)
+        self.v_t = nn.Linear(self.hidden_size, 1, bias=False)
+        self.ct_dropout = nn.Dropout(0.5)
+        self.b = nn.Linear(self.embedding_dim, 2 * self.hidden_size, bias=False)
+        self.sf = nn.Softmax()
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    def transpose_for_scores(self, x, attention_head_size):
+        # INPUT:  x'shape = [bs, seqlen, hid_size]  假设hid_size=128
+        new_x_shape = x.size()[:-1] + (self.num_heads, attention_head_size)  # [bs, seqlen, 8, 16]
+        x = x.view(*new_x_shape)  #
+        return x.permute(0, 2, 1, 3)
+
+    def user_loss(self, user_emb, health_emb, harm_emb):
+        # health_sim = self.cos_sim(self.ul_W1(user_emb), self.ul_W2(health_emb))
+        # harm_sim = self.cos_sim(self.ul_W1(user_emb), self.ul_W3(harm_emb))
+
+        health_sim = self.ul_W1(user_emb) * self.ul_W2(health_emb)
+        health_sim = torch.sum(health_sim, -1)
+        harm_sim = self.ul_W1(user_emb) * self.ul_W3(harm_emb)
+        harm_sim = torch.sum(harm_sim, -1)
+
+        # health_sim = user_emb * health_emb
+        # health_sim = torch.sum(health_sim, -1)
+        # harm_sim = user_emb + harm_emb
+        # harm_sim = torch.sum(harm_sim, -1)
+
+        ssl_loss = torch.log10(torch.exp(health_sim)) - torch.log10(torch.exp(health_sim) + torch.exp(harm_sim))
+        ssl_loss = torch.sum(ssl_loss, 0)
+        return -ssl_loss
+
+    def forward(self, seq, lengths):
+        hidden = self.init_hidden(seq.size(1))
+        embs = self.emb_dropout(self.emb(seq))
+        embs = pack_padded_sequence(embs, lengths)
+        gru_out, hidden = self.gru(embs, hidden)
+        gru_out, lengths = pad_packed_sequence(gru_out)
+
+
+        # fetch the last hidden state of last timestamp
+        ht = hidden[-1]
+        gru_out = gru_out.permute(1, 0, 2)
+
+        c_global = ht
+
+        mask = torch.where(seq.permute(1, 0) > 0, torch.tensor([1.], device=self.device),
+                           torch.tensor([0.], device=self.device))
+
+        item_embs = self.emb(torch.arange(1, self.n_items).to(self.device))
+        scores_rec = torch.matmul(c_global, item_embs.permute(1, 0))
+        # scores_rec = torch.matmul(c_t, item_embs.permute(1, 0))
+
+        # Self-attention healthy
+        mask_h = mask.float().unsqueeze(-1)
+        attention_mask = mask_h.permute(0, 2, 1).unsqueeze(1)  # [bs, 1, 1, seqlen] 增加维度
+        attention_mask = (1.0 - attention_mask) * -10000.0
+
+        seq_h = seq.permute(1, 0)
+        item_f = self.emb_reason(seq_h)
+        K_emb = item_f
+        V_emb = item_f
+        all_health = torch.cuda.LongTensor(list(K_emb.shape)[0], list(K_emb.shape)[1]).fill_(1)
+        Q_emb = self.emb_healthy(all_health)
+        Q_emb = self.dense_text_health(Q_emb)
+
+        mixed_query_layer = self.query(Q_emb)  # [bs, seqlen, hid_size]
+        mixed_key_layer = self.key(K_emb)  # [bs, seqlen, hid_size]
+        mixed_value_layer = self.value(V_emb)  # [bs, seqlen, hid_size]
+
+        attention_head_size = int(self.embedding_dim / self.num_heads)
+        query_layer = self.transpose_for_scores(mixed_query_layer, attention_head_size)  # [bs, 8, seqlen, 16]
+        key_layer = self.transpose_for_scores(mixed_key_layer, attention_head_size)
+        value_layer = self.transpose_for_scores(mixed_value_layer, attention_head_size)  # [bs, 8, seqlen, 16]
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+        # [bs, 8, seqlen, 16]*[bs, 8, 16, seqlen]  ==> [bs, 8, seqlen, seqlen]
+        attention_scores = attention_scores / math.sqrt(attention_head_size)  # [bs, 8, seqlen, seqlen]
+        attention_scores = attention_scores + attention_mask
+        attention_probs = nn.Softmax(dim=-1)(attention_scores)  # [bs, 8, seqlen, seqlen]
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+
+        # 矩阵相乘，[bs, 8, seqlen, seqlen]*[bs, 8, seqlen, 16] = [bs, 8, seqlen, 16]
+        context_layer = torch.matmul(attention_probs, value_layer)  # [bs, 8, seqlen, 16]
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()  # [bs, seqlen, 8, 16]
+        new_context_layer_shape = context_layer.size()[:-2] + (self.embedding_dim,)  # [bs, seqlen, 128]
+        sa_result = context_layer.view(*new_context_layer_shape)
+        # last hidden state
+        mask_h = mask.long().unsqueeze(-1)
+        item_pos = torch.tensor(range(1, V_emb.size()[1] + 1), device='cuda')
+        item_pos = item_pos.unsqueeze(0).expand_as(seq_h)
+        item_pos = item_pos * mask_h.squeeze(2)
+        item_last_num = torch.max(item_pos, 1)[0].unsqueeze(1).expand_as(item_pos)
+        last_pos_t = torch.where(item_pos - item_last_num >= 0, torch.tensor([1.0], device='cuda'),
+                                 torch.tensor([0.0], device='cuda'))
+        as_last_unit = last_pos_t.unsqueeze(2).expand_as(sa_result) * sa_result
+        user_h = torch.sum(as_last_unit, 1)
+
+        # item_embs_health = self.emb_reason(torch.arange(self.n_items).to(self.device))
+        # scores_health = torch.matmul(user_h, item_embs_health.permute(1, 0))
+        # scores = scores_rec + self.h_lambda*scores_health
+
+        item_embs_reason = self.emb_reason(torch.arange(1, self.n_items).to(self.device))
+
+        item_merge = item_embs_reason
+
+        user_health = torch.cuda.LongTensor(list(user_h.shape)[0]).fill_(1)
+        user_health_emb = self.emb_healthy(user_health)
+        user_health_emb = self.dense_text_health(user_health_emb)
+
+        scores_ui = torch.matmul(user_h, item_merge.permute(1, 0))
+        scores_item = torch.matmul(user_health_emb, item_merge.permute(1, 0))
+        scores = scores_rec
+        # scores = scores_rec
+        # scores = self.sf(scores)
+
+        # ssl loss
+
+        u_index = torch.cuda.LongTensor(list(user_h.shape)[0]).fill_(1)
+
+        u_health_emb = self.emb_healthy(u_index)
+        u_health_emb = self.dense_text_health(u_health_emb)
+
+        u_harm_emb = self.emb_harmful(u_index)
+        u_harm_emb = self.dense_text_harm(u_harm_emb)
+
+        ssl_loss = self.user_lambda*self.user_loss(user_h, u_health_emb, u_harm_emb)
+
+
+        return scores, ssl_loss, self.item_lambda * scores_item + self.ui_lambda * scores_ui
+
+    def init_hidden(self, batch_size):
+        return torch.zeros((self.n_layers, batch_size, self.hidden_size), requires_grad=True).to(self.device)