a /Sic5}@sdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZdgZedgddddZdddZddZGdddejZ GdddZ!Gddde Z"dS)z0Provides templates which allow variable sharing.N) checkpoint)context)function)ops)variable_scope) tf_logging)base)object_identity) tf_contextlib) tf_decorator) deprecated) tf_export make_template)v1FcKst|||||fddi|S)aGiven an arbitrary function, wrap it so that it does variable sharing. @compatibility(TF2) `tf.compat.v1.make_template` is a legacy API that is only compatible with eager execution enabled and `tf.function` if you combine it with `tf.compat.v1.keras.utils.track_tf1_style_variables`. See the model mapping migration guide section on `make_template` for more info: https://www.tensorflow.org/guide/migrate/model_mapping#using_tfcompatv1make_template_in_the_decorated_method Even if you use legacy apis for `variable_scope`-based variable reuse, we recommend using `tf.compat.v1.keras.utils.track_tf1_style_variables` directly and not using `tf.compat.v1.make_template`, as it interoperates with eager execution in a simpler and more predictable fashion than `make_template`. The TF2 API approach would be tracking your variables using `tf.Module`s or Keras layers and models rather than relying on `make_template`. @end_compatibility This wraps `func_` in a Template and partially evaluates it. Templates are functions that create variables the first time they are called and reuse them thereafter. In order for `func_` to be compatible with a `Template` it must have the following properties: * The function should create all trainable variables and any variables that should be reused by calling `tf.compat.v1.get_variable`. If a trainable variable is created using `tf.Variable`, then a ValueError will be thrown. Variables that are intended to be locals can be created by specifying `tf.Variable(..., trainable=false)`. * The function may use variable scopes and other templates internally to create and reuse variables, but it shouldn't use `tf.compat.v1.global_variables` to capture variables that are defined outside of the scope of the function. * Internal scopes and variable names should not depend on any arguments that are not supplied to `make_template`. In general you will get a ValueError telling you that you are trying to reuse a variable that doesn't exist if you make a mistake. In the following example, both `z` and `w` will be scaled by the same `y`. It is important to note that if we didn't assign `scalar_name` and used a different name for z and w that a `ValueError` would be thrown because it couldn't reuse the variable. ```python def my_op(x, scalar_name): var1 = tf.compat.v1.get_variable(scalar_name, shape=[], initializer=tf.compat.v1.constant_initializer(1)) return x * var1 scale_by_y = tf.compat.v1.make_template('scale_by_y', my_op, scalar_name='y') z = scale_by_y(input1) w = scale_by_y(input2) ``` As a safe-guard, the returned function will raise a `ValueError` after the first call if trainable variables are created by calling `tf.Variable`. If all of these are true, then 2 properties are enforced by the template: 1. Calling the same template multiple times will share all non-local variables. 2. Two different templates are guaranteed to be unique, unless you reenter the same variable scope as the initial definition of a template and redefine it. An examples of this exception: ```python def my_op(x, scalar_name): var1 = tf.compat.v1.get_variable(scalar_name, shape=[], initializer=tf.compat.v1.constant_initializer(1)) return x * var1 with tf.compat.v1.variable_scope('scope') as vs: scale_by_y = tf.compat.v1.make_template('scale_by_y', my_op, scalar_name='y') z = scale_by_y(input1) w = scale_by_y(input2) # Creates a template that reuses the variables above. with tf.compat.v1.variable_scope(vs, reuse=True): scale_by_y2 = tf.compat.v1.make_template('scale_by_y', my_op, scalar_name='y') z2 = scale_by_y2(input1) w2 = scale_by_y2(input2) ``` Depending on the value of `create_scope_now_`, the full variable scope may be captured either at the time of first call or at the time of construction. If this option is set to True, then all Tensors created by repeated calls to the template will have an extra trailing _N+1 to their name, as the first time the scope is entered in the Template constructor no Tensors are created. Note: `name_`, `func_` and `create_scope_now_` have a trailing underscore to reduce the likelihood of collisions with kwargs. Args: name_: A name for the scope created by this template. If necessary, the name will be made unique by appending `_N` to the name. func_: The function to wrap. create_scope_now_: Boolean controlling whether the scope should be created when the template is constructed or when the template is called. Default is False, meaning the scope is created when the template is called. unique_name_: When used, it overrides name_ and is not made unique. If a template of the same scope/unique_name already exists and reuse is false, an error is raised. Defaults to None. custom_getter_: Optional custom getter for variables used in `func_`. See the `tf.compat.v1.get_variable` `custom_getter` documentation for more information. **kwargs: Keyword arguments to apply to `func_`. Returns: A function to encapsulate a set of variables which should be created once and reused. An enclosing scope will be created either when `make_template` is called or when the result is called, depending on the value of `create_scope_now_`. Regardless of the value, the first time the template is called it will enter the scope with no reuse, and call `func_` to create variables, which are guaranteed to be unique. All subsequent calls will re-enter the scope and reuse those variables. Raises: ValueError: if `name_` is None. create_graph_function_F)make_template_internal)name_func_create_scope_now_ unique_name_custom_getter_kwargsrZ/var/www/html/django/DPS/env/lib/python3.9/site-packages/tensorflow/python/ops/template.pyr"scKs\|rt|tj|fi|}trH|dur6tdt|||||dSt||||||dS)aMake a template, optionally compiling func_ into a graph function. See `make_template` for full documentation. Args: name_: A name for the scope created by this template. If necessary, the name will be made unique by appending `_N` to the name. func_: The function to wrap. create_scope_now_: Boolean controlling whether the scope should be created when the template is constructed or when the template is called. Default is False, meaning the scope is created when the template is called. unique_name_: When used, it overrides name_ and is not made unique. If a template of the same scope/unique_name already exists and reuse is false, an error is raised. Defaults to None. If executing eagerly, must be None. custom_getter_: Optional custom getter for variables used in `func_`. See the `tf.compat.v1.get_variable` `custom_getter` documentation for more information. create_graph_function_: When True, `func_` will be executed as a graph function. This implies that `func_` must satisfy the properties that `function.defun` requires of functions: See the documentation of `function.defun` for details. When executing eagerly, setting this flag to True can improve performance. Regardless of whether eager execution is enabled, enabling this flag gives the caller access to graph-function semantics, i.e., accesses to variables are totally ordered and side-effecting ops are not pruned. **kwargs: Keyword arguments to apply to `func_`. Returns: A function to encapsulate a set of variables which should be created once and reused. An enclosing scope will be created either when `make_template` is called or when the result is called, depending on the value of `create_scope_now_`. Regardless of the value, the first time the template is called it will enter the scope with no reuse, and call `func_` to create variables, which are guaranteed to be unique. All subsequent calls will re-enter the scope and reuse those variables. Raises: ValueError: if `name_` is None. ValueError: if `unique_name_` is not None and eager execution is enabled. Nzz4Template.non_trainable_variables..)rdsetrV)r:rdrrkrnon_trainable_variabless z Template.non_trainable_variablescCs |jrttjj|jSgSdS=Returns the list of global variables created by the Template.N)r8rrgrHrIrcr_rrrrds  zTemplate.global_variablescCs |jrttjj|jSgSdSrp)r8rrgrHLOCAL_VARIABLESrcr_rrrres  zTemplate.local_variablescCs|jS)z2List of weights/variables created by the Template.)rWr_rrrweightsszTemplate.weightscCs|jS)zrZr^propertyr;r<rrcrWrVrordrersrtrur rvrrrrr$sJ >@            r$c@sNeZdZdZddZddZejddZdd Z d d Z d d Z ddZ dS)_EagerTemplateVariableStorezDWrapper around EagerVariableStore to support nesting EagerTemplates.cCs6||_t}|jr"t||_n t|_d|_dS)NF)_variable_scope_namer_get_default_variable_store_store_eager_variablesEagerVariableStore_eager_variable_store _used_once)r:rcdefaultrrrr>s  z$_EagerTemplateVariableStore.__init__cCs ||_dSN)r})r:rcrrrset_variable_scope_namesz3_EagerTemplateVariableStore.set_variable_scope_namec cszx|js$t}|jr||j_d|_|jdVWdn1sJ0YW|jdurhtdt |jn$|jdurtdt |j0dS)NTzPA variable scope must be set before an _EagerTemplateVariableStore object exits.) rrr~rr_store as_defaultr} RuntimeErrorget_variable_scope_storeclose_variable_subscopes)r:rrrrrs$ &  z&_EagerTemplateVariableStore.as_defaultcs$jdurtdfdd|DS)Nz>A variable scope must be set before variables can be accessed.cs"g|]}|jjdr|qS)rb)r; startswithr})rivr_rrrl#szC_EagerTemplateVariableStore._variables_in_scope..)r}r)r: variable_listrr_r_variables_in_scopes  z/_EagerTemplateVariableStore._variables_in_scopecCs||jSr)rrrWr_rrrrW(sz%_EagerTemplateVariableStore.variablescCs||jSr)rrrVr_rrrrV+sz/_EagerTemplateVariableStore.trainable_variablescCs||jSr)rrror_rrrro/sz3_EagerTemplateVariableStore.non_trainable_variablesN) rwrxryrzr>rr contextmanagerrrrWrVrorrrrr|s   r|csneZdZdZdfdd ZddZdd Zed d Zed d Z eddZ eddZ eddZ Z S)r#aWrap a function to aid in variable sharing in Eager mode. Templates are functions that create variables the first time they are called and reuse them thereafter. See `make_template` for full documentation. Note: By default, the full variable scope is captured at the time of first call. If `create_scope_now` is passed as True to the constructor, the full scope will be captured there, but no variables will be created until the first call. FNcs`tstdt|tt||||d|||jdurH|jj }nd}t ||_ d|_ dS)aCreates a template for the given function. Args: name: A name for the scope created by this template. The name will be made unique by appending `_N` to the it (see how `tf.compat.v1.variable_scope` treats the `default_name` for details). func: The function to apply each time. create_scope_now: Whether to create the scope at Template construction time, rather than first call. Defaults to false. Creating the scope at construction time may be more convenient if the template is passed through much lower level code, and you want to be sure of the scope name without knowing exactly where it will be first called. If set to True, the scope will be created in the constructor, and all subsequent times in `__call__`, leading to a trailing numeral being added to the names of all created Tensors. If set to False, the scope will be created at the first call location. custom_getter: optional custom getter to pass to `variable_scope()` create_graph_function: When True, `func` will be executed as a graph function. Enabling this flag allows the caller to reap the performance benefits associated with executing graphs, at the cost of sacrificing debuggability; however, not all Python functions can be compiled into graph functions. See the documentation for `function.defun` for details. Raises: RuntimeError: if eager execution is not enabled. zc{} objects can only be used when eager execution is enabled, use tf.Template for graph constructionN) rr!rformattypesuperr#r>r7r;r|_template_store_variable_scope_context_manager)r:r;r<rrrrc __class__rrr>@s    zEagerTemplate.__init__c Cs|z|j}|j}|jr.|j|i|}nrZr^r{rWrVrordre __classcell__rrrrr#4s"/;    r#)FNN)FNNF)#rzrr/tensorflow.python.checkpointrrMtensorflow.python.eagerrrtensorflow.python.frameworkrtensorflow.python.opsrtensorflow.python.platformrrKtensorflow.python.trackabler trackabletensorflow.python.utilr r r "tensorflow.python.util.deprecationr tensorflow.python.util.tf_exportr __all__rrr* Trackabler$r|r#rrrrs>               FtA