o 2h^p@sddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z dd l m Z dd l m Z dd lmZdd lmZe d Gddde eZe dGdddeZdS)) activations)backend) constraints) initializers)ops) regularizers)tree) keras_export) InputSpec)Layer)DropoutRNNCell)RNNzkeras.layers.GRUCellcsneZdZdZ              dfd d Zfd d ZdddZfddZdddZZ 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) tanhsigmoidTglorot_uniform orthogonalzerosNc s@|dkr td|d|dd}tjd i|||_||_t||_t||_ ||_ t ||_ t ||_ t ||_t||_t| |_t| |_t| |_t| |_t| |_tdtd||_tdtd||_|jdkrd|_|jdkrd |_||_tjj|d |_ ||_!|j|_"|j|_#dS) NrzQReceived an invalid value for argument `units`, expected a positive integer, got .implementation?r)seed)$ ValueErrorpopsuper__init__runitsrget activationrecurrent_activationuse_biasrkernel_initializerrecurrent_initializerbias_initializerrkernel_regularizerrecurrent_regularizerbias_regularizerrkernel_constraintrecurrent_constraintbias_constraintminmaxdropoutrecurrent_dropoutdropout_mask_countrrrandom SeedGeneratorseed_generator reset_after state_size output_size)selfr!r#r$r%r&r'r(r)r*r+r,r-r.r1r2r7rkwargsr __class__rS/var/www/html/chatgem/venv/lib/python3.10/site-packages/keras/src/layers/rnn/gru.pyr VsB               zGRUCell.__init__cst||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)Nrkernel)shapename initializer regularizer constraintrecurrent_kernelrbias)rbuild add_weightr!r&r)r,r@r'r*r-rFr%r7r(r+r.rG)r: input_shape input_dim bias_shaper<rr>rHs8   z GRUCell.buildFcCst|r |dn|}|jr,|js|jd}}nddtj|j|jjdddD\}}|jdkrx|rYd|j kr?dkrYnn| |}||d}||d} ||d} n|}|} |} t ||j ddd|j f} t | |j dd|j |j df} t | |j dd|j ddf} |jr| |d|j 7} | ||j |j d7} | ||j dd7} |rd|jkrdkrnn||}||d}||d}||d}n|}|}|}t ||jddd|j f}t ||jdd|j |j df}|jr$|jr$||d|j 7}|||j |j d7}|| |}|| |}|jr\t ||jdd|j ddf}|jrW|||j dd7}||}nt |||jdd|j ddf}|| |}n|rd|j krdkrnn | |}||}t ||j }|jr||7}tj|d d d\} } } |jrt ||j}|jr||7}nt ||jdddd|j f}|ddd|j f}|dd|j |j df}|dd|j ddf}|| |}|| |}|jr||}nt |||jddd|j df}|| |}||d||}t|r>|gn|}||fS) Nrcss|] }tj|ddVqdS)raxisN)rsqueeze).0errr> s  zGRUCell.call..rMrrrrrr?)r is_nestedr%r7rGrsplitrArr1get_dropout_maskmatmulr@r!r2get_recurrent_dropout_maskrFr$r#)r:inputsstatestrainingh_tm1 input_biasrecurrent_biasdp_maskinputs_zinputs_rinputs_hx_zx_rx_h rec_dp_maskh_tm1_zh_tm1_rh_tm1_h recurrent_z recurrent_rzr recurrent_hhhmatrix_x matrix_innerh new_staterrr>calls     $     $   z GRUCell.callcsid|jdt|jdt|jd|jdt|jdt|jdt|j dt |j d t |j d t |j d t|jd t|jd t|jd|jd|jd|jd|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_configr:config base_configr<rr>ru,sb        zGRUCell.get_configcCstj||jf|jdgS)N)dtype)rrr8 compute_dtype)r: batch_sizerrr>get_initial_stateOszGRUCell.get_initial_state)rrTrrrNNNNNNrrTNFN) __name__ __module__ __qualname____doc__r rHrsrur| __classcell__rrr<r>rs.H ; % v#rzkeras.layers.GRUcsDeZdZdZ                d6fd d Zd7fdd Zd8fdd ZeddZeddZ eddZ eddZ eddZ eddZ eddZed d!Zed"d#Zed$d%Zed&d'Zed(d)Zed*d+Zed,d-Zed.d/Zed0d1Zfd2d3Zed4d5ZZS)9GRUaGated 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`. rrTrrrNrFautoc s,t|fid|d|d|d|d|d|d|d| d | d | d | d |d |d|d|d|ddd|ddddd|d|dd}tj|f|||||| d|tdd|_|dvrptd|||_t dkrt j |j |j |j |j|dr|dvrd |_dSdSdSdS)!Nr#r$r%r&r'r(r)r*r+r,r-r.r1r2r7ry trainableTrBgru_cellrrr)return_sequences return_state go_backwardsstatefulunrollactivity_regularizerr)ndim)rTFzlInvalid valid received for argument `use_cudnn`. Expected one of {'auto', True, False}. Received: use_cudnn= tensorflow)r7)TrF)rr"rrr r input_specr use_cudnnrcudnn_okr#r$rr% supports_jit)r:r!r#r$r%r&r'r(r)r*r+rr,r-r.r1r2rrrrrrr7rr;cellr<rr>r s           z GRU.__init__cst|r |d}t|r|d}|jdvr{|js{zW|rD|jrD|j|dddddf}tj|dd}t |t |}||}n|}t j ||||jj |jj|jj|jj|jj|j|j|j|jjd }t dkrod|_|WStyzYnw|jdurtd tj||||d S) Nr)rTrrM) r@rFrGr#r$rrrr7rFTzuse_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.)maskrZ)rrSrr2r1rrUr expand_dims broadcast_torArgrur@rFrGr#r$rrrr7rNotImplementedErrorrr inner_loop)r: sequences initial_staterrZr^ dp_sequencesoutr<rr>r#sT         zGRU.inner_loopcstj||||dS)N)rrZr)rrs)r:rrrrZr<rr>rsXszGRU.callcC|jjSr~)rr!r:rrr>r!]z GRU.unitscCrr~)rr#rrrr>r#arzGRU.activationcCrr~)rr$rrrr>r$erzGRU.recurrent_activationcCrr~)rr%rrrr>r%irz GRU.use_biascCrr~)rr&rrrr>r&mrzGRU.kernel_initializercCrr~)rr'rrrr>r'qrzGRU.recurrent_initializercCrr~)rr(rrrr>r(urzGRU.bias_initializercCrr~)rr)rrrr>r)yrzGRU.kernel_regularizercCrr~)rr*rrrr>r*}rzGRU.recurrent_regularizercCrr~)rr+rrrr>r+rzGRU.bias_regularizercCrr~)rr,rrrr>r,rzGRU.kernel_constraintcCrr~)rr-rrrr>r-rzGRU.recurrent_constraintcCrr~)rr.rrrr>r.rzGRU.bias_constraintcCrr~)rr1rrrr>r1rz GRU.dropoutcCrr~)rr2rrrr>r2rzGRU.recurrent_dropoutcCrr~)rr7rrrr>r7rzGRU.reset_aftercsid|jdt|jdt|jd|jdt|jdt|jdt|j dt |j d t |j d t |j d t |jd t|jd t|jdt|jd|jd|jd|jd|jji}t}|d=i||S)Nr!r#r$r%r&r'r(r)r*r+rr,r-r.r1r2r7rr)r!rrtr#r$r%rr&r'r(rr)r*r+rrr,r-r.r1r2r7rrrrurvr<rr>rusl        " zGRU.get_configcCs|di|S)Nrr)clsrwrrr> from_configszGRU.from_config)rrTrrrNNNNNNNrrNFFFFFTrr})NNF)rrrrr rrspropertyr!r#r$r%r&r'r(r)r*r+r,r-r.r1r2r7ru classmethodrrrrr<r>rUs~}R5                 'rN) keras.srcrrrrrrrkeras.src.api_exportr keras.src.layers.input_specr keras.src.layers.layerr %keras.src.layers.rnn.dropout_rnn_cellr keras.src.layers.rnn.rnnr rrrrrr>s$           G