def to_representation_for_type(value, type_spec=None, backend=None):
"""Verifies or converts the `value` to executor payload matching `type_spec`.
The following kinds of `value` are supported:
* Computations, either `pb.Computation` or `computation_impl.ComputationImpl`.
These are compiled and converted into `runtime.ComputationCallable`.
* Numpy arrays and scalars, or Python scalars that are converted to Numpy.
Args:
value: The raw representation of a value to compare against `type_spec` and
potentially to be converted.
type_spec: An instance of `tff.Type`. Can be `None` for values that derive
from `typed_object.TypedObject`.
backend: Optional information about the backend, only required for
computations. Must be `None` or an instance of `backend_info.BackendInfo`.
Returns:
Either `value` itself, or a modified version of it.
Raises:
TypeError: If the `value` is not compatible with `type_spec`.
ValueError: If the arguments are incorrect (e.g., missing `backend` for a
computation-typed `value`).
"""
type_spec = type_utils.reconcile_value_with_type_spec(value, type_spec)
if backend is not None:
py_typecheck.check_type(backend, backend_info.BackendInfo)
if isinstance(value, computation_base.Computation):
return to_representation_for_type(
computation_impl.ComputationImpl.get_proto(value),
type_spec=type_spec,
backend=backend)
elif isinstance(value, pb.Computation):
if backend is None:
raise ValueError('Missing backend info for a computation.')
module = compiler.import_tensorflow_computation(value)
return runtime.ComputationCallable(module, backend)
elif isinstance(type_spec, computation_types.TensorType):
type_spec.shape.assert_is_fully_defined()
type_analysis.check_type(value, type_spec)
if type_spec.shape.rank == 0:
return np.dtype(type_spec.dtype.as_numpy_dtype).type(value)
elif type_spec.shape.rank > 0:
return np.array(value, dtype=type_spec.dtype.as_numpy_dtype)
else:
raise TypeError('Unsupported tensor shape {}.'.format(
type_spec.shape))
else:
raise TypeError('Unexpected type {}.'.format(type_spec))
def _import_compile_and_return_module_and_mlir(self, comp):
"""Testing helper that compiles `comp` and returns the compiler module.
Args:
comp: A computation created with `@computations.tf_computation`.
Returns:
A tuple consisting of the compiler module and MLIR.
"""
comp_proto = computation_impl.ComputationImpl.get_proto(comp)
module = compiler.import_tensorflow_computation(comp_proto)
self.assertIsInstance(module, computation_module.ComputationModule)
mlir = module.compiler_module.to_asm(large_element_limit=100)
return module, mlir