def testGetValidCanvasUnderUniformRollinPolicy(self): with self.session(use_gpu=True) as sess: params = insertion.SymbolInsertionLayer.Params() params.name = 'insertion' params.rollin_policy = 'oracle' params.oracle_policy = 'uniform' insertion_layer = insertion.SymbolInsertionLayer(params) batch_size = 4 time_dim = 10 inputs = tf.tile(tf.expand_dims(tf.range(time_dim), 0), [batch_size, 1]) spec = insertion_layer.FProp(None, inputs, force_sample_last_token=False) canvas, canvas_indices, canvas_paddings = sess.run( [spec.canvas, spec.canvas_indices, spec.canvas_paddings]) for b in range(batch_size): length = np.sum(1 - canvas_paddings[b, :]).astype(np.int32) self.assertAllEqual(canvas[b, :length], canvas_indices[b, :length]) # Test the invalid slots. self.assertAllEqual(canvas[b, length:], [0] * (canvas.shape[1] - length)) self.assertAllEqual(canvas_indices[b, length:], [time_dim - 1] * (canvas.shape[1] - length))
def testContiguousCanvasUnderUniformRollinPolicy(self): """Tests for valid canvas size.""" with self.session(use_gpu=True): params = insertion.SymbolInsertionLayer.Params() params.name = 'insertion' params.rollin_policy = 'oracle' params.oracle_policy = 'uniform' insertion_layer = insertion.SymbolInsertionLayer(params) batch_size = 4 time_dim = 10 inputs = tf.tile( tf.expand_dims(tf.range(time_dim), 0) + 100, [batch_size, 1]) inputs_len = tf.random.uniform([batch_size], 0, time_dim, tf.int32) paddings = 1 - tf.sequence_mask(inputs_len, time_dim, tf.int32) spec = insertion_layer.FProp( None, inputs, paddings, force_sample_last_token=False) for _ in range(1000): canvas, canvas_paddings = self.evaluate( [spec.canvas, spec.canvas_paddings]) for b in range(batch_size): length = np.sum(1 - canvas_paddings[b, :]).astype(np.int32) # Check for valid part of the canvas and padding. for l in range(length): self.assertEqual(canvas_paddings[b, l], 0) self.assertNotEqual(canvas[b, l], 0) # Check for invalid part of the canvas and padding. for l in range(length, canvas.shape[1]): self.assertEqual(canvas_paddings[b, l], 1) self.assertEqual(canvas[b, l], 0)
def testMaxCanvasSizeUnderUniformRollinPolicy(self): """Tests for valid canvas size.""" with self.session(use_gpu=True) as sess: params = insertion.SymbolInsertionLayer.Params() params.name = 'insertion' params.rollin_policy = 'oracle' params.oracle_policy = 'uniform' insertion_layer = insertion.SymbolInsertionLayer(params) batch_size = 4 time_dim = 10 inputs = tf.tile(tf.expand_dims(tf.range(time_dim), 0), [batch_size, 1]) inputs_len = tf.random.uniform([batch_size], 0, time_dim, tf.int32) paddings = 1 - tf.sequence_mask(inputs_len, time_dim, tf.int32) spec = insertion_layer.FProp(None, inputs, paddings) canvas_with_max_length = False for _ in range(1000): canvas_max_len, canvas, canvas_paddings = sess.run( [inputs_len, spec.canvas, spec.canvas_paddings]) for b in range(batch_size): max_len = canvas_max_len[b] length = np.sum(1 - canvas_paddings[b, :]).astype(np.int32) canvas_with_max_length |= length == max_len self.assertLessEqual(length, max_len) # Invalid entries of canvas should be 0. self.assertAllEqual(canvas[b, length:], [0] * (canvas.shape[1] - length)) # With high probability, there should be at least one canvas that is # of the same size as the maximum canvas size. self.assertEqual(canvas_with_max_length, True)
def testGetValidCanvasAndTargetsUnderUniformOraclePolicyForcedSample(self): """Tests for canvas+targets under uniform (rollin+oracle) policy.""" with self.session(use_gpu=True) as sess: params = insertion.SymbolInsertionLayer.Params() params.name = 'insertion' params.rollin_policy = 'oracle' params.oracle_policy = 'uniform' params.random_seed = 12345 insertion_layer = insertion.SymbolInsertionLayer(params) x = np.asarray( [[10, 11, 12, 13, 14, 15, 16, 1], [10, 11, 12, 13, 14, 15, 16, 1], [10, 1, 0, 0, 0, 0, 0, 0], [10, 11, 12, 13, 14, 15, 1, 0]], np.int32) x_paddings = np.asarray( [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 1]], np.float32) spec = insertion_layer.FProp(None, tf.convert_to_tensor(x), tf.convert_to_tensor(x_paddings)) (canvas, canvas_indices, canvas_paddings, target_indices, target_weights) = sess.run([ spec.canvas, spec.canvas_indices, spec.canvas_paddings, spec.target_indices, spec.target_weights ]) canvas_gold = np.asarray( [[10, 12, 13, 15, 16, 1], [13, 1, 0, 0, 0, 0], [10, 1, 0, 0, 0, 0], [10, 12, 14, 1, 0, 0]], np.int32) canvas_indices_gold = np.asarray( [[0, 2, 3, 5, 6, 7], [3, 7, 7, 7, 7, 7], [0, 1, 7, 7, 7, 7], [0, 2, 4, 6, 7, 7]], np.int32) canvas_paddings_gold = np.asarray( [[0., 0., 0., 0., 0., 0.], [0., 0., 1., 1., 1., 1.], [0., 0., 1., 1., 1., 1.], [0., 0., 0., 0., 1., 1.]], np.float32) target_indices_gold = np.asarray( [[0, 0, 1], [0, 1, 11], [0, 1, 1], [0, 2, 1], [0, 3, 14], [0, 3, 1], [0, 4, 1], [0, 5, 1], [1, 0, 10], [1, 0, 11], [1, 0, 12], [1, 0, 1], [1, 1, 14], [1, 1, 15], [1, 1, 16], [1, 1, 1], [2, 0, 1], [2, 1, 1], [3, 0, 1], [3, 1, 11], [3, 1, 1], [3, 2, 13], [3, 2, 1], [3, 3, 15], [3, 3, 1]], np.int32) target_weights_gold = np.asarray( [1, 1, 0, 1, 1, 0, 1, 1] + [1, 1, 1, 0, 1, 1, 1, 0] + [1, 1] + [1, 1, 0, 1, 0, 1, 0], np.float32) target_weights_gold = np.reshape(target_weights_gold, [target_weights_gold.shape[0], 1]) self.assertAllEqual(canvas, canvas_gold) self.assertAllEqual(canvas_indices, canvas_indices_gold) self.assertAllEqual(canvas_paddings, canvas_paddings_gold) self.assertAllEqual(target_indices, target_indices_gold) self.assertAllEqual(target_weights, target_weights_gold)
def testGetValidCanvasAndTargetsUnderUniformOraclePolicy(self): """Tests for valid canvas+targets under uniform (rollin+oracle) policy.""" with self.session(use_gpu=True) as sess: params = insertion.SymbolInsertionLayer.Params() params.name = 'insertion' params.rollin_policy = 'oracle' params.oracle_policy = 'uniform' insertion_layer = insertion.SymbolInsertionLayer(params) batch_size = 8 time_dim = 10 inputs = np.tile(np.arange(time_dim, dtype=np.int32), [batch_size, 1]) inputs_len = np.random.randint(0, time_dim, [batch_size], np.int32) inputs_len[0] = 0 inputs_len[1] = 1 inputs_len[2] = time_dim - 1 inputs_len[3] = time_dim - 2 inputs_paddings = 1 - tf.sequence_mask(inputs_len, time_dim, tf.int32) spec = insertion_layer.FProp(None, inputs, inputs_paddings) (canvas_indices, canvas_paddings, target_indices, target_weights) = sess.run([ spec.canvas_indices, spec.canvas_paddings, spec.target_indices, spec.target_weights ]) target_index = 0 for b in range(batch_size): canvas_length = np.sum(1 - canvas_paddings[b, :]) canvas_index = 0 # Loop through the original `inputs` length. for l in range(inputs_len[b]): if (canvas_index < canvas_length and canvas_indices[b, canvas_index] == l): canvas_index += 1 elif target_indices[target_index, 2] == l: self.assertEqual(target_indices[target_index, 0], b, 'Mismatch in batch index.') self.assertEqual(target_indices[target_index, 1], canvas_index, 'Mismatch in slot index.') self.assertEqual(target_indices[target_index, 2], inputs[b, l], 'Mismatch in content index.') target_index += 1 else: raise ValueError( 'Mismatch between canvas_indices and target_indices!\n%s\n%s' % (str(canvas_indices), str(target_indices))) # Make sure we consume all the targets. self.assertEqual(target_index, target_indices.shape[0]) self.assertAllEqual(target_weights, np.ones([target_indices.shape[0]], np.int32))