o ?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).0txrj/home/www/facesmatcher.com/pyenv/lib/python3.10/site-packages/tensorflow/python/keras/utils/layer_utils.py ;sz$get_source_inputs..) hasattrr_inbound_nodesZis_inputrflattenZ input_tensorsiterate_inboundget_source_inputsallappend)Ztensorlayer node_index_nodeZsource_tensorsZprevious_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)Z input_dataZallowable_stringsZ layer_nameZarg_name allow_noneZallow_callablesZ allowed_argsrrr validate_string_arg@s    rcCsDdd|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_listrrrr `r"z count_params..cSsg|] }dd|DqS)cSsg|] }|dur dn|qS)Nrr)rZw_irrr r%bsz+count_params...rrrrr r%ascss|]}t|VqdSr)npprodrprrr r dszcount_params..)valuesintsum)weightsZunique_weightsZ weight_shapesZstandardized_weight_shapesrrr count_paramsVs  r.csdurt|jjdkrd}nT|jsd}nNd}|j}g}|D]"}t|dks:t|dkr>tt|dj dkr>d}qC||7}q |rc|j D]}d} |j D]} | |vr]| r[d}q^d} qO|sbqcqH|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). NZ SequentialTrFA)g?g333333??cg|]}t|qSrr+r( line_lengthrr r%z!print_summary..) Layer (type) Output ShapeParam #b)gQ?g?gq= ףp?r1cr3rr4r(r5rr r%r7)r8r9r:z Connected tocsrd}tt|D]*}|dkr|ddd}|t||7}|d||}|d||t|7}q|dS)Nrrr2 )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__Zbuiltgetattrr.)rrKrNcls_nameparamsr?)r@rDrr 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. rFz {}[{}][{}]rrrIrJr/N) rKrLr rrformatrNrOrPr.r>r=) rrK connectionsrZ inbound_layerrZ tensor_indexrrNrRZfirst_connectionr?rB)r@rDrelevant_nodesrr $print_layer_summary_with_connectionss:       z;print_summary..print_layer_summary_with_connections_collected_trainable_weightszTotal params: {:,}zTrainable params: {:,}zNon-trainable params: {:,})printrOrPrHZ_nodes_by_depthr*r>rrZ keras_inputslayersr rUrNr=r r.rYZtrainable_weightsZnon_trainable_weights)modelr6r@rCZsequential_likeZnodes_by_depthnodesvrflagr to_displayrTrXr[rBZtrainable_countZnon_trainable_countr)r6r@rCrDrWr print_summarygs               $     rachannels_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. >Z channels_lastrbr/rbN)rr/)r/rcr)Z get_weightsr=r#Zreshaper&Z transposer'Z set_weights) ZdenseZprevious_feature_map_shapeZtarget_data_formatZkernelZbiasrBchr Zoriginal_fm_shapeZkirrr !convert_dense_weights_data_formats       "rfcCs$t|ddsdS|jdko|jdkS)N_keras_api_namesF)zkeras.layers.Layer)rQrgZ_keras_api_names_v1)rrrr is_builtin_layer6s  rhcs*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 functoolswrapsrm)rnrorrlr cached_per_instance@s Rrtccst}|ddd}|rC|}t||vrq |t|t|dr-t|ts-|Vnt|ddp4g}||ddd|s dSdS)z4Filter out empty Layer-like containers and uniquify.Nr2Z _is_layerr[) setpopraddr rtyperQextend)Z layer_listexistingZto_visitobjZ sub_layersrrr filter_empty_layer_containerss  r|)NN)FF)NNN)rb)__doc__rrrpnumpyr&Ztensorflow.python.utilrrrr.rarfrhrtr|rrrr s"  *  + ' _