
    Pi                        d dl mZ d dlZ ed           G d d                      Z ed           G d de                      Z ed           G d	 d
e                      Z ed           G d de                      Z ed           G d de                      Z ed           G d de                      Z ed           G d de                      Z	ej
                            e	eeg           dS )    )	dataclassNT)frozenc                       e Zd ZdZdS )Granularityz
    Base class for representing the granularity of quantization.

    This class serves as a parent for specific granularity types used in
    quantization operations, such as per-tensor or per-axis quantization.
    N__name__
__module____qualname____doc__     t/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/torchao/quantization/granularity.pyr   r                	Dr   r   c                       e Zd ZdZdS )	PerTensorz
    Represents per-tensor granularity in quantization.

    This granularity type calculates the quantization parameters
    based off the entire tensor.
    Nr   r   r   r   r   r      r   r   r   c                       e Zd ZU dZeed<   dS )PerAxisa  
    Represents per-axis granularity in quantization.

    This granularity type calculates different quantization parameters
    along a specified axis of the tensor.

    Examples:
    * input_tensor shape [A, B], axis 0 -> scale_shape [A, 1]
    * input_tensor shape [A, B], axis 1 -> scale_shape [1, B]
    * input_tensor shape [A, B, C], axis 1 -> scale_shape [1, B, 1]

    Attributes:
        axis (int): The axis which is kept, reduction is performed across all
          the other axes
    axisNr   r	   r
   r   int__annotations__r   r   r   r   r   $   s%            IIIIIr   r   c                       e Zd ZU dZeed<   dS )PerGroupa  
    Represents per-channel group granularity in quantization.

    This granularity type calculates different quantization parameters
    for each group of <group_size> elements.

    For example if the input tensor is shape [8, 16], and the group size is 4, then
    the input tensor is reshaped to [64, 4]
    quantization parameters are calculated for each group of 4 elements,
    giving a total of 64 quantization parameters.

    Attributes:
        group_size (int): The size of each quantization group

    
group_sizeNr   r   r   r   r   r   9   s%            OOOOOr   r   c                   "    e Zd ZU dZdZeed<   dS )PerRowa  
    Represents row-wise granularity in quantization.

    Examples:
    * input_tensor shape [A, B], dim 0 -> scale_shape [1, B]
    * input_tensor shape [A, B], dim 1 -> scale_shape [A, 1]
    * input_tensor shape [A, B], dim -1 -> scale_shape [A, 1]
    * input_tensor shape [A, B, C], dim 1 -> scale_shape [A, 1, C]

    Attributes:
        dim (int): The dim which is reduced across, all other dims are kept
    dimN)r   r	   r
   r   r   r   r   r   r   r   r   r   N   s)           CMMMMMr   r   c                       e Zd ZdZdS )PerTokena:  
    Represents per-token granularity in quantization.

    This granularity type calculates a different set of quantization parameters
    for each token, which is represented as the last dimension of the tensor.

    For example, if the input tensor has shape [2, 3, 4], then there are 6 tokens
    with 4 elements each, and we will calculate 6 sets of quantization parameters,
    one for each token.

    If the input tensor has only two dimensions, e.g. [8, 16], then this is
    equivalent to `PerAxis(axis=0)`, which yields 8 sets of quantization parameters.
    Nr   r   r   r   r    r    `   s          	Dr   r    c                   .    e Zd ZU dZeedf         ed<   dS )PerBlocka'  
    Represents multidimensional per-block granularity in quantization.

    Example:
    * block_size has shape [X, Y]
    * input_tensor shape [A] -> scaling undefined
    * input_tensor shape [A, B] -> scale shape [A // X, B // Y]
    * input_tensor shape [A, B, C] -> scale shape [A, B // X, C // Y]
    * input_tensor shape [A, B, C, D] -> scale shape [A, B, C // X, D // Y], and so on

    Note that `PerBlock((1, Y))` is equivalent to `PerGroup(Y)`

    Attributes:
        block_size (tuple[int, ...]): The size of each quantization group
    .
block_sizeN)r   r	   r
   r   tupler   r   r   r   r   r"   r"   s   s2          2 c3hr   r"   )dataclassesr   torchr   r   r   r   r   r    r"   serializationadd_safe_globalsr   r   r   <module>r)      s"   " ! ! ! ! !  $	 	 	 	 	 	 	 	 $	 	 	 	 	 	 	 	 $    k   ( $    {   ( $    [   " $	 	 	 	 	{ 	 	 	$ $         {      :   $ $h	%B C C C C Cr   