Vh ddlZddlZddlmZddlZddlmZddlmZddlm Z m Z m Z m Z m Z ddlmZddlmZgdZd!ded ed ed efd Zed ed!ded ed ed efdZdZGddej j0ZGddej j0ZGddeZGddeZGddej j0ZGddeZGddeZGdd eZ y)"N) deprecated)Tensor)DictListOptionalTupleUnion)_quantize_weight)PackedSequence) pack_weight_biasPackedParameterRNNBaseLSTMGRU RNNCellBaseRNNCellLSTMCellGRUCellapply_permutationtensor permutationdimreturnc&|j||SN) index_selectrrrs Y/home/dcms/DCMS/lib/python3.12/site-packages/torch/ao/nn/quantized/dynamic/modules/rnn.py_apply_permutationrs   sK 00z]`apply_permutation` is deprecated, please use `tensor.index_select(dim, permutation)` instead)categoryct|||Srrrs rrr!s fk3 77r c|tjk(r,tjjj ||}|Stjjj ||}|Sr)torchqint8ops quantizedlinear_prepacklinear_prepack_fp16)qweightbiasdtype packed_weights rr r )sV    ++::7DI   ++??N r c2eZdZfdZfdZfdZxZS)r c0t|||_yr)super__init__param)selfr3 __class__s rr2zPackedParameter.__init__=s  r cLt|||||j||dz<y)Nr3)r1_save_to_state_dictr3r4 destinationprefix keep_varsr5s rr7z#PackedParameter._save_to_state_dictAs' #KC(, FW$%r c J||dz|_t| |||d|||y)Nr3F)r3r1_load_from_state_dict r4 state_dictr:local_metadatastrict missing_keysunexpected_keys error_msgsr5s rr=z%PackedParameter._load_from_state_dictEs8  01  %        r )__name__ __module__ __qualname__r2r7r= __classcell__r5s@rr r <s3  r r c BeZdZejZdZdddddejffd Z dZ dZ d Z d e d ee d d fdZd e d ee d eeeeffdZ dde deeeefded d fdZd e de d ee d d fdZde dee d e fdZfdZdZeddZdZdZdZxZS) rTFgc t|||_||_||_||_||_||_t||_ ||_ | |_ d|_ d|_ |rdnd} t|tj r(d|cxkrdkrn t%dt|t"r t%d|dkDr |dk(rt'j(d|d||dk(rd |z} n|d k(rd |z} nt%d |zg} t+|D]} t+| D]}| dk(r|n|| z}t-j.| |j1t,j}t-j.| |j1t,j}t-j.| j1t,j}t-j.| j1t,j}| t,j2k(rt-j4|d dt,j2}t-j4|d dt,j2}t,j6j8j;||}t,j6j8j;||}|j|jdkr-t,j6j8j=||||}nt,j6j8j=||||d}n~t,j6j8j?||}t,j6j8j?||}t,j6j8jA||}| jCtE|t,jFjI| |_%y)NrKFrLrzbdropout should be a number in range [0, 1] representing the probability of an element being zeroedzdropout option adds dropout after all but last recurrent layer, so non-zero dropout expects num_layers greater than 1, but got dropout=z and num_layers=rrzUnrecognized RNN mode: g?scale zero_pointr-T)&r1r2mode input_size hidden_size num_layersr, batch_firstfloatdropout bidirectionalr-versiontraining isinstancenumbersNumberbool ValueErrorwarningswarnranger%randntor&quantize_per_tensorr'r(r)"make_quantized_cell_params_dynamicr*make_quantized_cell_params_fp16appendr nn ModuleList_all_weight_values)r4rSrTrUrVr,rWrYrZr-num_directions gate_sizermlayer_layer_input_sizew_ihw_hhb_ihb_hh packed_ih packed_hh cell_paramsr5s rr2zRNNBase.__init__`sW  $&$ &W~ *   + 7GNN3$1$ '4(  Q;:? MM>>EYG(\+  6>KI U]KI6=> >:&& HE>*% H"'1*J+2N!{{9.>?BB5;;O{{9k:==ekkJ{{9-00={{9-00=EKK' 44CAU[[D!44CAU[[D!& 3 3 B B4 NI % 3 3 B B4 NI||+t||a/?!II//RR )9dD$"II//RR )9dD$$ !& 3 3 G Gd SI % 3 3 G Gd SI"'))"5"5"U"U!9#K#))/+*FGK% H& HN#((("5"56H"Ir cy)NDynamicQuantizedRNNr4s r _get_namezRNNBase._get_name$r cd}|jdk7r|dz }|jdur|dz }|jdur|dz }|jdk7r|d z }|jdur|d z }|j d i|j S) N{input_size}, {hidden_size}rLz, num_layers={num_layers}T , bias={bias}Fz, batch_first={batch_first}rz, dropout={dropout}z, bidirectional={bidirectional}r|)rVr,rWrYrZformat__dict__r4ss r extra_reprzRNNBase.extra_reprs ) ??a  , ,A 99D  A   5 ( . .A <<1  & &A   U * 2 2Aqxx($--((r cg}|j}|r|jd}g}|jjD]u\}}t |t t jfr't|}t jjj|d}|jd|zdz|zw||z}|jdz}|r3t|dk(r |s ||dz }n|ddj|zdzz }|dz }|S) N rK(z): rLrz ))rsplit_modulesitemsr]r rkrlreprmodulesmodule _addindentrjr~lenjoin) r4 extra_linesr child_lineskeyrmod_strlinesmain_strs r__repr__zRNNBase.__repr__s   __& $**40K ==..0 G   sSy507: ;  < k)>>#c) ;1$[KN*FV[[%77$>>Cr input batch_sizesrNc|dnd}|j|k7rtd|d|j|j|jdk7r*td|jd|jdy)NrKrOzinput must have z dimensions, got z5input.size(-1) must be equal to input_size. Expected z, got )r RuntimeErrorrTsize)r4rrexpected_input_dims r check_inputzRNNBase.check_inputs"-"9Qq 99;, ,"#5"66G }U  ??ejjn ,GGXX^_d_i_ijl_m^no  -r c|t|d}n.|jr|jdn|jd}|jrdnd}|j|z||j f}|S)NrrLrK)intrWrrZrVrU)r4rr mini_batchrnexpected_hidden_sizes rget_expected_hidden_sizez RNNBase.get_expected_hidden_sizesn  "[^,J*.*:*:A 1 J"00a OOn ,      $#r hxrmsgc |j|k7r2t|j|t|jyr)rrrlist)r4rrrs rcheck_hidden_sizezRNNBase.check_hidden_size s9 779, ,szz*>RWWYPQ Q -r hiddenct|j|||j||}|j||dy)NExpected hidden size {}, got {})rrrrr4rrrrs rcheck_forward_argszRNNBase.check_forward_argssC  ,#<d}|jrdnd}g}t|jD]}t|D]}|dk(rdnd}|d||\}} |d||\} } ||} || } || }|| }| jtj k(rtj jj| | }tj jj||}|j|jdkr-tj jj||| |}ntj jj||| |d}n~tj jj| | }tj jj||}tj jj||}|jt|tjj!||_y) Nc2d|d||}d|d||}||fSNweight__lbias_r|)ihhhrpsuffix weight_name bias_names rweight_bias_namez1RNNBase.set_weight_bias..weight_bias_name7s9#D6E76(;KvRwvh7I ) )r rKrL_reverseihhhT)rZrdrVr-r%r&r'r(r)r[rhr*rirjr rkrlrm)r4weight_bias_dictrrnrmrp directionr w_ih_name b_ih_name w_hh_name b_hh_namersrurtrvrwrxrys rset_weight_biaszRNNBase.set_weight_bias6s * #00a4??+ HE">2 H '0A~2'7eV'L$ 9'7eV'L$ 9' 2' 2' 2' 2::, % 3 3 B B4 NI % 3 3 B B4 NI||+t||a/?!II//RR )9dD$"II//RR )9dD$$ !& 3 3 G Gd SI % 3 3 G Gd SI"'))"5"5"U"U!9#K#))/+*FG= H H@#((("5"56H"Ir c ttjjtjjhvsJdt dsJdj -j jj jnddlm }|jj}tjtjg}||vrtd|jdk(rYtjj j"j$j&j(j*|}nsjdk(rYt jj j"j$j&j(j*|}n t-d j*rd nd }j$sJg}t/|j"D]t/|D]} | d k(rd nd fd} | d\} } | d\} }|tjk(rfd}|| | }|| |}|j0|j0d kr-tj2j4j7||| |}ntj2j4j7||| |d}n|tjk(rtj2j4j9| j;| }tj2j4j9| j;|}tj2j4j=||}n td|j?tA|tjjC||_"|S)NzInn.quantized.dynamic.RNNBase.from_float only works for nn.LSTM and nn.GRUqconfig,Input float module must have qconfig definedrdefault_dynamic_qconfig0Unsupported dtype for dynamic RNN quantization: rrz3Only LSTM/GRU is supported for QuantizedRNN for nowrKrLrrcdd|d}d|d}t|}t|}||fSr)getattr)rrrweightr,rpmodrs rretrieve_weight_biasz0RNNBase.from_float..retrieve_weight_biassQ$+D6E76("CK"'vRwvh ?I$S+6F"3 2D!4<'r rrc}||t|j|}tjjj ||}|Sr)r rXr%r'r(r))wbweight_observerr+r.weight_observer_methods rquantize_and_packz-RNNBase.from_float..quantize_and_packsH*@*B'*"21779o"N(- (;(;(J(J7TU(V ,,r Tz7Unsupported dtype specified for dynamic quantized LSTM!)#typer%rkrrhasattrrrtorch.ao.quantization.qconfigrr-r&float16rrSrTrUrVr,rWrYrZNotImplementedErrorrdr[r'r(rhr*rXrirjr rlrm)clsruse_precomputed_fake_quantrr-supported_scalar_typesqRNNBasernrmrr weight_ihbias_ih weight_hhbias_hhrrwrxryrprrs ` @@@r from_floatzRNNBase.from_floatasbCy HHMM HHLL   W W W sI&V(VV& ;; "s{{'9'9'E%([[%7%7 " N%<%C%C "&(.."'++u}}!= . .B5'J  88v  !! HXX  !! H&E "//Qxxx8../6 HE">25 H '0A~2(&:$%?" 7%9$%?" 7EKK'-!2)W EI 1)W EI''/83C3Ca3G!II//RR )9gw$"II//RR )9gw$ emm+ % 3 3 G G!)7!I!& 3 3 G G!)7!I#())"5"5"U"U!9#K'Q#))/+*FGk5 H6 Hn',hh&9&9:L&M#r c.iid}d}|jrdnd}t|jD]}t|D]}|dk(rdnd}d||}d||}|j|jj dd } | dj dd|d |<| dj dd|d |<d ||}d ||}| dj dd|d |<| dj dd|d |<|dz}|S)Nrr,rrKrLrr weight_ih_l weight_hh_lrNr bias_ih_l bias_hh_lr,)rZrdrVrmr3 __getstate__) r4rcountrnrprr key_name1 key_name2packed_weight_biass r _weight_biaszRNNBase._weight_biass792,F"00a4??+ "E">2 " '0A~2)%9 )%9 &*%<%<&% q&**+&-"9K9,.9$$%9' *959K9,.9$$%9' *95(wvh7 'wvh7 6H7,.7$$%7' (37I7,.7$$%7' (3 / " "2 r c(|jdSNrrr}s r get_weightzRNNBase.get_weight  "8,,r c(|jdSNr,rr}s rget_biaszRNNBase.get_bias  "6**r )rF)rErFrGrkr _FLOAT_MODULE_versionr%r&r2r~rrrrrtuplerrstrrrrr=r classmethodrrrrrHrIs@rrr[sHJJMH kk^J@% )<  hv6F 4  $ $*26*: $ sC}  $&5 R R$CcM2R R  R  %+ :B6:J  33hv6F363  ,)JVrrh @-+r rc.eZdZdZej ZdddgiZfdZdZ de de e e e fd e e d e d e e d e e e e e fff d Zej j" dde de e e e fd e e e e e fffdZej j" ddede e e e fd e ee e e fffdZde e e fde e d e e e ffdZde de e e fd e e d dfdZej j.ddZedfd ZedZxZS)ra A dynamic quantized LSTM module with floating point tensor as inputs and outputs. We adopt the same interface as `torch.nn.LSTM`, please see https://pytorch.org/docs/stable/nn.html#torch.nn.LSTM for documentation. Examples:: >>> # xdoctest: +SKIP >>> rnn = nn.LSTM(10, 20, 2) >>> input = torch.randn(5, 3, 10) >>> h0 = torch.randn(2, 3, 20) >>> c0 = torch.randn(2, 3, 20) >>> output, (hn, cn) = rnn(input, (h0, c0)) forwardforward_packedforward_tensorc,t|dg|i|y)Nrr1r2r4argskwargsr5s rr2z LSTM.__init__s 1$1&1r cy)NDynamicQuantizedLSTMr|r}s rr~zLSTM._get_names%r rrrmax_batch_sizesorted_indicesrc |Z|jrdnd}tj|j|z||j|j |j }||f}n|j||}|j||||jDcgc]}|j} }|ptj||| |j|jt|j|j|j|j |j d } netj|||| |j|jt|j|j|j|j d } | d} | dd} | | fScc}w)NrKrLr-deviceT)r- use_dynamicr)rZr%zerosrVrUr-rrrrmr3quantized_lstmr,rXrYr\rW r4rrrrrrnrm _all_paramsresultoutputrs r forward_implzLSTM.forward_implso :"&"4"4Q!NKK.0  kk|| EB$$R8B r;7(,(?(?@1qww@ @  )) dll# ""  jj  F)) dll# ""jj  Fv~AAsF Ncd}|jr|jdn|jd}d}d}|j|||||\}}||j||fSNrrLrWrr"r r4rrrrrunsorted_indicesr!rs rr zLSTM.forward_tensorQm *.*:*:A 1 ** 2{NN t**63CDDDr c|\}}}}t|d}|j|||||\}} t||||} | |j| |fSNrrr"r r r4rrinput_rrr'routput_rr!s rr zLSTM.forward_packed`snAF= ^-=[^,++ B ^^  nFVWt**63CDDDr rcF||St|d|t|d|fSr$r#rs rrzLSTM.permute_hiddenos8  I!"Q%57I qE;8   r rc|j|||j||}|j|d|d|j|d|dy)Nrz"Expected hidden[0] size {}, got {}rLz"Expected hidden[1] size {}, got {}rrs rrzLSTM.check_forward_args{s_  ,#<* +9f% 9  9 !( 9 vuVV^,, -9v YYCG E E!)%*?!@ E vuVV^,, - E E YYKO E# E)1%2G)H E ~uVV^44 5 E E  &&. !  f%   vv~     ffn% f%     YY22   r rceZdZdZej ZdddgiZfdZdZ de de d e e d d fd Z de d e e d e e de de e d ee e ff dZej"j$ dde d e e d ee e ffdZej"j$ dded e e d eee ffdZd e de e d e fdZej"j.ddZedfd ZedZxZS)raxApplies a multi-layer gated recurrent unit (GRU) RNN to an input sequence. For each element in the input sequence, each layer computes the following function: .. math:: \begin{array}{ll} r_t = \sigma(W_{ir} x_t + b_{ir} + W_{hr} h_{(t-1)} + b_{hr}) \\ z_t = \sigma(W_{iz} x_t + b_{iz} + W_{hz} h_{(t-1)} + b_{hz}) \\ n_t = \tanh(W_{in} x_t + b_{in} + r_t \odot (W_{hn} h_{(t-1)}+ b_{hn})) \\ h_t = (1 - z_t) \odot n_t + z_t \odot h_{(t-1)} \end{array} where :math:`h_t` is the hidden state at time `t`, :math:`x_t` is the input at time `t`, :math:`h_{(t-1)}` is the hidden state of the layer at time `t-1` or the initial hidden state at time `0`, and :math:`r_t`, :math:`z_t`, :math:`n_t` are the reset, update, and new gates, respectively. :math:`\sigma` is the sigmoid function, and :math:`\odot` is the Hadamard product. In a multilayer GRU, the input :math:`x^{(l)}_t` of the :math:`l` -th layer (:math:`l >= 2`) is the hidden state :math:`h^{(l-1)}_t` of the previous layer multiplied by dropout :math:`\delta^{(l-1)}_t` where each :math:`\delta^{(l-1)}_t` is a Bernoulli random variable which is :math:`0` with probability :attr:`dropout`. Args: input_size: The number of expected features in the input `x` hidden_size: The number of features in the hidden state `h` num_layers: Number of recurrent layers. E.g., setting ``num_layers=2`` would mean stacking two GRUs together to form a `stacked GRU`, with the second GRU taking in outputs of the first GRU and computing the final results. Default: 1 bias: If ``False``, then the layer does not use bias weights `b_ih` and `b_hh`. Default: ``True`` batch_first: If ``True``, then the input and output tensors are provided as (batch, seq, feature). Default: ``False`` dropout: If non-zero, introduces a `Dropout` layer on the outputs of each GRU layer except the last layer, with dropout probability equal to :attr:`dropout`. Default: 0 bidirectional: If ``True``, becomes a bidirectional GRU. Default: ``False`` Inputs: input, h_0 - **input** of shape `(seq_len, batch, input_size)`: tensor containing the features of the input sequence. The input can also be a packed variable length sequence. See :func:`torch.nn.utils.rnn.pack_padded_sequence` for details. - **h_0** of shape `(num_layers * num_directions, batch, hidden_size)`: tensor containing the initial hidden state for each element in the batch. Defaults to zero if not provided. If the RNN is bidirectional, num_directions should be 2, else it should be 1. Outputs: output, h_n - **output** of shape `(seq_len, batch, num_directions * hidden_size)`: tensor containing the output features h_t from the last layer of the GRU, for each `t`. If a :class:`torch.nn.utils.rnn.PackedSequence` has been given as the input, the output will also be a packed sequence. For the unpacked case, the directions can be separated using ``output.view(seq_len, batch, num_directions, hidden_size)``, with forward and backward being direction `0` and `1` respectively. Similarly, the directions can be separated in the packed case. - **h_n** of shape `(num_layers * num_directions, batch, hidden_size)`: tensor containing the hidden state for `t = seq_len` Like *output*, the layers can be separated using ``h_n.view(num_layers, num_directions, batch, hidden_size)``. Shape: - Input1: :math:`(L, N, H_{in})` tensor containing input features where :math:`H_{in}=\text{input\_size}` and `L` represents a sequence length. - Input2: :math:`(S, N, H_{out})` tensor containing the initial hidden state for each element in the batch. :math:`H_{out}=\text{hidden\_size}` Defaults to zero if not provided. where :math:`S=\text{num\_layers} * \text{num\_directions}` If the RNN is bidirectional, num_directions should be 2, else it should be 1. - Output1: :math:`(L, N, H_{all})` where :math:`H_{all}=\text{num\_directions} * \text{hidden\_size}` - Output2: :math:`(S, N, H_{out})` tensor containing the next hidden state for each element in the batch Attributes: weight_ih_l[k] : the learnable input-hidden weights of the :math:`\text{k}^{th}` layer (W_ir|W_iz|W_in), of shape `(3*hidden_size, input_size)` for `k = 0`. Otherwise, the shape is `(3*hidden_size, num_directions * hidden_size)` weight_hh_l[k] : the learnable hidden-hidden weights of the :math:`\text{k}^{th}` layer (W_hr|W_hz|W_hn), of shape `(3*hidden_size, hidden_size)` bias_ih_l[k] : the learnable input-hidden bias of the :math:`\text{k}^{th}` layer (b_ir|b_iz|b_in), of shape `(3*hidden_size)` bias_hh_l[k] : the learnable hidden-hidden bias of the :math:`\text{k}^{th}` layer (b_hr|b_hz|b_hn), of shape `(3*hidden_size)` .. note:: All the weights and biases are initialized from :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` where :math:`k = \frac{1}{\text{hidden\_size}}` .. note:: The calculation of new gate :math:`n_t` subtly differs from the original paper and other frameworks. In the original implementation, the Hadamard product :math:`(\odot)` between :math:`r_t` and the previous hidden state :math:`h_{(t-1)}` is done before the multiplication with the weight matrix `W` and addition of bias: .. math:: \begin{aligned} n_t = \tanh(W_{in} x_t + b_{in} + W_{hn} ( r_t \odot h_{(t-1)} ) + b_{hn}) \end{aligned} This is in contrast to PyTorch implementation, which is done after :math:`W_{hn} h_{(t-1)}` .. math:: \begin{aligned} n_t = \tanh(W_{in} x_t + b_{in} + r_t \odot (W_{hn} h_{(t-1)}+ b_{hn})) \end{aligned} This implementation differs on purpose for efficiency. .. include:: ../cudnn_persistent_rnn.rst Examples:: >>> # xdoctest: +SKIP >>> rnn = nn.GRU(10, 20, 2) >>> input = torch.randn(5, 3, 10) >>> h0 = torch.randn(2, 3, 20) >>> output, hn = rnn(input, h0) r r r c,t|dg|i|y)Nrrrs rr2z GRU.__init__,s 000r cy)NDynamicQuantizedGRUr|r}s rr~z GRU._get_name/rr rrrrNcr|j|||j||}|j||dy)Nrrrs rrzGRU.check_forward_args2s>  ,#<._observe_and_quantize_weight>sB #"8":'*6<<>?K||~%r )rr%rkrrrrrrrrr-r&rrrTrUr,rdrr rrr[rrr\) rrrrr qRNNCellBasernr-rs @@rrzRNNCellBase.from_float s Cy HH   HH   HH     X X  X sI&V(VV& ;; "s{{'9'9'E%([[%7%7 " N%<%C%C "&(.."'++u}}!= . .B5'J  9)) )#chheL#Y%((** *"chheL#Y%((** *"XX -- L&4  xxx &*: ( 7e* &*: ( 7e* &r ct|dsJd t|dr@||j|j|j|j|j }n4||j|j|j|j }|j |jd|j|jdd}|j||S)Nweight_ih_dtypezWe are assuming weight_ih rdrX)rr)rrr) rrTrUr,rdrqget_quantized_weight_ihget_quantized_weight_hhrrr)rr@rArs rrBzRNNCellBase.from_referenceOsw 12P4PP2^ 7N +""## $$-- D""## -- D%<<>$<<> #??"??   -. r ciid}|jjd\}}|jjd\}}||dd<||dd<||dd<||dd<|S) Nrrrrrr,rr)r[rr\)r4rw1b1w2b2s rrzRNNCellBase._weight_biasos792,F''446q9B''446q9B35";/24";/.0 +.0 +r c(|jdSrrr}s rrzRNNCellBase.get_weight|rr c(|jdSrrr}s rrzRNNCellBase.get_biasrr ct|dd|dd|j|_t|dd|dd|j|_y)Nrrr,rrr)r rYr[r\)r4rs rrzRNNCellBase.set_weight_biassf"2 X &{ 3 V $Y /   "  "2 X &{ 3 V $Y /   " r cpt|||||j||dz<|j||dz<y)Nr[r\)r1r7r[r\r8s rr7zRNNCellBase._save_to_state_dicts@ #KC484J4J F001484J4J F001r c |j|dz|_|j|dz|_t||||d|||y)Nr[r\F)popr[r\r1r=r>s rr=z!RNNCellBase._load_from_state_dictsU",9L0L!M!+9L0L!M %        r )rr)rErFrG __constants__r%r&r2r~rrhrrrkr rrBrrrrr7r=rHrIs@rrrs9M-1Qekk12f))>@  !' 7:   CCJ>  -+  K   r rc~eZdZdZgdZddej ffd ZdZd de de e d e fd Z e d fd Z xZS)raeAn Elman RNN cell with tanh or ReLU non-linearity. A dynamic quantized RNNCell module with floating point tensor as inputs and outputs. Weights are quantized to 8 bits. We adopt the same interface as `torch.nn.RNNCell`, please see https://pytorch.org/docs/stable/nn.html#torch.nn.RNNCell for documentation. Examples:: >>> # xdoctest: +SKIP >>> rnn = nn.RNNCell(10, 20) >>> input = torch.randn(6, 3, 10) >>> hx = torch.randn(3, 20) >>> output = [] >>> for i in range(6): ... hx = rnn(input[i], hx) ... output.append(hx) )rTrUr,rdTrec<t||||d|||_y)NrLr]r-)r1r2rd)r4rTrUr,rdr-r5s rr2zRNNCell.__init__s% [$1ER(r cy)NDynamicQuantizedRNNCellr|r}s rr~zRNNCell._get_namerbr rrrc|j||Ftj|jd|j|j |j }|j||d|jdk(rXtjjj|||j|j|j|j}|S|jdk(rXtjjj!|||j|j|j|j}|S|}t#d|j)NrrrrereluzUnknown nonlinearity: )rhr%rrrUr-rrkrdr'r(quantized_rnn_tanh_cell_dynamicr[r\rrquantized_rnn_relu_cell_dynamicr)r4rrrets rr zRNNCell.forwards#   ' : 1 t//u{{5<<B !!%R0    &))%%EE&&&&  C(   & ())%%EE&&&&  C C!78I8I7JKL Lr c&t|||Sr6r7r8s rrzRNNCell.from_floatr9r rr)rErFrGrDrr%r&r2r~rrr r rrHrIs@rrrsZ JM-1vU[[) )V&)9V<  r rc peZdZdZfdZdZ d dedeeeefdeeeffdZ e d fd Z xZ S) raA long short-term memory (LSTM) cell. A dynamic quantized LSTMCell module with floating point tensor as inputs and outputs. Weights are quantized to 8 bits. We adopt the same interface as `torch.nn.LSTMCell`, please see https://pytorch.org/docs/stable/nn.html#torch.nn.LSTMCell for documentation. Examples:: >>> # xdoctest: +SKIP >>> rnn = nn.LSTMCell(10, 20) >>> input = torch.randn(6, 3, 10) >>> hx = torch.randn(3, 20) >>> cx = torch.randn(3, 20) >>> output = [] >>> for i in range(6): ... hx, cx = rnn(input[i], (hx, cx)) ... output.append(hx) c(t||ddi|y)Nr]rNrrs rr2zLSTMCell.__init__s $7177r cy)NDynamicQuantizedLSTMCellr|r}s rr~zLSTMCell._get_names)r rrrc|j||Jtj|jd|j|j |j }||f}|j||dd|j||ddtjjj|||j|j|j|jS)Nrrz[0]rLz[1])rhr%rrrUr-rrkr'r(quantized_lstm_cell_dynamicr[r\rr)r4rrrs rr zLSTMCell.forwards   ' :KK 1 t//u{{5<<EB !!%A6 !!%A6yy"">>    " "  " " LL LL   r c&t|||Sr6r7r8s rrzLSTMCell.from_floatr9r rr) rErFrGrDr2r~rrrr r rrHrIs@rrrsa&8*DH  !)%*?!@ vv~  (  r rcteZdZdZdej ffd ZdZd dede edefdZ e d fd Z xZ S) raUA gated recurrent unit (GRU) cell A dynamic quantized GRUCell module with floating point tensor as inputs and outputs. Weights are quantized to 8 bits. We adopt the same interface as `torch.nn.GRUCell`, please see https://pytorch.org/docs/stable/nn.html#torch.nn.GRUCell for documentation. Examples:: >>> # xdoctest: +SKIP >>> rnn = nn.GRUCell(10, 20) >>> input = torch.randn(6, 3, 10) >>> hx = torch.randn(3, 20) >>> output = [] >>> for i in range(6): ... hx = rnn(input[i], hx) ... output.append(hx) Tc.t||||d|y)NrOrr)r4rTrUr,r-r5s rr2zGRUCell.__init__5s [$1ERr cy)NDynamicQuantizedGRUCellr|r}s rr~zGRUCell._get_name8rbr rrrc|j||Ftj|jd|j|j |j }|j||dtjjj|||j|j|j|jS)Nrrr)rhr%rrrUr-rrkr'r(quantized_gru_cell_dynamicr[r\rrr3s rr zGRUCell.forward;s   ' : 1 t//u{{5<<B !!%R0yy""==    " "  " " LL LL   r c&t|||Sr6r7r8s rrzGRUCell.from_floatKr9r rr)rErFrGrDr%r&r2r~rrr r rrHrIs@rrr"sQ$6:S) V &)9 V   r r)rL)!r^rbtyping_extensionsrr%torch.nnrkrtorch._jit_internalrrrrr #torch.ao.nn.quantized.modules.utilsr torch.nn.utils.rnnr __all__rr FutureWarningrr Moduler rrrrrrrr|r rrs( BB@- 1v1F11V1 c 8f8688F8 8& ehhoo >_+ehhoo_+D k7k\F'FRu %((//u p> k> B2 {2 j- k- r