Xc@`s,ddlmZddlmZddlmZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZdd lmZyddlZWnek r)eZnXd efdYZ defdYZ!defdYZ"de"fdYZ#eeeej$e%edZ&de"fdYZ'eedZ(dZ)dZ*dZ+dZ,dZ-dZ.dZ/eed Z0d!Z1d"Z2dS(#i(tprint_function(tabsolute_import(tdivisionN(tzipi(tbackend(t initializers(task_to_proceed_with_overwrite(t print_summary(t conv_utils(t interfacest InputSpeccB`s)eZdZdddddddZRS(sSpecifies the ndim, dtype and shape of every input to a layer. Every layer should expose (if appropriate) an `input_spec` attribute: a list of instances of InputSpec (one per input tensor). A None entry in a shape is compatible with any dimension, a None shape is compatible with any shape. # Arguments dtype: Expected datatype of the input. shape: Shape tuple, expected shape of the input (may include None for unchecked axes). ndim: Integer, expected rank of the input. max_ndim: Integer, maximum rank of the input. min_ndim: Integer, minimum rank of the input. axes: Dictionary mapping integer axes to a specific dimension value. cC`s^||_||_|dk r0t||_n ||_||_||_|pTi|_dS(N(tdtypetshapetNonetlentndimtmax_ndimtmin_ndimtaxes(tselfR R RRRR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt__init__1s      N(t__name__t __module__t__doc__R R(((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR stNodecB`s#eZdZddZdZRS(srA `Node` describes the connectivity between two layers. Each time a layer is connected to some new input, a node is added to `layer.inbound_nodes`. Each time the output of a layer is used by another layer, a node is added to `layer.outbound_nodes`. # Arguments outbound_layer: the layer that takes `input_tensors` and turns them into `output_tensors` (the node gets created when the `call` method of the layer was called). inbound_layers: a list of layers, the same length as `input_tensors`, the layers from where `input_tensors` originate. node_indices: a list of integers, the same length as `inbound_layers`. `node_indices[i]` is the origin node of `input_tensors[i]` (necessary since each inbound layer might have several nodes, e.g. if the layer is being shared with a different data stream). tensor_indices: a list of integers, the same length as `inbound_layers`. `tensor_indices[i]` is the index of `input_tensors[i]` within the output of the inbound layer (necessary since each inbound layer might have multiple tensor outputs, with each one being independently manipulable). input_tensors: list of input tensors. output_tensors: list of output tensors. input_masks: list of input masks (a mask can be a tensor, or None). output_masks: list of output masks (a mask can be a tensor, or None). input_shapes: list of input shape tuples. output_shapes: list of output shape tuples. arguments: dictionary of keyword arguments that were passed to the `call` method of the layer at the call that created the node. `node_indices` and `tensor_indices` are basically fine-grained coordinates describing the origin of the `input_tensors`, verifying the following: `input_tensors[i] == inbound_layers[i].inbound_nodes[node_indices[i]].output_tensors[tensor_indices[i]]` A node from layer A to layer B is added to: A.outbound_nodes B.inbound_nodes c C`s||_||_||_||_||_||_||_||_| |_| |_ | |_ x-|D]%} | dk rj| j j |qjqjW|jj |dS(N(toutbound_layertinbound_layerst node_indicesttensor_indicest input_tensorstoutput_tensorst input_maskst output_maskst input_shapest output_shapest argumentsR toutbound_nodestappendt inbound_nodes( RRRRRRRRR R!R"R#tlayer((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRos             cC`s{g}x7|jD],}|r/|j|jq|jdqWi|jrX|jjndd6|d6|jd6|jd6S(NRRRR(RR%tnameR RRR(Rt inbound_namesR'((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt get_configs N(RRRR RR*(((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRBs+ 2tLayercB`seZdZdZedZejdZedZejdZedZejdZd'e d'd'dZ d Z d Z d Zd'd Zd Zd'dZdZdZdZdZdZdZdZdZedZedZedZedZedZedZd'dZ d'dZ!dZ"d Z#ed!Z$d"Z%d#Z&d$Z'e(d%Z)d&Z*RS((s Abstract base layer class. # Properties name: String, must be unique within a model. input_spec: List of InputSpec class instances each entry describes one required input: - ndim - dtype A layer with `n` input tensors must have an `input_spec` of length `n`. trainable: Boolean, whether the layer weights will be updated during training. uses_learning_phase: Whether any operation of the layer uses `K.in_training_phase()` or `K.in_test_phase()`. input_shape: Shape tuple. Provided for convenience, but note that there may be cases in which this attribute is ill-defined (e.g. a shared layer with multiple input shapes), in which case requesting `input_shape` will raise an Exception. Prefer using `layer.get_input_shape_for(input_shape)`, or `layer.get_input_shape_at(node_index)`. output_shape: Shape tuple. See above. inbound_nodes: List of nodes. outbound_nodes: List of nodes. input, output: Input/output tensor(s). Note that if the layer is used more than once (shared layer), this is ill-defined and will raise an exception. In such cases, use `layer.get_input_at(node_index)`. input_mask, output_mask: Same as above, for masks. trainable_weights: List of variables. non_trainable_weights: List of variables. weights: The concatenation of the lists trainable_weights and non_trainable_weights (in this order). constraints: Dict mapping weights to constraints. # Methods call(x, mask=None): Where the layer's logic lives. __call__(x, mask=None): Wrapper around the layer logic (`call`). If x is a Keras tensor: - Connect current layer with last layer from tensor: `self._add_inbound_node(last_layer)` - Add layer to tensor history If layer is not built: - Build from x._keras_shape get_weights() set_weights(weights) get_config() count_params() compute_output_shape(input_shape) compute_mask(x, mask) get_input_at(node_index) get_output_at(node_index) get_input_shape_at(node_index) get_output_shape_at(node_index) get_input_mask_at(node_index) get_output_mask_at(node_index) # Class Methods from_config(config) # Internal methods: build(input_shape) _add_inbound_node(layer, index=0) assert_input_compatibility() c K`sd|_t|_g|_g|_i|_t|_g|_g|_ ddddddddh}x,|D]$}||krmt d |qmqmW|j d}|s|j j }t|d ttj|}n||_|j dt|_d|ksd|krd|kr1t|d}nEd|krvd|krV|d}nd}|ft|d}n||_|j d}|dkr|j d}n|dkrtj}n||_nd|kr|d|_n d|_dS( Nt input_shapetbatch_input_shapet batch_sizeR R(t trainabletweightst input_dtypes Keyword argument not understood:t_(R t input_spectFalsetsupports_maskingt_trainable_weightst_non_trainable_weightst _constraintstbuiltR&R$t TypeErrortgett __class__Rt_to_snake_casetstrtKtget_uidR(tTrueR/ttupleR-tfloatxR t_initial_weights( Rtkwargstallowed_kwargstkwargR(tprefixR-R.R ((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRsV            &          cC`s|jS(N(R8(R((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt constraints7scC`s ||_dS(N(R8(RRI((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRI;scC`s't|dt}|r|jSgSdS(NR/(tgetattrRAR6(RR/((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyttrainable_weights?scC`s ||_dS(N(R6(RR0((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRKGscC`s1t|dt}|s&|j|jS|jSdS(NR/(RJRAR6R7(RR/((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytnon_trainable_weightsKscC`s ||_dS(N(R7(RR0((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRLSscC`stj|}tj||dtjd|}|dk rX|j||n|dk rt||j|tinputt enumerateRR RR?RRR Rt int_shapeR:titemstintR ( RtinputsR3t input_indextxtspecRtx_shapetaxistvaluetspec_dimtdim((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytassert_input_compatibilitywsr   6( ----    (U    -cC`s|S(sThis is where the layer's logic lives. # Arguments inputs: input tensor, or list/tuple of input tensors. # Returns A tensor or list/tuple of tensors. ((RR]((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytcalls cK`stj|j|js|j|g}xut|D]g}t|drd|j|jq<ttdr|jtj |q<t d|jdq<Wt |dkr|j |dn |j |t |_|jdk r|j|jqn|j|t|}t|sgdtj|jjkrgd|krd||dssLayer s9 does not support masking, but was passed an input_mask: N(R5R RTRURR:R(R>(RR]Ri((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRus  cC`s t|_dS(sCreates the layer weights. Must be implemented on all layers that have weights. # Arguments input_shape: Keras tensor (future input to layer) or list/tuple of Keras tensors to reference for weight shape computations. N(RAR9(RR,((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRms cC`s|js td|dnt|j|ksqtd|dt|dtt|jdnt|j||}t|dkr|dS|Sd S( sRetrieves an attribute (e.g. input_tensors) from a node. This is used to implement the methods: - get_input_shape_at - get_output_shape_at - get_input_at etc... # Arguments node_index: Integer index of the node from which to retrieve the attribute. attr: Exact node attribute name. attr_name: Human-readable attribute name, for error messages. # Returns The layer's attribute `attr` at the node of index `node_index`. # Raises RuntimeError: If the layer has no inbound nodes. ValueError: If the index is does not match any node. s8The layer has never been called and thus has no defined t.s Asked to get s at node s, but the layer has only s inbound nodes.iiN(R&t RuntimeErrorRRWR>RJ(RRtattrt attr_nametvalues((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt_get_node_attribute_at_indexs 9cC`s|j|ddS(sRetrieves the input shape(s) of a layer at a given node. # Arguments node_index: Integer, index of the node from which to retrieve the attribute. E.g. `node_index=0` will correspond to the first time the layer was called. # Returns A shape tuple (or list of shape tuples if the layer has multiple inputs). R!s input shape(R(RR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytget_input_shape_ats cC`s|j|ddS(sRetrieves the output shape(s) of a layer at a given node. # Arguments node_index: Integer, index of the node from which to retrieve the attribute. E.g. `node_index=0` will correspond to the first time the layer was called. # Returns A shape tuple (or list of shape tuples if the layer has multiple outputs). R"s output shape(R(RR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytget_output_shape_ats cC`s|j|ddS(sRetrieves the input tensor(s) of a layer at a given node. # Arguments node_index: Integer, index of the node from which to retrieve the attribute. E.g. `node_index=0` will correspond to the first time the layer was called. # Returns A tensor (or list of tensors if the layer has multiple inputs). RRX(R(RR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt get_input_at s cC`s|j|ddS(sRetrieves the output tensor(s) of a layer at a given node. # Arguments node_index: Integer, index of the node from which to retrieve the attribute. E.g. `node_index=0` will correspond to the first time the layer was called. # Returns A tensor (or list of tensors if the layer has multiple outputs). RR{(R(RR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt get_output_ats cC`s|j|ddS(sRetrieves the input mask tensor(s) of a layer at a given node. # Arguments node_index: Integer, index of the node from which to retrieve the attribute. E.g. `node_index=0` will correspond to the first time the layer was called. # Returns A mask tensor (or list of tensors if the layer has multiple inputs). Rs input mask(R(RR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytget_input_mask_at)s cC`s|j|ddS(sRetrieves the output mask tensor(s) of a layer at a given node. # Arguments node_index: Integer, index of the node from which to retrieve the attribute. E.g. `node_index=0` will correspond to the first time the layer was called. # Returns A mask tensor (or list of tensors if the layer has multiple outputs). R s output mask(R(RR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytget_output_mask_at:s cC`set|jdkr/td|jdn#|jsRtd|jdn|jdddS(siRetrieves the input tensor(s) of a layer. Only applicable if the layer has exactly one inbound node, i.e. if it is connected to one incoming layer. # Returns Input tensor or list of input tensors. # Raises AttributeError: if the layer is connected to more than one incoming layers. isLayer sv has multiple inbound nodes, hence the notion of "layer input" is ill-defined. Use `get_input_at(node_index)` instead.s& is not connected, no input to return.iRRX(RR&tAttributeErrorR(R(R((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRXKs      cC`se|js#td|jdnt|jdkrRtd|jdn|jdddS(slRetrieves the output tensor(s) of a layer. Only applicable if the layer has exactly one inbound node, i.e. if it is connected to one incoming layer. # Returns Output tensor or list of output tensors. # Raises AttributeError: if the layer is connected to more than one incoming layers. sLayer s has no inbound nodes.isx has multiple inbound nodes, hence the notion of "layer output" is ill-defined. Use `get_output_at(node_index)` instead.iRR{(R&RR(RR(R((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR{es      cC`sFt|jdkr3td|jddn|jdddS(sRetrieves the input mask tensor(s) of a layer. Only applicable if the layer has exactly one inbound node, i.e. if it is connected to one incoming layer. # Returns Input mask tensor (potentially None) or list of input mask tensors. # Raises AttributeError: if the layer is connected to more than one incoming layers. isLayer s has multiple inbound nodes, schence the notion of "layer input mask" is ill-defined. Use `get_input_mask_at(node_index)` instead.iRs input mask(RR&RR(R(R((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt input_masks   cC`sBt|jdkr/td|jdn|jdddS(sRetrieves the output mask tensor(s) of a layer. Only applicable if the layer has exactly one inbound node, i.e. if it is connected to one incoming layer. # Returns Output mask tensor (potentially None) or list of output mask tensors. # Raises AttributeError: if the layer is connected to more than one incoming layers. isLayer s has multiple inbound nodes, hence the notion of "layer output mask" is ill-defined. Use `get_output_mask_at(node_index)` instead.iR s output mask(RR&RR(R(R((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR|s    cC`s|jstdntg|jD]}t|j^q%}t|dkr|jdj}t|dkr|dS|Sntdt|jddS(sRetrieves the input shape tuple(s) of a layer. Only applicable if the layer has exactly one inbound node, i.e. if it is connected to one incoming layer. # Returns Input shape tuple (or list of input shape tuples, one tuple per input tensor). # Raises AttributeError: if the layer is connected to more than one incoming layers. sDThe layer has never been called and thus has no defined input shape.iis The layer "s has multiple inbound nodes, with different input shapes. Hence the notion of "input shape" is ill-defined for the layer. Use `get_input_shape_at(node_index)` instead.N(R&RtsetR>R!RR((Rtnodetall_input_shapesR!((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR,s +cC`s|jstdntg|jD]}t|j^q%}t|dkr|jdj}t|dkr|dS|Sntdt|jddS(sRetrieves the output shape tuple(s) of a layer. Only applicable if the layer has one inbound node, or if all inbound nodes have the same output shape. # Returns Output shape tuple (or list of input shape tuples, one tuple per output tensor). # Raises AttributeError: if the layer is connected to more than one incoming layers. sEThe layer has never been called and thus has no defined output shape.iis The layer "s has multiple inbound nodes, with different output shapes. Hence the notion of "output shape" is ill-defined for the layer. Use `get_output_shape_at(node_index)` instead.N(R&RRR>R"RR((RRtall_output_shapesR"((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR~s +cC`s|dkrdSt|}t|ds7g|_ny|j|7_Wntk r]nXt|dsyi|_n|dk rt|}nd}||jkrg|j|R?tbatch_get_valueRR R%tbatch_set_value(RR0tparamstweight_value_tuplest param_valuestpvtptw((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRnas Q"*cC`s|j}tj|S(s{Returns the current weights of the layer. # Returns Weights values as a list of numpy arrays. (R0R?R(RR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt get_weightss cC`s\i|jd6|jd6}t|dr9|j|dR?R@tsuperRRR4R/RAR9RRWR RZR:RBRCR R-tis_placeholdert placeholderR(RhRRR( RR,R.R-R t input_tensorRR(RH((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRs\                       cC`s2i|jd6|jd6|jd6|jd6}|S(NR-R RR((R-R RR((RR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR*&s     N(RRRR R4RR*(((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRs Dc C`s| r(|d kr(|s(tdn|rH| rHd t|}ntd|d|d|d|d|}|jdj}t|dkr|dS|Sd S( s`Input()` is used to instantiate a Keras tensor. A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), which we augment with certain attributes that allow us to build a Keras model just by knowing the inputs and outputs of the model. For instance, if a, b and c and Keras tensors, it becomes possible to do: `model = Model(input=[a, b], output=c)` The added Keras attributes are: ._keras_shape: Integer shape tuple propagated via Keras-side shape inference. ._keras_history: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively. # Arguments shape: A shape tuple (integer), not including the batch size. For instance, `shape=(32,)` indicates that the expected input will be batches of 32-dimensional vectors. batch_shape: A shape tuple (integer), including the batch size. For instance, `batch_shape=(10, 32)` indicates that the expected input will be batches of 10 32-dimensional vectors. `batch_shape=(None, 32)` indicates batches of an arbitrary number of 32-dimensional vectors. name: An optional name string for the layer. Should be unique in a model (do not reuse the same name twice). It will be autogenerated if it isn't provided. dtype: The data type expected by the input, as a string (`float32`, `float64`, `int32`...) sparse: A boolean specifying whether the placeholder to be created is sparse. tensor: Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor. # Returns A tensor. # Example ```python # this is a logistic regression in Keras x = Input(shape=(32,)) y = Dense(16, activation='softmax')(x) model = Model(x, y) ``` s}Please provide to Input either a `shape` or a `batch_shape` argument. Note that `shape` does not include the batch dimension.R-R(R RRiiN(N(R tAssertionErrorRBRR&RR(R t batch_shapeR(R Rttensort input_layertoutputs((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytInput.s4    t ContainercB`sgeZdZejedZeedZedZ edZ edZ edZ dZ edZed Zed Zed Zd Zd ZedZedZdZdZedZdZeedZedZedZedZ dZ!dZ"dZ#eedZ$RS(s{A Container is a directed acyclic graph of layers. It is the topological form of a "model". A Model is simply a Container with added training routines. # Properties name inputs outputs input_layers output_layers input_spec (list of class instances) each entry describes one required input: - ndim - dtype trainable (boolean) input_shape output_shape inbound_nodes: list of nodes outbound_nodes: list of nodes trainable_weights (list of variables) non_trainable_weights (list of variables) constraints (list of tuples (weight, constraint)) # Methods summary get_layer get_weights set_weights get_config compute_output_shape # Class Methods from_config c`s |s8|jjj}|dttj|}n||_t|_t |_ t |t t frzt ||_n |g|_t |t t frt ||_n |g|_t|j}t|t|jkrtdt|jng|_g|_g|_g|_g|_g|_g|_i|_i|_i|_x|jD]}t|ds|jj}td|ddt|dn|j\}} } t|j dks|j rc|j d j!rc|jj}t"j#|d |jd |jd t|jqcqcWxM|jD]B}t|ds>|jj}td |dt|q>q>WxS|jD]H}|j\}} } |jj$||jj$| |jj$| qWg} xJ|jD]?}|j\}} } |j | } | j%| } | j$| qWdj&g|jD]}tt'|^q=}|ddj&g| D]}tt'|^qq7}g} xJ|jD]?}|j\}} } |j | } | j%| } | j$| qWt| dkr| d } n| } | |j|Wi}xDj5D]6\}}||krg||g|jD]}|j^qw}xQ|D]I}|j?|dkrt;d|dt|j?|dqqWg|_@g|_ tAd|dgdgdgd |jd!|jd"g|jD] }d^q, d#g|jD] }d^qH d$g|jD]}|j1^qd d%g|jD]}|j1^q t |_BdS(&NR2s`The list of inputs passed to the model is redundant. All inputs should only appear once. Found: RsInput tensors to a t smust be Keras tensors. Found: s (missing Keras metadata).iis inputs must come from a Keras Input layer, they cannot be the output of a previous non-Input layer. Here, a tensor specified as input to "s5" was not an Input tensor, it was generated by layer sn. Note that input tensors are instantiated via `tensor = Input(shape)`. The tensor that caused the issue was: sOutput tensors to a s must be Keras tensors. Found: t,cS`stt|dt|S(Nt-(R>tid(Rtdepth((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytmake_node_marker0sc `s|p t}| s.|dks.|dkrC|j\}}}n|j|}|j|||jdt|}j|j|}|dkr||R;tmaxRRRRRR(Rt seen_nodesRR'RRRtnode_keyt node_depthtpreviously_seen_deptht current_depthRR_t next_nodet node_marker(tbuild_map_of_graphtcontainer_nodest layer_indicest layers_depthsRt nodes_depths(s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR3s8              Rtreversetkeyc`s|S(N((R_(R(s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytss3Graph disconnected: cannot obtain value for tensor s at layer "s>". The following previous layers were accessed without issue: s The name "s " is used s6 times in the model. All layer names should be unique.RRRRRRRR R!R"(CR<RtlowerR>R?R@R(R4R5RAR/RTRURBR]RRRRWt input_layerstinput_layers_node_indicestinput_layers_tensor_indicest output_layerstoutput_layers_node_indicestoutput_layers_tensor_indicestlayerst_output_mask_cachet_output_tensor_cachet_output_shape_cacheRlR:RR&RRRR%R tjoinRRt input_namest output_namest_feed_input_namest _feed_inputst_feed_input_shapesRYRRXRhtinternal_input_shapestinternal_output_shapesR R[tkeystsorttlayers_by_depthRRRRRtnodes_by_depthtcountR$RR9(RR]RR(RHt inputs_setR_tcls_nameR'RRtmasksRRitmask_cache_keyRRRRRt depth_keysRtlayers_for_depthtcomputable_tensorstlayers_with_complete_inputt all_namesR2((RRRRRRs4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRs:                 .   "  16          !""  ':                      cC`s|dk rct|j|krUtdt|dtt|jdqx|j|Sn|sxtdnd}x$|jD]}|j|kr|SqW|std|ndS(sRetrieves a layer based on either its name (unique) or index. Indices are based on order of horizontal graph traversal (bottom-up). # Arguments name: String, name of layer. index: Integer, index of layer. # Returns A layer instance. # Raises ValueError: In case of invalid layer name or index. s%Was asked to retrieve layer at index s but model only has s layers.s+Provide either a layer name or layer index.sNo such layer: N(R RRRWR>R((RR(tindexR'((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt get_layers 1cC`sg}x|jD]}t|drt|jdkrJ||j7}qxbt|jD]Q\}}|jdt|}||jkrZ|j }||j |7}qZqZW||j d7}qqW|S(s5Retrieve the model's updates. Will only include updates that are either inconditional, or conditional on inputs to this model (e.g. will not include updates that depend on tensors that aren't inputs to this model). # Returns A list of update ops. Ris_ib-N( RRlRR&RRYR(R>RRRR (RRR'RRRR]((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRs  cC`sg}x|jD]}t|drt|jdkrJ||j7}qxbt|jD]Q\}}|jdt|}||jkrZ|j }||j |7}qZqZW||j d7}qqWt|dr||j j dg7}n|S(s4Retrieve the model's losses. Will only include losses that are either inconditional, or conditional on inputs to this model (e.g. will not include losses that depend on tensors that aren't inputs to this model). # Returns A list of loss tensors. Ris_ib-RN(RRlRR&RRYR(R>RRRR RR;(RRR'RRRR]((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRs  cC`s#tg|jD]}|j^q S(N(RRR(RR_((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR8scC`s2tg|jD]}t|do(|j^q S(Ntstateful(RRRlR(RR'((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR<scC`sFx?|jD]4}t|dr t|dtr |jq q WdS(Nt reset_statesR(RRlRJR4R (RR'((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR @s!cC`sRg}xE|jD]:}t|dtrt|drJ||j7}qJqqW|S(sReturns the `updates` from all layers that are stateful. This is useful for separating training updates and state updates, e.g. when we need to update a layer's internal state during prediction. # Returns A list of update ops. RR(RRJR4RlR(Rt state_updatesR'((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR Es cC`s}i}xp|jD]e}x\|jjD]K\}}||krg|||krgtdt|n|||(RtconsR'RRc((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRIWscC`s8|js gSg}x|jD]}||j7}qW|S(N(R/RRK(RR0R'((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRKbs  cC`scg}x|jD]}||j7}qW|js_g}x|jD]}||j7}q@W||S|S(N(RRLR/RK(RR0R'RK((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRLks cC`s4g}x|jD]}||j7}qWtj|S(shRetrieves the weights of the model. # Returns A flat list of Numpy arrays. (RR0R?R(RR0R'((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRwscC`sg}xj|jD]_}t|j}|| }x3t|j|D]\}}|j||fqBW||}qWtj|dS(sSets the weights of the model. # Arguments weights: A list of Numpy arrays with shapes and types matching the output of `model.get_weights()`. N(RRR0RR%R?R(RR0ttuplesR't num_paramt layer_weightstswR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRns cC`sg}xt|dgD]k}|jdkr>|jdqt|jtswtd|jdt|jn||j7}qWt |dkr|dS|S(sGets the model's input specs. # Returns A list of `InputSpec` instances (one per input to the model) or a single instance if the model has only one input. RsLayer sV has an input_spec attribute that is not a list. We expect a list. Found input_spec = iiN( RJR3R R%RTRUR:R(R>R(RtspecsR'((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR3scC`st|}|dkr@gtt|D] }d^q+}n t|}djg|D]}tt|^qY}|ddjg|D]}tt|^q7}||jkr|j|S|j||\}}}|SdS(s9Call the model on new inputs. In this case `call` just reapplies all ops in the graph to the new inputs (e.g. build a new computational graph from the provided inputs). A model is callable on non-Keras tensors. # Arguments inputs: A tensor or list of tensors. mask: A mask or list of masks. A mask can be either a tensor or None (no mask). # Returns A tensor if there is a single output, or a list of tensors if there are more than one outputs. RR2N( RVR RRRR>RRtrun_internal_graph(RR]RiR2RR_t cache_keyR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRgs  ( .6 cC`st|}|dkr@gtt|D] }d^q+}n t|}djg|D]}tt|^qY}|ddjg|D]}tt|^q7}||jkr|j|S|j||\}}}|SdS(NRR2( RVR RRRR>RRR(RR]RiR2RR_RR ((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRus  ( .6 cC`st|}t|t|jkr[tdt|dtt|jdndjg|D]}t|^qh}||jkr|j|}t|trt|dkr|dS|Si}xHt t|D]4}|j|}||}|j d} ||| | D]6} | j}||jkrqung}xrt t| jD][}| j|}| j|}| j|}|j d ||f} || }|j|qWt|dkr<|j|d}n|j|}t|}|jj| }x?t t|D]+}|j d ||f} |||| RRRTRURR(RRRRARRRRR%RwR&RRRRRYR(RR,R!R_RR"tlayers_to_output_shapesRR't shape_keyRRtnodesRtjRRRR~toutput_shape_keysR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRwsp 1( !                !c C`s|dkr4gtt|D] }d^q}ni}xBt|j||D]+\}}}||f|tt|}tt||kr|j|tt|qqWt|t| krtj| j_| jru| j}ni}t|dkr|d\}}dtj| jjkrd|kr||dRRURRRRARRRR%R?RkR(R#RqRrRgRsRVRuRRRNRRvRlRwRhRRRJR4RRRRRR( RR]RR2t tensor_mapR_tyRiRRRRR'treference_input_tensorstreference_output_tensorst computed_dataREtcomputed_tensort computed_maskRR tcomputed_tensorstcomputed_maskst layer_inputstshapesRR}R"RR RR!((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR%s (%        $         (+" ""+.  .6     ( cC`si|jd6}i}x|jD]}t|jtrAd}nd}xZt|jD]I\}}|jdt|}||jkrW|||<|d7}qWqWWq Wg}x|jD]}|jj } |j } g} xct|jD]R\}}|jdt|}||jkr|j ryt j |j |j } Wqtk rtjd|jdt|j di} qXni} |jr>g} xtt|jD]r}|j|}|j|}|j|}|jdt|}|j|d}| j|j||| gqW| j| q>qqW|ji|jd6| d6| d 6| d 6qW||d RRR*R#tjsontdumpsR:RRRRRRRR;R%RRRRRRtcopytdeepcopy(RRtnode_conversion_mapR't kept_nodestoriginal_node_indexRRt layer_configstlayer_class_namet layer_configtfiltered_inbound_nodesREt node_dataRRRRtnew_node_indext model_inputst model_outputs((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR*s        #                   c `s-ifd}x|dD]}||q#W|jd}g}g}x^|dD]R}|\}} } |kst|} | j| j} |j| | q]Wx^|dD]R}|\}} } |kst|} | j| j} |j| | qW|d|d|d|S(sInstantiates a Model from its config (output of `get_config()`). # Arguments config: Model config dictionary. custom_objects: Optional dictionary mapping names (strings) to custom classes or functions to be considered during deserialization. # Returns A model instance. # Raises ValueError: In case of improperly formatted config dict. c`sV|d}ddlm}||d}||<|d}x|D]}g}x|D]}|d}|d} |d} t|dkri} n+t|d kr|d} n td |krtd |n|} | j| } |j| j| qZW|rGt|dkr>||d| qN||| qGqGWd S( sDeserialize a layer, then call it on appropriate inputs. # Arguments layer_data: layer config dict. # Raises ValueError: In case of improperly formatted `layer_data` dict. R(i(t deserializetcustom_objectsR&iiiis"Improperly formatted model config.sMissing layer: N(RR5RRWR&R%R(t layer_datat layer_nametdeserialize_layerR'tinbound_nodes_dataR1Rt input_datatinbound_layer_nametinbound_node_indextinbound_tensor_indexRERt inbound_node(tcreated_layersR6(s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt process_layer s4                RR(RRR]R(R;RR&RR%( RRR6RAR7R(RRR8RRR'tlayer_output_tensors((R@R6s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR s(,  cC`s$ddlm}||||dS(sSave the model to a single HDF5 file. The savefile includes: - The model architecture, allowing to re-instantiate the model. - The model weights. - The state of the optimizer, allowing to resume training exactly where you left off. This allows you to save the entirety of the state of a model in a single file. Saved models can be reinstantiated via `keras.models.load_model`. The model returned by `load_model` is a compiled model ready to be used (unless the saved model was never compiled in the first place). # Arguments filepath: String, path to the file to save the weights to. overwrite: Whether to silently overwrite any existing file at the target location, or provide the user with a manual prompt. # Example ```python from keras.models import load_model model.save('my_model.h5') # creates a HDF5 file 'my_model.h5' del model # deletes the existing model # returns a compiled model # identical to the previous one model = load_model('my_model.h5') ``` i(t save_modelN(tmodelsRC(Rtfilepatht overwriteRC((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytsaveY s#cC`stdkrtdn| rMtjj|rMt|}|sMdSntj|d}t||j |j |j dS(srDumps all layer weights to a HDF5 file. The weight file has: - `layer_names` (attribute), a list of strings (ordered names of model layers). - For every layer, a `group` named `layer.name` - For every such layer group, a group attribute `weight_names`, a list of strings (ordered names of weights tensor of the layer). - For every weight in the layer, a dataset storing the weight value, named after the weight tensor. # Arguments filepath: String, path to the file to save the weights to. overwrite: Whether to silently overwrite any existing file at the target location, or provide the user with a manual prompt. # Raises ImportError: If h5py is not available. s`save_weights` requires h5py.NR( th5pyR t ImportErrortostpathtisfileRtFiletsave_weights_to_hdf5_groupRtflushtclose(RRERFtproceedtf((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt save_weights s   cC`stdkrtdntj|dd}d|jkrXd|krX|d}n|rqt||jnt||jt|dr|j ndS(sLoads all layer weights from a HDF5 save file. If `by_name` is False (default) weights are loaded based on the network's topology, meaning the architecture should be the same as when the weights were saved. Note that layers that don't have weights are not taken into account in the topological ordering, so adding or removing layers is fine as long as they don't have weights. If `by_name` is True, weights are loaded into layers only if they share the same name. This is useful for fine-tuning or transfer-learning models where some of the layers have changed. # Arguments filepath: String, path to the weights file to load. by_name: Boolean, whether to load weights by name or by topological order. # Raises ImportError: If h5py is not available. s`load_weights` requires h5py.tmodetrt layer_namest model_weightsRPN( RHR RIRMtattrst$load_weights_from_hdf5_group_by_nameRtload_weights_from_hdf5_groupRlRP(RREtby_nameRR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt load_weights s  cC`sNddlm}|j}i|jjd6|d6|d6tjd6}|S(sUtil hared between different serialization methods. # Returns Model config with Keras version information added. i(t __version__R$Rt keras_versionR(tR]R*R<RR?R(RR^Rt model_config((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt_updated_config s  cK`s+d}|j}tj|d||S(shReturns a JSON string containing the network configuration. To load a network from a JSON save file, use `keras.models.model_from_json(json_string, custom_objects={})`. # Arguments **kwargs: Additional keyword arguments to be passed to `json.dumps()`. # Returns A JSON string. cS`sTt|jtjkr"|jSt|jtjkrA|jStd|dS(NsNot JSON Serializable:(RRtnpRtitemR:(tobj((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyt get_json_type s  tdefault(RaR&R'(RREReR`((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytto_json s cK`stj|j|S(sReturns a yaml string containing the network configuration. To load a network from a yaml save file, use `keras.models.model_from_yaml(yaml_string, custom_objects={})`. `custom_objects` should be a dictionary mapping the names of custom losses / layers / etc to the corresponding functions / classes. # Arguments **kwargs: Additional keyword arguments to be passed to `yaml.dump()`. # Returns A YAML string. (tyamltdumpRa(RRE((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytto_yaml scC`st|d|d|dS(Nt line_lengtht positions(tprint_layer_summary(RRkRl((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytsummary s (%RRRR t legacy_model_constructor_supportR RRRRRRRR R RIRKRLRRnR3RgRuRwRR*RRRARGRSR4R\RaRgRjRn(((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRvs>#9$"       N SS & ! $   c C`st|ds|S|dks%|r:|j\}}}n|jsJ|gS|j|}|jsg|jSg}xtt|jD]l}|j|}|j|}|j|}t |||}x*|D]"}||kr|j |qqWqW|SdS(sReturns the list of input tensors necessary to compute `tensor`. Output will always be a list of tensors (potentially with 1 element). # Arguments 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. RN( RlR RR&RRRRRtget_source_inputsR%( RR'RR2Rtsource_tensorsRR_tprevious_sources((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRp s*         cC`st|tr|S|gS(sNormalizes a list/tensor into a list. If a tensor is passed, we return a list of size 1 containing the tensor. # Arguments x: target object to be normalized. # Returns A list. (RTRU(R_((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRV4 s cC`s>t|}djg|D]}ttt|^qS(Ns, (RVRR>tabsR(t object_listR_((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRE s cC`sLt|ttfs!|g}n|}x|D]}|dk r.tSq.WtS(N(RTRURBR R4RA(titerable_or_elementtiterabletelement((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRpJ s   cC`st|}g}xf|D]^}t|drj|j\}}}|j|}|j|}|j|q|jdqWt|dkr|dS|S(sRetrieves the output mask(s) of the previous node. # Arguments input_tensors: A tensor or list of tensors. # Returns A mask tensor or list of mask tensors. RiiN(RVRlRR&R R%R R(RRR_RRRRRi((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRoU s    cC`sLtjdd|}tjdd|j}|ddkrD|Sd|S(Ns(.)([A-Z][a-z0-9]+)s\1_\2s([a-z])([A-Z])iR2tprivate(tretsubR(R(t intermediatetinsecure((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyR=m s cC`s|t|}g}xI|D]A}y|jtj|Wqtk rY|jdqXqWt|dkrx|dS|S(sCollects the output shape(s) of a list of Keras tensors. # Arguments input_tensors: list of input tensors (or single input tensor). # Returns List of shape tuples (or single tuple), one tuple per input. iiN(RVR%R?RZR:R R(RR#R_((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRtw s   c C`sddlm}g|D]}|jjd^q|jdt create_groupR0RRYRRlR%tcreate_datasetR R ( RRRR^R'tgtsymbolic_weightst weight_valuesRRRtvalR(t param_dset((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRN s*,  (    c C`s|dkrX|jjdkr|dj}|d |jddfks[|d|jkr|d|jkr|d|jddfksttj|dd|dRYRR(RR?R(RRRRRtfiltered_layersR'R0tnRVtfiltered_layer_namesR(RRRtkt weight_nameRR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRZ sN   )  )4 )   S cC`s'd|jkr(|jdjd}nd}d|jkrV|jdjd}nd }g|jdD]}|jd^qj}i}x6|D].}|jr|j|jgj|qqWg}xIt|D];\} } || } g| jdD]}|jd^q} g| D]} | | ^q}x|j| gD]}|j}t ||||}t |t |krt dt | d|jd t t |d d t t |d nx5t t |D]!}|j||||fqWqFWqWtj|d S(sXImplements name-based weight loading. (instead of topological weight loading). Layers that have no matching name are skipped. # Arguments f: A pointer to a HDF5 group. layers: a list of target layers. # Raises ValueError: in case of mismatch between provided layers and weights file. R^R}RRRVRsLayer #s (named "s ") expects s! weight(s), but the saved weightss have s element(s).N(RXRR R(t setdefaultR%RYR;R0RRRWR>RR?R(RRRRRRRVRR'RRR(RRRRRR((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pyRY_ s>)  # )  D  (3t __future__RRRtnumpyRbR&RhRR(RJRyRqt six.movesRR_RR?Rtutils.io_utilsRtutils.layer_utilsRRmtutilsRtlegacyR RHRIR tobjectR RR+RRCR4RRRpRVRRpRoR=RtRNRRZRY(((s4/tmp/pip-build-isqEY4/keras/keras/engine/topology.pytsb          %qa F+      p D