o NeM@sBdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl mmZddlmZddlmZddlmZddlmZddZd*d d Zd+d d ZedGdddZddZd,ddZddZddZddZ ddZ! d-ddZ"d d!Z#d"d#Z$d$d%Z%Gd&d'd'e j&Z'Gd(d)d)Z(dS).z#Python utilities required by Keras.N)serialization_lib)io_utils) tf_inspect) keras_exportcCstjdkrt|jdd}t|dd}nt|j}t|dd}|j }|j r9t dd|j D}nd}|||fS) zSerializes a user defined function. Args: func: the function to serialize. Returns: A tuple `(code, defaults, closure)`. nt\/base64asciicss|]}|jVqdSN) cell_contents).0crID:\Projects\ConvertPro\env\Lib\site-packages\keras/utils/generic_utils.py 7szfunc_dump..N) osnamemarshaldumps__code__replacecodecsencodedecode __defaults__ __closure__tuple)funcraw_codecodedefaultsclosurerrr func_dump&s   r#c st|ttfr|\}}}t|trt|}dd|dur(tfdd|D}z t|dd}WnttjfyD|d}Ynwt |}|durQt }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") csdSr rrvaluerrdummy_fnXsz9func_load..ensure_value_to_cell..dummy_fnr)r isinstancetype)r%r&Z cell_valuerr$rensure_value_to_cellNs z'func_load..ensure_value_to_cellNc3s|]}|VqdSr r)r _r)rrrbszfunc_load..r r Zraw_unicode_escape)rZargdefsr")r'rlistrrrUnicodeEncodeErrorbinasciiErrorrloadsglobals python_types FunctionTypeco_name)r r!r"Zglobsrrr+r func_load=s$    r5FcCs0t|}|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)rgetfullargspecvarkwargs kwonlyargs)fnrZ accept_allZarg_specrrrhas_argos r;zkeras.utils.Progbarc@sPeZdZdZ     dddZdd 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"). 皙?NstepcCs||_||_||_||_||_|rt||_nt|_ttj dr&tj p4dtj vp4dtj vp4dt j v|_d|_d|_i|_g|_t|_d|_|j|_d|_d|_dS)NisattyZ ipykernelposixZPYCHARM_HOSTEDr)targetwidthverboseinterval unit_namesetstateful_metricshasattrsysstdoutrAmodulesrenviron_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)selfrCrDrErFrIrGrrr__init__s0    zProgbar.__init__cCs|dur|jdur d}n||jk}|pg}|D]K\}}||jvr&|j|||jvr[t||jd}||jvrB|||g|j|<q|j|d||7<|j|d|7<q|dg|j|<q||_d}t}d||jdd} ||jkr~||_ |j dkr||j |j kr|sdS|j } |jr|d | 7}|d 7}n|d 7}|jdurtt|jd} d t| d ||jf} t||j} t|j| }|dkr| d|d7} ||jkr| d7} n| d7} | d|j|7} | d7} nd|} t| |_ || 7}|||}|jdus|r| |||j7} n5||j|}|dkr9d|d|dd|df}n|dkrId|d|df}nd|}d|} |jD]M}| d|d7} t|j|trt|j|dtd|j|d}t|dkr| d|d7} qU| d|d7} qU| d|j|7} qU|j t| 7_ | |j kr| d| |j 7} |r| d 7} || 7}tj|ddd}n|j dkri|ritt|jd} d t| d ||jf}|| } |jD]6}| d|d7} t|j|dtd|j|d}|dkr$| d|d7} q| d|d7} 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 [=>.]z %7d/Unknowniz %d:%02d:%02d<z%d:%02dz%dsz - ETA: :MbP? z.4fz.4e)Z line_breakzd/%dz -epoch) rCrSappendrImaxrQrRrTrUrXrErVrFrPrOintnplog10strfloatrDlen_estimate_step_duration _format_timerGr'r,meanabsrZ print_msgrW)rZcurrentvaluesfinalizekvZ value_basemessagenowinfoZprev_total_widthZ numdigitsbarprogZ prog_width time_per_unitetaZ eta_formatZavgcountZtime_per_epochZavg_time_per_steprrrupdates                               zProgbar.updatecCs||j||dSr )rrQ)rZnrzrrraddLsz Progbar.addcCsrd}|dks |dkr|d|dd|7}|S|dkr*|d|ddd |7}|S|d|d dd |7}|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 r\r>rrjr]zs/rig@@zms/g.Azus/r)rZrrG formattedrrrrvOs zProgbar._format_timecCsN|r%|jdur|dkr||j|d}n||j|}|dkr#||_|SdS)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)rYrU)rZryrrrrrrucszProgbar._estimate_step_durationcCs|j||_dSr )rIunion)rZrIrrr_update_stateful_metricssz Progbar._update_stateful_metrics)r=r>r?Nr@NNr ) __name__ __module__ __qualname____doc__r[rrrvrurrrrrr<s %  $r<cs0ttt}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)r i batch_sizesizerr sz make_batches..r)rorpceilrsrange)rrZ num_batchesrrr make_batchess rcs|durdgSttrdurtddt|tr@tdr6tdr-fdd|DSfdd|DStdrRtdrN|Std r]|SdgS) 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|] }|dur dn|qSr rr x)startrrrs z slice_arrays..cs2g|]}|dur dn t|dsdn|qS)N __getitem__)rJrrstoprrrs r)r'r, ValueErrorrJtolist)Zarraysrrrrr slice_arrayss2       rcCst|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. )r'r,)rrrrto_lists rcCs8tdd|}tdd|}|ddkr|Sd|S)Nz(.)([A-Z][a-z]+)z\1_\2z([a-z])([A-Z])rr*private)resublower)rZ intermediateZinsecurerrr to_snake_cases  rcCs(tj|}|D] }|durdSqdS)NFT)tfnestflatten)Z structureiterableelementrrr is_all_nones rcCs8t||}|rtd|dt|d|dS)NzUnknown entries in z dictionary: z . Only expected following keys: )rHkeys differencerr,)rZ input_dictZexpected_valuesunknownrrrcheck_for_unexpected_keyssr Keyword argument not understood:cCs |D] }||vr t||qdS)zAChecks that all keyword arguments are in the set of allowed keys.N) TypeError)kwargsZallowed_kwargs error_messagekwargrrrvalidate_kwargss  rcCs d|_|S)z5Decorates a method to detect overrides in subclasses.T) _is_defaultmethodrrrdefaultsrcCs t|ddS)z:Check if a method is decorated with the `default` wrapper.rF)getattrrrrr is_default s rcCs6|D]}t|D]}t||}||r|||<qqdSr )dirr) target_dictrMZ obj_filtermodulerobjrrr!populate_dict_with_module_objectss  rcs0eZdZdZfddZddZddZZS) LazyLoaderzFLazily import a module, mainly to avoid pulling in large dependencies.cs||_||_t|dSr ) _local_name_parent_module_globalssuperr[)rZZ local_nameZparent_module_globalsr __class__rrr[szLazyLoader.__init__cCs*t|j}||j|j<|j|j|S)z8Load the module and insert it into the parent's globals.) importlib import_modulerrr__dict__r)rZrrrr_load!s  zLazyLoader._loadcCs|}t||Sr )rr)rZitemrrrr __getattr__,s zLazyLoader.__getattr__)rrrrr[rr __classcell__rrrrrs   rc@seZdZddZddZdS)ConfigcKs ||_dSr )config)rZrrrrr[2s zConfig.__init__cCs t|jSr )rZserialize_keras_objectr)rZrrr serialize5s zConfig.serializeN)rrrr[rrrrrr1s r)NNN)Fr)r))rr.rrrrrrKrTtypesr2numpyrpZtensorflow.compat.v2compatv2rZkeras.saving.experimentalrZ keras.utilsrrZ tensorflow.python.util.tf_exportrr#r5r;r<rrrrrrrrrr ModuleTyperrrrrrsH      2 4