def test_output_values(self, output_dim, hidden_dim):
model = LSTMModel(
output_dim=output_dim,
hidden_dim=hidden_dim,
hidden_nonlinearity=None,
recurrent_nonlinearity=None,
hidden_w_init=tf.constant_initializer(1),
recurrent_w_init=tf.constant_initializer(1),
output_w_init=tf.constant_initializer(1))
step_hidden_var = tf.placeholder(
shape=(self.batch_size, hidden_dim),
name='step_hidden',
dtype=tf.float32)
step_cell_var = tf.placeholder(
shape=(self.batch_size, hidden_dim),
name='step_cell',
dtype=tf.float32)
outputs = model.build(self._input_var, self._step_input_var,
step_hidden_var, step_cell_var)
output = self.sess.run(
outputs[0], feed_dict={self._input_var: self.obs_inputs})
expected_output = np.full(
[self.batch_size, self.time_step, output_dim], hidden_dim * 8)
assert np.array_equal(output, expected_output)
def __init__(self,
env_spec,
name='CategoricalLSTMPolicyWithModel',
hidden_dim=32,
hidden_nonlinearity=tf.nn.tanh,
hidden_w_init=tf.glorot_uniform_initializer(),
hidden_b_init=tf.zeros_initializer(),
recurrent_nonlinearity=tf.nn.sigmoid,
recurrent_w_init=tf.glorot_uniform_initializer(),
output_nonlinearity=tf.nn.softmax,
output_w_init=tf.glorot_uniform_initializer(),
output_b_init=tf.zeros_initializer(),
hidden_state_init=tf.zeros_initializer(),
hidden_state_init_trainable=False,
cell_state_init=tf.zeros_initializer(),
cell_state_init_trainable=False,
state_include_action=True,
forget_bias=True,
layer_normalization=False):
if not isinstance(env_spec.action_space, Discrete):
raise ValueError('CategoricalLSTMPolicy only works'
'with akro.tf.Discrete action space.')
super().__init__(name, env_spec)
self._obs_dim = env_spec.observation_space.flat_dim
self._action_dim = env_spec.action_space.n
self._hidden_dim = hidden_dim
self._state_include_action = state_include_action
self._output_nonlinearity = output_nonlinearity
self._output_w_init = output_w_init
self._output_b_init = output_b_init
self._hidden_state_init = hidden_state_init
self._cell_state_init = cell_state_init
if state_include_action:
self._input_dim = self._obs_dim + self._action_dim
else:
self._input_dim = self._obs_dim
self.model = LSTMModel(
output_dim=self._action_dim,
hidden_dim=self._hidden_dim,
name='prob_network',
forget_bias=forget_bias,
hidden_nonlinearity=hidden_nonlinearity,
hidden_w_init=hidden_w_init,
hidden_b_init=hidden_b_init,
recurrent_nonlinearity=recurrent_nonlinearity,
recurrent_w_init=recurrent_w_init,
hidden_state_init=hidden_state_init,
hidden_state_init_trainable=hidden_state_init_trainable,
cell_state_init=cell_state_init,
cell_state_init_trainable=cell_state_init_trainable,
output_nonlinearity=output_nonlinearity,
output_w_init=output_w_init,
output_b_init=output_b_init,
layer_normalization=layer_normalization)
self._initialize()
def test_is_pickleable(self):
model = LSTMModel(output_dim=1, hidden_dim=1)
step_hidden_var = tf.placeholder(
shape=(self.batch_size, 1), name='step_hidden', dtype=tf.float32)
step_cell_var = tf.placeholder(
shape=(self.batch_size, 1), name='step_cell', dtype=tf.float32)
model.build(self._input_var, self._step_input_var, step_hidden_var,
step_cell_var)
# assign bias to all one
with tf.variable_scope('LSTMModel/lstm', reuse=True):
init_hidden = tf.get_variable('initial_hidden')
init_hidden.load(tf.ones_like(init_hidden).eval())
hidden = np.zeros((self.batch_size, 1))
cell = np.zeros((self.batch_size, 1))
outputs1 = self.sess.run(
model.networks['default'].all_output,
feed_dict={self._input_var: self.obs_inputs})
output1 = self.sess.run(
[
model.networks['default'].step_output,
model.networks['default'].step_hidden,
model.networks['default'].step_cell
],
feed_dict={
self._step_input_var: self.obs_input,
step_hidden_var: hidden,
step_cell_var: cell
})
h = pickle.dumps(model)
with tf.Session(graph=tf.Graph()) as sess:
model_pickled = pickle.loads(h)
input_var = tf.placeholder(
tf.float32,
shape=(None, None, self.feature_shape),
name='input')
step_input_var = tf.placeholder(
tf.float32, shape=(None, self.feature_shape), name='input')
step_hidden_var = tf.placeholder(
shape=(self.batch_size, 1),
name='initial_hidden',
dtype=tf.float32)
step_cell_var = tf.placeholder(
shape=(self.batch_size, 1),
name='initial_cell',
dtype=tf.float32)
model_pickled.build(input_var, step_input_var, step_hidden_var,
step_cell_var)
outputs2 = sess.run(
model_pickled.networks['default'].all_output,
feed_dict={input_var: self.obs_inputs})
output2 = sess.run(
[
model_pickled.networks['default'].step_output,
model_pickled.networks['default'].step_hidden,
model_pickled.networks['default'].step_cell
],
feed_dict={
step_input_var: self.obs_input,
step_hidden_var: hidden,
step_cell_var: cell
})
assert np.array_equal(outputs1, outputs2)
assert np.array_equal(output1, output2)