def testRaggedPlaceholderDoesNotIncludeValidationOps(self):
if context.executing_eagerly():
return
graph = ops.Graph()
with graph.as_default():
ragged_factory_ops.placeholder(dtypes.float32,
ragged_rank=1,
value_shape=[])
self.assertEqual([op.type for op in graph.get_operations()],
['Placeholder', 'Placeholder'])
def testRaggedPlaceholder(self, dtype, ragged_rank, value_shape, name,
expected):
if not context.executing_eagerly():
placeholder = ragged_factory_ops.placeholder(
dtype, ragged_rank, value_shape, name)
result = str(placeholder).replace('?', 'None')
self.assertEqual(result, expected)
def _model_with_ragged_input(self):
"""Generate a graph with a RaggedTensor input and serialize in V1 format."""
export_graph = ops.Graph()
with export_graph.as_default():
x = ragged_factory_ops.placeholder(dtypes.float32, 1, [])
y = x * 2
with session_lib.Session() as sess:
path = os.path.join(self.get_temp_dir(), "saved_model", str(ops.uid()))
simple_save.simple_save(sess, path, inputs={"x": x}, outputs={"y": y})
return path
def run_benchmark(self,
shape=(100, 100),
ragged_rank=None,
dtype=dtypes.float32,
fill=None,
default_shape=(),
output_shape=None,
min_iters=1000):
"""Run a benchmark with the specified configuraiton parameters.
Args:
shape: Bounding box for the input ragged tensor.
ragged_rank: Ragged rank for the input ragged tensor. Defauts to
`len(shape)-1`.
dtype: Data type for the input ragged tensor.
fill: How full each dimension should be (0-1). Corresponds 1:1 with
`shape`. Defaults to 0.8 for each dimension.
default_shape: Shape for the default (padding) value.
output_shape: Output shape -- ragged tensor will be padded or cropped to
this shape.
min_iters: Minimum iterations for benchmark.
"""
if ragged_rank is None:
ragged_rank = len(shape) - 1
if fill is None:
fill = [0.8 for _ in shape]
# Build the inputs for the op.
rt_input = self._generateRaggedTensor(shape, ragged_rank, dtype, fill)
default_value = constant_op.constant(self._generateRaggedTensor(
default_shape, 0, dtype),
dtype=dtype)
mbs = np.prod(shape) / (2**20)
with session.Session(config=benchmark.benchmark_config()) as sess:
extras = {
'shape': shape,
'ragged_rank': ragged_rank,
'dtype': dtype,
'fill': fill,
'default_shape': default_shape
}
rt = ragged_factory_ops.constant(rt_input,
dtype,
ragged_rank=ragged_rank)
# Inputs for with_splits:
splits_rt_placeholder = ragged_factory_ops.placeholder(
dtype, ragged_rank, shape[ragged_rank + 1:])
splits_feed_dict = {splits_rt_placeholder: sess.run(rt)}
# Inputs for with_rowids:
rowids_feed_dict = {}
rowids_rt_placeholder = rebuild_ragged_tensor_with_value_rowids(
rt, rowids_feed_dict, sess)
# Common arguments for benchmarks:
run_op_benchmark_kwargs = dict(sess=sess,
store_memory_usage=True,
min_iters=min_iters,
burn_iters=max(5, min_iters // 10),
mbs=mbs,
extras=extras)
ragged_to_dense_with_splits = ragged_conversion_ops.ragged_to_dense(
splits_rt_placeholder, default_value=default_value)
self.run_op_benchmark(op_or_tensor=ragged_to_dense_with_splits.op,
name='ragged_to_dense_with_splits',
feed_dict=splits_feed_dict,
**run_op_benchmark_kwargs)
ragged_to_tensor_with_splits = splits_rt_placeholder.to_tensor(
default_value=default_value)
self.run_op_benchmark(op_or_tensor=ragged_to_tensor_with_splits.op,
name='ragged_to_tensor_with_splits',
feed_dict=splits_feed_dict,
**run_op_benchmark_kwargs)
ragged_to_dense_with_rowids = ragged_conversion_ops.ragged_to_dense(
rowids_rt_placeholder, default_value=default_value)
self.run_op_benchmark(op_or_tensor=ragged_to_dense_with_rowids.op,
name='ragged_to_dense_with_rowids',
feed_dict=rowids_feed_dict,
**run_op_benchmark_kwargs)
ragged_to_tensor_with_rowids = rowids_rt_placeholder.to_tensor(
default_value=default_value)
self.run_op_benchmark(op_or_tensor=ragged_to_tensor_with_rowids.op,
name='ragged_to_tensor_with_rowids',
feed_dict=rowids_feed_dict,
**run_op_benchmark_kwargs)
def testRaggedPlaceholderRaisesExceptionInEagerMode(self):
if context.executing_eagerly():
with self.assertRaises(RuntimeError):
ragged_factory_ops.placeholder(dtypes.int32, 1, [])
