rippleNet

Author: shixiaowen03

.idea/workspace.xml

@@ -0,0 +1,115 @@
+import collections
+import os
+import numpy as np
+
+def load_data(args):
+    train_data,eval_data,test_data,user_history_dict = load_rating(args)
+    n_entity,n_relation,kg = load_kg(args)
+    ripple_set = get_ripple_set(args,kg,user_history_dict)
+    return train_data,eval_data,test_data,n_entity,n_relation,ripple_set
+
+def load_rating(args):
+    print('reaing rating file ...')
+
+    rating_file = 'data/ratings_final.txt'
+    rating_np = np.loadtxt(rating_file,dtype=np.int32)
+
+
+    return dataset_split(rating_np)
+
+
+def dataset_split(rating_np):
+
+    print('splitint dataset ...')
+    eval_ratio = 0.2
+    test_ratio = 0.2
+
+    n_ratings = rating_np.shape[0]
+
+    eval_indices = np.random.choice(n_ratings,size = int(n_ratings * eval_ratio),replace=False)
+    left = set(range(n_ratings)) - set(eval_indices)
+    test_indices = np.random.choice(list(left),size = int(n_ratings * test_ratio),replace=False)
+    train_indices = list(left - set(test_indices))
+
+    user_history_dict = dict()
+    for i in train_indices:
+        user = rating_np[i][0]
+        item = rating_np[i][1]
+        rating = rating_np[i][2]
+
+        if rating == 1:
+            if user not in user_history_dict:
+                user_history_dict[user] = []
+            user_history_dict[user].append(item)
+
+    train_indices = [i for i in train_indices if rating_np[i][0] in user_history_dict]
+    eval_indices = [i for i in eval_indices if rating_np[i][0] in user_history_dict]
+    test_indices = [i for i in test_indices if rating_np[i][0] in user_history_dict]
+
+    train_data = rating_np[train_indices]
+    eval_data = rating_np[eval_indices]
+    test_data = rating_np[test_indices]
+
+    return train_data,eval_data,test_data,user_history_dict
+
+def load_kg(args):
+    print('reading KG file')
+    kg_file = 'data/kg_final.txt'
+
+    kg_np = np.loadtxt(kg_file,dtype=np.int32)
+
+    n_entity = len(set(kg_np[:,0]) | set(kg_np[:,2]))
+    n_relation = len(set(kg_np[:,1]))
+
+    kg = construct_kg(kg_np)
+
+    return n_entity,n_relation,kg
+
+def construct_kg(kg_np):
+    print('constructing knowledge graph ...')
+    kg = collections.defaultdict(list)
+    for head,relation,tail in kg_np:
+        kg[head].append((tail,relation))
+    return kg
+
+
+
+def get_ripple_set(args,kg,user_history_dict):
+    print('constructing ripple set')
+    ripple_set = collections.defaultdict(list)
+
+    for user in user_history_dict:
+        for h in range(args.n_hop):
+            memories_h = []
+            memories_r = []
+            memories_t = []
+
+            if h == 0:
+                tails_of_last_hop = user_history_dict[user]
+            else:
+                tails_of_last_hop = ripple_set[user][-1][2]
+
+            for entity in tails_of_last_hop:
+                for tail_and_relation in kg[entity]:
+                    memories_h.append(entity)
+                    memories_r.append(tail_and_relation[1])
+                    memories_t.append(tail_and_relation[0])
+
+
+            # if the current ripple set of the given user is empty, we simply copy the ripple set of the last hop here
+            # this won't happen for h = 0, because only the items that appear in the KG have been selected
+            # this only happens on 154 users in Book-Crossing dataset (since both BX dataset and the KG are sparse)
+            if len(memories_h) == 0:
+                ripple_set[user].append(ripple_set[user][-1])
+            else:
+                replace = len(memories_h) < args.n_memory
+                indices = np.random.choice(len(memories_h),size = args.n_memory,replace= replace)
+                memories_h = [memories_h[i] for i in indices]
+                memories_r = [memories_r[i] for i in indices]
+                memories_t = [memories_t[i] for i in indices]
+                ripple_set[user].append((memories_h, memories_r, memories_t))
+
+    return ripple_set
+
+
+

recommendation/Basic-RippleNet-Demo/data_loader.py

@@ -0,0 +1,44 @@
+import argparse
+import numpy as np
+from data_loader import load_data
+from train import train
+
+np.random.seed(555)
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--dim', type=int, default=16, help='dimension of entity and relation embeddings')
+parser.add_argument('--n_hop', type=int, default=2, help='maximum hops')
+parser.add_argument('--kge_weight', type=float, default=0.01, help='weight of the KGE term')
+parser.add_argument('--l2_weight', type=float, default=1e-7, help='weight of the l2 regularization term')
+parser.add_argument('--lr', type=float, default=0.02, help='learning rate')
+parser.add_argument('--batch_size', type=int, default=1024, help='batch size')
+parser.add_argument('--n_epoch', type=int, default=10, help='the number of epochs')
+parser.add_argument('--n_memory', type=int, default=32, help='size of ripple set for each hop')
+parser.add_argument('--item_update_mode', type=str, default='plus_transform',
+                    help='how to update item at the end of each hop')
+parser.add_argument('--using_all_hops', type=bool, default=True,
+                    help='whether using outputs of all hops or just the last hop when making prediction')
+
+'''
+# default settings for Book-Crossing
+parser = argparse.ArgumentParser()
+parser.add_argument('--dataset', type=str, default='book', help='which dataset to use')
+parser.add_argument('--dim', type=int, default=4, help='dimension of entity and relation embeddings')
+parser.add_argument('--n_hop', type=int, default=2, help='maximum hops')
+parser.add_argument('--kge_weight', type=float, default=1e-2, help='weight of the KGE term')
+parser.add_argument('--l2_weight', type=float, default=1e-5, help='weight of the l2 regularization term')
+parser.add_argument('--lr', type=float, default=1e-3, help='learning rate')
+parser.add_argument('--batch_size', type=int, default=1024, help='batch size')
+parser.add_argument('--n_epoch', type=int, default=10, help='the number of epochs')
+parser.add_argument('--n_memory', type=int, default=32, help='size of ripple set for each hop')
+parser.add_argument('--item_update_mode', type=str, default='plus_transform',
+                    help='how to update item at the end of each hop')
+parser.add_argument('--using_all_hops', type=bool, default=True,
+                    help='whether using outputs of all hops or just the last hop when making prediction')
+'''
+
+args = parser.parse_args()
+
+show_loss = False
+data_info = load_data(args)
+train(args, data_info, show_loss)

recommendation/Basic-RippleNet-Demo/main.py

@@ -0,0 +1,154 @@
+import tensorflow as tf
+import numpy as np
+from sklearn.metrics import roc_auc_score
+
+
+class RippleNet(object):
+    def __init__(self, args, n_entity, n_relation):
+        self._parse_args(args, n_entity, n_relation)
+        self._build_inputs()
+        self._build_embeddings()
+        self._build_model()
+        self._build_loss()
+        self._build_train()
+
+    def _parse_args(self, args, n_entity, n_relation):
+        self.n_entity = n_entity
+        self.n_relation = n_relation
+        self.dim = args.dim
+        self.n_hop = args.n_hop
+        self.kge_weight = args.kge_weight
+        self.l2_weight = args.l2_weight
+        self.lr = args.lr
+        self.n_memory = args.n_memory
+        self.item_update_mode = args.item_update_mode
+        self.using_all_hops = args.using_all_hops
+
+    def _build_inputs(self):
+        self.items = tf.placeholder(dtype=tf.int32, shape=[None], name="items")
+        self.labels = tf.placeholder(dtype=tf.float64, shape=[None], name="labels")
+        self.memories_h = []
+        self.memories_r = []
+        self.memories_t = []
+
+        for hop in range(self.n_hop):
+            self.memories_h.append(
+                tf.placeholder(dtype=tf.int32, shape=[None, self.n_memory], name="memories_h_" + str(hop)))
+            self.memories_r.append(
+                tf.placeholder(dtype=tf.int32, shape=[None, self.n_memory], name="memories_r_" + str(hop)))
+            self.memories_t.append(
+                tf.placeholder(dtype=tf.int32, shape=[None, self.n_memory], name="memories_t_" + str(hop)))
+
+    def _build_embeddings(self):
+        self.entity_emb_matrix = tf.get_variable(name="entity_emb_matrix", dtype=tf.float64,
+                                                 shape=[self.n_entity, self.dim],
+                                                 initializer=tf.contrib.layers.xavier_initializer())
+        self.relation_emb_matrix = tf.get_variable(name="relation_emb_matrix", dtype=tf.float64,
+                                                   shape=[self.n_relation, self.dim, self.dim],
+                                                   initializer=tf.contrib.layers.xavier_initializer())
+
+    def _build_model(self):
+        # transformation matrix for updating item embeddings at the end of each hop
+        self.transform_matrix = tf.get_variable(name="transform_matrix", shape=[self.dim, self.dim], dtype=tf.float64,
+                                                initializer=tf.contrib.layers.xavier_initializer())
+
+        # [batch size, dim]
+        self.item_embeddings = tf.nn.embedding_lookup(self.entity_emb_matrix, self.items)
+
+        self.h_emb_list = []
+        self.r_emb_list = []
+        self.t_emb_list = []
+        for i in range(self.n_hop):
+            # [batch size, n_memory, dim]
+            self.h_emb_list.append(tf.nn.embedding_lookup(self.entity_emb_matrix, self.memories_h[i]))
+
+            # [batch size, n_memory, dim, dim]
+            self.r_emb_list.append(tf.nn.embedding_lookup(self.relation_emb_matrix, self.memories_r[i]))
+
+            # [batch size, n_memory, dim]
+            self.t_emb_list.append(tf.nn.embedding_lookup(self.entity_emb_matrix, self.memories_t[i]))
+
+        o_list = self._key_addressing()
+
+        self.scores = tf.squeeze(self.predict(self.item_embeddings, o_list))
+        self.scores_normalized = tf.sigmoid(self.scores)
+
+    def _key_addressing(self):
+        o_list = []
+        for hop in range(self.n_hop):
+            # [batch_size, n_memory, dim, 1]
+            h_expanded = tf.expand_dims(self.h_emb_list[hop], axis=3)
+            # [batch_size, n_memory, dim]
+            Rh = tf.squeeze(tf.matmul(self.r_emb_list[hop], h_expanded), axis=3)
+            # [batch_size, dim, 1]
+            v = tf.expand_dims(self.item_embeddings, axis=2)
+            # [batch_size, n_memory]
+            probs = tf.squeeze(tf.matmul(Rh, v), axis=2)
+            # [batch_size, n_memory]
+            probs_normalized = tf.nn.softmax(probs)
+            # [batch_size, n_memory, 1]
+            probs_expanded = tf.expand_dims(probs_normalized, axis=2)
+            # [batch_size, dim]
+            o = tf.reduce_sum(self.t_emb_list[hop] * probs_expanded, axis=1)
+
+            self.item_embeddings = self.update_item_embedding(self.item_embeddings, o)
+            o_list.append(o)
+        return o_list
+
+    def update_item_embedding(self, item_embeddings, o):
+        if self.item_update_mode == "replace":
+            item_embeddings = o
+        elif self.item_update_mode == "plus":
+            item_embeddings = item_embeddings + o
+        elif self.item_update_mode == "replace_transform":
+            item_embeddings = tf.matmul(o, self.transform_matrix)
+        elif self.item_update_mode == "plus_transform":
+            item_embeddings = tf.matmul(item_embeddings + o, self.transform_matrix)
+        else:
+            raise Exception("Unknown item updating mode: " + self.item_update_mode)
+        return item_embeddings
+
+    def predict(self, item_embeddings, o_list):
+        y = o_list[-1]
+        if self.using_all_hops:
+            for i in range(self.n_hop - 1):
+                y += o_list[i]
+
+        # [batch_size]
+        scores = tf.reduce_sum(item_embeddings * y, axis=1)
+        return scores
+
+    def _build_loss(self):
+        self.base_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=self.labels, logits=self.scores))
+
+        self.kge_loss = 0
+        for hop in range(self.n_hop):
+            h_expanded = tf.expand_dims(self.h_emb_list[hop], axis=2)
+            t_expanded = tf.expand_dims(self.t_emb_list[hop], axis=3)
+            hRt = tf.squeeze(tf.matmul(tf.matmul(h_expanded, self.r_emb_list[hop]), t_expanded))
+            self.kge_loss += tf.reduce_mean(tf.sigmoid(hRt))
+        self.kge_loss = -self.kge_weight * self.kge_loss
+
+        self.l2_loss = 0
+        for hop in range(self.n_hop):
+            self.l2_loss += tf.reduce_mean(tf.reduce_sum(self.h_emb_list[hop] * self.h_emb_list[hop]))
+            self.l2_loss += tf.reduce_mean(tf.reduce_sum(self.t_emb_list[hop] * self.t_emb_list[hop]))
+            self.l2_loss += tf.reduce_mean(tf.reduce_sum(self.r_emb_list[hop] * self.r_emb_list[hop]))
+            if self.item_update_mode == "replace nonlinear" or self.item_update_mode == "plus nonlinear":
+                self.l2_loss += tf.nn.l2_loss(self.transform_matrix)
+        self.l2_loss = self.l2_weight * self.l2_loss
+
+        self.loss = self.base_loss + self.kge_loss + self.l2_loss
+
+    def _build_train(self):
+        self.optimizer = tf.train.AdamOptimizer(self.lr).minimize(self.loss)
+
+    def train(self, sess, feed_dict):
+        return sess.run([self.optimizer, self.loss], feed_dict)
+
+    def eval(self, sess, feed_dict):
+        labels, scores = sess.run([self.labels, self.scores_normalized], feed_dict)
+        auc = roc_auc_score(y_true=labels, y_score=scores)
+        predictions = [1 if i >= 0.5 else 0 for i in scores]
+        acc = np.mean(np.equal(predictions, labels))
+        return auc, acc