Thanks for the great work @cwhsu-google. Our team is trying to use RecSim for slate recommendation.
After training the agent (slate_decomp_q_agent) for 300k steps. I tried loading different checkpoints and to generate slates for the same user (to understand convergence of q values) but the slates returned after every iteration are the same.
Here is my script that I used for prediction:
inference.py
from recsim.environments import interest_evolution
from recsim.agents import slate_decomp_q_agent
def create_decomp_q_agent(sess, environment, eval_mode, summary_writer=None):
"""
This is one variant of the agent featured in SlateQ paper """ kwargs = {
'observation_space': environment.observation_space,
'action_space': environment.action_space,
'summary_writer': summary_writer,
'eval_mode': eval_mode,
}
return slate_decomp_q_agent.create_agent(agent_name='slate_topk_sarsa', sess=sess, **kwargs)
seed = 0
slate_size = 3
np.random.seed(seed)
env_config = {
'num_candidates': 30,
'slate_size': slate_size,
'resample_documents': True,
'seed': seed,
}
tmp_decomp_q_dir = '../results12/'
user_vec = [-0.00598616, 0.1760635, -0.0913329, 0.59239239, -0.90903912,
-0.17019989, 0.00312255, -0.32639151, -0.5325127, -0.47683574,
-0.86847277, 0.32046379, -0.56788602, -0.69480169, 0.071154,
0.33922171, 0.04820297, 0.97037383, 0.04213649, -0.16748408]
user_obs = np.array(user_vec)
print('Shape of user observation:', user_obs.shape)
runner = prediction.PredRunner(
base_dir=tmp_decomp_q_dir,
create_agent_fn=create_decomp_q_agent,
env=interest_evolution.create_environment(env_config))
print('Going to predict...')
start_time = time.time()
print(runner.predict(user_obs_features=user_obs))
print('Prediction Time taken', time.time()-start_time, 'seconds')
prediction.py
import os
import time
from dopamine.discrete_domains import checkpointer
from recsim.simulator.runner_lib import Runner
import tensorflow.compat.v1 as tf
class PredRunner(Runner):
def __init__(self,
train_base_dir=None,
**kwargs):
st = time.time()
super(PredRunner, self).__init__(**kwargs)
self._output_dir = os.path.join(self._base_dir, 'pred')
tf.io.gfile.makedirs(self._output_dir)
if train_base_dir is None:
train_base_dir = self._base_dir
self._checkpoint_dir = os.path.join(train_base_dir, 'train', 'checkpoints')
self._set_up(eval_mode=True)
# Use the checkpointer class.
self._checkpointer = checkpointer.Checkpointer(
self._checkpoint_dir, self._checkpoint_file_prefix)
checkpoint_version = -1
latest_checkpoint_version = checkpointer.get_latest_checkpoint_number(
self._checkpoint_dir)
latest_checkpoint_version = 100
print('Checkpoint that would be read:', latest_checkpoint_version)
# checkpoints_iterator already makes sure a new checkpoint exists.
if latest_checkpoint_version <= checkpoint_version:
time.sleep(self._min_interval_secs)
experiment_data = self._checkpointer.load_checkpoint(
latest_checkpoint_version)
assert self._agent.unbundle(self._checkpoint_dir,
latest_checkpoint_version, experiment_data)
# Saving weights to file for debugging
tvars = tf.trainable_variables()
tvars_vals = self._sess.run(tvars)
var_list = []
tensor_list = []
for var, val in zip(tvars, tvars_vals):
var_list.append(var.name)
tensor_list.append(val)
import pandas as pd
df = pd.DataFrame({'var': var_list, 'tensor': tensor_list})
df.to_pickle('youtube-test-weights{}.pickle'.format(latest_checkpoint_version))
print('Model loading time taken: {}'.format(time.time() - st))
def predict(self, user_obs_features):
st = time.time()
self._env.reset_sampler()
self._initialize_metrics()
observation = self._env.reset()
observation['user'] = user_obs_features
start = time.time()
action = self._agent.begin_episode(observation)
print('Step time taken: {}'.format(time.time() - start))
slate = [0] * len(action)
doc_keys = list(observation['doc'].keys())
for i in range(len(action)):
slate[i] = doc_keys[action[i]]
print('Time taken: {} ms'.format(1000*(time.time()-st)))
return slate
These graphs were generated on tensorboard:









Most importantly I am looking answers for the following
- Why q values over different epochs are turning out to be same?
- Which in turn is returning same slates for all the checkpoints
- This raises question, whether model is training or not
- Also we see watch time for each video is 4 min, since q values reflect cumulative reward over state, action pair, how come their scale is 10exp-2
Any help would be appreciated
Thanks for the great work @cwhsu-google. Our team is trying to use RecSim for slate recommendation.
After training the agent (slate_decomp_q_agent) for 300k steps. I tried loading different checkpoints and to generate slates for the same user (to understand convergence of q values) but the slates returned after every iteration are the same.
Here is my script that I used for prediction:
inference.py
prediction.py
These graphs were generated on tensorboard:
Most importantly I am looking answers for the following
Any help would be appreciated