"""Gets the Tensorflow TypeSpec corresponding to the passed dataset. Args: value: A HDF5Matrix object. Returns: A tf.TensorSpec. """ if not isinstance(value, HDF5Matrix): raise TypeError( 'Expected value to be a HDF5Matrix, but saw: {}'.format( type(value))) return tensor_spec.TensorSpec(shape=value.shape, dtype=value.dtype) type_spec.register_type_spec_from_value_converter(HDF5Matrix, HDF5Matrix._to_type_spec) # pylint: disable=protected-access def ask_to_proceed_with_overwrite(filepath): """Produces a prompt asking about overwriting a file. Arguments: filepath: the path to the file to be overwritten. Returns: True if we can proceed with overwrite, False otherwise. """ overwrite = six.moves.input('[WARNING] %s already exists - overwrite? ' '[y/n]' % (filepath)).strip().lower() while overwrite not in ('y', 'n'): overwrite = six.moves.input('Enter "y" (overwrite) or "n" '
def from_value(cls, value): if isinstance(value, SparseTensor): return cls(value.shape, value.dtype) if isinstance(value, SparseTensorValue): if isinstance(value.values, np.ndarray): return cls(value.dense_shape, value.values.dtype) else: return cls.from_value(SparseTensor.from_value(value)) else: raise TypeError("Expected SparseTensor or SparseTensorValue") # TODO(b/133606651) Delete the SparseTensor registration when CompositeTensor # is updated to define a _type_spec field (since registration will be # automatic). Do *not* delete the SparseTensorValue registration. type_spec.register_type_spec_from_value_converter(SparseTensor, SparseTensorSpec.from_value) type_spec.register_type_spec_from_value_converter(SparseTensorValue, SparseTensorSpec.from_value) @tf_export(v1=["convert_to_tensor_or_sparse_tensor"]) def convert_to_tensor_or_sparse_tensor(value, dtype=None, name=None): """Converts value to a `SparseTensor` or `Tensor`. Args: value: A `SparseTensor`, `SparseTensorValue`, or an object whose type has a registered `Tensor` conversion function. dtype: Optional element type for the returned tensor. If missing, the type is inferred from the type of `value`. name: Optional name to use if a new `Tensor` is created.
@property def maximum(self): """Returns a NumPy array specifying the maximum bounds (inclusive).""" return self._maximum def __repr__(self): s = "BoundedTensorSpec(shape={}, dtype={}, name={}, minimum={}, maximum={})" return s.format(self.shape, repr(self.dtype), repr(self.name), repr(self.minimum), repr(self.maximum)) def __eq__(self, other): tensor_spec_eq = super(BoundedTensorSpec, self).__eq__(other) return (tensor_spec_eq and np.allclose(self.minimum, other.minimum) and np.allclose(self.maximum, other.maximum)) def __reduce__(self): return BoundedTensorSpec, (self._shape, self._dtype, self._minimum, self._maximum, self._name) def _serialize(self): return (self._shape, self._dtype, self._minimum, self._maximum, self._name) pywrap_tensorflow.RegisterType("TensorSpec", TensorSpec) # Note: we do not include Tensor names when constructing TypeSpecs. type_spec.register_type_spec_from_value_converter( ops.Tensor, lambda tensor: TensorSpec(tensor.shape, tensor.dtype))
def _from_components(self, components): x, y = components return TwoTensors(x, y, self.color) def _serialize(self): return (self.x_shape, self.x_dtype, self.y_shape, self.y_dtype, self.color) @classmethod def from_value(cls, value): return cls(value.x.shape, value.x.dtype, value.y.shape, value.y.dtype, value.color) type_spec.register_type_spec_from_value_converter( TwoTensors, TwoTensorsSpecNoOneDtype.from_value) class InputLayerTest(keras_parameterized.TestCase): @combinations.generate(combinations.combine(mode=['graph', 'eager'])) def testBasicOutputShapeNoBatchSize(self): # Create a Keras Input x = input_layer_lib.Input(shape=(32, ), name='input_a') self.assertAllEqual(x.shape.as_list(), [None, 32]) # Verify you can construct and use a model w/ this input model = functional.Functional(x, x * 2.0) self.assertAllEqual(model(array_ops.ones((3, 32))), array_ops.ones((3, 32)) * 2.0) @combinations.generate(combinations.combine(mode=['graph', 'eager']))
def from_value(value): return NoneTensorSpec() def _batch(self, batch_size): return NoneTensorSpec() def _unbatch(self): return NoneTensorSpec() def _to_batched_tensor_list(self, value): return [] def _to_legacy_output_types(self): return self def _to_legacy_output_shapes(self): return self def _to_legacy_output_classes(self): return self def most_specific_compatible_shape(self, other): if type(self) is not type(other): raise ValueError("No TypeSpec is compatible with both %s and %s" % (self, other)) return self type_spec.register_type_spec_from_value_converter(type(None), NoneTensorSpec.from_value)
s = "BoundedTensorSpec(shape={}, dtype={}, name={}, minimum={}, maximum={})" return s.format(self.shape, repr(self.dtype), repr(self.name), repr(self.minimum), repr(self.maximum)) def __eq__(self, other): tensor_spec_eq = super(BoundedTensorSpec, self).__eq__(other) return (tensor_spec_eq and np.allclose(self.minimum, other.minimum) and np.allclose(self.maximum, other.maximum)) def __hash__(self): return hash((self._shape, self.dtype)) def __reduce__(self): return BoundedTensorSpec, (self._shape, self._dtype, self._minimum, self._maximum, self._name) def _serialize(self): return (self._shape, self._dtype, self._minimum, self._maximum, self._name) trace_type.register_serializable(BoundedTensorSpec) _pywrap_utils.RegisterType("TensorSpec", TensorSpec) # Note: we do not include Tensor names when constructing TypeSpecs. type_spec.register_type_spec_from_value_converter( ops.Tensor, lambda tensor: TensorSpec(tensor.shape, tensor.dtype)) type_spec.register_type_spec_from_value_converter( np.ndarray, lambda array: TensorSpec(array.shape, array.dtype))
def _from_components(self, components): x, y = components return TwoTensors(x, y, self.color) def _serialize(self): return (self.x_shape, self.x_dtype, self.y_shape, self.y_dtype, self.color) @classmethod def from_value(cls, value): return cls(value.x.shape, value.x.dtype, value.y.shape, value.y.dtype, value.color) type_spec.register_type_spec_from_value_converter(TwoTensors, TwoTensorsSpec.from_value) class TwoComposites(object): """A simple value type to test TypeSpec. Contains two composite tensorstensors (x, y) and a string (color). """ def __init__(self, x, y, color="red"): assert isinstance(color, str) self.x = ops.convert_to_tensor_or_composite(x) self.y = ops.convert_to_tensor_or_composite(y) self.color = color @type_spec.register("tf.TwoCompositesSpec")
@property def _component_specs(self): return [tensor_spec.TensorSpec((), dtypes.variant)] def _to_components(self, value): return [value._variant_tensor] # pylint: disable=protected-access def _from_components(self, flat_value): # pylint: disable=protected-access return _OptionalImpl(flat_value[0], self._value_structure) @staticmethod def from_value(value): return OptionalStructure(value.value_structure) def _to_legacy_output_types(self): return self def _to_legacy_output_shapes(self): return self def _to_legacy_output_classes(self): return self type_spec.register_type_spec_from_value_converter(Optional, OptionalStructure.from_value) type_spec.register_type_spec_from_value_converter(_OptionalImpl, OptionalStructure.from_value)
def _to_legacy_output_shapes(self): return nest.map_structure(lambda s: s._to_legacy_output_shapes(), self._nested_structure) def _to_legacy_output_classes(self): return nest.map_structure(lambda s: s._to_legacy_output_classes(), self._nested_structure) def _batch(self, batch_size): return NestedStructure( nest.map_structure(lambda s: s._batch(batch_size), self._nested_structure)) def _unbatch(self): return NestedStructure( nest.map_structure(lambda s: s._unbatch(), self._nested_structure)) type_spec.register_type_spec_from_value_converter(tuple, NestedStructure.from_value, allow_subclass=True) type_spec.register_type_spec_from_value_converter(dict, NestedStructure.from_value, allow_subclass=True) # Re-register SparseTensorValue -- it's a subclass of tuple, but we don't # want the NestedStructure registration to take precedence. type_spec.register_type_spec_from_value_converter( sparse_tensor.SparseTensorValue, sparse_tensor.SparseTensorSpec.from_value)