AVh;dZddlZddlmZddlmZddlmZddlm Z ddl m Z ddlmZdd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZm Z m!Z!ddl"m#Z#edZ$dde#e!e$fde#e!e$fde%de%de#e!e$ff dZ&edejNe&Z(de#e!e$fde#e!e$fde%de%de#e!e$ff dZ)eddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-Z*dde#e!e*fde#e!e*fde%de#e!e*ffd.Z+ed/ejNe+Z,de#e!e*fde#e!e*fde%de#e!e*ffd0Z-ed1dddddd d!d"d#d$d%d&d'd(d)d*d+d,d-Z.dde#e!e.fde#e!e.fde%de#e!e.ffd2Z/ed3ejNe/Z0de#e!e.fde#e!e.fde%de#e!e.ffd4Z1ed5d"d#Z2dde#e!e2fd6e3de#e!e2ffd7Z4ed8ejNe4Z5de#e!e2fd6e3de#e!e2ffd9Z6ed:Z7dde#e!e7fd;e8de#e!e7ffd<Z9ed=ejNe9Z:de#e!e7fd;e8de#e!e7ffd>Z;ed?ZedAejNe>Z?de#e!e+'88c~)6!QX QK' ""$3%%c*,<  !12M  /1F::L ,1 (' .zraw_ops.Assignctd)Nr9rA)r3r4r5r6r;ctxs rSassign_eager_fallbackrYNs]^^rUTV_AssignAdd_Trrrrrr r!r"r$r%r&r'r(r)r*r-r.r0r1ctjxstj}|j}|jr t d|d}t j |d}tjd||||\}}}}|dd} t jrHd|jdd|jdf} |j} t jd| | | | \} | S)avUpdate '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. Args: ref: A mutable `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. Should be from a `Variable` node. value: A `Tensor`. Must have the same type 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: A mutable `Tensor`. Has the same type as `ref`. Jassign_add op does not support eager execution. Arg 'output_ref' is a ref.NFr6 AssignAddr3r4r6r;r<r= r3r4r6r;rKrLrMrNrOrPrQrRs rS assign_addr`S&    0h..0$ #\\ c ddK""; >+'88E{O!QX QK' ""$3%%c*M  /1F::L \674 (' .rUzraw_ops.AssignAddctd)Nr\rWr3r4r6r;rXs rSassign_add_eager_fallbackrd}abbrUTV_AssignSub_Tctjxstj}|j}|jr t d|d}t j |d}tjd||||\}}}}|dd} t jrHd|jdd|jdf} |j} t jd| | | | \} | S)aUpdate '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. Args: ref: A mutable `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. Should be from a `Variable` node. value: A `Tensor`. Must have the same type 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: A mutable `Tensor`. Has the same type as `ref`. Jassign_sub op does not support eager execution. Arg 'output_ref' is a ref.NFr6 AssignSubr^r<r=r_s rS assign_subrjrarUzraw_ops.AssignSubctd)NrhrWrcs rSassign_sub_eager_fallbackrlrerUTV_CountUpTo_Tlimitctjxstj}|j}|jr t dt j |d}tjd|||\}}}}|dd}t jrHd|jdd|jdf} |j} t jd| | ||\}|S)aIncrements 'ref' until it reaches 'limit'. Args: ref: A mutable `Tensor`. 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`. Dcount_up_to op does not support eager execution. Arg 'ref' is a ref.rn CountUpTo)r3rnr;Nr<)r>rr?r@rArBmake_intrDrErF _get_attr_intrGrIrJ) r3rnr;rKrLrMrNrOrPrQrRs rS count_up_torts    0h..0$ #\\ ] ^^   E7 +%'88E6!QX QK' ""$s((13  %'F::L \674 (' .rUzraw_ops.CountUpToctd)NrprW)r3rnr;rXs rScount_up_to_eager_fallbackrv[\\rU) TV_DestroyTemporaryVariable_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2var_namectjxstj}|j}|jr t dt j |d}tjd|||\}}}}|dd}t jrHd|jdd|jdf} |j} t jd| | ||\}|S)aDestroys the temporary variable and returns its final value. Sets output to the value of the Tensor pointed to by 'ref', then destroys the temporary variable called 'var_name'. All other uses of 'ref' *must* have executed before this op. This is typically achieved by chaining the ref through each assign op, or by using control dependencies. Outputs the final value of the tensor pointed to by 'ref'. Args: ref: A mutable `Tensor`. A reference to the temporary variable tensor. var_name: A `string`. Name of the temporary variable, usually the name of the matching 'TemporaryVariable' op. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `ref`. Sdestroy_temporary_variable op does not support eager execution. Arg 'ref' is a ref.ryDestroyTemporaryVariable)r3ryr;Nr<)r>rr?r@rArBmake_strrDrErFrGget_attrrIrJ) r3ryr;rKrLrMrNrOrPrQrRs rSdestroy_temporary_variablers*    0h..0$ #\\ l mm   x 4('88"hTK!QX QK' ""$3%%c*Jll:&(F::L "L&'C (' .rUz raw_ops.DestroyTemporaryVariablectd)Nr{rW)r3ryr;rXs rS)destroy_temporary_variable_eager_fallbackrsjkkrU) TV_IsVariableInitialized_dtyperrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2cztjxstj}|j}|jr t dt j d||\}}}}|dd}tjr7d|jdf}|j} tjd| |||\}|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`. Pis_variable_initialized op does not support eager execution. Arg 'ref' is a ref.IsVariableInitialized)r3r;Ndtype) r>rr?r@rArDrErBrFrGrIrJ) r3r;rKrLrMrNrOrPrQrRs rSis_variable_initializedrs    0h..0$ #\\ i jj'88St5!QX QK' ""$s))'2 3F::L vw@ (' .rUzraw_ops.IsVariableInitializedctd)NrrW)r3r;rXs rS&is_variable_initialized_eager_fallbackr(sghhrUTV_ResourceCountUpTo_Tresourcer<c  tjxstj}|j}|jr t j |d||d|d|}|Stj|d}tj|d}t!j"d||||\}}} } | dd}tj$rHd| j'dd| j)df} | j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rY#wxYw)aIncrements variable pointed to by 'resource' until it reaches 'limit'. Args: resource: A `Tensor` of type `resource`. Should be from a scalar `Variable` node. limit: An `int`. If incrementing ref would bring it above limit, instead generates an 'OutOfRange' error. T: A `tf.DType` from: `tf.int32, tf.int64`. name: A name for the operation (optional). Returns: A `Tensor` of type `T`. ResourceCountUpTornr<N)rnr<r;rX)rrnr<r;)r>rr?r@rTFE_Py_FastPathExecute_core_NotOkStatusException_opsraise_from_not_ok_status_FallbackException#resource_count_up_to_eager_fallback_SymbolicExceptionrBrr make_typerDrErFrsrGrIrJ) rrnr<r;rKrLrPerMrNrOrQrRs rSresource_count_up_tor-s    0h..0$ #\\ 11 !47E3Kg n   E7 +%C !'88heqtM!QX QK' ""$s((13  %'F::L \67< (' .-  & &- ##At,,  # #    0 %14T;;  # #   s0DE#D>>EEE++FFzraw_ops.ResourceCountUpTocNtj|d}tj|d}tj|t j }|g}d|d|f}tjdd||||}tjrtjd||||\}|S)Nrnr<sResourceCountUpTorIattrsrXr;r) rBrrrrconvert_to_tensor_dtypesrrrFrJ)rrnr<r;rXrRrQrPs rSrr^s   E7 +%C !  # #Hg.>.> ?(, UC #&   11\#)s ?' ""$ \67< (' .rU) TV_ResourceScatterNdAdd_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2 TV_ResourceScatterNdAdd_Tindicesindicesupdatesbad_indices_policyc Ztjxstj}|j}|jr! t j |d||||d|d| }|S|d}tj|d}|d}tj|d}t!j"d||||||\} } } } | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYwxYw) 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], use_resource=True) indices = tf.constant([[4], [3], [1], [7]]) updates = tf.constant([9, 10, 11, 12]) add = tf.scatter_nd_add(ref, indices, updates) with tf.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 `Tensor` of type `resource`. A resource handle. Must be from a VarHandleOp. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A Tensor. Must be one of the following types: int32, int64. A tensor of indices into ref. updates: A `Tensor`. A Tensor. Must have the same type as ref. A tensor of 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. bad_indices_policy: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: The created Operation. ResourceScatterNdAddr6rNr6rr;rXTr3rrr6rr;)r>rr?r@rrrrrrr&resource_scatter_nd_add_eager_fallbackrrBrCr}rDrE r3rrr6rr;rKrLrPrrMrNrOs rSresource_scatter_nd_addrpRn    0h..0$ #\\ 11 $dC'{$8:LNgnK""; >+(();=QR'88C',73E%) +!QX *-  & &- ##At,,  # #    3 w[/dFF  # #   0B77C> C%%C>=C>DD*)D*zraw_ops.ResourceScatterNdAddc|d}tj|d}|d}tj|d}tj|g|g\}\}tj|g|tj tj g\}\}tj|tj}|||g} d|d|d|d|f} tjdd| | || } d} | S) NTr6rrr<TindicessResourceScatterNdAddrr rBrCr}args_to_matching_eagerrint32int64rrrr r3rrr6rr;rX_attr_T_attr_TindicesrRrQrPs rSrrK""; >+(();=QR 77 3K':G'>>y#PWP]P]_f_l_lOop.*7 sG$4$45#w(, *nm #%7 9&   4a #)s ?' ' .rU) TV_ResourceScatterNdMax_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2 TV_ResourceScatterNdMax_Tindicesc Ztjxstj}|j}|jr! t j |d||||d|d| }|S|d}tj|d}|d}tj|d}t!j"d||||||\} } } } | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYwxYw) a1TODO: add doc. Args: ref: A `Tensor` of type `resource`. A resource handle. Must be from a VarHandleOp. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A Tensor. Must be one of the following types: int32, int64. A tensor of indices into ref. updates: A `Tensor`. A Tensor. Must have the same type as ref. A tensor of values whose element wise max is taken with 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. bad_indices_policy: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: The created Operation. ResourceScatterNdMaxr6rNrTrr)r>rr?r@rrrrrrr&resource_scatter_nd_max_eager_fallbackrrBrCr}rDrErs rSresource_scatter_nd_maxrQ*    0h..0$ #\\ 11 $dC'{$8:LNgnK""; >+(();=QR'88C',73E%) +!QX *-  & &- ##At,,  # #    3 w[/dFF  # #   rzraw_ops.ResourceScatterNdMaxc|d}tj|d}|d}tj|d}tj|g|g\}\}tj|g|tj tj g\}\}tj|tj}|||g} d|d|d|d|f} tjdd| | || } d} | S) NTr6rrr<rsResourceScatterNdMaxrrrrs rSrrrrU) TV_ResourceScatterNdMin_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2 TV_ResourceScatterNdMin_Tindicesc Ztjxstj}|j}|jr! t j |d||||d|d| }|S|d}tj|d}|d}tj|d}t!j"d||||||\} } } } | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYwxYw) a2TODO: add doc. Args: ref: A `Tensor` of type `resource`. A resource handle. Must be from a VarHandleOp. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A Tensor. Must be one of the following types: int32, int64. A tensor of indices into ref. updates: A `Tensor`. A Tensor. Must have the same type as ref. A tensor of values whose element wise min is taken with 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. bad_indices_policy: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: The created Operation. ResourceScatterNdMinr6rNrTrr)r>rr?r@rrrrrrr&resource_scatter_nd_min_eager_fallbackrrBrCr}rDrErs rSresource_scatter_nd_minr,rrzraw_ops.ResourceScatterNdMinc|d}tj|d}|d}tj|d}tj|g|g\}\}tj|g|tj tj g\}\}tj|tj}|||g} d|d|d|d|f} tjdd| | || } d} | S) NTr6rrr<rsResourceScatterNdMinrrrrs rSrrcrrU) TV_ResourceScatterNdSub_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2 TV_ResourceScatterNdSub_Tindicesc Ztjxstj}|j}|jr! t j |d||||d|d| }|S|d}tj|d}|d}tj|d}t!j"d||||||\} } } } | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYwxYw) 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 subtraction would look like this: ```python ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True) indices = tf.constant([[4], [3], [1], [7]]) updates = tf.constant([9, 10, 11, 12]) sub = tf.scatter_nd_sub(ref, indices, updates) with tf.Session() as sess: print sess.run(sub) ``` The resulting update to ref would look like this: [1, -9, 3, -6, -4, 6, 7, -4] See `tf.scatter_nd` for more details about how to make updates to slices. Args: ref: A `Tensor` of type `resource`. A resource handle. Must be from a VarHandleOp. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A Tensor. Must be one of the following types: int32, int64. A tensor of indices into ref. updates: A `Tensor`. A Tensor. Must have the same type as ref. A tensor of 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. bad_indices_policy: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: The created Operation. ResourceScatterNdSubr6rNrTrr)r>rr?r@rrrrrrr&resource_scatter_nd_sub_eager_fallbackrrBrCr}rDrErs rSresource_scatter_nd_subryrrzraw_ops.ResourceScatterNdSubc|d}tj|d}|d}tj|d}tj|g|g\}\}tj|g|tj tj g\}\}tj|tj}|||g} d|d|d|d|f} tjdd| | || } d} | S) NTr6rrr<rsResourceScatterNdSubrrrrs rSrrrrU) TV_ResourceScatterNdUpdate_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2#TV_ResourceScatterNdUpdate_Tindicesc Ztjxstj}|j}|jr! t j |d||||d|d| }|S|d}tj|d}|d}tj|d}t!j"d||||||\} } } } | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYwxYw) aApplies sparse `updates` to individual values or slices within a given variable according to `indices`. `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.scatter_nd_update(ref, indices, updates) with tf.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 `Tensor` of type `resource`. A resource handle. Must be from a VarHandleOp. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. A Tensor. Must be one of the following types: int32, int64. A tensor of indices into ref. updates: A `Tensor`. 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. bad_indices_policy: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: The created Operation. ResourceScatterNdUpdater6rNrTrr)r>rr?r@rrrrrrr)resource_scatter_nd_update_eager_fallbackrrBrCr}rDrErs rSresource_scatter_nd_updatersRt    0h..0$ #\\ 11 'sGW{$8:LNgnK""; >+(();=QR'88!sGW/:6H(, .!QX *-  & &- ##At,,  # #    6 w[/dFF  # #   rzraw_ops.ResourceScatterNdUpdatec|d}tj|d}|d}tj|d}tj|g|g\}\}tj|g|tj tj g\}\}tj|tj}|||g} d|d|d|d|f} tjdd| | || } d} | S) NTr6rrr<rsResourceScatterNdUpdaterrrrs rSrrDsK""; >+(();=QR 77 3K':G'>>y#PWP]P]_f_l_lOop.*7 sG$4$45#w(, *nm #%7 9&   7$0C"& (' ' .rUTV_ScatterAdd_TTV_ScatterAdd_Tindicesctjxstj}|j}|jr t d|d}t j |d}tjd|||||\}}}} | dd} t jrYd|jdd|jdd|jdf} |j} t jd| | | | \} | S) aAdds sparse updates to a variable reference. This operation computes # 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 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`, `qint16`, `quint16`, `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 add to `ref`. 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: A mutable `Tensor`. Has the same type as `ref`. Kscatter_add op does not support eager execution. Arg 'output_ref' is a ref.NFr6 ScatterAddr3rrr6r;r<rr= r3rrr6r;rKrLrMrNrOrPrQrRs rS scatter_addr[R    0h..0$ #\\ d eeK""; >+'88#w"-D:!QX QK' ""$3%%c*J  ,m  /1F::L lFG5 (' .rUzraw_ops.ScatterAddctd)NrrWr3rrr6r;rXs rSscatter_add_eager_fallbackrbccrUTV_ScatterDiv_TTV_ScatterDiv_Tindicesctjxstj}|j}|jr t d|d}t j |d}tjd|||||\}}}} | dd} t jrYd|jdd|jdd|jdf} |j} t jd| | | | \} | 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`, `qint16`, `quint16`, `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`. Kscatter_div op does not support eager execution. Arg 'output_ref' is a ref.NFr6 ScatterDivrr<rr=rs rS scatter_divrN    0h..0$ #\\ d eeK""; >+'88#w"-D:!QX QK' ""$3%%c*J  ,m  /1F::L lFG5 (' .rUzraw_ops.ScatterDivctd)NrrWrs rSscatter_div_eager_fallbackrrrUTV_ScatterMax_TTV_ScatterMax_Tindicesctjxstj}|j}|jr t d|d}t j |d}tjd|||||\}}}} | dd} t jrYd|jdd|jdd|jdf} |j} t jd| | | | \} | 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`. Kscatter_max op does not support eager execution. Arg 'output_ref' is a ref.NFr6 ScatterMaxrr<rr=rs rS scatter_maxrrrUzraw_ops.ScatterMaxctd)NrrWrs rSscatter_max_eager_fallbackr+rrUTV_ScatterMin_TTV_ScatterMin_Tindicesctjxstj}|j}|jr t d|d}t j |d}tjd|||||\}}}} | dd} t jrYd|jdd|jdd|jdf} |j} t jd| | | | \} | 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`. Kscatter_min op does not support eager execution. Arg 'output_ref' is a ref.NFr6 ScatterMinrr<rr=rs rS scatter_minr1rrUzraw_ops.ScatterMinctd)NrrWrs rSscatter_min_eager_fallbackrsrrUTV_ScatterMul_TTV_ScatterMul_Tindicesctjxstj}|j}|jr t d|d}t j |d}tjd|||||\}}}} | dd} t jrYd|jdd|jdd|jdf} |j} t jd| | | | \} | S) a Multiplies 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`, `qint16`, `quint16`, `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`. Kscatter_mul op does not support eager execution. Arg 'output_ref' is a ref.NFr6 ScatterMulrr<rr=rs rS scatter_mulryrrUzraw_ops.ScatterMulctd)NrrWrs rSscatter_mul_eager_fallbackrrrUTV_ScatterNdAdd_TTV_ScatterNdAdd_Tindicesc Ptjxstj}|j}|jr t d|d}t j |d}|d}t j|d}tjd||||||\}}} } | dd} t jrjd | jd d | jd d| jdd| jdf} | j} t jd| | | | \} | 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.scatter_nd_add(ref, indices, updates) with tf.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`, `qint16`, `quint16`, `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. 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 `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. bad_indices_policy: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. Nscatter_nd_add op does not support eager execution. Arg 'output_ref' is a ref.NFr6rr ScatterNdAddrr<rr>rr?r@rArBrCr}rDrErFrGrHr~rIrJr3rrr6rr;rKrLrMrNrOrPrQrRs rSscatter_nd_addr s1p    0h..0$ #\\ g hhK""; >+(();=QR'88C'$/+=DJ!QX QK' ""$3%%c*J  ,m  /1Ell/02F::L  fg7 (' .rUzraw_ops.ScatterNdAddctd)NrrWr3rrr6rr;rXs rSscatter_nd_add_eager_fallbackr effrUTV_ScatterNdMax_TTV_ScatterNdMax_Tindicesc Ptjxstj}|j}|jr t d|d}t j |d}|d}t j|d}tjd||||||\}}} } | dd} t jrjd | jd d | jd d| jdd| jdf} | j} t jd| | | | \} | S) aNComputes element-wise maximum. Args: ref: A mutable `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `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. 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 `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. bad_indices_policy: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. Nscatter_nd_max op does not support eager execution. Arg 'output_ref' is a ref.NFr6rr ScatterNdMaxrr<rrr s rSscatter_nd_maxr0,    0h..0$ #\\ g hhK""; >+(();=QR'88C'$/+=DJ!QX QK' ""$3%%c*J  ,m  /1Ell/02F::L  fg7 (' .rUzraw_ops.ScatterNdMaxctd)NrrWr s rSscatter_nd_max_eager_fallbackrOrrUTV_ScatterNdMin_TTV_ScatterNdMin_Tindicesc Ptjxstj}|j}|jr t d|d}t j |d}|d}t j|d}tjd||||||\}}} } | dd} t jrjd | jd d | jd d| jdd| jdf} | j} t jd| | | | \} | S) aNComputes element-wise minimum. Args: ref: A mutable `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `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. 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 `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. bad_indices_policy: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. Nscatter_nd_min op does not support eager execution. Arg 'output_ref' is a ref.NFr6rr ScatterNdMinrr<rrr s rSscatter_nd_minrUrrUzraw_ops.ScatterNdMinctd)NrrWr s rSscatter_nd_min_eager_fallbackrrrUTV_ScatterNdSub_TTV_ScatterNdSub_Tindicesc Ptjxstj}|j}|jr t d|d}t j |d}|d}t j|d}tjd||||||\}}} } | dd} t jrjd | jd d | jd d| jdd| jdf} | j} t jd| | | | \} | S) aApplies sparse subtraction to individual values or slices in a Variable. within a given variable according to `indices`. `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 subtraction 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]) sub = tf.scatter_nd_sub(ref, indices, updates) with tf.Session() as sess: print sess.run(sub) ``` The resulting update to ref would look like this: [1, -9, 3, -6, -4, 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`, `qint16`, `quint16`, `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. 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 subtract from 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. bad_indices_policy: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. Nscatter_nd_sub op does not support eager execution. Arg 'output_ref' is a ref.NFr6rr ScatterNdSubrr<rrr s rSscatter_nd_subr%s1t    0h..0$ #\\ g hhK""; >+(();=QR'88C'$/+=DJ!QX QK' ""$3%%c*J  ,m  /1Ell/02F::L  fg7 (' .rUzraw_ops.ScatterNdSubctd)Nr#rWr s rSscatter_nd_sub_eager_fallbackr'rrU) TV_ScatterNdUpdate_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2TV_ScatterNdUpdate_Tindicesc Ptjxstj}|j}|jr t d|d}t j |d}|d}t j|d}tjd||||||\}}} } | dd} t jrjd | jd d | jd d| jdd| jdf} | j} t jd| | | | \} | S) a6Applies sparse `updates` to individual values or slices within a given variable according to `indices`. `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.scatter_nd_update(ref, indices, updates) with tf.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. See also `tf.scatter_update` and `tf.batch_scatter_update`. Args: ref: A mutable `Tensor`. A mutable Tensor. Should be from a Variable node. indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. 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. bad_indices_policy: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A mutable `Tensor`. Has the same type as `ref`. Qscatter_nd_update op does not support eager execution. Arg 'output_ref' is a ref.NTr6rrScatterNdUpdaterr<rrr s rSscatter_nd_updater-s1r    0h..0$ #\\ j kkK""; >+(();=QR'88sGW'2.@tM!QX QK' ""$3%%c*J  ,m  /1Ell/02F::L <: (' .rUzraw_ops.ScatterNdUpdatectd)Nr+rWr s rS scatter_nd_update_eager_fallbackr/DshiirUTV_ScatterSub_TTV_ScatterSub_Tindicesctjxstj}|j}|jr t d|d}t j |d}tjd|||||\}}}} | dd} t jrYd|jdd|jdd|jdf} |j} t jd| | | | \} | 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`, `qint16`, `quint16`, `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`. Kscatter_sub op does not support eager execution. Arg 'output_ref' is a ref.NFr6 ScatterSubrr<rr=rs rS scatter_subr5JrrUzraw_ops.ScatterSubctd)Nr3rWrs rSscatter_sub_eager_fallbackr7rrU) TV_ScatterUpdate_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2TV_ScatterUpdate_Tindicesctjxstj}|j}|jr t d|d}t j |d}tjd|||||\}}}} | dd} t jrYd|jdd|jdd|jdf} |j} t jd| | | | \} | S) aMApplies 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:]` or `updates.shape = []`.
See also `tf.batch_scatter_update` and `tf.scatter_nd_update`. Args: ref: 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 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: A mutable `Tensor`. Has the same type as `ref`. Nscatter_update op does not support eager execution. Arg 'output_ref' is a ref.NTr6 ScatterUpdaterr<rr=rs rSscatter_updater=sZ    0h..0$ #\\ g hhK""; >+'88S'7%0t=!QX QK' ""$3%%c*J  ,m  /1F::L vw8 (' .rUzraw_ops.ScatterUpdatectd)Nr;rWrs rSscatter_update_eager_fallbackr?rrU) TV_TemporaryVariable_dtyperrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2rcNtjxstj}|j}|jr t dt j |d}t j|d}|d}t j|d}tjd||||\}}}}|dd} t jrYd|jdd|jdd|jdf} |j} t jd| | | | \} | S) aReturns a tensor that may be mutated, but only persists within a single step. This is an experimental op for internal use only and it is possible to use this op in unsafe ways. DO NOT USE unless you fully understand the risks. It is the caller's responsibility to ensure that 'ref' is eventually passed to a matching 'DestroyTemporaryVariable' op after all other uses have completed. Outputs a ref to the tensor state so it may be read or modified. E.g. var = state_ops._temporary_variable([1, 2], types.float_) var_name = var.op.name var = state_ops.assign(var, [[4.0, 5.0]]) var = state_ops.assign_add(var, [[6.0, 7.0]]) final = state_ops._destroy_temporary_variable(var, var_name=var_name) Args: shape: A `tf.TensorShape` or list of `ints`. The shape of the variable tensor. dtype: A `tf.DType`. The type of elements in the variable tensor. var_name: An optional `string`. Defaults to `""`. Overrides the name used for the temporary variable resource. Default value is the name of the 'TemporaryVariable' op (which is guaranteed unique). name: A name for the operation (optional). Returns: A mutable `Tensor` of type `dtype`. Ktemporary_variable op does not support eager execution. Arg 'ref' is a ref.shaperNrryTemporaryVariable)rCrryr;r>rr?r@rArB make_shaperr}rDrErFr~rGrIrJ) rCrryr;rKrLrMrNrOrPrQrRs rStemporary_variablerGs<    0h..0$ #\\ d ee   eW -%   UG ,% H   x 4('885"&(!QX QK' ""$s||G,g  ):ll:&(F::L \67< (' .rUzraw_ops.TemporaryVariablectd)NrBrW)rCrryr;rXs rS!temporary_variable_eager_fallbackrIrrU) TV_Variable_dtyperrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2 container shared_namec tjxstj}|j}|jr t dt j |d}t j|d}|d}t j|d}|d}t j|d}tjd||||| \}}}} | dd} t jrjd|jdd|jdd|jdd|jdf} |j} t jd| | | | \} | S) a@Use VariableV2 instead. Args: shape: A `tf.TensorShape` or list of `ints`. dtype: A `tf.DType`. container: An optional `string`. Defaults to `""`. shared_name: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A mutable `Tensor` of type `dtype`. Avariable op does not support eager execution. Arg 'ref' is a ref.rCrNrrKrLVariablerCrrKrLr;rE rCrrKrLr;rKrLrMrNrOrPrQrRs rSvariablerRsF    0h..0$ #\\ Z [[   eW -%   UG ,%I ;7)K!!+}=+'88%u +$8!QX QK' ""$s||G,g  );ll;'ll=)+F::L L&'3 (' .rUzraw_ops.Variablectd)NrNrWrCrrKrLr;rXs rSvariable_eager_fallbackrUGsXYYrU) TV_VariableV2_dtyperrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2c tjxstj}|j}|jr t dt j |d}t j|d}|d}t j|d}|d}t j|d}tjd||||| \}}}} | dd} t jrjd|jdd|jdd|jdd|jdf} |j} t jd| | | | \} | S) a_Holds state in the form of a tensor that persists across steps. Outputs a ref to the tensor state so it may be read or modified. TODO(zhifengc/mrry): Adds a pointer to a more detail document about sharing states in tensorflow. Args: shape: A `tf.TensorShape` or list of `ints`. The shape of the variable tensor. dtype: A `tf.DType`. The type of elements in the variable tensor. container: An optional `string`. Defaults to `""`. If non-empty, this variable is placed in the given container. Otherwise, a default container is used. shared_name: An optional `string`. Defaults to `""`. If non-empty, this variable is named in the given bucket with this shared_name. Otherwise, the node name is used instead. name: A name for the operation (optional). Returns: A mutable `Tensor` of type `dtype`. Dvariable_v2 op does not support eager execution. Arg 'ref' is a ref.rCrNrrKrL VariableV2rPrErQs rS variable_v2rZLsF,    0h..0$ #\\ ] ^^   eW -%   UG ,%I ;7)K!!+}=+'88E)"-D:!QX QK' ""$s||G,g  );ll;'ll=)+F::L lFG5 (' .rUzraw_ops.VariableV2ctd)NrXrWrTs rSvariable_v2_eager_fallbackr\rwrU)TTN)FN)N)TrN)FrN)TN)rN)rrN)__doc__ collectionstensorflow.pythonrtensorflow.python.eagerrr>rrrrBtensorflow.python.frameworkrrtensorflow.security.fuzzing.pyr_atypesr _op_def_registryr rr rD"tensorflow.python.util.deprecationr tensorflow.python.utilr _dispatch tensorflow.python.util.tf_exportrtypingrrrtyping_extensionsrrboolrT to_raw_opr:rYrZr`r]rdrfrjrirlrmintrtrqrvrxstrrr|rrBoolrrrrResourcerrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rr rrrrrrrrrrr r!r%r$r'r(r)r-r,r/r0r1r5r4r7r8r9r=r<r?r@rGrDrIrJrRrOrUrVrZrYr\rUrSrrs" 67179FK3IC86%%'z . #{*+.Ic;>N4O.`d.w{.QZ[^`k[kQl.` %# $^T^^F%; <_yk)9:_9SR]M]C^_pt_DH_XabegrbrXs_)+=?SUhj{~OQ_aprACRTbdtvFHWYjl|~NP`brtCD%Ic>12%9S.EX;Y%gk%BKLOQ_L_B`%N +I) *>4>>*+E F c9S.-@#Ac)TWYgTgJhcw{cLUVY[iViLjc)+=?SUhj{~OQ_aprACRTbdtvFHWYjl|~NP`brtCD%Ic>12%9S.EX;Y%gk%BKLOQ_L_B`%N +I) *>4>>*+E F c9S.-@#Ac)TWYgTgJhcw{cLUVY[iViLjc)?OLYsN23CyY\^lYlOm@ +I) *>4>>++F G ]Ic>.A$B]3]^ghkm{h{^|]!(!^ %Ic3P.P$Q%]`%pyz}@]{]q^%NI9%GHXrIstl9SB_=_3`llol@IJMOlJl@ml")"` 30N+N!O_hilnunznziz_{:C "AB>4>>RiCjki #?]:]0^inwx{~E~J~JyJoKi!!9?O\,9S'2B2B-B#C,C,Tj,{DEHJ`E`{a,\;I9:>4>>J^;_` )CAQAQ%>?R)TWYtTtJuRAJKNPdKdAeRswRQTRgpqtvJqJgKRh7)56~t~~FW7XYj)C9M4M*NjYbcfiDdDZEjPYZ]_sZsPtjCGj]`jpyz}SzSpTj+-?AUWjl}@QSacrtCETVdfvxHJY[ln~@PRbdtvEF !9?O\=YsO34=yNdId?e=pyz}@O{OqP=^b=xABEGVBVxW=~-Y+ ,^T^^K-H I dIc?.B$CdiX[]sXsNtd@IJMO^J^@_dnrdBKLOQ`L`BadH #$?RabA #'9"9:AYsTmOmEnAzCDGI[D[z\AjnACLMPRdMdCeAF3 12>4>>.3QR gy6H1H'IgT]^ac|^|T}gIRSVXjSjIkgz~gNWX[]oXoNpg%X 4%?4#4`ijmpJkJaK4l;I9:>4>>J\;]^d4NdZ]dmvwz}WxWnXdF ',''C'bklorCmCcD'R )9' ()A BZ*;ZZZ]Zmvwz}NxNnOZJ 010S0QT0gpqtwJrJhK0d-Y+ ,^T^^K-H I ]-@]S]_b]r{|BU}UsV]rU