
    i                     j   S SK Jr  S SKr\" SS9 " S S5      5       r\" SS9 " S S\5      5       r\" SS9 " S	 S
\5      5       r\" SS9 " S S\5      5       r\" SS9 " S S\5      5       r\" SS9 " S S\5      5       r\" SS9 " S S\5      5       r	\R                  R                  \	\\/5        g)    )	dataclassNT)frozenc                       \ rS rSrSrSrg)Granularity   z
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____firstlineno____doc____static_attributes__r       _/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/torchao/quantization/granularity.pyr   r           	r   r   c                       \ rS rSrSrSrg)	PerTensor   z
Represents per-tensor granularity in quantization.

This granularity type calculates the quantization parameters
based off the entire tensor.
r   Nr	   r   r   r   r   r      r   r   r   c                   $    \ rS rSr% Sr\\S'   Srg)PerAxis$   a  
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
axisr   Nr
   r   r   r   r   int__annotations__r   r   r   r   r   r   $   s      Ir   r   c                   $    \ rS rSr% Sr\\S'   Srg)PerGroup9   a  
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_sizer   Nr   r   r   r   r   r   9   s      Or   r   c                   (    \ rS rSr% SrSr\\S'   Srg)PerRowN   a}  
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
dimr   N)	r
   r   r   r   r   r%   r   r   r   r   r   r   r"   r"   N   s     CMr   r"   c                       \ rS rSrSrSrg)PerToken`   a  
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.
r   Nr	   r   r   r   r'   r'   `   s     	r   r'   c                   .    \ rS rSr% Sr\\S4   \S'   Srg)PerBlocks   a  
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_sizer   N)	r
   r   r   r   r   tupler   r   r   r   r   r   r*   r*   s   s    2 c3hr   r*   )dataclassesr   torchr   r   r   r   r"   r'   r*   serializationadd_safe_globalsr   r   r   <module>r2      s   "  $	 	 	 $	 	 	 $k  ( ${  ( $[  " $	{ 	 	$ $ {    :    $ $h	%B Cr   