def test_get_item_pyobject(self): self.assertBuildsConst(2., tdb.GetItem(1) >> tdb.Scalar(), [1, 2, 3])
def test_eval_metrics_different_lengths(self):
b = tdb.Record((tdb.Map(tdb.Scalar('int32') >> tdm.Metric('x')),
tdb.Map(tdb.Scalar() >> tdm.Metric('y'))))
desired = ([None, None], [None]), {'x': [1, 2], 'y': [3.]}
self.assertBuilds(desired, b, ([1, 2], [3]))
def test_mean_tuple(self): block = (tdb.Scalar(), tdb.Scalar(), tdb.Scalar()) >> tdb.Mean() self.assertBuildsConst(2., block, [0, 0, 6])
def test_input_transform(self):
block = tdb.Map(tdb.InputTransform(lambda x: 1 + ord(x) - ord('a')) >>
tdb.Scalar('int32') >> tdb.Function(tf.negative))
self.assertBuilds([-1, -2, -3, -4], block, 'abcd')
def test_map_map_const(self):
block = tdb.Map(tdb.Map(tdb.Scalar()))
self.assertBuildsConst([[]], block, [[]])
self.assertBuildsConst([[1., 2., 3.], [4., 5.], [6.], []], block,
[[1, 2, 3], [4, 5], [6], []])
def test_fold_tuple(self):
block = ((tdb.Scalar(), tdb.Scalar()) >>
tdb.Fold(tdb.Function(tf.add), tf.ones([])))
self.assertBuilds(6., block, (2, 3), max_depth=2)
def test_composition_connect_raises(self): self.assertRaises(TypeError, tdb.Pipe, tdb.Scalar(), tdb.Concat())
def test_map_const(self): block = tdb.Map(tdb.Scalar()) self.assertBuildsConst([], block, []) self.assertBuildsConst([1.], block, [1]) self.assertBuildsConst([1., 2., 3.], block, [1, 2, 3])
def scalar_all_of(*fns): return tdb.Scalar() >> tdb.AllOf(*[tdb.Function(f) for f in fns])
def test_composition_toposort_output(self):
block = tdb.Composition()
with block.scope():
s = tdb.Scalar('int32').reads(block.input)
block.output.reads(s, s)
self.assertBuildsConst((3, 3), block, 3)
def test_function_composition_with_block(self):
c = tdb.Composition()
with c.scope():
scalar = tdb.Scalar().reads(c.input)
c.output.reads(times_scalar_block(2.0).reads(scalar))
self.assertBuilds(42., c, 21)
def test_function_composition(self): sc = tdb.Scalar() fn1 = times_scalar_block(2.0) c = sc >> fn1 self.assertBuilds(42., c, 21)
def test_repr(self):
goldens = {
tdb.Tensor([]): '<td.Tensor dtype=\'float32\' shape=()>',
tdb.Tensor([1, 2], 'int32', name='foo'):
'<td.Tensor \'foo\' dtype=\'int32\' shape=(1, 2)>',
tdb.Scalar('int64'): '<td.Scalar dtype=\'int64\'>',
tdb.Vector(42): '<td.Vector dtype=\'float32\' size=42>',
tdb.FromTensor(tf.zeros(3)): '<td.FromTensor \'zeros:0\'>',
tdb.Function(tf.negative,
name='foo'): '<td.Function \'foo\' tf_fn=\'negative\'>',
tdb.Identity(): '<td.Identity>',
tdb.Identity('foo'): '<td.Identity \'foo\'>',
tdb.InputTransform(ord): '<td.InputTransform py_fn=\'ord\'>',
tdb.SerializedMessageToTree('foo'):
'<td.SerializedMessageToTree \'foo\' '
'py_fn=\'serialized_message_to_tree\'>',
tdb.GetItem(3, 'mu'): '<td.GetItem \'mu\' key=3>',
tdb.Length(): '<td.Length dtype=\'float32\'>',
tdb.Slice(stop=2): '<td.Slice key=slice(None, 2, None)>',
tdb.Slice(stop=2, name='x'):
'<td.Slice \'x\' key=slice(None, 2, None)>',
tdb.ForwardDeclaration(name='foo')():
'<td.ForwardDeclaration() \'foo\'>',
tdb.Composition(name='x').input: '<td.Composition.input \'x\'>',
tdb.Composition(name='x').output: '<td.Composition.output \'x\'>',
tdb.Composition(name='x'): '<td.Composition \'x\'>',
tdb.Pipe(): '<td.Pipe>',
tdb.Pipe(tdb.Scalar(), tdb.Identity()): '<td.Pipe>',
tdb.Record({}, name='x'): '<td.Record \'x\' ordered=False>',
tdb.Record((), name='x'): '<td.Record \'x\' ordered=True>',
tdb.AllOf(): '<td.AllOf>',
tdb.AllOf(tdb.Identity()): '<td.AllOf>',
tdb.AllOf(tdb.Identity(), tdb.Identity()): '<td.AllOf>',
tdb.AllOf(name='x'): '<td.AllOf \'x\'>',
tdb.AllOf(tdb.Identity(), name='x'): '<td.AllOf \'x\'>',
tdb.AllOf(tdb.Identity(), tdb.Identity(), name='x'): '<td.AllOf \'x\'>',
tdb.Map(tdb.Scalar(), name='x'):
'<td.Map \'x\' element_block=<td.Scalar dtype=\'float32\'>>',
tdb.Fold(tdb.Function(tf.add), tf.ones([]), name='x'):
'<td.Fold \'x\' combine_block=<td.Function tf_fn=\'add\'> '
'start_block=<td.FromTensor \'ones:0\'>>',
tdb.RNN(tdl.ScopedLayer(tf.contrib.rnn.GRUCell(num_units=8))):
'<td.RNN>',
tdb.RNN(tdl.ScopedLayer(tf.contrib.rnn.GRUCell(num_units=8)), name='x'):
'<td.RNN \'x\'>',
tdb.RNN(tdl.ScopedLayer(tf.contrib.rnn.GRUCell(num_units=8)),
initial_state=tf.ones(8)):
'<td.RNN>',
tdb.RNN(tdl.ScopedLayer(tf.contrib.rnn.GRUCell(num_units=8)),
initial_state=tf.ones(8), name='x'):
'<td.RNN \'x\'>',
tdb.Reduce(tdb.Function(tf.add), name='x'):
'<td.Reduce \'x\' combine_block=<td.Function tf_fn=\'add\'>>',
tdb.Sum(name='foo'):
'<td.Sum \'foo\' combine_block=<td.Function tf_fn=\'add\'>>',
tdb.Min(name='foo'):
'<td.Min \'foo\' combine_block=<td.Function tf_fn=\'minimum\'>>',
tdb.Max(name='foo'):
'<td.Max \'foo\' combine_block=<td.Function tf_fn=\'maximum\'>>',
tdb.Mean(name='foo'): '<td.Mean \'foo\'>',
tdb.OneOf(ord, (tdb.Scalar(), tdb.Scalar()), name='x'):
'<td.OneOf \'x\'>',
tdb.Optional(tdb.Scalar(), name='foo'):
'<td.Optional \'foo\' some_case_block=<td.Scalar dtype=\'float32\'>>',
tdb.Concat(1, True, 'x'):
'<td.Concat \'x\' concat_dim=1 flatten=True>',
tdb.Broadcast(name='x'): '<td.Broadcast \'x\'>',
tdb.Zip(name='x'): '<td.Zip \'x\'>',
tdb.NGrams(n=42, name='x'): '<td.NGrams \'x\' n=42>',
tdb.OneHot(2, 3, name='x'):
'<td.OneHot \'x\' dtype=\'float32\' start=2 stop=3>',
tdb.OneHot(3): '<td.OneHot dtype=\'float32\' start=0 stop=3>',
tdb.OneHotFromList(['a', 'b']): '<td.OneHotFromList>',
tdb.OneHotFromList(['a', 'b'], name='foo'):
'<td.OneHotFromList \'foo\'>',
tdb.Nth(name='x'): '<td.Nth \'x\'>',
tdb.Zeros([], 'x'): '<td.Zeros \'x\'>',
tdb.Void(): '<td.Void>',
tdb.Void('foo'): '<td.Void \'foo\'>',
tdm.Metric('foo'): '<td.Metric \'foo\'>'}
for block, expected_repr in sorted(six.iteritems(goldens),
key=lambda kv: kv[1]):
self.assertEqual(repr(block), expected_repr)
def test_record_slice_key(self):
b = tdb.Record([
(0, tdb.Scalar()),
(slice(1, 3), (tdb.Scalar(), tdb.Scalar()) >> tdb.Concat())])
self.assertBuilds((1., [2., 3.]), b, [1, 2, 3])
def test_composition_no_output_void_type(self): b = tdb.AllOf(tdb.Void(), tdb.Scalar()) >> tdb.GetItem(1) self.assertBuildsConst(42., b, 42)
def test_map(self): block = tdb.Map(tdb.Scalar() >> tdb.Function(tf.abs)) self.assertBuilds([], block, [], max_depth=0) self.assertBuilds([1.], block, [-1]) self.assertBuilds([1., 2., 3.], block, [-1, -2, -3])
def test_composition_rasies_read_output(self):
a = tdb.Scalar()
c = tdb.Composition([a])
self.assertRaisesWithLiteralMatch(
ValueError, 'cannot read from composition output',
c.connect, c.output, a)
def test_map_map(self):
block = tdb.Map(tdb.Map(tdb.Scalar() >> tdb.Function(tf.abs)))
self.assertBuilds([[]], block, [[]], max_depth=0)
self.assertBuilds([[1., 2., 3.], [4., 5.], [6.], []], block,
[[-1, -2, -3], [-4, -5], [-6], []])
def test_composition_rasies_write_input(self):
a = tdb.Scalar()
c = tdb.Composition([a])
self.assertRaisesWithLiteralMatch(
ValueError, 'cannot write to composition input', c.connect, a, c.input)
def test_map_tuple(self): block = (tdb.Scalar(), tdb.Scalar()) >> tdb.Map(tdb.Function(tf.negative)) self.assertBuilds([-3., -4.], block, (3, 4))
def test_record(self):
d = tdb.Record(collections.OrderedDict([('b', tdb.Scalar()),
('a', tdb.Scalar())]))
c = d >> tdb.Function(tf.subtract)
self.assertBuilds(4.0, c, {'a': 1.0, 'b': 5.0})
def test_fold_pyobject(self): block = tdb.Fold((tdb.Identity(), tdb.Scalar()) >> tdb.Sum(), tdb.Zeros([])) self.assertBuilds(5., block, (2, 3), max_depth=None)
def test_record_one_child(self):
self.assertBuildsConst((42,), tdb.Record({0: tdb.Scalar('int32')}), {0: 42})
def test_tuple_of_seq(self):
block = tdb.AllOf(
tdb.Map(tdb.Scalar() >> tdb.Function(tf.negative)),
tdb.Map(tdb.Scalar() >> tdb.Function(tf.identity)))
self.assertBuilds(([], []), block, [], max_depth=0)
self.assertBuilds(([-1., -2.], [1., 2.]), block, [1, 2])
def test_record_tuple(self):
block = (tdb.AllOf(tdb.Scalar(), tdb.OneHot(3, dtype='int32')) >>
(tdb.Function(tf.square), tdb.Function(tf.negative)))
self.assertBuilds((4., [0, 0, -1]), block, 2)
def test_input_transform_const(self):
block = tdb.Map(tdb.InputTransform(lambda x: 1 + ord(x) - ord('a')) >>
tdb.Scalar('int32'))
self.assertBuildsConst([1, 2, 3, 4], block, 'abcd')
def test_record_raises(self):
six.assertRaisesRegex(
self, RuntimeError,
'created with an unordered dict cannot take ordered',
tdb.Pipe, (tdb.Scalar(), tdb.Scalar()),
{'a': tdb.Identity(), 'b': tdb.Identity()})
def test_get_item_sequence(self): block = tdb.Map(tdb.Scalar()) >> tdb.GetItem(-1) self.assertBuildsConst(9., block, range(10))
def test_eval_metrics(self):
b = tdb.Map(tdb.Scalar() >> tdb.AllOf(tdm.Metric('x'), tdb.Identity()))
self.assertBuilds(([(None, 1.), (None, 2.)], {'x': [1., 2.]}), b, [1, 2,])
