a /Sic?@sdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl m Z dd lmZed Gd d d e jZd d ZddZddZddZedZedZddZddZdddZdS)z1Modules encapsulate building stateful components.N)tf2)ops) variables) autotrackable)nest) tf_decorator) tf_exportModulec@seZdZdZedZdddZeddZedd Z ed d Z ed d Z eddZ eddZ dddZeddZdS)r a Base neural network module class. A module is a named container for `tf.Variable`s, other `tf.Module`s and functions which apply to user input. For example a dense layer in a neural network might be implemented as a `tf.Module`: >>> class Dense(tf.Module): ... def __init__(self, input_dim, output_size, name=None): ... super(Dense, self).__init__(name=name) ... self.w = tf.Variable( ... tf.random.normal([input_dim, output_size]), name='w') ... self.b = tf.Variable(tf.zeros([output_size]), name='b') ... def __call__(self, x): ... y = tf.matmul(x, self.w) + self.b ... return tf.nn.relu(y) You can use the Dense layer as you would expect: >>> d = Dense(input_dim=3, output_size=2) >>> d(tf.ones([1, 3])) By subclassing `tf.Module` instead of `object` any `tf.Variable` or `tf.Module` instances assigned to object properties can be collected using the `variables`, `trainable_variables` or `submodules` property: >>> d.variables (, ) Subclasses of `tf.Module` can also take advantage of the `_flatten` method which can be used to implement tracking of any other types. All `tf.Module` classes have an associated `tf.name_scope` which can be used to group operations in TensorBoard and create hierarchies for variable names which can help with debugging. We suggest using the name scope when creating nested submodules/parameters or for forward methods whose graph you might want to inspect in TensorBoard. You can enter the name scope explicitly using `with self.name_scope:` or you can annotate methods (apart from `__init__`) with `@tf.Module.with_name_scope`. >>> class MLP(tf.Module): ... def __init__(self, input_size, sizes, name=None): ... super(MLP, self).__init__(name=name) ... self.layers = [] ... with self.name_scope: ... for size in sizes: ... self.layers.append(Dense(input_dim=input_size, output_size=size)) ... input_size = size ... @tf.Module.with_name_scope ... def __call__(self, x): ... for layer in self.layers: ... x = layer(x) ... return x >>> module = MLP(input_size=5, sizes=[5, 5]) >>> module.variables (, , , ) )+_self_unconditional_checkpoint_dependencies$_self_unconditional_dependency_namesNcCs|durtt|j}nt|s,td|||_trrt |}t ||_ Wdq1sf0Yn4tj |dd}||_ Wdn1s0YdS)Nzg%r is not a valid module name. Module names must be valid Python identifiers (e.g. a valid class name).F skip_on_eager) camel_to_snaketype__name__valid_identifier ValueError_namerenabledr name_scope_v2 _name_scope name_scope _scope_name)selfname scope_namer[/var/www/html/django/DPS/env/lib/python3.9/site-packages/tensorflow/python/module/module.py__init__ls ,zModule.__init__cCs|jS)zReturns the name of this module as passed or determined in the ctor. NOTE: This is not the same as the `self.name_scope.name` which includes parent module names. )rrrrrr}sz Module.namecCs"tr|jStj|jddSdS)z2Returns a `tf.name_scope` instance for this class.Fr N)rrrrrrrrrrrszModule.name_scopecCst|jtddS)aSequence of variables owned by this module and its submodules. Note: this method uses reflection to find variables on the current instance and submodules. For performance reasons you may wish to cache the result of calling this method if you don't expect the return value to change. Returns: A sequence of variables for the current module (sorted by attribute name) followed by variables from all submodules recursively (breadth first). T predicateexpand_composites)tuple_flatten _is_variablerrrrrs zModule.variablescCst|jtddS)aSequence of trainable variables owned by this module and its submodules. Note: this method uses reflection to find variables on the current instance and submodules. For performance reasons you may wish to cache the result of calling this method if you don't expect the return value to change. Returns: A sequence of variables for the current module (sorted by attribute name) followed by variables from all submodules recursively (breadth first). Tr )r#r$_is_trainable_variablerrrrtrainable_variabless  zModule.trainable_variablescCst|jtdS)aSequence of non-trainable variables owned by this module and its submodules. Note: this method uses reflection to find variables on the current instance and submodules. For performance reasons you may wish to cache the result of calling this method if you don't expect the return value to change. Returns: A sequence of variables for the current module (sorted by attribute name) followed by variables from all submodules recursively (breadth first). r!)r#r$_is_non_trainable_variablerrrrnon_trainable_variabless zModule.non_trainable_variablescCst|jtdS)aSequence of all sub-modules. Submodules are modules which are properties of this module, or found as properties of modules which are properties of this module (and so on). >>> a = tf.Module() >>> b = tf.Module() >>> c = tf.Module() >>> a.b = b >>> b.c = c >>> list(a.submodules) == [b, c] True >>> list(b.submodules) == [c] True >>> list(c.submodules) == [] True Returns: A sequence of all submodules. r()r#r$ _is_modulerrrr submodulesszModule.submodulesTFc Cs(|durdd}t||||j|||dS)aFlattened attribute values in sorted order by attribute name. Modules are flattened by first walking their attributes in name order. Each attribute value is then flattened to find leaf values. If flatten is applied `recursive`ly and if the leaf is a `Module` it will also be flattened to find leaves. Finally every leaf value is optionally tested against the given `predicate` and finally yielded. ``` class Foo(tf.Module): def __init__(self): super(Foo, self).__init__() self.x = [tf.constant('a'), tf.constant('b')] self.y = {'i': tf.constant('c'), 'j': tf.constant('d')} self.z = tf.constant('e') @property def tensors(self): return tuple(self._flatten(predicate=is_tensor, with_path=True)) foo = Foo() foo.tensors # ==> ((('x', 0), ), # (('x', 1), ), # (('y', 'i'), ), # (('y', 'j'), ), # (('z',), )) ``` `attribute_traversal_key` controls the order object properties are visited. If not set objects are visited in ascending order by name. Args: recursive: Whether to recurse into child modules or not. predicate: (Optional) If set then only values matching predicate are yielded. A value of `None` (the default) means no items will be filtered. attribute_traversal_key: (Optional) Method to rekey object attributes before they are sorted. Contract is the same as `key` argument to builtin `sorted` and only applies to object properties. with_path: (Optional) Whether to include the path to the object as well as the object itself. If `with_path` is `True` then leaves will not be de-duplicated (e.g. if the same leaf instance is reachable via multiple modules then it will be yielded multiple times with different paths). expand_composites: If true, then composite tensors are expanded into their component tensors. Returns: Flat generator for leaves of the current module and optionally all submodules. NcSsdS)NTr)_rrrz!Module._flatten..) recursiver!attributes_to_ignoreattribute_traversal_key with_pathr")_flatten_module_TF_MODULE_IGNORED_PROPERTIES)rr0r!r2r3r"rrrr$s9zModule._flattencsfdd}t|S)a)Decorator to automatically enter the module name scope. >>> class MyModule(tf.Module): ... @tf.Module.with_name_scope ... def __call__(self, x): ... if not hasattr(self, 'w'): ... self.w = tf.Variable(tf.random.normal([x.shape[1], 3])) ... return tf.matmul(x, self.w) Using the above module would produce `tf.Variable`s and `tf.Tensor`s whose names included the module name: >>> mod = MyModule() >>> mod(tf.ones([1, 2])) >>> mod.w Args: method: The method to wrap. Returns: The original method wrapped such that it enters the module's name scope. cs@|j&|g|Ri|WdS1s20YdSN)r)rargskwargsmethodrrmethod_with_name_scope5sz6Module.with_name_scope..method_with_name_scope)rmake_decorator)clsr:r;rr9rwith_name_scopes zModule.with_name_scope)N)TNNFF)r __module__ __qualname____doc__ frozensetr5rpropertyrrrr'r*r,r$ classmethodr>rrrrr s.G        EcCs t|tjSr6) isinstancerVariableobjrrrr%<sr%cCst|ot|ddSN trainableFr%getattrrGrrrr&@sr&cCst|ot|dd SrIrKrGrrrr)Dsr)cCs t|tSr6)rEr rGrrrr+Hsr+z(((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))z^[a-zA-Z_]([a-zA-Z0-9_])*$cCstt|Sr6)bool_VALID_IDENTIFIERmatch)rrrrrOsrcCstd|S)Nz_\1)_CAMEL_TO_SNAKE_Rsublower)valuerrrrSsrrc  cst|} |durt| g}t|} g} | dur2g} | | vr>d}t| |dD]} | |vrXqJ| | }ztj||d}Wn<ty}z$tt d | ||WYd}~n d}~00|D]v\}}| f|}|st|}||vrq| |||r |r|||fVn|V|rt |r| |||fqqJ| | | D]:\}}t|||||j||||| d }|D] }|Vqfq<| dS)a$Implementation of `flatten`. Args: module: Current module to process. recursive: Whether to recurse into child modules or not. predicate: (Optional) If set then only values matching predicate are yielded. A value of `None` (the default) means no items will be filtered. attribute_traversal_key: (Optional) Method to rekey object attributes before they are sorted. Contract is the same as `key` argument to builtin `sorted` and only applies to object properties. attributes_to_ignore: object attributes to ignored. with_path: (Optional) Whether to include the path to the object as well as the object itself. If `with_path` is `True` then leaves will not be de-duplicated (e.g. if the same leaf instance is reachable via multiple modules then it will be yielded multiple times with different paths). expand_composites: If true, then composite tensors are expanded into their component tensors. module_path: The path to the current module as a tuple. seen: A set containing all leaf IDs seen so far. recursion_stack: A list containing all module IDs associated with the current call stack. Yields: Matched leaves with the optional corresponding paths of the current module and optionally all its submodules. NF)key)r"z&Error processing property {!r} of {!r}) r0r!r2r1r3r" module_pathseenrecursion_stack)idsetvarssortedrflatten_with_tuple_paths Exceptionsix raise_fromrformataddr+appendr4r5pop)moduler0r!r2r1r3r"rUrVrW module_id module_dictr,rTpropleavescause leaf_pathleafZleaf_idZsubmodule_path submoduleZ subvaluessubvaluerrrr4Wsl%            r4)rNN)rArer^tensorflow.pythonrtensorflow.python.frameworkrtensorflow.python.opsrtensorflow.python.trackablertensorflow.python.utilrr tensorflow.python.util.tf_exportr AutoTrackabler r%r&r)r+compilerPrNrrr4rrrrs2