AVhdZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z dd l dd l m Z dd l mZdd lmZ d4d Zd5dZd6dZd7dZedgd8dZedgd8dZedgd9dZedgeddd7dZedgd:dZedgd:dZed gd;d!Zed"gd;d#Zed$gd;d%Zed&gd;d'Zed(gd;d)Zed*gd;d+Z ed,gd;d-Z!ed.gd;d/Z"ed0ge jd1d2d:d3Z#y)//1 L3L L1q{{},,.0B0BC%''G<%%%aU; ; ; ; ; ; ;&&t&9$%%aE: ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;sTFE1BE5 E1> F.E? E1 FE$ E1( F1E: 6FFNc|jjrtj||S|j |S)a<Checks whether a tensor has been initialized. Outputs boolean scalar indicating whether the tensor has been initialized. Args: ref: A mutable `Tensor`. Should be from a `Variable` node. May be uninitialized. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. refrr")r _is_ref_dtyperis_variable_initializedis_initializedr2s rr5r5rs8 YY  0 0St DD    &&r assign_sub)v1c|jjrtj||||S|j|S)a; Update `ref` by subtracting `value` from it. This operation outputs `ref` after the update is done. This makes it easier to chain operations that need to use the reset value. Unlike `tf.math.subtract`, this op does not broadcast. `ref` and `value` must have the same shape. Args: ref: A mutable `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`. Should be from a `Variable` node. value: A `Tensor`. Must have the same shape and dtype as `ref`. The value to be subtracted to the variable. use_locking: An optional `bool`. Defaults to `False`. If True, the subtraction will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: Same as `ref`. Returned as a convenience for operations that want to use the new value after the variable has been updated. @compatibility(TF2) `tf.compat.v1.assign_sub` is mostly compatible with eager execution and `tf.function`. To switch to the native TF2 style, one could use method 'assign_sub' of `tf.Variable`: #### How to Map Arguments | TF1 Arg Name | TF2 Arg Name | Note | | :-------------------- | :-------------- | :------------------------- | | `ref` | `self` | In `assign_sub()` method | | `value` | `value` | In `assign_sub()` method | | `use_locking` | `use_locking` | In `assign_sub()` method | | `name` | `name` | In `assign_sub()` method | | - | `read_value` | Set to True to replicate | : : : behavior (True is default) : #### Before & After Usage Example Before: >>> with tf.Graph().as_default(): ... with tf.compat.v1.Session() as sess: ... a = tf.compat.v1.Variable(1, dtype=tf.int64) ... sess.run(a.initializer) ... update_op = tf.compat.v1.assign_sub(a, 1) ... res_a = sess.run(update_op) ... print(res_a) 0 After: >>> b = tf.Variable(1, dtype=tf.int64) >>> res_b = b.assign_sub(1) >>> res_b.numpy().item() 0 @end_compatibility  use_lockingr)rr4rr7r3r!r;rs rr7r7=D YY  # # U $ 88  r assign_addc|jjrtj||||S|j|S)a' Update `ref` by adding `value` to it. This operation outputs `ref` after the update is done. This makes it easier to chain operations that need to use the reset value. Unlike `tf.math.add`, this op does not broadcast. `ref` and `value` must have the same shape. Args: ref: A mutable `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`. Should be from a `Variable` node. value: A `Tensor`. Must have the same shape and dtype as `ref`. The value to be added to the variable. use_locking: An optional `bool`. Defaults to `False`. If True, the addition will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: Same as `ref`. Returned as a convenience for operations that want to use the new value after the variable has been updated. @compatibility(TF2) `tf.compat.v1.assign_add` is mostly compatible with eager execution and `tf.function`. To switch to the native TF2 style, one could use method 'assign_add' of `tf.Variable`: #### How to Map Arguments | TF1 Arg Name | TF2 Arg Name | Note | | :-------------------- | :-------------- | :------------------------- | | `ref` | `self` | In `assign_add()` method | | `value` | `value` | In `assign_add()` method | | `use_locking` | `use_locking` | In `assign_add()` method | | `name` | `name` | In `assign_add()` method | | - | `read_value` | Set to True to replicate | : : : behavior (True is default) : #### Before & After Usage Example Before: >>> with tf.Graph().as_default(): ... with tf.compat.v1.Session() as sess: ... a = tf.compat.v1.Variable(0, dtype=tf.int64) ... sess.run(a.initializer) ... update_op = tf.compat.v1.assign_add(a, 1) ... res_a = sess.run(update_op) ... print(res_a) 1 After: >>> b = tf.Variable(0, dtype=tf.int64) >>> res_b = b.assign_add(1) >>> res_b.numpy().item() 1 @end_compatibility r:)rr4rr>r<s rr>r>r=rr-c|jjrtj|||||S|j||S)a Update `ref` by assigning `value` to it. This operation outputs a Tensor that holds the new value of `ref` after the value has been assigned. This makes it easier to chain operations that need to use the reset value. Args: ref: A mutable `Tensor`. Should be from a `Variable` node. May be uninitialized. value: A `Tensor`. Must have the same shape and dtype as `ref`. The value to be assigned to the variable. validate_shape: An optional `bool`. Defaults to `True`. If true, the operation will validate that the shape of 'value' matches the shape of the Tensor being assigned to. If false, 'ref' will take on the shape of 'value'. use_locking: An optional `bool`. Defaults to `True`. If True, the assignment will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: A `Tensor` that will hold the new value of `ref` after the assignment has completed. @compatibility(TF2) `tf.compat.v1.assign` is mostly compatible with eager execution and `tf.function`. However, argument 'validate_shape' will be ignored. To avoid shape validation, set 'shape' to tf.TensorShape(None) when constructing the variable: >>> import tensorflow as tf >>> a = tf.Variable([1], shape=tf.TensorShape(None)) >>> tf.compat.v1.assign(a, [2,3]) To switch to the native TF2 style, one could use method 'assign' of `tf.Variable`: #### How to Map Arguments | TF1 Arg Name | TF2 Arg Name | Note | | :-------------------- | :-------------- | :------------------------- | | `ref` | `self` | In `assign()` method | | `value` | `value` | In `assign()` method | | `validate_shape` | Not supported | Specify `shape` in the | : : : constructor to replicate : : : : behavior : | `use_locking` | `use_locking` | In `assign()` method | | `name` | `name` | In `assign()` method | | - | `read_value` | Set to True to replicate | : : : behavior (True is default) : @end_compatibility #### Before & After Usage Example Before: >>> with tf.Graph().as_default(): ... with tf.compat.v1.Session() as sess: ... a = tf.compat.v1.Variable(0, dtype=tf.int64) ... sess.run(a.initializer) ... update_op = tf.compat.v1.assign(a, 2) ... res_a = sess.run(update_op) ... print(res_a) 2 After: >>> b = tf.Variable(0, dtype=tf.int64) >>> res_b = b.assign(2) >>> res_b.numpy().item() 2 )r;rvalidate_shaper")rr4rr-)r3r!rAr;rs rr-r-sFV YY    U $% '' E %%r count_up_tozPrefer Dataset.range instead.c|jjrtj|||Stj|j ||j|S)a Increments 'ref' until it reaches 'limit'. Args: ref: A Variable. Must be one of the following types: `int32`, `int64`. Should be from a scalar `Variable` node. limit: An `int`. If incrementing ref would bring it above limit, instead generates an 'OutOfRange' error. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `ref`. A copy of the input before increment. If nothing else modifies the input, the values produced will all be distinct. )limitr)Tr)rr4rrBresource_count_up_tohandle)r3rDrs rrBrBgsJ$ YY  $ $SD AA  + + jj%3994 11rscatter_updatec |jjrtj|||||S|j t j |j|tj||j|S)aApplies sparse updates to a variable reference. This operation computes ```python # Scalar indices ref[indices, ...] = updates[...] # Vector indices (for each i) ref[indices[i], ...] = updates[i, ...] # High rank indices (for each i, ..., j) ref[indices[i, ..., j], ...] = updates[i, ..., j, ...] ``` This operation outputs `ref` after the update is done. This makes it easier to chain operations that need to use the reset value. If values in `ref` is to be updated more than once, because there are duplicate entries in `indices`, the order at which the updates happen for each value is undefined. Requires `updates.shape = indices.shape + ref.shape[1:]`.
Args: ref: A `Variable`. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor of indices into the first dimension of `ref`. updates: A `Tensor`. Must have the same type as `ref`. A tensor of updated values to store in `ref`. use_locking: An optional `bool`. Defaults to `True`. If True, the assignment will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: Same as `ref`. Returned as a convenience for operations that want to use the updated values after the update is done. r:r") rr4rrH _lazy_readrresource_scatter_updaterGrr,r3indicesupdatesr;rs rrHrHsp\ YY  ' 'Wg4?d LL 1II jj'300#))D  rscatter_nd_updatec |jjrtj|||||S|j tj |j |tj||j|S)a+Applies sparse `updates` to individual values or slices in a Variable. `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`. `indices` must be integer tensor, containing indices into `ref`. It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`. The innermost dimension of `indices` (with length `K`) corresponds to indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th dimension of `ref`. `updates` is `Tensor` of rank `Q-1+P-K` with shape: ``` [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]. ``` For example, say we want to update 4 scattered elements to a rank-1 tensor to 8 elements. In Python, that update would look like this: ```python ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8]) indices = tf.constant([[4], [3], [1] ,[7]]) updates = tf.constant([9, 10, 11, 12]) update = tf.compat.v1.scatter_nd_update(ref, indices, updates) with tf.compat.v1.Session() as sess: print sess.run(update) ``` The resulting update to ref would look like this: [1, 11, 3, 10, 9, 6, 7, 12] See `tf.scatter_nd` for more details about how to make updates to slices. Args: ref: A Variable. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor of indices into ref. updates: A `Tensor`. Must have the same type as `ref`. A Tensor. Must have the same type as ref. A tensor of updated values to add to ref. use_locking: An optional `bool`. Defaults to `True`. An optional bool. Defaults to True. If True, the assignment will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: The value of the variable after the update. r") rr4rrOrJresource_scatter_nd_updaterGrr,rLs rrOrOsml YY  * * Wg{D 22  @@ jj'300#))D  r scatter_addc |jjrtj|||||S|j t j |j|tj||j|S)aAdds sparse updates to the variable referenced by `resource`. This operation computes ```python # Scalar indices ref[indices, ...] += updates[...] # Vector indices (for each i) ref[indices[i], ...] += updates[i, ...] # High rank indices (for each i, ..., j) ref[indices[i, ..., j], ...] += updates[i, ..., j, ...] ``` This operation outputs `ref` after the update is done. This makes it easier to chain operations that need to use the updated value. Duplicate entries are handled correctly: if multiple `indices` reference the same location, their contributions add. Requires `updates.shape = indices.shape + ref.shape[1:]`.
Args: ref: A `Variable`. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor of indices into the first dimension of `ref`. updates: A `Tensor`. Must have the same type as `ref`. A tensor of updated values to store in `ref`. use_locking: An optional `bool`. Defaults to `False`. If True, the assignment will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: Same as `ref`. Returned as a convenience for operations that want to use the updated values after the update is done. r:r") rr4rrRrJrresource_scatter_addrGrr,rLs rrRrRpX YY  $ $S'71<4 II 1FF jj'300#))D  rscatter_nd_addc |jjrtj|||||S|j tj |j |tj||j|S)aApplies sparse addition to individual values or slices in a Variable. `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`. `indices` must be integer tensor, containing indices into `ref`. It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`. The innermost dimension of `indices` (with length `K`) corresponds to indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th dimension of `ref`. `updates` is `Tensor` of rank `Q-1+P-K` with shape: ``` [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]] ``` For example, say we want to add 4 scattered elements to a rank-1 tensor to 8 elements. In Python, that addition would look like this: ```python ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8]) indices = tf.constant([[4], [3], [1], [7]]) updates = tf.constant([9, 10, 11, 12]) add = tf.compat.v1.scatter_nd_add(ref, indices, updates) with tf.compat.v1.Session() as sess: print sess.run(add) ``` The resulting update to ref would look like this: [1, 13, 3, 14, 14, 6, 7, 20] See `tf.scatter_nd` for more details about how to make updates to slices. Args: ref: A mutable `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. A mutable Tensor. Should be from a Variable node. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor of indices into ref. updates: A `Tensor`. Must have the same type as `ref`. A tensor of updated values to add to ref. use_locking: An optional `bool`. Defaults to `False`. If True, the assignment will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. r") rr4rrVrJresource_scatter_nd_addrGrr,rLs rrVrV'smn YY  ' ' Wg{D 22  == jj'300#))D  r scatter_subc |jjrtj|||||S|j t j |j|tj||j|S)aSubtracts sparse updates to a variable reference. ```python # Scalar indices ref[indices, ...] -= updates[...] # Vector indices (for each i) ref[indices[i], ...] -= updates[i, ...] # High rank indices (for each i, ..., j) ref[indices[i, ..., j], ...] -= updates[i, ..., j, ...] ``` This operation outputs `ref` after the update is done. This makes it easier to chain operations that need to use the reset value. Duplicate entries are handled correctly: if multiple `indices` reference the same location, their (negated) contributions add. Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
Args: ref: A mutable `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. Should be from a `Variable` node. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor of indices into the first dimension of `ref`. updates: A `Tensor`. Must have the same type as `ref`. A tensor of updated values to subtract from `ref`. use_locking: An optional `bool`. Defaults to `False`. If True, the subtraction will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. r:r") rr4rrYrJrresource_scatter_subrGrr,rLs rrYrYfsp\ YY  $ $S'71<4 II 1FF jj'300#))D  rscatter_nd_subc |jjrtj|||||S|j tj |j |tj||j|S)aApplies sparse subtraction to individual values or slices in a Variable. `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`. `indices` must be integer tensor, containing indices into `ref`. It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`. The innermost dimension of `indices` (with length `K`) corresponds to indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th dimension of `ref`. `updates` is `Tensor` of rank `Q-1+P-K` with shape: ``` [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]] ``` For example, say we want to subtract 4 scattered elements from a rank-1 tensor with 8 elements. In Python, that update would look like this: ```python ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8]) indices = tf.constant([[4], [3], [1] ,[7]]) updates = tf.constant([9, 10, 11, 12]) op = tf.compat.v1.scatter_nd_sub(ref, indices, updates) with tf.compat.v1.Session() as sess: print sess.run(op) ``` The resulting update to ref would look like this: [1, -9, 3, -6, -6, 6, 7, -4] See `tf.scatter_nd` for more details about how to make updates to slices. Args: ref: A mutable `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. A mutable Tensor. Should be from a Variable node. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor of indices into ref. updates: A `Tensor`. Must have the same type as `ref`. A tensor of updated values to add to ref. use_locking: An optional `bool`. Defaults to `False`. An optional bool. Defaults to True. If True, the assignment will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. r") rr4rr\rJresource_scatter_nd_subrGrr,rLs rr\r\smp YY  ' ' Wg{D 22  == jj'300#))D  r scatter_mulc |jjrtj|||||S|j t j |j|tj||j|S)aMultiplies sparse updates into a variable reference. This operation computes ```python # Scalar indices ref[indices, ...] *= updates[...] # Vector indices (for each i) ref[indices[i], ...] *= updates[i, ...] # High rank indices (for each i, ..., j) ref[indices[i, ..., j], ...] *= updates[i, ..., j, ...] ``` This operation outputs `ref` after the update is done. This makes it easier to chain operations that need to use the reset value. Duplicate entries are handled correctly: if multiple `indices` reference the same location, their contributions multiply. Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`. Args: ref: A mutable `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. Should be from a `Variable` node. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor of indices into the first dimension of `ref`. updates: A `Tensor`. Must have the same type as `ref`. A tensor of updated values to multiply to `ref`. use_locking: An optional `bool`. Defaults to `False`. If True, the operation will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. r:r") rr4rr_rJrresource_scatter_mulrGrr,rLs rr_r_rUr scatter_divc |jjrtj|||||S|j t j |j|tj||j|S)aDivides a variable reference by sparse updates. This operation computes ```python # Scalar indices ref[indices, ...] /= updates[...] # Vector indices (for each i) ref[indices[i], ...] /= updates[i, ...] # High rank indices (for each i, ..., j) ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...] ``` This operation outputs `ref` after the update is done. This makes it easier to chain operations that need to use the reset value. Duplicate entries are handled correctly: if multiple `indices` reference the same location, their contributions divide. Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`. Args: ref: A mutable `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. Should be from a `Variable` node. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor of indices into the first dimension of `ref`. updates: A `Tensor`. Must have the same type as `ref`. A tensor of values that `ref` is divided by. use_locking: An optional `bool`. Defaults to `False`. If True, the operation will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. r:r") rr4rrbrJrresource_scatter_divrGrr,rLs rrbrbrUr scatter_maxc |jjrtj|||||S|j t j |j|tj||j|S)aReduces sparse updates into a variable reference using the `max` operation. This operation computes # Scalar indices ref[indices, ...] = max(ref[indices, ...], updates[...]) # Vector indices (for each i) ref[indices[i], ...] = max(ref[indices[i], ...], updates[i, ...]) # High rank indices (for each i, ..., j) ref[indices[i, ..., j], ...] = max(ref[indices[i, ..., j], ...], updates[i, ..., j, ...]) This operation outputs `ref` after the update is done. This makes it easier to chain operations that need to use the reset value. Duplicate entries are handled correctly: if multiple `indices` reference the same location, their contributions combine. Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
Args: ref: A mutable `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`, `int32`, `int64`. Should be from a `Variable` node. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor of indices into the first dimension of `ref`. updates: A `Tensor`. Must have the same type as `ref`. A tensor of updated values to reduce into `ref`. use_locking: An optional `bool`. Defaults to `False`. If True, the update will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. r:r") rr4rrerJrresource_scatter_maxrGrr,rLs rrereDp^ YY  $ $S'71<4 II 1FF jj'300#))D  r scatter_minc |jjrtj|||||S|j t j |j|tj||j|S)aReduces sparse updates into a variable reference using the `min` operation. This operation computes # Scalar indices ref[indices, ...] = min(ref[indices, ...], updates[...]) # Vector indices (for each i) ref[indices[i], ...] = min(ref[indices[i], ...], updates[i, ...]) # High rank indices (for each i, ..., j) ref[indices[i, ..., j], ...] = min(ref[indices[i, ..., j], ...], updates[i, ..., j, ...]) This operation outputs `ref` after the update is done. This makes it easier to chain operations that need to use the reset value. Duplicate entries are handled correctly: if multiple `indices` reference the same location, their contributions combine. Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
Args: ref: A mutable `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `float64`, `int32`, `int64`. Should be from a `Variable` node. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A tensor of indices into the first dimension of `ref`. updates: A `Tensor`. Must have the same type as `ref`. A tensor of updated values to reduce into `ref`. use_locking: An optional `bool`. Defaults to `False`. If True, the update will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. r:r") rr4rrirJrresource_scatter_minrGrr,rLs rriri{rhrbatch_scatter_updatez 2018-11-29z8Use the batch_scatter_update method of Variable instead.c tj|5tj|d}tj|}|j j }| tdtj|d}g}t|dz D]} || } dg|dzz} | | | <tjtjd| d| } | jj|jk7r tj| |j} |j!| tj"|z|j!|tj$|d} t'|| || cdddS#1swYyxYw) aUGeneralization of `tf.compat.v1.scatter_update` to axis different than 0. Analogous to `batch_gather`. This assumes that `ref`, `indices` and `updates` have a series of leading dimensions that are the same for all of them, and the updates are performed on the last dimension of indices. In other words, the dimensions should be the following: `num_prefix_dims = indices.ndims - 1` `batch_dim = num_prefix_dims + 1` `updates.shape = indices.shape + var.shape[batch_dim:]` where `updates.shape[:num_prefix_dims]` `== indices.shape[:num_prefix_dims]` `== var.shape[:num_prefix_dims]` And the operation performed can be expressed as: `var[i_1, ..., i_n, indices[i_1, ..., i_n, j]] = updates[i_1, ..., i_n, j]` When indices is a 1D tensor, this operation is equivalent to `tf.compat.v1.scatter_update`. To avoid this operation there would be 2 alternatives: 1) Reshaping the variable by merging the first `ndims` dimensions. However, this is not possible because `tf.reshape` returns a Tensor, which we cannot use `tf.compat.v1.scatter_update` on. 2) Looping over the first `ndims` of the variable and using `tf.compat.v1.scatter_update` on the subtensors that result of slicing the first dimension. This is a valid option for `ndims = 1`, but less efficient than this implementation. See also `tf.compat.v1.scatter_update` and `tf.compat.v1.scatter_nd_update`. Args: ref: `Variable` to scatter onto. indices: Tensor containing indices as described above. updates: Tensor of updates to apply to `ref`. use_locking: Boolean indicating whether to lock the writing operation. name: Optional scope name string. Returns: Ref to `variable` after it has been modified. Raises: ValueError: If the initial `ndims` of `ref`, `indices`, and `updates` are not the same. rMr"Nz7batch_gather does not allow indices with unknown shape.)axisr)r;)rr$r,rrr(ndims ValueError expand_dimsrangereshaper_rangerr+castappend ones_likeconcatrO)r3rMrNr;r indices_shapeindices_dimensions nd_indicesnd_indices_list dimensiondimension_sizeshape_to_broadcastdimension_range final_indicess rrlrlsl ~~d+>##G)M  ]G >U+>+>+>s EE>>F)VariableTr)rrr)r#)N)NN)NNN)TN)FN)$__doc__tensorflow.python.frameworkrrtensorflow.python.opsrrrrr #tensorflow.python.ops.gen_state_opstensorflow.python.utilr "tensorflow.python.util.deprecationr tensorflow.python.util.tf_exportr rrr0r5r7r>r-rBrHrOrRrVrYr\r_rbrerirlrrrs/  ,4+.;/,2.96JL  6 ;F'& |nDDN |nDDN xjN&N&b }o D12131,  !2"2j "#$:%:z }o00f  !;";| }o22j  !<"<~ }o00f }o00f }o33l }o33l %&'LN^>N(^>r