AVhedZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z ddl m Z ddl mZddl mZdd l mZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl"m#Z#gdZ$GddZ%GddejLZ'ejPZ(ejRZ)e'jTZ*e#dgjWe,dde*_dZ-Gdd Z.Gd!d"ej^Z0d#Z1d$Z2e2D]Z3e4e0e3e1e3d%Z5d&Z6e6D]Z3e4e0e3e5e3d'Z7d(Z8e8D]Z3e4e0e3e7e3ejre0d)ejte0d*e#d+gd,Z;e#d-gGd.d-ZGd1d2ej~Z@d3ZAe#d4gd5ZBd6ZCejd7ZEGd8d9ZFe#d:gddddddddd;ddde(je)jfd<ZId=ZJeJd>zeI_e#d?gddddd@dddd;ddde(je)jfdAZKeJdBzeK_ddddd;dddd;dde(je)jf dCZLGdDdEZMdFZNdGZOe#dHgGdIdHZPe#dJgej dTdKZQdLZRdMZSdNZTdOZUdaVdPZWe#dQgejdRZXe#dQgejdSZYy)UzHA class to store named variables and a scope operator to manage sharing.N)session)context)dtypes)ops)tensor)tensor_conversion_registry) tensor_shape) array_ops)init_ops)resource_variable_ops)resource_variables_toggle) variables) tf_logging)core)function_utils) tf_contextlib) tf_inspect)collections_abc) tf_export) AUTO_REUSE VariableScopeget_variable_scope get_variableget_local_variablevariable_scopevariable_op_scopeno_regularizerVariableSynchronizationVariableAggregationcJeZdZdZddgZdZedZedZdZ dZ y ) _PartitionInfoz3Holds partition info used by initializer functions. _full_shape _var_offsetc t|ttfs!tdt |j zt|ttfs!tdt |j zt |t |k7r-tdjt |t |t||D],\}}|dks||k\stdj||||||_ ||_ y)aConstructor. Args: full_shape: Tuple or list of `int` indicating the full combined shape of the partitioned variables. var_offset: Tuple or list of `int` specifying offset of this partition with respect to the full variable for each dimension. Raises: TypeError: If `full_shape` or `var_offset` is not a sequence. ValueError: If `full_shape` or `var_offset` differ in length. If `var_offset` exceeds `full_shape` in any dimension. z@`full_shape` must be a sequence (like tuple or list) instead of z@`var_offset` must be a sequence (like tuple or list) instead of zYExpected equal length, but `var_offset` is of length {} while full_shape is of length {}.rz[Expected 0 <= offset < shape but found offset={}, shape={} for var_offset={}, full_shape={}N) isinstancelisttuple TypeErrortype__name__len ValueErrorformatzipr"r#)self full_shape var_offsetoffsetshapes T/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/variable_scope.py__init__z_PartitionInfo.__init__9s j4- 0  L z  # # $ %% j4- 0  L z  # # $ %% :#j/)  ((.*os:)0 11 Z4?  !v ++16&%2<,>? ??"D!Dc|jSN)r"r/s r4r0z_PartitionInfo.full_shapea   r6c|jSr8)r#r9s r4r1z_PartitionInfo.var_offseter:r6cH|j|}|y|j|S)aReturns the offset when the variable is partitioned in at most one dim. Args: shape: Tuple or list of `int` indicating the shape of one specific variable partition. Returns: `int` representing the offset in the dimension along which the variable is partitioned. Returns 0 if the variable is not being partitioned. Raises: ValueError: Depending on self.single_slice_dim(). r)single_slice_dimr1)r/r3r=s r4 single_offsetz_PartitionInfo.single_offsetis0,,U3  ??+ ,,r6c t|ttfs!tdt |j zt |t |jk7rCtdj|t ||jt |jtt |D]X}|j|||z|j|kDs)tdj|j||j|d}tt |D]C}|||j|k(r|'tdj||j|||}E|S)a&Returns the slice dim when the variable is partitioned only in one dim. Args: shape: Tuple or list of `int` indicating the shape of one specific variable partition. Returns: `int` representing the dimension that the variable is partitioned in, or `None` if the variable doesn't seem to be partitioned at all. Raises: TypeError: If `shape` is not a sequence. ValueError: If `shape` is not the same length as `self.full_shape`. If the variable is partitioned in more than one dimension. z;`shape` must be a sequence (like tuple or list) instead of zcExpected equal length, but received shape={} of length {} while self.full_shape={} is of length {}.zaWith self.var_offset={}, a partition of shape={} would exceed self.full_shape={} in dimension {}.NzvCannot use single_slice_dim() with shape={} and self.full_shape={} since slice dim could be either dimension {} or {}.) r%r'r&r(r)r*r+r0r,r-ranger1)r/r3i slice_dims r4r=z_PartitionInfo.single_slice_dimsc eeT] +  G u+      5zS))  006uc%j7;7:4??7K1M NN 3u: =  eAh &); ; 228&3<= ==I 3u:  qT__Q' '   VE4??AyAC Ci r6N) r* __module__ __qualname____doc__ __slots__r5propertyr0r1r>r=r6r4r!r!4sG;m,)&"P    -,.r6r!ceZdZdZdZy) _ReuseModez1Mode for variable access within a variable scope.N)r*rCrDrErrHr6r4rJrJs 9*r6rJr)v1a+ @compatibility(TF2) `tf.compat.v1.AUTO_REUSE` is a legacy API that is a no-op when TF2 behaviors are enabled. If you rely on `get_variable` and auto-reuse, see the [model mapping guide](https://www.tensorflow.org/guide/migrate/model_mapping) for more info on how to migrate your code. Note: when you use the `tf.compat.v1.keras.utils.track_tf1_style_variables` API as described in the above guide, `get_variable` will always behave as if `v1.AUTO_REUSE` is set. Without the decorator, reuse will be ignored and new variables will always be created, regardless of if they have already been created. @end_compatibility When passed in as the value for the `reuse` flag, `AUTO_REUSE` indicates that get_variable() should create the requested variable if it doesn't exist or, if it does exist, simply return it. cttj|j}tj|st |t js|dz}|ttj|jxsgk(S)z8Returns true if the callable needs no arguments to call.rK) r+r getargspecargs isfunctionr% functoolspartialdefaults)python_callable num_argumentss r4_needs_no_argumentsrVsx j++O<AAB-    / y((9* QM #O,55;= ==r6c^eZdZdZgdZdZdejdddddddddddeje jfdZ dejdddddddddeje jf dZ dejddddddddddeje jfdZdejfd Zy) _VariableStoreaZVariable store that carries a number of named Variables. New variable names and new variables can be created; all stored variables are initialized with the initializer passed to __init__. Attributes: vars: a dictionary with string names (same as passed in GetVar) as keys and the corresponding TensorFlow Variables as values. _vars_partitioned_vars_store_eager_variablesc.i|_i|_d|_y)zCreate a variable store.FNrYr9s r4r5z_VariableStore.__init__sDJD"'Dr6NTc| t| std| ztj5t j rd} dddt j r+j s |r tdj rt} |j}dtjddddddddddtjtj ffd }t#j$||||\}}}| K|||||||||| | | | ||d}dt'j(| vst'j*| r||d<| d i|S|||||||||| | | | |||S#1swYxYw#t$rYwxYw) aGets an existing variable with these parameters or create a new one. If a variable with the given name is already stored, we return the stored variable. Otherwise, we create a new one. Set `reuse` to `True` when you only want to reuse existing Variables. Set `reuse` to `False` when you only want to create new Variables. Set `reuse` to None (the default) or tf.compat.v1.AUTO_REUSE when you want variables to be created if they don't exist or returned if they do. If initializer is `None` (the default), the default initializer passed in the constructor is used. If that one is `None` too, we use a new `glorot_uniform_initializer`. If initializer is a Tensor, we use it as a value and derive the shape from the initializer. If a partitioner is provided, a `PartitionedVariable` is returned. Accessing this object as a `Tensor` returns the shards concatenated along the partition axis. Some useful partitioners are available. See, e.g., `variable_axis_size_partitioner` and `min_max_variable_partitioner`. Args: name: The name of the new or existing variable. shape: Shape of the new or existing variable. dtype: Type of the new or existing variable (defaults to `DT_FLOAT`). initializer: Initializer for the variable. regularizer: A (Tensor -> Tensor or None) function; the result of applying it on a newly created variable will be added to the collection GraphKeys.REGULARIZATION_LOSSES and can be used for regularization. reuse: a Boolean, None, or tf.AUTO_REUSE. Controls reuse or creation of variables. When eager execution is enabled this argument is always forced to be False. trainable: If `True` also add the variable to the graph collection `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`). `trainable` defaults to `True`, unless `synchronization` is set to `ON_READ`, in which case it defaults to `False`. collections: List of graph collections keys to add the `Variable` to. Defaults to `[GraphKeys.GLOBAL_VARIABLES]` (see `tf.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. partitioner: Optional callable that accepts a fully defined `TensorShape` and dtype of the `Variable` to be created, and returns a list of partitions for each axis (currently only one axis can be partitioned). 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. use_resource: If False, creates a regular Variable. If True, creates instead an experimental ResourceVariable which has well-defined semantics. Defaults to False (will later change to True). When eager execution is enabled this argument is always forced to be true. custom_getter: Callable that takes as a first argument the true getter, and allows overwriting the internal get_variable method. The signature of `custom_getter` should match that of this method, but the most future-proof version will allow for changes: `def custom_getter(getter, *args, **kwargs)`. Direct access to all `get_variable` parameters is also allowed: `def custom_getter(getter, name, *args, **kwargs)`. A simple identity custom getter that simply creates variables with modified names is: ```python def custom_getter(getter, name, *args, **kwargs): return getter(name + '_suffix', *args, **kwargs) ``` 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`. Returns: The created or existing `Variable` (or `PartitionedVariable`, if a partitioner was used). Raises: ValueError: when creating a new variable and shape is not declared, when reusing a variable and specifying a conflicting shape, or when violating reuse during variable creation. RuntimeError: when eager execution is enabled and not called from an EagerVariableStore. Nz0Passed a custom_getter which is not callable: %sTzWhen eager execution is enabled variable reuse is only supported when an EagerVariableStore is active. See the documentation on EagerVariableStore for example usage.c|duxrt|tjxr| }| Z|sXt| st d| zt j d5j|||||||||| | | | | |cdddS|dur0| .|jvr j|||||||||d| | | | |Sd|zjvrt d|zj|||||||||| | | | |S#1swY{xYw)Nz.Partitioner must be callable, but received: %s)namer3dtype initializer regularizerreuse trainable collectionscaching_device partitionervalidate_shape use_resource constraintsynchronization aggregationT %s/part_0zNo partitioner was provided, but a partitioned version of the variable was found: %s/part_0. Perhaps a variable of the same name was already created with partitioning?)r`r3rarbrcrdrerfrgrirjrkrlrm) r%rSequencecallabler,r name_scope_get_partitioned_variabler[rZ_get_single_variable)r`r3rarbrcrdrerfrgrhrirjrkrlrm is_scalarr/s r4 _true_getterz1_VariableStore.get_variable.._true_getters" t   5/2J2J K )   $K&'( ( ^^D ! '//%%!%+%+'#-%0' ' '( 4-K/d,,,--###))%!+#.% %$ t tzz ) :<@ AB B  & &!!!''#)!'##] ' 's  C55C>)getterr`r3rarbrcrdrerfrgrhrirjrlrmrkr3rarbrcrdrerfrgrhrirjrkrlrmrH)rpr,r init_scoperexecuting_eagerlyr\ RuntimeErrorr base_dtypeAttributeErrorrfloat32rAUTOrNONEr.validate_synchronization_aggregation_trainablerfn_args has_kwargs)r/r`r3rarbrcrdrerfrgrhrirj custom_getterrkrlrmrucustom_getter_kwargss` r4rz_VariableStore.get_variablesZ -)@ I$% &&    " " $   "  ( (U 56 6  $ $  enn/44',,T#n @@ [)T ;,O[) !$$ $*$*&,$& .00? ?  # #M 2-7\*  21 22  !!!'!'#)!##s4    sE E'E$' E32E3c(|duxrt|tj}||jvrt d|zt j |}|r|j|j}d}|r|r t|||}||jvr|durt d|z|j|}|j|js#t d|d|d|jd|j|js3t d|d |jd |jjd|6|j|k7r#t d|d |d |jd|S|d urt d|zt|\}}d|z|jvrPd||dz fz|jvrt d||||dz fzd||fz|jvrt d||||fzg}t!t#|j%||D]\}\}}t'|j%|}d||fz}t)j*|dzd5||j-|||\}}|rd}n|}nt/|r|}|}nzt|tjr0t1j2|||}|jj4}d}n0t)j6||}t1j2|||}d}dddt)j*d5|j9||||||| | | | | ||}dddj;t<j>jA||j%|||jC|t=jD|||||}tGjHr |jJr||j|<|S#1swYxYw#1swYxYw)aGets or creates a sharded variable list with these parameters. The `partitioner` must be a callable that accepts a fully defined `TensorShape` and returns a sequence of integers (the `partitions`). These integers describe how to partition the given sharded `Variable` along the given dimension. That is, `partitions[1] = 3` means split the `Variable` into 3 shards along dimension 1. Currently, sharding along only one axis is supported. If the list of variables with the given name (prefix) is already stored, we return the stored variables. Otherwise, we create a new one. Set `reuse` to `True` when you only want to reuse existing Variables. Set `reuse` to `False` when you only want to create new Variables. Set `reuse` to None (the default) or tf.compat.v1.AUTO_REUSE when you want variables to be created if they don't exist or returned if they do. If initializer is `None` (the default), the default initializer passed in the constructor is used. If that one is `None` too, we use a new `glorot_uniform_initializer`. If initializer is a Tensor, we use it as a value and derive the shape from the initializer. If the initializer is a callable, then it will be called for each shard. Otherwise the initializer should match the shape of the entire sharded Variable, and it will be sliced accordingly for each shard. Some useful partitioners are available. See, e.g., `variable_axis_size_partitioner` and `min_max_variable_partitioner`. Args: name: the name of the new or existing sharded variable. partitioner: Optional callable that accepts a fully defined `TensorShape` and `dtype` of the Variable to be created, and returns a list of partitions for each axis (currently only one axis can be partitioned). shape: shape of the new or existing sharded variable. dtype: type of the new or existing sharded variable (defaults to `DT_FLOAT`). initializer: initializer for the sharded variable. regularizer: a (Tensor -> Tensor or None) function; the result of applying it on a newly created variable will be added to the collection GraphKeys.REGULARIZATION_LOSSES and can be used for regularization. reuse: a Boolean, None, or tf.AUTO_REUSE. Controls reuse or creation of variables. trainable: If `True` also add the variable to the graph collection `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`). collections: List of graph collections keys to add the Variable to. Defaults to `[GraphKeys.GLOBAL_VARIABLES]` (see `tf.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. 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. use_resource: If False, creates a regular Variable. If True, creates an experimental ResourceVariable which has well-defined semantics. Defaults to False (will later change to True). 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`. Returns: A `PartitionedVariable` object. Raises: ValueError: when creating a new variable and shape is not declared, when reusing a variable and specifying a conflicting shape, when violating reuse during variable creation, or if an existing sharded variable exists for the given name but with different sharding. NzA partitioner was provided, but an unpartitioned version of the variable was found: %s. Perhaps a variable of the same name was already created without partitioning?FztPartitioned variable with name %s already exists. Did you mean to set reuse=True or reuse=tf.AUTO_REUSE in VarScope?z%Trying to reuse partitioned variable , but specified shape  and found shape ., but specified dtype  and found dtype z, but specified partitions z and found partitions TzPartitionedVariable %s does not exist, or was not created with tf.get_variable(). Did you mean to set reuse=False or reuse=tf.AUTO_REUSE in VarScope?rnz %s/part_%drKzPartitioner returned a different partitioning than what was already found. Partitioner returned %d shards, and shard %s/part_0 was found, but %s/part_%d was not.zPartitioner returned a different partitioning than what was already found. Partitioner returned %d shards, and shard %s/part_0 was found, but so was the extra shard %s/part_%d.)r0r1z/PartitionedInitializer skip_on_eagerr`r3rara)r`r3rarbpartition_inforcrdrerfrgrirjrkrlrm)r`r3ra variable_list partitions)&r%rTensorrZr,r as_shape merge_with get_shape_call_partitionerr[is_compatible_withrar`_get_partitions_get_slice_dim_and_num_slices enumerate _iter_slicesas_listr!rrq_get_default_initializerrpr slicer{convert_to_tensorrs_set_save_slice_inforVariable SaveSliceInfoappendPartitionedVariablerryr\)r/r`rhr3rarbrcrdrerfrgrirjrkrlrminitializing_from_valuer existing_varrB num_slicesvsrAr1 var_shaper var_full_nameinit init_shapevarpartitioned_vars r4rrz(_VariableStore._get_partitioned_variablesF*5$*V]];$ tzz  248 9 ::  ! !% (E{4467eJ K$[%?j t%%% % ACG HI I++D1l  % %l&<&<&> ?%)5,2H2H2J LM M % %l&8&8 9%)5::|7I7I7N7N PQ Q   & & (J 6:|;;= ?@ @  } IKOP QQ:*EIzTTZZ' zA~. .djj @ ;tZ!^ 4 56 6 z* *djj 8 JtZ 0 12 2 B&/U]]_j)<'>3" "J %]]_=n"dAY.m >> 3 35 J  *.*G*GuE+H+3 '$' $J"J k "$ *  V]] 3j)D$**''%*&&{%@$z9=$*+. >>$  '')##))%!+#(  (     * *4*+4 67 iing3l 33  O  $ $ &$*E*E%4dT" s.  s,B,O<5!P<P P cd}| t|sd}| |r tdtj|}|t j |}|j vrM|dur|j }dz}t|tjr t||jjddd}|Dcgc] }d|dvs |c}dd }t|d d jtj||j }|B|j|js#td d |d|jd|j|j s7|j"}|j j"}td d|d|d|S|durtdz|(|tdd|j%||\}}t'j(5|r|}d}nt+j,|r|}||j/r|dt+j0|j2vr(t5j6||j9||}n&t5j6||j9|}|j:}nt=|r|}d}n tdddd| t?j@} tC|| | | | | ||| tEjFr|jHrw| rt'jJ| n.t'jLt&jNjP|r.t'jLt&jNjRtEjFr |jHr|j <tUjVddj"tY||rHfd}9t[|}t'jLt&jNj\|Scc}w#1swYzxYw)anGet or create a single Variable (e.g. a shard or entire variable). See the documentation of get_variable above (ignore partitioning components) for details. Args: name: see get_variable. shape: see get_variable. dtype: see get_variable. initializer: see get_variable. regularizer: see get_variable. partition_info: _PartitionInfo object. reuse: see get_variable. trainable: see get_variable. collections: see get_variable. caching_device: see get_variable. validate_shape: see get_variable. use_resource: see get_variable. constraint: see get_variable. synchronization: see get_variable. aggregation: see get_variable. Returns: A Variable. See documentation of get_variable above. Raises: ValueError: See documentation of get_variable above. FNTz3If initializer is a constant, do not specify shape.zjVariable %s already exists, disallowed. Did you mean to set reuse=True or reuse=tf.AUTO_REUSE in VarScope?ztensorflow/pythonrz Originally defined at: zTrying to share variable rrrrrz{Variable %s does not exist, or was not created with tf.get_variable(). Did you mean to set reuse=tf.AUTO_REUSE in VarScope?z Variable zG did not get an initializer, so its `shape` argument must be specified.rr)rarrzThe initializer passed is not valid. It should be a callable with no arguments and the shape should not be provided or an instance of `tf.keras.initializers.*' and `shape` should be fully defined.) initial_valuer`rerfrgrarirkrjrlrmr3rKz-Created variable %s with shape %s and init %sctj5tjdz5cdddcdddS#1swYnxYw dddy#1swYyxYw)Nz /Regularizer/)r colocate_withrq)r`rcvsr4make_regularizer_opz@_VariableStore._get_single_variable..make_regularizer_opsg   q ! "~~d_45 "q> " " " " " " " " " "s!A!A  A! A A!!A*)/rpr,ras_dtyper rrZr%r ResourceVariableop tracebackjoin format_listrrrar`rrrxrisclassis_fully_definedrNrOrQrRrr{rVr resource_variables_enabled _variable_v1rryr\add_to_collectionsadd_to_collection GraphKeysGLOBAL_VARIABLESTRAINABLE_VARIABLESloggingvlogr-_LazyEvalTensorREGULARIZATION_LOSSES)r/r`r3rarbrcrrdrerfrgrirjrkrlrmrrerr_msgtbx found_var dtype_strfound_type_strinit_valvariable_dtyperlazy_eval_tensorrs ` ` @r4rsz#_VariableStore._get_single_variables;^$x '< $ 4 L MM OOE "E ##E*e tzz %jj68<= c0AA B7# # VV  dd #  ?A2!A$>a ? C!2779+@+@+D#EGH H**T"i  5#;#;    $y':':'<>? ? % %ioo 6JJ "-- >;< < } :<@A BB  v+ +  .2-J-J5.K./*k*  -    k *# +  !7!7!9 !6!6{!C!H!H H (()./48FHH !(().GH ++.  - (.,- ---:.IIKl %%!' A  "t'B'B  {A. cmm<? cmmAA. 0 HW@D--s< P< P<.props 4&& --r6)rG)r`rs` r4_make_master_propertyrs . . +r6)deviceragraphr`rr3 value_indexcfd}|S)Nc<t|j|i|Sr8rr/rOkwargsr`s r4methodz#_make_master_method..methods" -74&& -t >v >>r6rHr`rs` r4_make_master_methodrs ? -r6)r__str__ shape_as_listcfd}|S)NcDt|j|i|Sr8)rrrs r4rz_make_op_method..methods# +74??$d +T r#sS^^E4%Hr6c"|jgdfS)Nc |dSNrrH) fetched_valss r4r#z..s Qr6)r)fetchs r4r#r#sE(()+OPr6rcy)z9Use this function to prevent regularization of variables.NrH)_s r4rrs r6rceZdZdZdddddddej ddf dZedZedZ edZ edZ ed Z ed Z ed Zed Zed ZedZedZdZdZdZdZdZdZdZdZdZdZdZdZdddddddddddddej@e!jDfdZ#dddddddddddej@e!jDf dZ$y)raVariable scope object to carry defaults to provide to `get_variable`. Many of the arguments we need for `get_variable` in a variable store are most easily handled with a context. This object is used for the defaults. Attributes: name: name of the current scope, used as prefix in get_variable. initializer: default initializer passed to get_variable. regularizer: default regularizer passed to get_variable. reuse: Boolean, None, or tf.compat.v1.AUTO_REUSE, setting the reuse in get_variable. When eager execution is enabled this argument is always forced to be False. caching_device: string, callable, or None: the caching device passed to get_variable. partitioner: callable or `None`: the partitioner passed to `get_variable`. custom_getter: default custom getter passed to get_variable. name_scope: The name passed to `tf.name_scope`. dtype: default type passed to get_variable (defaults to DT_FLOAT). use_resource: if False, create a normal Variable; if True create an experimental ResourceVariable with well-defined semantics. Defaults to False (will later change to True). When eager execution is enabled this argument is always forced to be True. 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. rNc ||_||_||_||_||_||_||_||_| |_| |_ | |_ tjr*|j tdt|_d|_ yy)z6Creates a new VariableScope with the given properties.NzECaching devices is not yet supported when eager execution is enabled.T)_name _initializer _regularizer_reuse_caching_device _partitioner_custom_getter _name_scope_dtype _use_resource _constraintrryNotImplementedErrorr) r/rdr`rbrcrgrhrrqrarjrks r4r5zVariableScope.__init__CsDJ#D#DDK)D#D'D!DDK%D!D  "   )!#EF Fdkd #r6c|jSr8)r-r9s r4r`zVariableScope.namebs ::r6c|jSr8)r4r9s r4original_name_scopez!VariableScope.original_name_scopefr:r6c|jSr8r0r9s r4rdzVariableScope.reusej ;;r6c|jSr8r.r9s r4rbzVariableScope.initializern   r6c|jSr8r5r9s r4razVariableScope.dtyperr>r6c|jSr8)r6r9s r4rjzVariableScope.use_resourcevs   r6c|jSr8r/r9s r4rczVariableScope.regularizerzrAr6c|jSr8)r1r9s r4rgzVariableScope.caching_device~s   r6c|jSr8r2r9s r4rhzVariableScope.partitionerrAr6c|jSr8r3r9s r4rzVariableScope.custom_getters   r6c|jSr8)r7r9s r4rkzVariableScope.constraintr:r6cd|_y)zReuse variables in this scope.TNr=r9s r4reuse_variableszVariableScope.reuse_variabless DKr6c||_y)zSet initializer for this scope.Nr@)r/rbs r4set_initializerzVariableScope.set_initializer #Dr6c||_y)zSet data type for this scope.NrC)r/ras r4 set_dtypezVariableScope.set_dtypes DKr6cTtjr |s td||_y)z5Sets whether to use ResourceVariables for this scope.zEWhen eager execution is enabled, use_resource cannot be set to false.N)rryr,r6)r/rjs r4set_use_resourcezVariableScope.set_use_resources*  "< > ??%Dr6c||_y)zSet regularizer for this scope.NrF)r/rcs r4set_regularizerzVariableScope.set_regularizerrQr6cPtjr td||_y)z"Set caching_device for this scope.zFCaching devices are not yet supported when eager execution is enabled.N)rryr8r1)r/rgs r4set_caching_devicez VariableScope.set_caching_devices+  " !C DD)Dr6c||_y)zSet partitioner for this scope.NrI)r/rhs r4set_partitionerzVariableScope.set_partitionerrQr6c||_y)z!Set custom getter for this scope.NrK)r/rs r4set_custom_getterzVariableScope.set_custom_getters 'Dr6ch|jr|jdznd}tj||S)zGet this scope's variables./r)r-rget_collection)r/r`scopes r4r`zVariableScope.get_collections+ $ DJJ E   dE **r6cT|jtjjS)z%Get this scope's trainable variables.)r`rrrr9s r4trainable_variablesz!VariableScope.trainable_variabless   s}}@@ AAr6cT|jtjjS)z"Get this scope's global variables.)r`rrrr9s r4global_variableszVariableScope.global_variabless   s}}== >>r6cT|jtjjS)z!Get this scope's local variables.)r`rrLOCAL_VARIABLESr9s r4local_variableszVariableScope.local_variabless   s}}<< ==r6Tc| |j}| |j} | |j} | |j}t j rd}d} n| |j }| |j} |jr|jdz|zn|}tjdd5|M|Kt|s@tj|jj}||k7rtd|d|d| |j }| |j"}| |j$}|j'|||||||| | | | | |||| cdddS#1swYyxYw) =Gets an existing variable with this name or create a new one.NFTr_rzInitializer type 'z' and explicit dtype 'z' don't match.)r3rarbrcrdrerfrgrhrirjrrkrlrm)r/r1r2r3rryr0r6r`rrqrprrar{r,r.r7r5r)r/ var_storer`r3rarbrcrdrerfrgrhrirjrrkrlrm full_name init_dtypes r4rzVariableScope.get_variables&%%k++n%%k))m  "el    )) *.)) C$&I E 2#   7{#**;7==HH  -7@A A  ''  %%    # # !!!'!'#%)!!$####s %BE  Ecp| |j}| |j}| |j} | |j} | |j} | |j }| |j } |jtd|jz| tdg}|jr|j|j|r|j|dj|}tjdd5|j||||||j||| | | | | ||cdddS#1swYyxYw)rjN Private access to _get_partitioned_variable is not allowed when a custom getter is set. Current custom getter: %s. It is likely that you're using create_partitioned_variables. If so, consider instead using get_variable with a non-empty partitioner parameter instead.zNo partitioner was specifiedr_Frrw)r.r/r7r1r2r5r6r3r,r`rrrrqrrrd)r/rkr`r3rarbrcrerfrgrhrirjrkrlrmfull_name_listrls r4rrz'VariableScope._get_partitioned_variable se"%%k%%k##j++n%%k }kke''l &  +.2-@-@  A BB 5 66 N yyDII& D!(I E 2#  0 0 !! !'!'#)!1####s 8*D,,D5)%r*rCrDrErr}r5rGr`r;rdrbrarjrcrgrhrrkrNrPrSrUrWrYr[r]r`rcrerhrr~rrrrrrHr6r4rr"sB"!^^  >                        $&$*$(+ B?>##!#"&#"& $!%"#:#?#?277#F#V'+&*,0,0*.,0/3,0/3-1+/0G0L0L,?,D,DH#r6)__variable_store) __varscopec4eZdZdZfdZdZdZdZxZS)_VariableScopeStorezEA thread local store for the current variable scope and scope counts.cXtt| td|_i|_y)NF)superrtr5r current_scopevariable_scopes_count)r/ __class__s r4r5z_VariableScopeStore.__init__`s& t-/&u-D!#Dr6cn||jvr|j|xxdz cc<yd|j|<y)NrK)rxr/ scope_names r4open_variable_scopez'_VariableScopeStore.open_variable_scopees6T///   ,1,/0d  ,r6c|!|jD]}d|j|<y|dz}t|}|jD]}|d||k(s d|j|<y)Nrr_)rxr+)r/r|kstartswith_checkstartswith_lens r4close_variable_subscopesz,_VariableScopeStore.close_variable_subscopesksz))*!()""1%*$c)+,n)),! _n !1 1*+$ $ $Q ',r6c:|jj|dSr&)rxgetr{s r4variable_scope_countz(_VariableScopeStore.variable_scope_countvs  % % ) )*a 88r6) r*rCrDrEr5r}rr __classcell__)rys@r4rtrt]sM$ 1 ,9r6rtctjt}|s&t}tjt||S|d}|S)z4Returns the variable scope store for current thread.r)rr`_VARSCOPESTORE_KEYrtr) scope_stores r4get_variable_scope_storerzsH""#56+ %'K,k: a.K r6rc*tjS)a{Returns the current variable scope. @compatibility(TF2) Although it is a legacy `compat.v1` api, `tf.compat.v1.get_variable` is compatible with eager execution and `tf.function` However, to maintain variable-scope based variable reuse you will need to combine it with `tf.compat.v1.keras.utils.track_tf1_style_variables`. (Though it will behave as if reuse is always set to `tf.compat.v1.AUTO_REUSE`.) See the [migration guide](https://www.tensorflow.org/guide/migrate/model_mapping) for more info. The TF2 equivalent, if you are just trying to track variable name prefixes and not control `get_variable`-based variable reuse, would be to use `tf.name_scope` and capture the output of opening the scope (which represents the current name prefix). For example: ```python x = tf.name_scope('foo') as current_scope: ... ``` @end_compatibility )rrwrHr6r4rrs< " # 1 11r6ctjt}|r|dSt}tjt||Sr&)rr` _VARSTORE_KEYrXr)stores r4_get_default_variable_storers;  ] +% 8O  % u- ,r6c#Ktjt}t|}|g|dd d||ddy#||ddwxYwwr8)rget_collection_refrr&)rstore_collectionolds r4with_variable_storersM++M: #1 Q#Qs+A8A?Ac6eZdZdZd dZdZdZdZdZdZ y) EagerVariableStoreaWrapper allowing functional layers to be used with eager execution. When eager execution is enabled Variables get deleted when they go out of scope, and are not stored in global collections by default. A lot of code (mostly the functional layers in tf.layers) assumes that variables are kept in a global list. EagerVariableStore can be used in conjunction with this code to make it eager-friendly. For example, to create a dense layer, use: ``` container = tfe.EagerVariableStore() for input in dataset_iterator: with container.as_default(): x = tf.compat.v1.layers.dense(input, name="l1") print(container.variables) # Should print the variables used in the layer. ``` Nc||js td||_nt|_d|j_y)NzcCannot construct EagerVariableStore from a VariableStore object that does not hold eager variables.T)r\r,_storerX)r/rs r4r5zEagerVariableStore.__init__sB   ) )&' 'dk"$dk)-DKK&r6c,t|jSr8)rrr9s r4 as_defaultzEagerVariableStore.as_defaults t{{ ++r6cbt|jjjdS)Nc|jSr8r`rs r4r#z.EagerVariableStore.variables..s AFFr6key)sortedrrZvaluesr9s r4rzEagerVariableStore.variabless# $++##**,2B CCr6ct|jjjDcgc]}|js|c}dScc}w)Nc|jSr8rrs r4r#z8EagerVariableStore.trainable_variables.. r6rrrrZrrer/rs r4rcz&EagerVariableStore.trainable_variabless; dkk//668HAKK1H& ((H A A ct|jjjDcgc]}|jr|c}dScc}w)Nc|jSr8rrs r4r#z.rr6rrrs r4non_trainable_variablesz*EagerVariableStore.non_trainable_variabless; dkk//668L 1L& ((Lrct}|jjjD]y\}} |jj d}|jd|}tj|j||j}||jj|<{|S#t $r|j}YdwxYw)a8Copy this variable store and all of its contents. Variables contained in this store will be copied over to the new variable store, meaning that they can be modified without affecting the variables in this store. Returns: A new EagerVariableStore instance containing copied variables. :N)r`re) rrrZitemsr`indexr,r r read_valuere)r/ new_storerrrstripped_var_namenew_vars r4copyzEagerVariableStore.copys#$IKK%%++- ,S-s# HHVe,&66 .. !2cmmMg$+iS! , %HH%sB--CCr8) r*rCrDrEr5rrrcrrrHr6r4rrs&& .,D( ( r6rrTcdtjt|||||||||| | | | | |S)N)r3rarbrcrerfrgrhrirjrrkrlrm)rrrr`r3rarbrcrerfrgrhrirjrrkrlrms r4rr sR   * *!#  ##!%! + r6a^%s @compatibility(TF2) Although it is a legacy `compat.v1` api, `tf.compat.v1.get_variable` is mostly compatible with eager execution and `tf.function` but only if you combine it with the `tf.compat.v1.keras.utils.track_tf1_style_variables` decorator. (Though it will behave as if reuse is always set to `AUTO_REUSE`.) See the [model migration guide](https://www.tensorflow.org/guide/migrate/model_mapping) for more info. If you do not combine it with `tf.compat.v1.keras.utils.track_tf1_style_variables`, `get_variable` will create a brand new variable every single time it is called and will never reuse variables, regardless of variable names or `reuse` arguments. The TF2 equivalent of this symbol would be `tf.Variable`, but note that when using `tf.Variable` you must make sure you track your variables (and regularizer arguments) either manually or via `tf.Module` or `tf.keras.layers.Layer` mechanisms. A section of the [migration guide](https://www.tensorflow.org/guide/migrate/model_mapping#incremental_migration_to_native_tf2) provides more details on incrementally migrating these usages to `tf.Variable` as well. Note: The `partitioner` arg is not compatible with TF2 behaviors even when using `tf.compat.v1.keras.utils.track_tf1_style_variables`. It can be replaced by using `ParameterServerStrategy` and its partitioners. See the [multi-gpu migration guide](https://www.tensorflow.org/guide/migrate/multi_worker_cpu_gpu_training) and the ParameterServerStrategy guides it references for more info. @end_compatibility %sThis function prefixes the name with the current variable scope and performs reuse checks. See the [Variable Scope How To](https://tensorflow.org/guide/variables) for an extensive description of how reusing works. Here is a basic example: ```python def foo(): with tf.variable_scope("foo", reuse=tf.AUTO_REUSE): v = tf.get_variable("v", [1]) return v v1 = foo() # Creates v. v2 = foo() # Gets the same, existing v. assert v1 == v2 ``` If initializer is `None` (the default), the default initializer passed in the variable scope will be used. If that one is `None` too, a `glorot_uniform_initializer` will be used. The initializer can also be a Tensor, in which case the variable is initialized to this value and shape. Similarly, if the regularizer is `None` (the default), the default regularizer passed in the variable scope will be used (if that is `None` too, then by default no regularization is performed). If a partitioner is provided, a `PartitionedVariable` is returned. Accessing this object as a `Tensor` returns the shards concatenated along the partition axis. Some useful partitioners are available. See, e.g., `variable_axis_size_partitioner` and `min_max_variable_partitioner`. Args: name: The name of the new or existing variable. shape: Shape of the new or existing variable. dtype: Type of the new or existing variable (defaults to `DT_FLOAT`). initializer: Initializer for the variable if one is created. Can either be an initializer object or a Tensor. If it's a Tensor, its shape must be known unless validate_shape is False. regularizer: A (Tensor -> Tensor or None) function; the result of applying it on a newly created variable will be added to the collection `tf.GraphKeys.REGULARIZATION_LOSSES` and can be used for regularization. %scollections: List of graph collections keys to add the Variable to. Defaults to `[%s]` (see `tf.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. partitioner: Optional callable that accepts a fully defined `TensorShape` and `dtype` of the Variable to be created, and returns a list of partitions for each axis (currently only one axis can be partitioned). 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. For this to be used the initializer must be a Tensor and not an initializer object. use_resource: If False, creates a regular Variable. If true, creates an experimental ResourceVariable instead with well-defined semantics. Defaults to False (will later change to True). When eager execution is enabled this argument is always forced to be True. custom_getter: Callable that takes as a first argument the true getter, and allows overwriting the internal get_variable method. The signature of `custom_getter` should match that of this method, but the most future-proof version will allow for changes: `def custom_getter(getter, *args, **kwargs)`. Direct access to all `get_variable` parameters is also allowed: `def custom_getter(getter, name, *args, **kwargs)`. A simple identity custom getter that simply creates variables with modified names is: ```python def custom_getter(getter, name, *args, **kwargs): return getter(name + '_suffix', *args, **kwargs) ``` 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`. Returns: The created or existing `Variable` (or `PartitionedVariable`, if a partitioner was used). Raises: ValueError: when creating a new variable and shape is not declared, when violating reuse during variable creation, or when `initializer` dtype and `dtype` don't match. Reuse is set inside `variable_scope`. )zDGets an existing variable with these parameters or create a new one.rz~trainable: If `True` also add the variable to the graph collection `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`). zGraphKeys.GLOBAL_VARIABLESrFc|r|tjjgz }ntjjg}t|||||d|||| | | || | S)NF)r3rarbrcrerfrgrhrirjrlrmrrk)rrrgrrs r4rrsj"CMM1122K==001K   ##%! r6)z7Gets an existing *local* variable or creates a new one.zBehavior is the same as in `get_variable`, except that variables are added to the `LOCAL_VARIABLES` collection and `trainable` is set to `False`. rzGraphKeys.LOCAL_VARIABLESct}|jtd|jz|jt |||||||||| | | | | S)aGets or creates a sharded variable list with these parameters. The `partitioner` must be a callable that accepts a fully defined `TensorShape` and returns a sequence of integers (the `partitions`). These integers describe how to partition the given sharded `Variable` along the given dimension. That is, `partitions[1] = 3` means split the `Variable` into 3 shards along dimension 1. Currently, sharding along only one axis is supported. If the list of variables with the given name (prefix) is already stored, we return the stored variables. Otherwise, we create a new one. If initializer is `None` (the default), the default initializer passed in the constructor is used. If that one is `None` too, we use a new `glorot_uniform_initializer`. If initializer is a Tensor, we use it as a value and derive the shape from the initializer. If the initializer is a callable, then it will be called for each shard. Otherwise the initializer should match the shape of the entire sharded Variable, and it will be sliced accordingly for each shard. Some useful partitioners are available. See, e.g., `variable_axis_size_partitioner` and `min_max_variable_partitioner`. Args: name: The name of the new or existing variable. shape: Shape of the new or existing variable. dtype: Type of the new or existing variable (defaults to `DT_FLOAT`). initializer: Initializer for the variable if one is created. regularizer: A (Tensor -> Tensor or None) function; the result of applying it on a newly created variable will be added to the collection GraphKeys.REGULARIZATION_LOSSES and can be used for regularization. trainable: If `True` also add the variable to the graph collection `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`). collections: List of graph collections keys to add the Variable to. Defaults to `[GraphKeys.GLOBAL_VARIABLES]` (see `tf.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. partitioner: Optional callable that accepts a fully defined `TensorShape` and `dtype` of the Variable to be created, and returns a list of partitions for each axis (currently only one axis can be partitioned). 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. use_resource: If False, creates a regular Variable. If True, creates an experimental ResourceVariable instead which has well-defined semantics. Defaults to False (will later change to True). 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`. Returns: A tuple `(shards, partitions)` where `shards` is the list of `Variable` shards and `partitions` is the output of the partitioner on the input shape. Raises: ValueError: when creating a new variable and shape is not declared, or when violating reuse during variable creation. Reuse is set inside `variable_scope`. ro) r3rarbrcrerfrgrhrirjrkrlrm)rrr,rrr)r`r3rarbrcrerfrgrhrirjrkrlrmras r4rrrrst  % $  ),1+>+>  ? @@  ( (!#  ##% ) r6c LeZdZdZdddddddej ddf dZdZdZy)_pure_variable_scopez@A context for the variable_scope, see `variable_scope` for docs.Nc ||_||_||_||_||_||_||_||_| |_| |_ | |_ t|_ t|_d|_t!|jt"rJ|jj$|_|jj(} t#|js|jj*n |j|j&|jj,|jj.|jj0|jj2|jj4|jj6| |jj8|j } |j| j;|j|j| j=|j|j| j?|j|j | jA|j |j 9| jCtE|j |jj6|j| jG|j|j| jI|j| |_%yy)a5Creates a context for the variable_scope, see `variable_scope` for docs. Note: this does not create a name scope. Args: name_or_scope: `string` or `VariableScope`: the scope to open. reuse: `True` or None, or tf.compat.v1.AUTO_REUSE; if `None`, we inherit the parent scope's reuse flag. initializer: default initializer for variables within this scope. regularizer: default regularizer for variables within this scope. caching_device: default caching device for variables within this scope. partitioner: default partitioner for variables within this scope. custom_getter: default custom getter for variables within this scope. old_name_scope: the original name scope when re-entering a variable scope. dtype: type of the variables within this scope (defaults to `DT_FLOAT`). use_resource: If False, variables in this scope will be regular Variables. If True, experimental ResourceVariables will be creates instead, with well-defined semantics. Defaults to False (will later change to True). 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. N) r`rbrcrgrhrarrqrjrk)&_name_or_scoper0r.r/r1r2r3_old_name_scoper5r6r7r _var_storer_var_scope_store_last_variable_scope_objectr%rr` _new_namer4rdrbrcrgrhrarrjrPrWrYr[r]_maybe_wrap_custom_getterrSrU_cached_variable_scope_object)r/ name_or_scoperdrbrcrgrhrold_name_scoperarjrkrqvariable_scope_objects r4r5z_pure_variable_scope.__init__esYL(DDK#D#D)D#D'D)DDK%D!D13DO46D'+D$$%%}5**//dn&&22j ,+/;;$   # #DKK~~))55))55,,;;))55##))++99**77%% '    &--d.?.?@   &--d.?.?@   )001E1EF   &--d.?.?@   (// %d&9&9&*&9&9&G&G I J  '' 4   '..t/A/AB+@d(G6r6c |jj|_t|jt ra|jj |jtj|jj|_ |j}n|jjr&|jjdz|jzn |j|_|jxs|jj|_ |j |j}n |j}t |j|j|jj |jj"|jj$|jj&|jj(|jj*|jj,||j. }|j0|j3|j0|j4|j7|j4|j8|j;|j8|j<|j?|j<|j@9|jCtE|j@|jj,|jF|jI|jF|jJ|jM|jJ|jj |j||j_||_'|S)aBegins the scope block. Returns: A VariableScope. Raises: ValueError: when trying to reuse within a create scope, or create within a reuse scope, or if reuse is not `None` or `True`. TypeError: when the types of some arguments are not appropriate. r_) r`rbrcrgrhrarjrrqrk)(rrw_oldr%rrr}rrrx_old_subscopesrr`r0rdrrbrcrgrhrarjrr7r.rPr/rWr1rYr2r[r3r]rr5rSr6rUr)r/rrqs r4 __enter__z_pure_variable_scope.__enter__s%%33DI$%%}5 //? II    5 57d"@@"& ))..3     595H5H n[[%YY__ k   %(( )) + ++~~ii++ii++11ii++ yy-- //%% '    &--d.?.?@   &--d.?.?@   )001E1EF   &--d.?.?@   (// %d&9&9&*ii&=&= ? @  '' 4   '..t/A/AB //?*?D'' ??$%%}5484G4Gd1 44T^^D*.))D'r6) r*rCrDrErr}r5rrrHr6r4rrbs<H"!"^^ WAr<!| 4r6rcSfd}|S)z@Wrap a call to a custom_getter to use the old_getter internally.cDtj|g|i|Sr8)rQrR)rvrOrr old_getters r4wrapped_custom_getterz8_maybe_wrap_custom_getter..wrapped_custom_getters' **:v> P P PPr6rH)rrrs`` r4rrs Q r6ct}t}|jr|jdz|zn|}|j|dk(r|Sd}|j|d|zzdkDr |dz }|j|d|zzdkDr |d|zzS)zFGet a name with the given prefix unique in the current variable scope.r_rrKz_%d)rrr`r)prefixvar_scope_storerwr`idxs r4_get_unique_variable_scopers,./$&-.;.@.@  c !F *f$))$/14 M #,,TUS[-ABQF1HC ,,TUS[-ABQF 53; r6rcBeZdZdZ ddZdZdZdZy)raA context manager for defining ops that creates variables (layers). @compatibility(TF2) Although it is a legacy `compat.v1` api, `tf.compat.v1.variable_scope` is mostly compatible with eager execution and `tf.function` as long as you combine it with the `tf.compat.v1.keras.utils.track_tf1_style_variables` decorator (though it will behave as if reuse is always set to `AUTO_REUSE`.) See the [model migration guide]( https://www.tensorflow.org/guide/migrate/model_mapping) for more info on migrating code that relies on `variable_scope`-based variable reuse. When you use it with eager execution enabled but without `tf.compat.v1.keras.utils.track_tf1_style_variables`, `tf.compat.v1.variable_scope` will still be able to prefix the names of variables created within the scope but it will not enable variable reuse or error-raising checks around variable reuse (`get_variable` calls within it would always create new variables). Once you have switched away from `get_variable`-based variable reuse mechanisms, to switch to TF2 APIs you can just use `tf.name_scope` to prefix variable names. @end_compatibility This context manager validates that the (optional) `values` are from the same graph, ensures that graph is the default graph, and pushes a name scope and a variable scope. If `name_or_scope` is not None, it is used as is. If `name_or_scope` is None, then `default_name` is used. In that case, if the same name has been previously used in the same scope, it will be made unique by appending `_N` to it. Variable scope allows you to create new variables and to share already created ones while providing checks to not create or share by accident. For details, see the [Variable Scope How To](https://tensorflow.org/guide/variables), here we present only a few basic examples. The Variable Scope works as expected when the Eager Execution is Disabled. ```python tf.compat.v1.disable_eager_execution() ``` Simple example of how to create a new variable: ```python with tf.compat.v1.variable_scope("foo"): with tf.compat.v1.variable_scope("bar"): v = tf.compat.v1.get_variable("v", [1]) assert v.name == "foo/bar/v:0" ``` Simple example of how to reenter a premade variable scope safely: ```python with tf.compat.v1.variable_scope("foo") as vs: pass # Re-enter the variable scope. with tf.compat.v1.variable_scope(vs, auxiliary_name_scope=False) as vs1: # Restore the original name_scope. with tf.name_scope(vs1.original_name_scope): v = tf.compat.v1.get_variable("v", [1]) assert v.name == "foo/v:0" c = tf.constant([1], name="c") assert c.name == "foo/c:0" ``` Keep in mind that the counters for `default_name` are discarded once the parent scope is exited. Therefore when the code re-enters the scope (for instance by saving it), all nested default_name counters will be restarted. For instance: ```python with tf.compat.v1.variable_scope("foo") as vs: with tf.compat.v1.variable_scope(None, default_name="bar"): v = tf.compat.v1.get_variable("a", [1]) assert v.name == "foo/bar/a:0", v.name with tf.compat.v1.variable_scope(None, default_name="bar"): v = tf.compat.v1.get_variable("b", [1]) assert v.name == "foo/bar_1/b:0" with tf.compat.v1.variable_scope(vs): with tf.compat.v1.variable_scope(None, default_name="bar"): v = tf.compat.v1.get_variable("c", [1]) assert v.name == "foo/bar/c:0" # Uses bar instead of bar_2! ``` Basic example of sharing a variable AUTO_REUSE: ```python def foo(): with tf.compat.v1.variable_scope("foo", reuse=tf.compat.v1.AUTO_REUSE): v = tf.compat.v1.get_variable("v", [1]) return v v1 = foo() # Creates v. v2 = foo() # Gets the same, existing v. assert v1 == v2 ``` Basic example of sharing a variable with reuse=True: ```python with tf.compat.v1.variable_scope("foo"): v = tf.compat.v1.get_variable("v", [1]) with tf.compat.v1.variable_scope("foo", reuse=True): v1 = tf.compat.v1.get_variable("v", [1]) assert v1 == v ``` Sharing a variable by capturing a scope and setting reuse: ```python with tf.compat.v1.variable_scope("foo") as scope: v = tf.compat.v1.get_variable("v", [1]) scope.reuse_variables() v1 = tf.compat.v1.get_variable("v", [1]) assert v1 == v ``` To prevent accidental sharing of variables, we raise an exception when getting an existing variable in a non-reusing scope. ```python with tf.compat.v1.variable_scope("foo"): v = tf.compat.v1.get_variable("v", [1]) v1 = tf.compat.v1.get_variable("v", [1]) # Raises ValueError("... v already exists ..."). ``` Similarly, we raise an exception when trying to get a variable that does not exist in reuse mode. ```python with tf.compat.v1.variable_scope("foo", reuse=True): v = tf.compat.v1.get_variable("v", [1]) # Raises ValueError("... v does not exists ..."). ``` Note that the `reuse` flag is inherited: if we open a reusing scope, then all its sub-scopes become reusing as well. A note about name scoping: Setting `reuse` does not impact the naming of other ops such as mult. See related discussion on [github#6189](https://github.com/tensorflow/tensorflow/issues/6189) Note that up to and including version 1.0, it was allowed (though explicitly discouraged) to pass False to the reuse argument, yielding undocumented behaviour slightly different from None. Starting at 1.1.0 passing None and False as reuse has exactly the same effect. A note about using variable scopes in multi-threaded environment: Variable scopes are thread local, so one thread will not see another thread's current scope. Also, when using `default_name`, unique scopes names are also generated only on a per thread basis. If the same name was used within a different thread, that doesn't prevent a new thread from creating the same scope. However, the underlying variable store is shared across threads (within the same graph). As such, if another thread tries to create a new variable with the same name as a variable created by a previous thread, it will fail unless reuse is True. Further, each thread starts with an empty variable scope. So if you wish to preserve name prefixes from a scope from the main thread, you should capture the main thread's scope and re-enter it in each thread. For e.g. ``` main_thread_scope = variable_scope.get_variable_scope() # Thread's target function: def thread_target_fn(captured_scope): with variable_scope.variable_scope(captured_scope): # .... regular code for this thread thread = threading.Thread(target=thread_target_fn, args=(main_thread_scope,)) ``` Nc||_||_||_||_||_||_||_||_| |_| |_ | |_ | |_ |j|j td|jdurd|_|jdus)|j|jtus td|jg|_tj |_|j"r$t%j&|j|_d|_d|_t/| t0stdj3| | |_y)a Initialize the context manager. Args: name_or_scope: `string` or `VariableScope`: the scope to open. default_name: The default name to use if the `name_or_scope` argument is `None`, this name will be uniquified. If name_or_scope is provided it won't be used and therefore it is not required and can be None. values: The list of `Tensor` arguments that are passed to the op function. initializer: default initializer for variables within this scope. regularizer: default regularizer for variables within this scope. caching_device: default caching device for variables within this scope. partitioner: default partitioner for variables within this scope. custom_getter: default custom getter for variables within this scope. reuse: `True`, None, or tf.compat.v1.AUTO_REUSE; if `True`, we go into reuse mode for this scope as well as all sub-scopes; if tf.compat.v1.AUTO_REUSE, we create variables if they do not exist, and return them otherwise; if None, we inherit the parent scope's reuse flag. When eager execution is enabled, new variables are always created unless an EagerVariableStore or template is currently active. dtype: type of variables created in this scope (defaults to the type in the passed scope, or inherited from parent scope). use_resource: If False, all variables will be regular Variables. If True, experimental ResourceVariables with well-defined semantics will be used instead. Defaults to False (will later change to True). When eager execution is enabled this argument is always forced to be True. 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. auxiliary_name_scope: If `True`, we create an auxiliary name scope with the scope. If `False`, we don't create it. Note that the argument is not inherited, and it only takes effect for once when creating. You should only use it for re-entering a premade variable scope. Returns: A scope that can be captured and reused. Raises: ValueError: when trying to reuse within a create scope, or create within a reuse scope. TypeError: when the types of some arguments are not appropriate. Nz6If default_name is None then name_or_scope is requiredFTz2The reuse parameter must be True or False or None.z@The auxiliary_name_scope must be `True` or `False`, while get {})r _default_name_valuesr.r/r1r2r3r0r5r6r7r(rr,rry_in_graph_moder_get_graph_from_inputs_graph_cached_pure_variable_scope_current_name_scoper%boolr-_auxiliary_name_scope)r/r default_namerrbrcrgrhrrdrarjrkauxiliary_name_scopes r4r5zvariable_scope.__init__sLv(D%DDL#D#D)D#D'DDKDK%D!D !d&9&9&A N OO {{edk KK4 {{"{{j( K LL ||dl%7799D ..t||> e4- $6$@$@$B !$6 d))3 /2...BB.2   ++))))//))--)++++'' ) (;(E(E(G %,?(**#' 2   ++))))//))--++++'' ) (;(E(E(G %,?(** LMM-3   E23"4">">"@"4d6t7I7IJ0 ''''--''++0 ))%% '&9&C&C&E#*=d& ((]  %  % %s||~ 6 (  &  & &  7 &  &  & &  7 ###S\\^4 $$$clln5 s<M!N N/6OO=!$N$N,/$O$O:=$P!c  |jj||| |jr|jj||||jr+|js|j j|||yyy#|jr+|js|j j|||wwwxYw# |jr|jj||||jr+|js|j j|||www#|jr+|js|j j|||wwwxYwxYwr8)rrrrrrrs r4rzvariable_scope.__exit__ sJ > &&//)0=?>  # #  " " + +Hi,9 ;   t'>'>  % % . .x/< >(? 4  t'>'>  % % . .x/< >(?  >  # #  " " + +Hi,9 ;   t'>'>  % % . .x/< >(? 4  t'>'>  % % . .x/< >(? s.B=)B9B:=E?)D (8E 9EE) NNNNNNNNNNNT)r*rCrDrEr5rrrrHr6r4rr+sGwv!"! $(Z6x 4u)n >r6rc #Ktjdt|||||||||| | |  5} | dddy#1swYyxYww)zFDeprecated: context manager for defining an op that creates variables.zqtf.variable_op_scope(values, name, default_name) is deprecated, use tf.variable_scope(name, default_name, values)) rrrbrcrgrhrrdrarjrkN)rwarnr) rrrrbrcrgrhrrdrarjrkras r4rr se ,,DE #!    !& K   s-A = A AA c|jstd|d|jdkrtd|z|||}t|tj std|zt ||jk7rtd|d|td |Drtd |ztd |DdkDrtd |d ||S)aCall partitioner validating its inputs/output. Args: partitioner: a function mapping `Tensor` shape and dtype to a list of partitions. shape: shape of the `Tensor` to partition, must have at least two dimensions. dtype: dtype of the elements in the `Tensor`. Returns: A list with elements >=1 and exactly one >1. The index of that element corresponds to the partitioning axis. zKShape of a new partitioned variable must be fully defined, but instead was rrKz;A partitioned Variable must have rank at least 1, shape: %s)r3raz/Partitioner must return a sequence, but saw: %szOPartitioner returned a partition list that does not match the Variable's rank: z vs. c3&K|] }|dk ywrKNrH.0ps r4 z$_call_partitioner..!  1Q z6Partitioner returned zero partitions for some axes: %sc3&K|] }|dkD ywrrHrs r4rz$_call_partitioner..$ rrz6Can only slice a variable along one dimension: shape: z, partitioning: ) rr,ndimsr%rror+anysum)rhr3raslicings r4rr s    ! =BE FF [[1_ !#() ** e5 1' G_55 6 F \U[[ (/ 8 99    M    1$ 6;WF GG .r6cLt|D]\}}|dkDs ||fSd}d}||fS)zGGet slicing dimension and number of slices from the partitioner output.rKr)r)rrBrs r4rr- sI(1iA~ J  IJ J r6c#K|||z}dgt|z}|||z}t|D]4}|dd}|t||kz||<|dd|f||xx||z cc<6yw)z5Slices a given a shape along the specified dimension.rN)r+r@r)r0rrBnum_slices_with_excessr2 min_slice_lenrAr3s r4rr9 s%i0:= 3Z &Y':5-  *a qME$tA0F,F'GGE) )U  9y)) *sA#A%cfdS)z.G s/*;FvFr6rH)rrs``r4 _make_getterrE s FFr6c|ay)z+Sets a reference to variable_v1.VariableV1.N)r) variable_v1s r4set_variable_v1rM s ,r6variable_creator_scopec#Ktjj|5ddddy#1swYyxYww)a Scope which defines a variable creation function to be used by variable(). variable_creator is expected to be a function with the following signature: ``` def variable_creator(next_creator, **kwargs) ``` The creator is supposed to eventually call the next_creator to create a variable if it does want to create a variable and not call Variable or ResourceVariable directly. This helps make creators composable. A creator may choose to create multiple variables, return already existing variables, or simply register that a variable was created and defer to the next creators in line. Creators can also modify the keyword arguments seen by the next creators. Custom getters in the variable scope will eventually resolve down to these custom creators when they do create variables. The valid keyword arguments in kwds are: * 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`, 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. `trainable` 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. * 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. * constraint: A constraint function to be applied to the variable after updates by some algorithms. * use_resource: if True, a ResourceVariable is always created. * 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`. This set may grow over time, so it's important the signature of creators is as mentioned above. Args: variable_creator: the passed creator Yields: A scope in which the creator is active Nrr_variable_creator_scopevariable_creators r4variable_creator_scope_v1rS s8N 667GH     $A4 A=Ac#Ktjj|5ddddy#1swYyxYww)a Scope which defines a variable creation function to be used by variable(). variable_creator is expected to be a function with the following signature: ``` def variable_creator(next_creator, **kwargs) ``` The creator is supposed to eventually call the next_creator to create a variable if it does want to create a variable and not call Variable or ResourceVariable directly. This helps make creators composable. A creator may choose to create multiple variables, return already existing variables, or simply register that a variable was created and defer to the next creators in line. Creators can also modify the keyword arguments seen by the next creators. Custom getters in the variable scope will eventually resolve down to these custom creators when they do create variables. The valid keyword arguments in kwds are: * 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`, the default, GradientTapes automatically watch uses of this Variable. * 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. 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. * constraint: A constraint function to be applied to the variable after updates by some algorithms. * 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`. This set may grow over time, so it's important the signature of creators is as mentioned above. Args: variable_creator: the passed creator Yields: A scope in which the creator is active Nrrs r4rr s8B 667GH     r) NNNNNNNNNN)ZrErenumrQr threadingrtensorflow.python.clientrtensorflow.python.eagerrtensorflow.python.frameworkrrrrr tensorflow.python.opsr r r r rtensorflow.python.platformrrtensorflow.python.typesrtensorflow.python.utilrrrtensorflow.python.util.compatr tensorflow.python.util.tf_exportr__all__r!EnumrJrrrexport_constantr*rVrXrrr_master_property_listr-setattrr_master_method_listr_op_list#register_tensor_conversion_function)register_session_run_conversion_functionsrrrrlocalrtrrrcontextmanagerrrr~rrget_variable_or_local_docstringrrrrrrrrrrrrrrrrrHr6r4r5skO  ,+.+.B4+*7;+<(10-96 yyx$;;33  " " l^,,X|D ,=$f 0f 0Rdkk( ( "@E /5"7">?@ @ >E /5"5e"<=>  :E /5/%"89:?>>H 211P  !"   r#r#!r#l & $9)//9:  #$%2&2@JJb ~!!! $! $"# !8!=!=055 DC$H7:""  #$%  +00#((#&#L=@33%)$(*.*.(,*.-1*.-1+/)-.E.J.J*=*B*Bqnc4c4L&    !s>s>"s>n  "#$$("&"&%)"&$(  #'!%%>#R  *G    '()F *F T #+@ ,@ r6