a 0Sic@sdZddlZddlZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z dd lmZdd lmZdd lmZe jZe jZe jZe jZed gd GdddeZGdddeZedddgZedgd GdddeZedgd GdddejZGddde jZ edgdZ!edgd d d!Z"ej#d"d#Z$ej#d$d%Z%ed&gd Gd'd(d(eZ&dS))z+An object-local variable management scheme.N)context)dtypes)ops)control_flow_ops) constants)saveable_object) tf_contextlib) tf_decorator) tf_exportz(__internal__.tracking.TrackableReference)v1c@sLeZdZdZdZddZeddZeddZd d Z d d Z d dZ dS)TrackableReferencea[A named reference to a trackable object for use with the `Trackable` class. These references mark named `Trackable` dependencies of a `Trackable` object and should be created when overriding `Trackable._checkpoint_dependencies`. Attributes: name: The local name for this dependency. ref: The `Trackable` object being referenced. _name_refcCs||_||_dSNr selfnamerefr\/var/www/html/django/DPS/env/lib/python3.9/site-packages/tensorflow/python/trackable/base.py__init__1szTrackableReference.__init__cCs|jSr)rrrrrr5szTrackableReference.namecCs|jSrrrrrrr9szTrackableReference.refccs|jV|jVdSrrrrrrr__iter__=szTrackableReference.__iter__cCs|jjd|jd|jdS)Nz(name=z, ref=)) __class____name__rrrrrr__repr__AszTrackableReference.__repr__cCsDt|tr|j|jf|kSt|tr<|j|jko:|j|jkSdSdS)NF) isinstancetuplerrr )rorrr__eq__Ds   zTrackableReference.__eq__N) r __module__ __qualname____doc__ __slots__rpropertyrrrrr#rrrrr #s   r cs0eZdZdZdZfddZeddZZS)WeakTrackableReferencez/TrackableReference that stores weak references.rcs.t|tjst|}tt|j||ddS)Nr)r weakrefrsuperr)rrrrrrQs  zWeakTrackableReference.__init__cCs|SrrrrrrrVszWeakTrackableReference.ref) rr$r%r&r'rr(r __classcell__rrr,rr)Ms  r)ZCheckpointInitialValueShardInfoshapeoffsetz4__internal__.tracking.CheckpointInitialValueCallablec@s:eZdZdZddZeddZd ddZed d ZdS) CheckpointInitialValueCallablezoA callable object that returns a CheckpointInitialValue. See CheckpointInitialValue for more information. cCs ||_dSr_checkpoint_position)rcheckpoint_positionrrrrgsz'CheckpointInitialValueCallable.__init__cCs|jSrr1rrrrr3jsz2CheckpointInitialValueCallable.checkpoint_positionNcCst|j||dS)N) shard_info)CheckpointInitialValuer2)rr.dtyper4rrr__call__nsz'CheckpointInitialValueCallable.__call__cCs|jjSr)r2 restore_uidrrrrr8vsz*CheckpointInitialValueCallable.restore_uid)NNN) rr$r%r&rr(r3r7r8rrrrr0`s  r0z,__internal__.tracking.CheckpointInitialValuec@s.eZdZdZd ddZddZeddZdS) r5a+Tensor wrapper for managing update UIDs in `Variables`. When supplied as an initial value, objects of this type let a `Variable` (`Variable`, `ResourceVariable`, etc.) know the UID of the restore the initial value came from. This allows deferred restorations to be sequenced in the order the user specified them, and lets us fall back on assignment if an initial value is not set (e.g. due to a custom getter interfering). See comments in _add_variable_with_custom_getter for more information about how `CheckpointInitialValue` is used. NcCsf|rDddd|Dd}dddt|j|jD}||}nd}|t|it|_||_dS)N css|]}d|VqdS)z%dNr).0drrr z2CheckpointInitialValue.__init__..:css|]\}}d||fVqdS)z%d,%dNr)r:r"srrrr<s)joinzipr/r.Z value_tensorsVARIABLE_VALUE_KEY wrapped_valuer2)rr3r.r4Zfull_shape_str slice_specZshape_and_slicerrrrs   zCheckpointInitialValue.__init__cCs0zt|j|WSty*||YS0dSr)getattrrDAttributeError__getattribute__)rattrrrr __getattr__s z"CheckpointInitialValue.__getattr__cCs|jSrr1rrrrr3sz*CheckpointInitialValue.checkpoint_position)NN)rr$r%r&rrJr(r3rrrrr5{s  r5cs*eZdZdZdfdd ZddZZS)NoRestoreSaveablez4Embeds a tensor in a checkpoint with no restore ops.Ncs.tj|d|||d}tt|||g|dS)Nr@)r6device)rSaveSpecr+rKr)rtensorrr6rLspecr,rrrs zNoRestoreSaveable.__init__cCstSr)rno_op)rrestored_tensorsrestored_shapesrrrrestoreszNoRestoreSaveable.restore)NN)rr$r%r&rrSr-rrr,rrKsrK_SlotVariableRestoration)Z optimizer_idZslot_variable_idZ slot_namez6__internal__.tracking.no_automatic_dependency_trackingcsfdd}tj|dS)aSDisables automatic dependency tracking on attribute assignment. Use to decorate any method of a Trackable object. Attribute assignment in that method will not add dependencies (also respected in Model). Harmless if used in a class which does not do automatic dependency tracking (which means it's safe to use in base classes which may have subclasses which also inherit from Trackable). Args: method: The method to decorate. Returns: A decorated method which sets and un-sets automatic dependency tracking for the object the method is called on (not thread safe). cs@t|dd}d|_z |g|Ri|}W||_n||_0|S)N_self_setattr_trackingTF)rFrU)rargskwargsprevious_valueresultmethodrr_method_wrappers  z9no_automatic_dependency_tracking.._method_wrapper)targetdecorator_func)r make_decorator)r[r\rrZr no_automatic_dependency_trackings r`ccs0t|dd}d|_zdVW||_n||_0dS)aA context that disables manual dependency tracking for the given `obj`. Sometimes library methods might track objects on their own and we might want to disable that and do the tracking on our own. One can then use this context manager to disable the tracking the library method does and do your own tracking. For example: class TestLayer(tf.keras.Layer): def build(): with no_manual_dependency_tracking_scope(self): var = self.add_variable("name1") # Creates a var and doesn't track it self._track_trackable("name2", var) # We track variable with name `name2` Args: obj: A trackable object. Yields: a scope in which the object doesn't track dependencies manually. _manual_trackingTFN)rFraobjrXrrr#no_manual_dependency_tracking_scopes  rdccs0t|dd}d|_zdVW||_n||_0dS)aA context that disables automatic dependency tracking when assigning attrs. Objects that inherit from Autotrackable automatically creates dependencies to trackable objects through attribute assignments, and wraps data structures (lists or dicts) with trackable classes. This scope may be used to temporarily disable this behavior. This works similar to the decorator `no_automatic_dependency_tracking`. Example usage: ``` model = tf.keras.Model() model.arr1 = [] # Creates a ListWrapper object with no_automatic_dependency_tracking_scope(model): model.arr2 = [] # Creates a regular, untracked python list ``` Args: obj: A trackable object. Yields: a scope in which the object doesn't track dependencies. _setattr_trackingTFN)rFrerbrrr&no_automatic_dependency_tracking_scopes  rfz__internal__.tracking.Trackablec@sBeZdZdZeddZejddZeddZejddZedd Zed d Z ed d Z e ddZ eddZ ddZddZeddZeddZddZdejdddfddZd d!Zd:d"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd;d.d/Zed Trackablea0Base class for `Trackable` objects without automatic dependencies. This class has no __setattr__ override for performance reasons. Dependencies must be added explicitly. Unless attribute assignment is performance-critical, use `AutoTrackable` instead. Use `Trackable` for `isinstance` checks. cCst|dsd|_|jS)NrUT)hasattrrUrrrrre$s zTrackable._setattr_trackingcCs ||_dSr)rUrvaluerrrre*scCs|jSr_self_update_uidrrrr _update_uid.szTrackable._update_uidcCs ||_dSrrkrirrrrm2scCs|jSr+_self_unconditional_checkpoint_dependenciesrrrr&_unconditional_checkpoint_dependencies6sz0Trackable._unconditional_checkpoint_dependenciescCs|jSr)$_self_unconditional_dependency_namesrrrr_unconditional_dependency_names:sz)Trackable._unconditional_dependency_namescCs|jSr)_self_name_based_restoresrrrr_name_based_restores>szTrackable._name_based_restorescCsJt|drdSg|_i|_i|_t|dr2tdd|_t|_i|_dS)zdInitialize dependency management. Not __init__, since most objects will forget to call it. roNrlzXInternal error: the object had an update UID set before its initialization code was run.) rhrorq)_self_unconditional_deferred_dependenciesAssertionErrorrlsetrs_self_saveable_object_factoriesrrrr_maybe_initialize_trackableFs  z%Trackable._maybe_initialize_trackablecCsdS)abString used to identify this object in a SavedModel. THIS FIELD HAS BEEN DEPRECATED IN FAVOR OF THE NAME REGISTERED WITH `register_serializable`. Generally, the object identifier is constant across objects of the same class, while the metadata field is used for instance-specific data. Returns: String object identifier. Z_generic_user_objectrrrrr_object_identifierrs zTrackable._object_identifiercCs|S)z=If automatic dependency tracking is enabled, ignores `value`.rrirrr_no_dependencyszTrackable._no_dependencycCs.|j||j|jkr*|||j|_dS)z=Restore the object's attributes from a name-based checkpoint.N)rsaddrlr8Z eager_restore)r checkpointrrr_name_based_attribute_restores   z'Trackable._name_based_attribute_restorecCs|jS)aAll dependencies of this object. May be overridden to include conditional dependencies. Returns: A list of `TrackableReference` objects indicating named `Trackable` dependencies which should be saved along with this object. rnrrrr_checkpoint_dependenciess z"Trackable._checkpoint_dependenciescCs|jS)aA dictionary with deferred dependencies. Stores restorations for other Trackable objects on which this object may eventually depend. May be overridden by sub-classes (e.g. Optimizers use conditional dependencies based the current graph, and so need separate management of deferred dependencies too). Returns: A dictionary mapping from local name to a list of CheckpointPosition objects. )rvrrrr_deferred_dependenciess z Trackable._deferred_dependenciescCs|j|dS)zLook up a dependency by name. May be overridden to include conditional dependencies. Args: name: The local name of the dependency. Returns: A `Trackable` object, or `None` if no dependency by this name was found. N)rqget)rrrrr_lookup_dependencys zTrackable._lookup_dependencyNFc Ks|tLtr(|j|d}nd}|durNt|trJ|j|jksN|}Wdn1sb0Y|f||||d|} |rt| t r|j | ||dS| SdS)aRestore-on-create for a variable be saved with this `Trackable`. If the user has requested that this object or another `Trackable` which depends on this object be restored from a checkpoint (deferred loading before variable object creation), `initializer` may be ignored and the value from the checkpoint used instead. Args: name: A name for the variable. Must be unique within this object. shape: The shape of the variable. dtype: The data type of the variable. initializer: The initializer to use. Ignored if there is a deferred restoration stored in the Trackable. getter: The getter to wrap which actually fetches the variable. overwrite: If True, disables unique name and type checks. **kwargs_for_getter: Passed to the getter. Returns: The new variable object. Raises: ValueError: If the variable name is not unique. rN)rr.r6 initializer)r overwrite) rzr init_scoperexecuting_eagerly_preload_simple_restorationr r0r8rg_track_trackable) rrr.r6rgetterrZkwargs_for_getterZcheckpoint_initializerZ new_variablerrr _add_variable_with_custom_getters,   " z*Trackable._add_variable_with_custom_gettercCsH|j|d}|sdS|D]}|sdSqt|ddd}t|dS)a!Return a dependency's value for restore-on-create. Note the restoration is not deleted; if for some reason preload is called and then not assigned to the variable (for example because a custom getter overrides the initializer), the assignment will still happen once the variable is tracked (determined based on checkpoint.restore_uid). Args: name: The object-local name of the dependency holding the variable's value. Returns: An callable for use as a variable's initializer/initial_value, or None if one should not be set (either because there was no variable with this name in the checkpoint or because it needs more complex deserialization). Any non-trivial deserialization will happen when the variable object is tracked. rNcSs|jjSrr~r8rSrrrr=z7Trackable._preload_simple_restoration..)key)r3)rrZis_simple_variablemaxr0)rrdeferred_dependencies_listr3rrrrsz%Trackable._preload_simple_restorationc Cs|t|ts&tdt|dt|dds6|St||d}||}|dur||ur|sptd|dt |j D]\}\}}||krz||j |<qzn"|dur|j ||j ||d ||j |<|S) aADeclare a dependency on another `Trackable` object. Indicates that checkpoints for this object should include variables from `trackable`. Variables in a checkpoint are mapped to `Trackable`s based on the names provided when the checkpoint was written. To avoid breaking existing checkpoints when modifying a class, neither variable names nor dependency names (the names passed to `_track_trackable`) may change. Args: trackable: A `Trackable` which this object depends on. name: A local name for `trackable`, used for loading checkpoints into the correct objects. overwrite: Boolean, whether silently replacing dependencies is OK. Used for __setattr__, where throwing an error on attribute reassignment would be inappropriate. Returns: `trackable`, for convenience when declaring a dependency and assigning to a member variable in one statement. Raises: TypeError: If `trackable` does not inherit from `Trackable`. ValueError: If another object is already tracked by this name. z[Trackable._track_trackable() can only be used to track objects of type Trackable. Got type .raTrNz/Called Trackable._track_trackable() with name='zp', but a Trackable with this name is already declared as a dependency. Names must be unique (or overwrite=True).)r trackable)rzr rg TypeErrortyperFr r ValueError enumerateroappend_handle_deferred_dependenciesrq) rrrrZ new_referenceZcurrent_objectindexold_name_rrrrs:       zTrackable._track_trackablecCsh|||j|d}t|ddddD]}||q0t|jddddD]}||qTdS)aPop and load any deferred checkpoint restores into `trackable`. This method does not add a new dependency on `trackable`, but it does check if any outstanding/deferred dependencies have been queued waiting for this dependency to be added (matched based on `name`). If so, `trackable` and its dependencies are restored. The restorations are considered fulfilled and so are deleted. `_track_trackable` is more appropriate for adding a normal/unconditional dependency, and includes handling for deferred restorations. This method allows objects such as `Optimizer` to use the same restoration logic while managing conditional dependencies themselves, by overriding `_checkpoint_dependencies` and `_lookup_dependency` to change the object's dependencies based on the context it is saved/restored in (a single optimizer instance can have state associated with multiple graphs). Args: name: The name of the dependency within this object (`self`), used to match `trackable` with values saved in a checkpoint. trackable: The Trackable object to restore (inheriting from `Trackable`). rcSs|jjSrrrrrrrqr=z9Trackable._handle_deferred_dependencies..T)rreversecSs|jSr)r8)r~rrrrxr=N)rzrpopsortedrSrsr)rrrrr3Zname_based_restorerrrrVs   z'Trackable._handle_deferred_dependenciescs>ddlmr.dfdd }d|iStdiSdS) aReturns a dictionary of values to checkpoint with this object. NOTE: This method is deprecated, please use `_serialize_to_tensors` and `_restore_from_tensors` instead. Keys in the returned dictionary are local to this object and in a separate namespace from dependencies. Values may either be `SaveableObject` factories or variables easily converted to `SaveableObject`s (as in `tf.compat.v1.train.Saver`'s `var_list` constructor argument). `SaveableObjects` have a name set, which Trackable needs to generate itself. So rather than returning `SaveableObjects` directly, this method should return a dictionary of callables which take `name` arguments and return `SaveableObjects` with that name. If this object may also be passed to the global-name-based `tf.compat.v1.train.Saver`, the returned callables should have a default value for their name argument (i.e. be callable with no arguments). Returned values must be saved only by this object; if any value may be shared, it should instead be a dependency. For example, variable objects save their own values with the key `VARIABLE_VALUE_KEY`, but objects which reference variables simply add a dependency. Returns: The dictionary mapping attribute names to `SaveableObject` factories described above. For example: {VARIABLE_VALUE_KEY: lambda name="global_name_for_this_object": SaveableObject(name=name, ...)} r)saveable_object_utilr@cs |Sr)ZTrackableSaveablerrrrrcreate_saveableszCTrackable._gather_saveables_for_checkpoint..create_saveableryN)r@)!tensorflow.python.training.savingrZ!trackable_has_serialize_to_tensorrF)rrrrr _gather_saveables_for_checkpoint|s %  z*Trackable._gather_saveables_for_checkpointcCstdS)aGathers tensors to save to the checkpoint. You should only override `_serialize_to_tensors` and `_restore_from_tensors` if you are defining a custom resource or variable with custom ops. Otherwise, please store the state of your trackable in `tf.Variable` objects and add them to Trackable object hierarchy using `setattr` (for subclasses of `AutoTrackable`) or overriding the `_trackable_children` method. For an example of a valid implementation of these two methods, please see `DenseHashTable`. **Invalid implementation** ```` class NamedTrackable(Trackable): def __init__(self, name: str): self.name = name def _serialize_to_tensors(self): return {"name": self.name} def _restore_from_tensors(self, restored_tensors): self.name = restored_tensors["name"] ``` In this example, `NamedTrackable` can be saved and restored from checkpoints, but is incompatible with SavedModel, which tries to convert the serialize/restore functions into tf.functions. This fails because attribute assignment (`self.attr = new_value`) is not graph-friendly. **Suggested fix** ``` class NamedTrackable(Trackable): def __init__(self, name: str): self.name = tf.Variable(name) def _trackable_children(self): return {"name": self.name} ``` If the `name` attribute should be saved to the checkpoint, then convert it a `tf.Variable`. Returns: A dictionary mapping names to tensors. NNotImplementedErrorrrrr_serialize_to_tensorss/zTrackable._serialize_to_tensorscCstdS)aURestores checkpointed values to this `Trackable`. Please see the documentation for `Trackable._serialize_to_tensors`. Args: restored_tensors: A dictionary mapping names to tensors. The keys to this dictionary matches the names passed to _serialize_to_tensors. Returns: An op that runs the restoration. Nr)rrQrrr_restore_from_tensorss zTrackable._restore_from_tensorscCsiifS)a Makes new resource handle ops corresponding to existing resource tensors. Internal sub-classes can override this to inform model saving how to add new resource handle ops to the main GraphDef of a SavedModel (TF 1.x style graph), which allows session based APIs (e.g, C++ loader API) to interact with resources owned by this object. Args: save_options: A tf.saved_model.SaveOptions instance. Returns: A tuple of (object_map, resource_map): object_map: A dictionary mapping from objects that hold existing resource tensors to replacement objects created to hold the new resource tensors. resource_map: A dictionary mapping from existing resource tensors to newly created resource tensors. r)r save_optionsrrr_map_resourcesszTrackable._map_resourcescKs~~dS)aQReturns a proto of any type to be saved into the SavedModel. Trackable classes decorated with `register_serializable` should overwrite this method to save metadata for this object to the SavedModel. The proto returned by this function will be passed to `_deserialize_from_proto` in the form of a `google.protobuf.Any` proto. This data is only saved and used by the Python API. Existing C++ loading APIs such as `tensorflow::LoadSavedModel` will not read this field at all. Args: object_proto: A `SavedObject` proto that may be filled by this function. Only the core serializable types (Variable, Function, Constant, Asset) should modify this argument. **kwargs: Future keyword arguments passed to the object during saving. Returns: A proto that serializes this class's type. Nr)r object_protorWrrr_serialize_to_protoszTrackable._serialize_to_protocKs~~~~~~~|S)a Returns a new object restored by the SavedModel. Trackable classes decorated with `register_serializable` should overwrite this method to change how the object is loaded from SavedModel. By default, the object is initialized with no arguments. Example: ``` def _serialize_to_proto(self, **unused_kwargs): return Message(name="a") @classmethod def _deserialize_from_proto(cls, proto, **unused_kwargs): if proto.Is(Message.DESCRIPTOR): unpacked = Message() proto.Unpack(unpacked) return cls(unpacked.name) else: return cls() ``` This function is only used by the Python API. C++ and TensorFlow Serving do not have access to your registered class and cannot execute any of the non-tf.functions attached to the Python class. However, all signatures and tf.functions are still accessible. **Avoid creating duplicate trackables** SavedModel is saved by recursively gathering all of the trackables and their children. SavedModel loading reverses those steps by creating all trackables, then reconnecting the children trackables to their parents using `Trackable._add_trackable_child`. That means that if `_deserialize_from_proto` calls the `__init__` function, which creates all of the children trackables, then those children end up being created *twice*. To avoid this, structure your code so that Trackables are not created when deserialized from SavedModel: ``` @register_serializable() class Serializable(trackable): def __init __(self, from_proto=False): create_non_trackable_objects() if not from_proto: create_variables_and_other_trackables() def _deserialize_from_proto(cls, **kwargs): return cls(from_proto=True) def _add_trackable_child(self, name, value): self.__setattr__(name, value) ``` Args: proto: A `google.protobuf.Any` proto read from the `SavedModel`. dependencies: A dictionary mapping names to dependencies (see `_deserialization_dependencies`) object_proto: The `SavedObject` proto for this object. export_dir: The `SavedModel` directory asset_file_def: The `MetaGraphDef`'s `asset_file_def` field. operation_attributes: Dictionary mapping nodes to attribute from the imported `GraphDef`. **kwargs: Future keyword arguments passed to the object when loading. Returns: A new object. r)clsproto dependenciesrZ export_dirZasset_file_defZoperation_attributesrWrrr_deserialize_from_protosO z!Trackable._deserialize_from_protocCs|j||dddS)aRestores a connection between trackables when loading from SavedModel. SavedModel stores both the object metadata and its list of children. When loading, this function is used along with `_deserialize_from_proto` to load objects from the SavedModel: First, all saved objects are created with `_deserialize_from_proto`. After that is complete, the children are connected using `_add_trackable_child`. **Example** `tf.Module`, `tf.keras.Model` and Keras layers use `__setattr__` to track children. This is why users can call `model.v = tf.Variable(...)`, and the variable will be automatically saved to the checkpoint. The implementation of this method for the listed objects is: ``` def _add_trackable_child(self, name, value): self.__setattr__(name, value) ``` Args: name: The name of the connection between the parent and child `Trackable`. value: The child `Trackable` object. T)rN)r)rrrjrrr_add_trackable_childlszTrackable._add_trackable_childcCs~iS)anReturns a dictionary containing `Trackables` that this object depends on. Dependencies define the order to serialize and deserialize objects in the SavedModel. For example: class A(Trackable): b = B() def _deserialization_dependencies(self, children): return {'b': self.b} class B(Trackable): pass We say that object `a=A()` depends on `a.b`. Dependencies are guaranteed to be serialized and deserialized before the object depending on them. The following methods use dependencies: - `_deserialize_from_proto` [loading] SavedModel loads with the bottom-up approach, by first creating all objects in the order defined by the dependencies, then connecting the children. Unlike `_trackable_children`, this function does not define the `SavedObjectGraph`. It only changes the order in which things are saved/loaded. Therefore, if there are dependencies that are not in the `SavedObjectGraph`, saving will fail. Args: children: Dict returned from `_trackable_children`. Returns: A dictionary mapping names to `Trackable`. r)rchildrenrrr_deserialization_dependenciess"z'Trackable._deserialization_dependenciescKs~~~|dd|jDS)aReturns this object's `Trackable` attributes. This method is used to build the object graph (or the object hierarchy, in pickling terms) for checkpoint save/restore, and `SavedModel` export. Override this method to define the children of this instance. Please read the implementation restrictions: **Rule 1: All children must be convertable to `Trackable`.** Must pass `isinstance` check or `converter.convert_to_trackable`. **Rule 2: [Checkpoint-only] Do not create new objects.** When saving to a `SavedModel`, this method is called *exactly once* for each `Trackable` in the object graph. When saving or restoring from a checkpoint, this method may be called *multiple times*. Thus, this method may create new Trackables when `save_type == SaveType.SAVEDMODEL` but not when `save_type == SaveType.CHECKPOINT`. When saving to `SavedModel`, new `Trackable` children can be created to save non-Trackable attributes to the `SavedModel`. In the example below, `hyper` is a regular python float hyperparameter. To save this value, a new Variable is created to store the value of `hyper`: ``` def __init__(self): self.hyper = 1e-5 def _trackable_children(self, save_type, **unused_kwargs): # Correct implementation children = {} if format == 'saved_model': children['hyper'] = tf.Variable(self.hyper) return children ``` An incorrect implementation of `_trackable_children` is shown below. This function would cause failures when loading the checkpoint, and calling `load_status.assert_consumed()` or `load_status.assert_existing_objects_matched`. If you want a value to be saved in the checkpoint, hyper must be defined as a `tf.Variable` from the start. ``` def _trackable_children(self, save_type, **unused_kwargs): # Incorrect implementation return {'hyper': tf.Variable(self.hyper)} ``` **Rule 3: [`SavedModel`-only] Watch out for un-traced tf.functions.** At the begining of `_trackable_children`, always call `get_concrete_function()` for any `tf.function` that has an input signature. When `tf.functions` are saved to `SavedModel`, any `tf.functions` that have an input signature and has never been called is traced at export time in order to copy the op graph into the `SavedModel`. `tf.functions` that are traced for the first time are allowed to create new state: ``` @tf.function(input_signature=[]): def fn(self); if self.v is None: self.v = tf.Variable(1.) return self.v ``` A problem occurs when there is a `Trackable` that returns `fn` as one of its children and `self.v` has not been created yet. When `fn` is traced, `self.v` is added to the `Trackable`, but `SavedModel` does not see this modification since the `Trackable`'s children have already been gathered. Therefore, as a precaution, call `get_concrete_function()` at the very start of `_trackable_children` to ensure that the function is traced: ``` def _trackable_children(self): self.fn.get_concrete_function() return {"v": self.v, "fn": self.fn} ``` Args: save_type: A string, can be 'savedmodel' or 'checkpoint'. Defaults to SaveType.CHECKPOINT. cache: May be `None`, or a dictionary. When `save_type == savedmodel`, a new cache is created at the start of the SavedModel export, and shared between all `Trackables` in the same object graph. This cache may be used for advanced saving functionality. **kwargs: Additional kwargs that may be added at a later time. Returns: Dictionary mapping names to child trackables. cSsi|]\}}||qSrr)r:rrrrr r=z1Trackable._trackable_children..)rzr)r save_typecacherWrrr_trackable_childrensdzTrackable._trackable_childrencKs0~||\}}||||t|S)aCreates a copy of this object's tensors onto SavedModel graph. Needs to be overridden if the class contains tensors that must be saved into the graph. This method should update the `object_map` and `tensor_map` dictionaries. This method is called on all nodes in the Trackable Graph (generated by `_trackable_children`). The nodes are traversed in the order defined by `_deserialization_dependencies` All usages of _map_resources should be migrated to this method. Args: object_map: A dictionary that maps original Trackables to the copied Trackables. This only needs to be updated if the object is a tf.function, or if the copied tensors are necessary for checkpointing this object. tensor_map: Dictionary mapping original tensors to copied tensors. options: A `tf.saved_model.SaveOptions` object. **kwargs: Additional kwargs that may be added at a later time. Returns: Flat list of original tensors that have been copied. )rupdatelistkeys)rZ object_mapZ tensor_mapoptionsrWZself_object_mapZself_tensor_maprrr_export_to_saved_model_graphs   z&Trackable._export_to_saved_model_graph)F)N)NNNNNN)NNN)&rr$r%r&r(resetterrmrprrrtr`rzr{r|rrrrrfloat32rrrrrrrrr classmethodrrrSaveType CHECKPOINTrrrrrrrgsr         +    E$ 7&01  S& jrg)'r& collectionsr*tensorflow.python.eagerrtensorflow.python.frameworkrrtensorflow.python.opsrtensorflow.python.trackablerrrtensorflow.python.utilrr tensorflow.python.util.tf_exportr ZOBJECT_GRAPH_PROTO_KEYrCZOBJECT_CONFIG_JSON_KEYrobjectr r) namedtupleZ ShardInfor0Tensorr5SaveableObjectrKrTr`contextmanagerrdrfrgrrrrsL          )  $