o i e=9@szdZddlZddlZddlZddlmZdddZ  dddZd d Z dd d Z dddZ ddZ ddZ ddZdS)z/Utilities related to layer/model functionality.N)nestcst|ds|S|dus |r|j\}}}|js|gS|j|}|jr't|jSg}|D]!\}}}}t|||}|D]t fdd|DrM| q;q-|S)aReturns the list of input tensors necessary to compute `tensor`. Output will always be a list of tensors (potentially with 1 element). Args: tensor: The tensor to start from. layer: Origin layer of the tensor. Will be determined via tensor._keras_history if not provided. node_index: Origin node index of the tensor. Returns: List of input tensors. _keras_historyNc3s|]}|uVqdSN).0txrX/var/www/myenv/lib/python3.10/site-packages/tensorflow/python/keras/utils/layer_utils.py ;sz$get_source_inputs..) hasattrr_inbound_nodesis_inputrflatten input_tensorsiterate_inboundget_source_inputsallappend)tensorlayer node_index_nodesource_tensorsprevious_sourcesrrr rs$       rFcCst|r|durdS|rt|rdSt|tr||vrdS|rdnd}||r&dnd7}|d|f7}td||||f)z0Validates the correctness of a string-based arg.Nz`None`, za `Callable`, z"or one of the following values: %szQThe %s argument of layer %s received an invalid value %s. Allowed values are: %s.)callable isinstancestr ValueError) input_dataallowable_strings layer_namearg_name allow_noneallow_callables allowed_argsrrr validate_string_arg@s    r(cCsDdd|D}dd|D}dd|D}ttdd|DS)zCount the total number of scalars composing the weights. Args: weights: An iterable containing the weights on which to compute params Returns: The total number of scalars composing the weights cSsi|]}t||qSr)idrwrrr _z count_params..cSsg|]}|jqSr)shapeas_listr*rrr `r-z count_params..cSsg|] }dd|DqS)cSsg|] }|dur dn|qS)Nrr)rw_irrr r0bsz+count_params...rr*rrr r0ascss|]}t|VqdSr)npprodrprrr r dszcount_params..)valuesintsum)weightsunique_weights weight_shapesstandardized_weight_shapesrrr count_paramsVs  r=csdurt|jjdkrd}nT|jsd}nNd}|j}g}|D]"}t|dks:t|dkr>tt|dj dkr>d}n||7}q |rc|j D]}d} |j D]} | |vr]| r[d}nd} qO|sbnqH|rphdpngdd dkr~fd d Dgd } n+pd pgdd dkrfdd Dgd} g|jD]}|7qfddd |j d| dfdd} fdd} |j }tt|D]'}|r| ||n| |||t|dkrdqdqt|drt|j}nt|j}t|j}d ||d |d |ddS)aZPrints a summary of a model. Args: model: Keras model instance. line_length: Total length of printed lines (e.g. set this to adapt the display to different terminal window sizes). positions: Relative or absolute positions of log elements in each line. If not provided, defaults to `[.33, .55, .67, 1.]`. print_fn: Print function to use. It will be called on each line of the summary. You can set it to a custom function in order to capture the string summary. It defaults to `print` (prints to stdout). N SequentialTrFA)g?g333333??cg|]}t|qSrr7r4 line_lengthrr r0z!print_summary..) Layer (type) Output ShapeParam #b)gQ?g?gq= ףp?rAcrCrrDr4rErr r0rG)rHrIrJz Connected tocsrd}tt|D]*}|dkr|ddd}|t||7}|d||}|d||t|7}q|dS)NrrrB )rangelenr)fields positionslinei)print_fnrr print_rows z print_summary..print_rowz Model: "{}"r=csz|j}Wntyd}Yn tyd}Ynw|j}|jj}|js.t|dds.d}n|}|d|d||g}|dS) zQPrints a summary for a single layer. Args: layer: target layer. multiple?_is_graph_networkFz 0 (unused) ()N) output_shapeAttributeError RuntimeErrorname __class____name__builtgetattrr=)rr[r^cls_nameparamsrO)rPrTrr print_layer_summarys   z*print_summary..print_layer_summaryc sz|j}Wn tyd}Ynwg}|jD]}r|vrq|D]\}}}}|d|j||q#q|j}|jj} |sBd} n|d} |d| d|| | g} | t |dkrvt dt |D]} ddd|| g} | qfdSdS) zuPrints a summary for a single layer (including topological connections). Args: layer: target layer. rVz {}[{}][{}]rrrYrZr?N) r[r\r rrformatr^r_r`r=rNrM) rr[ connectionsr inbound_layerr tensor_indexrr^rcfirst_connectionrOrR)rPrTrelevant_nodesrr $print_layer_summary_with_connectionss:       z;print_summary..print_layer_summary_with_connections_collected_trainable_weightszTotal params: {:,}zTrainable params: {:,}zNon-trainable params: {:,})printr_r`rX_nodes_by_depthr6rNrr keras_inputslayersr rfr^rMr r=rmtrainable_weightsnon_trainable_weights)modelrFrPrSsequential_likenodes_by_depthnodesvrflagr to_displayrerlrqrRtrainable_countnon_trainable_countr)rFrPrSrTrkr print_summarygs               $     r}channels_firstc Cs|dvsJ|\}}t|jdD]M}|dkr5|\}}}|||f} |dd|f| } t| d} n|\}}}|||f} |dd|f| } t| d} t| t|f|dd|f<q|||gdS)a=Utility useful when changing a convnet's `data_format`. When porting the weights of a convnet from one data format to the other, if the convnet includes a `Flatten` layer (applied to the last convolutional feature map) followed by a `Dense` layer, the weights of that `Dense` layer should be updated to reflect the new dimension ordering. Args: dense: The target `Dense` layer. previous_feature_map_shape: A shape tuple of 3 integers, e.g. `(512, 7, 7)`. The shape of the convolutional feature map right before the `Flatten` layer that came before the target `Dense` layer. target_data_format: One of "channels_last", "channels_first". Set it "channels_last" if converting a "channels_first" model to "channels_last", or reciprocally. > channels_lastr~r?r~N)rr?)r?rr) get_weightsrMr.reshaper2 transposer3 set_weights) denseprevious_feature_map_shapetarget_data_formatkernelbiasrRchr+original_fm_shapekirrr !convert_dense_weights_data_formats       "rcCs$t|ddsdS|jdko|jdkS)N_keras_api_namesF)zkeras.layers.Layer)rbr_keras_api_names_v1)rrrr is_builtin_layer6s  rcs*ttfdd}|_|S)a' Lightweight decorator for caching lazily constructed properties. When to use: This decorator provides simple caching with minimal overhead. It is designed for properties which are expensive to compute and static over the life of a class instance, and provides no mechanism for cache invalidation. Thus it is best suited for lazily exposing derived properties of other static data. For classes with custom getattr / setattr behavior (such as trackable objects), storing cache results as object attributes is not performant. Instead, a specialized cache can significantly reduce property lookup overhead. (While still allowing the decorated property to be lazily computed.) Consider the following class: ``` class MyClass(object): def __setattr__(self, key, value): # Some expensive class specific code # ... # ... super(MyClass, self).__setattr__(key, value) @property def thing(self): # `thing` is expensive to compute (and may not even be requested), so we # want to lazily compute it and then cache it. output = getattr(self, '_thing', None) if output is None: self._thing = output = compute_thing(self) return output ``` It's also worth noting that ANY overriding of __setattr__, even something as simple as: ``` def __setattr__(self, key, value): super(MyClass, self).__setattr__(key, value) ``` Slows down attribute assignment by nearly 10x. By contrast, replacing the definition of `thing` with the following sidesteps the expensive __setattr__ altogether: ''' @property @tracking.cached_per_instance def thing(self): # `thing` is expensive to compute (and may not even be requested), so we # want to lazily compute it and then cache it. return compute_thing(self) ''' Performance: The overhead for this decorator is ~0.4 us / call. A much lower overhead implementation (~0.085 us / call) can be achieved by using a custom dict type: ``` def dict_based_cache(f): class Cache(dict): __slots__ = () def __missing__(self, key): self[key] = output = f(key) return output return property(Cache().__getitem__) ``` However, that implementation holds class instances as keys, and as a result blocks garbage collection. (And modifying it to use weakref's as keys raises the lookup overhead to ~0.4 us) As a result, the WeakKeyDictionary implementation below turns out to be more prudent. Args: f: The function to cache. Returns: f decorated with simple caching behavior. cs&|}|dur||<}|Sr)get)itemoutputcachefrr wrappeds z$cached_per_instance..wrapped)weakrefWeakKeyDictionary functoolswrapsr)rrrrr cached_per_instance@s Rrccst}|ddd}|rC|}t||vrq |t|t|dr-t|ts-|Vnt|ddp4g}||ddd|s dSdS)z4Filter out empty Layer-like containers and uniquify.NrB _is_layerrq) setpopr)addr rtyperbextend) layer_listexistingto_visitobj sub_layersrrr filter_empty_layer_containerss  r)NN)FF)NNN)r~)__doc__rrnumpyr2tensorflow.python.utilrrr(r=r}rrrrrrrr s"  *  + ' _