VAE.py

# -*- coding: utf-8 -*-
"""Copy of VAE.ipynb

Automatically generated by Colaboratory.

Original file is located at
    https://colab.research.google.com/drive/1UkPquY3-UI0KleY_Wy4Q2If_y5PxiywM
"""

# from google.colab import drive
import pandas as pd
import numpy as np
from scipy import sparse
# import os
# drive.mount('/content/drive', force_remount=True)

data = pd.read_csv('./ratings.csv', header=0)

# Filter out ratings < 4
data = data[data["rating"]>=4]

# Remove users with less than 5 interactions
user_dist = data[["userId"]].groupby("userId",as_index=False).size()
data = data[data['userId'].isin(user_dist[user_dist >= 5].index)]

# Get movie and user distribution
movie_dist = data[["movieId"]].groupby("movieId",as_index=False).size()
user_dist = data[["userId"]].groupby("userId",as_index=False).size()

# Split data
user_dist = user_dist.sample(frac=1)
user_list = user_dist.index

user_list_tr = user_list[:-20000]
user_list_te = user_list[-20000:-10000]
user_list_vd = user_list[-10000:]

data_tr = data[data['userId'].isin(user_list_tr)]
unique_movie_tr = pd.unique(data_tr['movieId'])
movie2ind_tr = dict((ind, i) for (i, ind) in enumerate(unique_movie_tr))
user2ind = dict((ind, i) for (i, ind) in enumerate(user_list))

def numerize(dt):
    uid = list(map(lambda x: user2ind[x], dt['userId']))
    sid = list(map(lambda x: movie2ind_tr[x], dt['movieId']))
    return pd.DataFrame(data={'uid': uid, 'sid': sid}, columns=['uid', 'sid'])

train_data = numerize(data_tr)
# train_data.to_csv(os.path.join(save_dir, 'train.csv'), index=False)

num_movies = len(unique_movie_tr)
print(num_movies)
num_users = data_tr['userId'].max() + 1
rows, cols = train_data['uid'], train_data['sid']

# Data has entry 1 where the user has rated the movie: highly sparse matrix
training_data = sparse.csr_matrix((np.ones_like(rows),(rows, cols)), dtype='float64',shape=(num_users, num_movies))

def split_train_test_proportion(data, test_prop=0.2):
    data_grouped_by_user = data.groupby('userId')
    tr_list, te_list = list(), list()

    np.random.seed(98765)

    for i, (_, group) in enumerate(data_grouped_by_user):
        n_items_u = len(group)

        if n_items_u >= 5:
            idx = np.zeros(n_items_u, dtype='bool')
            idx[np.random.choice(n_items_u, size=int(test_prop * n_items_u), replace=False).astype('int64')] = True

            tr_list.append(group[np.logical_not(idx)])
            te_list.append(group[idx])
        else:
            tr_list.append(group) 

    data_tr = pd.concat(tr_list)
    data_te = pd.concat(te_list)
    
    return data_tr, data_te

data_test = data.loc[data['userId'].isin(user_list_te)]
data_test = data_test.loc[data['movieId'].isin(unique_movie_tr)]
data_test_tr, data_test_te = split_train_test_proportion(data_test)

data_test_tr = numerize(data_test_tr)
data_test_te = numerize(data_test_te)

# data_test_tr.to_csv(os.path.join(save_dir, 'data_test_tr.csv'), index=False)
# data_test_te.to_csv(os.path.join(save_dir, 'data_test_te.csv'), index=False)

data_vd = data.loc[data['userId'].isin(user_list_vd)]
data_vd = data_vd.loc[data['movieId'].isin(unique_movie_tr)]
data_vd_tr, data_vd_te = split_train_test_proportion(data_vd)

data_vd_tr = numerize(data_vd_tr)
data_vd_te = numerize(data_vd_te)

# data_vd_tr.to_csv(os.path.join(save_dir, 'data_vd_tr.csv'), index=False)
# data_vd_te.to_csv(os.path.join(save_dir, 'data_vd_te.csv'), index=False)

import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten, Conv2D, Dropout
from tensorflow.keras import Model
from tensorflow import Variable 
from tensorflow.keras import initializers


class MyModel(Model):
  def __init__(self, input_features, inherent_features ,weight_decay=0.0, drop_prob=0):
    super(MyModel, self).__init__()
    self.weight_decay_rate = weight_decay
    self.tanh = Dense(inherent_features,
                      activation='tanh',
                      kernel_initializer=tf.keras.initializers.GlorotNormal(),
                      bias_initializer = tf.keras.initializers.TruncatedNormal(stddev=0.001) )
    self.linear_layer = Dense(input_features, 
                              activation='linear', 
                              kernel_initializer=tf.keras.initializers.GlorotNormal(),
                              bias_initializer = tf.keras.initializers.TruncatedNormal(stddev=0.001))
    self.dropout = Dropout(drop_prob)
  
  def call(self, x):
    normalized_output = tf.math.l2_normalize(x, axis=1, epsilon=1e-12) #default 2nd degree normalizer
    dropout_output = self.dropout(normalized_output)
    tanh = self.tanh(dropout_output)
    dense_output = self.linear_layer(tanh)
    return dense_output

  def loss(self, pred, target):
    pred = tf.nn.log_softmax(pred , axis=-1)
    loss_matrix = pred*target
    loss = -tf.math.reduce_mean(loss_matrix, axis=1)
    return tf.math.reduce_mean(loss, axis=0)
  
  def l2_reg(self):
    regularizer = tf.keras.regularizers.L2(0.01)
    l2_reg = 0
    for l in self.layers:      
      if(len(l.weights)>0):
        l2_reg += regularizer(l.weights[0])*self.weight_decay_rate
    return l2_reg



class VAE(Model):
  def __init__(self, input_features, inherent_features ,weight_decay=0.0, drop_prob=0.5):
    super(VAE, self).__init__()
    self.weight_decay_rate = weight_decay
    self.q_graph = Dense(inherent_features,
                         activation='tanh',
                         kernel_initializer=tf.keras.initializers.GlorotNormal(),
                         bias_initializer = tf.keras.initializers.TruncatedNormal(stddev=0.001) )
#     self.dense1 = Dense(200,
#                          activation='tanh',
#                          kernel_initializer=tf.keras.initializers.GlorotNormal(),
#                          bias_initializer = tf.keras.initializers.TruncatedNormal(stddev=0.001) )
#     self.dense2 = Dense(600,
#                          activation='tanh',
#                          kernel_initializer=tf.keras.initializers.GlorotNormal(),
#                          bias_initializer = tf.keras.initializers.TruncatedNormal(stddev=0.001) )
    self.p_graph = Dense(input_features, activation='linear', 
                         kernel_initializer=tf.keras.initializers.GlorotNormal(), 
                         bias_initializer = tf.keras.initializers.TruncatedNormal(stddev=0.001))
    self.dropout = Dropout(drop_prob)
    self.anneal_ph = 0
    self.input_ph = 0
  
  def call(self,x):
    normalized_output = tf.math.l2_normalize(x, axis=1, epsilon=1e-12) #default 2nd degree normalizer
    dropout_output = self.dropout(normalized_output)
    q_graph_out = self.q_graph(dropout_output)
#     dense1_out = self.dense1(q_graph_out)
#     dense2_out = self.dense2(dense1_out)
    # print(q_graph_out.shape)
    # print(x.shape)
    # input()
    mu = q_graph_out[:,:100]#[:,:x.shape[-1]] #x.shape[-1]
    log_std_dev = q_graph_out[:,100:]#[:,:x.shape[-1]]  #x.shape[-1]
    std_dev = tf.exp(0.5 * log_std_dev )
    KL = tf.reduce_mean(tf.reduce_sum(0.5 * (-log_std_dev + tf.exp(log_std_dev) + mu**2 - 1), axis=1))
    print("KL is :", KL)
    epsilon = tf.random.normal(std_dev.shape)
    # print("epsilon:", epsilon)
    sampled_z = mu + epsilon * std_dev
    # print("sampled z: ", sampled_z)
    logits = self.p_graph(sampled_z)
    # print("Logits:", logits)
    # input()
    return logits, KL, normalized_output
  
  def l2_reg(self):
    regularizer = tf.keras.regularizers.L2(0.0)
    l2_reg = 0
    for l in self.layers:      
      if(len(l.weights)>0):
        l2_reg += regularizer(l.weights[0])*self.weight_decay_rate
    return l2_reg

  def loss(self, pred, target, KL):
      log_softmax_var = tf.nn.log_softmax(pred)
      # print("Log Softmax Var: ", log_softmax_var)
      neg_ll = -tf.math.reduce_mean(tf.math.reduce_sum(log_softmax_var * self.input_ph,axis=-1))
      # print("Neg ll: ", neg_ll)
      reg_var = self.l2_reg()
      # print("Reg Var: ", reg_var)
      neg_ELBO = neg_ll + self.anneal_ph * KL + 2 * reg_var
      # print("Neg Elbo: ", neg_ELBO)
      # input()
      return neg_ELBO

N = training_data.shape[0]
# idxlist = range(N)
batch_size = 500
batches_per_epoch = int(np.ceil(float(N) / batch_size))

def load_tr_te_data(tp_tr, tp_te):
    start_idx = min(tp_tr['uid'].min(), tp_te['uid'].min())
    end_idx = max(tp_tr['uid'].max(), tp_te['uid'].max())

    rows_tr, cols_tr = tp_tr['uid'] - start_idx, tp_tr['sid']
    rows_te, cols_te = tp_te['uid'] - start_idx, tp_te['sid']

    data_tr = sparse.csr_matrix((np.ones_like(rows_tr),
                             (rows_tr, cols_tr)), dtype='float64', shape=(end_idx - start_idx + 1, num_movies))
    data_te = sparse.csr_matrix((np.ones_like(rows_te),
                             (rows_te, cols_te)), dtype='float64', shape=(end_idx - start_idx + 1, num_movies))
    return data_tr, data_te

vad_data_tr, vad_data_te = load_tr_te_data(data_vd_tr,data_vd_te)

import bottleneck as bn
def NDCG_binary_at_k_batch(X_pred, heldout_batch, k=100):
    '''
    normalized discounted cumulative gain@k for binary relevance
    ASSUMPTIONS: all the 0's in heldout_data indicate 0 relevance
    '''
    batch_users = X_pred.shape[0]
    idx_topk_part = bn.argpartition(-X_pred, k, axis=1)
    topk_part = X_pred[np.arange(batch_users)[:, np.newaxis],
                       idx_topk_part[:, :k]]
    idx_part = np.argsort(-topk_part, axis=1)
    # X_pred[np.arange(batch_users)[:, np.newaxis], idx_topk] is the sorted
    # topk predicted score
    idx_topk = idx_topk_part[np.arange(batch_users)[:, np.newaxis], idx_part]
    # build the discount template
    tp = 1. / np.log2(np.arange(2, k + 2))

    DCG = (heldout_batch[np.arange(batch_users)[:, np.newaxis],
                         idx_topk].toarray() * tp).sum(axis=1)
    IDCG = np.array([(tp[:min(n, k)]).sum()
                     for n in heldout_batch.getnnz(axis=1)])
    return DCG / IDCG

# weight initialization
def weights_init(m):
    classname = m.__class__.__name__
    if classname.find('Linear') != -1:
        tf.keras.initializer.GlorotNormal(m.weight.data) ## might throw error
        tf.keras.initializer.RandomNormal(m.bias.data,stddev=0.001)
        m.bias.data.clamp_(-2*0.001, 2*0.001) # temporary fix: this will set the values to 0 but 
        # in tf the values are redrawn : write a function for this if necessary

#call model
device = tf.device('cuda' if tf.test.is_gpu_available(cuda_only=True) else 'cpu')
model = VAE(num_movies,200,weight_decay=0)
# model.apply(weights_init)
optimizer =tf.keras.optimizers.Adam(learning_rate=1e-3, beta_1=0.0)

# # # #define default pytorch dataloader
# # # # from torch.utils import data
# # # # assumes 'training_data' is np array
# # # # need to chage the structure of array from [a,b] to [a,[b,1]]
# # # #training_data= sparse.csr_matrix.toarray(training_data)
# # # # dataloader= torch.utils.data.DataLoader(training_data,batch_size = 500,drop_last=True)

from scipy import sparse

def convert_to_sparse_matrix(x):
  indices = [[]]
  values = []
  finalShape = x.shape
  rows, cols = x.nonzero()
  for row, col in zip(rows, cols):
    indices.append((row, col))
    values.append(x[row,col])
  return tf.sparse.SparseTensor(indices[1:], values, finalShape)

# print(training_data.shape)
sparse_training_data = convert_to_sparse_matrix(training_data)
dataloader = tf.data.Dataset.from_tensor_slices(sparse_training_data)

dataloader =  dataloader.batch(500, drop_remainder=True)

#for validation data
batch_size_vd = batch_size
no_batches = 10000/batch_size_vd
print(no_batches)
batch_list_vd = np.arange((no_batches)).astype('int32')
rng = np.random.default_rng()
rng.shuffle(batch_list_vd)

# loop for training
# training_data

# batches_per_epoch = 138494/500
batch_list = np.arange((batches_per_epoch-2))

rng = np.random.default_rng()
rng.shuffle(batch_list)

ndcg_vad =[]

# the total number of gradient updates for annealing
total_anneal_steps = 200000
# largest annealing parameter
anneal_cap = 0.2
update_count = 0.0
# from torch.autograd import Variable
ndcgs_vad=[]
out_val = []
for epoch in range(50):
  rng.shuffle(batch_list)
  i = 0
  loss = 0
  loss_total = 0
  while i < len(batch_list):
    data = training_data[batch_list[i]*batch_size:(batch_list[i]+1)*batch_size].toarray()
    i+=1
    # model.zero_grad() ## try this
    with tf.GradientTape() as tape:
      inputs=tf.convert_to_tensor(data, dtype='float32')
      
      anneal = 0
      if total_anneal_steps > 0:
          anneal = min(anneal_cap, 1. * update_count / total_anneal_steps)
      else:
          anneal = anneal_cap
      model.anneal_ph = anneal
      update_count += 1
      inputv = Variable(inputs)

      pred, KL, normalized_input = model(inputv)
      # print("Prediction:", pred)
      # print("Target:", inputv)
      # input()
      model.input_ph = normalized_input
      loss = model.loss(pred, inputv, KL)
      print("Batch ", i, ":", loss)
      # los_reg = model.l2_reg()
      # loss_total = loss+los_reg
      gradients = tape.gradient(loss, model.trainable_variables)
      optimizer.apply_gradients(zip(gradients, model.trainable_variables))
  print(epoch, loss)

  ndcg_dist = []
  j=0
  while j< len(batch_list_vd):
    data_vd_tr = vad_data_tr[batch_list_vd[j]*batch_size:(batch_list_vd[j]+1)*batch_size].toarray()
    data_vd_te = vad_data_te[batch_list_vd[j]*batch_size:(batch_list_vd[j]+1)*batch_size]#.toarray()
   
   
    pred_val, KL, normalized_input = model(Variable(tf.convert_to_tensor(data_vd_tr)))
    model.input_ph = normalized_input
    pred_val = pred_val.cpu().numpy()
    pred_val[data_vd_tr.nonzero()] = -np.inf
    ndcg_dist.append(NDCG_binary_at_k_batch(pred_val, data_vd_te))
    j+=1
  ndcg = np.nan_to_num(ndcg_dist, nan=1)
  ndcg_dist1 = np.concatenate(ndcg) 
  #   print(np.mean(ndcg_dist1))
  out_val.append(np.mean(ndcg_dist1))
  print("-----------------------")
  print(out_val)
  print("-----------------------")

# Commented out IPython magic to ensure Python compatibility.
import matplotlib.pyplot as plt
# %matplotlib inline
x = np.arange(1,33,1)

plt.figure(figsize=(12, 3))
plt.plot(x,ndcg_dist,'r-',label='final')
plt.ylabel("Validation NDCG@100")
plt.xlabel("Epochs")
plt.legend()
plt.savefig(save_dir+'/combine')