BVhlFdZddlZddlZddlZ ddlZddlmZddlm Z ddl m Z ddl mZdd l mZdd lmZdd lmZGd d ZdZedgdZedgdZGddeZedgGddej4ZGddeej8ZGddeej<eZ GddeejBZ!Gdd eejDZ#Gd!d"eejDZ$d#Z%d$Z&d%Z'y#e$r ddlmZY wxYw)&zTrackable data structures.N)wrapt) def_function)function) variables)base) layer_utils)collections_abc) tf_exportceZdZdZdgZdZy) NoDependencyaAllows attribute assignment to `Trackable` objects with no dependency. Example usage: ```python obj = Trackable() obj.has_dependency = tf.Variable(0., name="dep") obj.no_dependency = NoDependency(tf.Variable(1., name="nodep")) assert obj.no_dependency.name == "nodep:0" ``` `obj` in this example has a dependency on the variable "dep", and both attributes contain un-wrapped `Variable` objects. `NoDependency` also works with `tf.keras.Model`, but only for checkpoint dependencies: wrapping a `Layer` in `NoDependency` will assign the (unwrapped) `Layer` to the attribute without a checkpoint dependency, but the `Model` will still track the `Layer` (so it will appear in `Model.layers`, and its variables will appear in `Model.variables`). valuec||_yNrselfrs [/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/trackable/data_structures.py__init__zNoDependency.__init__:s DJN)__name__ __module__ __qualname____doc__ __slots__rrrr r #s(i)rr c6|D]}t|tryt|tjryt |t k(ryt |t jk(ryt |tk(ryt|tst|syy)z2Determine if a tuple has any trackable components.TF) isinstancer r Trackabletypedict collections OrderedDictlisttuple_should_wrap_tuple)telements rr&r&>s~  g'<( '4>>*  G}  G} ///  G} '5!&8&A   rz__internal__.tracking.wrap)v1ct|tr |jSt|tjr|St |t k(r t|St |tjk(r t|St |tk(r t|St|trt|r t|S|S)aWraps input value into trackable data structures. This is mostly useful for containers like list, dict, etc, which could contain trackable objects in it. Wrapped data structure will be tracked when associated with a `tf.Module`, so that save model/checkpoint can properly track the dependency. It will also unwrap NoDependency objects. Args: value: the input object to be wrapped. Returns: Wrapped trackable data structure. )rr rrrr r! _DictWrapperr"r#r$ ListWrapperr%r& _TupleWrapperrs rwrap_or_unwrapr.Vs(|$ ;;t~~& L E{d   E{k---   E{d u %$6u$=   Lrz1__internal__.tracking.sticky_attribute_assignmentct|trd}nd}t|}|s|St|tjr|j ||d|S)akAdds dependencies, generally called from __setattr__. This behavior is shared between Trackable and Model. Respects NoDependency indicators, but otherwise makes trackable objects out of common data structures and tracks objects by their attribute names. Args: trackable: The object to add dependencies to (generally the one having an attribute assigned). name: The attribute name being assigned. value: The value being assigned. Not necessarily a trackable object. Returns: The value which should be stored in the attribute (unwrapped from a NoDependency object if necessary). FT)name overwrite)rr r.rr_track_trackable) trackabler0radd_dependencys rsticky_attribute_assignmentr5|s\&|$NN  %  Lt~~&  D  ,rceZdZdZdZy)_UntrackableErrorc||_yr_valuers rrz_UntrackableError.__init__s DKrc"d|jdS)NzZOnly trackable objects (such as Layers or Optimizers) may be stored in a List object. Got z(, which does not inherit from Trackable.r9rs r__str__z_UntrackableError.__str__s ,,0KK=9& &'rN)rrrrr=rrrr7r7s 'rr7z,__internal__.tracking.TrackableDataStructureceZdZdZdZedZedZejdZdZ edZ edZ ed Z ed Z ed Zed Zed ZedZedZedZedZdZdZy)TrackableDataStructurez?Base class for data structures which contain trackable objects.cTd|_g|_tjd|_yNT)_self_trainable_self_extra_variablesr AttributeSentinel_self_attribute_sentinelr<s rrzTrackableDataStructure.__init__s'  D!#D$/$A$A$$GD!rc|jSr)rEr<s r_attribute_sentinelz*TrackableDataStructure._attribute_sentinels  ( ((rc|jSrrBr<s r trainablez TrackableDataStructure.trainables   rc||_yrrIrs rrJz TrackableDataStructure.trainables  DrcPt|||}t|tjr|jj |t|t js t|t|drd|_ t|dd}|r|j|j|S)zAdd a dependency on `value`.r3rr0_use_resource_variablesTrGN)r5rrVariablerCappendrrr7hasattrrNgetattr add_parentrG)rrr0value_attribute_sentinels r _track_valuez#TrackableDataStructure._track_values 'e$ 0E%++,   ''. eT^^ , e $$u/0'+e#&u.CTJ))$*B*BC Lrctd)z9An iterable/sequence which may contain trackable objects.zAbstract method)NotImplementedErrorr<s r_valueszTrackableDataStructure._valuess / 00rcg}|jD]N}t|ts+tj|stj |s>|j |P|S)z#>>?   9# c4>> *w &0( !8!8 8 9  9 9 ! "$A B #" "$A A #"7!%sDDDDc4|j|jzSr)rfrjr<s rweightszTrackableDataStructure.weightss  ! !D$>$> >>rc|jSr)rfr<s rrcz*TrackableDataStructure.trainable_variabless  ! !!rc|jSr)rjr<s rrhz.TrackableDataStructure.non_trainable_variables s  % %%rc|jSr)rlr<s rrz TrackableDataStructure.variables$s <<rcdg}|jD]}t|ds||jz } |S)z-Aggregate updates from any `Layer` instances.updates)rarQrqr aggregatedlayers rrqzTrackableDataStructure.updates(s< J$  "emm# $ rcdg}|jD]}t|ds||jz } |S)z,Aggregate losses from any `Layer` instances.losses)rarQrvrrs rrvzTrackableDataStructure.losses4s<J#  !ell" # rct|Sr)idr<s r__hash__zTrackableDataStructure.__hash__=s  d8Orc ||uSrrrothers r__eq__zTrackableDataStructure.__eq__Bs 5=rN)rrrrrpropertyrGrJsetterrUrXr^rarfrjrlrcrhrrqrvryr}rrrr?r?s:GH ) )     !!" 1 1     I I  ;  ; # #< ? ? " " & &         rr?ceZdZdZfdZdZdZdZdZdZ e dZ d Z d Z d Zd Zd ZdZdZdZdZdZdZdZfdZxZS)ListaAn append-only sequence type which is trackable. Maintains checkpoint dependencies on its contents (which must also be trackable), and forwards any `Layer` metadata such as updates and losses. Note that `List` is purely a container. It lets a `tf.keras.Model` or other trackable object know about its contents, but does not call any `Layer` instances which are added to it. To indicate a sequence of `Layer` instances which should be called sequentially, use `tf.keras.Sequential`. Example usage: ```python class HasList(tf.keras.Model): def __init__(self): super().__init__() self.layer_list = List([layers.Dense(3)]) self.layer_list.append(layers.Dense(4)) def call(self, x): aggregation = 0. for l in self.layer_list: x = l(x) aggregation += tf.reduce_sum(x) return aggregation ``` This kind of wrapping is necessary because `Trackable` objects do not (yet) deeply inspect regular Python data structures, so for example assigning a regular list (`self.layer_list = [layers.Dense(3)]`) does not create a checkpoint dependency and does not add the `Layer` instance's weights to its parent `Model`. ct||j|i||_t |jD]4\}}|j ||j ||j|<6y)z;Construct a new sequence. Arguments are passed to `list()`.r0N)superr _make_storage_storage enumeraterU _name_element)rargskwargsindexr( __class__s rrz List.__init__ksq G&D&&77DM#DMM23w!.. **51/3dmmE3rc^t|tj|jSrr copyrr<s rrz List.copys 4:dii . //rc"|jSrrr<s r__copy__z List.__copy__vs 99;rc`t|tj|j|Srr rdeepcopyrrmemos r __deepcopy__zList.__deepcopy__y" 4:dmmDMM48 99rct|i|S)z:Determines the backing storage (overridden in subclasses).)r$rrrs rrzList._make_storage|s    rcd|fzS)N%dr)rrs rrzList._name_elements 5(?rc|S*Collect values for TrackableDataStructure.rr<s rrXz List._values  Krc|j||jt|j}|jj |yzAdd a new trackable value.N)rUrlenrrPrs rrPz List.appends:   eT%7%7DMM8J%K LEMMrc4|D]}|j|yz#Add a sequence of trackable values.N)rP)rvaluesrs rextendz List.extends kk%rc(|j||Sr)r)rrs r__iadd__z List.__iadd__sKK Krc6|jt|d|zSNrrrRr{s r__add__z List.__add__ ==75*e< < >>r)rrrrrrrrrrr~rXrPrrrrrrrrrrrr __classcell__rs@rrrHs D30:!    = !&/??rrcneZdZdZfdZedZejdZedZejdZfdZ fdZ d Z d Z d Z d Zej j"ffd ZdZdZdZfdZfdZfdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#fdZ$d Z%xZ&S)!r,a7Wraps the built-in `list` to support restore-on-create for variables. Unlike `List`, this sequence type is mutable in the same ways built-in lists are. Instead of throwing an error immediately like `List`, it records problematic mutations (e.g. assigning a new element to a position already occupied, meaning both elements get the same names at different times) and refuses to save. On assignment to an attribute of a Model or Trackable object, Python lists are replaced with ListWrapper. Wrapping a list in a `NoDependency` object prevents this. ctd|_d|_t| |t |j |_y)abConstruct a new list wrapper. Args: wrapped_list: The initial value of the data structure. A shallow copy may be maintained for error checking. `wrapped_list` itself should not be modified directly after constructing the `ListWrapper`, and if changes are detected the `ListWrapper` will throw an exception on save. FN)_non_append_mutation_value_external_modification_valuerrr$r_last_wrapped_list_snapshot)r wrapped_listrs rrzListWrapper.__init__s3',D#(-D% G\"'+DMM':D$rc|jSr)rr<s r_non_append_mutationz ListWrapper._non_append_mutations  * **rcF|jj||_yr)rGinvalidate_allrrs rrz ListWrapper._non_append_mutations ++-&+D#rc|jSr)rr<s r_external_modificationz"ListWrapper._external_modifications  , ,,rcF|jj||_yr)rGrrrs rrz"ListWrapper._external_modifications ++-(-D%rcht|}|j|_|j|_|Sr)rrrr)rcopiedrs rrzListWrapper.__copy__s1 W  F"&";";F$($?$?F! Mrcjt||}|j|_|j|_|Sr)rrrr)rrrrs rrzListWrapper.__deepcopy__s3 W !$ 'F"&";";F$($?$?F! Mrc4|j|jffSr)rrrprotocols r __reduce_ex__zListWrapper.__reduce_ex__ s NN ]]  rc|S)z)Use the user's original list for storage.r)rrs rrzListWrapper._make_storages rc|js |jry|j|jk7rd|_d|_yy)zCChecks for any changes to the wrapped list not through the wrapper.NT)rrrrr<s r_check_external_modificationz(ListWrapper._check_external_modifications= ""d&?&?  }}888$(d!)-d&9rc|jj|js |jryt |j |_y)z1Acknowledges tracked changes to the wrapped list.N)rGrrrr$rrr<s r_update_snapshotzListWrapper._update_snapshots;  ++- ""d&?&? '+DMM':D$rc |j|jrtd|d|jr)td|d|jd|j dt ||fi|}|tjjk(rB|jt|Dcic]\}}t|r t||c}}|Scc}}w)NUnable to save the object a (a list wrapper constructed to track trackable TensorFlow objects). A list element was replaced (__setitem__, __setslice__), deleted (__delitem__, __delslice__), or moved (sort). In order to support restoration on object creation, tracking is exclusively for append-only data structures. If you don't need this list checkpointed, wrap it in a non-trackable object; it will be subsequently ignored.z (a list wrapper constructed to track trackable TensorFlow objects). The wrapped list was modified outside the wrapper (its final value was 7, its value when a checkpoint dependency was added was z), which breaks restoration on object creation. If you don't need this list checkpointed, wrap it in a NoDependency object; it will be subsequently ignored.)rrrrrrr_trackable_childrenrSaveType SAVEDMODELupdater _is_functionstrr save_typerchildrenrrrs rrzListWrapper._trackable_children's%%'    &tf-C C DD ""  &tf-66:mm_E9  - - ./"  " ##w*9??HDMM,,,oo%dOc5 %  c(E/ O s(!C cT|jrytd|jDS)zDShort-circuits a check for trackables if there's already a mutation.Tc3PK|]}t|tj ywr)rrr).0r(s r z9ListWrapper._has_mutation_or_trackable..LsPwz'4>>2Ps$&)ranyrr<s r_has_mutation_or_trackablez&ListWrapper._has_mutation_or_trackableHs#    P$--P PPrc|j|jrd|_|j|=|j yrA)rrrrrrs r __delitem__zListWrapper.__delitem__Ns:%%' &&("&d crc|jt|trt|j}||j|<t |}t |j}t t||D]}||kr|j|nd}||kr||nd}t|tjrd|_ |I||k7sO|j|j||j||j|<n\t|j|tjrd|_ |j||j||j|<|jyrA)rrrr$rrrmaxrrrrUrr) rrr storage_copy len_beforelen_nowr value_now value_befores r __setitem__zListWrapper.__setitem__Us;%%'#u$--(l dmmC|$jDMM"gSW-. F!()G DMM!$ *+j.|Ad lDNN 3&*$ #  Y,%>!..t}}Q/?/3/A/A!/DF$--  F DMM#& 7$(!,,UD4F4Fs4KLdmmCrcd|jt| ||jyr)rrrPr)rrrs rrPzListWrapper.appendss'%%' GN5rcd|jt| ||jyr)rrrr)rrrs rrzListWrapper.extendys'%%' GN6rc|dkrN|j|jrd|_|xj|zc_|j |St ||S)NrT)rrrrrrr)rrrs rrzListWrapper.__imul__s[Av '') ( ( *$(! mmqm  k 7 A rc6|jt|d|k(Srrr{s rr}zListWrapper.__eq__ ==GE:u= ==rc6|jt|d|k7Srrr{s r__ne__zListWrapper.__ne__rrc6|jt|d|kSrrr{s r__lt__zListWrapper.__lt__rrc6|jt|d|kSrrr{s r__le__zListWrapper.__le__rrc6|jt|d|kDSrrr{s r__gt__zListWrapper.__gt__rrc6|jt|d|k\Srrr{s r__ge__zListWrapper.__ge__rrctd)Nzunhashable type: 'ListWrapper' TypeErrorr<s rryzListWrapper.__hash__s 4 55rc|j|jst|tjrd|_|j j|||jyrA) rrrrrrrinsertr)rrr]s rr#zListWrapper.insertsO%%' '')ZT^^-L"&dMM$rc|j|jrd|_|jj |j yrA)rrrrsortrr<s rr%zListWrapper.sorts>%%' &&("&dMMrc<|jt|||yr)rr)rrrrs r __setslice__zListWrapper.__setslice__sU1a[!$rc|j|jrd|_|jt ||=|j yrA)rrrrrrrs r __delslice__zListWrapper.__delslice__s@%%' &&("&d eAqk"rch t|||}|S#t$rt|||}Y|SwxYw(Allows storage of non-trackable objects.rr0rMrrUrr5rrr0rs rrUzListWrapper._track_valueL2g"T":e L 2*D2e L 2 11c4dt|jdS)Nz ListWrapper(rrr<s rrzListWrapper.__repr__s $T]] 3 55r)'rrrrrr~rrrrrrrrrrr CHECKPOINTrrrrrPrrr}rrrrrryr#r%r'r)rUrrrs@rr,r,s ;" + + , , - -  .!.  .;+/--*B*BBQ <  >>=>=>6 % 6rr,cneZdZdZfdZdZdZdZedZ dZ dZ d Z d Z d Zd Zd ZxZS)MappingzAn append-only trackable mapping data structure with string keys. Maintains checkpoint dependencies on its contents (which must also be trackable), named based on its keys. Note that once a key has been added, it may not be deleted or replaced. c *t||j|i||_|jj |jj Dcic](\}}||j ||j|*c}}ycc}}w)z;Construct a new sequence. Arguments are passed to `dict()`.rN)rrrrritemsrUr)rrrrrrs rrzMapping.__init__s G&D&&77DMMM ==..0 2 S% d **3/ 1 1 23 2s-B c^t|tj|jSrrr<s rrzMapping.__copy__rrc`t|tj|j|Srrrs rrzMapping.__deepcopy__rrct|i|Sr)r!rs rrzMapping._make_storages    rcjttt|jd}|r|dSgS)rc |dSNrrits rz!Mapping._values.. BqErrrr$zipsortedr7rordereds rrXzMapping._values33tzz|1ABCDG QZ Ircht|tstdt|dt|S)Nz0Mapping accepts only string keys, but got a key .)rrr!rrs rrzMapping._name_elements4 c3   $--(8(8$? @F)-)I)IF&"&";";F Mrcjttt|jd}|r|dSgS)rc |dSr=rr>s rr@z&_DictWrapper._values..RrArrBrrCrFs rrXz_DictWrapper._valuesNrHrc |j|jrtd|d|jrtd|d|d|jd|j rJt ||fi|}|tjjk(r?|j|jDcic]\}}t|s||c}}|Scc}}w)zBCheck that the object is saveable before listing its dependencies.ra, (a dictionary wrapper constructed automatically on attribute assignment). The wrapped dictionary contains a non-string key which maps to a trackable object or mutable data structure. If you don't need this dictionary checkpointed, wrap it in a non-trackable object; it will be subsequently ignored.z (a dictionary wrapper constructed automatically on attribute assignment). The wrapped dictionary was modified outside the wrapper (its final value was rz), which breaks restoration on object creation. If you don't need this dictionary checkpointed, wrap it in a non-trackable object; it will be subsequently ignored.)!_check_self_external_modificationr[rr\ _self_last_wrapped_dict_snapshot_dirtyrrrrrrr7rrs rrz _DictWrapper._trackable_childrenWs**,    &tf-5 5 66 ''  &tf-??CfE9  2 2 34C  C DD{{?w*9??HDMM,,,oo(, L*#u U8K3: LN O Ms 1C C c6|jxs |jS)zACheck if there has already been a mutation which prevents saving.)r\r[r<s rroz_DictWrapper._dirtyvs   , , )((*rcZ|jry||jk7rd|_d|_yy)zCChecks for any changes to the wrapped dict not through the wrapper.NT)rornr\r<s rrmz._DictWrapper._check_self_external_modification|s/ {{  t444)-d&.2d+5rcr|jj|jryt||_y)z1Acknowledges tracked changes to the wrapped dict.N)rGrror!rnr<s rrz_DictWrapper._update_snapshots*++- {{ ,0JD)rct|trd}nd}d} t|t}t|||}|s |sd|_|S#t $rt|||cYSwxYw)r,Tz-non_string_keyFr-rM)rrr rrUr[rr5)rrr0 string_key no_dependencyrs rrUz_DictWrapper._track_valuesz$j dj 2  5mg"T":eM%)! l 2)D222s-AA"!A"c|S)z8Tells TrackableDataStructure to use keys as names as-is.rrs rrz_DictWrapper._name_elements JrcF|j|jt|t}t|tr|j ||}n.t |}|s!t|tjrd|_ ||j|<|jy)zEAllow any modifications, but possibly mark the wrapper as unsaveable.rTN) rm_maybe_initialize_trackablerr rrUr.rrr[r]r)rrrno_deps rrz_DictWrapper.__setitem__s**,$$& | ,F#sC0eU#e  5$..9%)!!DSrc^|j|j|=|jyr)rmr]rrs rrz_DictWrapper.__delitem__s(**, rc4dt|jdS)Nz DictWrapper(rrr]r<s rrz_DictWrapper.__repr__s $T%5%5 6 88rctd)Nzunhashable type: 'DictWrapper'r r<s rryz_DictWrapper.__hash__s 4 55rc |j|k(Srr]r{s rr}z_DictWrapper.__eq__   u $$rcPt|i|jD] \}}|||< yrrOrPs rrz_DictWrapper.updaterQrr)rrrrrrrdrrrr~rXrrr3rrormrrUrrrrryr}rrrs@rr+r+s"!$"   +/--*B*B> * * 372*$ 96% rr+ceZdZdZddZedZfdZdZdZ dZ dZ d Z ed Z d Zd Zd Zej$j&ffd ZfdZxZS)r-z-Trackable wrapper for tuples and namedtuples.c 6g}g}|D]O}t|tr|jdn|jd|jt|Q |j}d}t |}d|_|r |ditt|}n||}tjj||tj||r,t||D]\}} }| s |j||t!t||D]"\} \} }| s |j|d| fz$y#t $rd}YwxYw#t$r?tjj||tj|d|_YywxYw)NFTrrr)rr rPr._fieldsrer _self_tuple_is_constructabler!rDr!rrZrr?rUr) roriginal_wrapped_tupler4substituted_wrapped_tupler(fields is_namedtuple original_typer0 should_dependrs rrz_TupleWrapper.__init__sN ")@ G\ *e$d#&&~g'>? @ %--f m/0M)-D%$1%<3v89:%<!#00I"J t%>?##D)+. .";+=0 &$ w    G$  /0 ,5 N56,89'' w  'x89C m ""4)?@''-,1) s% D?=E? E  E AFFc|Srrr<s rrXz_TupleWrapper._valuesrrch t|||}|S#t$rt|||}Y|SwxYwr+r.r/s rrUz_TupleWrapper._track_valuer0r1c4dt|jdS)Nz_TupleWrapper(rr|r<s rrz_TupleWrapper.__repr__s"&t'7'7"8 ::rc,t|jSr)hashr]r<s rryz_TupleWrapper.__hash__s   !!rc |j|k(Srrr{s rr}z_TupleWrapper.__eq__rrcRttj|jSr)r-rr]r<s rrz_TupleWrapper.__copy__s 4#3#34 55rcTttj|j|Sr)r-rrr]rs rrz_TupleWrapper.__deepcopy__s t'7'7> ??rc.|jjSr)r]__dict__r<s rrz_TupleWrapper.__dict__"s    $ $$rc4|j|jffSrr`rs rrz_TupleWrapper.__reduce_ex__-rarc |j|zS)z:Avoid running self.__wrapped__ *= y, which mutates `self`.rrrs rrz_TupleWrapper.__imul__3   a rc |j|zS)z:Avoid running self.__wrapped__ += y, which mutates `self`.rrs rrz_TupleWrapper.__iadd__7rrc |js0td|jd|jjdt ||fi|S)Nz&Unable to save because the namedtuple z` is not constructable from its _fields (i.e. __new__ is overridden). Expected keyword arguments zs. If you do not need to save this object, consider wrapping it in a custom object that does not inherit from tuple.)rrr]rrr)rrrrs rrz!_TupleWrapper._trackable_children;sa  , ,  243C3C2DE((,(8(8(@(@'AB5 5 66 7 &y ;F ;;rc |dk7r,t|j|rt|j|Stt||r9t tt||t rt j||St||S)Nr]) rQr]rRr rr~rcrdr)rr0rs rrdz_TupleWrapper.__getattribute__Esw })9)94!@T%%t ,,T D! wtDz40( ;  $ $T4 00 W %d ++r)r)rrrrrr~rXrUrryr}rrrrrrrrr3rrdrrs@rr-r-s5/9b   ;" % 6@ % %!   +/--*B*B<,,rr-cVt|tjtjfSr)rrFunctiondefunConcreteFunction)xs rrrVs A --u/E/EF GGrct|}t||kr$|jdgd|zt|z z|||<yNr)intrr list_object index_stringr item_indexs r set_list_itemrZsF< *#vZ#k2B!BCD!+jrc t|}t||kr$|jdgd|zt|z z|||<y#t$rYywxYwr)rrrrrs rset_tuple_itemrasa \"J #vZ#k2B!BCD!+j    s A AA)(rr"rrr ImportError third_partytensorflow.python.eagerrrrtensorflow.python.opsrtensorflow.python.trackablerr tensorflow.python.util.compatr tensorflow.python.util.tf_exportr r r&r.r5rr7rr?SequencerMutableSequencer$r,r5rZr+r-rrrrrrrsX  % 15+,39660 'B/!0!J >2F G F' ' 9bAYT^^YBYxt? !?#;#;t?tD6## D6NB$o&=&=BJz)5+<+<zzH,*E,=,=H,VH""W"%$$%sD D D