6bimSrSSKJr SSKJr SSKJr SSKrSSKrSSKJs J r SSK J r SSK J r SSK Jr SS KJr SS KJr SS KJr SS KJr SS KJr SSKJr SSKJr SrSrSrS7Sjr Sr!\"S/S9\"S/S9"SS\RD555r#"SS\#5r$\"S/S9\"S/S9"SS\$555r%\"S /S9\"S!/S9"S"S#\$555r&\RN"S$S%5r(\"S&/S9\"S'/S9"S(S$\(555r)\"S)/S9\"S*/S9"S+S,\$555r*\"S-/S9\"S./S9"S/S0\$555r+\"S1/S9\"S2/S9"S3S4\#555r,S5r-S6r.g)8a}Legacy module implementing RNN Cells. This module provides a number of basic commonly used RNN cells, such as LSTM (Long Short Term Memory) or GRU (Gated Recurrent Unit), and a number of operators that allow adding dropouts, projections, or embeddings for inputs. Constructing multi-layer cells is supported by the class `MultiRNNCell`, or by calling the `rnn` ops several times. )absolute_import)division)print_functionN) activations)backend) initializers)base_layer_utils) input_spec)base)tf_utils) tf_logging) keras_export) tf_exportbiaskernelc<[X5 g![a gf=f)NTF)getattrAttributeError)obj attr_names ^/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/layers/rnn/legacy_cells.py_hasattrr3s( s  c[U[R5(aUn[R"U5nURR S:Xa+[R RRUS5nOURR S:wa[SU35eO}[R"U5nUR bUR5OSnUR5(a1[R"UR5[RS9OSn[U[R5(aUn[R"U5nURR S:Xa+[R RRUS5nOURR S:wa[SU35eO}[R"U5nUR bUR5OSnUR5(a1[R"UR5[RS9OSnU(aH[R"U5RU5nUR bUR5nU$SnU$UbUc[SUSU35e[R "X54S5nU$) aConcat that enables int, Tensor, or TensorShape values. This function takes a size specification, which can be an integer, a TensorShape, or a Tensor, and converts it into a concatenated Tensor (if static = False) or a list of integers (if static = True). Args: prefix: The prefix; usually the batch size (and/or time step size). (TensorShape, int, or Tensor.) suffix: TensorShape, int, or Tensor. static: If `True`, return a python list with possibly unknown dimensions. Otherwise return a `Tensor`. Returns: shape: the concatenation of prefix and suffix. Raises: ValueError: if `suffix` is not a scalar or vector (or TensorShape). ValueError: if prefix or suffix was `None` and asked for dynamic Tensors out. rzFPrefix tensor must be either a scalar or vector, but received tensor: NdtypezFsuffix tensor must be either a scalar or vector, but received tensor: z2Prefix or suffix can't be None. Received prefix = z and suffix = ) isinstancetfTensorget_static_valueshapendimscompatv1 expand_dims ValueError TensorShapeas_listis_fully_definedconstantint32 concatenateconcat)prefixsuffixstaticpp_staticss_staticr!s r_concatr5<sJ,&"))$$ &&v. 77==A  ((A.A WW]]a (()s,  NN6 ""#''"5199;4!!## KK 288 4 &"))$$ &&v. 77==A  ((A.A WW]]a (()s,  NN6 ""#''"5199;4!!## KK 288 4 x(44X>#(;;#:  LAE L 9 %%+HN6(D  1&!$ LcR^^UU4Sjn[RRX05$)zCCreate tensors of zeros based on state_size, batch_size, and dtype.c>[TU5n[R"UTS9n[R"5(d[TUSS9nUR U5 U$)z7Combine s with batch_size to get a proper tensor shape.rT)r0)r5rzerosexecuting_eagerly set_shape)r3csizec_static batch_sizers rget_state_shape,_zero_state_tensors..get_state_shapesM J "xx'##%%z1T:H NN8 $ r6)rnest map_structure) state_sizer?rr@s `` r_zero_state_tensorsrEs 77  ==r6z*keras.__internal__.legacy.rnn_cell.RNNCell)r$znn.rnn_cell.RNNCellc^\rSrSrSrSU4SjjrSU4SjjrSr\S5r \S5r Sr SS jr S r U4S jr\S 5rS rU=r$)RNNCella#Abstract object representing an RNN cell. Every `RNNCell` must have the properties below and implement `call` with the signature `(output, next_state) = call(input, state)`. The optional third input argument, `scope`, is allowed for backwards compatibility purposes; but should be left off for new subclasses. This definition of cell differs from the definition used in the literature. In the literature, 'cell' refers to an object with a single scalar output. This definition refers to a horizontal array of such units. An RNN cell, in the most abstract setting, is anything that has a state and performs some operation that takes a matrix of inputs. This operation results in an output matrix with `self.output_size` columns. If `self.state_size` is an integer, this operation also results in a new state matrix with `self.state_size` columns. If `self.state_size` is a (possibly nested tuple of) TensorShape object(s), then it should return a matching structure of Tensors having shape `[batch_size].concatenate(s)` for each `s` in `self.batch_size`. c :>[TU]"SXUS.UD6 SUlg)N) trainablenamerT)super__init___is_tf_rnn_cell)selfrJrKrkwargs __class__s rrNRNNCell.__init__s$ O9uOO $r6c>UbI[RRRX0RS9n[ TU]XUS9sSSS5 $Sn[XS5nUcd[RRR[RRR5URS9n[XU5 U [ TU]X5sSSS5 $!,(df  g=f!,(df  g=f)aRun this RNN cell on inputs, starting from the given state. Args: inputs: `2-D` tensor with shape `[batch_size, input_size]`. state: if `self.state_size` is an integer, this should be a `2-D Tensor` with shape `[batch_size, self.state_size]`. Otherwise, if `self.state_size` is a tuple of integers, this should be a tuple with shapes `[batch_size, s] for s in self.state_size`. scope: VariableScope for the created subgraph; None uses class name. Defaults to `None`. Returns: A pair containing: - Output: A `2-D` tensor with shape `[batch_size, self.output_size]`. - New state: Either a single `2-D` tensor, or a tuple of tensors matching the arity and shapes of `state`. N) custom_getter)scope rnncell_scope) rr#r$variable_scope_rnn_get_variablerM__call__rget_variable_scopesetattr)rPinputsstaterVscope_attrnamerRs rrZRNNCell.__call__s&  ,,%;%;-w'U'C -ND$7E} 33IILL335"&"8"84e4w'6sCC/ C,/ C=c^U"U0UD6m[RRR5(a TRnOT[RRR 5;=(dT [ R"T5=(a7 [T5S[RRR 5;nU(aA[U4SjUR55(aURRT5 T$U(d?[U4SjUR55(aURRT5 T$)Nrc3,># UH nTULv M g7fNrL.0vvariables r ,RNNCell._rnn_get_variable..s '>!HA '>c3,># UH nTULv M g7frcrLrds rrhris# 'B!HA 'Brj) rr#r$#executing_eagerly_outside_functionsrJtrainable_variablesr is_split_variablelistall_trainable_weightsappend_non_trainable_weights)rPgetterargsrQrJrgs @rrYRNNCell._rnn_get_variables 4*6* 99<< ; ; = = **I BIILL$D$D$FF 228<LN1%)I)I)KK   '+'>'>     # # * *8 4  s# '+'B'B#     ' ' . .x 8r6c[S5e)zsize(s) of state(s) used by this cell. It can be represented by an Integer, a TensorShape or a tuple of Integers or TensorShapes. Abstract methodNotImplementedErrorrPs rrDRNNCell.state_sizes""344r6c[S5e)z>Integer or TensorShape: size of outputs produced by this cell.rxryr{s r output_sizeRNNCell.output_sizes""344r6cgrcrL)rP_s rbuild RNNCell.builds r6cUGb4[R"USS9nUb[R"U5(a[R"USS9nOUnURR SR U:wa2[SURR SR SU35eUb+URU:wa[SURS U35eURR SR =(d, [RRR U5SnURnUbUc[S US U35eURX#5$) Nr]rKT)partialrzTbatch size from input tensor is different from the input param. Input tensor batch: z, batch_size: zOdtype from input tensor is different from the input param. Input tensor dtype: z , dtype: zQbatch_size and dtype cannot be None while constructing initial state: batch_size=z, dtype=) rconvert_to_tensor is_tensorr r!dimsvaluer&rr#r$ zero_state)rPr]r?rstatic_batch_sizes rget_initial_stateRNNCell.get_initial_statesl  ))&x@F%<< ++(*(;(;"D)%)3%<<$$Q'--1BB$<!<<,,Q/5567''1l4 V\\U%: 88> ~F#W& !!!$**Kbiill.@.@.H.K LLE  --7LI z11r6cURn[R"5nU(a3[US5(a"[ US5unnnnXa:Xa Xr:XaXS:XaU$[ R "[U5RS-5 [X1U5n SSS5 U(a X1UW 4Ul W $!,(df  N!=f)aReturn zero-filled state tensor(s). Args: batch_size: int, float, or unit Tensor representing the batch size. dtype: the data type to use for the state. Returns: If `state_size` is an int or TensorShape, then the return value is a `N-D` tensor of shape `[batch_size, state_size]` filled with zeros. If `state_size` is a nested list or tuple, then the return value is a nested list or tuple (of the same structure) of `2-D` tensors with the shapes `[batch_size, s]` for each s in `state_size`. _last_zero_state ZeroStateN) rDrr:rrr name_scopetype__name__rEr) rPr?rrDis_eagerlast_state_sizelast_batch_size last_dtype last_outputoutputs rrRNNCell.zero_state$s"__ '') '9:: 01   -'#1""   T 3 3k A B(GFC %/UF$KD ! C Bs  B00 B>c >[TU]5$rc)rM get_config)rPrRs rrRNNCell.get_configJsw!##r6cg)NFrLr{s r!_use_input_spec_as_call_signature)RNNCell._use_input_spec_as_call_signatureMs r6)rOr)TNNrc)NNN)r __module__ __qualname____firstlineno____doc__rNrZrYpropertyrDr~rrrrr__static_attributes__ __classcell__rRs@rrGrGsj*$"7H&5555 $2L$L$r6rGc"\rSrSrSrSSjrSrg) LayerRNNCelliUaSubclass of RNNCells that act like proper `tf.Layer` objects. For backwards compatibility purposes, most `RNNCell` instances allow their `call` methods to instantiate variables via `tf.compat.v1.get_variable`. The underlying variable scope thus keeps track of any variables, and returning cached versions. This is atypical of `tf.layer` objects, which separate this part of layer building into a `build` method that is only called once. Here we provide a subclass for `RNNCell` objects that act exactly as `Layer` objects do. They must provide a `build` method and their `call` methods do not access Variables `tf.compat.v1.get_variable`. NcP[RR"XU/UQ7SU0UD6$)aRun this RNN cell on inputs, starting from the given state. Args: inputs: `2-D` tensor with shape `[batch_size, input_size]`. state: if `self.state_size` is an integer, this should be a `2-D Tensor` with shape `[batch_size, self.state_size]`. Otherwise, if `self.state_size` is a tuple of integers, this should be a tuple with shapes `[batch_size, s] for s in self.state_size`. scope: optional cell scope. *args: Additional positional arguments. **kwargs: Additional keyword arguments. Returns: A pair containing: - Output: A `2-D` tensor with shape `[batch_size, self.output_size]`. - New state: Either a single `2-D` tensor, or a tuple of tensors matching the arity and shapes of `state`. rV) base_layerLayerrZ)rPr]r^rVrurQs rrZLayerRNNCell.__call__ds:.(( % /3 ', 7=  r6rLrc)rrrrrrZrrLr6rrrUs   r6rz/keras.__internal__.legacy.rnn_cell.BasicRNNCellznn.rnn_cell.BasicRNNCellc^\rSrSrSrS U4Sjjr\S5r\S5r\ RS5r Sr U4Sjr S rU=r$) BasicRNNCelliaThe most basic RNN cell. Note that this cell is not optimized for performance. Args: num_units: int, The number of units in the RNN cell. activation: Nonlinearity to use. Default: `tanh`. It could also be string that is within TF-Keras activation function names. reuse: (optional) Python boolean describing whether to reuse variables in an existing scope. If not `True`, and the existing scope already has the given variables, an error is raised. name: String, the name of the layer. Layers with the same name will share weights, but to avoid mistakes we require reuse=True in such cases. dtype: Default dtype of the layer (default of `None` means use the type of the first input). Required when `build` is called before `call`. **kwargs: Dict, keyword named properties for common layer attributes, like `trainable` etc when constructing the cell from configs of get_config(). c >[R"SSS9 [TU] "SX4US.UD6 [ UR 5 [ R"5(a;[ RRS5(a[R"SU5 [R"SS9Ul XlU(a[R "U5Ulg[ R$Ulg) Nz`tf.nn.rnn_cell.BasicRNNCell` is deprecated and will be removed in a future version. This class is equivalent as `tf.keras.layers.SimpleRNNCell`, and will be replaced by that in Tensorflow 2.0. stacklevel_reuserKrGPUz9%s: Note that this cell is not optimized for performance.ndimrL)warningswarnrMrN_check_supported_dtypesrrr:configlist_logical_devicesloggingwarningr InputSpec _num_unitsrget _activationtanh)rP num_units activationreuserKrrQrRs rrNBasicRNNCell.__init__s   >   HHH +   ! !bii&D&DU&K&K OOK  %..A6# *z:D !wwD r6cUR$rcrr{s rrDBasicRNNCell.state_size r6cUR$rcrr{s rr~BasicRNNCell.output_sizerr6cxUSc[SU35e[UR5 USnUR[X R -UR /S9UlUR[UR /[RRRURS9S9Ul SUl g)N7Expected inputs.shape[-1] to be known, received shape: r!rr! initializerT)r&rr add_weight_WEIGHTS_VARIABLE_NAMEr_kernel_BIAS_VARIABLE_NAMErr#r$zeros_initializer_biasbuiltrP inputs_shape input_depths rrBasicRNNCell.builds   ###/.2   +"2&  "0$//B'  __ ??# 66TZZ6H%   r6c[X/5 [R"[R"X/S5UR5n[R R X0R5nURU5nXD4$)zDMost basic RNN: output = new_state = act(W * input + U * state + B).r) _check_rnn_cell_input_dtypesrmatmulr-rnnbias_addrr)rPr]r^ gate_inputsrs rcallBasicRNNCell.calls] %f_5ii 6/1 =t||L eenn[**= !!+.~r6c>UR[R"UR5URS.n[ TU]5n[[UR55[UR55-5$)N)rrr) rr serializerrrMrdictroitemsrPr base_configrRs rrBasicRNNCell.get_configsd%//0@0@A[[  g(* D**,-V\\^0DDEEr6)rrrrrr )NNNNrrrrrrNrrDr~r shape_type_conversionrrrrrrs@rrrso,  'B##$*FFr6rz*keras.__internal__.legacy.rnn_cell.GRUCellznn.rnn_cell.GRUCellc^\rSrSrSrS U4Sjjr\S5r\S5r\ RS5r Sr U4Sjr S rU=r$) GRUCelliaGated Recurrent Unit cell. Note that this cell is not optimized for performance. Please use `tf.compat.v1.keras.layers.CuDNNGRU` for better performance on GPU, or `tf.raw_ops.GRUBlockCell` for better performance on CPU. Args: num_units: int, The number of units in the GRU cell. activation: Nonlinearity to use. Default: `tanh`. reuse: (optional) Python boolean describing whether to reuse variables in an existing scope. If not `True`, and the existing scope already has the given variables, an error is raised. kernel_initializer: (optional) The initializer to use for the weight and projection matrices. bias_initializer: (optional) The initializer to use for the bias. name: String, the name of the layer. Layers with the same name will share weights, but to avoid mistakes we require reuse=True in such cases. dtype: Default dtype of the layer (default of `None` means use the type of the first input). Required when `build` is called before `call`. **kwargs: Dict, keyword named properties for common layer attributes, like `trainable` etc when constructing the cell from configs of get_config(). References: Learning Phrase Representations using RNN Encoder Decoder for Statistical Machine Translation: [Cho et al., 2014] (https://aclanthology.coli.uni-saarland.de/papers/D14-1179/d14-1179) ([pdf](http://emnlp2014.org/papers/pdf/EMNLP2014179.pdf)) c D>[R"SSS9 [T U] "SX6US.UD6 [ UR 5 [ R"5(a;[ RRS5(a[R"SU5 [R"SS9Ul XlU(a[R "U5UlO[ R$Ul[&R "U5Ul[&R "U5Ulg) Nz`tf.nn.rnn_cell.GRUCell` is deprecated and will be removed in a future version. This class is equivalent as `tf.keras.layers.GRUCell`, and will be replaced by that in Tensorflow 2.0.rrrrz%s: Note that this cell is not optimized for performance. Please use tf.compat.v1.keras.layers.CuDNNGRU for better performance on GPU.rrL)rrrMrNrrrr:rrrrr rrrrrrr_kernel_initializer_bias_initializer) rPrrrkernel_initializerbias_initializerrKrrQrRs rrNGRUCell.__init__s   >   HHH +   ! !bii&D&DU&K&K OO&  %..A6# *z:D !wwD #/#3#34F#G !-!1!12B!Cr6cUR$rcrr{s rrDGRUCell.state_size-rr6cUR$rcrr{s rr~GRUCell.output_size1rr6c 8USc[SU35e[UR5 USnURS[3X R -SUR -/UR S9UlURS[3SUR -/URb URO1[RRRSURS9S9UlURS[3X R -UR /UR S9UlURS[3UR /URb URO0[RRR!URS9S9UlS Ulg) Nrrzgates/rr?rz candidate/T)r&rrrrrr _gate_kernelrrrr#r$constant_initializer _gate_bias_candidate_kernelr_candidate_biasrrs rr GRUCell.build5s   ###/.2   +"2&  OO+, -0!doo2EF00,  //() *t&'))5&&YY\\66s$**6M * "&/0 10$//B00"1"  $,- .??#))5&&YY\\33$**3E /  r6c@[X/5 [R"[R"X/S5UR5n[R R X0R5n[R"U5n[R"USSS9upVXR-n[R"[R"X/S5UR5n[R R XR5nURU5n Xb-SU- U --n X4$)z-Gated recurrent unit (GRU) with nunits cells.rrrnum_or_size_splitsaxis) rrrr-rrrrsigmoidsplitrrr) rPr]r^rrrur_state candidater<new_hs rr GRUCell.call]s$f_5ii IIvoq )4+<+< eenn[//B  ;'xxeB)II IIv' +T-C-C EENN9.B.BC   Y ' QUaK'|r6c>UR[R"UR5[R"UR5[ R"UR 5URS.n[TU]%5n[[UR55[UR55-5$)N)rrrrr) rrrrrrrrrMrrrorrs rrGRUCell.get_configts"."8"8((#!- 6 6t7M7M N%//0@0@A[[ g(* D**,-V\\^0DDEEr6) rrrrrrrrrr )NNNNNNrrs@rrrsw< %DN##%$%N. F Fr6rLSTMStateTuple)r<hz1keras.__internal__.legacy.rnn_cell.LSTMStateTupleznn.rnn_cell.LSTMStateTuplec,\rSrSrSrSr\S5rSrg)rizTuple used by LSTM Cells for `state_size`, `zero_state`, & output state. Stores two elements: `(c, h)`, in that order. Where `c` is the hidden state and `h` is the output. Only used when `state_is_tuple=True`. rLcUupURUR:wa%[SURSUR35eUR$)Nz(Inconsistent dtypes for internal state: z vs )r TypeError)rPr<rs rrLSTMStateTuple.dtypesL 77agg :77)4y* wwr6N) rrrrr __slots__rrrrLr6rrrs I r6z0keras.__internal__.legacy.rnn_cell.BasicLSTMCellznn.rnn_cell.BasicLSTMCellc^\rSrSrSrS U4Sjjr\S5r\S5r\ RS5r Sr U4Sjr S rU=r$) BasicLSTMCelliaDEPRECATED: Please use `tf.compat.v1.nn.rnn_cell.LSTMCell` instead. Basic LSTM recurrent network cell. The implementation is based on We add forget_bias (default: 1) to the biases of the forget gate in order to reduce the scale of forgetting in the beginning of the training. It does not allow cell clipping, a projection layer, and does not use peep-hole connections: it is the basic baseline. For advanced models, please use the full `tf.compat.v1.nn.rnn_cell.LSTMCell` that follows. Note that this cell is not optimized for performance. Please use `tf.compat.v1.keras.layers.CuDNNLSTM` for better performance on GPU, or `tf.raw_ops.LSTMBlockCell` for better performance on CPU. c ,>[R"SSS9 [T U] "S XVUS.UD6 [ UR 5 U(d[ R"SU5 [R"5(a;[RRS5(a[ R"SU5 [R"SS9Ul XlX lX0lU(a["R$"U5Ulg [R(Ulg ) aYInitialize the basic LSTM cell. Args: num_units: int, The number of units in the LSTM cell. forget_bias: float, The bias added to forget gates (see above). Must set to `0.0` manually when restoring from CudnnLSTM-trained checkpoints. state_is_tuple: If True, accepted and returned states are 2-tuples of the `c_state` and `m_state`. If False, they are concatenated along the column axis. The latter behavior will soon be deprecated. activation: Activation function of the inner states. Default: `tanh`. It could also be string that is within TF-Keras activation function names. reuse: (optional) Python boolean describing whether to reuse variables in an existing scope. If not `True`, and the existing scope already has the given variables, an error is raised. name: String, the name of the layer. Layers with the same name will share weights, but to avoid mistakes we require reuse=True in such cases. dtype: Default dtype of the layer (default of `None` means use the type of the first input). Required when `build` is called before `call`. **kwargs: Dict, keyword named properties for common layer attributes, like `trainable` etc when constructing the cell from configs of get_config(). When restoring from CudnnLSTM-trained checkpoints, must use `CudnnCompatibleLSTMCell` instead. z`tf.nn.rnn_cell.BasicLSTMCell` is deprecated and will be removed in a future version. This class is equivalent as `tf.keras.layers.LSTMCell`, and will be replaced by that in Tensorflow 2.0.rrr_%s: Using a concatenated state is slower and will soon be deprecated. Use state_is_tuple=True.r%s: Note that this cell is not optimized for performance. Please use tf.compat.v1.keras.layers.CuDNNLSTM for better performance on GPU.rNrL)rrrMrNrrrrrr:rrr rr _forget_bias_state_is_tuplerrrr) rPr forget_biasstate_is_tuplerrrKrrQrRs rrNBasicLSTMCell.__init__sL   >   HHH + OO8     ! !bii&D&DU&K&K OO&  %..A6#'- *z:D !wwD r6cUR(a [URUR5$SUR-$)Nr)r"rrr{s rrDBasicLSTMCell.state_sizes9## 4??DOO < T__$ r6cUR$rcrr{s rr~BasicLSTMCell.output_sizerr6cUSc[SU35e[UR5 USnURnUR [ X#-SUR-/S9UlUR [SUR-/[RRRURS9S9Ul SUl g)NrrrrrT)r&rrrrrrrrr#r$rrr)rPrrh_depths rrBasicLSTMCell.builds   ###/.2   +"2& // "(!doo*=>'  __ t&' 66TZZ6H%   r6c [X/5 [Rn[R"S[RS9nUR (aUupVO[R "USUS9upV[R"[R"X/S5UR5n[RRXpR5n[R "USUS9upp[R"URU RS9n [Rn [R nU "U"XS"U "X555U"U"U5UR#U 555nU"UR#U5U"U 55nUR (a[%UU5nUU4$[R"UU/S5nUU4$)aLong short-term memory cell (LSTM). Args: inputs: `2-D` tensor with shape `[batch_size, input_size]`. state: An `LSTMStateTuple` of state tensors, each shaped `[batch_size, num_units]`, if `state_is_tuple` has been set to `True`. Otherwise, a `Tensor` shaped `[batch_size, 2 * num_units]`. Returns: A pair containing the new hidden state, and the new state (either a `LSTMStateTuple` or a concatenated state, depending on `state_is_tuple`). rrrrr+)rrr r*r+r"r rr-rrrrr!raddmultiplyrr)rPr]r^r oner<rrijfoforget_bias_tensorr/r0new_cr new_states rrBasicLSTMCell.callsf %f_5**kk!288,   DAq88%ACHDAii 6+q 94<<H eenn[**= XXKACP a[[):):!''Jff;; QA :; < WQZ!1!1!!4 5 ))%0'!*=   &ue4Ii 5%.!4Iir6c4>URURUR[R"UR 5UR S.n[TU]!5n[[UR55[UR55-5$)N)rr#r$rr) rr!r"rrrrrMrrrorrs rrBasicLSTMCell.get_configMsv,,"22%//0@0@A[[  g(* D**,-V\\^0DDEEr6)rrr!rrr"rr )rTNNNNrrs@rrrsw. F'P  ##$*- ^ F Fr6rz+keras.__internal__.legacy.rnn_cell.LSTMCellznn.rnn_cell.LSTMCellc^\rSrSrSrS U4Sjjr\S5r\S5r\ RS5r Sr U4Sjr S rU=r$) LSTMCelliYaLong short-term memory unit (LSTM) recurrent network cell. The default non-peephole implementation is based on (Gers et al., 1999). The peephole implementation is based on (Sak et al., 2014). The class uses optional peep-hole connections, optional cell clipping, and an optional projection layer. Note that this cell is not optimized for performance. Please use `tf.compat.v1.keras.layers.CuDNNLSTM` for better performance on GPU, or `tf.raw_ops.LSTMBlockCell` for better performance on CPU. References: Long short-term memory recurrent neural network architectures for large scale acoustic modeling: [Sak et al., 2014] (https://www.isca-speech.org/archive/interspeech_2014/i14_0338.html) ([pdf] (https://www.isca-speech.org/archive/archive_papers/interspeech_2014/i14_0338.pdf)) Learning to forget: [Gers et al., 1999] (http://digital-library.theiet.org/content/conferences/10.1049/cp_19991218) ([pdf](https://arxiv.org/pdf/1409.2329.pdf)) Long Short-Term Memory: [Hochreiter et al., 1997] (https://www.mitpressjournals.org/doi/abs/10.1162/neco.1997.9.8.1735) ([pdf](http://ml.jku.at/publications/older/3504.pdf)) c z>[R"SSS9 [TU] "S XUS.UD6 [ UR 5 U (d[ R"SU5 UcUb[ R"SU5 [R"5(a;[RRS5(a[ R"S U5 [R"SS 9Ul XlX lX0l["R$"U5UlXPlX`lXplXlXlXlU (a[4R$"U 5UlO[R8UlU(a"U (a [;X5OX-UlXPlgU (a [;X5OSU-UlXlg) aInitialize the parameters for an LSTM cell. Args: num_units: int, The number of units in the LSTM cell. use_peepholes: bool, set True to enable diagonal/peephole connections. cell_clip: (optional) A float value, if provided the cell state is clipped by this value prior to the cell output activation. initializer: (optional) The initializer to use for the weight and projection matrices. num_proj: (optional) int, The output dimensionality for the projection matrices. If None, no projection is performed. proj_clip: (optional) A float value. If `num_proj > 0` and `proj_clip` is provided, then the projected values are clipped elementwise to within `[-proj_clip, proj_clip]`. num_unit_shards: Deprecated, will be removed by Jan. 2017. Use a variable_scope partitioner instead. num_proj_shards: Deprecated, will be removed by Jan. 2017. Use a variable_scope partitioner instead. forget_bias: Biases of the forget gate are initialized by default to 1 in order to reduce the scale of forgetting at the beginning of the training. Must set it manually to `0.0` when restoring from CudnnLSTM trained checkpoints. state_is_tuple: If True, accepted and returned states are 2-tuples of the `c_state` and `m_state`. If False, they are concatenated along the column axis. This latter behavior will soon be deprecated. activation: Activation function of the inner states. Default: `tanh`. It could also be string that is within TF-Keras activation function names. reuse: (optional) Python boolean describing whether to reuse variables in an existing scope. If not `True`, and the existing scope already has the given variables, an error is raised. name: String, the name of the layer. Layers with the same name will share weights, but to avoid mistakes we require reuse=True in such cases. dtype: Default dtype of the layer (default of `None` means use the type of the first input). Required when `build` is called before `call`. **kwargs: Dict, keyword named properties for common layer attributes, like `trainable` etc when constructing the cell from configs of get_config(). When restoring from CudnnLSTM-trained checkpoints, use `CudnnCompatibleLSTMCell` instead. z`tf.nn.rnn_cell.LSTMCell` is deprecated and will be removed in a future version. This class is equivalent as `tf.keras.layers.LSTMCell`, and will be replaced by that in Tensorflow 2.0.rrrrNz%s: The num_unit_shards and proj_unit_shards parameters are deprecated and will be removed in Jan 2017. Use a variable scope with a partitioner instead.rr rrL) rrrMrNrrrrrr:rrr rr_use_peepholes _cell_cliprr _initializer _num_proj _proj_clip_num_unit_shards_num_proj_shardsr!r"rrrr _state_size _output_size)rPr use_peepholes cell_cliprnum_proj proj_clipnum_unit_shardsnum_proj_shardsr#r$rrrKrrQrRs rrNLSTMCell.__init__xs~x   >   HHH + OO8   &/*E OOC      ! !bii&D&DU&K&K OO&  %..A6#+#(,,[9!# / /'- *z:D !wwD  "y3)   !) "y4]   !* r6cUR$rc)rFr{s rrDLSTMCell.state_sizesr6cUR$rc)rGr{s rr~LSTMCell.output_sizes   r6cUSc[SU35e[UR5 USnURc URO URnUR b3[ RRRUR 5OSnUR[X#-SUR-/URUS9Ul URc%[ RRRnO1[ RRRURS9nUR[SUR-/US9UlUR"(aURSUR/URS9UlURSUR/URS9UlURS UR/URS9UlURbUR*b3[ RRRUR*5OSnURS [3URUR/URUS9UlS Ulg) Nrrr+)r!r partitionerrrw_f_diagw_i_diagw_o_diagz projection/T)r&rrrBrrDrr#r$fixed_size_partitionerrrrArrrrr? _w_f_diag _w_i_diag _w_o_diagrE _proj_kernelr)rPrrr,maybe_partitionerrmaybe_proj_partitioners rrLSTMCell.buildsH   ###/.2   +"2& %)^^%;$//$$0 IILL / /0E0E F   "(!doo*=>))) '  :: )),,88K)),,88tzz8JK__ t&'#%    !__' ---DN "__' ---DN "__' ---DN >> %((4 33D4I4IJ # !%4567 --2 !0!D  r6cd[X/5 URc URO URn[RnUR (aUupVOL[R "USS/SUR/5n[R "USUR/SU/5nUR5RS5RSRnUc[SUR535e[R"[R"X/S5UR5n[RR!XR"5n[R$"USSS9uppUR&(aRU"XR(-UR*U--5U-U"XR,U--5UR/U 5--n O2U"XR(-5U-U"U 5UR/U 5--n UR0b,[R2"XR0*UR05n UR&(a*U"XR4U --5UR/U 5-nOU"U 5UR/U 5-nURbY[R"XR65nUR8b,[R2"XR8*UR85nUR (a [;X5O[R"X/S5nX4$)aARun one step of LSTM. Args: inputs: input Tensor, must be 2-D, `[batch, input_size]`. state: if `state_is_tuple` is False, this must be a state Tensor, `2-D, [batch, state_size]`. If `state_is_tuple` is True, this must be a tuple of state Tensors, both `2-D`, with column sizes `c_state` and `m_state`. Returns: A tuple containing: - A `2-D, [batch, output_dim]`, Tensor representing the output of the LSTM after reading `inputs` when previous state was `state`. Here output_dim is: num_proj if num_proj was set, num_units otherwise. - Tensor(s) representing the new state of LSTM after reading `inputs` when the previous state was `state`. Same type and shape(s) as `state`. Raises: ValueError: If input size cannot be inferred from inputs via static shape inference. rrrrzMCould not infer input size from inputs.get_shape()[-1].Received input shape: r+r)rrBrrr r"slice get_shape with_rankrrr&rr-rrrrr r?r!rYrZrr@ clip_by_valuer[r\rCr)rPr]r^rJr c_prevm_prev input_size lstm_matrixr2r3r4r5r<mr8s rr LSTMCell.call9s4 %f_5&*nn&<4??$..**   $ VVXXeaVb$//-BCFXXea%9B>JF%%'11!499!<BB  ))/)9)9);(<>  ii 6*:A > M eenn[**= XXKAAN a   %%%(?? NNV++  A---.7';  #;$$A ?? &  __$4dooFA   NNQ../$2B2B12EEA T--a00A >> % !../A*$$Q(8$//J## 1 A61%  |r6c >URURUR[R"UR 5UR URURURURUR[R"UR5URS. n[TU]A5n[#[%UR'55[%UR'55-5$)N) rrHrIrrJrKrLrMr#r$rr)rr?r@rrrArBrCrDrEr!r"rrrrMrrrorrs rrLSTMCell.get_configs!00'11$2C2CD#44#44,,"22%//0@0@A[[  g(* D**,-V\\^0DDEEr6)rrr@r!rArrBrErDrrGrCr\r"rFr?rYrZr[rr ) FNNNNNNrTNNNNrrs@rr=r=Ys> y*v  !!##;$;zRhFFr6r=z/keras.__internal__.legacy.rnn_cell.MultiRNNCellznn.rnn_cell.MultiRNNCellc^\rSrSrSrS U4Sjjr\S5r\S5rU4Sjr \S5r \S5r S r S r U=r$) MultiRNNCellizRNN cell composed sequentially of multiple simple cells. Example: ```python num_units = [128, 64] cells = [BasicLSTMCell(num_units=n) for n in num_units] stacked_rnn_cell = MultiRNNCell(cells) ``` c>[R"S5 [TU] 5 U(d [ S5e[ R RU5(d[SUS35e[[SU555[U5:a&[R"[RSS5 Xl [UR5HNup4[U[ R R"R$5(dM:UR'USU4-S 9 MP X lU(dT[+S UR55(a2[ S URVs/sHoUR,PM sn35eg g s snf) aCreate a RNN cell composed sequentially of a number of RNNCells. Args: cells: list of RNNCells that will be composed in this order. state_is_tuple: If True, accepted and returned states are n-tuples, where `n = len(cells)`. If False, the states are all concatenated along the column axis. This latter behavior will soon be deprecated. Raises: ValueError: if cells is empty (not allowed), or at least one of the cells returns a state tuple but the flag `state_is_tuple` is `False`. z`tf.nn.rnn_cell.MultiRNNCell` is deprecated. This class is equivalent as `tf.keras.layers.StackedRNNCells`, and will be replaced by that in Tensorflow 2.0.z0Must specify at least one cell for MultiRNNCell.z-cells must be a list or tuple, but received: .c38# UHn[U5v M g7frc)idrecells rrh(MultiRNNCell.__init__..s.2d88zWAt least two cells provided to MultiRNNCell are the same object and will share weights.rzcell-%drc3t# UH.n[RRUR5v M0 g7frc)rrB is_nestedrD)rer<s rrhrus&HKq277$$Q\\22Ks68z]Some cells return tuples of states, but the flag state_is_tuple is not set. State sizes are: N)rrrMrNr&rrBrxrlenset log_first_nWARN_cells enumerater __internal__tracking Trackable_track_trackabler"anyrD)rPcellsr$ cell_numberrtr<rRs rrNMultiRNNCell.__init__sU  > OP Pww  ''?waH  s... /#e* <    >   !*4;;!7 K$ 8 8 B BCC%%dk^1K%L "8 .HDKKHHH (?C{{(K{!{(K'LNI )Ls(F cUR(a[SUR55$[SUR55$)Nc38# UHoRv M g7frcrDrss rrh*MultiRNNCell.state_size..sA[T[rvc38# UHoRv M g7frcrrss rrhrs?;4;rv)r"tupler}sumr{s rrDMultiRNNCell.state_sizes5   AT[[AA A?4;;?? ?r6c4URSR$)Nr)r}r~r{s rr~MultiRNNCell.output_sizes{{2***r6c*>^^[R"[U5RS-5 UR(a)[ UU4SjUR 55sSSS5 $[TU]!TT5sSSS5 $!,(df  g=f)Nrc3F># UHoRTT5v M g7frc)r)rertr?rs rrh*MultiRNNCell.zero_state..s CN4OOJ66;s!) rrrrr"rr}rMr)rPr?rrRs ``rrMultiRNNCell.zero_statesi   T 3 3k A B##CG;;C Bw)*e<C B Bs1B+B BcUR(d/$/nURH2n[U[R5(dM$XR - nM4 U$rc)rJr}rrrtrainable_weights)rPweightsrts rrMultiRNNCell.trainable_weightssI~~IKKD$ 0 011111 r6c@/nURH2n[U[R5(dM$XR- nM4 UR (dH/nURH2n[U[R5(dM$X2R - nM4 X1-$U$rc)r}rrrnon_trainable_weightsrJr)rPrrtrs rr"MultiRNNCell.non_trainable_weightssKKD$ 0 011555 ~~ "  dJ$4$455%)?)??%$%. .r6cSnUn/n[UR5Hupg[RRR SU-5 UR (aM[RRU5(d$[S[UR5SU35eX&nO4[R"USU/SUR/5nX7R- nU"XH5upIURU 5 SSS5 M UR (a [U5O[R"US5nXE4$!,(df  GM1=f)z9Run this multi-layer cell on inputs, starting from state.rzcell_%dz'Expected state to be a tuple of length z, but received: rNr)r~r}rr#r$rXr"rBrxr&ryrDrarrrr-) rPr]r^ cur_state_poscur_inp new_statesr2rt cur_stater8s rrMultiRNNCell.calls"   -GA,,Y];''77,,U33(E"4??34.ug7 !&I "=1B3H!I"__4M%)'%="!!),<;.(## * :q)  ""/<;s B.D== E )r}r")T)rrrrrrNrrDr~rrrrrrrs@rrnrnso 2h@@ ++ =  ##r6rncz[RRU5Hn[UR5 M g)aCheck whether the input tensors are with supported dtypes. Default RNN cells only support floats and complex as its dtypes since the activation function (tanh and sigmoid) only allow those types. This function will throw a proper error message if the inputs is not in a supported type. Args: inputs: tensor or nested structure of tensors that are feed to RNN cell as input or state. Raises: ValueError: if any of the input tensor are not having dtypes of float or complex. N)rrBflattenrr)r]ts rrr1s'WW__V $(%r6cUcg[R"U5nUR(d UR(d[ SU35egg)NzBRNN cell only supports floating point inputs, but received dtype: )ras_dtype is_floating is_complexr&rs rrrDsM } KK E   !1!1 ##(' +  "2 r6)F)/r __future__rrr collectionsrtensorflow.compat.v2r#v2r tf_keras.srcrrrtf_keras.src.enginer r tf_keras.src.legacy_tf_layersr rtf_keras.src.utilsr tensorflow.python.platformr r tensorflow.python.util.tf_exportrrrrrr5rErrGrrr namedtuple_LSTMStateTuplerrr=rnrrrLr6rrs.'%!!$ %0*<'=96!EP >>?@ $%&}j}'A}@( 7( VCDE )*+cF<cF,FcFL>?@ $%&UFlUF'AUFp(()9:FEFG +,-_.H,DEF *+,wFLwF-GwFt?@A %&'BF|BF(BBFJ CDE )*+L#7L#,FL#^)& r6