MKR

Author: shixiaowen03

.idea/workspace.xml

@@ -72,7 +72,7 @@ def gen_epochs(n):
     b = tf.get_variable("b",[num_classes],initializer=tf.constant_initializer(0.0))
 
 
-logits = tf.reshape(tf.matmul(tf.reshape(rnn_outputs,[-1,batch_size]),W)+b,[batch_size,num_steps,num_classes])
+logits = tf.reshape(tf.matmul(tf.reshape(rnn_outputs,[-1,state_size]),W)+b,[batch_size,num_steps,num_classes])
 predictions = tf.nn.softmax(logits)
 
 losses = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y,logits=predictions)

nlp/RNN_dynamic_cell.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+def load_data(args):
+    n_user,n_item,train_data,eval_data,test_data = load_rating(args)
+    n_entity,n_relation,kg = load_kg(args)
+    print('data loaded.')
+
+    return n_user,n_item,n_entity,n_relation,train_data,eval_data,test_data,kg
+
+
+def load_rating(args):
+    print('reading rating file......')
+
+    rating_file = 'data/ratings_final.txt'
+    rating_np = np.loadtxt(rating_file,dtype=np.int32)
+
+    n_user = len(set(rating_np[:,0]))
+    n_item = len(set(rating_np[:,1]))
+
+    train_data,eval_data,test_data = dataset_split(rating_np)
+    return n_user,n_item,train_data,eval_data,test_data
+
+
+def dataset_split(rating_np):
+    print('spliting dataset ....')
+
+    eval_ratio = 0.2
+    test_ratio = 0.2
+
+    n_ratings = rating_np.shape[0]
+
+    eval_indices = np.random.choice(list(range(n_ratings)),size = int(n_ratings * eval_ratio),replace=False)
+    left = set(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))
+
+    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
+
+def load_kg(args):
+    print('reading KG file...')
+
+    kg_file = 'data/kg_final.txt'
+    kg = np.loadtxt(kg_file,dtype=np.int32)
+    n_entity = len(set(kg[:,0]) | set(kg[:,2]))
+    n_relation = len(set(kg[:,1]))
+
+    return n_entity,n_relation,kg
+
+

recommendation/Basic-MKR-Demo/data_loader.py

@@ -0,0 +1,92 @@
+import tensorflow as tf
+from abc import abstractclassmethod
+
+LAYER_IDS = {}
+
+
+def get_layer_id(layer_name=''):
+    if layer_name not in LAYER_IDS:
+        LAYER_IDS[layer_name] = 0
+        return 0
+
+    else:
+        LAYER_IDS[layer_name] += 1
+        return LAYER_IDS[layer_name]
+
+
+class Layer(object):
+    def __init__(self,name):
+        if not name:
+            layer = self.__class__.__name__.lower()
+            name = layer + '_' + str(get_layer_id(layer))
+        self.name = name
+        self.vars = []
+
+    def __call__(self,inputs):
+        outputs = self._call(inputs)
+        return outputs
+
+
+    @abstractclassmethod
+    def _call(self,inputs):
+        pass
+
+
+class Dense(Layer):
+    def __init__(self,input_dim,output_dim,dropout=0.0,act = tf.nn.relu,name=None):
+        super(Dense,self).__init__(name)
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+        self.dropout = dropout
+        self.act =act
+        with tf.variable_scope(self.name):
+            self.weight = tf.get_variable(name='weight',shape=(input_dim,output_dim),dtype=tf.float32)
+            self.bias = tf.get_variable(name='bias',shape=output_dim,initializer=tf.zeros_initializer())
+        self.vars = [self.weight]
+
+    def _call(self,inputs):
+        x = tf.nn.dropout(inputs,1-self.dropout)
+        output = tf.matmul(x,self.weight) + self.bias
+        return self.act(output)
+
+
+
+class CrossCompressUnit(Layer):
+    def __init__(self,dim,name=None):
+        super(CrossCompressUnit,self).__init__(name)
+        self.dim = dim
+        with tf.variable_scope(self.name):
+            self.weight_vv = tf.get_variable(name='weight_vv',shape=(dim,1),dtype=tf.float32)
+            self.weight_ev = tf.get_variable(name='weight_ev',shape=(dim,1),dtype=tf.float32)
+            self.weight_ve = tf.get_variable(name='weight_ve',shape=(dim,1),dtype=tf.float32)
+            self.weight_ee = tf.get_variable(name='weight_ee',shape=(dim,1),dtype=tf.float32)
+
+            self.bias_v = tf.get_variable(name='bias_v',shape=dim,initializer=tf.zeros_initializer())
+            self.bias_e = tf.get_variable(name='bias_e',shape=dim,initializer=tf.zeros_initializer())
+
+        self.vars = [self.weight_vv,self.weight_ev,self.weight_ve,self.weight_ee]
+
+    def _call(self,inputs):
+        # [batch_size, dim]
+        v,e = inputs
+
+        v = tf.expand_dims(v,dim=2)
+        e = tf.expand_dims(e,dim=1)
+
+
+        # [batch_size, dim, dim]
+        c_matrix = tf.matmul(v, e)
+        c_matrix_transpose = tf.transpose(c_matrix, perm=[0, 2, 1])
+
+        # [batch_size * dim, dim]
+        c_matrix = tf.reshape(c_matrix, [-1, self.dim])
+        c_matrix_transpose = tf.reshape(c_matrix_transpose, [-1, self.dim])
+
+        v_output = tf.reshape(tf.matmul(c_matrix,self.weight_vv) + tf.matmul(c_matrix_transpose,self.weight_ev),[-1,self.dim]) + self.bias_v
+
+        e_output = tf.reshape(tf.matmul(c_matrix, self.weight_ve) + tf.matmul(c_matrix_transpose, self.weight_ee),
+                              [-1, self.dim]) + self.bias_e
+
+        return v_output,e_output
+
+

recommendation/Basic-MKR-Demo/layers.py

@@ -0,0 +1,28 @@
+import argparse
+import numpy as np
+from data_loader import load_data
+from train import train
+
+np.random.seed(555)
+
+
+parser = argparse.ArgumentParser()
+
+# movie
+parser.add_argument('--dataset', type=str, default='movie', help='which dataset to use')
+parser.add_argument('--n_epochs', type=int, default=20, help='the number of epochs')
+parser.add_argument('--dim', type=int, default=8, help='dimension of user and entity embeddings')
+parser.add_argument('--L', type=int, default=1, help='number of low layers')
+parser.add_argument('--H', type=int, default=1, help='number of high layers')
+parser.add_argument('--batch_size', type=int, default=4096, help='batch size')
+parser.add_argument('--l2_weight', type=float, default=1e-6, help='weight of l2 regularization')
+parser.add_argument('--lr_rs', type=float, default=0.02, help='learning rate of RS task')
+parser.add_argument('--lr_kge', type=float, default=0.01, help='learning rate of KGE task')
+parser.add_argument('--kge_interval', type=int, default=3, help='training interval of KGE task')
+
+show_loss = False
+show_topk = False
+
+args = parser.parse_args()
+data = load_data(args)
+train(args, data, show_loss, show_topk)

recommendation/Basic-MKR-Demo/main.py

@@ -0,0 +1,132 @@
+import numpy as np
+import tensorflow as tf
+from sklearn.metrics import roc_auc_score
+from layers import Dense,CrossCompressUnit
+
+
+class MKR(object):
+    def __init__(self,args,n_users,n_items,n_entities,n_relations):
+        self._parse_args(n_users, n_items, n_entities, n_relations)
+        self._build_inputs()
+        self._build_model(args)
+        self._build_loss(args)
+        self._build_train(args)
+
+    def _parse_args(self, n_users, n_items, n_entities, n_relations):
+        self.n_user = n_users
+        self.n_item = n_items
+        self.n_entity = n_entities
+        self.n_relation = n_relations
+
+        # for computing l2 loss
+        self.vars_rs = []
+        self.vars_kge = []
+
+    def _build_inputs(self):
+        self.user_indices = tf.placeholder(tf.int32,[None],'user_indices')
+        self.item_indices = tf.placeholder(tf.int32,[None],'item_indices')
+        self.labels = tf.placeholder(tf.float32,[None],'labels')
+        self.head_indices = tf.placeholder(tf.int32,[None],'head_indices')
+        self.tail_indices = tf.placeholder(tf.int32,[None],'tail_indices')
+        self.relation_indices = tf.placeholder(tf.int32,[None],'relation_indices')
+
+    def _build_model(self,args):
+        self._build_low_layers(args)
+        self._build_high_layers(args)
+
+
+    def _build_low_layers(self,args):
+        self.user_emb_matrix = tf.get_variable('user_emb_matrix', [self.n_user, args.dim])
+        self.item_emb_matrix = tf.get_variable('item_emb_matrix', [self.n_item, args.dim])
+        self.entity_emb_matrix = tf.get_variable('entity_emb_matrix', [self.n_entity, args.dim])
+        self.relation_emb_matrix = tf.get_variable('relation_emb_matrix', [self.n_relation, args.dim])
+
+        # [batch_size, dim]
+        self.user_embeddings = tf.nn.embedding_lookup(self.user_emb_matrix, self.user_indices)
+        self.item_embeddings = tf.nn.embedding_lookup(self.item_emb_matrix, self.item_indices)
+        self.head_embeddings = tf.nn.embedding_lookup(self.entity_emb_matrix, self.head_indices)
+        self.relation_embeddings = tf.nn.embedding_lookup(self.relation_emb_matrix, self.relation_indices)
+        self.tail_embeddings = tf.nn.embedding_lookup(self.entity_emb_matrix, self.tail_indices)
+
+        for _ in range(args.L):
+            user_mlp = Dense(input_dim=args.dim,output_dim=args.dim)
+            tail_mlp = Dense(input_dim=args.dim,output_dim = args.dim)
+            cc_unit = CrossCompressUnit(args.dim)
+
+            self.user_embeddings = user_mlp(self.user_embeddings)
+            self.item_embeddings,self.head_embeddings = cc_unit([self.item_embeddings,self.head_embeddings])
+            self.tail_embeddings = tail_mlp(self.tail_embeddings)
+
+            self.vars_rs.extend(user_mlp.vars)
+            self.vars_rs.extend(cc_unit.vars)
+            self.vars_kge.extend(tail_mlp.vars)
+            self.vars_kge.extend(cc_unit.vars)
+
+    def _build_high_layers(self,args):
+        #RS
+        use_inner_product = True
+        if use_inner_product:
+            self.scores = tf.reduce_sum(self.user_embeddings*self.item_embeddings,axis=1)
+        else:
+            self.user_item_concat = tf.concat([self.user_embeddings,self.item_embeddings],axis=1)
+            for _ in range(args.H - 1):
+                rs_mlp = Dense(input_dim = args.dim * 2 , output_dim = args.dim * 2)
+                self.user_item_concat = rs_mlp(self.user_item_concat)
+                self.vars_rs.extend(rs_mlp.vars)
+
+            rs_pred_mlp = Dense(input_dim=args.dim * 2,output_dim=1)
+            self.scores = tf.squeeze(rs_pred_mlp(self.user_item_concat))
+            self.vars_rs.extend(rs_pred_mlp)
+
+        self.scores_normalized = tf.nn.sigmoid(self.scores)
+
+        #KGE
+        self.head_relation_concat = tf.concat([self.head_embeddings,self.relation_embeddings],axis=1)
+        for _ in range(args.H - 1):
+            kge_mlp = Dense(input_dim=args.dim * 2,output_dim = args.dim * 2)
+            self.head_relation_concat = kge_mlp(self.head_relation_concat)
+            self.vars_kge.extend(kge_mlp.vars)
+
+        kge_pred_mlp = Dense(input_dim=args.dim * 2,output_dim = args.dim)
+        self.tail_pred = kge_pred_mlp(self.head_relation_concat)
+        self.vars_kge.extend(kge_pred_mlp.vars)
+        self.tail_pred = tf.nn.sigmoid(self.tail_pred)
+
+        self.scores_kge = tf.nn.sigmoid(tf.reduce_sum(self.tail_embeddings * self.tail_pred,axis=1))
+        self.rmse = tf.reduce_mean(tf.sqrt(tf.reduce_sum(tf.square(self.tail_embeddings - self.tail_pred),axis=1) / args.dim))
+
+    def _build_loss(self, args):
+        # RS
+        self.base_loss_rs = tf.reduce_mean(
+            tf.nn.sigmoid_cross_entropy_with_logits(labels=self.labels, logits=self.scores))
+        self.l2_loss_rs = tf.nn.l2_loss(self.user_embeddings) + tf.nn.l2_loss(self.item_embeddings)
+        for var in self.vars_rs:
+            self.l2_loss_rs += tf.nn.l2_loss(var)
+        self.loss_rs = self.base_loss_rs + self.l2_loss_rs * args.l2_weight
+
+        # KGE
+        self.base_loss_kge = -self.scores_kge
+        self.l2_loss_kge = tf.nn.l2_loss(self.head_embeddings) + tf.nn.l2_loss(self.tail_embeddings)
+        for var in self.vars_kge:
+            self.l2_loss_kge += tf.nn.l2_loss(var)
+        self.loss_kge = self.base_loss_kge + self.l2_loss_kge * args.l2_weight
+
+    def _build_train(self, args):
+        self.optimizer_rs = tf.train.AdamOptimizer(args.lr_rs).minimize(self.loss_rs)
+        self.optimizer_kge = tf.train.AdamOptimizer(args.lr_kge).minimize(self.loss_kge)
+
+    def train_rs(self, sess, feed_dict):
+        return sess.run([self.optimizer_rs, self.loss_rs], feed_dict)
+
+    def train_kge(self, sess, feed_dict):
+        return sess.run([self.optimizer_kge, self.rmse], 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
+
+    def get_scores(self, sess, feed_dict):
+        return sess.run([self.item_indices, self.scores_normalized], feed_dict)