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)