6bi@bSrSSKrSSKJs Jr SSKJr SSKJr SSKJ r SSKJ r SSKJ r SSK J r SS KJr SS KJr SS KJr SS KJr SS KJr SSKJr SSKJr SSKJr Sr\"S/S9"SS\\ R>55r \"S/S9"SS\\\ R>55r!Sr"Sr#Sr$g)zGated Recurrent Unit layer.N) activations)backend) constraints) initializers) regularizers) base_layer) InputSpec)gru_lstm_utils) rnn_utils)RNN)DropoutRNNCellMixin)tf_utils) tf_logging) keras_exportzbRNN `implementation=2` is not supported when `recurrent_dropout` is set. Using `implementation=1`.zkeras.layers.GRUCell)v1c^\rSrSrSrS U4Sjjr\RU4Sj5rS Sjr U4Sjr S Sjr Sr U=r $) GRUCell-a+ Cell class for the GRU layer. See [the TF-Keras RNN API guide](https://www.tensorflow.org/guide/tf_keras/rnn) for details about the usage of RNN API. This class processes one step within the whole time sequence input, whereas `tf.keras.layer.GRU` processes the whole sequence. For example: >>> inputs = tf.random.normal([32, 10, 8]) >>> rnn = tf.keras.layers.RNN(tf.keras.layers.GRUCell(4)) >>> output = rnn(inputs) >>> print(output.shape) (32, 4) >>> rnn = tf.keras.layers.RNN( ... tf.keras.layers.GRUCell(4), ... return_sequences=True, ... return_state=True) >>> whole_sequence_output, final_state = rnn(inputs) >>> print(whole_sequence_output.shape) (32, 10, 4) >>> print(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 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`. 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). Call arguments: inputs: A 2D tensor, with shape of `[batch, feature]`. states: A 2D tensor with shape of `[batch, units]`, which is the state from the previous time step. For timestep 0, the initial state provided by user will be feed to cell. 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. c >US::a[SUS35e[RRR 5(aUR SS5UlOUR SS5Ul[TU] "S 0UD6 Xl [R"U5Ul [R"U5Ul X@l[R"U5Ul[R"U5Ul[R"U5Ul[&R"U5Ul[&R"U 5Ul[&R"U 5Ul[.R"U 5Ul[.R"U 5Ul[.R"U 5Ul[7S[9SU55Ul[7S[9SU55UlUR S S 5nUR<S:wa(US :wa"[>R@"[B5 S Ul"OUUl"UUl#URUl$URUl%g) NrzQReceived an invalid value for argument `units`, expected a positive integer, got .enable_caching_deviceTF?implementation)& ValueErrortfcompatr#executing_eagerly_outside_functionspop_enable_caching_devicesuper__init__unitsrget activationrecurrent_activationuse_biasrkernel_initializerrecurrent_initializerbias_initializerrkernel_regularizerrecurrent_regularizerbias_regularizerrkernel_constraintrecurrent_constraintbias_constraintminmaxdropoutrecurrent_dropoutloggingdebugRECURRENT_DROPOUT_WARNING_MSGr reset_after state_size output_size)selfr&r(r)r*r+r,r-r.r/r0r1r2r3r6r7r;kwargsr __class__s U/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/layers/rnn/gru.pyr%GRUCell.__init__ws( A:4497!=  99<< ; ; = =*0**'+D '+1**'+D ' "6" %//*5$/OO4H$I! "."2"23E"F%1%5%56K%L" , 0 01A B"."2"23E"F%1%5%56K%L" , 0 01A B!,1B!C$/OO4H$I!*?3C 12 !$S#c3D*E!F$4a8  ! !Q &>Q+> MM7 8"#D "0D &**::c >[TU]U5 USn[R"U5nUR X R S-4SUR URURUS9Ul UR UR UR S-4SURURURUS9Ul UR(akUR(dSUR -4nOSSUR -4nUR USUR UR"UR$US9UlOSUlSUlg) Nkernel)shapename initializer regularizer constraintcaching_devicerecurrent_kernelrbiasT)r$buildr rM add_weightr&r+r.r1rGr,r/r2rNr*r;r-r0r3rObuilt)r> input_shape input_dimdefault_caching_device bias_shaper@s rArP GRUCell.builds9  k"O !*!9!9$!?oojj1n-////--1 &  !%::tzzA~.#2222001 !0!  ==##$**n.  TZZ0   11 11//5 (DIDI rCc [RRU5(aUSOUnURXSS9nUR XCSS9nUR (aAUR (dURSpO"[R"UR5upxURS:XGaSURs=:aS:aO OXS-n XS-n XS-n OUn Un Un [R"XRSS2SUR245n [R"XRSS2URURS-245n [R"XRSS2URS-S245nUR (az[R"U WSUR5n [R"XURURS-5n [R"XURS-S5nSUR s=:aS:aO OXFS-nXFS-nXFS-nOUnUnUn[R"XR"SS2SUR245n[R"UUR"SS2URURS-245nUR (aeUR (aT[R"UWSUR5n[R"UXRURS-5nUR%U U-5nUR%U U-5nUR (au[R"UUR"SS2URS-S245nUR (a'[R"UWURS-S5nUU-nO:[R"UU-UR"SS2URS-S245nUR'UU-5nGOSURs=:aS:a O OXS-n[R"XR5nUR (a[R"UW5n[R("USSS 9upnUR (aI[R"X@R"5nUR (a[R"UW5nO6[R"X@R"SS2SSUR-245n[R("UURURS/SS 9unnnUR%U U-5nUR%U U-5nUR (aUU-nO:[R"UU-UR"SS2SUR-S245nUR'UU-5nUU-SU- U--n[RRU5(aU/OUnUU4$) NrrFcountrrrrrEaxis)rnest is_nestedget_dropout_mask_for_cell#get_recurrent_dropout_mask_for_cellr*r;rOunstackrr6rdotrGr&bias_addr7rNr)r(split)r>inputsstatestrainingh_tm1dp_mask rec_dp_mask input_biasrecurrent_biasinputs_zinputs_rinputs_hx_zx_rx_hh_tm1_zh_tm1_rh_tm1_h recurrent_z recurrent_rzr recurrent_hhhmatrix_x matrix_innerh new_states rAcall GRUCell.calls]**622F1I 000K>> 1?  ==##-1YYN-/ZZ -B*   ! #T\\'C'!AJ.!AJ.!AJ.!!!++h A||O(DEC++++adjj1n)D&DEC++h AtzzA~7G4G(HIC}}&&sJ|,DE&&DJJa@&&stzzA~7G,HIT++1c1a.0a.0a.0!++..q,DJJ,?K"++..q$**tzzA~2M/MNKDMM%.. $**!= &.. TZZ!^!L ))# *;0SUR_S[R"UR5_S[R"UR5_SUR _S[ R"UR5_S[ R"UR5_S[ R"UR5_S[R"UR5_S [R"UR5_S [R"UR5_S [R"UR5_S [R"UR 5_S [R"UR"5_SUR$_SUR&_SUR(_SUR*_nUR-[.R0"U55 [2TU]i5n[7[9UR;55[9UR;55-5$)Nr&r(r)r*r+r,r-r.r/r0r1r2r3r6r7rr;)r&r serializer(r)r*rr+r,r-rr.r/r0rr1r2r3r6r7rr;updater config_for_enable_caching_devicer$ get_configdictlistitemsr>config base_configr@s rArGRUCell.get_configas  TZZ +//@  #K$9$9))%    !,"8"8''#  $\%;%;**&   6 6t7L7L M  !,"8"8''# " $\%;%;**&# (  6 6t7L7L M) * !6!6t7M7M!N+ , #K$9$9))%- 2 {44T5I5IJ3 4 t||5 6 !7!77 8 d119 : 4++; >  i@@FGg(* D**,-V\\^0DDEErCc0[R"XX#5$N)r #generate_zero_filled_state_for_cell)r>re batch_sizedtypes rAget_initial_stateGRUCell.get_initial_states<< *  rC)r#r(rOr3r-r0rRr6rrGr1r+r.r=r)r2r7r,rNr/r;r<r&r*)tanhsigmoidTglorot_uniform orthogonalzerosNNNNNNrrTrNNN)__name__ __module__ __qualname____firstlineno____doc__r%rshape_type_conversionrPrrr__static_attributes__ __classcell__r@s@rArr-srFV&+* "!#?&B##($(T||"FH  rCrzkeras.layers.GRUc^\rSrSrSrSU4SjjrSSjr\S5r\S5r \S5r \S5r \S 5r \S 5r \S 5r\S 5r\S 5r\S5r\S5r\S5r\S5r\S5r\S5r\S5r\S5rU4Sjr\S5rSrSrU=r$)GRUiaxGated Recurrent Unit - Cho et al. 2014. See [the TF-Keras RNN API guide](https://www.tensorflow.org/guide/tf_keras/rnn) for details about the usage of RNN API. Based on available runtime hardware and constraints, this layer will choose different implementations (cuDNN-based or pure-TensorFlow) 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. 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 = tf.random.normal([32, 10, 8]) >>> gru = tf.keras.layers.GRU(4) >>> output = gru(inputs) >>> print(output.shape) (32, 4) >>> gru = tf.keras.layers.GRU(4, return_sequences=True, return_state=True) >>> whole_sequence_output, final_state = gru(inputs) >>> print(whole_sequence_output.shape) (32, 10, 4) >>> print(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 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 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. time_major: The shape format of the `inputs` and `outputs` tensors. If True, the inputs and outputs will be in shape `[timesteps, batch, feature]`, whereas in the False case, it will be `[batch, timesteps, feature]`. Using `time_major = True` is a bit more efficient because it avoids transposes at the beginning and end of the RNN calculation. However, most TensorFlow data is batch-major, so by default this function accepts input and emits output in batch-major form. reset_after: GRU convention (whether to apply reset gate after or before matrix multiplication). False = "before", True = "after" (default and cuDNN compatible). 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`. c 6>URSS5UlURSS5nUS:Xa[R"S5 SU;aSURS50nO0n[ U40SU_S U_S U_S U_S U_S U_SU_SU _SU _SU _SU _SU_SU_SU_SU_SU_SUR S5_SUR SS5_SS_UD6n[ TU]"U4UUUUUUS.UD6 [R "U 5Ul [SS9/Ul UR[R[R4;=(a UR [R"[R"4;=(aT US:H=(aH U(+=(a: U=(a1 U=(a( [R$R&R)5Ul[R,R/S5(atUR*(a2[R0"[2R4UR6-5 O1[R"[2R8UR6-5 [2R:"5(a[2R<"UUS 5Ulgg)!Nreturn_runtimeFrrrzm`implementation=0` has been deprecated, and now defaults to `implementation=2`.Please update your layer call.rr(r)r*r+r,r-r.r/r0r1r2r3r6r7r;r trainableTrIgru_cell)return_sequences return_state go_backwardsstatefulunroll time_majorrF)ndimGPUgru) r"_return_runtimer8warningrr'r$r%ractivity_regularizerr input_specr(rrrr)rr rr!_could_use_gpu_kernelrlist_logical_devicesr9r CUDNN_AVAILABLE_MSGrICUDNN_NOT_AVAILABLE_MSGuse_new_gru_lstm_impl DefunWrapper_defun_wrapper)r>r&r(r)r*r+r,r-r.r/r0rr1r2r3r6r7rrrrrrr;r?r cell_kwargscellr@s rAr% GRU.__init__ s: &zz*:EB$4a8 Q  OO1  #f ,'4K)LKK  ! "6   2  #8  .  2 #8 . 0 "6 ,  0 *! "$# $**W%% &jjd3' (+ .   -%%!  %1$4$45I$J!$!,- OO 0 0"'': : C))k.A.A2::-NN C!Q& C  C  C   C  @@B " 99 ) )% 0 0)) n@@499LM"::TYYF  / / 1 1"0"="=L%#D  2rCc^^[R"U5upUSLnTRXb5 TRXS5upn[ U[ 5(aUSn[R "U5nTR(aUSOUSn TR(dSU0mTRTR5 UU4Sjn [R"U UUSTRUTRUbUOU TRTRTRS9 upn [ R""[ R$5nOTR'XX2U5uppTR((ax[*R,R.R1TR2S[*R4"U STR2SR655/nTR9U5 TR(a"[R:"UU UTRS9nOU nTR<(aU/[ U 5-$TR>(aUU4$U$)Nrrrgc*>TR"X40TD6$r)r) cell_inputs cell_statesr?r>s rAstepGRU.call..stepsyyDVDDrC) constantsrmaskr input_lengthrzero_output_for_maskreturn_all_outputs)r) rconvert_inputs_if_ragged_validate_args_if_ragged_process_inputs isinstancer int_shaperr_maybe_reset_cell_dropout_maskrrnnrrrrr runtimeRUNTIME_UNKNOWN_defun_gru_callrrr rassignrfcastr add_updatemaybe_convert_to_raggedrr)r>rerrg initial_state row_lengthsis_ragged_input_rS timestepsr last_outputoutputsrfrupdatesoutputr?s` @rArGRU.callus&>>vF%T1 %%o<$(#7#7 4$  q dD ! !7D''/ &*ooKN;q> )) (+F  / / : E,3;;!..{{*)??%)%>%>#'#8#8, (K& %,,^-K-KLG484H4Hx{5 1K' == ##KKNBGGF1It{{1~7K7K$LG OOG $  44!.. F!F   8d6l* *  ! !7? "MrCc.URR$r)rr&r>s rAr& GRU.unitssyyrCc.URR$r)rr(rs rAr(GRU.activationsyy###rCc.URR$r)rr)rs rAr)GRU.recurrent_activationyy---rCc.URR$r)rr*rs rAr* GRU.use_biassyy!!!rCc.URR$r)rr+rs rAr+GRU.kernel_initializeryy+++rCc.URR$r)rr,rs rAr,GRU.recurrent_initializeryy...rCc.URR$r)rr-rs rAr-GRU.bias_initializeryy)))rCc.URR$r)rr.rs rAr.GRU.kernel_regularizerrrCc.URR$r)rr/rs rAr/GRU.recurrent_regularizerrrCc.URR$r)rr0rs rAr0GRU.bias_regularizerrrCc.URR$r)rr1rs rAr1GRU.kernel_constraintyy***rCc.URR$r)rr2rs rAr2GRU.recurrent_constraintrrCc.URR$r)rr3rs rAr3GRU.bias_constraintsyy(((rCc.URR$r)rr6rs rAr6 GRU.dropoutsyy   rCc.URR$r)rr7rs rAr7GRU.recurrent_dropoutrrCc.URR$r)rrrs rArGRU.implementationsyy'''rCc.URR$r)rr;rs rAr;GRU.reset_aftersyy$$$rCc>0SUR_S[R"UR5_S[R"UR5_SUR _S[ R"UR5_S[ R"UR5_S[ R"UR5_S[R"UR5_S [R"UR5_S [R"UR5_S [R"UR5_S [R"UR 5_S [R"UR"5_S[R"UR$5_SUR&_SUR(_SUR*_SUR,0EnUR/[0R2"UR455 [6TU]q5nUS [;[=UR?55[=UR?55-5$)Nr&r(r)r*r+r,r-r.r/r0rr1r2r3r6r7rr;r) r&rrr(r)r*rr+r,r-rr.r/r0rrr1r2r3r6r7rr;rr rrr$rrrrrs rArGRU.get_configs9! TZZ! +//@!  #K$9$9))%!  !  !,"8"8''#!  $\%;%;**&!   6 6t7L7L M!  !,"8"8''#! " $\%;%;**&#! (  6 6t7L7L M)! * #L$:$:))%+! 0 !6!6t7M7M!N1! 2 #K$9$9))%3! 8 {44T5I5IJ9! : t||;! < !7!7=! > d11?! @ 4++A! D  i@@KLg(*  D**,-V\\^0DDEErCc:SU;aUSS:XaSUS'U"S0UD6$)Nrrrrr)clsrs rA from_configGRU.from_config)s. v %&1A*Ba*G'(F# $}V}rCc UR5 URXSS9nUbXS-n[R"5(aU[R"US5[R"UR R 5[R"UR R5[R"UR R5UURURUURS. nURR"S0UD6unn n n GOU[R"US5[R"UR R 5[R"UR R5[R"UR R5UURURUURS. n U R5n U R!SUR05 ["R$"5(a[R&"5nU[R(:H=(d* USL=(a ["R*R-S5=(a! [R."X@RU5nU(a[1S0U D6uppO[3S0U D6uppO[5S0U D6unn n n U /nXU U4$) NrFrYr) reinit_hrGrNrOrrrsequence_lengthsr rerrGrNrOrrrrrrrr)reset_dropout_maskr_r rread_variable_valuerrGrNrOrrrr defun_layerrcopyrrexecuting_eagerlyget_context_device_typeGPU_DEVICE_NAMErris_cudnn_supported_inputsgpu_gru standard_grugru_with_backend_selection)r>rerrgrr dropout_mask gru_kwargsrrnew_hrgpu_gru_kwargsnormal_gru_kwargs device_type can_use_gpurfs rArGRU._defun_gru_call/s !55fa5P  #1o-F  / / 1 1 (<<]1=MN(<>J"oo $ 1 1$4(,(A(A J&##//=*=  !(<<]1=MN(<>J"oo $ 1 1$4$($9$9 N!/ 3 3 5   $ $*D,E,E  ##%%,DDF $~'E'EE'4/F " > >u E '@@ //3C";B<(<8K%USn[R"UT5n[R"UT5n[R"USSS9upEn[R"UT5n[R"UT5n[R"USSS9upn [R "XH-5n [R "XY-5n [R "XlU --5n X-SU - U --nX/4$)z8Step function that will be used by TF-Keras RNN backend.rrFrr[)rrbrcrrdrr)rrrhr|rprqrrr}rvrwrzrxryr{r~rkrGrlrNs rArstandard_gru..stepsA;;{F3##Hj9115 #{{5*:; '' nE 02 !!1 - + JJs( ) JJs( ) WWS{?* + IQ" $#v rCNF)rrrrrrrr)rrrrarr r RUNTIME_CPU)rerrGrNrOrrrrrrrSrrrr new_statesrkrls `` @@rArrsp##F+K", A+a.I!#D!1J2(/{{   !  '& 1+($K* 1 ~99:  rCc FUb[R"XV5nU(dUc[R"USS9nSupO U(aSOSup[R"XS9n[R "USSS9n U [R "USSS9- n [R "[ R"U5S5n[RR5S (aDU SU S sU S 'U S'U S U SsU S'U S 'USUS sUS 'US'US USsUS'US '[R"U U[R"S /5S S9n Ub{U(a[R"UUU U S9n[RRUUS U S SUUS9up nU(a,[R"UUU U S9n[R"X/S9nOCU(a[R"US /S9n[RR!UUS U S SS9up nUS nU(d!UcU (a[R"U/SQS9n[R""XS9nUbUnU (d[R"UU(aS OSS9nUUU[R$"[R&54$)z>GRU with cuDNN implementation which is only available for GPU.)rrr)perm)rr)rrr[rFr is_cuda_buildrrET)weightsbiasesrHtranspose_weights)seq_axis batch_axisr)inputinput_hinput_cparams is_trainingrnn_moderr)r:r;r<r=r>r?)r calculate_sequence_by_maskr transpose expand_dimsrdrflatten sysconfigget_build_infocanonical_to_paramsconstantreverse_sequenceraw_ops CudnnRNNV3reverseCudnnRNNsqueezer RUNTIME_GPU)rerrGrNrOrrrrrr8r9r5r=rr~rrs rArrs )DD   *2f95%*)3v^^F 2Fhhvqq)G rxx(!!44G 88GOOD)1 -D ||""$_5")WQZ GAJ!(WQZ GAJ7DGQa7DGQa  / /kk2$ F#  (( !% F !jj33-!4  Aq! )) !% G jjz:G ZZaS1F::.. / Aq"+K *27G,,wY7 1$A#  .. 1J  ~99:  rCc >^^UUUUUUUUUU U S. mSm[R"5(aS[RR [R U4Sj[R UU4Sj0U4Sj5un n n nOS[[R"55-nUUS.n[R"U[R [U5n[R"U[R TU5nU"S0TD6upp[R"U40TD6 XX4$) aCall the GRU with optimized backend kernel selection. Under the hood, this function will create two TF function, one with the most generic kernel and can run on all device condition, and the second one with cuDNN specific kernel, which can only run on GPU. The first function will be called with normal_lstm_params, while the second function is not called, but only registered in the graph. The Grappler will do the proper graph rewrite and swap the optimized TF function based on the device placement. Args: inputs: Input tensor of GRU layer. init_h: Initial state tensor for the cell output. kernel: Weights for cell kernel. recurrent_kernel: Weights for cell recurrent kernel. bias: Weights for cell kernel bias and recurrent bias. Only recurrent bias is used in this case. mask: Boolean tensor for mask out the steps within sequence. An individual `True` entry indicates that the corresponding timestep should be utilized, while a `False` entry indicates that the corresponding timestep should be ignored. time_major: Boolean, whether the inputs are in the format of [time, batch, feature] or [batch, time, feature]. go_backwards: Boolean (default False). If True, process the input sequence backwards and return the reversed sequence. sequence_lengths: The lengths of all sequences coming from a variable length input, such as ragged tensors. If the input has a fixed timestep size, this should be None. zero_output_for_mask: Boolean, whether to output zero for masked timestep. return_sequences: Boolean. If True, return the recurrent outputs for all timesteps in the sequence. If False, only return the output for the last timestep (which consumes less memory). Returns: List of output tensors, same as standard_gru. rerrGrNrOrrrrrrc ^^^^^^^^^^ ^ UUUUUUUU UU4 Sjn UUUUUUUU UUU 4 Sjn [RRR[R"TTT5U U S9$)z [TTTTTTT TTTS9 $)Nr)r) rOrrrerGrrNrrrs rA cudnn_gru_fnOgru_with_backend_selection..gpu_gru_with_fallback..cudnn_gru_fns.!1%)!1!1  rCc*> [TTTTTTT TTT TS9 $)NrPr) rOrrrerGrrNrrrrs rAstandard_gru_fnRgru_with_backend_selection..gpu_gru_with_fallback..standard_gru_fns1!1%)!1%9!1  rC)true_fnfalse_fn)r __internal__ smart_condr r) rerrGrNrOrrrrrrrSrWs ``````````` rAgpu_gru_with_fallback9gru_with_backend_selection..gpu_gru_with_fallbacksZ    ))44  4 4j"2 !$ 5  rCc>[S0TD6$NrrVr=srA,gru_with_backend_selection..s 8Nv8NrCc>T"S0TD6$r`r)r]r=srArbrcs8M99rCc>[S0TD6$r`rVrasrArbrcs L*6*rCgru_)rrr) r rrr[execute_fn_for_deviceCPU_DEVICE_NAMErstruuiduuid4generate_defun_backendrfunction_register)rerrGrNrOrrrrrrrrr#rapi_namesupportive_attributedefun_standard_gru defun_gpu_grur]r=s @@rAr r vs/f, $, 4, F2 h++-- OO 1 1..0N..1  +     C --$( ,BB   * *    '==   * * !  0B/KF/K, e((A&A  //rC)%rrjtensorflow.compat.v2r v2r tf_keras.srcrrrrrtf_keras.src.enginertf_keras.src.engine.input_specr tf_keras.src.layers.rnnr r tf_keras.src.layers.rnn.base_rnnr .tf_keras.src.layers.rnn.dropout_rnn_cell_mixinr tf_keras.src.utilsrtensorflow.python.platformrr8 tensorflow.python.util.tf_exportrr:BaseRandomLayerrrrrr rrCrAr~s" !!$ $%%*42-0N'=9  $,Z !:#=#=Z -Z z  R(5 sJ$>$>5)5DjZxv`0rC