o 2hlD@sddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl m Z dd l m Z dd l mZdd lmZed Gd dde eZedGdddeZdS)) activations)backend) constraints) initializers)ops) regularizers) keras_export) InputSpec)Layer)DropoutRNNCell)RNNzkeras.layers.SimpleRNNCellcsfeZdZdZ              dfd d Zd d ZdddZdddZfddZZ S) SimpleRNNCellav Cell class for SimpleRNN. This class processes one step within the whole time sequence input, whereas `keras.layer.SimpleRNN` 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`). 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. seed: Random seed for dropout. Call arguments: sequence: 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: ```python inputs = np.random.random([32, 10, 8]).astype(np.float32) rnn = keras.layers.RNN(keras.layers.SimpleRNNCell(4)) output = rnn(inputs) # The output has shape `(32, 4)`. rnn = keras.layers.RNN( keras.layers.SimpleRNNCell(4), return_sequences=True, return_state=True ) # whole_sequence_output has shape `(32, 10, 4)`. # final_state has shape `(32, 4)`. whole_sequence_output, final_state = rnn(inputs) ``` tanhTglorot_uniform orthogonalzerosNc s|dkr td|dtjdi|||_tj||_||_t ||_ ||_ t ||_t ||_t ||_t ||_t ||_t | |_t | |_t | |_t | |_tdtd| |_tdtd||_|j|_|j|_dS)NrzQReceived an invalid value for argument `units`, expected a positive integer, got .g?r) ValueErrorsuper__init__seedrrandom SeedGeneratorseed_generatorunitsrget activationuse_biasrkernel_initializerrecurrent_initializerbias_initializerrkernel_regularizerrecurrent_regularizerbias_regularizerrkernel_constraintrecurrent_constraintbias_constraintminmaxdropoutrecurrent_dropout state_size output_size)selfrrrr r!r"r#r$r%r&r'r(r+r,rkwargs __class__rZ/var/www/html/chatgem/venv/lib/python3.10/site-packages/keras/src/layers/rnn/simple_rnn.pyrOs2           zSimpleRNNCell.__init__cCs~|j|d|jfd|j|j|jd|_|j|j|jfd|j|j|jd|_ |j r:|j|jfd|j |j |j d|_dSd|_dS)Nkernel)shapename initializer regularizer constraintrecurrent_kernelbias) add_weightrr r#r&r5r!r$r'r;rr"r%r(r<)r/ input_shaperrr3builds.   zSimpleRNNCell.buildFc Cst|ttfr |dn|}||}||}|r!|dur!||}t||j}|jdur2||j7}|r<|dur<||}|t||j }|j durO| |}t|ttfrY|gn|} || fS)Nr) isinstancelisttupleget_dropout_maskget_recurrent_dropout_maskrmatmulr5r<r;r) r/sequencestatestraining prev_outputdp_mask rec_dp_maskhoutput new_staterrr3calls        zSimpleRNNCell.callcCstj||jf|jdgS)N)dtype)rrr- compute_dtype)r/ batch_sizerrr3get_initial_stateszSimpleRNNCell.get_initial_statecs|jt|j|jt|jt|jt|jt |j t |j t |j t |jt |jt |j|j|j|jd}t}i||S)N)rrrr r!r"r#r$r%r&r'r(r+r,r)rr serializerrrr r!r"rr#r$r%rr&r'r(r+r,rr get_configr/config base_configr1rr3rUs8       zSimpleRNNCell.get_config)rTrrrNNNNNNrrN)FN) __name__ __module__ __qualname____doc__rr?rOrSrU __classcell__rrr1r3r s*B1  r zkeras.layers.SimpleRNNcseZdZdZ               d.fd d Zd/fd d ZeddZeddZeddZ eddZ eddZ eddZ eddZ eddZeddZed d!Zed"d#Zed$d%Zed&d'Zed(d)Zfd*d+Zed,d-ZZS)0 SimpleRNNaFully-connected RNN where the output is to be fed back as the new input. 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`). use_bias: Boolean, (default `True`), whether the layer uses 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. 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 the 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 an RNN, although it tends to be more memory-intensive. Unrolling is only suitable for short sequences. Call arguments: sequence: A 3D tensor, with shape `[batch, timesteps, feature]`. mask: Binary tensor of shape `[batch, timesteps]` indicating whether a given timestep should be masked. An individual `True` entry indicates that the corresponding timestep should be utilized, while a `False` entry indicates that the corresponding timestep should be ignored. 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. initial_state: List of initial state tensors to be passed to the first call of the cell. Example: ```python inputs = np.random.random((32, 10, 8)) simple_rnn = keras.layers.SimpleRNN(4) output = simple_rnn(inputs) # The output has shape `(32, 4)`. simple_rnn = keras.layers.SimpleRNN( 4, return_sequences=True, return_state=True ) # whole_sequence_output has shape `(32, 10, 4)`. # final_state has shape `(32, 4)`. whole_sequence_output, final_state = simple_rnn(inputs) ``` rTrrrNrFc st|fid|d|d|d|d|d|d|d| d | d | d | d |d |d|d|ddd|dddd}tj|f|||||d|tddg|_dS)Nrrr r!r"r#r$r%r&r'r(r+r,rrP trainableTr7simple_rnn_cell)return_sequences return_state go_backwardsstatefulunroll)ndim)r rrrr input_spec)r/rrrr r!r"r#r$r%activity_regularizerr&r'r(r+r,rbrcrdrerfrr0cellr1rr3r(sb        zSimpleRNN.__init__cstj||||dS)N)maskrH initial_state)rrO)r/ sequencesrmrlrHr1rr3rO`szSimpleRNN.callcC|jjSrY)rkrr/rrr3rezSimpleRNN.unitscCrorY)rkrrprrr3rirqzSimpleRNN.activationcCrorY)rkrrprrr3rmrqzSimpleRNN.use_biascCrorY)rkr rprrr3r qrqzSimpleRNN.kernel_initializercCrorY)rkr!rprrr3r!urqzSimpleRNN.recurrent_initializercCrorY)rkr"rprrr3r"yrqzSimpleRNN.bias_initializercCrorY)rkr#rprrr3r#}rqzSimpleRNN.kernel_regularizercCrorY)rkr$rprrr3r$rqzSimpleRNN.recurrent_regularizercCrorY)rkr%rprrr3r%rqzSimpleRNN.bias_regularizercCrorY)rkr&rprrr3r&rqzSimpleRNN.kernel_constraintcCrorY)rkr'rprrr3r'rqzSimpleRNN.recurrent_constraintcCrorY)rkr(rprrr3r(rqzSimpleRNN.bias_constraintcCrorY)rkr+rprrr3r+rqzSimpleRNN.dropoutcCrorY)rkr,rprrr3r,rqzSimpleRNN.recurrent_dropoutcs|jt|j|jt|jt|jt|jt |j t |j t |j t |j t|jt|jt|j|j|jd}t}|d=i||S)N)rrrr r!r"r#r$r%rjr&r'r(r+r,rk)rrrTrrrr r!r"rr#r$r%rjrr&r'r(r+r,rrUrVr1rr3rUs>       zSimpleRNN.get_configcCs|di|S)Nrr)clsrWrrr3 from_configszSimpleRNN.from_config)rTrrrNNNNNNNrrFFFFFN)NNF)rZr[r\r]rrOpropertyrrrr r!r"r#r$r%r&r'r(r+r,rU classmethodrsr^rrr1r3r_snV8               "r_N) keras.srcrrrrrrkeras.src.api_exportrkeras.src.layers.input_specr keras.src.layers.layerr %keras.src.layers.rnn.dropout_rnn_cellr keras.src.layers.rnn.rnnr r r_rrrr3s          E