AVhdZddlmZddlmZddlmZddlmZedejd dZ edejd d Z y ) z(Operations to stack and unstack tensors.)ops) gen_array_ops)dispatch) tf_exportstackc R|dk(r tj||Stj|d|j }|/t |dz}|| ks||k\rtd|d| d|dtj|||S#tttf$rYwxYw) aStacks a list of rank-`R` tensors into one rank-`(R+1)` tensor. See also `tf.concat`, `tf.tile`, `tf.repeat`. Packs the list of tensors in `values` into a tensor with rank one higher than each tensor in `values`, by packing them along the `axis` dimension. Given a list of length `N` of tensors of shape `(A, B, C)`; if `axis == 0` then the `output` tensor will have the shape `(N, A, B, C)`. if `axis == 1` then the `output` tensor will have the shape `(A, N, B, C)`. Etc. For example: >>> x = tf.constant([1, 4]) >>> y = tf.constant([2, 5]) >>> z = tf.constant([3, 6]) >>> tf.stack([x, y, z]) >>> tf.stack([x, y, z], axis=1) This is the opposite of unstack. The numpy equivalent is `np.stack` >>> np.array_equal(np.stack([x, y, z]), tf.stack([x, y, z])) True Args: values: A list of `Tensor` objects with the same shape and type. axis: An `int`. The axis to stack along. Defaults to the first dimension. Negative values wrap around, so the valid range is `[-(R+1), R+1)`. name: A name for this operation (optional). Returns: output: A stacked `Tensor` with the same type as `values`. Raises: ValueError: If `axis` is out of the range [-(R+1), R+1). r)nameArgument `axis` =  not in range [, ))axisr ) rconvert_to_tensor TypeError ValueErrorNotImplementedError _shape_tuplelenrpack)valuesrr value_shapeexpanded_num_dimss U/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/array_ops_stack.pyrrs^ QY  " "6 55%%fQid;HHJ+K(1,    D,=$= +D62--.b1B0C1F GG   FD 99 z#6 7   sBB&%B&unstackNc ~|tj|}|j}|jb||j ks||jk\r*t d|d|j d|jd|j |j }|t d|tj||||S)a Unpacks the given dimension of a rank-`R` tensor into rank-`(R-1)` tensors. Unpacks tensors from `value` by chipping it along the `axis` dimension. >>> x = tf.reshape(tf.range(12), (3,4)) >>> >>> p, q, r = tf.unstack(x) >>> p.shape.as_list() [4] >>> i, j, k, l = tf.unstack(x, axis=1) >>> i.shape.as_list() [3] This is the opposite of stack. >>> x = tf.stack([i, j, k, l], axis=1) More generally if you have a tensor of shape `(A, B, C, D)`: >>> A, B, C, D = [2, 3, 4, 5] >>> t = tf.random.normal(shape=[A, B, C, D]) The number of tensor returned is equal to the length of the target `axis`: >>> axis = 2 >>> items = tf.unstack(t, axis=axis) >>> len(items) == t.shape[axis] True The shape of each result tensor is equal to the shape of the input tensor, with the target `axis` removed. >>> items[0].shape.as_list() # [A, B, D] [2, 3, 5] The value of each tensor `items[i]` is equal to the slice of `input` across `axis` at index `i`: >>> for i in range(len(items)): ... slice = t[:,:,i,:] ... assert tf.reduce_all(slice == items[i]) #### Python iterable unpacking With eager execution you _can_ unstack the 0th axis of a tensor using python's iterable unpacking: >>> t = tf.constant([1,2,3]) >>> a,b,c = t `unstack` is still necessary because Iterable unpacking doesn't work in a `@tf.function`: Symbolic tensors are not iterable. You need to use `tf.unstack` here: >>> @tf.function ... def bad(t): ... a,b,c = t ... return a >>> >>> bad(t) Traceback (most recent call last): ... OperatorNotAllowedInGraphError: ... >>> @tf.function ... def good(t): ... a,b,c = tf.unstack(t) ... return a >>> >>> print(good(t).numpy()) 1 #### Unknown shapes Eager tensors have concrete values, so their shape is always known. Inside a `tf.function` the symbolic tensors may have unknown shapes. If the length of `axis` is unknown `tf.unstack` will fail because it cannot handle an unknown number of tensors: >>> @tf.function(input_signature=[tf.TensorSpec([None], tf.float32)]) ... def bad(t): ... tensors = tf.unstack(t) ... return tensors[0] >>> >>> bad(tf.constant([1.0, 2.0, 3.0])) Traceback (most recent call last): ... ValueError: Cannot infer argument `num` from shape (None,) If you know the `axis` length you can pass it as the `num` argument. But this must be a constant value. If you actually need a variable number of tensors in a single `tf.function` trace, you will need to use exlicit loops and a `tf.TensorArray` instead. Args: value: A rank `R > 0` `Tensor` to be unstacked. num: An `int`. The length of the dimension `axis`. Automatically inferred if `None` (the default). axis: An `int`. The axis to unstack along. Defaults to the first dimension. Negative values wrap around, so the valid range is `[-R, R)`. name: A name for the operation (optional). Returns: The list of `Tensor` objects unstacked from `value`. Raises: ValueError: If `axis` is out of the range `[-R, R)`. ValueError: If `num` is unspecified and cannot be inferred. InvalidArgumentError: If `num` does not match the shape of `value`. r r r rz'Cannot infer argument `num` from shape )numrr ) rr get_shapendimsrdimsvaluerunpack)r!rrr rs rrrXsh [  ! !% (E//#K$ """ "dk.?.?&?-dV4)///0;3D3D2EQHI I   T " ( (c { @ N OO   e4d CC)rr)Nrr) __doc__tensorflow.python.frameworkrtensorflow.python.opsrtensorflow.python.utilr tensorflow.python.util.tf_exportradd_dispatch_supportrrr#rr+si /+/+6 7 ;:;:| 9 |D|Dr#