add demo file

Author: lipingliulp

experiment/demo.py

@@ -0,0 +1,104 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import sys
+import pickle
+
+import numpy as np
+from six.moves import xrange # python2/3 compatible 
+import tensorflow as tf
+import string
+import scipy 
+import scipy.sparse as sparse
+import os
+
+# import code of this project
+sys.path.insert(0, '../util/')
+from util import config_to_name
+sys.path.insert(0, '../model/')
+from embedding import fit_emb
+from embedding import evaluate_emb
+from embedding import dense_array_feeder
+from embedding import sparse_array_feeder
+from random_data import rand_data
+
+def embedding_experiment(config, dataset):
+ np.random.seed(seed=27)
+
+ ## Step 1: load data
+ print('Generating a dataset ...')
+
+ data = rand_data() # the training/test dataset generated by rand_data has two fields, but only 'scores' are needed here
+
+ trainset = data['trainset']['scores']
+ testset = data['testset']['scores']
+
+ """
+ trainset: scores: a sparse matrix, each ij entry is the rating of movie j given by person i, or the count of item j in basket i
+ testset: [same structure as trainset]
+ """
+
+ # one can always redefine zie.generate_batch(reviews, rind) to use other format of trainset and testset 
+
+ print('The training set has %d rows and %d columns, and the test set has %d rows' % 
+ (trainset.shape[0], trainset.shape[1], testset.shape[0]))
+ 
+
+
+
+ # batch_feeder is a function, which will be executed as batch_feeder(trainset[i])
+ # its output will be fed into tf place holders
+ batch_feeder = sparse_array_feeder
+
+ # fit an emb model
+ print('Training set has size: ', trainset.shape)
+ emb_model, logg = fit_emb(trainset, batch_feeder, config)
+ print('Training done!')
+
+ print('Test set has size: ', testset.shape)
+ test_llh = evaluate_emb(testset, batch_feeder, emb_model, config)
+ print('Testing done!')
+
+ # Save result 
+ print('Check result...')
+ emb_vec = emb_model['alpha']
+ print('Embedding matrix has shape ', emb_vec.shape)
+ # Save wherever you want 
+ 
+ print('Done!')
+
+if __name__ == '__main__':
+
+ dataset = 'random'
+ dist = 'poisson'
+ max_iter = 500
+ nprint = 100
+
+ config = dict(
+ # the dimensionality of the embedding vectors 
+ K=50, 
+ # the embedding distribution 'poisson' or 'binomial' (N=3)
+ dist=dist, 
+ # ratio of negative samples. if there are N0 zeros in one row, only sample (0.1 * N0) from these zero, 
+ # it is equivalent to downweight zero-targets with weight 0.1 
+ neg_ratio=0.1, 
+ # number of optimization iterations
+ max_iter=max_iter, 
+ # number of iterations to print objective, training log-likelihood, and validation log-likelihood, and debug values
+ nprint=nprint, 
+ # weight for regularization terms of embedding vectors
+ ar_sigma2=1, 
+ # uncomment the following line to use the base model
+ #model='base', 
+ # uncomment the following line to use context selection. Only the prior 'fixed_bern' works for now 
+ model='context_select', prior='fixed_bern', nsample=30, hidden_size=[30, 15], histogram_size=40, nsample_test=1000, selsize=10,
+ ) 
+
+ print('The configuration is: ')
+ print(config)
+
+ embedding_experiment(config, dataset)
+ 
+
+

experiment/random_data.py

@@ -0,0 +1,46 @@
+import numpy as np
+from scipy import sparse 
+import pickle
+
+'''
+Generate a random copy of data
+
+input:
+output: dict with two fields:
+ trainset: dict with two fields 
+ scores: a sparse matrix, each ij entry is the rating of movie j given by person i, or the count of item j in basket i
+ atts : a matrix, each row is a feature vector extracted from person i, or basket i
+ testset : [same structure as test set]
+
+'''
+
+def rand_data():
+ n_rows = 200
+ n_columns = 50
+ n_feat = 5
+ 
+ 
+ np.random.seed(27)
+ # allocate more rows than necessary, to make sure each row has at least 2 non-zero entries
+ score_mat = np.random.rand(n_rows * 2, n_columns)
+ 
+ score_mat[score_mat < 0.88] = 0
+ score_mat[np.logical_and(0.96 <= score_mat, score_mat < 1)] = 3
+ score_mat[np.logical_and(0.92 <= score_mat, score_mat < 0.96)] = 2
+ score_mat[np.logical_and(0.88 <= score_mat, score_mat < 0.92)] = 1
+ 
+ 
+ row_sum = np.sum(score_mat > 0, axis=1)
+ score_mat = score_mat[row_sum >= 2, ]
+ score_mat = score_mat[0 : n_rows, ]
+ 
+ feature = np.random.rand(n_rows, n_feat)
+ 
+ trainset = dict(scores=sparse.csr_matrix(score_mat[0:(n_rows / 2)]), atts=feature[0:(n_rows / 2)]) 
+ testset = dict(scores=sparse.csr_matrix(score_mat[(n_rows / 2):]), atts=feature[(n_rows / 2):]) 
+
+ return dict(trainset=trainset, testset=testset)
+
+
+
+

model/conbernarray.py

@@ -57,9 +57,9 @@ def logprob(logits, samples):
 
  logprob_cbs = logprob_unc - tf.expand_dims(logprob_non0, 1) # expand to samples
 
- check_point = tf.assert_less(tf.reduce_mean(logprob_cbs), 0.001, data=[tf.reduce_mean(logprob_cbs), tf.reduce_mean(logits), tf.reduce_mean(samples)])
- with tf.control_dependencies([check_point]):
- logprob_cbs = tf.identity(logprob_cbs)
+ #check_point = tf.assert_less(tf.reduce_mean(logprob_cbs), 0.001, data=[tf.reduce_mean(logprob_cbs), tf.reduce_mean(logits), tf.reduce_mean(samples)])
+ #with tf.control_dependencies([check_point]):
+ # logprob_cbs = tf.identity(logprob_cbs)
 
 
  return logprob_cbs 
@@ -135,9 +135,9 @@ def sample(logits, nsample):
  samples = samples * trunc_mask + trunc_flag 
 
 
- check_point = tf.assert_greater(tf.reduce_mean(samples), 0.0, data=[tf.reduce_mean(logits), tf.reduce_mean(samples)])
- with tf.control_dependencies([check_point]):
- samples = tf.identity(samples)
+ #check_point = tf.assert_greater(tf.reduce_mean(samples), 0.0, data=[tf.reduce_mean(logits), tf.reduce_mean(samples)])
+ #with tf.control_dependencies([check_point]):
+ # samples = tf.identity(samples)
 
  return samples
 

model/embedding.py

@@ -64,7 +64,7 @@ def get_model(model_param, session, config):
 
 
 
-def fit_emb(reviews, batch_feeder, config, save_path):
+def fit_emb(reviews, batch_feeder, config):
 
  do_log_save = False
  do_profiling = False
@@ -171,8 +171,6 @@ def fit_emb(reviews, batch_feeder, config, save_path):
 
 
  model = get_model(model_param, session, config)
- save_file = save_path + ('iter%d' % step) + config_to_name(config) + '.pkl'
- pickle.dump(dict(model=model, logg=train_logg), open(save_file, "wb"))
 
  if do_log_save:
  tf.train.Saver().save(session, log_save_path, step)
@@ -232,7 +230,7 @@ def evaluate_emb(reviews, batch_feeder, model, config):
  return dict(pos_llh=pos_llh, neg_llh=neg_llh)
 
 def sparse_array_feeder(batch): 
- _, nz_ind, values = scipy.sparse.find(batch)
+ _, nz_ind, values = sparse.find(batch)
  return nz_ind, values
 
 

model/graph_builder.py

@@ -37,13 +37,6 @@ def sample_negatives(self, context, config):
  cat_dist = tf.contrib.distributions.Categorical(probs=prob)
  sample = cat_dist.sample(nneg)
 
- # sanity check
- context_zero = tf.assert_equal(tf.gather(prob, context), 0.0)
- other_prob = tf.assert_equal(tf.reduce_sum(tf.cast(tf.abs(prob - (1.0 / normalizer)) < 1e-6, tf.int32)), \
- movie_size - ncontext)
- with tf.control_dependencies([context_zero, other_prob]):
- sample = tf.identity(sample)
-
  return sample
 
  def log_dist_prob(self, target, target_label, emb_score, config, zero_labels=False):
@@ -198,7 +191,9 @@ def calculate_bernoulli_logpb(self, target, context, is_same_set, comb, comb_bin
  def calculate_noisy_elbo(self, target, target_label, context, context_label, is_same_set, training, config):
 
  if is_same_set:
- with tf.control_dependencies([tf.assert_greater(tf.shape(context)[0], 2)]):
+ # if is_same_set, the variable "context" here contains both the index of the target item and also indices of context items. 
+ # it need to has at least 2 elements, otherwise the target item has no context items, and such row should be removed.
+ with tf.control_dependencies([tf.assert_greater(tf.shape(context)[0], 1)]):
  context = tf.identity(context)
 
  # generate configurations

model/inference_network.py

@@ -157,28 +157,23 @@ def build_network(self, target_label, context_scores, b_logit, is_same_set, nsam
 
  logits = logits + b_logit
 
- if is_same_set:
- self.debug_var.append(h_fc1)
- self.debug_var.append(h_fc2)
- self.debug_var.append(logits)
-
- # assert logits is not nan or -inf
  if is_same_set: # set the diagnal to be negative so that 1) diagnal element of a sample is always 0 2) it does not have gradient 
  logits = tf.matrix_set_diag(logits, tf.ones([ntarget]) * (-50.0))
 
- check_point = tf.assert_greater(tf.reduce_mean(logits), -10000.0, data=[tf.reduce_mean(logits), 
- tf.reduce_mean(context_scores), 
- tf.reduce_mean(b_logit), 
- tf.reduce_mean(feat),
- tf.reduce_mean(self.W_fc1), 
- tf.reduce_mean(self.W_fc2), 
- tf.reduce_mean(self.W_fc3), 
- tf.reduce_mean(self.b_fc1), 
- tf.reduce_mean(self.b_fc2), 
- tf.reduce_mean(self.b_fc3)
- ])
- with tf.control_dependencies([check_point]):
- logits = tf.identity(logits)
+ # assert logits is not nan or -inf
+ #check_point = tf.assert_greater(tf.reduce_mean(logits), -10000.0, data=[tf.reduce_mean(logits), 
+ # tf.reduce_mean(context_scores), 
+ # tf.reduce_mean(b_logit), 
+ # tf.reduce_mean(feat),
+ # tf.reduce_mean(self.W_fc1), 
+ # tf.reduce_mean(self.W_fc2), 
+ # tf.reduce_mean(self.W_fc3), 
+ # tf.reduce_mean(self.b_fc1), 
+ # tf.reduce_mean(self.b_fc2), 
+ # tf.reduce_mean(self.b_fc3)
+ # ])
+ #with tf.control_dependencies([check_point]):
+ # logits = tf.identity(logits)
 
  samples = cba.sample(logits, nsample) 
  logprob = cba.logprob(logits, samples)