session-based recommend rnn

Author: shixiaowen03

.idea/workspace.xml

@@ -0,0 +1,5 @@
+git:https://github.com/Songweiping/GRU4Rec_TensorFlow
+
+paper:Session-based Recommendations With Recurrent Neural Networks
+
+site:http://arxiv.org/abs/1511.06939

recommendation/Basic-SessionBasedRNN-Demo/README.md

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Feb 27 2017
+Author: Weiping Song
+"""
+import numpy as np
+import pandas as pd
+
+
+def evaluate_sessions_batch(model, train_data, test_data, cut_off=20, batch_size=50, session_key='SessionId',
+                            item_key='ItemId', time_key='Time'):
+    '''
+    Evaluates the GRU4Rec network wrt. recommendation accuracy measured by recall@N and MRR@N.
+
+    Parameters
+    --------
+    model : A trained GRU4Rec model.
+    train_data : It contains the transactions of the train set. In evaluation phrase, this is used to build item-to-id map.
+    test_data : It contains the transactions of the test set. It has one column for session IDs, one for item IDs and one for the timestamp of the events (unix timestamps).
+    cut-off : int
+        Cut-off value (i.e. the length of the recommendation list; N for recall@N and MRR@N). Defauld value is 20.
+    batch_size : int
+        Number of events bundled into a batch during evaluation. Speeds up evaluation. If it is set high, the memory consumption increases. Default value is 100.
+    session_key : string
+        Header of the session ID column in the input file (default: 'SessionId')
+    item_key : string
+        Header of the item ID column in the input file (default: 'ItemId')
+    time_key : string
+        Header of the timestamp column in the input file (default: 'Time')
+
+    Returns
+    --------
+    out : tuple
+        (Recall@N, MRR@N)
+
+    '''
+    model.predict = False
+    # Build itemidmap from train data.
+    itemids = train_data[item_key].unique()
+    itemidmap = pd.Series(data=np.arange(len(itemids)), index=itemids)
+
+    test_data.sort([session_key, time_key], inplace=True)
+    offset_sessions = np.zeros(test_data[session_key].nunique() + 1, dtype=np.int32)
+    offset_sessions[1:] = test_data.groupby(session_key).size().cumsum()
+    evalutation_point_count = 0
+    mrr, recall = 0.0, 0.0
+    if len(offset_sessions) - 1 < batch_size:
+        batch_size = len(offset_sessions) - 1
+    iters = np.arange(batch_size).astype(np.int32)
+    maxiter = iters.max()
+    start = offset_sessions[iters]
+    end = offset_sessions[iters + 1]
+    in_idx = np.zeros(batch_size, dtype=np.int32)
+    np.random.seed(42)
+    while True:
+        valid_mask = iters >= 0
+        if valid_mask.sum() == 0:
+            break
+        start_valid = start[valid_mask]
+        minlen = (end[valid_mask] - start_valid).min()
+        in_idx[valid_mask] = test_data[item_key].values[start_valid]
+        for i in range(minlen - 1):
+            out_idx = test_data[item_key].values[start_valid + i + 1]
+            preds = model.predict_next_batch(iters, in_idx, itemidmap, batch_size)
+            preds.fillna(0, inplace=True)
+            in_idx[valid_mask] = out_idx
+            ranks = (preds.values.T[valid_mask].T > np.diag(preds.ix[in_idx].values)[valid_mask]).sum(axis=0) + 1
+            rank_ok = ranks < cut_off
+            recall += rank_ok.sum()
+            mrr += (1.0 / ranks[rank_ok]).sum()
+            evalutation_point_count += len(ranks)
+        start = start + minlen - 1
+        mask = np.arange(len(iters))[(valid_mask) & (end - start <= 1)]
+        for idx in mask:
+            maxiter += 1
+            if maxiter >= len(offset_sessions) - 1:
+                iters[idx] = -1
+            else:
+                iters[idx] = maxiter
+                start[idx] = offset_sessions[maxiter]
+                end[idx] = offset_sessions[maxiter + 1]
+    return recall / evalutation_point_count, mrr / evalutation_point_count

recommendation/Basic-SessionBasedRNN-Demo/evaluation.py

@@ -0,0 +1,26 @@
+import pandas as pd
+
+import numpy as np
+
+import random
+
+train_data = np.zeros([3,10000],dtype=np.int32)
+
+test_data = np.zeros([3,100],dtype=np.int32)
+
+for i in range(10000):
+    train_data[0,i] = random.randint(0,200)
+    train_data[1,i] = random.randint(0,200)
+    train_data[2,i] = random.randint(0,20000)
+
+for i in range(100):
+    test_data[0,i] = random.randint(0, 200)
+    test_data[1,i] = random.randint(0, 200)
+    test_data[2,i] = random.randint(0, 20000)
+
+train_data = np.transpose(train_data)
+test_data = np.transpose(test_data)
+
+
+train_df = pd.DataFrame(train_data,columns=['SessionId','ItemId','Timestamps']).to_csv('data/train.csv')
+test_df = pd.DataFrame(test_data,columns=['SessionId','ItemId','Timestamps']).to_csv('data/test.csv')

recommendation/Basic-SessionBasedRNN-Demo/gen_data.py

@@ -9,8 +9,8 @@
 import model
 import evaluation
 
-train_data = ''
-test_data = ''
+train_data = 'data/train.csv'
+test_data = 'data/test.csv'
 
 class Args():
     is_training = False
@@ -21,13 +21,13 @@ class Args():
     dropout_p_hidden = 1
     learning_rate = 0.001
     decay = 0.96
-    decay_steps = 1e4
+    decay_steps = 10
     sigma = 0
     init_as_normal = False
     reset_after_session = True
     session_key = 'SessionId'
     item_key = 'ItemId'
-    time_key = 'Time'
+    time_key = 'Timestamps'
     grad_cap = 0
     test_model = 2
     checkpoint_dir = './checkpoint'
@@ -41,7 +41,7 @@ def parseArgs():
     parser = argparse.ArgumentParser(description='GRU4Rec args')
     parser.add_argument('--layer', default=1, type=int)
     parser.add_argument('--size', default=100, type=int)
-    parser.add_argument('--epoch', default=3, type=int)
+    parser.add_argument('--epoch', default=300, type=int)
     parser.add_argument('--lr', default=0.001, type=float)
     parser.add_argument('--train', default=1, type=int)
     parser.add_argument('--test', default=2, type=int)

recommendation/Basic-SessionBasedRNN-Demo/main.py

@@ -52,7 +52,7 @@ def __init__(self,sess,args):
             if args.final_act == 'linear':
                 self.final_activation = self.linear
             elif args.final_act == 'relu':
-                self.final_activatin = self.relu
+                self.final_activation = self.relu
             else:
                 self.final_activation = self.tanh
             self.loss_function = self.top1
@@ -109,4 +109,219 @@ def top1(self, yhat):
         term1 = tf.reduce_mean(tf.nn.sigmoid(-tf.diag_part(yhat)+yhatT)+tf.nn.sigmoid(yhatT**2), axis=0)
         term2 = tf.nn.sigmoid(tf.diag_part(yhat)**2) / self.batch_size
         return tf.reduce_mean(term1 - term2)
+
+
+    def build_model(self):
+        self.X = tf.placeholder(tf.int32,[self.batch_size],name='input')
+        self.Y = tf.placeholder(tf.int32,[self.batch_size],name='output')
+        self.state = [tf.placeholder(tf.float32,[self.batch_size,self.rnn_size],name='rnn_state') for _ in range(self.layers)]
+        self.global_step = tf.Variable(0,name='global_step',trainable=False)
+
+        with tf.variable_scope('gru_layer'):
+            sigma = self.sigma if self.sigma != 0 else np.sqrt(6.0 / (self.n_items + self.rnn_size))
+            if self.init_as_normal:
+                initializer = tf.random_normal_initializer(mean=0, stddev=sigma)
+            else:
+                initializer = tf.random_uniform_initializer(minval=-sigma, maxval=sigma)
+
+            embedding = tf.get_variable('embedding',[self.n_items,self.rnn_size],initializer=initializer)
+            softmax_W = tf.get_variable('softmax_w',[self.n_items,self.rnn_size],initializer=initializer)
+            softmax_b = tf.get_variable('softmax_b',[self.n_items],initializer=tf.constant_initializer(0.0))
+
+
+            cell = rnn_cell.GRUCell(self.rnn_size,activation=self.hidden_act)
+            drop_cell = rnn_cell.DropoutWrapper(cell,output_keep_prob=self.dropout_p_hidden)
+            stacked_cell = rnn_cell.MultiRNNCell([drop_cell] * self.layers)
+
+            inputs = tf.nn.embedding_lookup(embedding,self.X)
+            output,state = stacked_cell(inputs,tuple(self.state))
+            self.final_state = state
+
+
+        if self.is_training:
+            sampled_W = tf.nn.embedding_lookup(softmax_W,self.Y)
+            sampled_b = tf.nn.embedding_lookup(softmax_b,self.Y)
+
+            logits = tf.matmul(output,sampled_W,transpose_b=True) + sampled_b
+            self.y_hat = self.final_activation(logits)
+            self.cost = self.loss_function(self.y_hat)
+
+        else:
+            logits = tf.matmul(output,softmax_W,transpose_b=True) + softmax_b
+            self.y_hat = self.final_activation(logits)
+
+
+        if not self.is_training:
+            return
+
+        self.lr = tf.maximum(1e-5,
+                             tf.train.exponential_decay(self.learning_rate, self.global_step, self.decay_steps,
+                                                        self.decay, staircase=True))
+
+        optimizer = tf.train.AdamOptimizer(self.lr)
+        tvars = tf.trainable_variables()
+        gvs = optimizer.compute_gradients(self.cost, tvars)
+        if self.grad_cap > 0:
+            capped_gvs = [(tf.clip_by_norm(grad, self.grad_cap), var) for grad, var in gvs]
+        else:
+            capped_gvs = gvs
+        self.train_op = optimizer.apply_gradients(capped_gvs, global_step=self.global_step)
+
+
+    def init(self,data):
+        data.sort_values([self.session_key,self.time_key],inplace=True)
+        offset_sessions = np.zeros(data[self.session_key].nunique()+1,dtype=np.int32)
+        offset_sessions[1:] = data.groupby(self.session_key).size().cumsum() # [0,25,38] 说明第一个session有25个，第二个session有13个
+        return offset_sessions
+
+
+    def fit(self,data):
+        self.error_during_train = False
+
+        itemids = data[self.item_key].unique()
+        self.n_items = len(itemids)
+        self.itemidmap = pd.Series(data=np.arange(self.n_items),index=itemids)
+
+        data = pd.merge(data, pd.DataFrame({self.item_key: itemids, 'ItemIdx': self.itemidmap[itemids].values}),
+                        on=self.item_key, how='inner')
+        offset_sessions = self.init(data)
+
+        print('fitting model...')
+
+        for epoch in range(self.n_epochs):
+            epoch_cost = []
+            state = [np.zeros([self.batch_size,self.rnn_size],dtype=np.float32) for _ in range(self.layers)]
+            session_idx_arr = np.arange(len(offset_sessions)-1)
+            iters = np.arange(self.batch_size)
+
+            maxiter = iters.max()
+            start = offset_sessions[session_idx_arr[iters]]
+            end = offset_sessions[session_idx_arr[iters] + 1]
+
+            finished = False
+            while not finished:
+                minlen = (end-start).min()
+                out_idx = data.ItemIdx.values[start]
+                for i in range(minlen-1):
+                    in_idx = out_idx
+                    out_idx = data.ItemIdx.values[start+i+1]
+                    fetches = [self.cost,self.final_state,self.global_step,self.lr,self.train_op]
+                    feed_dict = {self.X:in_idx,self.Y:out_idx}
+
+                    for j in range(self.layers):
+                        feed_dict[self.state[j]] = state[j]
+
+                    cost,state,step,lr,_ = self.sess.run(fetches,feed_dict)
+
+
+                    epoch_cost.append(cost)
+                    if np.isnan(cost):
+                        print(str(epoch) + ':Nan error!')
+                        self.error_during_train = True
+                        return
+                    if step == 1 or step % self.decay_steps == 0:
+                        avgc = np.mean(epoch_cost)
+                        print('Epoch {}\tStep {}\tlr: {:.6f}\tloss: {:.6f}'.format(epoch, step, lr, avgc))
+
+                start = start + minlen - 1
+                mask = np.arange(len(iters))[(end-start) <= 1] # 哪些是已经结束的
+
+                for idx in mask:
+                    maxiter += 1
+                    if maxiter >= len(offset_sessions) - 1:
+                        print("epoch finish")
+                        finished = True
+                        break
+                    # 用下一个session的数据接力
+                    iters[idx] = maxiter
+                    start[idx] = offset_sessions[session_idx_arr[maxiter]]
+                    end[idx] = offset_sessions[session_idx_arr[maxiter] + 1]
+
+                if len(mask) and self.reset_after_session:
+                    for i in range(self.layers):
+                        state[i][mask] = 0
+
+            avgc = np.mean(epoch_cost)
+            if np.isnan(avgc):
+                print('Epoch {}: Nan error!'.format(epoch, avgc))
+                self.error_during_train = True
+                return
+            self.saver.save(self.sess, '{}/gru-model'.format(self.checkpoint_dir), global_step=epoch)
+
+    def predict_next_batch(self, session_ids, input_item_ids, itemidmap, batch=50):
+        '''
+        Gives predicton scores for a selected set of items. Can be used in batch mode to predict for multiple independent events (i.e. events of different sessions) at once and thus speed up evaluation.
+
+        If the session ID at a given coordinate of the session_ids parameter remains the same during subsequent calls of the function, the corresponding hidden state of the network will be kept intact (i.e. that's how one can predict an item to a session).
+        If it changes, the hidden state of the network is reset to zeros.
+
+        Parameters
+        --------
+        session_ids : 1D array
+            Contains the session IDs of the events of the batch. Its length must equal to the prediction batch size (batch param).
+        input_item_ids : 1D array
+            Contains the item IDs of the events of the batch. Every item ID must be must be in the training data of the network. Its length must equal to the prediction batch size (batch param).
+        batch : int
+            Prediction batch size.
+
+        Returns
+        --------
+        out : pandas.DataFrame
+            Prediction scores for selected items for every event of the batch.
+            Columns: events of the batch; rows: items. Rows are indexed by the item IDs.
+
+        '''
+        if batch != self.batch_size:
+            raise Exception('Predict batch size({}) must match train batch size({})'.format(batch, self.batch_size))
+        if not self.predict:
+            self.current_session = np.ones(batch) * -1
+            self.predict = True
+
+        session_change = np.arange(batch)[session_ids != self.current_session]
+        if len(session_change) > 0:  # change internal states with session changes
+            for i in range(self.layers):
+                self.predict_state[i][session_change] = 0.0
+            self.current_session = session_ids.copy()
+
+        in_idxs = itemidmap[input_item_ids]
+        fetches = [self.y_hat, self.final_state]
+        feed_dict = {self.X: in_idxs}
+        for i in range(self.layers):
+            feed_dict[self.state[i]] = self.predict_state[i]
+        preds, self.predict_state = self.sess.run(fetches, feed_dict)
+        preds = np.asarray(preds).T
+        return pd.DataFrame(data=preds, index=itemidmap.index)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+