AVhzdZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd l m Z dd l mZdd l mZdd l mZddl mZddl mZddl mZddl mZddl mZddlmZddlmZddlmZddlmZddl m!Z!ddZ"ddZ#ddZ$e jJe jLjNejPe#e$e jJe jLjRejPe#e$e jJe jLjTejPe#e$e jJe jLjVejPe#e$e jJe jLjXejPe#e$e jJe jLjZejPe#e$e jJe jLj\ejPe#e$Gddej^ej`Z1e jde1e1jfy) zRefVariable class.)attr_value_pb2) variable_pb2)context)dtypes)indexed_slices)ops)tensor_conversion_registry) tensor_shape) array_ops) gen_array_ops) gen_state_ops)resource_variable_ops)resource_variables_toggle) state_ops)variable_scope) variable_v1) variables) tf_logging)base)core)compat) deprecatedNc b|J|jdd}|jdd}|jdd}|jdd}|jdd}|jdd}|jd d}|jd d} |jd d} |jd d} |jd d} |jdd} |jdd}|jdd}|jdd}| tjj} | t j } | xst j} | r5|jdd}tj||||||| | || ||||St||||||| | || | |||S)zDefault variable creator.N initial_value trainable collectionsvalidate_shapeTcaching_devicename variable_defdtypeexpected_shape import_scope constraint use_resourcesynchronization aggregationshapedistribute_strategy)rrrrrrr!r$r r#r)r&r'r()rrrrrrr!r$r r"r#r&r'r() getrget_variable_scoper%rresource_variables_enabledrexecuting_eagerlyrResourceVariable RefVariable) next_creatorkwargsrrrrrrr r!r"r#r$r%r&r'r(r)s R/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/ref_variable.pydefault_variable_creatorr3)s   **_d3-jjd+) =$/+::.5.::.5. FD !$ND1, **Wd #%::.5.ND1,zz,-*ND1,JJ0$7/ =$/+ **Wd #%!446CCL,GGIL<!:!:!<, **%:DA 1 1#%% !!/'  #%% !%!' c&|j|S)zFConverts Variable and ResourceVariable to VariableDef for collections. export_scope)to_proto)vr7s r2 _to_proto_fnr:ds  ..r4c|jr!tjj||Stj j||S)z@Creates Variable or ResourceVariable from VariableDef as needed.r#) is_resourcerr. from_protor VariableV1)r9r#s r2_from_proto_fnr@isH]] 1 1 < <  = &&    * *1< * HHr4) proto_typer8r>ceZdZdZ d:dZdZ d;dZddZd>dZd>dZd>dZd>dZd>dZd>dZd>dZdd8Z?d9Z@y)@r/z&Ref-based implementation of variables.Ncd|_|r!|r td|j|| y|j|||||||| | | | | y)aCreates a new variable with value `initial_value`. The new variable is added to the graph collections listed in `collections`, which defaults to `[GraphKeys.GLOBAL_VARIABLES]`. If `trainable` is `True` the variable is also added to the graph collection `GraphKeys.TRAINABLE_VARIABLES`. This constructor creates both a `variable` Op and an `assign` Op to set the variable to its initial value. Args: initial_value: A `Tensor`, or Python object convertible to a `Tensor`, which is the initial value for the Variable. The initial value must have a shape specified unless `validate_shape` is set to False. Can also be a callable with no argument that returns the initial value when called. In that case, `dtype` must be specified. (Note that initializer functions from init_ops.py must first be bound to a shape before being used here.) trainable: If `True`, also adds the variable to the graph collection `GraphKeys.TRAINABLE_VARIABLES`. This collection is used as the default list of variables to use by the `Optimizer` classes. Defaults to `True`, unless `synchronization` is set to `ON_READ`, in which case it defaults to `False`. collections: List of graph collections keys. The new variable is added to these collections. Defaults to `[GraphKeys.GLOBAL_VARIABLES]`. validate_shape: If `False`, allows the variable to be initialized with a value of unknown shape. If `True`, the default, the shape of `initial_value` must be known. caching_device: Optional device string describing where the Variable should be cached for reading. Defaults to the Variable's device. If not `None`, caches on another device. Typical use is to cache on the device where the Ops using the Variable reside, to deduplicate copying through `Switch` and other conditional statements. name: Optional name for the variable. Defaults to `'Variable'` and gets uniquified automatically. variable_def: `VariableDef` protocol buffer. If not `None`, recreates the Variable object with its contents, referencing the variable's nodes in the graph, which must already exist. The graph is not changed. `variable_def` and the other arguments are mutually exclusive. dtype: If set, initial_value will be converted to the given type. If `None`, either the datatype will be kept (if `initial_value` is a Tensor), or `convert_to_tensor` will decide. expected_shape: A TensorShape. If set, initial_value is expected to have this shape. import_scope: Optional `string`. Name scope to add to the `Variable.` Only used when initializing from protocol buffer. constraint: An optional projection function to be applied to the variable after being updated by an `Optimizer` (e.g. used to implement norm constraints or value constraints for layer weights). The function must take as input the unprojected Tensor representing the value of the variable and return the Tensor for the projected value (which must have the same shape). Constraints are not safe to use when doing asynchronous distributed training. synchronization: Indicates when a distributed a variable will be aggregated. Accepted values are constants defined in the class `tf.VariableSynchronization`. By default the synchronization is set to `AUTO` and the current `DistributionStrategy` chooses when to synchronize. aggregation: Indicates how a distributed variable will be aggregated. Accepted values are constants defined in the class `tf.VariableAggregation`. shape: (optional) The shape of this variable. If None, the shape of `initial_value` will be used. When setting this argument to `tf.TensorShape(None)` (representing an unspecified shape), the variable can be assigned with values of different shapes. Raises: ValueError: If both `variable_def` and initial_value are specified. ValueError: If the initial value is not specified, or does not have a shape and `validate_shape` is `True`. RuntimeError: If eager execution is enabled. Tz6variable_def and initial_value are mutually exclusive.r<) rrrrrrr!r"r$r&r'r(N)_in_graph_mode ValueError_init_from_proto_init_from_args)selfrrrrrrr r!r"r#r$r&r'r(s r2__init__zRefVariable.__init__sqpD &' ' L|D %!''')! r4c ntjrj|js^d|jd|j d|j jdt j|jdd Sd|jd|j d|j jdS)Nz) rr-rDr get_shaper!r numpy_text read_valuerHs r2__repr__zRefVariable.__repr__ sv  "4+>+> ))T^^%tzz ..*D 9;; ))T^^%tzz88r4c  |} | tdt|}|tjjg}t |t ttfstd|dt|| t| s tdtjj|_ t |tjr7|j|jj |_|j$}t'j(| | ||\} } }| |_| |_||_|rCtjj0|vr't |tjj0gz}tj25t5j6r t9dtj:|d|rgn|g5}|rtj<|}t?j@t>j@jCtEjFd|zg  }tjjId |i5tj:d 5tjJd5|}t |tjr7|j|jj |_|j$}tjL|d ||_'| 0|r|jNjQntSjT} ddddddtWjX| |jNjZj\||_/dddntjL|d ||_'|jNj`jctd|z| 0|r|jNjQntSjT} tWjX| |jNjZj\||_/|j^jd|_3|rB|jNjQ}|jistd|jNztWjj|j^t'jl||jN|j`|_7|EtjJ|5tqjr|j^d|_:dddnXtjv|j^j`5tqjr|j^d|_:ddddddtjx||ddd||_=d|_>| |_?y#1swYxYw#1swYxYw#1swYxYw#1swYlxYw#1swYxxYw#1swY|xYw#1swYjxYw)a> Creates a new variable from arguments. Args: initial_value: A `Tensor`, or Python object convertible to a `Tensor`, which is the initial value for the Variable. The initial value must have a shape specified unless `validate_shape` is set to False. Can also be a callable with no argument that returns the initial value when called. (Note that initializer functions from init_ops.py must first be bound to a shape before being used here.) trainable: If `True`, also adds the variable to the graph collection `GraphKeys.TRAINABLE_VARIABLES`. This collection is used as the default list of variables to use by the `Optimizer` classes. Defaults to `True`, unless `synchronization` is set to `ON_READ`, in which case it defaults to `False`. collections: List of graph collections keys. The new variable is added to these collections. Defaults to `[GraphKeys.GLOBAL_VARIABLES]`. validate_shape: If `False`, allows the variable to be initialized with a value of unknown shape. If `True`, the default, the shape of `initial_value` must be known. caching_device: Optional device string or function describing where the Variable should be cached for reading. Defaults to the Variable's device. If not `None`, caches on another device. Typical use is to cache on the device where the Ops using the Variable reside, to deduplicate copying through `Switch` and other conditional statements. name: Optional name for the variable. Defaults to `'Variable'` and gets uniquified automatically. dtype: If set, initial_value will be converted to the given type. If None, either the datatype will be kept (if initial_value is a Tensor) or float32 will be used (if it is a Python object convertible to a Tensor). expected_shape: Deprecated. Ignored. constraint: An optional projection function to be applied to the variable after being updated by an `Optimizer` (e.g. used to implement norm constraints or value constraints for layer weights). The function must take as input the unprojected Tensor representing the value of the variable and return the Tensor for the projected value (which must have the same shape). Constraints are not safe to use when doing asynchronous distributed training. synchronization: Indicates when a distributed a variable will be aggregated. Accepted values are constants defined in the class `tf.VariableSynchronization`. By default the synchronization is set to `AUTO` and the current `DistributionStrategy` chooses when to synchronize. aggregation: Indicates how a distributed variable will be aggregated. Accepted values are constants defined in the class `tf.VariableAggregation`. shape: (optional) The shape of this variable. If None, the shape of `initial_value` will be used. When setting this argument to `tf.TensorShape(None)` (representing an unspecified shape), the variable can be assigned with values of different shapes. Raises: ValueError: If the initial value is not specified, or does not have a shape and `validate_shape` is `True`. RuntimeError: If lifted into the eager context. Nz initial_value must be specified.zPcollections argument to Variable constructor must be a list, tuple, or set. Got z of type z-The `constraint` argument must be a callable.zReference variables are not supported when eager execution is enabled. Please run `tf.compat.v1.enable_resource_variables()` to switch to resource variables.Variablezloc:@%s)s)list_class Initializerr)rr!rzInitializer for variable %s is from inside a control-flow construct, such as a loop or conditional. When creating a variable inside a loop or conditional, use a lambda as the initializer.z-initial_value must have a shape specified: %srread)@rEcallabler GraphKeysGLOBAL_VARIABLES isinstancerUtuplesettypeget_default_graph _graph_key trackableCheckpointInitialValue_maybe_initialize_trackablecheckpoint_position restore_uid _update_uid wrapped_valuer.validate_synchronization_aggregation_trainable_synchronization _aggregation _trainableTRAINABLE_VARIABLES init_scoperr- RuntimeError name_scopename_from_scope_namer AttrValue ListValueras_bytes _attr_scopedeviceconvert_to_tensor_initial_valuerMr unknown_shapervariable_op_v2r! base_dtype _variableop_get_control_flow_contextr_nameis_fully_definedassign-_try_guard_against_uninitialized_dependencies_initializer_opr identity _snapshot colocate_withadd_to_collections_caching_device_save_slice_info _constraint)rHrrrrrrr!r"r$r&r'r(_ init_from_fn true_nameattrinitial_value_shapes r2rGzRefVariable._init_from_argssoH A 9 ::M*L]]334k kD%#5 6 )4d;6G I JJhz&: F GG++-88DO-!A!AB &&(&::FFd#11m @@ [)T ;,O[),D#DDOS]]66kI%)J)J(KKk  V0  " " $ ,- - >>$ ,"=/ CNMFJ ..t4)))!++55__Y%:;<6>?$$$&22Hd3CD H . I 40@ I+omM9+K+KL002#0#D#D#P#P - ; ; $'$9$9oU%Dd!&''113+7+E+E+G I I'55t**00;;$HDN H H&!$ 5 5/!@$  # # = = ? K"&&' ' ]"##--/'3'A'A'C  %33T((..99F$. ^^((   $ 3 3 = = ? $557L!0012 2 )// NN  C Cd)) +)  +,.2   %zz.) M&//VLDN M M  !2!23 M&//VLDN M[NM^ [$/mV0p*D D!DM I I I I H H| M M M M[NMNMV0V0s$> @,O[),D#DDO''   & &\ CDDN23'00>>*>>#?%d#dDDr4c|jS)z1Conversion function for Graph.as_graph_element().r~rPs r2_as_graph_elementzRefVariable._as_graph_elements >>r4c|jS)aReturns the last snapshot of this variable. You usually do not need to call this method as all ops that need the value of the variable call it automatically through a `convert_to_tensor()` call. Returns a `Tensor` which holds the value of the variable. You can not assign a new value to this tensor as it is not a reference to the variable. To avoid copies, if the consumer of the returned value is on the same device as the variable, this actually returns the live value of the variable, not a copy. Updates to the variable are seen by the consumer. If the consumer is on a different device it will get a copy of the variable. Returns: A `Tensor` containing the value of the variable. )rrPs r2valuezRefVariable.values" >>r4cDtj|jdS)zReturns the value of this variable, read in the current context. Can be different from value() if it's on another device, with control dependencies, etc. Returns: A `Tensor` containing the value of the variable. rZrX)r rr~rPs r2rOzRefVariable.read_values   dnn6 ::r4c|jS)aReturns a reference to this variable. You usually do not need to call this method as all ops that need a reference to the variable call it automatically. Returns is a `Tensor` which holds a reference to the variable. You can assign a new value to the variable by passing the tensor to an assign op. See `tf.Variable.value` if you want to get the value of the variable. Returns: A `Tensor` that is a reference to the variable. rrPs r2_refzRefVariable._refs >>r4c|jj||jj|y)zxOverrides the shape for this variable. Args: shape: the `TensorShape` representing the overridden shape. N)r set_shaper)rHr(s r2rzRefVariable.set_shape/s,  IIK% JJL5!r4c|jSN)rnrPs r2rzRefVariable.trainable8s ??r4c|jSr)rlrPs r2r&zRefVariable.synchronization<s   r4c|jSr)rmrPs r2r'zRefVariable.aggregation@s   r4c:|jj|S)aIn a session, computes and returns the value of this variable. This is not a graph construction method, it does not add ops to the graph. This convenience method requires a session where the graph containing this variable has been launched. If no session is passed, the default session is used. See `tf.compat.v1.Session` for more information on launching a graph and on sessions. ```python v = tf.Variable([1, 2]) init = tf.compat.v1.global_variables_initializer() with tf.compat.v1.Session() as sess: sess.run(init) # Usage passing the session explicitly. print(v.eval(sess)) # Usage with the default session. The 'with' block # above makes 'sess' the default session. print(v.eval()) ``` Args: session: The session to use to evaluate this variable. If none, the default session is used. Returns: A numpy `ndarray` with a copy of the value of this variable. )session)r~eval)rHrs r2rzRefVariable.evalDs< >>  w  //r4c|jS)aLReturns the Tensor used as the initial value for the variable. Note that this is different from `initialized_value()` which runs the op that initializes the variable before returning its value. This method returns the tensor that is used by the op that initializes the variable. Returns: A `Tensor`. )rzrPs r2rzRefVariable.initial_valueds   r4c|jS)zReturns the constraint function associated with this variable. Returns: The constraint function that was passed to the variable constructor. Can be `None` if no constraint was passed. )rrPs r2r$zRefVariable.constraintrs   r4chtj|j|||}|r|S|jS)a(Assigns a new value to the variable. This is essentially a shortcut for `assign(self, value)`. Args: value: A `Tensor`. The new value for this variable. use_locking: If `True`, use locking during the assignment. name: The name of the operation to be created read_value: if True, will return something which evaluates to the new value of the variable; if False will return the assign op. Returns: A `Tensor` that will hold the new value of this variable after the assignment has completed.  use_lockingr)rrr~r)rHrrrrOrs r2rzRefVariable.assign|s4    ;TCF m 99r4chtj|j|||}|r|S|jS)a&Adds a value to this variable. This is essentially a shortcut for `assign_add(self, delta)`. Args: delta: A `Tensor`. The value to add to this variable. use_locking: If `True`, use locking during the operation. name: The name of the operation to be created read_value: if True, will return something which evaluates to the new value of the variable; if False will return the assign op. Returns: A `Tensor` that will hold the new value of this variable after the addition has completed. r)r assign_addr~rrHdeltarrrOrs r2rzRefVariable.assign_add4  ! ! ;TCF m 99r4chtj|j|||}|r|S|jS)a6Subtracts a value from this variable. This is essentially a shortcut for `assign_sub(self, delta)`. Args: delta: A `Tensor`. The value to subtract from this variable. use_locking: If `True`, use locking during the operation. name: The name of the operation to be created read_value: if True, will return something which evaluates to the new value of the variable; if False will return the assign op. Returns: A `Tensor` that will hold the new value of this variable after the subtraction has completed. r)r assign_subr~rrs r2rzRefVariable.assign_subrr4ct|tjstd|zt j |j |j|j||S)aSubtracts `tf.IndexedSlices` from this variable. Args: sparse_delta: `tf.IndexedSlices` to be subtracted from this variable. use_locking: If `True`, use locking during the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered subtraction has completed. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. %sparse_delta is not IndexedSlices: %sr) r^r IndexedSlices TypeErrorr scatter_subr~indicesvaluesrH sparse_deltarrs r2rzRefVariable.scatter_subW lN$@$@ A = L MM  $ $    r4ct|tjstd|zt j |j |j|j||S)aAdds `tf.IndexedSlices` to this variable. Args: sparse_delta: `tf.IndexedSlices` to be added to this variable. use_locking: If `True`, use locking during the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered addition has completed. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r^rrrr scatter_addr~rrrs r2rzRefVariable.scatter_addrr4ct|tjstd|zt j |j |j|j||S)aUpdates this variable with the max of `tf.IndexedSlices` and itself. Args: sparse_delta: `tf.IndexedSlices` to use as an argument of max with this variable. use_locking: If `True`, use locking during the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered maximization has completed. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r^rrrr scatter_maxr~rrrs r2rzRefVariable.scatter_maxW lN$@$@ A = L MM  $ $    r4ct|tjstd|zt j |j |j|j||S)aUpdates this variable with the min of `tf.IndexedSlices` and itself. Args: sparse_delta: `tf.IndexedSlices` to use as an argument of min with this variable. use_locking: If `True`, use locking during the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered minimization has completed. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r^rrrr scatter_minr~rrrs r2rzRefVariable.scatter_minrr4ct|tjstd|zt j |j |j|j||S)aMultiply this variable by `tf.IndexedSlices`. Args: sparse_delta: `tf.IndexedSlices` to multiply this variable by. use_locking: If `True`, use locking during the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered multiplication has completed. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r^rrrr scatter_mulr~rrrs r2rzRefVariable.scatter_mul rr4ct|tjstd|zt j |j |j|j||S)aDivide this variable by `tf.IndexedSlices`. Args: sparse_delta: `tf.IndexedSlices` to divide this variable by. use_locking: If `True`, use locking during the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered division has completed. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r^rrrr scatter_divr~rrrs r2rzRefVariable.scatter_div8rr4ct|tjstd|zt j |j |j|j||S)aAssigns `tf.IndexedSlices` to this variable. Args: sparse_delta: `tf.IndexedSlices` to be assigned to this variable. use_locking: If `True`, use locking during the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered assignment has completed. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r^rrrr scatter_updater~rrrs r2rzRefVariable.scatter_updatePsW lN$@$@ A = L MM  ' '    r4c^tj||j|j||S)atAssigns `tf.IndexedSlices` to this variable batch-wise. Analogous to `batch_gather`. This assumes that this variable and the sparse_delta IndexedSlices 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 = sparse_delta.indices.ndims - 1` `batch_dim = num_prefix_dims + 1` `sparse_delta.updates.shape = sparse_delta.indices.shape + var.shape[ batch_dim:]` where `sparse_delta.updates.shape[:num_prefix_dims]` `== sparse_delta.indices.shape[:num_prefix_dims]` `== var.shape[:num_prefix_dims]` And the operation performed can be expressed as: `var[i_1, ..., i_n, sparse_delta.indices[i_1, ..., i_n, j]] = sparse_delta.updates[ i_1, ..., i_n, j]` When sparse_delta.indices is a 1D tensor, this operation is equivalent to `scatter_update`. To avoid this operation one can looping over the first `ndims` of the variable and using `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. Args: sparse_delta: `tf.IndexedSlices` to be assigned to this variable. use_locking: If `True`, use locking during the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered assignment has completed. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. r)rbatch_scatter_updaterrrs r2rz RefVariable.batch_scatter_updatehs3Z  ) )    r4cJtj|j||d|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 add 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]) op = ref.scatter_nd_sub(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: indices: The indices to be used in the operation. updates: The values to be used in the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered subtraction has completed. Tr)r scatter_nd_subr~rHrupdatesrs r2rzRefVariable.scatter_nd_sub)\  ' ' d GGr4cJtj|j||d|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 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]) add = ref.scatter_nd_add(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: indices: The indices to be used in the operation. updates: The values to be used in the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered addition has completed. Tr)r scatter_nd_addr~rs r2rzRefVariable.scatter_nd_addrr4cJtj|j||d|S)aApplies sparse assignment 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 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 = ref.scatter_nd_update(indices, updates) with tf.compat.v1.Session() as sess: print sess.run(op) ``` 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: indices: The indices to be used in the operation. updates: The values to be used in the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered assignment has completed. Tr)r scatter_nd_updater~rs r2rzRefVariable.scatter_nd_updates)\  * * d GGr4cJtj|j||d|S)aUpdates this variable with the max of `tf.IndexedSlices` and itself. `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]]. ``` See `tf.scatter_nd` for more details about how to make updates to slices. Args: indices: The indices to be used in the operation. updates: The values to be used in the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered addition has completed. Tr)r scatter_nd_maxr~rs r2rzRefVariable.scatter_nd_max/(<  ' ' d GGr4cJtj|j||d|S)aUpdates this variable with the min of `tf.IndexedSlices` and itself. `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]]. ``` See `tf.scatter_nd` for more details about how to make updates to slices. Args: indices: The indices to be used in the operation. updates: The values to be used in the operation. name: the name of the operation. Returns: A `Tensor` that will hold the new value of this variable after the scattered addition has completed. Tr)r scatter_nd_minr~rs r2rzRefVariable.scatter_nd_minPrr4c ^tj|j||||||||| |  S)N) refbeginendstridesrr begin_maskend_mask ellipsis_mask new_axis_maskshrink_axis_mask)r strided_slice_assignr) rHrrrrrrrrrrs r2_strided_slice_assignz!RefVariable._strided_slice_assignqs>  - - IIK  ##) + +r4zPrefer Dataset.range instead.cDtj|j|S)aIncrements this variable until it reaches `limit`. When that Op is run it tries to increment the variable by `1`. If incrementing the variable would bring it above `limit` then the Op raises the exception `OutOfRangeError`. If no error is raised, the Op outputs the value of the variable before the increment. This is essentially a shortcut for `count_up_to(self, limit)`. Args: limit: value at which incrementing the variable raises an error. Returns: A `Tensor` that will hold the variable value before the increment. If no other Op modifies this variable, the values produced will all be distinct. )limit)r count_up_tor~)rHrs r2rzRefVariable.count_up_tos*  u ==r4c|}|rK|j|js0td|jd|jjd|r|j S|j S)z7Utility function for converting a Variable to a Tensor.z0Incompatible type conversion requested to type 'z' for variable of type '')is_compatible_withr!rErrr)r9r!ras_refrs r2_TensorConversionFunctionz%RefVariable._TensorConversionFunctions\ A U--agg6 !JJ  6 77 VVXo WWYr4dc|jS)zThe name of this variable.)rrPs r2rzRefVariable.names ::r4returnc|jS)z,The initializer operation for this variable.)rrPs r2 initializerzRefVariable.initializers   r4c.|jjS)zThe device of this variable.)r~rxrPs r2rxzRefVariable.devices >>  r4c.|jjS)zThe `DType` of this variable.)r~r!rPs r2r!zRefVariable.dtype >>  r4c.|jjS)z!The `Operation` of this variable.)r~rrPs r2rzRefVariable.ops >>  r4c.|jjS)zThe `Graph` of this variable.)r~graphrPs r2rzRefVariable.graphrr4cy)zBThe `tf.distribute.Strategy` that this variable was created under.NrPs r2_distribute_strategyz RefVariable._distribute_strategys r4c6|jjS)zMThe `TensorShape` of this variable. Returns: A `TensorShape`. )r~rMrPs r2r(zRefVariable.shapes >> # # %%r4c |&|jjj|rftj}t j |jj||_|j/t j |jj||_ |j|_ |jj|_ |jj|_ t j |jj||_t j |j j||_|j$r5|j&j)|j$j+||Sy)aConverts a `Variable` to a `VariableDef` protocol buffer. Args: export_scope: Optional `string`. Name scope to remove. Returns: A `VariableDef` protocol buffer, or `None` if the `Variable` is not in the specified name scope. Nr6)r~r startswithrrrstrip_name_scoperrzrrr&rr'rrrrrr MergeFromr8)rHr7var_defs r2r8zRefVariable.to_protos;  3 3 > >| L((*g!224>>3F3F3?Ag   (%(%9%9    $ $l&4"..g $ 4 4 : :g ,,22g!$!5!5d6F6F6K6K6B"Dg!224>>3F3F3?Ag  ##--  ! ! * * * E G n r4cVtjtjdd||zS)NzVariable += will be deprecated. Use variable.assign_add if you want assignment to the variable value or 'x = x + y' if you want a new python Tensor object.logging log_first_nWARNrHothers r2__iadd__zRefVariable.__iadd__+  3457 %<r4cVtjtjdd||z S)NzVariable -= will be deprecated. Use variable.assign_sub if you want assignment to the variable value or 'x = x - y' if you want a new python Tensor object.r r rs r2__isub__zRefVariable.__isub__rr4cVtjtjdd||zS)NzVariable *= will be deprecated. Use `var.assign(var * other)` if you want assignment to the variable value or `x = x * y` if you want a new python Tensor object.r r rs r2__imul__zRefVariable.__imul__ +   345 7 %<r4cVtjtjdd||z SNzVariable /= will be deprecated. Use `var.assign(var / other)` if you want assignment to the variable value or `x = x / y` if you want a new python Tensor object.r r rs r2__idiv__zRefVariable.__idiv__rr4cVtjtjdd||z Srr rs r2 __itruediv__zRefVariable.__itruediv__rr4cVtjtjdd||z Srr rs r2 __irealdiv__zRefVariable.__irealdiv__!rr4cVtjtjdd||zS)NzVariable **= will be deprecated. Use `var.assign(var ** other)` if you want assignment to the variable value or `x = x ** y` if you want a new python Tensor object.r r rs r2__ipow__zRefVariable.__ipow__)s+   345 7 ;r4c&tj|iS)z+Implements Trackable._serialize_to_tensors.)rdVARIABLE_VALUE_KEYrPs r2_serialize_to_tensorsz!RefVariable._serialize_to_tensors1s  ( ($ //r4c|tj}tj|||j j S)z+Implements Trackable._restore_from_tensors.rY)rdr$rrrMr)rHrestored_tensorsrestored_tensors r2_restore_from_tensorsz!RefVariable._restore_from_tensors5s>&y'C'CDO    ~~'88: <5>.  &    3==    ! !  V\\    #--   SYY      & &@0rEs42+.6+B4+//7;+0-+<9()98v/ IMM""''   MM%%''   MM**''   MM!!''   MM!!''   MM''   MM""''  d<+(($++d>668r4