tf.map_fn  |  TensorFlow v2.16.1 (original) (raw)

Transforms elems by applying fn to each element unstacked on axis 0. (deprecated arguments)

tf.map_fn(
    fn,
    elems,
    dtype=None,
    parallel_iterations=None,
    back_prop=True,
    swap_memory=False,
    infer_shape=True,
    name=None,
    fn_output_signature=None
)

Used in the notebooks

See also tf.scan.

map_fn unstacks elems on axis 0 to obtain a sequence of elements; calls fn to transform each element; and then stacks the transformed values back together.

Mapping functions with single-Tensor inputs and outputs

If elems is a single tensor and fn's signature is tf.Tensor->tf.Tensor, then map_fn(fn, elems) is equivalent totf.stack([fn(elem) for elem in tf.unstack(elems)]). E.g.:

tf.map_fn(fn=lambda t: tf.range(t, t + 3), elems=tf.constant([3, 5, 2])) <tf.Tensor: shape=(3, 3), dtype=int32, numpy= array([[3, 4, 5], [5, 6, 7], [2, 3, 4]], dtype=int32)>

map_fn(fn, elems).shape = [elems.shape[0]] + fn(elems[0]).shape.

Mapping functions with multi-arity inputs and outputs

map_fn also supports functions with multi-arity inputs and outputs:

• If elems is a tuple (or nested structure) of tensors, then those tensors must all have the same outer-dimension size (num_elems); and fn is used to transform each tuple (or structure) of corresponding slices fromelems. E.g., if elems is a tuple (t1, t2, t3), then fn is used to transform each tuple of slices (t1[i], t2[i], t3[i])(where 0 <= i < num_elems).
• If fn returns a tuple (or nested structure) of tensors, then the result is formed by stacking corresponding elements from those structures.

Specifying fn's output signature

If fn's input and output signatures are different, then the output signature must be specified using fn_output_signature. (The input and output signatures are differ if their structures, dtypes, or tensor types do not match). E.g.:

tf.map_fn(fn=tf.strings.length, # input & output have different dtypes elems=tf.constant(["hello", "moon"]), fn_output_signature=tf.int32) <tf.Tensor: shape=(2,), dtype=int32, numpy=array([5, 4], dtype=int32)> tf.map_fn(fn=tf.strings.join, # input & output have different structures elems=[tf.constant(['The', 'A']), tf.constant(['Dog', 'Cat'])], fn_output_signature=tf.string) <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'TheDog', b'ACat'], dtype=object)>

fn_output_signature can be specified using any of the following:

• A tf.DType or tf.TensorSpec (to describe a tf.Tensor)
• A tf.RaggedTensorSpec (to describe a tf.RaggedTensor)
• A tf.SparseTensorSpec (to describe a tf.sparse.SparseTensor)
• A (possibly nested) tuple, list, or dict containing the above types.

RaggedTensors

map_fn supports tf.RaggedTensor inputs and outputs. In particular:

• If elems is a RaggedTensor, then fn will be called with each row of that ragged tensor.
  • If elems has only one ragged dimension, then the values passed tofn will be tf.Tensors.
  • If elems has multiple ragged dimensions, then the values passed tofn will be tf.RaggedTensors with one fewer ragged dimension.
• If the result of map_fn should be a RaggedTensor, then use atf.RaggedTensorSpec to specify fn_output_signature.
  • If fn returns tf.Tensors with varying sizes, then use atf.RaggedTensorSpec with ragged_rank=0 to combine them into a single ragged tensor (which will have ragged_rank=1).
  • If fn returns tf.RaggedTensors, then use a tf.RaggedTensorSpecwith the same ragged_rank.

# Example: RaggedTensor input rt = tf.ragged.constant([[1, 2, 3], [], [4, 5], [6]]) tf.map_fn(tf.reduce_sum, rt, fn_output_signature=tf.int32) <tf.Tensor: shape=(4,), dtype=int32, numpy=array([6, 0, 9, 6], dtype=int32)>

# Example: RaggedTensor output elems = tf.constant([3, 5, 0, 2]) tf.map_fn(tf.range, elems, fn_output_signature=tf.RaggedTensorSpec(shape=[None], dtype=tf.int32)) <tf.RaggedTensor [[0, 1, 2], [0, 1, 2, 3, 4], [], [0, 1]]>

• tf.ragged.map_flat_values(fn, rt)(if fn is expressible as TensorFlow ops)
• rt.with_flat_values(map_fn(fn, rt.flat_values))(otherwise)

E.g.:

rt = tf.ragged.constant([[1, 2, 3], [], [4, 5], [6]]) tf.ragged.map_flat_values(lambda x: x + 2, rt) <tf.RaggedTensor [[3, 4, 5], [], [6, 7], [8]]>

SparseTensors

map_fn supports tf.sparse.SparseTensor inputs and outputs. In particular:

• If elems is a SparseTensor, then fn will be called with each row of that sparse tensor. In particular, the value passed to fn will be atf.sparse.SparseTensor with one fewer dimension than elems.
• If the result of map_fn should be a SparseTensor, then use atf.SparseTensorSpec to specify fn_output_signature. The individualSparseTensors returned by fn will be stacked into a singleSparseTensor with one more dimension.

# Example: SparseTensor input st = tf.sparse.SparseTensor([[0, 0], [2, 0], [2, 1]], [2, 3, 4], [4, 4]) tf.map_fn(tf.sparse.reduce_sum, st, fn_output_signature=tf.int32) <tf.Tensor: shape=(4,), dtype=int32, numpy=array([2, 0, 7, 0], dtype=int32)>

# Example: SparseTensor output tf.sparse.to_dense( tf.map_fn(tf.sparse.eye, tf.constant([2, 3]), fn_output_signature=tf.SparseTensorSpec(None, tf.float32))) <tf.Tensor: shape=(2, 3, 3), dtype=float32, numpy= array([[[1., 0., 0.], [0., 1., 0.], [0., 0., 0.]], [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]], dtype=float32)>

• If the function is expressible as TensorFlow ops, use:

tf.sparse.SparseTensor(st.indices, fn(st.values), st.dense_shape)  

• Otherwise, use:

tf.sparse.SparseTensor(st.indices, tf.map_fn(fn, st.values),  
                       st.dense_shape)  

map_fn vs. vectorized operations

map_fn will apply the operations used by fn to each element of elems, resulting in O(elems.shape[0]) total operations. This is somewhat mitigated by the fact that map_fn can process elements in parallel. However, a transform expressed using map_fn is still typically less efficient than an equivalent transform expressed using vectorized operations.

map_fn should typically only be used if one of the following is true:

• It is difficult or expensive to express the desired transform with vectorized operations.
• fn creates large intermediate values, so an equivalent vectorized transform would take too much memory.
• Processing elements in parallel is more efficient than an equivalent vectorized transform.
• Efficiency of the transform is not critical, and using map_fn is more readable.

E.g., the example given above that maps fn=lambda t: tf.range(t, t + 3)across elems could be rewritten more efficiently using vectorized ops:

elems = tf.constant([3, 5, 2]) tf.range(3) + tf.expand_dims(elems, 1) <tf.Tensor: shape=(3, 3), dtype=int32, numpy= array([[3, 4, 5], [5, 6, 7], [2, 3, 4]], dtype=int32)>

In some cases, tf.vectorized_map can be used to automatically convert a function to a vectorized equivalent.

Eager execution

When executing eagerly, map_fn does not execute in parallel even ifparallel_iterations is set to a value > 1. You can still get the performance benefits of running a function in parallel by using thetf.function decorator:

fn=lambda t: tf.range(t, t + 3) @tf.function def func(elems): return tf.map_fn(fn, elems, parallel_iterations=3) func(tf.constant([3, 5, 2])) <tf.Tensor: shape=(3, 3), dtype=int32, numpy= array([[3, 4, 5], [5, 6, 7], [2, 3, 4]], dtype=int32)>