B ӻd9@sdZddlZddlZddlZddlmZddlmZeddddZ dd d Z d d Z dd dZ dddZ ddZddZddZdS)z/Utilities related to layer/model functionality.N)nest) keras_exportzkeras.utils.get_source_inputscst|ds|S|dks|r&|j\}}}|js2|gS|j|}|jrNt|jSg}xR|D]F\}}}}t|||}x,|D]$t fdd|Drz| qzWq\W|SdS)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|]}|k VqdS)N).0t)xr[/var/www/html/venv/lib/python3.7/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_sourcesr)rr rs        rFcCsx|r|dkrdS|r t|r dSt|tr6||kr6dS|r>dnd}||rLdnd7}|d|f7}td||||fdS)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_argBs   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)id)rwrrr asz count_params..cSsg|]}|jqSr)shapeas_list)rrrrr bsz count_params..cSsg|]}dd|DqS)cSsg|]}|dkrdn|qS)Nrr)rZw_irrr r"dsz+count_params...r)rrrrr r"dscss|]}t|VqdS)N)npprod)rprrr r fszcount_params..)valuesintsum)weightsZunique_weightsZ weight_shapesZstandardized_weight_shapesrrr count_paramsXs r*csdkr t|jjdkrd}n|js*d}nd}|j}g}xJ|D]B}t|dksvt|dkr|tt|dj dkr|d}P||7}qBW|rx@|j D]6}d} x&|j D]} | |kr| rd}Pqd} qW|sPqW|rpdpdd d gd dkr fd d Ddddg} njpdp0dddd gd dkrRfdd Dddddg} gx|jD]}|7qnWfddd |j d| dfdd} fdd} |j }xbtt|D]R}|r| ||n | |||t|dkr4dn dqWt|d r^t|j}n t|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 SequentialTrFAg?g333333?g?csg|]}t|qSr)r')rr%) line_lengthrr r"sz!print_summary..z Layer (type)z Output ShapezParam #bgQ?g?gq= ףp?csg|]}t|qSr)r')rr%)r.rr r"sz Connected tocsvd}xdtt|D]T}|dkr.|ddd}|t||7}|d||}|d||t|7}qW|dS)Nrrr- )rangelenr)fields positionslinei)print_fnrr print_rowsz print_summary..print_rowz Model: "{}"r=csy |j}Wn.tk r"d}Yntk r8d}YnX|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)z ()N) output_shapeAttributeError RuntimeErrorname __class____name__Zbuiltgetattrr*)rr>rAcls_nameparamsr3)r4r8rr print_layer_summarys  z*print_summary..print_layer_summaryc sy |j}Wntk r"d}YnXg}xL|jD]B}rB|krBq0x.|D]"\}}}}|d|j||qLWq0W|j}|jj} |sd} n|d} |d| d|| | g} | t |dkrx0t dt |D]} ddd|| g} | qWdS) zuPrints a summary for a single layer (including topological connections). Args: layer: target layer. r:z {}[{}][{}]rrz (r=r+N) r>r?r rrformatrArBrCr*r2r1) rr> connectionsrZ inbound_layerrZ tensor_indexrrArEZfirst_connectionr3r6)r4r8relevant_nodesrr $print_layer_summary_with_connectionss.       z;print_summary..print_layer_summary_with_connections_collected_trainable_weightszTotal params: {:,}zTrainable params: {:,}zNon-trainable params: {:,})printrBrCr<Z_nodes_by_depthr&r2rr Z keras_inputslayersr rHrAr1r r*rLZtrainable_weightsZnon_trainable_weights)modelr.r4r7Zsequential_likeZnodes_by_depthZnodesvrflagr to_displayrGrKrNr6Ztrainable_countZnon_trainable_countr)r.r4r7r8rJr print_summaryis~             $     rSchannels_firstc Cs|dks t|\}}xt|jdD]}|dkrl|\}}}|||f} |dd|f| } t| d} n6|\}}}|||f} |dd|f| } t| d} t| t|f|dd|f<q(W|||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. >rT channels_lastr+rTN)rr+)r+rVr) AssertionErrorZ get_weightsr1r Zreshaper#Z transposer$Z set_weights) ZdenseZprevious_feature_map_shapeZtarget_data_formatZkernelZbiasr6chrZoriginal_fm_shapeZkirrr !convert_dense_weights_data_formats       $rZcCs$t|ddsdS|jdko"|jdkS)N_keras_api_namesF)zkeras.layers.Layer)rDr[Z_keras_api_names_v1)rrrr is_builtin_layer8s  r\cs*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&|}|dkr"||<}|S)N)get)itemoutput)cachefrr wrappeds z$cached_per_instance..wrapped)weakrefWeakKeyDictionary functoolswrapsr`)rarbr)r`rar cached_per_instanceBsRrgccst}|ddd}xl|r|}t||kr0q|t|t|drZt|tsZ|Vqt|ddphg}||dddqWdS)z4Filter out empty Layer-like containers and uniquify.Nr-Z _is_layerrN) setpopraddr rtyperDextend)Z layer_listexistingZto_visitobjZ sub_layersrrr filter_empty_layer_containerss ro)NN)FF)NNN)rT)__doc__rercnumpyr#Ztensorflow.python.utilrZ tensorflow.python.util.tf_exportrrrr*rSrZr\rgrorrrr s    *  + % _