View source on GitHub |

foldl on the list of tensors unpacked from `elems`

on dimension 0. (deprecated argument values)

tf.foldl( fn, elems, initializer=None, parallel_iterations=10, back_prop=True, swap_memory=False, name=None )

This foldl operator repeatedly applies the callable `fn`

to a sequence of elements from first to last. The elements are made of the tensors unpacked from `elems`

on dimension 0. The callable fn takes two tensors as arguments. The first argument is the accumulated value computed from the preceding invocation of fn, and the second is the value at the current position of `elems`

. If `initializer`

is None, `elems`

must contain at least one element, and its first element is used as the initializer.

Suppose that `elems`

is unpacked into `values`

, a list of tensors. The shape of the result tensor is fn(initializer, values[0]).shape`.

This method also allows multi-arity `elems`

and output of `fn`

. If `elems`

is a (possibly nested) list or tuple of tensors, then each of these tensors must have a matching first (unpack) dimension. The signature of `fn`

may match the structure of `elems`

. That is, if `elems`

is `(t1, [t2, t3, [t4, t5]])`

, then an appropriate signature for `fn`

is: `fn = lambda (t1, [t2, t3, [t4, t5]]):`

.

Args | |
---|---|

`fn` | The callable to be performed. |

`elems` | A tensor or (possibly nested) sequence of tensors, each of which will be unpacked along their first dimension. The nested sequence of the resulting slices will be the first argument to `fn` . |

`initializer` | (optional) A tensor or (possibly nested) sequence of tensors, as the initial value for the accumulator. |

`parallel_iterations` | (optional) The number of iterations allowed to run in parallel. |

`back_prop` | (optional) Deprecated. False disables support for back propagation. Prefer using `tf.stop_gradient` instead. |

`swap_memory` | (optional) True enables GPU-CPU memory swapping. |

`name` | (optional) Name prefix for the returned tensors. |

Returns | |
---|---|

A tensor or (possibly nested) sequence of tensors, resulting from applying `fn` consecutively to the list of tensors unpacked from `elems` , from first to last. |

Raises | |
---|---|

`TypeError` | if `fn` is not callable. |

elems = tf.constant([1, 2, 3, 4, 5, 6]) sum = foldl(lambda a, x: a + x, elems) # sum == 21

© 2020 The TensorFlow Authors. All rights reserved.

Licensed under the Creative Commons Attribution License 3.0.

Code samples licensed under the Apache 2.0 License.

https://www.tensorflow.org/versions/r2.4/api_docs/python/tf/foldl