AVh4dZddlZddlZddlmZddlZddlmZddlm Z ddl m Z ddl m Z ddl mZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZ ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$ddlm%Z&ddlm'Z'ddlm(Z(ddlm)Z)ddlm*Z*ddlm+Z,ddlm-Z-ddlm.Z.ddl/m0Z0ddl/m1Z1dd l/m2Z2dd!l/m3Z3dd"l/m4Z4dd#l/m5Z5dd$l/m6Z6dd%l7dd&l8m9Z9dd'l:m;Z<dd(l=m>Z>dd l?mZdd)l?m@Z@dd*lAmBZBdd+lCmDZDe jd,e jd-e jd.e jd/e jd0e4jZFd1ZGd2ZHd3ZI d]d4ZJd5ZKejd6ZMGd7d8ZNd]d9ZOd:ZPd;ZQd]d<ZRGd=d>e6je>jZUGd?d@e"jZWGdAdBeUe!jZYGdCdDeUZZd^dEZ[e-jeUe[GdFdGeUZ]e*jd,dHZ_d]dIZ`e*jd.dJZaeDdKgLdMZbdNZce*jdOe*jdPe*jd-GdQdRZeGdSdTeeZfGdUdVeeZgGdWdXe,jZie9je9jeiejj d_dYZndZeUd[efd\Zoy)`z"Ops to use variables as resources.N)Any)logging) gen_xla_ops)flags)attr_value_pb2) variable_pb2) trace_type) struct_pb2)tensor_callable)pywrap_tf_session)compat)context)record)tape)auto_control_deps_utils)composite_tensor)composite_tensor_gradient) constant_op)cpp_shape_inference_pb2)device)dtypes)errors)indexed_slices)ops)tensor)tensor_conversion_registry) tensor_shape) array_ops) gen_array_ops)gen_resource_variable_ops) gen_state_ops)handle_data_util) state_ops) variables)*)nested_structure_coder)base)core) numpy_compat) deprecated) tf_exportReadVariableOp VariableShapeResourceGatherResourceGatherNd_ReadVariablesOpct|tjsJt|tjr |j St |S)z-Get the data handle from the Tensor `handle`.) isinstance tensor_moduleTensorr EagerTensor _handle_dataget_resource_handle_datahandles [/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/resource_variable_ops.pyget_eager_safe_handle_datar;Os= FM00 11 1(    #F ++cj||_|syt|jDcgc]}|j|jfc}\}}|Dcgc]%}|j st |jnd'}}|Dcgc]4}|j s$|jDcgc]}|jc}nd6}}}|jjjj5} tj| |j|||dddycc}wcc}wcc}wcc}}w#1swYyxYw)zSets the shape inference result HandleData on tensor. Args: tensor: A `Tensor` or `EagerTensor`. handle_data: A `CppShapeInferenceResult.HandleData`. graph_mode: A python bool. N)r6zipshape_and_typeshapedtype unknown_ranklendimsize_opgraph_c_graphgetr -TF_GraphSetOutputHandleShapesAndTypes_wrapper _as_tf_output) r handle_data graph_modepairshapestypessranksdc_graphs r:_set_handle_shapes_and_typesrVYs$&  -8-G-GHTTZZ HJ-&%=C DQ^^3quu: 3 D% D06 *+Q^^uu!qvv!%& & zz  $$&'CC   I D s/D*D9D#D +D##(D)D#)D2c~|jtjk(sJt|}|jtjk7r|St|}|f|j rZ|$|j rt |jdk7rtd|d|jj|j|S)aConcats HandleData from tensors `handle` and `initial_value`. Args: handle: A `Tensor` of dtype `resource`. initial_value: A `Tensor`. Returns: A `CppShapeInferenceResult.HandleData`. If `initial_value` has dtype `variant`, the `HandleData` contains the concatenation of the shape_and_type from both `handle` and `initial_value`. Raises: RuntimeError: If handle, which was returned by VarHandleOp, either has no handle data, or its len(handle_data.shape_and_type) != 1. EExpected VarHandleOp to return a length==1 shape_and_type, but saw: '') rBrresourcer;variantis_setrDr@ RuntimeErrorextend)r9 initial_valuevariable_handle_dataextra_handle_datas r:_combine_handle_datarcvs  (( (3F;FNN* 0?"'8'?'?$,@,G,G / /0A5  +,A / 00''../@/O/OP r<ctjj}|d}tj|}t j |}|s.|tjdddtj}tj||||||}||}|rt||}t||||Stj ||} ||j"t j$k(rqt'|} | d| j(rX| j(rt+| j,dk7rt/d| d| j,j1| j,t|| ||S) zFCreate a variable handle, copying in handle data from `initial_value`.NzDUsing an explicit shared_name is not allowed when executing eagerly.)node_defopmessage)rArB shared_name debug_namename containerrXrYrZ)rget_default_graph _containerras_shaperas_dtyper InternalErrorranonymous_namer var_handle_oprcrVr"create_handle_datarBr\r;r]rDr@r^r_) rArBrirkrNr`rlr9full_handle_datarMrbs r:%_variable_handle_from_shape_and_dtypervss##%00)I    &% //% %    0 11 ((*K $ 2 2     &M+FMB )9:F M"55eUCK ]%8%8FNN%J4]C  &+<+C+C""c+*D*D&E&J&-q*+ + ""))*;*J*JK jA Mr<cN|jj}t||||||S)azCreates a variable handle with information to do shape inference. The dtype is read from `initial_value` and stored in the returned resource tensor's handle data. If `initial_value.dtype == tf.variant`, we additionally extract the handle data (if any) from `initial_value` and append it to the `handle_data`. In this case, the returned tensor's handle data is in the form ``` is_set: true shape_and_type { shape { // initial_value.shape } dtype: DT_VARIANT } shape_and_type { // handle_data(initial_value).shape_and_type[0] } shape_and_type { // handle_data(initial_value).shape_and_type[1] } ... ``` Ops that read from this tensor, such as `ReadVariableOp` and `AssignVariableOp`, know that `handle_data(handle).shape_and_type[1:]` correspond to the handle data of the variant(s) stored in the Variable. Args: initial_value: A `Tensor`. shape: The shape of the handle data. Can be `TensorShape(None)` (i.e. unknown shape). shared_name: A string. name: A string. graph_mode: A python bool. Returns: The handle, a `Tensor` of type `resource`. )rB base_dtyperv)r`rArirkrNrBs r:eager_safe_variable_handlerys2V    ( (% .ue[$/9= JJr<c#Ktjs.t|tjstj rdy|j j5ddddy#1swYyxYwwN)rexecuting_eagerlyr2rr5has_default_graphrH as_defaultr8s r: _handle_graphrsW!Z%H   "     sA"A>$A2) A>2A;7A>c$eZdZdZgdZdZdZy)EagerResourceDeleteraAn object which cleans up a resource handle. An alternative to defining a __del__ method on an object. The intended use is that ResourceVariables or other objects with resource handles will maintain a single reference to this object. When the parent object is collected, this object will be too. Even if the parent object is part of a reference cycle, the cycle will be collectable. )_handle_handle_device_contextct|tjstd|d||_||_t j |_y)NzPassed handle=zG to EagerResourceDeleter. Was expecting the handle to be a `tf.Tensor`.)r2r3r4 ValueErrorrrrr)selfr9 handle_devices r:__init__zEagerResourceDeleter.__init__sQ fm22 3  F8$- . 00DL'DOO%DMr<c t|jtjr|jjryt j 5tj|j5tj|jdddddddy#1swYxYw#1swYyxYw#t$rYyt$rYywxYw)NT)ignore_lookup_error) r2rrr5 is_packedr eager_moderrr destroy_resource_op TypeErrorAttributeErrorrs r:__del__zEagerResourceDeleter.__del__s DLL#// 2t||7M7M    6 ZZ++ , 6 # 7 7ll 6 666 6 666      sR:B<B< B01"B$B0B<$B- )B00B95B<9B<< CCCN)__name__ __module__ __qualname____doc__ __slots__rrr<r:rrs8) & r<rct|5tj|}ddd|jjt j |||S#1swYdXd9Z?dXd:Z@dXd;ZAdXd<ZBdXd=ZCdXd>ZDdXd?ZEdTd@ZFdTdAZGdTdBZHdTdCZIdTdDZJdEZKdFZLdGZMdHZNdIZOdJZPdYdKZQdLZRdMZSdNZTdOZUdPZVdQZWdRZXy)ZBaseResourceVariablez*A python variable from an existing handle.Nc |8tj5tj |_dddn||_t j |||| \}}}||_||_||_ ||_ | |_ ||_ ||_ | |_||_||_||_tj$j&|_t)j*||_t/j0||_||_| |_| d|_n | dz|_||_d|_||_d|_ d|_!y#1swYxYw)a Creates a variable from a handle. Args: trainable: If `True`, GradientTapes automatically watch uses of this Variable. shape: The variable's shape. This shape can be set to tf.TensorShape(None) in order to assign values of different shapes to this variable. Otherwise (i.e. if the shape is fully determined), it will trigger run time checks to ensure that each assignment is of the same shape. dtype: The variable's dtype. handle: The variable's handle 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`. distribute_strategy: The distribution strategy this variable was created under. name: The name for this variable. unique_id: Internal. Unique ID for this variable's handle. handle_name: The name for the variable's handle. graph_element: Optional, required only in session.run-mode. Pre-created tensor which reads this variable's value. initial_value: Optional. Variable's initial value. initializer_op: Operation which assigns the variable's initial value. is_initialized_op: Pre-created operation to check whether this variable is initialized. cached_value: Pre-created operation to read this variable in a specific device. save_slice_info: Metadata for variable partitioning. 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. in_graph_mode: whether we are executing in TF1 graph mode. If None, will detect within the function. This is to avoid repeated init_scope() context entrances which can add up. 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. Nz Variable:0:0F)"r init_scoperr|_in_graph_moder$.validate_synchronization_aggregation_trainable _trainable_synchronization _aggregation_save_slice_info_initial_value_initializer_op_is_initialized_op_graph_element_caching_device _cached_value_distribute_strategyrm _graph_keyrro_shaperrp_dtyper _unique_id _handle_name _constraint_cached_shape_as_list_validate_shape _xla_sharding_variable_read)rrrArBr9rrrrrk unique_id handle_name graph_elementr`initializer_opis_initialized_op cached_valuesave_slice_infor in_graph_moder unused_kwargss r:rzBaseResourceVariable.__init__}sTV >> >")";";"==>>*d@@ [)T ;,O[) DO+D#D+D'D)D/D'D)D%D 3D++-88DO''.DK//%(DKDLDO&d%,d!D!%D)DDDC>>s EEc|jSr{)rrs r:_get_xla_shardingz&BaseResourceVariable._get_xla_shardings   r<c|jr4tjs tjd|j ||_y)a Annotates this `ResourceVariable` with `xla_sharding`. `xla_sharding` will be used to create an `XlaShardingOp` whenever a `ReadVariableOp` is created. Args: xla_sharding: The xla.OpSharding proto to annotate this ResourceVariable with. aThis variable (%s) has already been read (ie. a ReadVariableOp has already been generated) and a new XlaShardingOp using this sharding will not be created unless it is read again. If that's not possible, please set the XLA sharding before reading the variable.N)rrr|rwarningrkr)r xla_shardings r:_set_xla_shardingz&BaseResourceVariable._set_xla_shardings= 7#<#<#> oo G )) &Dr<c tjr|js tj|j5tj |j d}dddd|jd|jd|jjdd Sd|jd|jd|jjdS#1swY|xYw#d}YxYw) NT)is_reprznumpy=z) rr|rrr value_text read_valuerk get_shaperB)rrs r:__repr__zBaseResourceVariable.__repr__s  "4+>+> + ZZ $ G~~doo&7F* G ))T^^%tzz DD ))T^^%tzz88 G G+* s#C.&C"'C."C+'C..C4c|j|jj}|j||t |j |j |j|S)NrArBralias_id)alias_global_idr_idadd_placeholder VariableSpecrArBr)rsignature_contextrs r:__tf_tracing_type__z(BaseResourceVariable.__tf_tracing_type__sR 001A1ABH%%h5 djj"jj"&..!) ++r<c#K|j.tj|jg5ddddydy#1swYyxYww)zMakes assignments depend on the cached value, if any. This prevents undefined behavior with reads not ordered wrt writes. Yields: None. N)rrcontrol_dependenciesrs r:_assign_dependenciesz)BaseResourceVariable._assign_dependencies sL %  # #T%7%7$8 9  s-AAAA AcLtj|j|S)zAllows direct conversion to a numpy array. >>> np.array(tf.Variable([1.0])) array([1.], dtype=float32) Returns: The variable value as a numpy array. rB)r) np_asarraynumpy)rrBs r: __array__zBaseResourceVariable.__array__/s  " "4::|j}|yt|Sr{)rtuplers r: _shape_tuplez!BaseResourceVariable._shape_tuplezs"    !E }  <r<cH|js td|jS)2The op responsible for initializing this variable.@This operation is not supported when eager execution is enabled.)rr^rrs r:createzBaseResourceVariable.creates+    < ==   r<c|jS)z2The handle by which this variable can be accessed.)rrs r:r9zBaseResourceVariable.handles <<r<c|j |jStjdd5|jcdddS#1swYyxYw)z:A cached operation which reads the value of this variable.NTignore_existing)rr colocate_with_read_variable_oprs r:rzBaseResourceVariable.valuesK %     4 6&  # # %&&&s A  Ac|jS)z1Conversion function for Graph.as_graph_element().)rrs r:_as_graph_elementz&BaseResourceVariable._as_graph_elements   r<c|jS)r)rrs r: initializerz BaseResourceVariable.initializers   r<cXtjr td|jS)z>Returns the Tensor used as the initial value for the variable.z?This property is not supported when eager execution is enabled.)rr|r^rrs r:r`z"BaseResourceVariable.initial_values.  " < ==   r<c|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. )rrs r:rzBaseResourceVariable.constraints   r<returnc.|jjSzThe op for this variable.)r9rgrs r:rgzBaseResourceVariable.ops ;;>>r<c|jSr{)rrs r:rzBaseResourceVariable.trainables ??r<c|jSr{)rrs r:rz$BaseResourceVariable.synchronizations   r<c|jSr{)rrs r:rz BaseResourceVariable.aggregations   r<cxtjr td|jj |S)z1Evaluates and returns the value of this variable.r)session)rr|r^reval)rr2s r:r3zBaseResourceVariable.evals:  " < ==    # #G # 44r<c|tjr|jjSt d)Nz:numpy() is only available when eager execution is enabled.)rr|rrrrs r:rzBaseResourceVariable.numpys6  " __  $ $ && D FFr<zPrefer Dataset.range instead.cZtj|j||jS)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. )limitT)r!resource_count_up_tor9rB)rr6s r: count_up_toz BaseResourceVariable.count_up_tos&*  - - 5DJJ 00r<c||vrtjj|jj ddj }t j|5t|j|j|j|j}ddd||<||}t j|j5|j|jdddy#1swY[xYw#1swYyxYw)For implementing `Trackable`.CPUr) device_type device_index)rrArBrkN)pydev DeviceSpec from_stringrreplace to_stringrUninitializedVariablerrArBrassignr)r object_map op_devicenew_vardestination_vars r:_copy_trackable_to_cpuz+BaseResourceVariable._copy_trackable_to_cpus :""..t{{;CC!D--6Y[ ::i $(nn****"" $$!j!&O O** +0T__./00$$00s"8C4 D4C=D c &d}|jjr4tj|j5t |}dddn t |}|||<|j ||j <|j gS#1swY4xYw)r;N)experimental_variable_policy_save_variable_devicesrrcopy_to_graph_uninitializedr9)rrF tensor_mapoptionsr new_variables r:_export_to_saved_model_graphz1BaseResourceVariable._export_to_saved_model_graphsL++BBD ::dkk "9248 9916l#Jt*11Jt{{ KK= 99s BBcfd}tjtj|jj iS)z+Implements Trackable._serialize_to_tensors.c}tj|j5tjr|j s dddy|j }tjd5t j|cdddcdddS#1swYnxYw dddy#1swYyxYw)Nz /device:CPU:0)rrrr|is_initializedread_value_no_copyridentity)vxrs r:_read_variable_closurezJBaseResourceVariable._serialize_to_tensors.._read_variable_closure s a ::ahh  '  $ $ &q/?/?/A ' '  "ZZ ( '##A& ' ' ' ' ' ' ' ' ' 's)&B5%B57B B5B( $B55B>)rBr) trackableVARIABLE_VALUE_KEYr CallablerBr)rrZs` r:_serialize_to_tensorsz*BaseResourceVariable._serialize_to_tensors s; ' $$  $ $&djj N r<c tj|j5tj|tj } t |j|j|}|cdddS#t$r9}td|jd|jd|jd|d}~wwxYw#1swYyxYw)z+Implements Trackable._restore_from_tensors.z(Received incompatible tensor with shape z0 when attempting to restore variable with shape z and name .N) rrrrWr[r\rr9rArrk)rrestored_tensorsrestored_tensorassigned_variablees r:_restore_from_tensorsz*BaseResourceVariable._restore_from_tensors s DKK !** 977 8:o-= KK_6   -67L7L6MN>>Bjj\J {! %&,- --  s/'B9!A4)B94 B6=4B11B66B99Cc,td_fd}tddQtjdd5tj j 5||}ddddddn||}tjs(tjdgjgdd tjrtjsjjj}tj5tj || }ddd|j"j%d t'j(| S#1swY xYw#1swYxYw#1swYUxYw) a$Reads the value of the variable. If the variable is in copy-on-read mode and `no_copy` is True, the variable is converted to copy-on-write mode before it is read. Args: no_copy: Whether to prevent a copy of the variable. Returns: The value of the variable. Tc|r6tjdddrtjjtj jj }tj j||S)N)forward_compatforward_compatibler disable_copy_on_readr9read_variable_oprr)no_copyresultrs r:read_and_set_handlezCBaseResourceVariable._read_variable_op..read_and_set_handle>s_ ^66tQB!66t{{C(99 ++t{{$fT[[$++v> mr<rNr!r,c|gSr{rrYs r:z8BaseResourceVariable._read_variable_op..Rsqcr<c|gSr{rrss r:rtz8BaseResourceVariable._read_variable_op..SsaSr<)backward_functionforward_function)sharding _XlaShardingrR)rrgetattrrr#rrrr|rrecord_operationr9+xla_sharding_for_resource_variables_enabledrSerializeToStringrrrg _set_attrr AttrValue)rrorqrpsharding_strings` r:r$z&BaseResourceVariable._read_variable_op/scdDt&-9   T4 80 ZZ,, - 0&w/& 000#7+f  $ $ &  VHt{{m)(* ;;=))+    ***<<>o   V $L))&?KL ii   " "_ 5 M; 0 000.LLs/ E= E0&E=F 0E: 5E==F Fctjd5|j}dddtjS#1swYxYw)zConstructs an op which reads the value of this variable. Should be used when there are multiple reads, or when it is desirable to read the value only after some condition is true. Returns: The value of the variable. ReadNr name_scoper$rrWrrs r:rzBaseResourceVariable.read_valuegsF  '$$&e'   e $$ ''s AA ctjd5|jd}dddtjS#1swYxYw)a"Constructs an op which reads the value of this variable without copy. The variable is read without making a copy even when it has been sparsely accessed. Variables in copy-on-read mode will be converted to copy-on-write mode. Returns: The value of the variable. rT)roNrrs r:rVz'BaseResourceVariable.read_value_no_copyvsK  3$$T$2e3   e $$ 33s AAc$tj|dn|5}t|tj|j ||j |}|j tjk(rt|j }|jrKt|jdkDr3tjjd|jdd|_t#j$|cdddS ddd|S#1swYSxYw)z:Reads the value of this variable sparsely, using `gather`.NGatherrBrkrXTr)rrrr resource_gatherr9rrr\r;r]rDr@rrrr6rrW)rindicesrkrrMs r: sparse_readz BaseResourceVariable.sparse_reads DLd ; )t'77 ++wdkk>e  &1=   #k&@&@"AA"E%==HHk.H.H.LIN  !!%( ) ) ' ) L ) Ls CDDctj|dn|5}|jr t|t j |j ||j|}dddtjS#1swYxYw)z=Reads the value of this variable sparsely, using `gather_nd`.NGatherNdr) rrrrr resource_gather_ndr9rrrW)rrrkrs r: gather_ndzBaseResourceVariable.gather_ndsn dl  => $':: ++wdkk>e>   e $$ >>s AA<<Bctjr td|&|jjj |rt j}tj|jj||_ |j/tj|jj||_ tj|jj||_|j0tj|jj||_n/tj|j"j||_d|_|j&|_|j(j*|_|j,j*|_|j.r5|j0j3|j.j5||Sy)a@Converts a `ResourceVariable` to a `VariableDef` protocol buffer. Args: export_scope: Optional `string`. Name scope to remove. Raises: RuntimeError: If run in EAGER mode. Returns: A `VariableDef` protocol buffer, or `None` if the `Variable` is not in the specified name scope. rNT) export_scope)rr|r^r9rk startswithr VariableDefrstrip_name_scope variable_namerinitial_value_namer(initializer_namer snapshot_namer is_resourcerrrrrsave_slice_info_def MergeFromto_proto)rrvar_defs r:rzBaseResourceVariable.to_protos  " < ==t{{//::<H((*g!224;;3C3C3?Ag   (&)%9%9    $ $l&4"!$!5!5d6F6F6K6K6B"Dg   ' # 4 4T5G5G5L5L5A!C!$ 4 4T5H5H5M5M5A!C g..g $ 4 4 : :g ,,22g  ##--  ! ! * * * E G n r<cZtjr tdt||S)Nrrr)rr|r^rrs r: from_protozBaseResourceVariable.from_protos2  " < == !  >>r<dcBtj|j|S)zChecks whether a resource variable has been initialized. Outputs boolean scalar indicating whether the tensor has been initialized. Args: name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. )r var_is_initialized_opr9)rrks r:rUz#BaseResourceVariable.is_initializeds % : :4;; MMr<c Lt|j5|j5tj|jt j ||j|}dddddd|r|jSS#1swY&xYw#1swY*xYw)alSubtracts a value from this variable. Args: delta: A `Tensor`. The value to subtract from this variable. use_locking: If `True`, use locking during the operation. name: The name to use for the operation. read_value: A `bool`. Whether to read and return the new value of the variable or not. Returns: If `read_value` is `True`, this method will return the new value of the variable after the assignment has completed. Otherwise, when in graph mode it will return the `Operation` that does the assignment, and when in eager mode it will return `None`. rrN) rr9rr assign_sub_variable_oprrrB _lazy_read)rdelta use_lockingrkr assign_sub_ops r: assign_subzBaseResourceVariable.assign_subs& t{{ #T%>%>%@/FF ++  TZZ 8m  __] ++ #BAB)BB BB#c Lt|j5|j5tj|jt j ||j|}dddddd|r|jSS#1swY&xYw#1swY*xYw)a^Adds a value to this variable. Args: delta: A `Tensor`. The value to add to this variable. use_locking: If `True`, use locking during the operation. name: The name to use for the operation. read_value: A `bool`. Whether to read and return the new value of the variable or not. Returns: If `read_value` is `True`, this method will return the new value of the variable after the assignment has completed. Otherwise, when in graph mode it will return the `Operation` that does the assignment, and when in eager mode it will return `None`. rrN) rr9rr assign_add_variable_oprrrBr)rrrrkr assign_add_ops r: assign_addzBaseResourceVariable.assign_adds t{{ #T%>%>%@/FF ++  TZZ 8m  __] ++ rct|t|j|j|j|j ||j S)N)r9rBrAr parent_opr)r_UnreadVariabler9rBrrr)rrgs r:rzBaseResourceVariable._lazy_reads?d {{jjkk))//  ##r<c t|j5tj||j}|j j |jsP|jd}ndt|jz}td|d|j d|jdi}tjd d d r-|jxr|j j}||d <tj |j|fd |i|} |r|j#| cdddS ddd| S#1swY SxYw)aeAssigns a new value to this variable. Args: value: A `Tensor`. The new value for this variable. use_locking: If `True`, use locking during the assignment. name: The name to use for the assignment. read_value: A `bool`. Whether to read and return the new value of the variable or not. Returns: If `read_value` is `True`, this method will return the new value of the variable after the assignment has completed. Otherwise, when in graph mode it will return the `Operation` that does the assignment, and when in eager mode it will return `None`. rNre z!Cannot assign value to variable 'z%': Shape mismatch.The variable shape z, and the assigned value shape z are incompatible.rhrjrrk)rr9rrrBris_compatible_withrArkstrrrkrlris_fully_definedr rr) rrrrkrr tensor_namerr assign_ops r:rEzBaseResourceVariable.assign'sG$ t{{ #***5 Cl [[ + +L,>,> ? 99 +c$))n,+0 >##';;-0%%1%7%7$88JLN Nf  * *4B 7--P$++2N2N2P#1 +>> ++|:*.:28:i y))**& '** +** s DD==Ec tjt|j|j|j |j |j|jdfS)N)r`rrkrBrrr) functoolspartialrrrrrBrrrs r: __reduce__zBaseResourceVariable.__reduce__PsR   jjl..   jj?? 55 79; ;;r<c t|tjstd||j t j |j|jtj|j|j|S)ahSubtracts `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: The updated variable. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. DArgument `sparse_delta` must be a `tf.IndexedSlices`. Received arg: r) r2r IndexedSlicesrrr resource_scatter_subr9rrrvaluesrBr sparse_deltarrks r: scatter_subz BaseResourceVariable.scatter_sub[ lN$@$@ A ;;G.J KK ??!66 KK   ! !,"5"5tzz B   r<c t|tjstd||j t j |j|jtj|j|j|S)aZAdds `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: The updated variable. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r2rrrrr resource_scatter_addr9rrrrrBrs r: scatter_addz BaseResourceVariable.scatter_addsrr<c t|tjstd||j t j |j|jtj|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: The updated variable. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r2rrrrr resource_scatter_maxr9rrrrrBrs r: scatter_maxz BaseResourceVariable.scatter_max lN$@$@ A ;;G.J KK ??!66 KK   ! !,"5"5tzz B   r<c t|tjstd||j t j |j|jtj|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: The updated variable. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r2rrrrr resource_scatter_minr9rrrrrBrs r: scatter_minz BaseResourceVariable.scatter_minrr<c t|tjstd||j t j |j|jtj|j|j|S)a^Multiply 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: The updated variable. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r2rrrrr resource_scatter_mulr9rrrrrBrs r: scatter_mulz BaseResourceVariable.scatter_mulrr<c t|tjstd||j t j |j|jtj|j|j|S)aZDivide 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: The updated variable. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r2rrrrr resource_scatter_divr9rrrrrBrs r: scatter_divz BaseResourceVariable.scatter_divrr<c t|tjstd||j t j |j|jtj|j|j|S)a`Assigns `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: The updated variable. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. rr) r2rrrrr resource_scatter_updater9rrrrrBrs r:scatter_updatez#BaseResourceVariable.scatter_updates lN$@$@ A ;;G.J KK ??!99 KK   ! !,"5"5tzz B   r<c t|tjstd||j t j ||j|j||S)aAssigns `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: The updated variable. Raises: TypeError: if `sparse_delta` is not an `IndexedSlices`. r)rrk) r2rrrrr#batch_scatter_updaterrrs r:rz)BaseResourceVariable.batch_scatter_updatesnX lN$@$@ A ;;G.J KK ??&&     #   r<c |jtj|j|t j ||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 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: The updated variable. r)rr!resource_scatter_nd_subr9rrrBrrupdatesrks r:scatter_nd_subz#BaseResourceVariable.scatter_nd_sub<EZ ??-- KK   ! !'4:: 6   r<c |jtj|j|t j ||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 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: The updated variable. r)rr!resource_scatter_nd_addr9rrrBrs r:scatter_nd_addz#BaseResourceVariable.scatter_nd_addprr<c |jtj|j|t j ||j |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: The updated variable. r)rr!resource_scatter_nd_updater9rrrBrs r:scatter_nd_updatez&BaseResourceVariable.scatter_nd_updatesEZ ??00 KK   ! !'4:: 6   r<c |jtj|j|t j ||j |S)avUpdates 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: The updated variable. r)rr!resource_scatter_nd_maxr9rrrBrs r:scatter_nd_maxz#BaseResourceVariable.scatter_nd_maxD: ??-- KK   ! !'4:: 6   r<c |jtj|j|t j ||j |S)avUpdates 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: The updated variable. r)rr!resource_scatter_nd_minr9rrrBrs r:scatter_nd_minz#BaseResourceVariable.scatter_nd_minrr<ct|||y)a[Writes additional information of the variable into the SavedObject proto. Subclasses of ResourceVariables could choose to override this method to customize extra information to provide when saving a SavedModel. Ideally, this should contain the logic in write_object_proto_for_resource_variable but `DistributedValue` is an outlier at the momemnt. Once `DistributedValue` becomes a proper ResourceVariable, we should remove the helper method below. Args: proto: `SavedObject` proto to update. options: A `SaveOption` instance that configures save behavior. N)(write_object_proto_for_resource_variable)rprotorPs r:_write_object_protoz(BaseResourceVariable._write_object_proto s-T5'Br<c ft|j5|j5|jt j |j|||t j||j||||| |  cdddcdddS#1swYnxYwdddy#1swYyxYw)Nr) refbeginendstridesrrk begin_maskend_mask ellipsis_mask new_axis_maskshrink_axis_mask) rr9rrrresource_strided_slice_assignrrrB) rrrrrrkrrrrrs r:_strided_slice_assignz*BaseResourceVariable._strided_slice_assign1s t{{ # 2T%>%>%@ 2 __  5 5++))%tzzB#))/ 1 2 2 2 2 2 2 2 2s#B'AB? B'B B''B0cPt|jjSr{)complexrrrs r: __complex__z BaseResourceVariable.__complex__Cs 4::<%%' ((r<cPt|jjSr{)intrrrs r:__int__zBaseResourceVariable.__int__Fs tzz|!!# $$r<cPt|jjSr{)longrrrs r:__long__zBaseResourceVariable.__long__Is  ""$ %%r<cPt|jjSr{)floatrrrs r: __float__zBaseResourceVariable.__float__Ls ##% &&r<c ~|N|j|js3td|jd|jjd|d|r'|j j j dS|jS)Nz/Incompatible type conversion requested to type z for `tf.Variable of type z . (Variable: )r)rrBrrkrrginputsr)rrBrkas_refs r:_dense_var_to_tensorz)BaseResourceVariable._dense_var_to_tensorOs  !9!9$**!E  ;EJJ<H""&**//!2-vQ H II __  ! ! ( ( ++ ZZ\r<ctd)Nz`variable += value` with `tf.Variable`s is not supported. Use `variable.assign_add(value)` to modify the variable, or `out = variable + value` if you need to get a new output Tensor.r^r unused_others r:__iadd__zBaseResourceVariable.__iadd__Z : ;;r<ctd)Nz`variable -= value` with `tf.Variable`s is not supported. Use `variable.assign_sub(value)` to modify the variable, or `out = variable * value` if you need to get a new output Tensor.rrs r:__isub__zBaseResourceVariable.__isub__`rr<ctd)Nz`var *= value` with `tf.Variable`s is not supported. Use `var.assign(var * value)` to modify the variable, or `out = var * value` if you need to get a new output Tensor.rrs r:__imul__zBaseResourceVariable.__imul__frr<ctdNz`var /= value` with `tf.Variable`s is not supported. Use `var.assign(var / value)` to modify the variable, or `out = var / value` if you need to get a new output Tensor.rrs r:__idiv__zBaseResourceVariable.__idiv__lrr<ctdrrrs r: __itruediv__z!BaseResourceVariable.__itruediv__rrr<ctdrrrs r: __irealdiv__z!BaseResourceVariable.__irealdiv__xrr<ctd)Nz`var **= value` with `tf.Variable`s is not supported. Use `var.assign(var ** value)` to modify the variable, or `out = var ** value` if you need to get a new output Tensor.rrs r:__ipow__zBaseResourceVariable.__ipow__~rr<)NNNNNNNNNNNNNNNNNNNTr{)NNN)FNNTFNNNF)Yrrrrrrrrr contextlibcontextmanagerrrrrrr propertyrBrrHrkrArrrrr9rr&r(r`rr Operationrgrrrr3rr*r9rJrRr^rer$rrVrrr staticmethodr__array_priority__rUrrrrErrrrrrrrrrrrrrrrrrr r rrrrrr!r#r%rr<r:rrys2     +m ^&(8&+    >"#           02        &         #--    ! !  5F d34050.0.FJ+/ . 6p %% &%,\>> N82#'R ;00220005n2h2h2h"H"HC"2$)%&' ; ; ; ; ; ; ;r<rceZdZdZdZdZy)ResourceVariableGradientz6CompositeTensorGradient protocol for ResourceVariable.c|S)aReturns the components of `value` that should be included in gradients. For a ResourceVariable, its gradient component is its handle tensor. For now, we return the ResourceVariable because the gradient infrastructure has special logic to handle ResourceVariables. We should remove the special logic and return the handle tensor. Args: value: A `ResourceVariable`. Returns: `value` itself. rrs r:get_gradient_componentsz0ResourceVariableGradient.get_gradient_componentss  Lr<c|S)aReplaces the gradient components in `value` with `component_grads`. The gradient of a ResourceVariable is either None or a Tensor. So we don't need `value`'s TypeSpec or non-gradient components in this method. Args: value: A `ResourceVariable` with its gradient components compatible with `component_grads`. component_grads: A `Tensor` or None as the gradient result. Returns: The `component_grads`, which is either a `Tensor` or None. r)rrcomponent_gradss r:replace_gradient_componentsz4ResourceVariableGradient.replace_gradient_componentss  r<N)rrrrr2r5rr<r:r0r0s> r<r0ceZdZdZ ddZedZdZeZ d fd Z d dZ d fd Z xZ S) ras Variable based on resource handles. See the [Variables How To](https://tensorflow.org/guide/variables) for a high level overview. A `ResourceVariable` allows you to maintain state across subsequent calls to session.run. The `ResourceVariable` constructor requires an initial value for the variable, which can be a `Tensor` of any type and shape. The initial value defines the type and shape of the variable. After construction, the type and shape of the variable are fixed. The value can be changed using one of the assign methods. Just like any `Tensor`, variables created with `tf.Variable(use_resource=True)` can be used as inputs for other Ops in the graph. Additionally, all the operators overloaded for the `Tensor` class are carried over to variables, so you can also add nodes to the graph by just doing arithmetic on variables. Unlike ref-based variable, a ResourceVariable has well-defined semantics. Each usage of a ResourceVariable in a TensorFlow graph adds a read_value operation to the graph. The Tensors returned by a read_value operation are guaranteed to see all modifications to the value of the variable which happen in any operation on which the read_value depends on (either directly, indirectly, or via a control dependency) and guaranteed to not see any modification to the value of the variable from operations that depend on the read_value operation. Updates from operations that have no dependency relationship to the read_value operation might or might not be visible to read_value. For example, if there is more than one assignment to a ResourceVariable in a single session.run call there is a well-defined value for each operation which uses the variable's value if the assignments and the read are connected by edges in the graph. Consider the following example, in which two writes can cause tf.Variable and tf.ResourceVariable to behave differently: ```python a = tf.Variable(1.0, use_resource=True) a.initializer.run() assign = a.assign(2.0) with tf.control_dependencies([assign]): b = a.read_value() with tf.control_dependencies([b]): other_assign = a.assign(3.0) with tf.control_dependencies([other_assign]): # Will print 2.0 because the value was read before other_assign ran. If # `a` was a tf.Variable instead, 2.0 or 3.0 could be printed. tf.compat.v1.Print(b, [b]).eval() ``` c|rJ|td|d|tjrtd||j|| |y||j ||||y|j ||||||| | | || || y)a Creates a variable. Args: initial_value: A `Tensor`, or Python object convertible to a `Tensor`, which is the initial value for the Variable. 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`, the default, 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). variable_def: `VariableDef` protocol buffer. If not None, recreates the `ResourceVariable` object with its contents. `variable_def` and other arguments (except for import_scope) are mutually exclusive. import_scope: Optional `string`. Name scope to add to the ResourceVariable. Only used when `variable_def` is provided. 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. distribute_strategy: The tf.distribute.Strategy this variable is being created inside of. 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. handle: (optional) The handle of a `tf.Variable`. If provided, only `trainable`, `shape`, `dtype`, and `handle` will be used to construct this `tf.Variable`. experimental_enable_variable_lifting: Whether to lift the variable out if it's in a `tf.function`. Default is `True`. When this argument is `True`, variable creation will follow the behavior and restrictions described [here](https://www.tensorflow.org/guide/function#creating_tfvariables). If this argument is `False`, that description doesn't apply, and you can freely create and use the variable in the `tf.function`, as if it's a "mutable `tf.Tensor`". You can't return the variable though. Raises: ValueError: If the initial value is not specified, or does not have a shape and `validate_shape` is `True`. @compatibility(eager) When Eager Execution is enabled, the default for the `collections` argument is `None`, which signifies that this `Variable` will not be added to any collections. @end_compatibility NzlThe variable_def and initial_value args to `tf.Variable` are mutually exclusive, but got both: variable_def=z, initial_value=zwCreating a `tf.Variable` with a `variable_def` arg is not supported when eager execution is enabled. Got: variable_def=)rrrrArBr9) r`r collectionsrrkrBrrrrArrr)rrr|_init_from_proto_init_from_handle_init_from_args)rr`rr9rrrkrBrrrrrrrAr9rs r:rzResourceVariable.__init__s@  "))57**7:; ;  " " $..:^=> >  #')   y#(#($*,  %!')!1'/S r<c,tj|Sr{)r from_valuers r: _type_speczResourceVariable._type_speces  " "4 ((r<cDt||j|jSr{)rrBrrs r:_shape_invariant_to_type_specz.ResourceVariable._shape_invariant_to_type_specjs tzz4>> ::r<cftj|| ||\}} }| d} | tdt|}t |t j r4t|dr(|jjrtd|d|d|tjjg}t |tttfstd|d t!||%t|std t!|d ||rCtjj"|vr't|tjj"gz}tj$5t'j( |_ddd| rtj$}nt,j.}|5tj0|d |rgn|gd 5}tj2|}|j*r|}|}nd|tj4fz}d}|j*rtj6ntj8}t;j<t:j<j?tAjBd|zg}tjDjGd|i5tj0d5|d5|r|}t |tHjJr7|jM|jNjP|_)|jT}tjV|d|}dddddd| 7|jXj[| s(td|jXd| d|jX} t]|| |||j*}t_j`||_1|dz|_2||_3ddd|j*r.|,|jhjktd|d|d|jljn}|j*rtj0d5tqjr}ddd|tj0d 5}tjtdd!5tj6j65tqjv|tjx|||"}dddddddddtj0d#5tj6j65tqjz||}t}|||ddd}|Ttjtdd!5tj6|5tj|}ddddddnd}dddnbtqjv|d}d}d}|rBtj6|5tqjz||}t}|||dddnd}t_j`||_A|j*rtj||nJtjj|vr.tjtjj|ddd|j*r|nd}tt||| |||| | |||| $dddy#1swYxYw#1swYxYw#1swYxYw#1swYKxYw#1swYxYw#1swYQxYw#1swYVxYw#1swY[xYw#1swYxYw#1swYxYw#1swYxYw#1swYixYw#1swYvxYw#1swYxYw#1swYyxYw)%a}Creates a variable. 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`, the default, 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]`. 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). 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`. distribute_strategy: DistributionStrategy under which this variable was created. 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. 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. experimental_enable_variable_lifting: Whether to lift the variable out if it's in a `tf.function`. Default is `True`. When this argument is `True`, variable creation will follow the behavior and restrictions described [here](https://www.tensorflow.org/guide/function#creating_tfvariables). If this argument is `False`, that description doesn't apply, and you can freely create and use the variable in the `tf.function`, as if it's a "mutable `tf.Tensor`". You can't return the variable though. Raises: ValueError: If the initial value is not specified, or does not have a shape and `validate_shape` is `True`. @compatibility(eager) When Eager Execution is enabled, variables are never added to collections. It is not implicitly added to the `GLOBAL_VARIABLES` or `TRAINABLE_VARIABLES` collections, and the `collections` argument is ignored. @end_compatibility NTzThe `initial_value` arg to `tf.Variable` must be specified except when you are not providing a `variable_def`. You provided neither.rHzArgument `initial_value` (zS) could not be lifted out of a `tf.function`. (Tried to create variable with name='a8'). To avoid this error, when constructing `tf.Variable`s inside of `tf.function` you can create the `initial_value` tensor in a `tf.init_scope` or pass a callable `initial_value` (e.g., `tf.Variable(lambda : tf.truncated_normal([10, 40]))`). Please file a feature request if this restriction inconveniences you.zPcollections argument to Variable constructor must be a list, tuple, or set. Got z of type zDArgument `constraint` must be None or a callable. a callable. Got a z: VariableF skip_on_eager%s_%dzloc:@%srz)list_class Initializerr`)rkrBz;In this `tf.Variable` creation, the initial value's shape (zC) is not compatible with the explicitly supplied `shape` argument (z).)r`rArirkrNrz,The `initial_value` passed to `tf.Variable` z is from inside a control-flow construct, such as a loop or conditional. When creating a `tf.Variable` inside a loop or conditional, use a lambda as the `initial_value`. Got: initial_value=(r IsInitializedAssignr!rr)rrArBr9rrrrrkrrrr`rrrrr)Gr$rrcallabler2r3r4rrHbuilding_functionr GraphKeysGLOBAL_VARIABLESrGrsettypeTRAINABLE_VARIABLESrrr|rr) nullcontextrname_from_scope_nameuidrNullContextmanagerrr ListValuer as_bytesrm _attr_scoper[CheckpointInitialValue_maybe_initialize_trackablecheckpoint_position restore_uid _update_uid wrapped_valuerrArryweakrefr_parent_trackable_namerrg_get_control_flow_contextrBrxr rr#r-_try_guard_against_uninitialized_dependenciesrnrrrW_cached_variableadd_to_collections GLOBAL_STEPsuperrr)rr`rr9rrkrBrrrrrArr init_from_fnmaybe_init_scoperrirdevice_context_managerattrr9rnrrrr __class__s r:r<z ResourceVariable._init_from_argspsp @@ [)T ;,O[),3-1* ? @@M*L-!5!567w< $1$7$7$I$I 3M?C??CfE9 9 : :]]334k kD%#5 6  +}Id;6G5H J KKhz&: ,,0,<+=S N OOS]]66kI%)J)J(KKk  < ' 9 9 ;;d<+#//  Q >>  Lb}o {B#'..t4   #+!)cggi 88)+ --CJJ33I3I ''))33??9{#:;<4>? " " $ 0 0(D1A B (~~m, B.DT.J B+om-)I)IJ..0!.!B!B!N!Nd+99m11O5BM B B  &&99%@#))*+??DgRIJJ "''E-)%,, .& &-[[%6& "$t+&,'& 5 (8   M$=    6 6 8 D FMM*  ,>>MM /    ~~f% "FMM* ;/@@Oe$UFE: ;"M)$$T4@;ZZ/;!*!3!3E!:,;;;"l' " "* $ 6 6v} M" .- N+ B6GG%!l$UFLA B B  L  #+2++d*;, '     d 3 ]] & &+ 5 !:!:D Aw{Bx(,':':mm d,)!1!%%'-#''%-}QQ <<< B B B B ( (P I I       ; ;;;;; " "4 B BS{B{BQQsU[2'^'C^$\: \ A3[? 6\ >B\A:^ \& ^?]  ] 7-\3 $] ,] 4^ ^1$] #^8]4 ]' $]4 , ^7<^3$^B^+>^'2[<?\ \ \ \\# ^&\0 +^3\=8] ] ]  ] ^]$ ^']1,]4 4]> 9^^ ^^ ^^$ ^''^0ctjrJd|_t|tj sJ|j std|tj}|jtj|j|d|_ tj|jj j#d|_|jj&|_|j(|_|jtj|j,||_t1|drB|j2r6|jtj|j2||_nd|_t7j8|j:|j<|j>|j\}}}||_ ||_!||_"|jFr|jtj|jF|}|j jHd k7r||_%nd|_%|j jHd k7r3|j jLd }|j jHd k7r3||_'n>d|_%|jQ|jj j&d z|_'|jSd r1t6jTjW|jX| |_-nd|_-d|_.t_j`|jj j#d|_1d|_2||_3y)z%Initializes from `VariableDef` proto.TzThe `variable_def` you passed to `tf.Variable` is Trying to restore a TF 1.x Reference Variable as a TF 2.x ResourceVariable. This is unsupported. Got variable_def=)rF)allow_operationrArNr,rz/Read/ReadVariableOp:0r)rrrB)4rr|rr2rrrrrrmas_graph_elementprepend_name_scoperrr TensorShapergget_attrrrkrrrrrrrr$rrrrrrrrrQrrrget_tensor_by_nameHasFieldrC SaveSliceInforrrrrprrr) rrrrgrrrsnapshots r:r:z!ResourceVariable._init_from_protos ((** *D lL$<$< == =  # # +,8.: ;; A%%   & &\ C&DL**4<$> @,O[),D#DDO!!## ((| EFh   - -%! KK   0 0;;%%a( KK   0 0$dd001E1E1I2JKd23'00>>*>>#?%d#dD//$,,//":":7"CDDKD)Dr<cXt|}|js,tj||}tj||t |dr6t |jtr|jjd}nd}t|dd}t|1||||||y)Nrbrr)rrArBr9rr) r;r]r"rtset_handle_datarr2rbrrstripr{rhr) rrrArBr9rMrrrns r:r;z"ResourceVariable._init_from_handles -V4K   %77uEk&&v{;vwJv||S$ALL''-kk d3I G5f6r<)NNNTNNNNNNNNNNNN) NNNNNNNNNNNTN)NT)NNNN)rrrrrr+r?rAr0__composite_gradient__r<r:r; __classcell__rns@r:rrs2l    +/#B J ) );45   +/Sn%)&*D*N#'""# 66r<rc8eZdZdZ dfd ZxZS)rDzA variable with no initializer.c  tj5tj |_tj |dd5}tj |} |jr| } | }nd| tjfz}d} t||| ||j| }tj||_ | dz|_ ||_ |jrtj d5tj|j5tj ||}t#|||ddd}dddtj$tj&j(|nd}ddddddt+t,|^d | || |||||jd | y#1swYxYw#1swYxYw#1swYTxYw#1swYXxYw) azCreates the variable handle. Args: trainable: If `True`, GradientTapes automatically watch uses of this Variable. 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. shape: The variable's shape. dtype: The variable's dtype. 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`. extra_handle_data: Optional, another resource handle or Tensor with handle data to merge with `shape` and `dtype`. distribute_strategy: The tf.distribute.Strategy this variable is being created inside of. rCFrDrFN)rArBrirkrNr`rr) rrArBrrrr9rrrrrr)rrrr|rrrTrUrvr`rrarbrrr rnradd_to_collectionrNrOrhrDr)rrrrkrArBrrrrbrrrrirr9rrrns r:rzUninitializedVariable.__init__s^  %!( 9 9 ;;d >>$ % @!D..t4   #+!)cggi 88)+6#**+ -$+;;t#4 "T) %   ~~f% "FMM* ;/@@Oe$UFE: ;"M  "    > > E -C! %L / </#')) <.; < ; ; " "+!! %%sT3G B)G 2 G$F4 6 G9G 9G4F= 9GG G  G GG!) NNNNNNNNNN)rrrrrr~rs@r:rDrDs2'   a<aN)rF).0rYs r: z!variable_shape.. s$KaQVVr\$Ksr)rconfigtf_shape_default_int64rrint64int32r;r]r variable_shaper@rArCanyrErconstantrF)r9rrM shape_protorYs r:rr s ||~,,224hh*62+ 2 2 $ 3 3FX NN**1-33+$K;??$K!K $ 3 3FX NN   {?!qvv?x PP?s5Dcf|jd}|jd}t|}tjtj|d}tj ||ddgd}tj ||}tj ||}tj|||dfS)zGradient for gather op.rrXN) rrr expand_dimsrFconcatreshaperr)rgrr9r params_shaperF values_shapers r: _GatherGradr s 99Q<& IIaL'',   y~~g6 :$!!4ab)9":A>,   T< 0&   gt ,'  & &vw Et LLr<z%__internal__.ops.is_resource_variable)v1c>t|txs t|dS)z>"Returns True if `var` is to be considered a ResourceVariable. _should_act_as_resource_variable)r2rrrs r:is_resource_variabler s& C- . /' -3//r<c t|j|j|j|j|j |j |j|j}|j|S)z@Copies an existing variable to a new graph, with no initializer.)rrrArBrkrrrb) rDrrrArBrrrr9r[)rrQs r:rNrN s^ '  II II   ))// $,**, r<AssertVarIsInitializedOpc eZdZy)StructurePatternN)rrrrr<r:rr' sr<rc"eZdZdZfdZxZS)PLeafz-Represents a singleton leaf StructurePattern.c\t|dst| ||_|jS)Ninstance)rrh__new__r)clsrns r:rz PLeaf.__new__. s' 3 #W_S)cl <<r<)rrrrrr~rs@r:rr+ s5r<rceZdZdZdZdZy)PListz'Represents a list of StructurePatterns.c$t||_yr{)rG components)rrs r:rzPList.__init__7 s:&DOr<cXt|txr|j|jk(Sr{)r2rrrothers r:__eq__z PList.__eq__: s# eU # K5;K;K(KKr<N)rrrrrrrr<r:rr4 s/'Lr<rceZdZdZddgZedZejddffd Z dZ e d Z d Z d Zed Zd ZfdZfdZdZdZdZdZdZdZdZxZS)rzDescribes a tf.Variable. A `VariableSpec` provides metadata describing the `tf.Variable` objects accepted or returned by TensorFlow 2.x APIs. rrctSr{)rrs r:rtzVariableSpec.G s%5r<TNcLtt| ||||_||_y)Nr)rhrrrr)rrArBrrrns r:rzVariableSpec.__init__I s% ,&uE&:DNDMr<cdt|t||jfsy|jj |jxr4|j |j k(xr|j |j k(}t|t|r|xr|j|jk(S|S)aReturns True if `spec_or_value` is compatible with this `VariableSpec`. `spec_or_value` is considered to be compatible with this `VariableSpec` if * `spec_or_value` is a `Variable` or `VariableSpec`, * their shapes are compatible, * their dtypes are the same, * they are both trainable or not trainable. * they share the same alias_id if `spec_or_value` is a `VariableSpec`. Example: >>> v = tf.Variable([1., 2., 3.]) >>> spec = VariableSpec([None]) >>> spec.is_compatible_with(v) True >>> v = tf.Variable(1) >>> spec.is_compatible_with(v) False Args: spec_or_value: A VariableSpec or Variable to compare against. Returns: True if `spec_or_value` is compatible with this `VariableSpec`. F)r2rQ value_typerArrBrr)r spec_or_value compatibles r:rzVariableSpec.is_compatible_withO s6 md4j$//%B C **// 0C0CD<** 3 33<..M$;$;;-d,  CDMM]-C-CCC r<cT||j|j|jS)aCreates a `VariableSpec` from the given `Variable`. `value`'s shape, dtype, and trainable attributes will be used to create the new `VariableSpec`. Example: >>> v = tf.Variable([1., 2., 3.]) >>> VariableSpec.from_value(v) VariableSpec(shape=(3,), dtype=tf.float32, trainable=True, alias_id=None) Args: value: A Variable. Returns: A `VariableSpec` created from `value`. )rBr)rArBr)rrs r:r>zVariableSpec.from_valuet s& u{{%++ IIr<c|jgSr{r8rs r:_to_componentszVariableSpec._to_components s LL>r<cvt|ttfstd|dt |dk7rt d|d|d}t|t jr|jtjk7rt d|dt|j|j|j|S)Nz?Components of a ResourceVariable must be a list or tuple, got fz instead.rXzMComponents of a ResourceVariable must only contain its resource handle, got frz@The handle of a ResourceVariable must be a resource tensor, got r8)r2rGrrrDrr3r4rBrr[rrrA)rrr9s r:_from_componentszVariableSpec._from_components s j4- 0 %%/L ; << :! 44>>4== @@r<ct|t|ury|j|jt| |S|j |jt d|d|dt| |S)NFzDVariableSpec.is_subtype_of doesn't support alias_id=None, got self: z and other: r`)rQrrh is_subtype_ofr)rrrns r:rzVariableSpec.is_subtype_of s Dze$  }}!7 W "5 )) }} 6 #<<@6#('!, -- 7  ''r<ctfd|Dryj!td|Drt|Sjtd|Drt dd|dt|S)Nc3JK|]}tt|uywr{)rQ)rrrs r:rz>VariableSpec.most_specific_common_supertype.. s =U4:T%[ ( =s #c38K|]}|jduywr{rrrs r:rz>VariableSpec.most_specific_common_supertype.. s 7uENNd " 7c38K|]}|jduywr{rrs r:rz>VariableSpec.most_specific_common_supertype.. s#OuENNd$:#OrzUVariableSpec.most_specific_common_supertype doesn't support alias_id=None, got self: z and others: r`)rrallrhmost_specific_common_supertyper)rothersrns` r:rz+VariableSpec.most_specific_common_supertype s =f ==   7 77 W 3F ;; }}#O#O O #L#'& fXQ!@ AA 7 1& 99r<c|jr|S|jxs |j}|j}|j |j r|j |j }ntjgtj}tj|j}|j||j|}|j!|g}|j |j#|j ||j%|j&|}|j(j+dt-j.t1j2||S)Nr_user_specified_namerz) unnest_onlyrk naming_scope context_graphhas_placeholderrget_placeholderr3rrr[r InternalPlaceholderContext outer_graphupdate_naming_scopeplaceholder_valuerrcapturer9rgrrrr rX)rplaceholder_contextrkrrspec spec_context placeholders r:rzVariableSpec.placeholder_value s%&& k 99 8+88D'55M**4==9%44T]]Ch  % %b&// :d::  # #%l&&t,**<8k&& }5h  "++DMM8D ''d'CKNN  6??4#89; Or<cVt|tsJt||jgSr{)r2rrr9rs r: to_tensorszVariableSpec.to_tensors s' e1 22 2e LL>r<c*t|tsJ|Sr{)r2r)rrrs r:castzVariableSpec.cast s e1 22 2 Lr<c^tttttSr{)rrrs r:_get_structurezVariableSpec._get_structure s %'57EG 44r<c t|jd|jd|jd|jd|j d S)Nz(shape=z, dtype=z , trainable=z , alias_id=r)rQrrArBrrrs r:rzVariableSpec.__repr__ sODz""#74::,htzznM*+dmm5Fa IJr<cpt|j|j|j|jfSr{)hashrArBrrrs r:__hash__zVariableSpec.__hash__ s& TZZG HHr<ct|t|uxrj|j|jk(xrO|j|jk(xr4|j|jk(xr|j|jk(Sr{)rQrArBrrrs r:rzVariableSpec.__eq__ sj J$u+ % ,$** *C , JJ%++ % ,*...EOO*K , MMU^^ +-r<)rrrrrr+rrfloat32rr classmethodr>rrrrrrrr r r rrrr~rs@r:rr> s J')56*"(..D #JJJ(+"    A(":$: 5JI-r<rc|jj|r4|jjdst d|jdt j |j|j_|j|j_|jj|j_|jj|j_ |jj|j_ |jjj|jj|j j#r)t%|dr|j&|j_yyy)auWrites additional information of the variable into the SavedObject proto. This allows users to define a `hook` to provide extra information of the variable to the SavedObject. For example, DistributedVariable class would fill in components in the distributed context. Args: resource_variable: A `ResourceVariable` or `DistributedValue` that has the information to be saved into the proto. proto: `SavedObject` proto to update. options: A `SaveOption` instance that configures save behavior. enforce_naming: A bool determining whether to check that names end in the expected string ':0' rz#Cowardly refusing to save variable zQ because of unexpected suffix in the name (expected ':0')which won't be restored.rN)r SetInParentrkendswithrr3 get_op_namerrBas_datatype_enumrrrrACopyFromas_protorLrMrr)resource_variablerrPenforce_namings r:rr s.(..-22;;DA :)../001 22&112C2H2HI%...88%..*00AA%..#4#D#D#J#J%.. 0<<BB%.... 1 7 7 @ @ BC ))@@ (+/66enn,r<rr+c"|jS)z6Returns the XLA sharding associated with the variable.)rrs r:get_xla_shardingr4 s    r<r{r()T)prr)rtypingrr`abslrtensorflow.compiler.tf2xla.opsrtensorflow.core.configrtensorflow.core.frameworkrrtensorflow.core.functionr tensorflow.core.protobufr tensorflow.python.checkpointr tensorflow.python.clientr tensorflow.python.compatr rktensorflow.python.eagerrrrtensorflow.python.frameworkracdrrrrrr?rrrrrr3rrtensorflow.python.opsrrr r!r"r#r$/tensorflow.python.ops.gen_resource_variable_opstensorflow.python.saved_modelr&tensorflow.python.trackabler'r[tensorflow.python.typesr(tensorflow.python.utilr)"tensorflow.python.util.deprecationr* tensorflow.python.util.tf_exportr+register_read_only_resource_opr7r;rVrcrvryr*rrrrrrrCr4rCompositeTensorGradientr0CompositeTensorrrDr#register_tensor_conversion_functionrRegisterGradientrrrrrNNotDifferentiablerrr DenseSpecrregister_codecBuiltInTypeSpecCodec TypeSpecProto VARIABLE_SPECrrrr<r:r@s )6(42//86=+*(F8A3?7..6+?B4+/;/2++>@9()/96"""#34"""?3"""#34"""#56"""#56,DD,:N9= .b-J`   / / f'K%"JI;9--t{{I;X(#55#Lt6+-=-M-Mt6nd<0d>.0A*AH&'( Q6&' M( M 2r:/;/ &h*+o&  L LF-=**F-R&%%///j..<<=A#7L!.!3!r<