
    Phn              	          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j0                  fdZej0                  fdZy)     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                  j                  t        j                        j                               \  | _        | _        | _        | _        t        j                  j!                  | j                  d      | _        t        j                  j!                  | j                  d      | _        |j"                  J d       t        j                  j!                  |j"                  j                  t        j                        j                         d      | _        | j%                  dt        j&                  | j                  j                  t        j                                     y )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     ^C:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\site-packages\torch/jit/quantized.pyr   zQuantizedLinear.__init__   sc   \	

 !,,!.. //LLU-D-DEKKM
	
KJO hh((E(J 88--d.>.>e-Tzz%H'HH%HH&&JJ5+B+BCIIK ' 
	
 	..!!0G0G!H	
    c                 t    | j                   j                  t        j                  | j                               y N)r   set_r   r$   r   r&   s    r)   _unpackzQuantizedLinear._unpack.   s%    ##E$F$Ft{{$STr*   c                     | j                   j                  t        j                  t        j                  j                  t        t           g       t        j                        j                                y N)dtype)
r   r-   r   zerosjitannotater   intuint8detachr.   s    r)   _packzQuantizedLinear._pack2   sF    ##KK		**49b9MTTV	
r*   c           	         t        j                  |j                         | 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   s^    ==KKMKK""JJOOII
 vvekk""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   s0    < 55;VM>BmmM 	 r*   )__name__
__module____qualname____constants__r   r   r4   script_methodr/   r9   r@   rH   __classcell__r(   s   @r)   r
   r
   
   st    l+M
B YYU U YY
 

 YY
# 
#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                 h   t         |           t        j                  d       |j                  | _        |j
                  | _        |j                  | _        t        j                  |j                  j                  t        j                        j                               | _        |j                  J d       t        j                  j                  |j                  j                  t        j                        j                         d      | _        | j!                  d| j                         y )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8LLU-D-DEKKM
 zz%L'LL%HH&&JJ5+B+BCIIK ' 
	 	_dkk:r*   c                 t    | j                   j                  t        j                  | j                               y r,   )rS   r-   r   rU   rT   r.   s    r)   r/   zQuantizedLinearFP16._unpackb   s*    ..t/C/CD	
r*   c                     | j                   j                  t        j                  t        j                  j                  t        t           g       t        j                        j                                y r1   )
rS   r-   r   r3   r4   r5   r   r6   r7   r8   r.   s    r)   r9   zQuantizedLinearFP16._packh   sF    KK		**49b9MTTV	
r*   c                 x    t        j                  |j                         | j                  | j                        }|S r,   )r   )fbgemm_linear_fp16_weight_fp32_activationr   rS   r"   r=   s      r)   r@   zQuantizedLinearFP16.forwardn   s0    ==KKM4--tyy
 
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P 
mm
 r*   )rI   rJ   rK   r   r   r4   rM   r/   r9   r@   rH   rN   rO   s   @r)   rQ   rQ   N   sg    ;& YY
 

 YY
 

 YY 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                  j                  t        j                        j                               \  }}| _        | _        | j!                  d|       | j!                  d|       t        j                  |j"                  j                  t        j                        j                               \  }}| _        | _        | j!                  d|       | j!                  d|       t        j(                  | j                        }| j!                  d|       t        j(                  | j"                        }| j!                  d	|       t        j*                  j-                  |j.                  j                  t        j                        j                         d
      | _        t        j*                  j-                  |j0                  j                  t        j                        j                         d
      | _        y )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__   s   ]	

  ** ,,JJ	yyEFF //OO!!0G0G!HNNP
	
M 	[)4-~> //OO!!0G0G!HNNP
	
M 	[)4-~>66t~~F	[)466t~~F	[)4xx))MMe.E.EFLLN * 
 xx))MMe.E.EFLLN * 
r*   c                     d}d| j                   v r| j                  dur|dz  }d| j                   v r| j                  dk7  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   sd    )T]]"tyy'< AT]]*t/@/@F/J00Aqxx($--((r*   c                     |j                  d      | j                  k7  r*t        d|j                  d       d| j                         y )N   z'input has inconsistent input_size: got , expected )sizer]   RuntimeError)r&   r>   s     r)   check_forward_inputz(QuantizedRNNCellBase.check_forward_input   sH    ::a=DOO+9%**Q-TXTcTcSde  ,r*   r>   hxhidden_labelreturnNc           
      D   |j                  d      |j                  d      k7  r2t        d|j                  d       d| d|j                  d             |j                  d      | j                  k7  r-t        d| d|j                  d       d| j                         y )	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>   rw   rx   s       r)   check_forward_hiddenz)QuantizedRNNCellBase.check_forward_hidden   s     ::a=BGGAJ&#EJJqM?2G~Uabdbibijkblamn  771:)))&I"''RS*U`aeaqaq`rs  *r*   c                     | j                   j                  t        j                  | j                               | j
                  j                  t        j                  | j                               y r,   )rh   r-   r   r$   rd   ri   rf   r.   s    r)   r/   zQuantizedRNNCellBase._unpack   sD    E>>t~~NOE>>t~~NOr*   c                    | j                   j                  t        j                  t        j                  j                  t        t           g       t        j                        j                                | j                  j                  t        j                  t        j                  j                  t        t           g       t        j                        j                                y r1   )rh   r-   r   r3   r4   r5   r   r6   r7   r8   ri   r.   s    r)   r9   zQuantizedRNNCellBase._pack   s    KK		**49b9MTTV	
 	KK		**49b9MTTV	
r*   ) )rI   rJ   rK   rL   r   rH   r   r4   rM   rv   r   strr|   r/   r9   rN   rO   s   @r)   r\   r\   }   s    M.
`) YY  YY=?!'7:	 " YYP P
 YY
 
r*   r\   c                   t     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                 p    t         |   |       t        j                  d       |j                  | _        y )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__   s2    ]	
 "..r*   r>   rw   ry   c                    | j                  |       |Ft        j                  |j                  d      | j                  |j
                  |j                        }| j                  ||d       | j                  dk(  rt        j                  ||| j                  | j                  | j                  | j                  | j                  | j                   | j"                  | j$                  | j&                  | j(                  | j*                  | j,                        }|S | j                  dk(  rt        j.                  ||| j                  | j                  | j                  | j                  | j                  | j                   | j"                  | j$                  | j&                  | j(                  | j*                  | j,                        }|S |}t1        d| j                         )Nr   r2   devicer   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>   rw   rets       r)   r@   zQuantizedRNNCell.forward   s     ':

1t//u{{5<<B 	!!%R0&--####""""CH 
) &(--####""""C& 
 C!78I8I7JKLLr*   r,   )rI   rJ   rK   rL   r   r   r4   rM   r   r   r@   rN   rO   s   @r)   r   r      sG    	M/ YY,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                 N    t         |   |       t        j                  d       y )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*   r>   rw   ry   c                 H   | j                  |       |Jt        j                  |j                  d      | j                  |j
                  |j                        }||f}| j                  ||d   d       | j                  ||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>   rw   r3   s       r)   r@   zQuantizedLSTMCell.forward5  s     	  ':KK

1t//u{{5<<E B!!%A6!!%A6&&NNNNLLLLNNNNMMMM
 	
r*   r,   )rI   rJ   rK   r   r   r4   rM   r   r   r   r@   rN   rO   s   @r)   r   r   -  sX    
 YYCG

!)%*?!@
	vv~	
 
r*   r   c                   l     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                 N    t         |   |       t        j                  d       y )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*   r>   rw   ry   c                    | j                  |       |Ft        j                  |j                  d      | j                  |j
                  |j                        }| j                  ||d       t        j                  ||| j                  | j                  | j                  | j                  | j                  | j                  | j                   | j"                  | j$                  | j&                  | j(                  | j*                        S )Nr   r   r   )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>   rw   s      r)   r@   zQuantizedGRUCell.forward[  s      ':

1t//u{{5<<B 	!!%R0%%NNNNLLLLNNNNMMMM
 	
r*   r,   )rI   rJ   rK   r   r   r4   rM   r   r   r@   rN   rO   s   @r)   r   r   S  s@    
 YY
V 
&)9 
V 
 
r*   r   tensorpermutationdimry   c                 &    | j                  ||      S r,   )index_select)r   r   r   s      r)   apply_permutationr   u  s    sK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k7  r| j                  rJ j                  | _
        j                  | _        | j                  rdnd}|| _        | j                  sJ | j                  dk7  r| j                  dk7  rt        d      |t        j                  k7  r!|t        j                   k7  rt        d|       g | _        t%        | j                        D ]c  t%        |      D ]Q  }dk(  r| j
                  n| j                  |z  }|dk(  rd	nd
fd} |d      \  }} |d      \  }	}
|t        j                  k(  r-t        j&                  j(                  j+                  ||	||
      }nt        j&                  j(                  j-                  |j/                         |      }t        j&                  j(                  j-                  |	j/                         |
      }t        j&                  j(                  j1                  ||      }t3        | d d |       | j"                  j5                  |       T f y )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   _reverser   c                 d    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  sQ    $+D6E76("CK"'vRwvh ?I$UK8F"5)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	
 JJ	** ,,**JJ	 ,,99''''}}"00"00a
yyy 99499#5OPPEJJ5EMM#9!4UG<==4??+E">2	',zDOOt7G7G.7X ! (1A~2( &5T%:"	7%4T%:"	7EJJ&"'))"5"5"P"P!9gw#K !&		 3 3 G G!)7!I !&		 3 3 G G!)7!I #())"5"5"U"U!9#K UG1VH={K  ''4G 3 ,r*   r>   batch_sizesry   Nc                    |dnd}|j                         |k7  rt        d| d|j                                | j                  |j                  d      k7  r*t        d| j                   d|j                  d             y )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    "-"9Qq99;,,"#5"66G		}U  ??ejjn,GGXX^_d_i_ijl_m^no  -r*   c                     |t        |d         }n.| j                  r|j                  d      n|j                  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  sn     "[^,J*.*:*:A

1J"00aOOn, 

 $#r*   rw   r   msgc           	          |j                         |k7  r2t        |j                  |t        |j                                           y r,   )rt   ru   rD   list)r&   rw   r   r   s       r)   check_hidden_sizez"QuantizedRNNBase.check_hidden_size  s9     779,,szz*>RWWYPQQ -r*   r{   c                 t    | j                  ||       | j                  ||      }| j                  ||d       y )NExpected hidden size {}, got {})r   r   r   r   r&   r>   r{   r   r   s        r)   check_forward_argsz#QuantizedRNNBase.check_forward_args  sC     	,#<<UKP(.O 	 	
r*   r   c                 "    ||S t        ||      S r,   r   r&   rw   r   s      r)   permute_hiddenzQuantizedRNNBase.permute_hidden  s    I [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  sm   
M %*JJ A5F YY	 	hv6F 	4 	 	 YY$$*26*:$	sC}	$ $ YY
 5	RR $CcM2R 	R
 
R R YY

%+
:B6:J
	
 
 YY2 2hv6F 26 2 2r*   r   c                   J    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                 P    t         |   ||       t        j                  d       y )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__  s$    &Z	
r*   r>   rw   r   max_batch_sizesorted_indicesry   c                    |Z| j                   rdnd}t        j                  | j                  |z  || j                  |j
                  |j                        }||f}n| j                  ||      }| j                  |||       |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>   rw   r   r   r   r   r3   resultoutputr{   s              r)   forward_implzQuantizedLSTM.forward_impl
  s    :"&"4"4Q!NKK.0  kk||E B $$R8Br;7"""%%IIOO$,,MM**
 v~r*   Nc                     d }| j                   r|j                  d      n|j                  d      }d }d }| j                  |||||      \  }}|| j                  ||      fS Nr   rr   r   rt   r   r   	r&   r>   rw   r   r   r   unsorted_indicesr   r{   s	            r)   r   zQuantizedLSTM.forward_tensor6  sm     *.*:*:A

1**2{NN
 t**63CDDDr*   c                     |\  }}}}t        |d         }| j                  |||||      \  }}	t        ||||      }|| j                  |	|      fS Nr   r6   r   r   r   
r&   r>   rw   input_r   r   r   r   r   r{   s
             r)   r   zQuantizedLSTM.forward_packedE  n     AF=^-=[^,**B^^
  ^EUVt**63CDDDr*   r   c                 F    ||S t        |d   |      t        |d   |      fS r   r   r   s      r)   r   zQuantizedLSTM.permute_hiddenS  s8     I A46GqE;7
 
 	
r*   r{   c                     | j                  ||       | j                  ||      }| j                  |d   |d       | j                  |d   |d       y )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1I+-Q	
 	1I+-Q	
r*   c                 j    t        |t              r| j                  ||      S | j                  ||      S r,   
isinstancer   r   r   r   s      r)   r@   zQuantizedLSTM.forwardn  2    e^,&&ub11&&ub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      s   !13C DEM
 YY)) U66>*+) f%	)
 ) !() 
vuVV^,,	-) )V YYCGEE!)%*?!@E	vuVV^,,	-E E YYKOE#E)1%2G)HE	~uVV^44	5E E YY
'
6>v6F
	vv~	
 
 YY

 ffn%
 f%	

 

 
 2r*   r   c                   T    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                 N    t        |   |i | t        j                  d       y )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  s'    $)&)Y	
r*   r>   rw   r   r   r   ry   c                    |V| j                   rdnd}t        j                  | j                  |z  || j                  |j
                  |j                        }n| j                  ||      }| j                  |||       |mt        j                  ||| j                  | j                  | j                  t        | j                        | j                  | j                   | j                  	      }nbt        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>   rw   r   r   r   r   r   r   r{   s
             r)   r   zQuantizedGRU.forward_impl  s6    :"&"4"4Q!N.0  kk||B $$R8Br;7((  		dll#""  
F ((  		dll#""
F v~r*   c                     d }| j                   r|j                  d      n|j                  d      }d }d }| j                  |||||      \  }}|| j                  ||      fS r   r   r   s	            r)   r   zQuantizedGRU.forward_tensor  sm     *.*:*:A

1**2{NN
 t**63CDDDr*   c                     |\  }}}}t        |d         }| j                  |||||      \  }}	t        ||||      }|| j                  |	|      fS r   r   r   s
             r)   r   zQuantizedGRU.forward_packed  r   r*   c                 j    t        |t              r| j                  ||      S | j                  ||      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
 YY33 V3 f%	3
 3 !(3 
vv~	3 3j YY48EE!)&!1E	vv~	E E YY<@E#E)1&)9E	~v%	&E E2r*   r   c                    t        j                  d       i }| j                         D ]  \  }}|| u rt        |      }||us|||<   ! |j	                         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    MM	I H))+	c&=+C0#$HTN , ^^%	cc" &&%((++, ((&%((**+''&%((**+''Mr*   c                    t        j                  d       i }| j                         D ]   \  }}|| u rt        ||      }||us|||<   " |j	                         D ]  \  }}t        | ||        t        | t        j                  j                        rJ|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    MM	I
 H))+	c&=)#u5#$HTN , ^^%	cc" &&%((//*EJJ"6**emm#&v..!4UG<==Mr*   c                 
   t        j                  d       i }| j                         D ]   \  }}|| u rt        ||      }||us|||<   " |j	                         D ]  \  }}t        | ||        t        | t        j                  j                        r@|t        j                  k7  r!|t        j                  k7  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    MM	I H))+	c&=&sE2#$HTN , ^^%	cc" &&%((--(EJJ5EMM#9!4UG<==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    ( (   -@eii,, @H+%))00 +^i
59911 i
XA+ AH#
, #
L
+ 
D1f 16 1 1F 1D2uyy-- D2Nr2$ r2j`2# `2F. +0** 4 (-zz r*   