o b¦µippã@sÆddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z dd l m Z dd l m Z dd lmZdd lmZe d ƒGdd„de eƒƒZe dƒGdd„deƒƒZdS)é)Ú activations)Úbackend)Ú constraints)Ú initializers)Úops)Ú regularizers)Útree)Ú keras_export)Ú InputSpec)ÚLayer)ÚDropoutRNNCell)ÚRNNzkeras.layers.GRUCellcsneZdZdZ              d‡fd d „ Z‡fd d „Zddd„Z‡fdd„Zddd„Z‡Z S)ÚGRUCellaà Cell class for the GRU layer. This class processes one step within the whole time sequence input, whereas `keras.layer.GRU` processes the whole sequence. Args: units: Positive integer, dimensionality of the output space. activation: Activation function to use. Default: hyperbolic tangent (`tanh`). If you pass None, no activation is applied (ie. "linear" activation: `a(x) = x`). recurrent_activation: Activation function to use for the recurrent step. Default: sigmoid (`sigmoid`). If you pass `None`, no activation is applied (ie. "linear" activation: `a(x) = x`). use_bias: Boolean, (default `True`), whether the layer should use a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix, used for the linear transformation of the inputs. Default: `"glorot_uniform"`. recurrent_initializer: Initializer for the `recurrent_kernel` weights matrix, used for the linear transformation of the recurrent state. Default: `"orthogonal"`. bias_initializer: Initializer for the bias vector. Default: `"zeros"`. kernel_regularizer: Regularizer function applied to the `kernel` weights matrix. Default: `None`. recurrent_regularizer: Regularizer function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_regularizer: Regularizer function applied to the bias vector. Default: `None`. kernel_constraint: Constraint function applied to the `kernel` weights matrix. Default: `None`. recurrent_constraint: Constraint function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_constraint: Constraint function applied to the bias vector. Default: `None`. dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the inputs. Default: 0. recurrent_dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the recurrent state. Default: 0. reset_after: GRU convention (whether to apply reset gate after or before matrix multiplication). False = "before", True = "after" (default and cuDNN compatible). seed: Random seed for dropout. Call arguments: inputs: A 2D tensor, with shape `(batch, features)`. states: A 2D tensor with shape `(batch, units)`, which is the state from the previous time step. training: Python boolean indicating whether the layer should behave in training mode or in inference mode. Only relevant when `dropout` or `recurrent_dropout` is used. Example: >>> inputs = np.random.random((32, 10, 8)) >>> rnn = keras.layers.RNN(keras.layers.GRUCell(4)) >>> output = rnn(inputs) >>> output.shape (32, 4) >>> rnn = keras.layers.RNN( ... keras.layers.GRUCell(4), ... return_sequences=True, ... return_state=True) >>> whole_sequence_output, final_state = rnn(inputs) >>> whole_sequence_output.shape (32, 10, 4) >>> final_state.shape (32, 4) ÚtanhÚsigmoidTÚglorot_uniformÚ orthogonalÚzerosNçc s@|dkr td|›dƒ‚| dd¡}tƒjd i|¤Ž||_||_t |¡|_t |¡|_ ||_ t  |¡|_ t  |¡|_ t  |¡|_t |¡|_t | ¡|_t | ¡|_t | ¡|_t | ¡|_t | ¡|_tdtd|ƒƒ|_tdtd|ƒƒ|_|jdkr€d|_|jdkrˆd |_||_tjj|d |_ ||_!|j|_"|j|_#dS) NrzQReceived an invalid value for argument `units`, expected a positive integer, got Ú.Úimplementationéçð?réé)Úseed©)$Ú ValueErrorÚpopÚsuperÚ__init__rÚunitsrÚgetÚ activationÚrecurrent_activationÚuse_biasrÚkernel_initializerÚrecurrent_initializerÚbias_initializerrÚkernel_regularizerÚrecurrent_regularizerÚbias_regularizerrÚkernel_constraintÚrecurrent_constraintÚbias_constraintÚminÚmaxÚdropoutÚrecurrent_dropoutÚdropout_mask_countrrÚrandomÚ SeedGeneratorÚseed_generatorÚ reset_afterÚ state_sizeÚ output_size)Úselfr!r#r$r%r&r'r(r)r*r+r,r-r.r1r2r7rÚkwargsr©Ú __class__rúL/home/ubuntu/.local/lib/python3.10/site-packages/keras/src/layers/rnn/gru.pyr VsBÿÿ               zGRUCell.__init__cs´tƒ |¡|d}|j||jdfd|j|j|jd|_|j|j|jdfd|j|j |j d|_ |j rU|j s>d|jf}ndd|jf}|j|d|j|j|jd|_dSd|_dS)NéÿÿÿÿrÚkernel)ÚshapeÚnameÚ initializerÚ regularizerÚ constraintÚrecurrent_kernelrÚbias)rÚbuildÚ add_weightr!r&r)r,r@r'r*r-rFr%r7r(r+r.rG)r:Ú input_shapeÚ input_dimÚ bias_shaper<rr>rH‘s8  ûû û z GRUCell.buildFcCsŒt |¡r |dn|}|jr,|js|jd}}ndd„tj|j|jjdddDƒ\}}|jdkrx|rYd|j kr?dkrYnn|  |¡}||d}||d} ||d} n|}|} |} t  ||j dd…d|j …f¡} t  | |j dd…|j |j d…f¡} t  | |j dd…|j dd…f¡} |jr·| |d|j …7} | ||j |j d…7} | ||j dd…7} |rÞd|jkrÄdkrÞnn| |¡}||d}||d}||d}n|}|}|}t  ||jdd…d|j …f¡}t  ||jdd…|j |j d…f¡}|jr$|jr$||d|j …7}|||j |j d…7}| | |¡}| | |¡}|jr\t  ||jdd…|j dd…f¡}|jrW|||j dd…7}||}nt  |||jdd…|j dd…f¡}| | |¡}nµ|r“d|j krˆdkr“nn |  |¡}||}t  ||j ¡}|jr¤t ||¡}tj|d d d\} } } |jrÃt  ||j¡}|jrÂ||7}nt  ||jdd…dd|j …f¡}|dd…d|j …f}|dd…|j |j d…f}|dd…|j dd…f}| | |¡}| | |¡}|jr||}nt  |||jdd…d|j d…f¡}| | |¡}||d||}t |¡r@|gn|}||fS) Nrcss|] }tj|ddVqdS)r©ÚaxisN)rÚsqueeze)Ú.0Úerrr>Ú ¿s € ÿ ÿzGRUCell.call..rMrrrrrr?)rÚ is_nestedr%r7rGrÚsplitrArr1Úget_dropout_maskÚmatmulr@r!r2Úget_recurrent_dropout_maskrFr$r#Úadd)r:ÚinputsÚstatesÚtrainingÚh_tm1Ú input_biasÚrecurrent_biasÚdp_maskÚinputs_zÚinputs_rÚinputs_hÚx_zÚx_rÚx_hÚ rec_dp_maskÚh_tm1_zÚh_tm1_rÚh_tm1_hÚ recurrent_zÚ recurrent_rÚzÚrÚ recurrent_hÚhhÚmatrix_xÚ matrix_innerÚhÚ new_staterrr>Úcall¶sªÿ þ     ÿ$   ÿÿÿ  ÿ$  €ÿ  ÿz GRUCell.callcsäid|j“dt |j¡“dt |j¡“d|j“dt |j¡“dt |j¡“dt |j ¡“dt  |j ¡“d t  |j ¡“d t  |j ¡“d t |j¡“d t |j¡“d t |j¡“d|j“d|j“d|j“d|j“}tƒ ¡}i|¥|¥S)Nr!r#r$r%r&r'r(r)r*r+r,r-r.r1r2r7r)r!rÚ serializer#r$r%rr&r'r(rr)r*r+rr,r-r.r1r2r7rrÚ get_config©r:ÚconfigÚ base_configr<rr>rv,sbÿ þÿýúÿù ÿö óÿòÿï ì ëÿê çæåäã  zGRUCell.get_configcCstj||jf|jdgS)N)Údtype)rrr8Ú compute_dtype)r:Ú batch_sizerrr>Úget_initial_stateOsÿzGRUCell.get_initial_state)rrTrrrNNNNNNrrTN©F©N) Ú__name__Ú __module__Ú __qualname__Ú__doc__r rHrtrvr}Ú __classcell__rrr<r>rs.Hî ; % v#rzkeras.layers.GRUcsDeZdZdZ                d6‡fd d „ Zd7‡fdd„ Zd8‡fdd„ Zedd„ƒZedd„ƒZ edd„ƒZ edd„ƒZ edd„ƒZ edd„ƒZ edd„ƒZed d!„ƒZed"d#„ƒZed$d%„ƒZed&d'„ƒZed(d)„ƒZed*d+„ƒZed,d-„ƒZed.d/„ƒZed0d1„ƒZ‡fd2d3„Zed4d5„ƒZ‡ZS)9ÚGRUa©Gated Recurrent Unit - Cho et al. 2014. Based on available runtime hardware and constraints, this layer will choose different implementations (cuDNN-based or backend-native) to maximize the performance. If a GPU is available and all the arguments to the layer meet the requirement of the cuDNN kernel (see below for details), the layer will use a fast cuDNN implementation when using the TensorFlow backend. The requirements to use the cuDNN implementation are: 1. `activation` == `tanh` 2. `recurrent_activation` == `sigmoid` 3. `recurrent_dropout` == 0 4. `unroll` is `False` 5. `use_bias` is `True` 6. `reset_after` is `True` 7. Inputs, if use masking, are strictly right-padded. 8. Eager execution is enabled in the outermost context. There are two variants of the GRU implementation. The default one is based on [v3](https://arxiv.org/abs/1406.1078v3) and has reset gate applied to hidden state before matrix multiplication. The other one is based on [original](https://arxiv.org/abs/1406.1078v1) and has the order reversed. The second variant is compatible with CuDNNGRU (GPU-only) and allows inference on CPU. Thus it has separate biases for `kernel` and `recurrent_kernel`. To use this variant, set `reset_after=True` and `recurrent_activation='sigmoid'`. For example: >>> inputs = np.random.random((32, 10, 8)) >>> gru = keras.layers.GRU(4) >>> output = gru(inputs) >>> output.shape (32, 4) >>> gru = keras.layers.GRU(4, return_sequences=True, return_state=True) >>> whole_sequence_output, final_state = gru(inputs) >>> whole_sequence_output.shape (32, 10, 4) >>> final_state.shape (32, 4) Args: units: Positive integer, dimensionality of the output space. activation: Activation function to use. Default: hyperbolic tangent (`tanh`). If you pass `None`, no activation is applied (ie. "linear" activation: `a(x) = x`). recurrent_activation: Activation function to use for the recurrent step. Default: sigmoid (`sigmoid`). If you pass `None`, no activation is applied (ie. "linear" activation: `a(x) = x`). use_bias: Boolean, (default `True`), whether the layer should use a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix, used for the linear transformation of the inputs. Default: `"glorot_uniform"`. recurrent_initializer: Initializer for the `recurrent_kernel` weights matrix, used for the linear transformation of the recurrent state. Default: `"orthogonal"`. bias_initializer: Initializer for the bias vector. Default: `"zeros"`. kernel_regularizer: Regularizer function applied to the `kernel` weights matrix. Default: `None`. recurrent_regularizer: Regularizer function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_regularizer: Regularizer function applied to the bias vector. Default: `None`. activity_regularizer: Regularizer function applied to the output of the layer (its "activation"). Default: `None`. kernel_constraint: Constraint function applied to the `kernel` weights matrix. Default: `None`. recurrent_constraint: Constraint function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_constraint: Constraint function applied to the bias vector. Default: `None`. dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the inputs. Default: 0. recurrent_dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the recurrent state. Default: 0. seed: Random seed for dropout. return_sequences: Boolean. Whether to return the last output in the output sequence, or the full sequence. Default: `False`. return_state: Boolean. Whether to return the last state in addition to the output. Default: `False`. 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. unroll: Boolean (default: `False`). If `True`, the network will be unrolled, else a symbolic loop will be used. Unrolling can speed-up a RNN, although it tends to be more memory-intensive. Unrolling is only suitable for short sequences. reset_after: GRU convention (whether to apply reset gate after or before matrix multiplication). `False` is `"before"`, `True` is `"after"` (default and cuDNN compatible). use_cudnn: Whether to use a cuDNN-backed implementation. `"auto"` will attempt to use cuDNN when feasible, and will fallback to the default implementation if not. Call arguments: inputs: A 3D tensor, with shape `(batch, timesteps, feature)`. mask: Binary tensor of shape `(samples, timesteps)` indicating whether a given timestep should be masked (optional). An individual `True` entry indicates that the corresponding timestep should be utilized, while a `False` entry indicates that the corresponding timestep should be ignored. Defaults to `None`. 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 only relevant if `dropout` or `recurrent_dropout` is used (optional). Defaults to `None`. initial_state: List of initial state tensors to be passed to the first call of the cell (optional, `None` causes creation of zero-filled initial state tensors). Defaults to `None`. rrTrrrNrFÚautoc s,t|fid|“d|“d|“d|“d|“d|“d|“d| “d | “d | “d | “d |“d |“d|“d|“d| dd¡“d| dd¡“dd“d|“d| dd¡“Ž}tƒj|f|||||| dœ|¤Žtdd|_|dvrptd|›ƒ‚||_t   ¡dkrt j |j |j |j |j|dr’|dvr”d |_dSdSdSdS)!Nr#r$r%r&r'r(r)r*r+r,r-r.r1r2r7rzÚ trainableTrBÚgru_cellrrr)Úreturn_sequencesÚ return_stateÚ go_backwardsÚstatefulÚunrollÚactivity_regularizerr)Úndim)r†TFzlInvalid valid received for argument `use_cudnn`. Expected one of {'auto', True, False}. Received: use_cudnn=Ú tensorflow)r7)Tr†F)rr"rrr r Ú input_specrÚ use_cudnnrÚcudnn_okr#r$rr%Ú supports_jit)r:r!r#r$r%r&r'r(r)r*r+rŽr,r-r.r1r2rr‰rŠr‹rŒrr7r’r;Úcellr<rr>r Ñs˜ÿþýüûúùø ÷ ö õ ô óòñð ï îíì ëÿùø þÿ ûÿ öz GRU.__init__cst |¡r |d}t |¡r|d}|jdvr{|js{zW|rD|jrD|j |dd…ddd…f¡}tj|dd}t  |t  |¡¡}||}n|}t j ||||jj |jj|jj|jj|jj|j|j|j|jjd }t   ¡dkrod|_|WStyzYnw|jdur„td ƒ‚tƒj||||d S) Nr)r†TrrM) r@rFrGr#r$r‰r‹rr7rFTz©use_cudnn=True was specified, but cuDNN is not supported for this layer configuration with this backend. Pass use_cudnn='auto' to fallback to a non-cuDNN implementation.)Úmaskr[)rrSr’r2r1r•rUrÚ expand_dimsÚ broadcast_torArÚgrur@rFrGr#r$r‰r‹rr7r”ÚNotImplementedErrorrrÚ inner_loop)r:Ú sequencesÚ initial_stater–r[r_Ú dp_sequencesÚoutr<rr>r›#sT     ÿ ô  ÿ ÿÿzGRU.inner_loopcstƒj||||dS)N)r–r[r)rrt)r:rœrr–r[r<rr>rtXsÿzGRU.callcCó|jjSr)r•r!©r:rrr>r!]óz GRU.unitscCr r)r•r#r¡rrr>r#ar¢zGRU.activationcCr r)r•r$r¡rrr>r$er¢zGRU.recurrent_activationcCr r)r•r%r¡rrr>r%ir¢z GRU.use_biascCr r)r•r&r¡rrr>r&mr¢zGRU.kernel_initializercCr r)r•r'r¡rrr>r'qr¢zGRU.recurrent_initializercCr r)r•r(r¡rrr>r(ur¢zGRU.bias_initializercCr r)r•r)r¡rrr>r)yr¢zGRU.kernel_regularizercCr r)r•r*r¡rrr>r*}r¢zGRU.recurrent_regularizercCr r)r•r+r¡rrr>r+r¢zGRU.bias_regularizercCr r)r•r,r¡rrr>r,…r¢zGRU.kernel_constraintcCr r)r•r-r¡rrr>r-‰r¢zGRU.recurrent_constraintcCr r)r•r.r¡rrr>r.r¢zGRU.bias_constraintcCr r)r•r1r¡rrr>r1‘r¢z GRU.dropoutcCr r)r•r2r¡rrr>r2•r¢zGRU.recurrent_dropoutcCr r)r•r7r¡rrr>r7™r¢zGRU.reset_aftercsüid|j“dt |j¡“dt |j¡“d|j“dt |j¡“dt |j¡“dt |j ¡“dt  |j ¡“d t  |j ¡“d t  |j ¡“d t  |j¡“d t |j¡“d t |j¡“dt |j¡“d|j“d|j“d|j“d|jji¥}tƒ ¡}|d=i|¥|¥S)Nr!r#r$r%r&r'r(r)r*r+rŽr,r-r.r1r2r7rr•)r!rrur#r$r%rr&r'r(rr)r*r+rŽrr,r-r.r1r2r7r•rrrvrwr<rr>rvslÿ þÿýúÿù ÿö óÿòÿï ìÿë èÿç äãâá à " zGRU.get_configcCs|di|¤ŽS)Nrr)Úclsrxrrr>Ú from_configÄszGRU.from_config)rrTrrrNNNNNNNrrNFFFFFTr†r~)NNF)r€rr‚rƒr r›rtÚpropertyr!r#r$r%r&r'r(r)r*r+r,r-r.r1r2r7rvÚ classmethodr¤r„rrr<r>r…Us~}çR5                 'r…N)Ú keras.srcrrrrrrrÚkeras.src.api_exportr Úkeras.src.layers.input_specr Úkeras.src.layers.layerr Ú%keras.src.layers.rnn.dropout_rnn_cellr Úkeras.src.layers.rnn.rnnr rr…rrrr>Ús$           G