a Sic@sdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddlZddlmmZddlmZddlmZddlmZddlmZiZiZdadZeZed d Gd d d Z ed ddZ!dZ"eZ#ea$ea%ddZ&ddZ'ddZ(GdddZ)GdddZ*GdddZ+Gddde,Z-Gdd d Z.d^d!d"Z/ed#d_d%d&Z0ed'd(d)Z1ej2d*d+Z3ed,d`d-d.Z4Gd/d0d0e5Z6ed1d2d3Z7dad4d5Z8dbd7d8Z9ed9dcd:d;Z:dd?ZdEdFZ?dfdGdHZ@dIdJZAdKdLZBdMdNZCdOdPZDdgdRdSZEdTdUZFdVdWZGdXdYZHdZd[ZIGd\d]d]e jJZKe ZLdS)hz#Python utilities required by Keras.N)io_utils) tf_contextlib) tf_inspect) keras_exportFzlayer was saved without configzkeras.utils.custom_object_scopezkeras.utils.CustomObjectScopec@s(eZdZdZddZddZddZdS) CustomObjectScopeaExposes custom classes/functions to Keras deserialization internals. Under a scope `with custom_object_scope(objects_dict)`, Keras methods such as `tf.keras.models.load_model` or `tf.keras.models.model_from_config` will be able to deserialize any custom object referenced by a saved config (e.g. a custom layer or metric). Example: Consider a custom regularizer `my_regularizer`: ```python layer = Dense(3, kernel_regularizer=my_regularizer) # Config contains a reference to `my_regularizer` config = layer.get_config() ... # Later: with custom_object_scope({'my_regularizer': my_regularizer}): layer = Dense.from_config(config) ``` Args: *args: Dictionary or dictionaries of `{name: object}` pairs. cGs||_d|_dSN)custom_objectsbackup)selfargsr U/var/www/html/django/DPS/env/lib/python3.9/site-packages/keras/utils/generic_utils.py__init__TszCustomObjectScope.__init__cCs(tj|_|jD]}tj|q|Sr)_THREAD_LOCAL_CUSTOM_OBJECTS__dict__copyr rupdate)r objectsr r r __enter__Xs  zCustomObjectScope.__enter__cOstjtj|jdSr)rrclearrr r r kwargsr r r __exit__^s zCustomObjectScope.__exit__N)__name__ __module__ __qualname____doc__rrrr r r r r6srzkeras.utils.get_custom_objectscCstS)aRetrieves a live reference to the global dictionary of custom objects. Custom objects set using using `custom_object_scope` are not added to the global dictionary of custom objects, and will not appear in the returned dictionary. Example: ```python get_custom_objects().clear() get_custom_objects()['MyObject'] = MyObject ``` Returns: Global dictionary of names to classes (`_GLOBAL_CUSTOM_OBJECTS`). )_GLOBAL_CUSTOM_OBJECTSr r r r get_custom_objectscsrshared_object_idcCs ttddS)zFGet whether shared object handling is disabled in a threadsafe manner.disabledF)getattrSHARED_OBJECT_DISABLEDr r r r _shared_object_disabledsr#cCsttdtS)BGet the current shared object saving scope in a threadsafe manner.scope)r!SHARED_OBJECT_LOADINGNoopLoadingScoper r r r _shared_object_loading_scopesr(cCs ttddS)r$r%N)r!SHARED_OBJECT_SAVINGr r r r _shared_object_saving_scopesr*c@s eZdZdZddZddZdS)DisableSharedObjectScopezA context manager for disabling handling of shared objects. Disables shared object handling for both saving and loading. Created primarily for use with `clone_model`, which does extra surgery that is incompatible with shared objects. cCsdt_t|_t|_dSNT)r"r r(_orig_loading_scoper*_orig_saving_scoper r r r rsz"DisableSharedObjectScope.__enter__cOsdt_|jt_|jt_dS)NF)r"r r-r&r%r.r)rr r r rsz!DisableSharedObjectScope.__exit__N)rrrrrrr r r r r+sr+c@s eZdZdZddZddZdS)r'zThe default shared object loading scope. It does nothing. Created to simplify serialization code that doesn't care about shared objects (e.g. when serializing a single object). cCsdSrr )r unused_object_idr r r getszNoopLoadingScope.getcCsdSrr r object_idobjr r r setszNoopLoadingScope.setN)rrrrr1r5r r r r r'sr'c@s0eZdZdZddZddZddZdd Zd S) SharedObjectLoadingScopeaWA context manager for keeping track of loaded objects. During the deserialization process, we may come across objects that are shared across multiple layers. In order to accurately restore the network structure to its original state, `SharedObjectLoadingScope` allows us to re-use shared objects rather than cloning them. cCstr tS|t_i|_|Sr)r#r'r&r%_obj_ids_to_objr/r r r rs z"SharedObjectLoadingScope.__enter__cCs|dur dS|j|S)aGiven a shared object ID, returns a previously instantiated object. Args: object_id: shared object ID to use when attempting to find already-loaded object. Returns: The object, if we've seen this ID before. Else, `None`. N)r7r1)r r3r r r r1s zSharedObjectLoadingScope.getcCs|dur dS||j|<dS)zr r8s r8c@s0eZdZdZddZddZddZdd Zd S) SharedObjectSavingScopez6Keeps track of shared object configs when serializing.cCs@tr dStdur d|_tSd|_|t_t|_d|_|S)NTFr) r#r* _passthroughr)r%weakrefWeakKeyDictionary_shared_objects_config_next_idr/r r r r s  z!SharedObjectSavingScope.__enter__c Cs4z|j|}Wnttfy&YdS0||S)aGets a `SharedObjectConfig` if one has already been seen for `obj`. Args: obj: The object for which to retrieve the `SharedObjectConfig`. Returns: The SharedObjectConfig for a given object, if already seen. Else, `None`. N)rG TypeErrorKeyErrorrA)r r4shared_object_configr r r get_config s z"SharedObjectSavingScope.get_configcCs@t||j}|jd7_z||j|<Wnty:Yn0|S)z3Create a new SharedObjectConfig for a given object.r:)r8rHrGrI)r r=r4rKr r r create_config5s  z%SharedObjectSavingScope.create_configcOst|ddsdt_dS)NrDF)r!r)r%rr r r rCs z SharedObjectSavingScope.__exit__N)rrrrrrLrMrr r r r rCs rCcCsV||d}|dur||t<tdurR|durRt|}|durNt||S|S|S)z=Returns the serialization of the class with the given config.) class_nameconfigN)r@r*rLrM)cls_name cls_configr4rr=rKr r r serialize_keras_class_and_configIs  rRz'keras.utils.register_keras_serializableCustomcsfdd}|S)aRegisters an object with the Keras serialization framework. This decorator injects the decorated class or function into the Keras custom object dictionary, so that it can be serialized and deserialized without needing an entry in the user-provided custom object dict. It also injects a function that Keras will call to get the object's serializable string key. Note that to be serialized and deserialized, classes must implement the `get_config()` method. Functions do not have this requirement. The object will be registered under the key 'package>name' where `name`, defaults to the object name if not passed. Example: ```python # Note that `'my_package'` is used as the `package` argument here, and since # the `name` argument is not provided, `'MyDense'` is used as the `name`. @keras.utils.register_keras_serializable('my_package') class MyDense(keras.layers.Dense): pass assert keras.utils.get_registered_object('my_package>MyDense') == MyDense assert keras.utils.get_registered_name(MyDense) == 'my_package>MyDense' ``` Args: package: The package that this class belongs to. This is used for the `key` (which is 'package>name') to idenfify the class. Note that this is the first argument passed into the decorator. name: The name to serialize this class under in this package. If not provided or `None`, the class' name will be used (note that this is the case when the decorator is used with only one argument, which becomes the `package`). Returns: A decorator that registers the decorated class with the passed names. csdur n|j}d|}t|r:t|ds:td|tvrXt|dt||tvrvt|dt||t|<|t|<|S)z9Registers a class with the Keras serialization framework.N>rLzACannot register a class that does not have a get_config() method.z has already been registered to )rrisclasshasattr ValueErrorr_GLOBAL_CUSTOM_NAMES)argrNregistered_namenamepackager r decorators* z.register_keras_serializable..decoratorr )r]r\r^r r[r register_keras_serializablebs)r_zkeras.utils.get_registered_namecCs|tvrt|S|jSdS)aReturns the name registered to an object within the Keras framework. This function is part of the Keras serialization and deserialization framework. It maps objects to the string names associated with those objects for serialization/deserialization. Args: obj: The object to look up. Returns: The name associated with the object, or the default Python name if the object is not registered. N)rXr)r4r r r get_registered_namesr`ccs"t}zdadVW|an|a0dSr,)_SKIP_FAILED_SERIALIZATION)prevr r r skip_failed_serializations rcz!keras.utils.get_registered_objectcCsP|tjvrtj|S|tvr$t|S|r8||vr8||S|rL||vrL||SdS)aReturns the class associated with `name` if it is registered with Keras. This function is part of the Keras serialization and deserialization framework. It maps strings to the objects associated with them for serialization/deserialization. Example: ``` def from_config(cls, config, custom_objects=None): if 'my_custom_object_name' in config: config['hidden_cls'] = tf.keras.utils.get_registered_object( config['my_custom_object_name'], custom_objects=custom_objects) ``` Args: name: The name to look up. custom_objects: A dictionary of custom objects to look the name up in. Generally, custom_objects is provided by the user. module_objects: A dictionary of custom objects to look the name up in. Generally, module_objects is provided by midlevel library implementers. Returns: An instantiable class associated with 'name', or None if no such class exists. Nrrr)r\rmodule_objectsr r r get_registered_objects    rfc@s eZdZdS)CustomMaskWarningN)rrrr r r r rgsrgz"keras.utils.serialize_keras_objectc Cstjj|\}}|durdSt|ddp>t|do>t|j }|r^t|jr^t j dt ddt|drZt |j }z |}WnFty}z.trt|td iWYd}~S|WYd}~n d}~00i}|D]n\}}t|tr|||<qz4t|} t| trt|tsd | d <| ||<Wqty@|||<Yq0qt |j }t|||St|d rnt |Std |d dS)aSerialize a Keras object into a JSON-compatible representation. Calls to `serialize_keras_object` while underneath the `SharedObjectSavingScope` context manager will cause any objects re-used across multiple layers to be saved with a special shared object ID. This allows the network to be re-created properly during deserialization. Args: instance: The object to serialize. Returns: A dict-like, JSON-compatible representation of the object's config. Nsupports_maskingF compute_maskzCustom mask layers require a config and must override get_config. When loading, the custom mask layer must be passed to the custom_objects argument.)category stacklevelrLT__passive_serialization__rzCannot serialize zK since it doesn't implement `get_config()`, and also doesn have `__name__`)tf __internal__r^unwrapr!rV is_defaultrirLwarningswarnrgr`r?NotImplementedErrorrarR_LAYER_UNDEFINED_CONFIG_KEYitems isinstancestrserialize_keras_objectdictrW) instance_rhr\rOeserialization_configkeyitemserialized_itemr r r rys\           rycCs<|tjvrtj|S|tvr$t|S|r8||vr8||SdS)zCReturns the item if it is in either local or global custom objects.Nrd)rrr r r get_custom_objects_by_name>s   robjectc Cst|trd|vsd|vr*td|d|d}t|||}|dur\td|d|d|d}t|trv||fSi}|D]j\}} |d kr| ||<qt| trd | vrt| ||d d ||<qt| trt t| |rt| |||<q|D]\}} ||||<q||fS) z@Returns the class name and config for a serialized keras object.rNrOzImproper config format for zB. Expecting python dict contains `class_name` and `config` as keysNUnknown : . Please ensure this object is passed to the `custom_objects` argument. See https://www.tensorflow.org/guide/keras/save_and_serialize#registering_the_custom_object for details.r\rm config_item)rerprintable_module_name) rwrzrWrflistrvdeserialize_keras_objectrxr isfunction) rOrerrrNclsrQdeserialized_objectsrrr r r ,class_and_config_for_serialized_keras_objectIsL       rz$keras.utils.deserialize_keras_objectc Cs|dur dSt|tr4|}t||||\}}|t}t|}|durP|St|drt|j } |pli}d| j vr|j |tt t t tj t | d} n2t|| |} Wdn1s0Yn@|pi}t||fi|} Wdn1s0Yt|| | St|tr|} |r`| |vr`|| } nV| tjvrxtj| } n>| t vrt | } n*|| } | durtd|d| dt| r| S| St|r|Std|d|dS) aTurns the serialized form of a Keras object back into an actual object. This function is for mid-level library implementers rather than end users. Importantly, this utility requires you to provide the dict of `module_objects` to use for looking up the object config; this is not populated by default. If you need a deserialization utility that has preexisting knowledge of built-in Keras objects, use e.g. `keras.layers.deserialize(config)`, `keras.metrics.deserialize(config)`, etc. Calling `deserialize_keras_object` while underneath the `SharedObjectLoadingScope` context manager will cause any already-seen shared objects to be returned as-is rather than creating a new object. Args: identifier: the serialized form of the object. module_objects: A dictionary of built-in objects to look the name up in. Generally, `module_objects` is provided by midlevel library implementers. custom_objects: A dictionary of custom objects to look the name up in. Generally, `custom_objects` is provided by the end user. printable_module_name: A human-readable string representing the type of the object. Printed in case of exception. Returns: The deserialized object. Example: A mid-level library implementer might want to implement a utility for retrieving an object from its config, as such: ```python def deserialize(config, custom_objects=None): return deserialize_keras_object( identifier, module_objects=globals(), custom_objects=custom_objects, name="MyObjectType", ) ``` This is how e.g. `keras.layers.deserialize()` is implemented. N from_configr)rrrrzCould not interpret serialized )rwrzrr1r@r(rVrgetfullargspecrr rrrvrrrr5rxrWrUr) identifierrerrrOrrQr shared_objectarg_specdeserialized_obj object_namer4r r r rsr4          * .          rcCstjdkr2t|jdd}t|dd}nt|j}t|dd}|j }|j rrt dd|j D}nd}|||fS) zSerializes a user defined function. Args: func: the function to serialize. Returns: A tuple `(code, defaults, closure)`. nt\/base64asciicss|] }|jVqdSr) cell_contents).0cr r r )zfunc_dump..N) osr\marshaldumps__code__replacecodecsencodedecode __defaults__ __closure__tuple)funcraw_codecodedefaultsclosurer r r func_dumps  rc st|ttfr*|\}}}t|tr*t|}dd|durPtfdd|D}zt|dd}Wn"ttjfy|d}Yn0t |}|durt }t j |||j||d S) a Deserializes a user defined function. Args: code: bytecode of the function. defaults: defaults of the function. closure: closure of the function. globs: dictionary of global objects. Returns: A function object. cs,fdd}|jd}tt|s(|SS)zEnsures that a value is converted to a python cell object. Args: value: Any value that needs to be casted to the cell type Returns: A value wrapped as a cell object (see function "func_load") csdSrr r valuer r dummy_fnJsz9func_load..ensure_value_to_cell..dummy_fnr)rrwtype)rr cell_valuer rr ensure_value_to_cell@s  z'func_load..ensure_value_to_cellNc3s|]}|VqdSrr )rr|rr r rTrzfunc_load..rrraw_unicode_escape)r\argdefsr)rwrrrrrUnicodeEncodeErrorbinasciiErrorrloadsglobals python_types FunctionTypeco_name)rrrglobsrr rr func_load/s"     rcCs0t|}|r|jdurdS||jvp.||jvS)aChecks if a callable accepts a given keyword argument. Args: fn: Callable to inspect. name: Check if `fn` can be called with `name` as a keyword argument. accept_all: What to return if there is no parameter called `name` but the function accepts a `**kwargs` argument. Returns: bool, whether `fn` accepts a `name` keyword argument. NT)rrvarkwr kwonlyargs)fnr\ accept_allrr r r has_argas rzkeras.utils.Progbarc@sFeZdZdZdddZdd d Zdd d Zd dZddZddZ dS)Progbara[Displays a progress bar. Args: target: Total number of steps expected, None if unknown. width: Progress bar width on screen. verbose: Verbosity mode, 0 (silent), 1 (verbose), 2 (semi-verbose) stateful_metrics: Iterable of string names of metrics that should *not* be averaged over time. Metrics in this list will be displayed as-is. All others will be averaged by the progbar before display. interval: Minimum visual progress update interval (in seconds). unit_name: Display name for step counts (usually "step" or "sample"). r:皙?NstepcCs||_||_||_||_||_|r.t||_nt|_ttj drLtj phdtj vphdtj vphdt j v|_d|_d|_i|_g|_t|_d|_|j|_d|_d|_dS)Nisatty ipykernelposixPYCHARM_HOSTEDr)targetwidthverboseinterval unit_namer5stateful_metricsrVsysstdoutrmodulesrenviron_dynamic_display _total_width _seen_so_far_values _values_ordertime_start _last_update_time_at_epoch_start_time_at_epoch_end_time_after_first_step)r rrrrrrr r r rs0   zProgbar.__init__cCs|dur"|jdurd}n ||jk}|p(g}|D]\}}||jvrL|j|||jvrt||jd}||jvr|||g|j|<q|j|d||7<|j|d|7<q.|dg|j|<q.||_d}t}d||j} ||jkr||_ |j dkr||j |j kr|sdS|j } |jrB|d| 7}|d7}n|d 7}|jdurtt|jd} d t| d ||jf} t||j} t|j| }|dkr| d |d7} ||jkr| d 7} n| d 7} | d|j|7} | d7} nd|} t| |_ || 7}|||}|jdus,|r@| |||j7} nh||j|}|dkrxd|d|dd|df}n(|dkrd|d|df}nd|}d|} |jD]}| d|7} t|j|tr"t|j|dtd|j|d}t|dkr| d|7} n | d|7} n| d|j|7} q|j t| 7_ | |j krh| d| |j 7} |rv| d 7} || 7}tj|ddd}n$|j dkr|rtt|jd} d t| d||jf}|| } |jD]^}| d|7} t|j|dtd|j|d}|dkr2| d|7} n | d|7} q|j r|j |j}||j}||_d|_ | d ||d!7} | d |||j7} | d 7} || 7}tj|ddd}||_ dS)"aUpdates the progress bar. Args: current: Index of current step. values: List of tuples: `(name, value_for_last_step)`. If `name` is in `stateful_metrics`, `value_for_last_step` will be displayed as-is. Else, an average of the metric over time will be displayed. finalize: Whether this is the last update for the progress bar. If `None`, defaults to `current >= self.target`. NFr:rz - %.0fs  %zd/%d [=rT.]z %7d/Unknowniz %d:%02d:%02d<z%d:%02dz%dsz - ETA: %sz - %s:MbP?z %.4fz %.4ez %s ) line_breakrjzd/%dz -epoch) rrappendrmaxrrrrrrrrrrintnplog10rxfloatrlen_estimate_step_duration _format_timerrwrmeanabsr print_msgr)r currentvaluesfinalizekv value_basemessagenowinfoprev_total_width numdigitsbarprog prog_width time_per_uniteta eta_formatavgcountZtime_per_epochZavg_time_per_stepr r r rs                                 zProgbar.updatecCs||j||dSr)rr)r nrr r r add>sz Progbar.addcCs\d}|dks|dkr&|d||f7}n2|dkrD|d|d|f7}n|d|d |f7}|S) aformat a given duration to display to the user. Given the duration, this function formats it in either milliseconds or seconds and displays the unit (i.e. ms/step or s/epoch) Args: time_per_unit: the duration to display unit_name: the name of the unit to display Returns: a string with the correctly formatted duration and units rr:rz %.0fs/%srz %.0fms/%sg@@z %.0fus/%sg.Ar )r r r formattedr r r rAs zProgbar._format_timecCsR|rJ|jdur*|dkr*||j|d}n||j|}|dkrF||_|SdSdS)aEstimate the duration of a single step. Given the step number `current` and the corresponding time `now` this function returns an estimate for how long a single step takes. If this is called before one step has been completed (i.e. `current == 0`) then zero is given as an estimate. The duration estimate ignores the duration of the (assumed to be non-representative) first step for estimates when more steps are available (i.e. `current>1`). Args: current: Index of current step. now: The current time. Returns: Estimate of the duration of a single step. Nr:r)rr)r rrr r r r rUszProgbar._estimate_step_durationcCs|j||_dSr)runion)r rr r r _update_stateful_metricsysz Progbar._update_stateful_metrics)rr:rNr)NN)N) rrrrrrrrrrr r r r rss %  $rcs0ttt}fddtd|DS)zReturns a list of batch indices (tuples of indices). Args: size: Integer, total size of the data to slice into batches. batch_size: Integer, batch size. Returns: A list of tuples of array indices. cs&g|]}|t|dfqS)r:)min)ri batch_sizesizer r sz make_batches..r)rrceilrrange)rr num_batchesr rr make_batches}s  r cs|durdgSttr6dur6tddnt|trtdrntdr\fdd|DSfdd|DStdrtdr|Std r|SdgSdS) aSlice an array or list of arrays. This takes an array-like, or a list of array-likes, and outputs: - arrays[start:stop] if `arrays` is an array-like - [x[start:stop] for x in arrays] if `arrays` is a list Can also work on list/array of indices: `slice_arrays(x, indices)` Args: arrays: Single array or list of arrays. start: can be an integer index (start index) or a list/array of indices stop: integer (stop index); should be None if `start` was a list. Returns: A slice of the array(s). Raises: ValueError: If the value of start is a list and stop is not None. NzQThe stop argument has to be None if the value of start is a list. Received start=z, stop=__len__shapecs g|]}|durdn|qSrr rx)startr r rrz slice_arrays..cs2g|]*}|durdnt|ds"dn |qS)N __getitem__)rVr#r%stopr r rs r&)rwrrWrVtolist)arraysr%r(r r'r slice_arrayss2        r+cCst|tr|S|gS)zNormalizes a list/tensor into a list. If a tensor is passed, we return a list of size 1 containing the tensor. Args: x: target object to be normalized. Returns: A list. )rwr)r$r r r to_lists r,cCs8tdd|}tdd|}|ddkr0|Sd|S)Nz(.)([A-Z][a-z]+)z\1_\2z([a-z])([A-Z])rr|private)resublower)r\ intermediateinsecurer r r to_snake_cases  r3cCs(tj|}|D]}|durdSqdS)NFT)rnnestflatten) structureiterableelementr r r is_all_nones  r9cCs8t||}|r4td|dt|d|dS)NzUnknown entries in z dictionary: z . Only expected following keys: )r5keys differencerWr)r\ input_dictexpected_valuesunknownr r r check_for_unexpected_keyssr? Keyword argument not understood:cCs |D]}||vrt||qdS)zAChecks that all keyword arguments are in the set of allowed keys.N)rI)rallowed_kwargs error_messagekwargr r r validate_kwargssrDcCst|tot|vS)z=Determines whether config appears to be a valid layer config.)rwrzru)rOr r r validate_configsrEcCs d|_|S)z5Decorates a method to detect overrides in subclasses.T) _is_defaultmethodr r r defaultsrIcCs t|ddS)z:Check if a method is decorated with the `default` wrapper.rFF)r!rGr r r rqsrqcCs6|D],}t|D]}t||}||r|||<qqdSr)dirr!) target_dictr obj_filtermoduler\r4r r r !populate_dict_with_module_objects s   rNcs0eZdZdZfddZddZddZZS) LazyLoaderzFLazily import a module, mainly to avoid pulling in large dependencies.cs||_||_t|dSr) _local_name_parent_module_globalsr<r)r local_nameparent_module_globalsr\r>r r rszLazyLoader.__init__cCs*t|j}||j|j<|j|j|S)z8Load the module and insert it into the parent's globals.) importlib import_modulerrQrPrr)r rMr r r _loads  zLazyLoader._loadcCs|}t||Sr)rVr!)r rrMr r r __getattr__%szLazyLoader.__getattr__)rrrrrrVrWrBr r r>r rOs  rO)NN)rSN)NN)N)NNr)NNr)NNN)F)NN)r@)MrrrrTrrr.r threadingrtypesrrrrEnumpyrtensorflow.compat.v2compatv2rn keras.utilsrrr tensorflow.python.util.tf_exportrrrXrarulocalrrrr@r"r&r)r#r(r*r+r'r6rzr8rCrRr_r`contextmanagerrcrfWarningrgryrrrrrrrr r+r,r3r9r?rDrErIrqrN ModuleTyperOcustom_object_scoper r r r s    ) - C  F   % J  K  2   4