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, [])