def test_features_shape_dynamic_multi_none( self, encoding: features_lib.Encoding): x = np.random.randint(256, size=(2, 3, 1), dtype=np.uint8) x_other_shape = np.random.randint(256, size=(4, 4, 1), dtype=np.uint8) wrong_shape = np.random.randint(256, size=(2, 3, 2), dtype=np.uint8) self.assertFeature( feature=features_lib.Tensor( shape=(None, None, 1), dtype=tf.uint8, encoding=encoding, ), shape=(None, None, 1), dtype=tf.uint8, tests=[ testing.FeatureExpectationItem( value=x, expected=x, ), testing.FeatureExpectationItem( value=x_other_shape, expected=x_other_shape, ), testing.FeatureExpectationItem( value=wrong_shape, # Wrong shape raise_cls=ValueError, raise_msg='are incompatible', ), ], )
def test_custom_feature_connector(tmp_path: pathlib.Path): module_name = 'tensorflow_datasets.core.features.test_feature' feature_qualname = f'{module_name}.CustomFeatureConnector' assert module_name not in sys.modules assert feature_qualname not in features_lib.FeatureConnector._registered_features # Save tfds.feature.Tensor to avoid importing the custom feature connector feature = features_lib.Tensor(shape=(), dtype=tf.int32) feature.save_config(tmp_path) # Update the features.json file to simulate as if the original # FeatureConnector had been save feature_path = tmp_path / 'features.json' content = feature_path.read_text() content = content.replace( 'tensorflow_datasets.core.features.tensor_feature.Tensor', feature_qualname, ) feature_path.write_text(content) # Loading will load the custom feature connector, even if it is not # registered yet. feature = features_lib.FeatureConnector.from_config(tmp_path) # After loading, the custom feature connector is registered assert module_name in sys.modules assert feature_qualname in features_lib.FeatureConnector._registered_features # Check that the loaded feature is the custom feature from tensorflow_datasets.core.features import test_feature # pylint: disable=g-import-not-at-top assert isinstance(feature, test_feature.CustomFeatureConnector)
def test_bool_flat(self, encoding: features_lib.Encoding): self.assertFeature(feature=features_lib.Tensor( shape=(), dtype=tf.bool, encoding=encoding, ), dtype=tf.bool, shape=(), tests=[ testing.FeatureExpectationItem( value=np.array(True), expected=True, ), testing.FeatureExpectationItem( value=np.array(False), expected=False, ), testing.FeatureExpectationItem( value=True, expected=True, ), testing.FeatureExpectationItem( value=False, expected=False, ), ])
def test_features_multi_none_sequence( self, encoding: features_lib.Encoding, shape, ): x = np.random.randint(256, size=(3, 2, 3, 1), dtype=np.uint8) x_other_shape = np.random.randint(256, size=(3, 2, 2, 1), dtype=np.uint8) self.assertFeature( feature=features_lib.Sequence( features_lib.Tensor( shape=shape, dtype=tf.uint8, encoding=encoding, ), ), shape=(None, ) + shape, dtype=tf.uint8, tests=[ testing.FeatureExpectationItem( value=x, expected=x, ), testing.FeatureExpectationItem( value=x_other_shape, expected=x_other_shape, ), # TODO(epot): Is there a way to catch if the user try to encode # tensors with different shapes ? ], )
def test_shape_dynamic(self): np_input_dynamic_1 = np.random.randint(256, size=(2, 3, 2), dtype=np.int32) np_input_dynamic_2 = np.random.randint(256, size=(5, 3, 2), dtype=np.int32) self.assertFeature( feature=features_lib.Tensor(shape=(None, 3, 2), dtype=tf.int32), dtype=tf.int32, shape=(None, 3, 2), tests=[ test_utils.FeatureExpectationItem( value=np_input_dynamic_1, expected=np_input_dynamic_1, ), test_utils.FeatureExpectationItem( value=np_input_dynamic_2, expected=np_input_dynamic_2, ), # Invalid shape test_utils.FeatureExpectationItem( value=np.random.randint(256, size=(2, 3, 1), dtype=np.int32), raise_cls=ValueError, raise_msg='are incompatible', ), ])
def test_shape_dynamic_none_second(self, encoding: features_lib.Encoding): np_input_dynamic_1 = np.random.randint(256, size=(3, 2, 2), dtype=np.int32) np_input_dynamic_2 = np.random.randint(256, size=(3, 5, 2), dtype=np.int32) self.assertFeature( feature=features_lib.Tensor( shape=(3, None, 2), # None not at the first position. dtype=tf.int32, encoding=encoding, ), dtype=tf.int32, shape=(3, None, 2), tests=[ testing.FeatureExpectationItem( value=np_input_dynamic_1, expected=np_input_dynamic_1, ), testing.FeatureExpectationItem( value=np_input_dynamic_2, expected=np_input_dynamic_2, ), # Invalid shape testing.FeatureExpectationItem( value=np.random.randint(256, size=(2, 3, 1), dtype=np.int32), raise_cls=ValueError, raise_msg='are incompatible', ), ])
def _info(self): return dataset_info.DatasetInfo( builder=self, features=features.FeaturesDict({ "frames": features.Sequence({ "coordinates": features.Sequence( features.Tensor(shape=(2,), dtype=tf.int32) ), }), }), )
def __init__(self, base_feature, shape): if not isinstance(shape, tuple): raise ValueError("shape must be a tuple, got %s" % str(shape)) num_unknown = shape.count(None) self._base_info = base_feature.get_tensor_info() if num_unknown < 2: raise ValueError( "shape must contain at least 2 None values, got %s. Use " "StaticShapedTensor." % shape) base_shape = self._base_info.shape _assert_reshapable(base_shape, shape) self._shape_tuple = shape self._base = base_feature self._shape = features.Tensor(shape=(len(shape), ), dtype=tf.int64) self._tensor_shape = tf.TensorShape(shape)
def test_repr_tensor(self): # Top level Tensor is printed expanded self.assertEqual( repr(features_lib.Tensor(shape=(), dtype=tf.int32)), 'Tensor(shape=(), dtype=tf.int32)', ) # Sequences colapse tensor repr self.assertEqual( repr(features_lib.Sequence(tf.int32)), 'Sequence(tf.int32)', ) class ChildTensor(features_lib.Tensor): pass self.assertEqual( repr( features_lib.FeaturesDict({ 'colapsed': features_lib.Tensor(shape=(), dtype=tf.int32), # Tensor with defined shape are printed expanded 'noncolapsed': features_lib.Tensor(shape=(1, ), dtype=tf.int32), # Tensor inherited are expanded 'child': ChildTensor(shape=(), dtype=tf.int32), })), textwrap.dedent("""\ FeaturesDict({ 'child': ChildTensor(shape=(), dtype=tf.int32), 'colapsed': tf.int32, 'noncolapsed': Tensor(shape=(1,), dtype=tf.int32), })"""), )
def test_bool_array(self): self.assertFeature(feature=features_lib.Tensor(shape=(3, ), dtype=tf.bool), dtype=tf.bool, shape=(3, ), tests=[ testing.FeatureExpectationItem( value=np.array([True, True, False]), expected=[True, True, False], ), testing.FeatureExpectationItem( value=[True, False, True], expected=[True, False, True], ), ])
def test_shape_static(self, encoding: features_lib.Encoding): np_input = np.random.rand(2, 3).astype(np.float32) array_input = [ [1, 2, 3], [4, 5, 6], ] self.assertFeature( feature=features_lib.Tensor( shape=(2, 3), dtype=tf.float32, encoding=encoding, ), dtype=tf.float32, shape=(2, 3), tests=[ # Np array testing.FeatureExpectationItem( value=np_input, expected=np_input, ), # Python array testing.FeatureExpectationItem( value=array_input, expected=array_input, ), # Invalid dtype testing.FeatureExpectationItem( # On Windows, np default dtype is `int32` value=np.random.randint(256, size=(2, 3), dtype=np.int64), raise_cls=ValueError, raise_msg='int64 do not match', ), # Invalid shape testing.FeatureExpectationItem( value=np.random.rand(2, 4).astype(np.float32), raise_cls=ValueError, raise_msg='are incompatible', ), ], test_attributes={ '_encoding': encoding, }, )
def test_shapes_dynamic(self): specs = features.SpecDict({ 'input': features.Tensor(shape=(None, None, 1), dtype=tf.int32), }) # Numpy array np_input = np.random.randint(256, size=(2, 3, 1), dtype=np.int32) tf_output = _encode_decode(specs, { 'input': np_input, }) self.assertAllEqual(tf_output['input'], np_input) # Invalid shape with self.assertRaises(ValueError) as err: _encode_decode(specs, { 'input': np.random.randint(256, size=(2, 3, 2), dtype=np.int32), }) self.assertIn('Shape (2, 3, 2) do not match', str(err.exception))
def test_shapes_dynamic(self): specs = features.SpecDict({ 'input': features.Tensor(shape=(None, None, 1), dtype=tf.int32), }) # Numpy array np_input = np.random.randint(256, size=(2, 3, 1), dtype=np.int32) tf_output = _encode_decode(specs, { 'input': np_input, }) self.assertAllEqual(tf_output['input'], np_input) # Invalid shape with self.assertRaisesWithPredicateMatch(ValueError, 'are incompatible'): _encode_decode(specs, { 'input': np.random.randint(256, size=(2, 3, 2), dtype=np.int32), })
def test_shape_static(self): np_input = np.random.rand(2, 3).astype(np.float32) array_input = [ [1, 2, 3], [4, 5, 6], ] self.assertFeature( feature=features_lib.Tensor(shape=(2, 3), dtype=tf.float32), dtype=tf.float32, shape=(2, 3), tests=[ # Np array testing.FeatureExpectationItem( value=np_input, expected=np_input, ), # Python array testing.FeatureExpectationItem( value=array_input, expected=array_input, ), # Invalid dtype testing.FeatureExpectationItem( value=np.random.randint(256, size=(2, 3)), raise_cls=ValueError, raise_msg='int64 do not match', ), # Invalid shape testing.FeatureExpectationItem( value=np.random.rand(2, 4).astype(np.float32), raise_cls=ValueError, raise_msg='are incompatible', ), ], )
def test_shapes_static(self): specs = features.SpecDict({ 'input': features.Tensor(shape=(2, 3), dtype=tf.float32), }) # Numpy array np_input = np.random.rand(2, 3).astype(np.float32) tf_output = _encode_decode(specs, { 'input': np_input, }) self.assertAllEqual(tf_output['input'], np_input) # Python array array_input = [ [1, 2, 3], [4, 5, 6], ] tf_output = _encode_decode(specs, { 'input': array_input, }) self.assertAllEqual(tf_output['input'], array_input) # Invalid type with self.assertRaises(ValueError) as err: _encode_decode(specs, { 'input': np.random.randint(256, size=(2, 3)), }) self.assertIn('Dtype int64 do not match', str(err.exception)) # Invalid shape with self.assertRaises(ValueError) as err: _encode_decode(specs, { 'input': np.random.rand(2, 4).astype(np.float32), }) self.assertIn('Shape (2, 4) do not match', str(err.exception))
def test_bool_flat(self): self.assertFeature(feature=features_lib.Tensor(shape=(), dtype=tf.bool), dtype=tf.bool, shape=(), tests=[ test_utils.FeatureExpectationItem( value=np.array(True), expected=True, ), test_utils.FeatureExpectationItem( value=np.array(False), expected=False, ), test_utils.FeatureExpectationItem( value=True, expected=True, ), test_utils.FeatureExpectationItem( value=False, expected=False, ), ])
def test_shapes_static(self): specs = features.SpecDict({ 'input': features.Tensor(shape=(2, 3), dtype=tf.float32), }) # Numpy array np_input = np.random.rand(2, 3).astype(np.float32) tf_output = _encode_decode(specs, { 'input': np_input, }) self.assertAllEqual(tf_output['input'], np_input) # Python array array_input = [ [1, 2, 3], [4, 5, 6], ] tf_output = _encode_decode(specs, { 'input': array_input, }) self.assertAllEqual(tf_output['input'], array_input) # Invalid type with self.assertRaisesWithPredicateMatch(ValueError, 'int64 do not match'): _encode_decode(specs, { 'input': np.random.randint(256, size=(2, 3)), }) # Invalid shape with self.assertRaisesWithPredicateMatch(ValueError, 'are incompatible'): _encode_decode(specs, { 'input': np.random.rand(2, 4).astype(np.float32), })
def test_extract_features(): features = features_lib.FeaturesDict({ 'img': features_lib.Image(shape=(256, 256, 3)), 'img2': features_lib.Image(shape=(256, 256, 3)), 'metadata': { 'label': features_lib.ClassLabel(num_classes=4), 'other': tf.string, }, 'sequence': features_lib.Sequence({ 'x': tf.int64, 'y': tf.int64, }), 'sequence_flat': features_lib.Sequence(tf.int64), }) result = _extract_features( feature=features, expected_feature={}, ) testing.assert_features_equal(result, features_lib.FeaturesDict({})) # Feature spec accepted result = _extract_features( feature=features, expected_feature={ 'img': features_lib.Image(shape=(None, None, 3)), 'metadata': { 'other': tf.string, }, 'sequence': features_lib.Sequence({ 'x': tf.int64, }), }, ) testing.assert_features_equal( result, features_lib.FeaturesDict({ 'img': features_lib.Image(shape=(256, 256, 3)), 'metadata': { 'other': tf.string, }, 'sequence': features_lib.Sequence({ 'x': tf.int64, }), }), ) # Failure mode: # * Structure not matching # * Type not matching # * Shape/dtype not matching # * Sequence values not matching (e.g. try bad dtype) with pytest.raises(ValueError, match="Missing expected feature 'unknown'"): _extract_features( feature=features, expected_feature={ 'sequence': features_lib.Sequence({ 'unknown': tf.bool, }) }, ) with pytest.raises(ValueError, match="Missing expected feature 'non_exista"): _extract_features( feature=features, expected_feature={ 'non_existant': features_lib.Image(shape=(None, None, 3)), }, ) with pytest.raises(TypeError, match='Expected: Tensor.*. Got: Image'): _extract_features( feature=features, expected_feature={ 'img': features_lib.Tensor(shape=(256, 256, 3), dtype=tf.uint8), }, ) with pytest.raises(ValueError, match='Expected: Image.*. Got: Image'): _extract_features( feature=features, expected_feature={ 'img': features_lib.Image(shape=(None, None, 1)), }, ) with pytest.raises(ValueError, match='Expected: Tensor.*. Got: Tensor'): _extract_features( feature=features, expected_feature={ 'sequence_flat': features_lib.Sequence(tf.float32), # Wrong dtype }, )
def test_input_dict(self): self.assertFeatureEagerOnly( feature=feature_lib.Dataset({ 'a': tf.string, 'b': { 'c': feature_lib.Tensor(shape=(4, 2), dtype=tf.int32), 'd': tf.uint8, } }, length=None), shape={ 'a': (), 'b': { 'c': (4, 2), 'd': (), } }, dtype={ 'a': tf.string, 'b': { 'c': tf.int32, 'd': tf.uint8, } }, tests=[ testing.FeatureExpectationItem( value={ 'a': ['aa', 'b', 'ccc'], 'b': { 'c': np.ones(shape=(3, 4, 2), dtype=np.int32), 'd': [1, 2, 3], } }, expected=tf.data.Dataset.from_tensor_slices({ 'a': [ tf.compat.as_bytes(t) for t in ('aa', 'b', 'ccc') ], 'b': { 'c': np.ones(shape=(3, 4, 2), dtype=np.int32), 'd': [1, 2, 3], } }), ), testing.FeatureExpectationItem( value={ 'a': [str(i) for i in range(100)], 'b': { # pylint: disable=g-complex-comprehension 'c': [np.ones(shape=(4, 2), dtype=np.int32) for _ in range(100)], 'd': [5 for _ in range(100)], } }, expected=tf.data.Dataset.from_tensor_slices({ 'a': [tf.compat.as_bytes(str(i)) for i in range(100)], 'b': { 'c': np.ones(shape=(100, 4, 2), dtype=np.int32), 'd': [5] * 100, } }), ), # Wrong length in one of the lists. testing.FeatureExpectationItem( value={ 'a': ['aa'], 'b': { 'c': np.ones(shape=(3, 4, 2), dtype=np.int32), 'd': [1, 2, 3], } }, raise_cls=ValueError, raise_msg='The length of all elements of one sequence should be the same.', ), ], )
def test_nested(self): self.assertFeatureEagerOnly( feature=feature_lib.Dataset({ 'a': tf.string, 'b': { 'c': feature_lib.Tensor(shape=(4, 2), dtype=tf.int32), 'd': tf.uint8, } }, length=None), shape={ 'a': (), 'b': { 'c': (4, 2), 'd': (), } }, dtype={ 'a': tf.string, 'b': { 'c': tf.int32, 'd': tf.uint8, } }, tests=[ testing.FeatureExpectationItem( value=dataset_utils.as_numpy(tf.data.Dataset.from_tensor_slices({ 'a': ['aa', 'b', 'ccc'], 'b': { 'c': np.ones(shape=(3, 4, 2), dtype=np.int32), 'd': [1, 2, 3], } })), expected=tf.data.Dataset.from_tensor_slices({ 'a': [ tf.compat.as_bytes(t) for t in ('aa', 'b', 'ccc') ], 'b': { 'c': np.ones(shape=(3, 4, 2), dtype=np.int32), 'd': [1, 2, 3], } }), ), testing.FeatureExpectationItem( value=dataset_utils.as_numpy(tf.data.Dataset.from_tensor_slices({ 'a': [str(i) for i in range(100)], 'b': { # pylint: disable=g-complex-comprehension 'c': [np.ones(shape=(4, 2), dtype=np.int32) for _ in range(100)], 'd': [5 for _ in range(100)], } })), expected=tf.data.Dataset.from_tensor_slices({ 'a': [tf.compat.as_bytes(str(i)) for i in range(100)], 'b': { 'c': np.ones(shape=(100, 4, 2), dtype=np.int32), 'd': [5] * 100, } }), ), ], )
def test_string(self, encoding: features_lib.Encoding): nonunicode_text = 'hello world' unicode_text = u'你好' self.assertFeature( feature=features_lib.Tensor( shape=(), dtype=tf.string, encoding=encoding, ), shape=(), dtype=tf.string, tests=[ # Non-unicode testing.FeatureExpectationItem( value=nonunicode_text, expected=tf.compat.as_bytes(nonunicode_text), ), # Unicode testing.FeatureExpectationItem( value=unicode_text, expected=tf.compat.as_bytes(unicode_text), ), # Empty string testing.FeatureExpectationItem( value='', expected=b'', ), # Trailing zeros testing.FeatureExpectationItem( value=b'abc\x00\x00', expected=b'abc\x00\x00', ), ], ) self.assertFeature( feature=features_lib.Tensor( shape=(2, 1), dtype=tf.string, encoding=encoding, ), shape=(2, 1), dtype=tf.string, tests=[ testing.FeatureExpectationItem( value=[[nonunicode_text], [unicode_text]], expected=[ [tf.compat.as_bytes(nonunicode_text)], [tf.compat.as_bytes(unicode_text)], ], ), testing.FeatureExpectationItem( value=[nonunicode_text, unicode_text], # Wrong shape raise_cls=ValueError, raise_msg='(2,) and (2, 1) must have the same rank', ), testing.FeatureExpectationItem( value=[['some text'], [123]], # Wrong dtype raise_cls=TypeError, raise_msg='Expected binary or unicode string, got 123', ), ], )
def features(self): return dict( camera_position=features.Tensor(shape=(3, ), dtype=tf.float32))
def features(self): return dict( vertices=features.Tensor(shape=(None, 3), dtype=tf.float32), faces=features.Tensor(shape=(None, 3), dtype=tf.int64), )
def test_2lvl_sequences(self): self.assertFeature( feature=feature_lib.Sequence( feature_lib.Sequence( feature_lib.Tensor(shape=(2, ), dtype=tf.int32), ), ), shape=(None, None, 2), dtype=tf.int32, tests=[ testing.FeatureExpectationItem( value=[ [[0, 1], [2, 3]], [], [[4, 5]], ], expected=testing.RaggedConstant([ [[0, 1], [2, 3]], [], [[4, 5]], ], inner_shape=(2, )), ), # Empty testing.FeatureExpectationItem( value=[], expected=[], ), # List of empty lists testing.FeatureExpectationItem( value=[[], [], []], expected=[[], [], []], ), # List of empty np.array testing.FeatureExpectationItem( value=[ np.empty(shape=(0, 2), dtype=np.int32), np.empty(shape=(0, 2), dtype=np.int32), ], expected=[ [], [], ], ), testing.FeatureExpectationItem( value=[ np.empty(shape=(0, 2), dtype=np.int32), np.empty(shape=(0, 2), dtype=np.int32), np.ones(shape=(3, 2), dtype=np.int32), ], expected=[ [], [], [[1, 1], [1, 1], [1, 1]], ], ), # Wrong types should fails testing.FeatureExpectationItem( value=[ np.ones(shape=(3, 2), dtype=np.float32), ], raise_cls=ValueError, raise_msg='float32 do not match int32', ), ], )
def test_nested(self): self.assertFeature( feature=feature_lib.Sequence({ 'a': tf.string, 'b': { 'c': feature_lib.Tensor(shape=(4, 2), dtype=tf.int32), 'd': tf.uint8, } }, length=None), shape={ 'a': (None,), 'b': { 'c': (None, 4, 2), 'd': (None,), } }, dtype={ 'a': tf.string, 'b': { 'c': tf.int32, 'd': tf.uint8, } }, tests=[ testing.FeatureExpectationItem( value={ 'a': ['aa', 'b', 'ccc'], 'b': { 'c': np.ones(shape=(3, 4, 2), dtype=np.int32), 'd': [1, 2, 3], } }, expected={ 'a': [ tf.compat.as_bytes(t) for t in ('aa', 'b', 'ccc') ], 'b': { 'c': np.ones(shape=(3, 4, 2), dtype=np.int32), 'd': [1, 2, 3], } }, ), testing.FeatureExpectationItem( value={ 'a': [str(i) for i in range(100)], 'b': [{ # pylint: disable=g-complex-comprehension 'c': np.ones(shape=(4, 2), dtype=np.int32), 'd': 5, } for _ in range(100)] }, expected={ 'a': [tf.compat.as_bytes(str(i)) for i in range(100)], 'b': { 'c': np.ones(shape=(100, 4, 2), dtype=np.int32), 'd': [5] * 100, } }, ), # Test inputs not same sequence length testing.FeatureExpectationItem( value={ 'a': ['aa', 'b', 'ccc'], 'b': { 'c': np.ones(shape=(4, 4, 2), dtype=np.int32), 'd': [1, 2, 3], } }, raise_cls=ValueError, raise_msg='length of all elements of one sequence should', ), ], )
def expectations(self): np_input = np.random.rand(2, 3).astype(np.float32) array_input = [ [1, 2, 3], [4, 5, 6], ] np_input_dynamic_1 = np.random.randint(256, size=(2, 3, 2), dtype=np.int32) np_input_dynamic_2 = np.random.randint(256, size=(5, 3, 2), dtype=np.int32) return [ test_utils.FeatureExpectation( name='shape_static', feature=features_lib.Tensor(shape=(2, 3), dtype=tf.float32), dtype=tf.float32, shape=(2, 3), tests=[ # Np array test_utils.FeatureExpectationItem( value=np_input, expected=np_input, ), # Python array test_utils.FeatureExpectationItem( value=array_input, expected=array_input, ), # Invalid dtype test_utils.FeatureExpectationItem( value=np.random.randint(256, size=(2, 3)), raise_cls=ValueError, raise_msg='int64 do not match', ), # Invalid shape test_utils.FeatureExpectationItem( value=np.random.rand(2, 4).astype(np.float32), raise_cls=ValueError, raise_msg='are incompatible', ), ], ), test_utils.FeatureExpectation( name='shape_dynamic', feature=features_lib.Tensor(shape=(None, 3, 2), dtype=tf.int32), dtype=tf.int32, shape=(None, 3, 2), tests=[ test_utils.FeatureExpectationItem( value=np_input_dynamic_1, expected=np_input_dynamic_1, ), test_utils.FeatureExpectationItem( value=np_input_dynamic_2, expected=np_input_dynamic_2, ), # Invalid shape test_utils.FeatureExpectationItem( value= np.random.randint(256, size=(2, 3, 1), dtype=np.int32), raise_cls=ValueError, raise_msg='are incompatible', ), ] ), test_utils.FeatureExpectation( name='bool_flat', feature=features_lib.Tensor(shape=(), dtype=tf.bool), dtype=tf.bool, shape=(), tests=[ test_utils.FeatureExpectationItem( value=np.array(True), expected=True, ), test_utils.FeatureExpectationItem( value=np.array(False), expected=False, ), test_utils.FeatureExpectationItem( value=True, expected=True, ), test_utils.FeatureExpectationItem( value=False, expected=False, ), ] ), test_utils.FeatureExpectation( name='bool_array', feature=features_lib.Tensor(shape=(3,), dtype=tf.bool), dtype=tf.bool, shape=(3,), tests=[ test_utils.FeatureExpectationItem( value=np.array([True, True, False]), expected=[True, True, False], ), test_utils.FeatureExpectationItem( value=[True, False, True], expected=[True, False, True], ), ] ), ]