AVhqlfdZddlZddlmZddlmZddlm Z ddl m Z ddl m Z ddl m Z dd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZedgej@ddd d)dZ!dZ"dZ#dZ$dZ%d Z&d!Z'd"Z(edgejRdd#dd$ej@ddd d)d%Z*ejVd&d'e!je*_d(e*jvsJy)*zFunctional operations.N)ag_ctx)api)context)composite_tensor) constant_op)ops) tensor_shape) tensor_spec) type_spec) array_ops)tensor_array_ops)variable_scope) while_loop) tf_logging) deprecation)nest)variable_utils) tf_exportmap_fn)v1zUse fn_output_signature insteaddtypeTFc b "#$%&|tstdjdtj } | r|sd}n5| s|sd}n.| s,|dkDr't j t jddd}tjtj} t| dk(rtdj| D cgc]} tj | c} #fd $*| D cgc]} t#| j%c} &$} n1tjD cgc] } t'| c} &fd } t)j*|d | 5| r6t-j.}d }|j0|j3d d}| Dcgc]}t)j4|d} }| d}t7|dr2|j8}|j:|j:dkr tdt=| }t?j@t?jB|djEjGdd}|ddD]Y}|jIt?j@t?jB|jEjGdd[|jJxstMj8|dd%|Dcgc]%}tOjP|jR%d d'c}"tU"|Dcgc]\}}|jW|c}}"tYjZd}t]&}g}|D]?}|j_tOjP|jR%d ||j8A"#$&fd}taj`%fd|||f|||%\}}|Dcgc]}|jc}}|D]F}|jet?jf|ji|jEddH| rrj3dtk|&|} | | }!|!cdddScc} wcc} wcc} wcc}wcc}wcc}}wcc}w#1swYyxYw)a3-Transforms `elems` by applying `fn` to each element unstacked on axis 0. 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 to `tf.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])) `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 from `elems`. 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.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) `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 to `fn` will be `tf.Tensor`s. * If `elems` has multiple ragged dimensions, then the values passed to `fn` will be `tf.RaggedTensor`s with one fewer ragged dimension. * If the result of `map_fn` should be a `RaggedTensor`, then use a `tf.RaggedTensorSpec` to specify `fn_output_signature`. * If `fn` returns `tf.Tensor`s with varying sizes, then use a `tf.RaggedTensorSpec` with `ragged_rank=0` to combine them into a single ragged tensor (which will have ragged_rank=1). * If `fn` returns `tf.RaggedTensor`s, then use a `tf.RaggedTensorSpec` with 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) >>> # 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)) Note: `map_fn` should only be used if you need to map a function over the *rows* of a `RaggedTensor`. If you wish to map a function over the individual values, then you should use: * `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) #### 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 a `tf.sparse.SparseTensor` with one fewer dimension than `elems`. * If the result of `map_fn` should be a `SparseTensor`, then use a `tf.SparseTensorSpec` to specify `fn_output_signature`. The individual `SparseTensor`s returned by `fn` will be stacked into a single `SparseTensor` 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) >>> # 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))) Note: `map_fn` should only be used if you need to map a function over the *rows* of a `SparseTensor`. If you wish to map a function over the nonzero values, then you should use: * If the function is expressible as TensorFlow ops, use: ```python tf.sparse.SparseTensor(st.indices, fn(st.values), st.dense_shape) ``` * Otherwise, use: ```python 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) 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 if `parallel_iterations` is set to a value > 1. You can still get the performance benefits of running a function in parallel by using the `tf.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])) Note: if you use the `tf.function` decorator, any non-TensorFlow Python code that you may have written in your function won't get executed. See `tf.function` for more details. The recommendation would be to debug without `tf.function` but switch to it to get performance benefits of running `map_fn` in parallel. Args: fn: The callable to be performed. It accepts one argument, which will have the same (possibly nested) structure as `elems`. Its output must have the same structure as `fn_output_signature` if one is provided; otherwise it must have the same structure as `elems`. elems: A tensor or (possibly nested) sequence of tensors, each of which will be unstacked along their first dimension. `fn` will be applied to the nested sequence of the resulting slices. `elems` may include ragged and sparse tensors. `elems` must consist of at least one tensor. dtype: Deprecated: Equivalent to `fn_output_signature`. parallel_iterations: (optional) The number of iterations allowed to run in parallel. When graph building, the default value is 10. While executing eagerly, the default value is set to 1. back_prop: (optional) False disables support for back propagation. swap_memory: (optional) True enables GPU-CPU memory swapping. infer_shape: (optional) False disables tests for consistent output shapes. name: (optional) Name prefix for the returned tensors. fn_output_signature: The output signature of `fn`. Must be specified if `fn`'s input and output signatures are different (i.e., if their structures, dtypes, or tensor types do not match). `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. Returns: A tensor or (possibly nested) sequence of tensors. Each tensor stacks the results of applying `fn` to tensors unstacked from `elems` along the first dimension, from first to last. The result may include ragged and sparse tensors. Raises: TypeError: if `fn` is not callable or the structure of the output of `fn` and `fn_output_signature` do not match. ValueError: if the lengths of the output of `fn` and `fn_output_signature` do not match, or if the `elems` does not contain any tensor. Examples: >>> elems = np.array([1, 2, 3, 4, 5, 6]) >>> tf.map_fn(lambda x: x * x, elems) >>> elems = (np.array([1, 2, 3]), np.array([-1, 1, -1])) >>> tf.map_fn(lambda x: x[0] * x[1], elems, fn_output_signature=tf.int64) >>> elems = np.array([1, 2, 3]) >>> tf.map_fn(lambda x: (x, -x), elems, ... fn_output_signature=(tf.int64, tf.int64)) (, ) NzThe provided function z% is not callable.fn must be callable. zSetting parallel_iterations > 1 has no effect when executing eagerly. Consider calling map_fn with tf.function to execute fn in parallel.rzlelems must be a Tensor or (possibly nested) sequence of Tensors. Got {}, which does not contain any Tensors.c0tj|SNrpack_sequence_as)xelemss L/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/map_fn.pyzmap_fn..sd33E1=c0tj|Srr)rfn_output_signatures r!r"zmap_fn..s!6!67JA!Nr#mapFc|jSr)device)ops r!r"zmap_fn..s ryyr#Telem)nameshapez=Elements in elems must be 1+ dimensional Tensors, not scalars)rsize dynamic_size infer_shape)rr-r.r/ element_shapec Dcgc]}|j|}}t|}|}tj}t j |}||}t jxs |t j|} t| } t|| D cgc]\}} |j|| }}} |dz|fScc}wcc} }w)a{The loop body of map_fn. Args: i: the loop counter tas: the flat TensorArray accumulator list Returns: (i + 1, tas): the updated counter + updated TensorArrays Raises: TypeError: if fn_output_signature and result_value structure don't match ValueType: if fn_output_signature and result_value lengths don't match r) read_elems_value_batchable_to_flat autograph_ctxcontrol_status_ctx autograph tf_convertrassert_same_structureflatten_result_value_flat_to_batchablezipwrite)itastaelems_value_batchableelems_value_flat elems_valuerautographed_fn result_valueresult_value_flatresult_value_batchablevaluer elems_batchable_taelems_flat_signatureelems_unflattenfnr%result_flat_signatures r!computezmap_fn..computes5GGbrwwqzGG78M8LN#$45k//1f ++B7n#K0l   !4!=|L,,|4> 2 414C9O0P !,"e"((1e  c !eS\H s C0Cc|kSr)r=_ns r!r"zmap_fn..s QUr#)parallel_iterations back_prop swap_memorymaximum_iterations)6callable TypeError__name__rexecuting_eagerlylogging log_first_nWARNrconvert_variables_to_tensorsrr9len ValueErrorformatr type_spec_from_value_most_general_type_spec_unbatch_dtype_to_specr name_scopevsget_variable_scopecaching_deviceset_caching_deviceconvert_to_tensor_or_compositehasattrr,ndims_elems_flat_to_batchabler Dimensiondimension_value get_shapewith_rank_at_leastassert_is_compatible_withrGr r TensorArrayrr;unstackrconstant/_result_flat_signature_to_batchable_tensor_specappendrstack set_shape TensorShape concatenate_result_batchable_to_flat)'rKr rrRrSrTr/r+r% in_graph_mode elems_flateresult_unflattendvarscope varscope_caching_device_was_nonet first_elemelems_static_shapeelems_batchablen_statictensorr?r=result_batchable_tensor_specresult_batchable_taspecrMrPr_arresult_batchable result_flatresultrHrIrJrQrLs'`` ` @@@@@r!rr)sn   " ,R[[M:++ ,,//11-. !4 014      5 5e <%||E"* _  66 result_batchable_tensor_specs.zmap_fn can not generate z outputs)rr BatchableTypeSpecrWextend_flat_tensor_specs)rL tensor_specsrs r!rvrvsP,#1d dI77 8 dD EE//01 r#cg}|D]b}tj|}t|tjst d|d||j |j |d|S)z'Converts elems_flat -> elems_batchable.zmap_fn can not consume z inputs: got )r rarrrWr_to_batched_tensor_list)r~r elems_tensorrs r!rmrm)sr/ Gl  ) ), 7D dI77 8 \+ ,,477 EF G r#cg}d}|D][}|j}|||t|jz}|j|j ||t|z }]|t|k(sJ|S)z3Converts elems_value_batchable -> elems_value_flat.r)rcr^rrw_from_compatible_tensor_list)r@rIrAr=r tensor_lists r!r3r36s!"d ==?D'!c$2I2I.J*JKKD==kJK[ A  c'( (( ( r#c <g}t||D]\}}t|tjr|j |2|j |s(t d|dtj|d|d|j|j||S)z5Converts result_value_flat -> result_value_batchable.z2Error in map_fn: Expected `fn` to return a: z But it returned a: z (value=zO) To fix, update the `fn_output_signature` (or `dtype`) argument to `map_fn`.) r;rr rrwis_compatible_withr_r rar_to_tensor_list)rErLrFr_valuer_specs r!r:r:Ds02GH Ew&+001##G,  & &w / Y33G result_flat.r)r^rrw_batchr)rrL batch_sizerr=r num_tensorss r!r|r|Vs+!#dd--.K J<< Qq; / 12A  c"# ## # r#zback_prop=False is deprecated. Consider using tf.stop_gradient instead. Instead of: results = tf.map_fn(fn, elems, back_prop=False) Use: results = tf.nest.map_structure(tf.stop_gradient, tf.map_fn(fn, elems))) warn_oncerSc 0||}t||||||||S)zGTransform `elems` by applying `fn` to each element unstacked on axis 0.)rKr r%rRrSrTr/r+)r) rKr rrRrSrTr/r+r%s r! map_fn_v2rfs5*   --  r#z ( back_prop: \(optional\) )(.*)z:\1Deprecated: prefer using `tf.stop_gradient` instead. \2z'prefer using `tf.stop_gradient` instead)NNTFTNN),__doc__re tensorflow.python.autograph.corerr4 tensorflow.python.autograph.implrr6tensorflow.python.eagerrtensorflow.python.frameworkrrrr r r tensorflow.python.opsr r rrfrtensorflow.python.platformrrZtensorflow.python.utilrrr tensorflow.python.util.tf_exportrdeprecated_argsrrdrbrvrmr3r:r|deprecated_arg_valuesrsubrOr#r!rse  D=+83+431+26,<.'16 xjT#DgN##]O]@    $   8"""K T#DgN"&"&O0BFF'A NN 1I4E4EEEEr#