
    Pi/                     x   U d dl Z d dlmZmZ d dlmZ d dlmZmZm	Z	 d dl
Z
d dlmZ ddlmZmZmZ ddlmZmZmZmZ dd	lmZ  e j        e          Z G d
 d          Zd Z edefi           Zeed<    G d dee
j         j!                  Z" G d de"          Z# G d de"          Z$ G d de"          Z%dS )    N)ABCMetaabstractmethod)partial)AnyOptionalTuple)_fake_quantize_affine   )GranularityPerRow	PerTensor)MappingTypeZeroPointDomain_get_reduction_params"choose_qparams_affine_with_min_max)get_block_sizec                   &    e Zd Zd Zd Zd Zd ZdS )_PartialWrapperc                     || _         d S Np)selfr   s     q/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/torchao/quantization/observer.py__init__z_PartialWrapper.__init__   s        c                      | j         |i |S r   r   )r   argskeywordss      r   __call__z_PartialWrapper.__call__    s    tvt(x(((r   c                 4    | j                                         S r   )r   __repr__r   s    r   r"   z_PartialWrapper.__repr__#   s    v   r   c                 "    t          | g|R i |S r   )
_with_args)r   r   kwargss      r   	with_argsz_PartialWrapper.with_args&   s     $0000000r   N)__name__
__module____qualname__r   r    r"   r'    r   r   r   r      sP          ) ) )! ! !1 1 1 1 1r   r   c                 @    t          t          | g|R i |          }|S )a  Wrapper that allows creation of class factories.

    This can be useful when there is a need to create classes with the same
    constructor arguments, but different instances.

    Example::

        >>> # xdoctest: +SKIP("Undefined vars")
        >>> Foo.with_args = classmethod(_with_args)
        >>> foo_builder = Foo.with_args(a=3, b=4).with_args(answer=42)
        >>> foo_instance1 = foo_builder()
        >>> foo_instance2 = foo_builder()
        >>> id(foo_instance1) == id(foo_instance2)
        False
    )r   r   )cls_or_selfr   r&   rs       r   r%   r%   *   s.      	=d===f==>>AHr   ABCc                   J    e Zd ZdZ ee          Zddddddej        fde	de
j        dedee         dee         d	ee         d
ee
j                 dee
j                 dedef fdZede
j        de
j        fd            Zedee
j        e
j        f         fd            Z xZS )AffineQuantizedObserverBasea  Observer module for affine quantization (https://github.com/pytorch/ao/tree/main/torchao/quantization#affine-quantization)

    Args:
      `granularity` and `block_size`: The granularity of the quantization,
        must specify at least one, if both are specified `block_size` takes precedence
        Current supported granularity type are `PerTensor` and `PerAxis`
      other args: please see `:class:torchao.dtypes.AffineQuantizedTensor`
    NTmapping_typetarget_dtypegranularity	quant_min	quant_maxepsscale_dtypezero_point_dtypepreserve_zerozero_point_domainc                    t                                                       |
J d            |
t          d          || _        || _        || _        || _        || _        || _        || _	        || _
        |	| _        |
| _        d S )Ngranularity is Nonez/Please use ZeroPointDomain.NONE instead of None)superr   
ValueErrorr2   r3   r4   r5   r6   r7   r8   r9   r:   r;   )r   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   	__class__s              r   r   z$AffineQuantizedObserverBase.__init__M   s     	&&(=&&&$NOOO((&""& 0*!2r   inputreturnc                     dS )z~forward function should take the input tensor
        and updates internal stats and return the original input Tensor
        Nr+   r   rA   s     r   forwardz#AffineQuantizedObserverBase.forwardi   	    
 	r   c                     dS )zCalculate quantization parameter based on the stats attached to the observer module
        and returns a tuple of scale and zero_point Tensor
        Nr+   r#   s    r   calculate_qparamsz-AffineQuantizedObserverBase.calculate_qparamsp   rF   r   )r(   r)   r*   __doc__classmethodr%   r'   r   INTr   torchdtyper   r   intfloatboolr   r   TensorrE   r   rH   __classcell__r@   s   @r   r1   r1   A   s\         J''I $(#'#-126"-<-@3 3!3 k3 !	3
 C=3 C=3 e_3 ek*3 #5;/3 3 +3 3 3 3 3 38 U\ el    ^ 5u|)C#D    ^    r   r1   c                   T    e Zd Zdej        fdZdeej        ej        f         fdZdS )AffineQuantizedMinMaxObserverrA   c                    |                                 dk    r|S |                                }| j        
J d            t          |j        | j                  }t          ||                                          \  }}|                    |          }t          j	        ||d          }t          j
        ||d          }t          | d          rt          | d          s|| _        || _        n| j        j        |j        k    sJ d| j        j         d|j                     | j        j        |j        k    sJ d	| j        j         d
|j                     t          j        | j        |          }t          j        | j        |          }| j                            |           | j                            |           |S )Nr   r=   Fdimkeepdimmin_valmax_valz=Can't update existing min_val - shape mismatch, self.min_val:z != min_val:z=Can't update existing max_val - shape mismatch, self.max_val z != max_val:)numeldetachr4   r   shaper   sizeviewrL   aminamaxhasattrrZ   r[   minmaxcopy_)r   rA   input_detached
block_sizeshape_for_reductionreduction_dimsrZ   r[   s           r   rE   z%AffineQuantizedMinMaxObserver.forwardy   s   ;;==AL++-B+++#N$8$:JKK
.C++--/
 /
+^ (,,-@AA*^OOO*^OOOtY'' 	(wtY/G/G 	("DL"DLL<%666PTP\Pbpwp} 766 <%666PTP\Pbpwp} 766 ig66Gig66GLw'''Lw'''r   rB   c                     t          | d          rt          | d          s
J d            t          | j        | j        | j        g | j        | j        | j        | j        | j	        | j
        | j        | j                  S NrZ   r[   zhExpecting the observer has min_val and max_val, please run the observer before calling calculate_qparamsrc   r   rZ   r[   r2   r3   r5   r6   r7   r8   r9   r:   r;   r#   s    r   rH   z/AffineQuantizedMinMaxObserver.calculate_qparams       tY'' 	
GD),D,D 	
 	
v	
 	
D 2LLNNH!"
 
 	
r   N)r(   r)   r*   rL   rQ   rE   r   rH   r+   r   r   rU   rU   x   sZ        U\    >
5u|)C#D 
 
 
 
 
 
r   rU   c                       e Zd ZdZddddddej        ddf	dedej        de	de
e         de
e         d	e
e         d
e
ej                 de
ej                 dedede
ej                 de
ej                 f fdZddZd Zd Z xZS )"AffineQuantizedFixedQParamObserverzO
    Observer that allows manual setting of fixed quantization parameters.
    NTr2   r3   r4   r5   r6   r7   r8   r9   r:   r;   scale
zero_pointc                 ^   t                                          |||||||||	|

  
         |st          j        dg          }|st          j        |          }|                     d|                    |                     |                     d|                    |                     d S )Nr
   rq   rM   rr   )r>   r   rL   rQ   
zeros_likeregister_bufferto)r   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   rq   rr   r@   s                r   r   z+AffineQuantizedFixedQParamObserver.__init__   s     		
 	
 	
  	&L!%%E 	1)%00JWehh[h&A&ABBB\:==?O=+P+PQQQQQr   c                     |st          j        |          }|                    | j                  | _        |                    | j                  | _        d S )Nrt   )rL   ru   rw   r8   rq   r9   rr   )r   rq   rr   s      r   set_qparamsz.AffineQuantizedFixedQParamObserver.set_qparams   sN     	1)%00JXXD$4X55
$--d.C-DDr   c                     |S r   r+   rD   s     r   rE   z*AffineQuantizedFixedQParamObserver.forward   s    r   c                     | j         | j        fS r   )rq   rr   r#   s    r   rH   z4AffineQuantizedFixedQParamObserver.calculate_qparams   s    z4?**r   r   )r(   r)   r*   rI   r   rK   r   rL   rM   r   r   rN   rO   rP   rQ   r   ry   rE   rH   rR   rS   s   @r   rp   rp      sV         $(#'#-126"-<-@(,-1 R  R! R k R !	 R
 C= R C= R e_ R ek* R #5;/ R  R + R % R U\* R  R  R  R  R  RDE E E E  + + + + + + +r   rp   c                        e Zd ZdZddddddej        ddf	dedej        de	d	e
e         d
e
e         de
e         de
ej                 de
ej                 dedededef fdZd Zd Zd Zd Zd Z xZS )AffineQuantizedMSEObserverz
    Minimize quantization loss caused by outlier via linear search. More details can be found at https://arxiv.org/pdf/2209.13325
    NTd   Fr2   r3   r4   r5   r6   r7   r8   r9   r:   r;   stepsrun_oncec                     t                                          |||||||||	|

  
         || _        d| _        || _        d S )NF)r>   r   r   
calibratedr   )r   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r   r   r@   s                r   r   z#AffineQuantizedMSEObserver.__init__   sZ     		
 	
 	
 
 r   c                     ||z
                                                       d          }t          ||                                          \  }}|                    |          }t          j        ||d          S )N   FrW   )abspowr   r_   r`   rL   mean)r   predexpectrh   lossri   rj   s          r   msezAffineQuantizedMSEObserver.mse  sr    v""$$((++.C		/
 /
+^ yy,--z$NEBBBBr   c                 L   t          |j        | j                  }t          ||| j        g | j        | j        | j        | j        | j	        | j
        | j        | j                  \  }}t          ||||| j        | j        | j        | j                  }|                     |||          S r   )r   r^   r4   r   r2   r3   r5   r6   r7   r8   r9   r:   r;   r	   r   )r   xnew_minnew_maxrh   rq   rr   x_qs           r   loss_fnz"AffineQuantizedMSEObserver.loss_fn  s    #AGT-=>>
>NNH!"
 
z $NN"	
 	
 xxQ
+++r   c                    |                                 dk    r|S |                                }| j        
J d            t          |j        | j                  }t          ||                                          \  }}|                    |          }t          j	        ||d          }t          j
        ||d          }t          j        |                                |          }t          j        |          dz   }	t          d| j        dz             D ]q}
|| j        z  |
z  }|                     || |          }t          j        ||	k     | |          }t          j        ||	k     ||          }t          j        ||	          }	r||fS )Nr   r=   FrW   g    eAr
   )r\   r]   r4   r   r^   r   r_   r`   rL   ra   rb   re   r   ru   ranger   r   whererd   )r   rA   rg   rh   ri   rj   rZ   r[   	range_valoptimal_lossithrescurrent_losss                r   line_searchz&AffineQuantizedMSEObserver.line_search(  s   ;;==AL++-B+++#N$8$:JKK
.C++--/
 /
+^ (,,-@AA*^OOO*^OOOIgkkmmW55	'0036 q$*q.)) 	A 	AA
*Q.E<<vu==Lk,"=vwOOGk,"=ugNNG 9\<@@LLr   c                 t    | j         r| j        s)|                     |          \  | _        | _        d| _        |S )NT)r   r   r   rZ   r[   rD   s     r   rE   z"AffineQuantizedMSEObserver.forwardD  s=     	#$/ 	#)-)9)9%)@)@&DL$,"DOr   c                     t          | d          rt          | d          s
J d            t          | j        | j        | j        g | j        | j        | j        | j        | j	        | j
        | j        | j                  S rl   rm   r#   s    r   rH   z,AffineQuantizedMSEObserver.calculate_qparamsK  rn   r   )r(   r)   r*   rI   r   rK   r   rL   rM   r   r   rN   rO   rP   r   r   r   r   rE   rH   rR   rS   s   @r   r}   r}      sL         $(#'#-126"-<-@! !!! k! !	!
 C=! C=! e_! ek*! #5;/! ! +! ! ! ! ! ! ! !>C C C, , ,8     8  
 
 
 
 
 
 
r   r}   )&loggingabcr   r   	functoolsr   typingr   r   r   rL   %torchao.quantization.quant_primitivesr	   r4   r   r   r   quant_primitivesr   r   r   r   utilsr   	getLoggerr(   loggerr   r%   objectr/   __annotations__nnModuler1   rU   rp   r}   r+   r   r   <module>r      s    ' ' ' ' ' ' ' '       ' ' ' ' ' ' ' ' ' '  G G G G G G 7 7 7 7 7 7 7 7 7 7            " ! ! ! ! !		8	$	$1 1 1 1 1 1 1 1  ( 756)R((S ( ( (4 4 4 4 4#ux 4 4 4n1
 1
 1
 1
 1
$? 1
 1
 1
h1+ 1+ 1+ 1+ 1+)D 1+ 1+ 1+h|
 |
 |
 |
 |
!< |
 |
 |
 |
 |
r   