AVh'dZddlZddlmZddlmZddlmZddlm Z ddl m Z ddlmZdd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZm Z m!Z!ddl"m#Z#ejHdgdZ%edddZ&d^de#e!ejNfde#e!e&fde#e!e&fde#e!e&fde#e!e&fde#e!e&fde#e!e&fde#e!e&fde#e!e&fde(d e(d!e)fd"Z*ed#ejVe*Z,de#e!ejNfde#e!e&fde#e!e&fde#e!e&fde#e!e&fde#e!e&fde#e!e&fde#e!e&fde#e!e&fde(d e(d!e)fd$Z-ejHd%gd&Z.ed'ddZ/d_de#e!ejNfde#e!e/fde#e!e/fde#e!e/fde#e!e/fde#e!e/fde#e!e/fde#e!e/fde#e!e/fd(e#e!e/fd)e#e!e/fd*e#e!e/fd+e#e!e/fd,e#e!e/fd-e#e!e/fd.e#e!e/fd/e#e!e/fd0e#e!e/fd!e)f&d1Z0ed2ejVe0Z1de#e!ejNfde#e!e/fde#e!e/fde#e!e/fde#e!e/fde#e!e/fde#e!e/fde#e!e/fde#e!e/fd(e#e!e/fd)e#e!e/fd*e#e!e/fd+e#e!e/fd,e#e!e/fd-e#e!e/fd.e#e!e/fd/e#e!e/fd0e#e!e/fd!e)f&d3Z2ejHd4gd&Z3ed5ddZ4d_de#e!ejNfde#e!e4fde#e!e4fde#e!e4fde#e!e4fde#e!e4fde#e!e4fde#e!e4fde#e!e4fd(e#e!e4fd)e#e!e4fd*e#e!e4fd+e#e!e4fd,e#e!e4fd-e#e!e4fd.e#e!e4fd/e#e!e4fd0e#e!e4fd!e)f&d6Z5ed7ejVe5Z6de#e!ejNfde#e!e4fde#e!e4fde#e!e4fde#e!e4fde#e!e4fde#e!e4fde#e!e4fde#e!e4fd(e#e!e4fd)e#e!e4fd*e#e!e4fd+e#e!e4fd,e#e!e4fd-e#e!e4fd.e#e!e4fd/e#e!e4fd0e#e!e4fd!e)f&d8Z7ejHd9gdZ8ed:ddZ9d`de#e!ejNfde#e!e9fde#e!e9fde#e!e9fde#e!e9fde#e!e9fde#e!e9fde#e!e9fde#e!e9fd e(d!e)fd;Z:ed<ejVe:Z;de#e!ejNfde#e!e9fde#e!e9fde#e!e9fde#e!e9fde#e!e9fde#e!e9fde#e!e9fde#e!e9fd e(d!e)fd=Z<ejHd>gd?Z=ed@ej|AZ?d_de#e!e?fde#e!e?fdBe#e!e?fdCe#e!e?fdDe#e!e?fdEe#e!e?ff dFZ@edGejVe@ZAde#e!e?fde#e!e?fdBe#e!e?fdCe#e!e?fdDe#e!e?fdEe#e!e?ff dHZBejHdIgdJZCedKej|AZDd_de#e!eDfde#e!eDfdBe#e!eDfdCe#e!eDfdDe#e!eDfdEe#e!eDfdLe#e!eDfdMe#e!eDfdNe#e!eDfdOe#e!eDffdPZEedQejVeEZFde#e!eDfde#e!eDfdBe#e!eDfdCe#e!eDfdDe#e!eDfdEe#e!eDfdLe#e!eDfdMe#e!eDfdNe#e!eDfdOe#e!eDffdRZGejHdSgdZHedTddZId^de#e!eIfde#e!eIfde#e!eIfde#e!eIfde#e!eIfde#e!eIfde#e!eIfde#e!eIfde(d e(d!e)fdUZJedVejVeJZKde#e!eIfde#e!eIfde#e!eIfde#e!eIfde#e!eIfde#e!eIfde#e!eIfde#e!eIfde(d e(d!e)fdWZLejHdXgdYZMedZddZNd_de#e!eNfde#e!eNfde#e!eNfde#e!eNfde#e!eNfde#e!eNfde#e!eNfde#e!eNfd(e#e!eNfd)e#e!eNfd*e#e!eNfd+e#e!eNfd,e#e!eNfd-e#e!eNfd/e#e!eNfd0e#e!eNfd!e)f"d[ZOed\ejVeOZPde#e!eNfde#e!eNfde#e!eNfde#e!eNfde#e!eNfde#e!eNfde#e!eNfde#e!eNfd(e#e!eNfd)e#e!eNfd*e#e!eNfd+e#e!eNfd,e#e!eNfd-e#e!eNfd/e#e!eNfd0e#e!eNfd!e)f"d]ZQy)azUPython wrappers around TensorFlow ops. This file is MACHINE GENERATED! Do not edit. N) pywrap_tfe)context)core)execute)dtypes)annotation_types)op_def_registry)ops)op_def_library)deprecated_endpoints)dispatch) tf_export)TypeVarListAny) Annotated BlockLSTM)icsfocicohTV_BlockLSTM_Tz_atypes.Float32z _atypes.Half seq_len_maxxcs_prevh_prevwwciwcfwcob forget_bias cell_clip use_peepholec tjxstj} | j}|jr> t j | d| |||||||||d| d| d| }t j|}|S| d} tj | d} | d} tj | d} | d } tj"| d} t%j&d|||||||||| | | | \}}}}|dd}tj(rjd|j+dd|j+dd|j-dd |j/d f}|j0}tj2d|||t j|}|S#tj$r }tj|| Yd}~nd}~wtj$rYnwxYw t|||||||||| | | | | S#tj$rYwxYw) aComputes the LSTM cell forward propagation for all the time steps. This is equivalent to applying LSTMBlockCell in a loop, like so: ```python for x1 in unpack(x): i1, cs1, f1, o1, ci1, co1, h1 = LSTMBlock( x1, cs_prev, h_prev, w, wci, wcf, wco, b) cs_prev = cs1 h_prev = h1 i.append(i1) cs.append(cs1) f.append(f1) o.append(o1) ci.append(ci1) co.append(co1) h.append(h1) return pack(i), pack(cs), pack(f), pack(o), pack(ci), pack(ch), pack(h) ``` Args: seq_len_max: A `Tensor` of type `int64`. Maximum time length actually used by this input. Outputs are padded with zeros beyond this length. x: A `Tensor`. Must be one of the following types: `half`, `float32`. The sequence input to the LSTM, shape (timelen, batch_size, num_inputs). cs_prev: A `Tensor`. Must have the same type as `x`. Value of the initial cell state. h_prev: A `Tensor`. Must have the same type as `x`. Initial output of cell (to be used for peephole). w: A `Tensor`. Must have the same type as `x`. The weight matrix. wci: A `Tensor`. Must have the same type as `x`. The weight matrix for input gate peephole connection. wcf: A `Tensor`. Must have the same type as `x`. The weight matrix for forget gate peephole connection. wco: A `Tensor`. Must have the same type as `x`. The weight matrix for output gate peephole connection. b: A `Tensor`. Must have the same type as `x`. The bias vector. forget_bias: An optional `float`. Defaults to `1`. The forget gate bias. cell_clip: An optional `float`. Defaults to `3`. Value to clip the 'cs' value to. use_peephole: An optional `bool`. Defaults to `False`. Whether to use peephole weights. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (i, cs, f, o, ci, co, h). i: A `Tensor`. Has the same type as `x`. cs: A `Tensor`. Has the same type as `x`. f: A `Tensor`. Has the same type as `x`. o: A `Tensor`. Has the same type as `x`. ci: A `Tensor`. Has the same type as `x`. co: A `Tensor`. Has the same type as `x`. h: A `Tensor`. Has the same type as `x`. rr%r&r'Nr%r&r'namectxF) rrrrr r!r"r#r$r%r&r'r*T)_contextr_thread_local_datais_eagerrTFE_Py_FastPathExecute_BlockLSTMOutput_make_core_NotOkStatusException_opsraise_from_not_ok_status_FallbackExceptionblock_lstm_eager_fallback_SymbolicException_execute make_float make_bool_op_def_library_apply_op_helpermust_record_gradientget_attr_get_attr_bool_get_attr_typeinputsrecord_gradient)rrrrr r!r"r#r$r%r&r'r*_ctxtld_resulte__op_outputs_attrs _inputs_flats Q/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/gen_rnn_ops.py block_lstmrQs.r    0h..0$ #\\  11 k4a&!S# Q {K &g!&&w/g nK##K?+I!!)[9)L##L.A,'887"aScsa!, ".T ;!QX QK' ""$S\\-8+ll;'  0#  %'F::L \674  " "7 +' .I  & &- ##At,,  # #    & q'61c3Q!Y#$D::  # #   s0args_to_matching_eager_dtypeshalffloat32r7convert_to_tensorint64rrArFr3r4)rrrrr r!r"r#r$r%r&r'r*r+_attr_T _inputs_TrOrNrIs rPr:r:s[K##K?+I!!)[9)L##L.A,667FAsTWY\^_7`behohthtv}wFwFhIJ'9.7+1gvq#sC&&{GMMB+q'61c3QG, ; Y,W .&   \1\#)s ?' ""$ \674  " "7 +' . BlockLSTMGrad)x_grad cs_prev_grad h_prev_gradw_gradwci_gradwcf_gradwco_gradb_gradTV_BlockLSTMGrad_Trrrrrrrcs_gradh_gradctjxstj}|j}|jrC t j |d||||||||||| | | | | ||||d|}t j|}|Stj |d}t#j$ did|d|d|d|d |d |d |d |d |d| d| d| d| d| d|d|d|d|d|d|\}}}}|dd}tj&rHd|j)dd|j+df}|j,}tj.d|||t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||||||||| | | | | |||||||S#tj$rYdwxYw)a Computes the LSTM cell backward propagation for the entire time sequence. This implementation is to be used in conjunction of LSTMBlock. Args: seq_len_max: A `Tensor` of type `int64`. Maximum time length actually used by this input. Outputs are padded with zeros beyond this length. x: A `Tensor`. Must be one of the following types: `half`, `float32`. The sequence input to the LSTM, shape (timelen, batch_size, num_inputs). cs_prev: A `Tensor`. Must have the same type as `x`. Value of the initial cell state. h_prev: A `Tensor`. Must have the same type as `x`. Initial output of cell (to be used for peephole). w: A `Tensor`. Must have the same type as `x`. The weight matrix. wci: A `Tensor`. Must have the same type as `x`. The weight matrix for input gate peephole connection. wcf: A `Tensor`. Must have the same type as `x`. The weight matrix for forget gate peephole connection. wco: A `Tensor`. Must have the same type as `x`. The weight matrix for output gate peephole connection. b: A `Tensor`. Must have the same type as `x`. The bias vector. i: A `Tensor`. Must have the same type as `x`. The input gate over the whole time sequence. cs: A `Tensor`. Must have the same type as `x`. The cell state before the tanh over the whole time sequence. f: A `Tensor`. Must have the same type as `x`. The forget gate over the whole time sequence. o: A `Tensor`. Must have the same type as `x`. The output gate over the whole time sequence. ci: A `Tensor`. Must have the same type as `x`. The cell input over the whole time sequence. co: A `Tensor`. Must have the same type as `x`. The cell after the tanh over the whole time sequence. h: A `Tensor`. Must have the same type as `x`. The output h vector over the whole time sequence. cs_grad: A `Tensor`. Must have the same type as `x`. The current gradient of cs. h_grad: A `Tensor`. Must have the same type as `x`. The gradient of h vector. use_peephole: A `bool`. Whether to use peephole weights. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (x_grad, cs_prev_grad, h_prev_grad, w_grad, wci_grad, wcf_grad, wco_grad, b_grad). x_grad: A `Tensor`. Has the same type as `x`. cs_prev_grad: A `Tensor`. Has the same type as `x`. h_prev_grad: A `Tensor`. Has the same type as `x`. w_grad: A `Tensor`. Has the same type as `x`. wci_grad: A `Tensor`. Has the same type as `x`. wcf_grad: A `Tensor`. Has the same type as `x`. wco_grad: A `Tensor`. Has the same type as `x`. b_grad: A `Tensor`. Has the same type as `x`. r_r'Nr'r*r+rrrrr r!r"r#r$rrrrrrrrirjr*r.)r_)r/rr0r1rr2_BlockLSTMGradOutputr4r5r6r7r8r9block_lstm_grad_eager_fallbackr;r<r>r?r@rArCrDrErFrrrrr r!r"r#r$rrrrrrrrirjr'r*rGrHrIrJrKrLrMrNrOs rPblock_lstm_gradrps}p    0h..0$ #\\  11 ot[!Wfa S!QAq"b!Wfng%**73g n##L.A,'88?%0?45??F? &?*+?14?:=?CF?JK??"$?()?-.?35?:<?@A?") ?28 ? '3 ? :> ?!QX QK' ""$c00@#  %'F::L vw8 & &w /' .7  & &- ##At,,  # #    + q'61c3Q2q! b!WfrVrWrXrYr7rZr[rrArFrmr4rrrrr r!r"r#r$rrrrrrrrirjr'r*r+r\r]rOrNrIs rPrnrn sp##L.A,667FAsTWY\^_abdfhiklnprtvwzACI8JLORYR^R^`g`o`oQrs'9W`T1gvq#sCAr1aRGV&&{GMMB+q'61c3Q2qRSUWY[]^`giop, L#w 7&   -q#)s ?' ""$ vw8 & &w /' .r^BlockLSTMGradV2TV_BlockLSTMGradV2_Tctjxstj}|j}|jrC t j |d||||||||||| | | | | ||||d|}t j|}|Stj |d}t#j$ did|d|d|d|d |d |d |d |d |d| d| d| d| d| d|d|d|d|d|d|\}}}}|dd}tj&rHd|j)dd|j+df}|j,}tj.d|||t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||||||||| | | | | |||||||S#tj$rYdwxYw)a Computes the LSTM cell backward propagation for the entire time sequence. This implementation is to be used in conjunction of BlockLSTMV2. Args: seq_len_max: A `Tensor` of type `int64`. Maximum time length actually used by this input. Outputs are padded with zeros beyond this length. x: A `Tensor`. Must be one of the following types: `half`, `float32`. The sequence input to the LSTM, shape (timelen, batch_size, num_inputs). cs_prev: A `Tensor`. Must have the same type as `x`. Value of the initial cell state. h_prev: A `Tensor`. Must have the same type as `x`. Initial output of cell (to be used for peephole). w: A `Tensor`. Must have the same type as `x`. The weight matrix. wci: A `Tensor`. Must have the same type as `x`. The weight matrix for input gate peephole connection. wcf: A `Tensor`. Must have the same type as `x`. The weight matrix for forget gate peephole connection. wco: A `Tensor`. Must have the same type as `x`. The weight matrix for output gate peephole connection. b: A `Tensor`. Must have the same type as `x`. The bias vector. i: A `Tensor`. Must have the same type as `x`. The input gate over the whole time sequence. cs: A `Tensor`. Must have the same type as `x`. The cell state before the tanh over the whole time sequence. f: A `Tensor`. Must have the same type as `x`. The forget gate over the whole time sequence. o: A `Tensor`. Must have the same type as `x`. The output gate over the whole time sequence. ci: A `Tensor`. Must have the same type as `x`. The cell input over the whole time sequence. co: A `Tensor`. Must have the same type as `x`. The cell after the tanh over the whole time sequence. h: A `Tensor`. Must have the same type as `x`. The output h vector over the whole time sequence. cs_grad: A `Tensor`. Must have the same type as `x`. The current gradient of cs. h_grad: A `Tensor`. Must have the same type as `x`. The gradient of h vector. use_peephole: A `bool`. Whether to use peephole weights. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (x_grad, cs_prev_grad, h_prev_grad, w_grad, wci_grad, wcf_grad, wco_grad, b_grad). x_grad: A `Tensor`. Has the same type as `x`. cs_prev_grad: A `Tensor`. Has the same type as `x`. h_prev_grad: A `Tensor`. Has the same type as `x`. w_grad: A `Tensor`. Has the same type as `x`. wci_grad: A `Tensor`. Has the same type as `x`. wcf_grad: A `Tensor`. Has the same type as `x`. wco_grad: A `Tensor`. Has the same type as `x`. b_grad: A `Tensor`. Has the same type as `x`. rur'Nrlrrrrr r!r"r#r$rrrrrrrrirjr*r.)ru)r/rr0r1rr2_BlockLSTMGradV2Outputr4r5r6r7r8r9!block_lstm_grad_v2_eager_fallbackr;r<r>r?r@rArCrDrErFros rPblock_lstm_grad_v2rz"sp    0h..0$ #\\  11 {Aw S#q!RAr2q'6 &g',,W5g n##L.A,'88A'2A67AAHA"(A,-A36AABCA$+ A4: A )5 A <@ A!QX QK' ""$c00@#  %'F::L <: " ( ( 1' .7  & &- ##At,,  # #    . q'61c3Q2q! b!WfrVrWrXrYr7rZr[rrArFrxr4rts rPryrysp##L.A,667FAsTWY\^_abdfhiklnprtvwzACI8JLORYR^R^`g`o`oQrs'9W`T1gvq#sCAr1aRGV&&{GMMB+q'61c3Q2qRSUWY[]^`giop, L#w 7&   /<#)s ?' ""$ <: " ( ( 1' .r^ BlockLSTMV2TV_BlockLSTMV2_Tc tjxstj} | j} | jr< t j | d| |||||||||d| d| }t j|}|S| d} tj | d} | d} tj"| d} t%j&d|||||||||| | |  \}}}}|dd}tj(rYd|j+dd|j-dd |j/d f}|j0}tj2d|||t j|}|S#tj$r }tj|| Yd}~nd}~wtj$rYnwxYw t|||||||||| | | |  S#tj$rY]wxYw) a% Computes the LSTM cell forward propagation for all the time steps. This is equivalent to applying LSTMBlockCell in a loop, like so: ```python for x1 in unpack(x): i1, cs1, f1, o1, ci1, co1, h1 = LSTMBlock( x1, cs_prev, h_prev, w, wci, wcf, wco, b) cs_prev = cs1 h_prev = h1 i.append(i1) cs.append(cs1) f.append(f1) o.append(o1) ci.append(ci1) co.append(co1) h.append(h1) return pack(i), pack(cs), pack(f), pack(o), pack(ci), pack(ch), pack(h) Note that unlike LSTMBlockCell (and BlockLSTM) which uses ICFO gate layout, this op uses IFCO. So in order for the following snippet to be equivalent all gate-related outputs should be reordered. ``` Args: seq_len_max: A `Tensor` of type `int64`. Maximum time length actually used by this input. Outputs are padded with zeros beyond this length. x: A `Tensor`. Must be one of the following types: `half`, `float32`. The sequence input to the LSTM, shape (timelen, batch_size, num_inputs). cs_prev: A `Tensor`. Must have the same type as `x`. Value of the initial cell state. h_prev: A `Tensor`. Must have the same type as `x`. Initial output of cell (to be used for peephole). w: A `Tensor`. Must have the same type as `x`. The weight matrix. wci: A `Tensor`. Must have the same type as `x`. The weight matrix for input gate peephole connection. wcf: A `Tensor`. Must have the same type as `x`. The weight matrix for forget gate peephole connection. wco: A `Tensor`. Must have the same type as `x`. The weight matrix for output gate peephole connection. b: A `Tensor`. Must have the same type as `x`. The bias vector. cell_clip: An optional `float`. Defaults to `0`. Value to clip the 'cs' value to. use_peephole: An optional `bool`. Defaults to `False`. Whether to use peephole weights. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (i, cs, f, o, ci, co, h). i: A `Tensor`. Has the same type as `x`. cs: A `Tensor`. Has the same type as `x`. f: A `Tensor`. Has the same type as `x`. o: A `Tensor`. Has the same type as `x`. ci: A `Tensor`. Has the same type as `x`. co: A `Tensor`. Has the same type as `x`. h: A `Tensor`. Has the same type as `x`. r|r&r'N)r&r'r*r+rF) rrrrr r!r"r#r$r&r'r*r.)r/rr0r1rr2_BlockLSTMV2Outputr4r5r6r7r8r9block_lstmv2_eager_fallbackr;r<r=r>r?r@rArBrCrDrErF)rrrrr r!r"r#r$r&r'r*rGrHrIrJrKrLrMrNrOs rP block_lstmv2rsx    0h..0$ #\\  11 mT;7FAs S![)^\Kg#((1g nI!!)[9)L##L.A,'88;!W$s!* "!QX QK' ""$3<< 4n  0#  %'F::L |VW6  $ $W -' .?  & &- ##At,,  # #    ( q'61c3QLtOO  # #   s0:EF&2F  F&%F&*GGGzraw_ops.BlockLSTMV2c *| d} tj| d} | d} tj| d} tj||||||||g| tj tj g\} }|\}}}}}}}}tj|tj}|||||||||g }d| d| d| f}tjdd||| | }tjrtjd |||tj|}|S) Nrr&Fr'r.s BlockLSTMV2rSrTr|)r<r=r>rVrWrXrYr7rZr[rrArFrr4)rrrrr r!r"r#r$r&r'r*r+r\r]rOrNrIs rPrrs:I!!)[9)L##L.A,667FAsTWY\^_7`behohthtv}wFwFhIJ'9.7+1gvq#sC&&{GMMB+q'61c3QG, NL#  &   ^Q|#)s ?' ""$ |VW6  $ $W -' .r^ GRUBlockCell)rucrTV_GRUBlockCell_T)boundw_ruw_cb_rub_cc tjxstj}|j}|jr5 t j |d||||||| } t j| } | Stj d|||||||\} } } } | dd} t#j$r7d| j'df}| j(}t#j*d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||S#tj$rYwxYw)a?Computes the GRU cell forward propagation for 1 time step. Args x: Input to the GRU cell. h_prev: State input from the previous GRU cell. w_ru: Weight matrix for the reset and update gate. w_c: Weight matrix for the cell connection gate. b_ru: Bias vector for the reset and update gate. b_c: Bias vector for the cell connection gate. Returns r: Output of the reset gate. u: Output of the update gate. c: Output of the cell connection gate. h: Current state of the GRU cell. Note on notation of the variables: Concatenation of a and b is represented by a_b Element-wise dot product of a and b is represented by ab Element-wise dot product is represented by \circ Matrix multiplication is represented by * Biases are initialized with : `b_ru` - constant_initializer(1.0) `b_c` - constant_initializer(0.0) This kernel op implements the following mathematical equations: ``` x_h_prev = [x, h_prev] [r_bar u_bar] = x_h_prev * w_ru + b_ru r = sigmoid(r_bar) u = sigmoid(u_bar) h_prevr = h_prev \circ r x_h_prevr = [x h_prevr] c_bar = x_h_prevr * w_c + b_c c = tanh(c_bar) h = (1-u) \circ c + u \circ h_prev ``` Args: x: A `Tensor`. Must be one of the following types: `float32`. h_prev: A `Tensor`. Must have the same type as `x`. w_ru: A `Tensor`. Must have the same type as `x`. w_c: A `Tensor`. Must have the same type as `x`. b_ru: A `Tensor`. Must have the same type as `x`. b_c: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (r, u, c, h). r: A `Tensor`. Has the same type as `x`. u: A `Tensor`. Has the same type as `x`. c: A `Tensor`. Has the same type as `x`. h: A `Tensor`. Has the same type as `x`. rNr*r+)rrrrrrr*r.)r/rr0r1rr2_GRUBlockCellOutputr4r5r6r7r8r9gru_block_cell_eager_fallbackr;r?r@r<rArDrErF)rrrrrrr*rGrHrIrJrKrLrMrNrOs rPgru_block_cellrsuB    0h..0$ #\\ 11 ndAvtS$Eg#))'2g n(88!F3Td,!QX QK' ""$3%%c* +F::L  fg7  % %g .' .)  & &- ##At,,  # #    * VT3c$@@  # #   s03C==ED++EEEE10E1zraw_ops.GRUBlockCellcFtj||||||g|tjg\}} | \}}}}}}||||||g} d|f} tjdd| | ||} tj rtj d| | | tj| } | S)Nr.s GRUBlockCellrTr) r<rVrWrYrrArFrr4) rrrrrrr*r+r\r]rOrNrIs rPrrs6664dTW7XZ]`g`o`o_rs'9&/#1fdCsVT3c2, >&   _a #)s ?' ""$  fg7  % %g .' .r^GRUBlockCellGrad)d_xd_h_prevd_c_bar d_r_bar_u_barTV_GRUBlockCellGrad_Trrrd_hc tjxstj} | j} | jr9 t j | d| |||||||||| } t j| } | Stj d|||||||||| |  \}}}}|dd} t#j$r7d|j'df}|j(}t#j*d||| t j| } | S#tj$r }tj|| Yd}~nd}~wtj$rYnwxYw t|||||||||| | |  S#tj$rYwxYw)a6 Computes the GRU cell back-propagation for 1 time step. Args x: Input to the GRU cell. h_prev: State input from the previous GRU cell. w_ru: Weight matrix for the reset and update gate. w_c: Weight matrix for the cell connection gate. b_ru: Bias vector for the reset and update gate. b_c: Bias vector for the cell connection gate. r: Output of the reset gate. u: Output of the update gate. c: Output of the cell connection gate. d_h: Gradients of the h_new wrt to objective function. Returns d_x: Gradients of the x wrt to objective function. d_h_prev: Gradients of the h wrt to objective function. d_c_bar Gradients of the c_bar wrt to objective function. d_r_bar_u_bar Gradients of the r_bar & u_bar wrt to objective function. This kernel op implements the following mathematical equations: Note on notation of the variables: Concatenation of a and b is represented by a_b Element-wise dot product of a and b is represented by ab Element-wise dot product is represented by \circ Matrix multiplication is represented by * Additional notes for clarity: `w_ru` can be segmented into 4 different matrices. ``` w_ru = [w_r_x w_u_x w_r_h_prev w_u_h_prev] ``` Similarly, `w_c` can be segmented into 2 different matrices. ``` w_c = [w_c_x w_c_h_prevr] ``` Same goes for biases. ``` b_ru = [b_ru_x b_ru_h] b_c = [b_c_x b_c_h] ``` Another note on notation: ``` d_x = d_x_component_1 + d_x_component_2 where d_x_component_1 = d_r_bar * w_r_x^T + d_u_bar * w_r_x^T and d_x_component_2 = d_c_bar * w_c_x^T d_h_prev = d_h_prev_component_1 + d_h_prevr \circ r + d_h \circ u where d_h_prev_componenet_1 = d_r_bar * w_r_h_prev^T + d_u_bar * w_r_h_prev^T ``` Mathematics behind the Gradients below: ``` d_c_bar = d_h \circ (1-u) \circ (1-c \circ c) d_u_bar = d_h \circ (h-c) \circ u \circ (1-u) d_r_bar_u_bar = [d_r_bar d_u_bar] [d_x_component_1 d_h_prev_component_1] = d_r_bar_u_bar * w_ru^T [d_x_component_2 d_h_prevr] = d_c_bar * w_c^T d_x = d_x_component_1 + d_x_component_2 d_h_prev = d_h_prev_component_1 + d_h_prevr \circ r + u ``` Below calculation is performed in the python wrapper for the Gradients (not in the gradient kernel.) ``` d_w_ru = x_h_prevr^T * d_c_bar d_w_c = x_h_prev^T * d_r_bar_u_bar d_b_ru = sum of d_r_bar_u_bar along axis = 0 d_b_c = sum of d_c_bar along axis = 0 ``` Args: x: A `Tensor`. Must be one of the following types: `float32`. h_prev: A `Tensor`. Must have the same type as `x`. w_ru: A `Tensor`. Must have the same type as `x`. w_c: A `Tensor`. Must have the same type as `x`. b_ru: A `Tensor`. Must have the same type as `x`. b_c: A `Tensor`. Must have the same type as `x`. r: A `Tensor`. Must have the same type as `x`. u: A `Tensor`. Must have the same type as `x`. c: A `Tensor`. Must have the same type as `x`. d_h: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (d_x, d_h_prev, d_c_bar, d_r_bar_u_bar). d_x: A `Tensor`. Has the same type as `x`. d_h_prev: A `Tensor`. Has the same type as `x`. d_c_bar: A `Tensor`. Has the same type as `x`. d_r_bar_u_bar: A `Tensor`. Has the same type as `x`. rNr) rrrrrrrrrrr*r.)r/rr0r1rr2_GRUBlockCellGradOutputr4r5r6r7r8r9"gru_block_cell_grad_eager_fallbackr;r?r@r<rArDrErF)rrrrrrrrrrr*rGrHrIrJrKrLrMrNrOs rPgru_block_cell_gradrsR    0h..0$ #\\  11  $64dCA 3g(--g6g n(88aTs #qA$H!QX QK' ""$3%%c* +F::L L&'; # ) )' 2' .)  & &- ##At,,  # #    / VT3c1aCdNN  # #   s07DE D33E  E E''E>=E>zraw_ops.GRUBlockCellGradc ^tj|||||||||| g | tjg\} } | \ }}}}}}}}}} |||||||||| g }d| f}tjdd||| | }tj rtj d|||tj|}|S)Nr.sGRUBlockCellGradrrTr) r<rVrWrYrrArFrr4)rrrrrrrrrrr*r+r\r]rOrNrIs rPrr s6664dTWYZ\]_`be7fhknun}n}nAB'94=11fdCsAq!SVT3c1aC@, >&   0!L#)s ?' ""$ L&'; # ) )' 2' .r^ LSTMBlockCellTV_LSTMBlockCell_Tc tjxstj} | j} | jr= t j | d| ||||||||d|d| d| }t j|}|S|d}tj |d}| d} tj | d} | d } tj"| d} t%j&d|||||||||| | | \}}}}|dd}tj(rjd|j+dd|j+dd|j-dd |j/d f}|j0}tj2d|||t j|}|S#tj$r }tj|| Yd}~nd}~wtj$rYnwxYw t|||||||||| | | |  S#tj$rYwxYw) aRComputes the LSTM cell forward propagation for 1 time step. This implementation uses 1 weight matrix and 1 bias vector, and there's an optional peephole connection. This kernel op implements the following mathematical equations: ```python xh = [x, h_prev] [i, f, ci, o] = xh * w + b f = f + forget_bias if not use_peephole: wci = wcf = wco = 0 i = sigmoid(cs_prev * wci + i) f = sigmoid(cs_prev * wcf + f) ci = tanh(ci) cs = ci .* i + cs_prev .* f cs = clip(cs, cell_clip) o = sigmoid(cs * wco + o) co = tanh(cs) h = co .* o ``` Args: x: A `Tensor`. Must be one of the following types: `half`, `float32`. The input to the LSTM cell, shape (batch_size, num_inputs). cs_prev: A `Tensor`. Must have the same type as `x`. Value of the cell state at previous time step. h_prev: A `Tensor`. Must have the same type as `x`. Output of the previous cell at previous time step. w: A `Tensor`. Must have the same type as `x`. The weight matrix. wci: A `Tensor`. Must have the same type as `x`. The weight matrix for input gate peephole connection. wcf: A `Tensor`. Must have the same type as `x`. The weight matrix for forget gate peephole connection. wco: A `Tensor`. Must have the same type as `x`. The weight matrix for output gate peephole connection. b: A `Tensor`. Must have the same type as `x`. The bias vector. forget_bias: An optional `float`. Defaults to `1`. The forget gate bias. cell_clip: An optional `float`. Defaults to `3`. Value to clip the 'cs' value to. use_peephole: An optional `bool`. Defaults to `False`. Whether to use peephole weights. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (i, cs, f, o, ci, co, h). i: A `Tensor`. Has the same type as `x`. cs: A `Tensor`. Has the same type as `x`. f: A `Tensor`. Has the same type as `x`. o: A `Tensor`. Has the same type as `x`. ci: A `Tensor`. Has the same type as `x`. co: A `Tensor`. Has the same type as `x`. h: A `Tensor`. Has the same type as `x`. rr%r&r'Nr)r,r-F) rrrr r!r"r#r$r%r&r'r*r.)r/rr0r1rr2_LSTMBlockCellOutputr4r5r6r7r8r9lstm_block_cell_eager_fallbackr;r<r=r>r?r@rArBrCrDrErF)rrrr r!r"r#r$r%r&r'r*rGrHrIrJrKrLrMrNrOs rPlstm_block_cellr4s)z    0h..0$ #\\  11 otQCc1{KNg%**73g nK##K?+I!!)[9)L##L.A,'881gfs cQK#,<" $!QX QK' ""$S\\-8+ll;'  0#  %'F::L vw8 & &w /' .G  & &- ##At,,  # #    + Wfac3{LtOO  # #   s0;F GF99GGG..HHzraw_ops.LSTMBlockCellc |d}tj|d}| d} tj| d} | d} tj| d} tj||||||||g| tj tj g\} }|\}}}}}}}}||||||||g}d|d| d| d| f}tjdd ||| | }tjrtjd |||tj|}|S) Nr,r%r-r&Fr'r.s LSTMBlockCellrSrTr) r<r=r>rVrWrXrYrrArFrr4)rrrr r!r"r#r$r%r&r'r*r+r\r]rOrNrIs rPrrsDK##K?+I!!)[9)L##L.A,667FAsTWY\^_7`behohthtv}wFwFhIJ'9.7+1gvq#sCWfac3:, ; Y,W .&   -q#)s ?' ""$ vw8 & &w /' .r^LSTMBlockCellGrad)radicfordrerfTV_LSTMBlockCellGrad_Tctjxstj}|j}|jrA t j |d||||||||||| | | | | ||d|}t j|}|Stj |d}t#j$ did|d|d|d|d |d |d |d |d |d| d| d| d| d| d|d|d|d|\}}}}|dd}tj&rHd|j)dd|j+df}|j,}tj.d|||t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||||||||| | | | | |||||S#tj$rY\wxYw)aComputes the LSTM cell backward propagation for 1 timestep. This implementation is to be used in conjunction of LSTMBlockCell. Args: x: A `Tensor`. Must be one of the following types: `half`, `float32`. The input to the LSTM cell, shape (batch_size, num_inputs). cs_prev: A `Tensor`. Must have the same type as `x`. The previous cell state. h_prev: A `Tensor`. Must have the same type as `x`. The previous h state. w: A `Tensor`. Must have the same type as `x`. The weight matrix. wci: A `Tensor`. Must have the same type as `x`. The weight matrix for input gate peephole connection. wcf: A `Tensor`. Must have the same type as `x`. The weight matrix for forget gate peephole connection. wco: A `Tensor`. Must have the same type as `x`. The weight matrix for output gate peephole connection. b: A `Tensor`. Must have the same type as `x`. The bias vector. i: A `Tensor`. Must have the same type as `x`. The input gate. cs: A `Tensor`. Must have the same type as `x`. The cell state before the tanh. f: A `Tensor`. Must have the same type as `x`. The forget gate. o: A `Tensor`. Must have the same type as `x`. The output gate. ci: A `Tensor`. Must have the same type as `x`. The cell input. co: A `Tensor`. Must have the same type as `x`. The cell after the tanh. cs_grad: A `Tensor`. Must have the same type as `x`. The current gradient of cs. h_grad: A `Tensor`. Must have the same type as `x`. The gradient of h vector. use_peephole: A `bool`. Whether the cell uses peephole connections. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (cs_prev_grad, dicfo, wci_grad, wcf_grad, wco_grad). cs_prev_grad: A `Tensor`. Has the same type as `x`. dicfo: A `Tensor`. Has the same type as `x`. wci_grad: A `Tensor`. Has the same type as `x`. wcf_grad: A `Tensor`. Has the same type as `x`. wco_grad: A `Tensor`. Has the same type as `x`. rr'Nrlrrrr r!r"r#r$rrrrrrrirjr*r.)r)r/rr0r1rr2_LSTMBlockCellGradOutputr4r5r6r7r8r9#lstm_block_cell_grad_eager_fallbackr;r<r>r?r@rArCrDrErF)rrrr r!r"r#r$rrrrrrrirjr'r*rGrHrIrJrKrLrMrNrOs rPlstm_block_cell_gradrs_T    0h..0$ #\\  11 !4GVQS# 1b!QBOg)..w7g n##L.A,'88( (*1(:@(DE(!$(*-(36(:;(?@(EG(KL( !(&((-/(9@(%+ (:F ( #' (!QX QK' ""$c00@#  %'F::L \67< $ * *7 3' .5  & &- ##At,,  # #    0 Wfac31b!QB 6 4TKK  # #   s0?EF$0F  F$#F$(GGGzraw_ops.LSTMBlockCellGradctj|d}tj|||||||||| | | | | ||g|tjtj g\}}|\}}}}}}}}}} } } } } }}|||||||||| | | | | ||g}d|d|f}tj dd||||}tjrtjd|||tj|}|S)Nr'r.sLSTMBlockCellGradrTr) r<r>rVrWrXrYrrArFrr4)rrrr r!r"r#r$rrrrrrrirjr'r*r+r\r]rOrNrIs rPrrsI##L.A,667FAsTWY\^_abdfhiklnprtv}@F8GILOVO[O[]d]l]lNop'9T]Q1gvq#sCAr1aR&Wfac31b!QBPWY_`, L#w 7&   11\#)s ?' ""$ \67< $ * *7 3' .r^)r,r-FN)N)rFN)R__doc__ collectionstensorflow.pythonrtensorflow.python.eagerrr/rr5rr<tensorflow.python.frameworkrrWtensorflow.security.fuzzing.pyr_atypesr _op_def_registryr r7r r?"tensorflow.python.util.deprecationr tensorflow.python.utilr _dispatch tensorflow.python.util.tf_exportrtypingrrrtyping_extensionsr namedtupler3rInt64floatboolrQ to_raw_oprr:rmrhrpr_rnrxrvrzruryrr}rr|rrFloat32rrrrrrrrrrrrrrrrrrrr^rPrs  67179FK3IC86%%');))*, )+\ggpqtwErEhFgPYZ]_mZmPngs|}@BP}PsQgXabegubuXvg}FGJLZGZ}[gbkloqlb@gENORTbObEcgqvgDIgZ^gR +I) *>4>>*+E F 9S'--5G+HYWZ\jWjMkvADFTATwU_hiln|i|_}BKLOQ_L_B`gpqtvDqDgELUVY[iViLjqz{~@N{NqOT]^acq^qTrAFSXhl0.{--eg 13DnU]3 +=!>]9SRdMdCe]pyz}@R{RqS]]fgjl~g~]]DMNQSeNeDf]mvwz|NwNmO]V_`cew`wVx]HILN`I`a]fopsuGpGfH]MVWZ\nWnMo]u~BDVVuW]\efik}f}\~]CLMPRdMdCe]ktuxzL uL kM ]S \ ] ` b t ] t S u ]z C D G I [ D [ z \ ]g p q t v H q H g I ]S \ ] ` b t ] t S u ]E I ]~3 12>4>>/3RS   #w}}:L0M R[\_as\sRt @IJMOaJa@b luvy{MvMlN S\]`bt]tSu |EFIK]F]|^ enortFoFeG NWX[]oXoNp u~BDVVuW \efik}f}\~ DMNQSeNeDf ktuxzLuLkM R[\_as\sRt zC D G I [ D [ z\ b k l o q C l C b D I R S V X j S j I k v  @ C E W @ W v X b k l o q C l C b D T X 0//eg 57H.Y]Ic7==.@$A]iPSUiPiFj]u~@CEY@YvZ]dmnqsGnGdH]MVWZ\pWpMq]xABEG[B[x\]clmprFmFcG]NWX[]qXqNr]w@ADFZAZw[]`ijmoCjC`D]JSTWYmTmJn]s|}@BV}VsW]\efikf\@ ]F O P S U i P i F j ]p y z }  S z S p T ]Y b c f h | c | Y } ]H Q R U W k R k H l ]v  @ C E Y @ Y v Z ]j n ]~7)56~t~~FX7YZ 9S'--=O3P U^_bdx_xUy ENORThOhEi s|}@BV}VsW \efikf\@ GPQTVjQjGk r{|AU|UrV ]fgjl@g@]A FOPSUiPiFj oxy|~RyRoS Ybcfh|c|Y} BKLOQeLeBf ktuxzN uN kO U ^ _ b d x _ x U y  H I L N b I b  c h q r u w K r K h L W ` a d f z a z W { E N O R T h O h E i y } ,[++*, -/@.QdiW]](:;d #O_J_@`dktux{KvKlLdV_`ceu`uVvd{DEHJZEZ{[dbkloqAlAbBdIRSVXhShIidpyz}OzOpPdU^_bdt_tUudAFdW[dL/i-.~t~~l/KL YsGMM7I-JyY\^nYnOo{DEHJZEZ{[enortDoDeEJSTWYiTiJjqz{~@P{PqQXabegwbwXxHILN^I^_dmnqsCnCdDQVfj*-k,, /wG]i%6 67]3PaKaAb]jstwzKuKkL]S\]`bs]sSt]|EFIK\F\|]]dmnqsDnDdE]~1y/01OP  Ys4E/E%F PYZ]_pZpPq zCDGIZDZz[ bkloqBlBbC KTUXZkUkKl s|}@BS}SsT 1+0035  7wOF9S*?%?@F)TWYnTnJoFxABEG\B\x]FdmnqsHnHdIFQZ[^`u[uQvF}FGJLaGa}bFgpqtvKqKgLFQZ[^`u[uQvF{DEHJ_E_{`FgpqtvKqKgLFP9978H[9\] )C9N4N*O Ybcfh}c}Y~ GPQTVkQkGl s|}@BW}WsX `ijmoDjD`E LUVY[pVpLq v@CEZ@Zv[ `ijmoDjD`E JSTWYnTnJo v@CEZ@Zv[ .{--*, 13DnUjy&8!89jIcSeNeDfjpyz}@R{RqSjXabegybyXzjAJKNPbKbAcjjstwyKtKjLjS\]`bt]tSujzCDGI[D[z\jjoj}BjSWjX3 12>4>>/3RS i5G0G&HS\]`bt]tSu@IJMOaJa@bgpqtvHqHgIPYZ]_qZqPryBCFHZCZy[bkloqClCbDIRSVXjSjIkzLQae.2;11AC !!9;Ln]MIc+A&ABMYWZ\rWrMsM~GHKMcHc~dMirsvxNsNiOMV_`ce{`{V|MCLMPRhMhCiMpyz}UzUpVM[dehj@e@[AMFOPSUkPkFlMr{|AW|WrXM]fgjlBgB]CMHQRUWmRmHnMt}~A C Y ~Y tZ M` i j m o E j E ` F MQ Z [ ^ ` v [ v Q w MA J K N P f K f A g Mw { M^;I9:>4>>J^;_` 9S:P5P+Q \efilBgB]C MVWZ\rWrMs xABEG]B]x^ enortJoJeK R[\_aw\wRx HILNdIde jstwyOtOjP U^_bdz_zU{ AJKNPfKfAg luvy{QvQlR W`adf|a|W} C L M P R h M h C i o x y | ~ T y T o U ` i j m o E j E ` F P Y Z ] _ u Z u P v F J r^