U Kcи @s>ddlZddlZddlZddlmZddlmZddlmZmZm Z m Z m Z ddl m Z ddlmZdddd d d d d dg ZdeeeedddZdeeeedddZddZGdddejjZGdddejjZGdd d eZGdd d eZGdd d ejjZGdd d eZGdd d eZGdddeZdS) N)Tensor)TupleOptionalListUnionDict)PackedSequence)_quantize_weightpack_weight_biasPackedParameterRNNBaseLSTMGRU RNNCellBaseRNNCellLSTMCellGRUCell)tensor permutationdimreturncCs |||SN)Z index_selectrrrrM/tmp/pip-unpacked-wheel-gikjz4vx/torch/ao/nn/quantized/dynamic/modules/rnn.py_apply_permutationsrcCstdt|||S)NzYapply_permutation is deprecated, please use tensor.index_select(dim, permutation) instead)warningswarnrrrrrapply_permutations rcCs6|tjkrtjj||}|Stjj||}|SdSr)torchqint8ops quantizedlinear_prepacklinear_prepack_fp16)qweightbiasdtype packed_weightrrrr s cs4eZdZfddZfddZfddZZS)r cstt|||_dSr)superr __init__param)selfr, __class__rrr++szPackedParameter.__init__cs&tt|||||j||d<dS)Nr,)r*r _save_to_state_dictr,r-Z destinationprefixZ keep_varsr.rrr0/sz#PackedParameter._save_to_state_dictc s.||d|_tt||||d|||dS)Nr,F)r,r*r _load_from_state_dictr- state_dictr2local_metadatastrict missing_keysunexpected_keys error_msgsr.rrr33s z%PackedParameter._load_from_state_dict)__name__ __module__ __qualname__r+r0r3 __classcell__rrr.rr *s  cs eZdZejZdZdddddejffdd Z dd Z d d Z d d Z e ee ddddZe ee eeeefdddZd*e eeeefeddddZe e ee ddddZe ee e dddZfddZd d!Zed"d#Zd$d%Zd&d'Zd(d)ZZS)+r rTFgc  sZtt|||_||_||_||_||_||_t ||_ ||_ | |_ d|_ d|_|r\dnd} t|tjrd|krdkrnn t|trtd|dkr|dkrtd|||dkrd|} n|d krd |} n td |g} t|D]P} t| D]@}| dkr|n|| }t| |tj }t| |tj }t| tj }t| tj }| tjkrtj|d dtjd }tj|d dtjd }tjj||}tjj||}|j dks|j dkrtjj ||||}ntjj ||||d}n0tjj!||}tjj!||}tjj"||}| #t$|qqtj%&| |_'dS)Nr?Frrzbdropout 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={} and num_layers={}r rzUnrecognized RNN mode: g?ZscaleZ zero_pointr(T)(r*r r+mode input_size hidden_size num_layersr' batch_firstfloatdropout bidirectionalr(versiontraining isinstancenumbersNumberbool ValueErrorrrformatranger randntor!quantize_per_tensorr"r#r$"make_quantized_cell_params_dynamicr%make_quantized_cell_params_fp16appendr nn ModuleList_all_weight_values)r-rCrDrErFr'rGrIrJr(num_directionsZ gate_sizer\layer directionZlayer_input_sizew_ihw_hhb_ihb_hh packed_ih packed_hh cell_paramsr.rrr+?s        zRNNBase.__init__cCsdS)NZDynamicQuantizedRNNrr-rrr _get_nameszRNNBase._get_namecCsld}|jdkr|d7}|jdk r(|d7}|jdk r:|d7}|jdkrL|d 7}|jdk r^|d 7}|jf|jS) N{input_size}, {hidden_size}rz, num_layers={num_layers}T , bias={bias}Fz, batch_first={batch_first}rz, dropout={dropout}z, bidirectional={bidirectional})rFr'rGrIrJrR__dict__r-srrr extra_reprs     zRNNBase.extra_reprc Csg}|}|r|d}g}|jD]H\}}t|ttjfrBq(t|}tj j |d}| d|d|q(||}| d}|rt|dkr|s||d7}n|dd|d7}|d7}|S) N r?(z): rrz ))rnsplitZ_modulesitemsrMr rZr[reprmodulesmoduleZ _addindentrYrhlenjoin) r-Z extra_linesrnZ child_lineskeyrvZmod_strlinesZmain_strrrr__repr__s&  zRNNBase.__repr__N)input batch_sizesrcCs\|dk r dnd}||kr0td|||j|dkrXtd|j|ddS)Nr?rAz%input must have {} dimensions, got {}z?input.size(-1) must be equal to input_size. Expected {}, got {})r RuntimeErrorrRrDsize)r-r|r}Zexpected_input_dimrrr check_inputs zRNNBase.check_inputcCsT|dk rt|d}n|jr&|dn|d}|jr:dnd}|j|||jf}|S)Nrrr?)intrGrrJrFrE)r-r|r}Z mini_batchr]expected_hidden_sizerrrget_expected_hidden_sizesz RNNBase.get_expected_hidden_sizeExpected hidden size {}, got {})hxrmsgrcCs(||kr$t||t|dSr)rrrRlist)r-rrrrrrcheck_hidden_sizes   zRNNBase.check_hidden_sizer|hiddenr}rcCs,||||||}|j||dddS)Nr)rrrrr-r|rr}rrrrcheck_forward_argss   zRNNBase.check_forward_argsrrrcCs|dkr |St||Srrr-rrrrrpermute_hiddenszRNNBase.permute_hiddenc s2|dd}||_tt||||d|||dS)NrKF)getrKr*r r3) r-r5r2r6r7r8r9r:rKr.rrr3s zRNNBase._load_from_state_dictc CsJdd}|jrdnd}g}t|jD]}t|D]}|dkrDdnd}|d||\}} |d||\} } ||} || } || }|| }| jtjkrtjj| | }tjj||}|j dks|j dkrtjj ||| |}ntjj ||| |d }n0tjj | | }tjj ||}tjj ||}| t|q2q$tj||_dS) NcSs$d|||}d|||}||fSNzweight_{}_l{}{}z bias_{}_l{}{})rR)ihhhr^suffix weight_name bias_namerrrweight_bias_namesz1RNNBase.set_weight_bias..weight_bias_namer?r_reverseihhhT)rJrSrFr(r r!r"r#r$rKrWr%rXrYr rZr[r\)r-weight_bias_dictrr]r\r^r_rZ w_ih_nameZ b_ih_nameZ w_hh_nameZ b_hh_namer`rbrarcrdrerfrrrset_weight_biassJ zRNNBase.set_weight_biasc sZtttjjtjjgks$tdtds6tdjdk rVjj dk rVjj nddl m }|j j }tj tjg}||krtd|jdkrtjjjjjjj|}n8jdkrtjjjjjjj|}ntd jrd nd }jstg}t|jD] t|D]}|d krFd nd fdd} | d\} } | d\} } |tj krfdd}|| | }|| | }|jdks|jd krtjj||| | }ntjj||| | d}nN|tjkr*tjj| | }tjj| | }tjj!||}ntd|"t#|q2q$tj$||_%|S)NzInn.quantized.dynamic.RNNBase.from_float only works for nn.LSTM and nn.GRUqconfig,Input float module must have qconfig definedrdefault_dynamic_qconfig2Unsupported dtype for dynamic RNN quantization: {}r rz3Only LSTM/GRU is supported for QuantizedRNN for nowr?rrrcs8d|}d|}t|}t|}||fSr)rRgetattr)rrrweightr')r^modrrrretrieve_weight_bias3s   z0RNNBase.from_float..retrieve_weight_biasrrcs0}||t||}tjj||}|Sr)r rHr r"r#r$)wbweight_observerr&r))weight_observer_methodrrquantize_and_pack>s z-RNNBase.from_float..quantize_and_packTz7Unsupported dtype specified for dynamic quantized LSTM!)&typesetr rZr rAssertionErrorhasattrrrtorch.ao.quantization.qconfigrr(r!float16rrRrCrDrErFr'rGrIrJNotImplementedErrorrSrKr"r#rWr%rHrXrYr r[r\)clsrrr(supported_scalar_typesZqRNNBaser]r\r_r weight_ihbias_ih weight_hhbias_hhrrdrerfr)r^rrrr from_floats             zRNNBase.from_floatc Csiid}d}|jrdnd}t|jD]}t|D]}|dkrBdnd}dj||d}d j||d}|j|jdd } | ddd|d |<| ddd|d |<d j||d}d j||d}| ddd|d|<| ddd|d|<|d}q2q&|S)Nrr'rr?rrrzweight_ih_l{layer_idx}{suffix})Z layer_idxrzweight_hh_l{layer_idx}{suffix}r@rzbias_ih_l{layer_idx}{suffix}zbias_hh_l{layer_idx}{suffix}r')rJrSrFrRr\r, __getstate__) r-rcountr]r^r_rZ key_name1Z key_name2Zpacked_weight_biasrrr _weight_bias_s"   zRNNBase._weight_biascCs |dSNrrrgrrr get_weightuszRNNBase.get_weightcCs |dSNr'rrgrrrget_biasxszRNNBase.get_bias)r)r;r<r=rZr _FLOAT_MODULE_versionr r!r+rhrnr{rrrrrrstrrrrr3r classmethodrrrrr>rrr.rr 9s<E    % Wc sZeZdZdZejZdddgiZfddZddZ e e e e e fe e e e e e e e e e ffd d d Zejjde e e e e fe e e e e ffd ddZejjdee e e e fe ee e e ffd ddZe e e fe e e e e fdddZe e e e fe e d dddZejjd ddZefddZeddZZS)!r a 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:: >>> 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_tensorcstt|jd||dS)Nr )r )r*r r+r-argskwargsr.rrr+sz LSTM.__init__cCsdS)NZDynamicQuantizedLSTMrrgrrrrhszLSTM._get_namer|rr}max_batch_sizesorted_indicesrc Cs|dkr@|jrdnd}tj|j|||j|j|jd}||f}n |||}||||dd|j D}|dkrtj ||||j |jt |j |j|j|j|jdd } n0tj |||||j |jt |j |j|j|jdd } | d} | dd} | | fS) Nr?rr(devicecSsg|] }|jqSrr,.0mrrr sz%LSTM.forward_impl..T)r(Z use_dynamicr)rJr zerosrFrEr(rrrr\Zquantized_lstmr'rHrIrLrG r-r|rr}rrr]rZ _all_paramsresultoutputrrrr forward_impls@    zLSTM.forward_implNr|rrc CsLd}|jr|dn|d}d}d}||||||\}}||||fSNrrrGrrr r-r|rr}rrunsorted_indicesrrrrrrszLSTM.forward_tensorc CsP|\}}}}|d}t|}||||||\}} t||||} | || |fSNrrrrr r-r|rZinput_r}rrrZoutput_rrrrrrs zLSTM.forward_packedrcCs(|dkr |St|d|t|d|fSrrrrrrrszLSTM.permute_hiddenrcCs@||||||}||d|d||d|ddS)Nrz"Expected hidden[0] size {}, got {}rz"Expected hidden[1] size {}, got {}rrrrrrs    zLSTM.check_forward_argscCs&t|tr|||S|||SdSrrMrrrr-r|rrrrrs  z LSTM.forwardcstt||Sr)r*r rrrr.rrrszLSTM.from_floatc CsJt|dstd||j|j|j|j|j|j|j|j }| | |S)Nweight_ih_l0_dtypezWe are assuming weight_ih_l0 ) rrrDrErFr'rGrIrJrrZget_quantized_weight_bias_dict)rref_modqmodrrrfrom_references zLSTM.from_reference)N)N)N)r;r<r=__doc__rZr r __overloads__r+rhrrrrrr jitexportrrrrrignorerrrrr>rrr.rr {sR          cseZdZdZejZdddgiZfddZddZ e e e e d d d d Z e e e e e e e e ee e fd ddZejjde e e ee e fdddZejjdee e eee fdddZe e e e dddZejjdddZefddZZS)raApplies 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 * (W_{hn} h_{(t-1)}+ b_{hn})) \\ h_t = (1 - z_t) * n_t + z_t * 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:`*` 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}}` .. include:: ../cudnn_persistent_rnn.rst Examples:: >>> rnn = nn.GRU(10, 20, 2) >>> input = torch.randn(5, 3, 10) >>> h0 = torch.randn(2, 3, 20) >>> output, hn = rnn(input, h0) rrrcstt|jd||dS)Nr)r)r*rr+rr.rrr+nsz GRU.__init__cCsdS)NZDynamicQuantizedGRUrrgrrrrhqsz GRU._get_nameNrcCs*||||||}|||ddS)Nrrrrrrrts   zGRU.check_forward_argsrc Cs|dkr<|jrdnd}tj|j|||j|j|jd}|}n |||}||||dd|j D}|dkrt ||||j |j|j |j |j|j } n$t |||||j |j|j |j |j } | d} | d} | | fS)Nr?rrcSsg|] }|jqSrrrrrrrsz$GRU.forward_impl..r)rJr rrFrEr(rrrr\Z quantized_grur'rIrLrGrrrrr{sH    zGRU.forward_implrc CsLd}|jr|dn|d}d}d}||||||\}}||||fSrrrrrrrszGRU.forward_tensorc CsP|\}}}}|d}t|}||||||\}} t||||} | || |fSrrrrrrrs zGRU.forward_packedrcCs|dkr |St||SrrrrrrrszGRU.permute_hiddencCs&t|tr|||S|||SdSrrrrrrrs  z GRU.forwardcstt||Sr)r*rrrr.rrrszGRU.from_float)N)N)N)r;r<r=rrZrrrr+rhrrrrrrr rrrrrrrrrrr>rrr.rrsFg   -     cseZdZdddgZddejffdd Zdd Zd d Zd d Z d#e e e ddddZ e ddZe ddZddZddZddZddZfdd Zfd!d"ZZS)$rrDrEr'Tr@c s@tt|||_||_||_||_|r`t||j tj d|_ t||j tj d|_ n| dd| ddt||| tj }t||| tj }|tjkrtj|ddtjd}tj|ddtjd}|tjkr tjj||j }tjj||j } n$tjj||j }tjj||j } ||_| |_dS)Nr(rrrrrB)r*rr+rDrEr' weight_dtyper rTrUrHrrZregister_parameterr!rVr"r#r$r%_packed_weight_ih_packed_weight_hh) r-rDrEr' num_chunksr(rrZpacked_weight_ihZpacked_weight_hhr.rrr+s<    zRNNCellBase.__init__cCsdS)NZDynamicQuantizedRNNBaserrgrrrrhszRNNCellBase._get_namecCsJd}d|jkr |jdk r |d7}d|jkr<|jdkr<|d7}|jf|jS)Nrir'Trj nonlinearitytanhz, nonlinearity={nonlinearity})rkr'rrRrlrrrrns zRNNCellBase.extra_reprcCs,|d|jkr(td|d|jdS)Nrz6input has inconsistent input_size: got {}, expected {})rrDrrR)r-r|rrrcheck_forward_inputszRNNCellBase.check_forward_inputrN)r|r hidden_labelrcCs`|d|dkr2td|d||d|d|jkr\td||d|jdS)Nrz8Input batch size {} doesn't match hidden{} batch size {}rz:hidden{} has inconsistent hidden_size: got {}, expected {})rrrRrE)r-r|rrrrrcheck_forward_hiddens z RNNCellBase.check_forward_hiddencsht|ttjjtjjtjjgks*tdt|ds._observe_and_quantize_weight)rrr rZrrrrrrrrrr(r!rrrRrDrEr'rrr rrrrrr)rrrrZ qRNNCellBaserrrrr s@      zRNNCellBase.from_floatcCst|dstdt|dr:||j|j|j|j|jd}n||j|j|j|jd}||d|j |j dd}| ||S)Nweight_ih_dtypezWe are assuming weight_ih rr)rr)rrr) rrrDrEr'rrZget_quantized_weight_ihZget_quantized_weight_hhrrr)rrrrrrrrRs0  zRNNCellBase.from_referencecCsbiid}|jd\}}|jd\}}||dd<||dd<||dd<||dd<|S) Nrrrrrr'rr)rrr)r-rZw1Zb1Zw2Zb2rrrrrs     zRNNCellBase._weight_biascCs |dSrrrgrrrrszRNNCellBase.get_weightcCs |dSrrrgrrrrszRNNCellBase.get_biascCsDt|dd|dd|j|_t|dd|dd|j|_dS)Nrrr'rrr)r rrr)r-rrrrrs    zRNNCellBase.set_weight_biascs4tt|||||j||d<|j||d<dS)Nrr)r*rr0rrr1r.rrr0szRNNCellBase._save_to_state_dictc s@||d|_||d|_tt||||d|||dS)NrrF)poprrr*rr3r4r.rrr3sz!RNNCellBase._load_from_state_dict)r)r;r<r= __constants__r r!r+rhrnrrrrrrrrrrrr0r3r>rrr.rrs  )  1   csfeZdZdZddddgZddejffdd Zd d Zde e e e d ddZ e fddZ ZS)raGAn 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:: >>> 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) rDrEr'rTrcs$tt|j|||d|d||_dS)Nrrr()r*rr+r)r-rDrEr'rr(r.rrr+szRNNCell.__init__cCsdS)NZDynamicQuantizedRNNCellrrgrrrrhszRNNCell._get_nameNrcCs|||dkr0tj|d|j|j|jd}|||d|jdkrjtj j |||j |j |j|j}n@|jdkrtj j |||j |j |j|j}n|}td|j|S)NrrrrZreluzUnknown nonlinearity: {})rr rrrEr(rrrr"r#Zquantized_rnn_tanh_cell_dynamicrrrrZquantized_rnn_relu_cell_dynamicrrR)r-r|rretrrrrs6    zRNNCell.forwardcstt||Sr)r*rrrr.rrrszRNNCell.from_float)N)r;r<r=rrr r!r+rhrrrrrr>rrr.rrs cs`eZdZdZfddZddZd eeeeefeeefddd Z e fd d Z Z S) ramA 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:: >>> 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) cstt|j|ddi|dS)Nrr@)r*rr+rr.rrr+szLSTMCell.__init__cCsdS)NZDynamicQuantizedLSTMCellrrgrrrrhszLSTMCell._get_nameNrcCs||||dkr8tj|d|j|j|jd}||f}|||dd|||ddtjj |||j |j |j |jS)Nrrz[0]rz[1])rr rrrEr(rrr"r#Zquantized_lstm_cell_dynamicrrrr)r-r|rrrrrrs zLSTMCell.forwardcstt||Sr)r*rrrr.rrrszLSTMCell.from_float)N) r;r<r=rr+rhrrrrrrr>rrr.rrs  ( csXeZdZdZdejffdd ZddZd ee eedd d Z e fd d Z Z S)ra7A 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:: >>> 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) Tcstt|j|||d|ddS)NrAr)r*rr+)r-rDrEr'r(r.rrr+ szGRUCell.__init__cCsdS)NZDynamicQuantizedGRUCellrrgrrrrhszGRUCell._get_nameNrcCs^|||dkr0tj|d|j|j|jd}|||dtjj |||j |j |j |jS)Nrrr)rr rrrEr(rrr"r#Zquantized_gru_cell_dynamicrrrrrrrrrs zGRUCell.forwardcstt||Sr)r*rrrr.rrrszGRUCell.from_float)N)r;r<r=rr r!r+rhrrrrrr>rrr.rrs  )r)r)rNrr Ztorch.nnrZrZtorch._jit_internalrrrrrZtorch.nn.utils.rnnrZ#torch.ao.nn.quantized.modules.utilsr __all__rrrr Moduler r r rrrrrrrrrs4    DVG3)