o i eVH@sdZddlZddlmmZddlmZddl m Z ddl m Z ddl mZddlmZddlmZdd lmZGd d d eZdS) z.Base class for convolutional-recurrent layers.N)backend) base_layer InputSpec)RNN) conv_utils) generic_utils)tf_utilscsleZdZdZ     dfdd ZejddZejddZd d Z dd d Z dddZ Z S)ConvRNNa)N-Dimensional Base class for convolutional-recurrent layers. Args: rank: Integer, rank of the convolution, e.g. "2" for 2D convolutions. cell: A RNN cell instance. A RNN cell is a class that has: - a `call(input_at_t, states_at_t)` method, returning `(output_at_t, states_at_t_plus_1)`. The call method of the cell can also take the optional argument `constants`, see section "Note on passing external constants" below. - a `state_size` attribute. This can be a single integer (single state) in which case it is the number of channels of the recurrent state (which should be the same as the number of channels of the cell output). This can also be a list/tuple of integers (one size per state). In this case, the first entry (`state_size[0]`) should be the same as the size of the cell output. return_sequences: Boolean. Whether to return the last output. in the output sequence, or the full sequence. return_state: Boolean. Whether to return the last state in addition to the output. go_backwards: Boolean (default False). If True, process the input sequence backwards and return the reversed sequence. stateful: Boolean (default False). If True, the last state for each sample at index i in a batch will be used as initial state for the sample of index i in the following batch. input_shape: Use this argument to specify the shape of the input when this layer is the first one in a model. Call arguments: inputs: A (2 + `rank`)D tensor. mask: Binary tensor of shape `(samples, timesteps)` indicating whether a given timestep should be masked. training: Python boolean indicating whether the layer should behave in training mode or in inference mode. This argument is passed to the cell when calling it. This is for use with cells that use dropout. initial_state: List of initial state tensors to be passed to the first call of the cell. constants: List of constant tensors to be passed to the cell at each timestep. Input shape: (3 + `rank`)D tensor with shape: `(samples, timesteps, channels, img_dimensions...)` if data_format='channels_first' or shape: `(samples, timesteps, img_dimensions..., channels)` if data_format='channels_last'. Output shape: - If `return_state`: a list of tensors. The first tensor is the output. The remaining tensors are the last states, each (2 + `rank`)D tensor with shape: `(samples, filters, new_img_dimensions...)` if data_format='channels_first' or shape: `(samples, new_img_dimensions..., filters)` if data_format='channels_last'. img_dimension values might have changed due to padding. - If `return_sequences`: (3 + `rank`)D tensor with shape: `(samples, timesteps, filters, new_img_dimensions...)` if data_format='channels_first' or shape: `(samples, timesteps, new_img_dimensions..., filters)` if data_format='channels_last'. - Else, (2 + `rank`)D tensor with shape: `(samples, filters, new_img_dimensions...)` if data_format='channels_first' or shape: `(samples, new_img_dimensions..., filters)` if data_format='channels_last'. Masking: This layer supports masking for input data with a variable number of timesteps. Note on using statefulness in RNNs: You can set RNN layers to be 'stateful', which means that the states computed for the samples in one batch will be reused as initial states for the samples in the next batch. This assumes a one-to-one mapping between samples in different successive batches. To enable statefulness: - Specify `stateful=True` in the layer constructor. - Specify a fixed batch size for your model, by passing - If sequential model: `batch_input_shape=(...)` to the first layer in your model. - If functional model with 1 or more Input layers: `batch_shape=(...)` to all the first layers in your model. This is the expected shape of your inputs *including the batch size*. It should be a tuple of integers, e.g. `(32, 10, 100, 100, 32)`. for rank 2 convolution Note that the image dimensions should be specified too. - Specify `shuffle=False` when calling fit(). To reset the states of your model, call `.reset_states()` on either a specific layer, or on your entire model. Note on specifying the initial state of RNNs: You can specify the initial state of RNN layers symbolically by calling them with the keyword argument `initial_state`. The value of `initial_state` should be a tensor or list of tensors representing the initial state of the RNN layer. You can specify the initial state of RNN layers numerically by calling `reset_states` with the keyword argument `states`. The value of `states` should be a numpy array or list of numpy arrays representing the initial state of the RNN layer. Note on passing external constants to RNNs: You can pass "external" constants to the cell using the `constants` keyword argument of `RNN.__call__` (as well as `RNN.call`) method. This requires that the `cell.call` method accepts the same keyword argument `constants`. Such constants can be used to condition the cell transformation on additional static inputs (not changing over time), a.k.a. an attention mechanism. Fc  st|r td|t|ttfrtd|tj||||||fi|||_t|ddg|_d|_ d|_ dS)NzDUnrolling is not possible with convolutional RNNs. Received: unroll=zIt is not possible at the moment tostack convolutional cells. Only pass a single cell instance as the `cell` argument. Received: cell=)ndim) TypeError isinstancelisttuplesuper__init__rankr input_specstates_num_constants) selfrcellreturn_sequences return_state go_backwardsstatefulunrollkwargs __class__Q/var/www/myenv/lib/python3.10/site-packages/keras/src/layers/rnn/base_conv_rnn.pyr|s4   zConvRNN.__init__cs.ttr d|jjdkrddn jdkr#ddtfddttDjdkrEddjf}njdkrVddjf}|jse|dd |dd}|j r|g}jdkr|fd dtdD7}|Sjdkr|fd dtdD7}|S) Nrchannels_firstr channels_lastc s8g|]}tj|j|jj|j|dqS))paddingstridedilation)rconv_output_length kernel_sizer'strides dilation_rate).0idx)rimg_dimsr!r" sz0ConvRNN.compute_output_shape..csg|] }djfqSrfiltersr._r input_shape norm_img_dimsr!r"r1cs"g|] }dfjfqSr3r4r6r8r!r"r1s) rrr data_formatrrangelenr5rr)rr9 output_shaper!)rr0r9r:r"compute_output_shapes<          zConvRNN.compute_output_shapecs|jdur||j d}nd}t|tr|d}|jr |dnd}t|df|d|jdd|jd<t|jtj r[|df|dd}|durU|j |g|n|j |t |jj drit|jj }n|jj g}|j dur|jjdkr|dn |jjdkr|jdfd d |j D|krtd d d |j Dd |jj n-tddt|jD|jjdkrÇfdd |D|_ n|jjdkrӇfdd |D|_ |jr|d|_dS)Nrr%r shape__len__r#r2r$csg|]}|jqSr!rAr.spec)ch_dimr!r"r1sz!ConvRNN.build..zcAn `initial_state` was passed that is not compatible with `cell.state_size`. Received state shapes cSsg|]}|jqSr!rArDr!r!r"r1sz. However `cell.state_size` is css|]}dVqdSNr!r6r!r!r" sz ConvRNN.build..csg|] }td|fdqS)NrArr.dimr0r!r"r1r;cs g|] }td|fdqS)rGrArrIrKr!r"r1sT)rrrrrrrrrLayerbuildhasattr state_size state_specr< ValueErrorrr= reset_statesbuilt)rr9constants_shape batch_sizestep_input_shaperOr!)rFr0r"rMsV              z ConvRNN.buildcs~t|tjddt|jj}|jj|d<|jjt t |j |jj dt |jjdr<fdd|jjDSgS)Nr2)axisr&)r'rCcsg|]}qSr!r!r6 initial_stater!r"r1sz-ConvRNN.get_initial_state..)r zeros_likesumrr kernel_shaper5 input_convtfzerosrdtyper'rNrO)rinputsrBr!rXr"get_initial_state s   zConvRNN.get_initial_stateNc s$|||\}}}t|tr|d}t|d}itjjdr(|d<|rEtjjds=t djd|fdd}nfd d}tj ||||j ||j d \}} } j rqd d tj| D} | j rw| } n|} jrt| ttfs| g} nt| } | g| S| S) Nrr2training constantsz RNN cell z1 does not support constants. Received: constants=cs:|j d}|dj }jj||fd|iS)Nrd)rrcall)rarrdrrr!r"step;szConvRNN.call..stepcsjj||fiSrG)rre)rarrfr!r"rgDs)rdrmask input_lengthreturn_all_outputscSsg|] \}}t||qSr!)rupdate)r. self_statestater!r!r"r1Rs z ConvRNN.call..)_process_inputsrrr int_shaperhas_argrrerQrnnrrrzipr add_updaterr) rrarhrcrYrd timestepsrg last_outputoutputsrupdatesoutputr!rfr"resT         z ConvRNN.callc sjstdjdj}|jrdjr)dddddvr1tdfddj ddurat j j drTfd d j j D_ dSt j j g_ dS|durt j j drtj j j D]\}}t |t|qtdSt j dtj j dSt|ttfs|g}t|tj krtd jd tj d t|d|tt|j D]6\}\}}t j j dr݈j j |}nj j }|j|krtdjd|d|jt ||qdS)NzLayer must be stateful.rr2r%aIf a RNN is stateful, it needs to know its batch size. Specify the batch size of your input tensors: - If using a Sequential model, specify the batch size by passing a `batch_input_shape` argument to your first layer. - If using the functional API, specify the time dimension by passing a `batch_shape` argument to your Input layer. The same thing goes for the number of rows and columns.csXt}jjdkr||d<t|Sjjdkr#||jd<t|Stdjj)Nr#r2r$z`Cell data format must be one of {"channels_first", "channels_last"}. Received: cell.data_format=)rrr<rKeyErrorr) nb_channelsresult)r state_shaper!r"get_tuple_shapes  z-ConvRNN.reset_states..get_tuple_shaperCcsg|] }t|qSr!)rr_rI)r}r!r"r1s z(ConvRNN.reset_states..zLayer z expects z states, but it received z state values. States received: z)State {index} is incompatible with layer z: expected shape=z, found shape=)rAttributeErrorrrBr@rr concatenaterQrrNrrOrr_rr set_valuenprrrr>name enumerate)rrr9rmrJindexvaluer!)r}rr|r"rResn     zConvRNN.reset_states)FFFFF)NNNNrG) __name__ __module__ __qualname____doc__rr shape_type_conversionr@rMrbrerR __classcell__r!r!rr"r s&a& - ; Gr )rnumpyrtensorflow.compat.v2compatv2r^ keras.srcrkeras.src.enginerkeras.src.engine.input_specrkeras.src.layers.rnn.base_rnnrkeras.src.utilsrrr r r!r!r!r"s