def test_vectorized_2d_perf(self):
"""
Check that vectorized_2d
- returns a tensor of the correct shape
- that the values correspond to the values from vectorized
"""
tx = tf.Variable(np.random.randint(0, 10, (10, 3)))
y = self.builder.vectorized_2d(tx)
tx0 = tx[:, 0]
tx1 = tx[:, 1]
tx2 = tx[:, 2]
y0 = self.builder.vectorized(tx0)
y1 = self.builder.vectorized(tx1)
y2 = self.builder.vectorized(tx2)
with Timer('vectorized_2d'):
for _ in range(10):
evaluate_tensor(y)
with Timer('vectorized'):
for _ in range(10):
evaluate_tensor([y0, y1, y2])
ay, ay0, ay1, ay2 = evaluate_tensor([y, y0, y1, y2])
self.assertAllClose(ay0, ay[:, 0])
self.assertAllClose(ay1, ay[:, 1])
self.assertAllClose(ay2, ay[:, 2])
def test_vectorized_rank1(self):
tx = tf.Variable([0, 1, 2, 3])
y = self.builder.vectorized(tx)
result = evaluate_tensor(y)
shape = tuple(evaluate_tensor(tf.shape(result)))
self.assertEqual((4, 3), shape)
def test_state_rewards(self):
next_states = tf.stack([t_next_state, t_terminal_state])
print('Next states are %s' % str(evaluate_tensor(next_states)))
rf = RewardFunction()
state_rewards = rf.state_rewards(t_state, next_states)
actual = evaluate_tensor(state_rewards)
desired = np.array([2.0, 4.0])
np.testing.assert_array_equal(actual, desired)
def test_build(self):
y = self.builder.calculate(self.tx)
result = evaluate_tensor(y)
print(result)
self.assertIsInstance(result, np.ndarray)
def test_vectorized_2d(self):
"""
Check that vectorized_2d
- returns a tensor of the correct shape
- that the values correspond to the values from vectorized
"""
tx = tf.Variable([
[0, 1],
[1, 2],
[2, 3],
[3, 4],
])
y = self.builder.vectorized_2d(tx)
tx0 = tx[:, 0]
tx1 = tx[:, 1]
y0 = self.builder.vectorized(tx0)
y1 = self.builder.vectorized(tx1)
a_y, a_y0, a_y1 = evaluate_tensor([y, y0, y1])
print(a_y)
self.assertEqual((4, 2, 3), a_y.shape)
self.assertAllClose(a_y[:, 0], a_y0)
self.assertAllClose(a_y[:, 1], a_y1)
def test_get_state_targets(self):
targets = self.calc.get_state_targets(self.t_state)
actual = evaluate_tensor(targets)
# live target and terminal_reward
desired = np.array([3.0, 4.0])
np.testing.assert_array_equal(actual, desired)
def test_are_states_terminal_vectorized_performance(self):
model = LineWorldModel()
a_positions = np.random.randint(0, 10, 10000)
t_positions = tf.Variable(a_positions)
v_are_terminal = model.are_states_terminal_vectorized(t_positions)
m_are_terminal = model.are_states_terminal(t_positions)
with Timer('vectorized'):
v_result = evaluate_tensor(v_are_terminal)
with Timer('map'):
m_result = evaluate_tensor(m_are_terminal)
self.assertAllClose(v_result, m_result)
def test_calculate(self):
tx = tf.Variable([1], dtype=tf.int32, trainable=False)
y = self.builder.calculate(tx)
result = evaluate_tensor(y)
print(result)
self.assertIsInstance(result, np.ndarray)
def test_are_states_terminal_vectorized(self):
model = LineWorldModel()
positions = tf.Variable([TARGET-1, TARGET, TARGET+1])
are_terminal = model.are_states_terminal_vectorized(positions)
result = evaluate_tensor(are_terminal)
expected = np.array([False, True, False])
np.testing.assert_array_equal(expected, result)
def test_get_states_targets_double(self):
states = tf.stack([t_state, t_state], axis=0)
targets = self.calc.get_states_targets(states)
actual = evaluate_tensor(targets)
desired = np.array([[3.0, 4.0], [3.0, 4.0]])
np.testing.assert_array_equal(actual, desired)
def test_apply_actions(self):
model = LineWorldModel()
t_state = tf.Variable(1)
t_next_states = model.apply_actions(t_state)
result = evaluate_tensor(t_next_states)
expected = np.array([0, 2])
np.testing.assert_array_equal(expected, result)
def test_apply_actions_vectorized_vs_map_fn(self):
"""
Compare the vectorized version vs using map_fn
Returns:
"""
N = 100
model = LineWorldModel()
t_states = tf.Variable([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
t_next_states = model.apply_actions_vectorized(t_states)
with Timer('Vectorized'):
for _ in range(N):
a_result = evaluate_tensor(t_next_states)
# slow way
result2 = tf.map_fn(model.apply_actions, t_states)
with Timer('map'):
for _ in range(N):
a_result2 = evaluate_tensor(result2)
self.assertAllEqual(a_result, a_result2)
def test_apply_actions_vectorized(self):
model = LineWorldModel()
t_states = tf.Variable([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
t_next_states = model.apply_actions_vectorized(t_states)
result = evaluate_tensor(t_next_states)
expected = np.array([
[0, 1],
[0, 2],
[1, 3],
[2, 4],
[3, 5],
[4, 6],
[5, 7],
[6, 8],
[7, 9],
[8, 9]
])
self.assertAllEqual(expected, result)
def test_vectorized_values(self):
"""
Show that vectorized returns the same values as those we would get
if we looped through a list
"""
positions = [0, 1, 2, 3]
tx = tf.Variable(positions)
tx = tf.reshape(tx, (-1, 1))
y = self.builder.vectorized(tx)
# There are 4 input states, and 3 actions, so we expect
# an output of shape (4, 3)
for position in positions:
t_position = tf.Variable(position)
t_expected = self.builder.calculate(t_position)
[ay, ey] = evaluate_tensor([y, t_expected])
np.testing.assert_array_equal(ey.ravel(), ay[position])
def test_get_state_action_target_terminal(self):
target = self.calc.get_state_action_target(self.t_state,
self.t_action_to_terminal)
actual = evaluate_tensor(target)
self.assertEqual(4.0, actual)
def test_get_state_action_target_live(self):
target = self.calc.get_state_action_target(self.t_state,
self.t_action_to_live)
actual = evaluate_tensor(target)
self.assertEqual(3.0, actual)
