
    #hk              	          d dl Z d dlmZmZmZ d dlZd dlmZmZ d dlm	Z	  G d dej
        j                  Z G d dej
        j                  Z G d	 d
ej
        j                  Z G d de          Z G d de          Z G d de          Zd dedededefdZ G d dej
        j                  Z G d de          Z G d de          Zd Zej        fdZej        fdZdS )!    N)ListOptionalTuple)_VFTensor)PackedSequencec                        e Zd ZddgZ fdZej        j        d             Zej        j        d             Z	ej        j        d             Z
d Z xZS )QuantizedLinearscale
zero_pointc                 ~   t                                                       t          j        d           |j        | _        |j        | _        t          j        |j        	                    t          j
                                                            \  | _        | _        | _        | _        t          j                            | j        d          | _        t          j                            | j        d          | _        |j        
J d            t          j                            |j        	                    t          j
                                                  d          | _        |                     dt          j        | j        	                    t          j
                                       d S )Nztorch.jit.QuantizedLinear is deprecated and will be removed in an upcoming PyTorch release. Please use the torch.ao.nn.quantized.dynamic.Linear instead.memory_formatFrequires_gradzQuantizedLinear requires a biaspacked_tensor_ptr)super__init__warningswarnin_featuresout_featurestorchfbgemm_linear_quantize_weightweightclonecontiguous_formatfloatcol_offsetsr   r   nn	Parameterbiasregister_bufferfbgemm_pack_quantized_matrixselfother	__class__s     S/var/www/html/auto_sub_bot/venv/lib/python3.11/site-packages/torch/jit/quantized.pyr   zQuantizedLinear.__init__   s   \	
 	
 	

 !,!. /LU-DEEKKMM
 
	
KJO h((E(JJ 8--d.>e-TTz%%'H%%%H&&J5+BCCIIKK ' 
 
	
 	.!!0G!HH 	
 	
 	
 	
 	
    c                 h    | j                             t          j        | j                             d S N)r   set_r   r$   r   r&   s    r)   _unpackzQuantizedLinear._unpack.   s,    ##E$Ft{$S$STTTTTr*   c                     | j                             t          j        t          j                            t          t                   g           t          j                  	                                           d S N)dtype)
r   r-   r   zerosjitannotater   intuint8detachr.   s    r)   _packzQuantizedLinear._pack2   s]    ##K	**49b99MMMTTVV	
 	
 	
 	
 	
r*   c           	          t          j        |                                | j        | j        | j        | j        | j        | j                  }|	                    |j
                  S r,   )r   )fbgemm_linear_int8_weight_fp32_activationr   r   r   r   r   r   r"   tor2   r&   inputouts      r)   forwardzQuantizedLinear.forward8   sU    =KKMMK"JOI
 
 vvek"""r*   c                 *     dj         di | j        }|S )Nz^in_features={in_features}, out_features={out_features}, scale={scale}, zero_point={zero_point} format__dict__r&   reprs     r)   
extra_reprzQuantizedLinear.extra_reprE   s8    < 55;M M>BmM M 	 r*   )__name__
__module____qualname____constants__r   r   r4   script_methodr/   r9   r@   rH   __classcell__r(   s   @r)   r
   r
   
   s        l+M
 
 
 
 
B YU U U Y
 
 

 Y
# 
# 
#      r*   r
   c                        e Zd Z fdZej        j        d             Zej        j        d             Zej        j        d             Z	d Z
 xZS )QuantizedLinearFP16c                 b   t                                                       t          j        d           |j        | _        |j        | _        |j        | _        t          j	        |j        
                    t          j                                                            | _        |j        
J d            t          j                            |j        
                    t          j                                                  d          | _        |                     d| j                   d S )Nztorch.jit.QuantizedLinearFP16 is deprecated and will be removed in an upcoming PyTorch release. Please use the torch.ao.nn.quantized.dynamic.Linear instead.r   z#QuantizedLinearFP16 requires a biasFr   packed_weight)r   r   r   r   r   r   r   original_weightr   fbgemm_pack_gemm_matrix_fp16r   r   r   r"   r    r!   r#   r%   s     r)   r   zQuantizedLinearFP16.__init__O   s   \	
 	
 	
 !,!.$|8LU-DEEKKMM
 
 z%%'L%%%H&&J5+BCCIIKK ' 
 
	 	_dk:::::r*   c                 h    | j                             t          j        | j                             d S r,   )rS   r-   r   rU   rT   r.   s    r)   r/   zQuantizedLinearFP16._unpackb   s8    .t/CDD	
 	
 	
 	
 	
r*   c                     | j                             t          j        t          j                            t          t                   g           t          j                  	                                           d S r1   )
rS   r-   r   r3   r4   r5   r   r6   r7   r8   r.   s    r)   r9   zQuantizedLinearFP16._packh   s]    K	**49b99MMMTTVV	
 	
 	
 	
 	
r*   c                 j    t          j        |                                | j        | j                  }|S r,   )r   )fbgemm_linear_fp16_weight_fp32_activationr   rS   r"   r=   s      r)   r@   zQuantizedLinearFP16.forwardn   s/    =KKMM4-ty
 
 
r*   c                 *     dj         di | j        }|S )Nz8in_features={in_features}, out_features={out_features}, rB   rC   rF   s     r)   rH   zQuantizedLinearFP16.extra_repru   s-    PIP 
 
m
 
 r*   )rI   rJ   rK   r   r   r4   rM   r/   r9   r@   rH   rN   rO   s   @r)   rQ   rQ   N   s        ; ; ; ; ;& Y
 
 

 Y
 
 

 Y        r*   rQ   c            
            e Zd Zg dZ fdZd Zej        j        d             Z	ej        j        	 dde
de
ded	d
fd            Zej        j        d             Zej        j        d             Z xZS )QuantizedRNNCellBase)
input_sizehidden_sizer"   scale_hhscale_ihzero_point_ihzero_point_hhc                    t                                                       t          j        d           |j        | _        |j        | _        |j        | _        | j        st          d          t          j	        |j
                            t          j                                                            \  }}| _        | _        |                     d|           |                     d|           t          j	        |j                            t          j                                                            \  }}| _        | _        |                     d|           |                     d|           t          j        | j
                  }|                     d|           t          j        | j                  }|                     d	|           t          j                            |j                            t          j                                                  d
          | _        t          j                            |j                            t          j                                                  d
          | _        d S )Nztorch.jit.QuantizedRNNCellBase is deprecated and will be removed in an upcoming PyTorch release. Please use the torch.ao.nn.quantized.dynamic.RNNCell instead.z&Quantized RNN cells require bias termsr   	weight_ihcol_offsets_ih	weight_hhcol_offsets_hh	packed_ih	packed_hhFr   )r   r   r   r   r]   r^   r"   
ValueErrorr   r   rd   r   r   r   r`   ra   r#   rf   r_   rb   r$   r    r!   bias_ihbias_hh)	r&   r'   rd   re   rf   rg   rh   ri   r(   s	           r)   r   zQuantizedRNNCellBase.__init__   sG   ]	
 	
 	

  * ,J	y 	GEFFF /O!!0G!HHNNPP
 
	
M 	[)444-~>>> /O!!0G!HHNNPP
 
	
M 	[)444-~>>>6t~FF	[)4446t~FF	[)444x))Me.EFFLLNN * 
 
 x))Me.EFFLLNN * 
 
r*   c                     d}d| j         v r| j        dur|dz  }d| j         v r| j        dk    r|dz  } |j        di | j         S )	Nz{input_size}, {hidden_size}r"   Tz, bias={bias}nonlinearitytanhz, nonlinearity={nonlinearity}rB   )rE   r"   rn   rD   )r&   ss     r)   rH   zQuantizedRNNCellBase.extra_repr   si    )T]""ty'<'< AT]**t/@F/J/J00Aqx(($-(((r*   c                     |                     d          | j        k    r-t          d|                     d           d| j                   d S )N   z'input has inconsistent input_size: got , expected )sizer]   RuntimeError)r&   r>   s     r)   check_forward_inputz(QuantizedRNNCellBase.check_forward_input   sT    ::a==DO++e%**Q--eeTXTcee   ,+r*    r>   hxhidden_labelreturnNc           
      v   |                     d          |                     d          k    r>t          d|                     d           d| d|                     d                     |                     d          | j        k    r0t          d| d|                     d           d| j                   d S )	Nr   zInput batch size z doesn't match hiddenz batch size rr   hiddenz# has inconsistent hidden_size: got rs   )rt   ru   r^   )r&   r>   rx   ry   s       r)   check_forward_hiddenz)QuantizedRNNCellBase.check_forward_hidden   s     ::a==BGGAJJ&&nEJJqMMnnnnbdbibijkblblnn   771::)))sss"''RS**ssaeaqss   *)r*   c                     | j                             t          j        | j                             | j                            t          j        | j                             d S r,   )rh   r-   r   r$   rd   ri   rf   r.   s    r)   r/   zQuantizedRNNCellBase._unpack   sN    E>t~NNOOOE>t~NNOOOOOr*   c                    | j                             t          j        t          j                            t          t                   g           t          j                  	                                           | j
                            t          j        t          j                            t          t                   g           t          j                  	                                           d S r1   )rh   r-   r   r3   r4   r5   r   r6   r7   r8   ri   r.   s    r)   r9   zQuantizedRNNCellBase._pack   s    K	**49b99MMMTTVV	
 	
 	
 	K	**49b99MMMTTVV	
 	
 	
 	
 	
r*   )rw   )rI   rJ   rK   rL   r   rH   r   r4   rM   rv   r   strr}   r/   r9   rN   rO   s   @r)   r\   r\   }   s         M.
 .
 .
 .
 .
`) ) ) Y   Y=? !'7:	   " YP P P
 Y
 
 
 
 
 
 
r*   r\   c                   l     e Zd Zg dZ fdZej        j        ddede	e         defd            Z
 xZS )	QuantizedRNNCell)r]   r^   r"   r_   r`   ra   rb   rn   c                     t                                          |           t          j        d           |j        | _        d S )Nztorch.jit.QuantizedRNNCell is deprecated and will be removed in an upcoming PyTorch release. Please use the torch.ao.nn.quantized.dynamic.RNNCell instead.)r   r   r   r   rn   r%   s     r)   r   zQuantizedRNNCell.__init__   sH    ]	
 	
 	
 ".r*   Nr>   rx   rz   c                    |                      |           |:t          j        |                    d          | j        |j        |j                  }|                     ||d           | j        dk    r^t          j
        ||| j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j                  }n| j        dk    r^t          j        ||| j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j                  }n|}t1          d| j                   |S )Nr   r2   devicerw   ro   reluzUnknown nonlinearity: )rv   r   r3   rt   r^   r2   r   r}   rn   r   quantized_rnn_tanh_cellrd   rf   rk   rl   rh   ri   re   rg   r`   r_   ra   rb   quantized_rnn_relu_cellru   )r&   r>   rx   rets       r)   r@   zQuantizedRNNCell.forward   s]     ''':

1t/u{5<  B 	!!%R000&&-##"" CC  &((-##"" CC" CK8IKKLLL
r*   r,   )rI   rJ   rK   rL   r   r   r4   rM   r   r   r@   rN   rO   s   @r)   r   r      s        	 	 	M/ / / / / Y, ,V ,&)9 ,V , , , , , , , ,r*   r   c            
            e Zd Z fdZej        j        	 ddedee	eef                  de	eef         fd            Z
 xZS )QuantizedLSTMCellc                 r    t                                          |           t          j        d           d S )Nztorch.jit.QuantizedLSTMCell is deprecated and will be removed in an upcoming PyTorch release. Please use the torch.ao.nn.quantized.dynamic.LSTMCell instead.r   r   r   r   r%   s     r)   r   zQuantizedLSTMCell.__init__.  s?    ^	
 	
 	
 	
 	
r*   Nr>   rx   rz   c                    |                      |           |>t          j        |                    d          | j        |j        |j                  }||f}|                     ||d         d           |                     ||d         d           t          j	        ||| j
        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j                  S )Nr   r   z[0]rr   z[1])rv   r   r3   rt   r^   r2   r   r}   r   quantized_lstm_cellrd   rf   rk   rl   rh   ri   re   rg   r`   r_   ra   rb   )r&   r>   rx   r3   s       r)   r@   zQuantizedLSTMCell.forward5  s     	  ''':K

1t/u{5<  E B!!%A666!!%A666&NNLLNNMM
 
 	
r*   r,   )rI   rJ   rK   r   r   r4   rM   r   r   r   r@   rN   rO   s   @r)   r   r   -  s        
 
 
 
 
 YCG
 

!)%*?!@
	vv~	
 
 
 
 
 
 
 
r*   r   c                   d     e Zd Z fdZej        j        ddedee         defd            Z	 xZ
S )QuantizedGRUCellc                 r    t                                          |           t          j        d           d S )Nztorch.jit.QuantizedGRUCell is deprecated and will be removed in an upcoming PyTorch release. Please use the torch.ao.nn.quantized.dynamic.GRUCell instead.r   r%   s     r)   r   zQuantizedGRUCell.__init__T  s?    ]	
 	
 	
 	
 	
r*   Nr>   rx   rz   c                    |                      |           |:t          j        |                    d          | j        |j        |j                  }|                     ||d           t          j	        ||| j
        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j        | j                  S )Nr   r   rw   )rv   r   r3   rt   r^   r2   r   r}   r   quantized_gru_cellrd   rf   rk   rl   rh   ri   re   rg   r`   r_   ra   rb   r&   r>   rx   s      r)   r@   zQuantizedGRUCell.forward[  s      ''':

1t/u{5<  B 	!!%R000%NNLLNNMM
 
 	
r*   r,   )rI   rJ   rK   r   r   r4   rM   r   r   r@   rN   rO   s   @r)   r   r   S  s}        
 
 
 
 
 Y
 
V 
&)9 
V 
 
 
 
 
 
 
 
r*   r   rr   tensorpermutationdimrz   c                 .    |                      ||          S r,   )index_select)r   r   r   s      r)   apply_permutationr   u  s    sK000r*   c            
           e Zd Zg dZej        f fd	Zej        j        de	de
e	         ddfd            Zej        j        de	de
e	         deeeef         fd            Zej        j        	 dd
e	deeeef         deddfd            Zej        j        de	de	de
e	         ddfd            Zej        j        d
e	de
e	         de	fd            Z xZS )QuantizedRNNBase)	moder]   r^   
num_layersr"   batch_firstdropoutbidirectionalr2   c           	      *   t                                                       t          j        d           j        | _        j        | _        j        | _        j        | _        j        | _        j	        | _	        | j        dk    r	| j	        rJ j
        | _
        j        | _        | j        rdnd}|| _        | j        sJ | j        dk    r| j        dk    rt          d          |t          j        k    r"|t          j        k    rt          d|           g | _        t%          | j                  D ]Wt%          |          D ]C}dk    r| j        n	| j        |z  }|dk    rd	nd
fd} |d          \  }} |d          \  }	}
|t          j        k    r(t          j        j                            ||	||
          }nt          j        j                            |                                |          }t          j        j                            |	                                |
          }t          j        j                            ||          }t3          | d d |           | j                            |           EYd S )Nztorch.jit.QuantizedRNNBase is deprecated and will be removed in an upcoming PyTorch release. Please use the torch.ao.nn.quantized.dynamic instead.GRU   rr   LSTMz.Only LSTM or GRU is supported for QuantizedRNNUnsupported dtype: r   _reverserw   c                 t    d|  d  }d|  d  }t          |          }t          |          }||fS )Nweight__lbias_)getattr)ihhhweight_name	bias_namer   r"   layerr'   suffixs        r)   get_weight_biasz2QuantizedRNNBase.__init__.<locals>.get_weight_bias  s_    "CD"C"CE"C6"C"CK ? ? ? ?v ? ?I$UK88F"5)44D!4<'r*   ihhhcell_params__)r   r   r   r   r   r]   r^   r   r"   r   r   r   r2   ru   r   int8float16all_weightsrangeops	quantizedmake_quantized_cell_paramslinear_prepack_fp16r   make_quantized_cell_params_fp16setattrappend)r&   r'   r2   num_directions	directionlayer_input_sizer   rd   rk   rf   rl   cell_paramsrh   ri   r   r   r(   s    `            @@r)   r   zQuantizedRNNBase.__init__  s   U	
 	
 	
 J	* ,*J	 ,9''''}"0"07a
yy 949#5#5OPPPEJ5EM#9#9<U<<===4?++ $	5 $	5E">22 #5 #5	',zzDOOt7G.7X ! (1A~~2( ( ( ( ( ( ( &5_T%:%:"	7%4_T%:%:"	7EJ&&"')"5"P"P!9gw# #KK !&	 3 G G!))7! !I !&	 3 G G!))7! !I #()"5"U"U!9# #K =U==V=={KKK ''4444G#5$	5 $	5r*   r>   batch_sizesrz   Nc                 &   |dnd}|                                 |k    r't          d| d|                                            | j        |                    d          k    r-t          d| j         d|                    d                     d S )Nr      zinput must have z dimensions, got z5input.size(-1) must be equal to input_size. Expected z, got )r   ru   r]   rt   )r&   r>   r   expected_input_dims       r)   check_inputzQuantizedRNNBase.check_input  s    "-"9QQq99;;,,,U#5UU		UU   ?ejjnn,,ooo_d_i_ijl_m_moo   -,r*   c                     |t          |d                   }n1| j        r|                    d          n|                    d          }| j        rdnd}| j        |z  || j        f}|S )Nr   rr   r   )r6   r   rt   r   r   r^   )r&   r>   r   
mini_batchr   expected_hidden_sizes         r)   get_expected_hidden_sizez)QuantizedRNNBase.get_expected_hidden_size  sv     "[^,,JJ*.*:MA

1J"07aOn, 

 $#r*   Expected hidden size {}, got {}rx   r   msgc           	          |                                 |k    rBt          |                    |t          |                                                               d S r,   )rt   ru   rD   list)r&   rx   r   r   s       r)   check_hidden_sizez"QuantizedRNNBase.check_hidden_size  sK     7799,,,szz*>RWWYYPPQQQ -,r*   r|   c                     |                      ||           |                     ||          }|                     ||d           d S )Nr   )r   r   r   r   r&   r>   r|   r   r   s        r)   check_forward_argsz#QuantizedRNNBase.check_forward_args  s`     	,,,#<<UKPP(.O 	 	
 	
 	
 	
 	
r*   r   c                 *    ||S t          ||          S r,   r   r&   rx   r   s      r)   permute_hiddenzQuantizedRNNBase.permute_hidden  s    I [111r*   )r   )rI   rJ   rK   rL   r   r   r   r4   rM   r   r   r   r   r6   r   r   r   r   r   rN   rO   s   @r)   r   r   y  s       
 
 
M %*J A5 A5 A5 A5 A5 A5F Y	 	hv6F 	4 	 	 	 	 Y$$*26*:$	sC}	$ $ $ $ Y
 5	R RR $CcM2R 	R
 
R R R R Y

%+
:B6:J
	
 
 
 
 Y2 2hv6F 26 2 2 2 2 2 2 2 2r*   r   c                   v    e Zd ZdddgiZ fdZej        j        dede	e
eef                  de	e         ded	e	e         d
e
ee
eef         f         fd            Zej        j        	 ddede	e
eef                  d
e
ee
eef         f         fd            Zej        j        	 ddede	e
eef                  d
e
ee
eef         f         fd            Zej        j        de
eef         de	e         d
e
eef         fd            Zej        j        dede
eef         de	e         d
dfd            ZddZ xZS )QuantizedLSTMr@   forward_packedforward_tensorc                 t    t                                          ||           t          j        d           d S )Nztorch.jit.QuantizedLSTM is deprecated and will be removed in an upcoming PyTorch release. Please use the torch.ao.nn.quantized.dynamic.LSTM instead.r   )r&   r'   r2   r(   s      r)   r   zQuantizedLSTM.__init__  sA    &&&Z	
 	
 	
 	
 	
r*   r>   rx   r   max_batch_sizesorted_indicesrz   c                    |@| j         rdnd}t          j        | j        |z  || j        |j        |j                  }||f}n|                     ||          }|                     |||           |J t          j	        ||| j
        | j        | j        t          | j                  | j        | j         | j        | j        d          }|d         }	|dd          }
|	|
fS )Nr   rr   r   F)r2   use_dynamicr   )r   r   r3   r   r^   r2   r   r   r   quantized_lstmr   r"   r   r   trainingr   )r&   r>   rx   r   r   r   r   r3   resultoutputr|   s              r)   forward_implzQuantizedLSTM.forward_impl
  s
    :"&"4;QQ!NK.0 k|  E BB $$R88Br;777"""%IO$,M*
 
 
 v~r*   Nc                     d }| j         r|                    d          n|                    d          }d }d }|                     |||||          \  }}||                     ||          fS Nr   rr   r   rt   r   r   	r&   r>   rx   r   r   r   unsorted_indicesr   r|   s	            r)   r   zQuantizedLSTM.forward_tensor6  s{     *.*:MA

1**2{NN
 
 t**63CDDDDr*   c                     |\  }}}}t          |d                   }|                     |||||          \  }}	t          ||||          }||                     |	|          fS Nr   r6   r   r   r   
r&   r>   rx   input_r   r   r   r   r   r|   s
             r)   r   zQuantizedLSTM.forward_packedE  |     AF=^-=[^,,**B^^
 
  ^EUVVt**63CDDDDr*   r   c                 b    ||S t          |d         |          t          |d         |          fS r   r   r   s      r)   r   zQuantizedLSTM.permute_hiddenS  s@     I A446GqE;7
 7
 
 	
r*   r|   c                     |                      ||           |                     ||          }|                     |d         |d           |                     |d         |d           d S )Nr   z"Expected hidden[0] size {}, got {}rr   z"Expected hidden[1] size {}, got {}r   r   s        r)   r   z QuantizedLSTM.check_forward_args]  s     	,,,#<<UKPP1I+-Q	
 	
 	
 	1I+-Q	
 	
 	
 	
 	
r*   c                     t          |t                    r|                     ||          S |                     ||          S r,   
isinstancer   r   r   r   s      r)   r@   zQuantizedLSTM.forwardn  @    e^,, 	2&&ub111&&ub111r*   r,   )rI   rJ   rK   __overloads__r   r   r4   rM   r   r   r   r6   r   r   r   r   r   r   r@   rN   rO   s   @r)   r   r      sv       !13C DEM
 
 
 
 
 Y)) U66>*+) f%	)
 ) !() 
vuVV^,,	-) ) ) )V YCGE EE!)%*?!@E	vuVV^,,	-E E E E YKOE E#E)1%2G)HE	~uVV^44	5E E E E Y
'
6>v6F
	vv~	
 
 
 
 Y

 ffn%
 f%	

 

 
 
 
 2 2 2 2 2 2 2 2r*   r   c                   Z    e Zd ZdddgiZ fdZej        j        dede	e         de	e         de
d	e	e         d
eeef         fd            Zej        j        	 ddede	e         d
eeef         fd            Zej        j        	 ddede	e         d
eeef         fd            ZddZ xZS )QuantizedGRUr@   r   r   c                 b     t                      j        |i | t          j        d           d S )Nztorch.jit.QuantizedGRU is deprecated and will be removed in an upcoming PyTorch release. Please use the torch.ao.nn.quantized.dynamic.GRU instead.r   )r&   argskwargsr(   s      r)   r   zQuantizedGRU.__init__x  sC    $)&)))Y	
 	
 	
 	
 	
r*   r>   rx   r   r   r   rz   c                 ,   |<| j         rdnd}t          j        | j        |z  || j        |j        |j                  }n|                     ||          }|                     |||           |Mt          j	        ||| j
        | j        | j        t          | j                  | j        | j         | j        	  	        }nGt          j	        |||| j
        | j        | j        t          | j                  | j        | j         	  	        }|d         }|d         }	||	fS )Nr   rr   r   r   )r   r   r3   r   r^   r2   r   r   r   quantized_grur   r"   r   r   r   r   )
r&   r>   rx   r   r   r   r   r   r   r|   s
             r)   r   zQuantizedGRU.forward_impl  s/    :"&"4;QQ!N.0 k|  BB $$R88Br;777( 	dl##" 
 
FF ( 	dl##"
 
F v~r*   Nc                     d }| j         r|                    d          n|                    d          }d }d }|                     |||||          \  }}||                     ||          fS r   r   r   s	            r)   r   zQuantizedGRU.forward_tensor  s{     *.*:MA

1**2{NN
 
 t**63CDDDDr*   c                     |\  }}}}t          |d                   }|                     |||||          \  }}	t          ||||          }||                     |	|          fS r   r   r   s
             r)   r   zQuantizedGRU.forward_packed  r   r*   c                     t          |t                    r|                     ||          S |                     ||          S r,   r   r   s      r)   r@   zQuantizedGRU.forward  r   r*   r,   )rI   rJ   rK   r   r   r   r4   rM   r   r   r6   r   r   r   r   r   r@   rN   rO   s   @r)   r   r   u  s       !13C DEM
 
 
 
 
 Y33 V3 f%	3
 3 !(3 
vv~	3 3 3 3j Y48E EE!)&!1E	vv~	E E E E Y<@E E#E)1&)9E	~v%	&E E E E2 2 2 2 2 2 2 2r*   r   c                 
   t          j        d           i }|                                 D ]"\  }}|| u r
t          |          }||ur|||<   #|                                D ]\  }}t          | ||           t          | t          j        j	                  rt          |           S t          | t          j        j                  rt          |           S t          | t          j        j                  rt          |           S | S )Nzvquantize_rnn_cell_modules function has been deprecated. Please use torch.ao.quantization.quantize_dynamic API instead.)r   r   named_modulesquantize_rnn_cell_modulesitemsr   r   r   r    LSTMCellr   GRUCellr   RNNCellr   )modulereassignnamemodnew_mods        r)   r  r    s   M	I   H))++ % %	c&==+C00#$HTN^^%% # #	cc""""&%(+,, ) (((&%(*++ ('''&%(*++ ('''Mr*   c                    t          j        d           i }|                                 D ]#\  }}|| u r
t          ||          }||ur|||<   $|                                D ]\  }}t          | ||           t          | t          j        j	                  rP|t          j
        k    rt          |           S |t          j        k    rt          |           S t          d|           | S )Nztquantize_linear_modules function has been deprecated. Please use torch.ao.quantization.quantize_dynamic API instead.r   )r   r   r
  quantize_linear_modulesr  r   r   r   r    Linearr   r
   r   rQ   ru   r  r2   r  r  r  r  s         r)   r  r    s   M	I  
 H))++ % %	c&==)#u55#$HTN^^%% # #	cc""""&%(/** >EJ"6***em##&v...<U<<===Mr*   c                    t          j        d           i }|                                 D ]#\  }}|| u r
t          ||          }||ur|||<   $|                                D ]\  }}t          | ||           t          | t          j        j	                  rB|t          j
        k    r"|t          j        k    rt          d|           t          | |          S t          | t          j        j                  rt          |           S | S )Nzqquantize_rnn_modules function has been deprecated. Please use torch.ao.quantization.quantize_dynamic API instead.r   )r   r   r
  quantize_rnn_modulesr  r   r   r   r    r   r   r   ru   r   r   r   r  s         r)   r  r  	  s#   M	I   H))++ % %	c&==&sE22#$HTN^^%% # #	cc""""&%(-(( ,EJ5EM#9#9<U<<===VU+++&%(,'' $F###Mr*   )rr   )r   typingr   r   r   r   r   r   torch.nn.utils.rnnr   r4   ScriptModuler
   rQ   r\   r   r   r   r6   r   r   r   r   r  r   r  r  rB   r*   r)   <module>r     s    ( ( ( ( ( ( ( ( ( (          - - - - - -@ @ @ @ @ei, @ @ @H+ + + + +%)0 + + +^i
 i
 i
 i
 i
591 i
 i
 i
XA A A A A+ A A AH#
 #
 #
 #
 #
, #
 #
 #
L
 
 
 
 
+ 
 
 
D1 1f 16 1 1F 1 1 1 1D2 D2 D2 D2 D2uy- D2 D2 D2Nr2 r2 r2 r2 r2$ r2 r2 r2j`2 `2 `2 `2 `2# `2 `2 `2F  . +0*    4 (-z      r*   