
    &Vji                      8   d dl Z d dlmZmZmZ d dlZd dlZd dlmZ d dl	m
Z
 d dlmZ d dlmZ d dlmZ d dlmZmZ d	d
gZ ed           G d d	e                      Z	 ddej        defdZ ed           G d d
ej        j                              ZdS )    N)Any
NamedTupleOptional)enable_python_dispatcher)detect_fake_mode)(is_contiguous_for_memory_format_or_false)is_sparse_any)compatibility)map_aggregateNodeTensorMetadata	ShapePropT)is_backward_compatiblec                       e Zd ZU ej        ed<   ej        ed<   eed<   ee	df         ed<   e
ej                 ed<   eed<   eeef         ed<   d	S )
r   shapedtyperequires_grad.stridememory_formatis_quantizedqparamsN)__name__
__module____qualname__torchSize__annotations__r   booltupleintr   r   dictstrr        T/root/voice-cloning/.venv/lib/python3.11/site-packages/torch/fx/passes/shape_prop.pyr   r      s          :;#s(OE/0000 #s(^r$   resultreturnc           	      6   | j         }| j        }| j        }t          |           s|                                 nd}d}|rLt          |           s=t
          j        t
          j        t
          j        h}|D ]}t          | |          r|} n| j
        }	i }
|	r|                                 }||
d<   |t
          j        t
          j        hv r/|                                 |
d<   |                                 |
d<   n|t
          j        t
          j        t
          j        hv ri|                                                                 |
d<   |                                                                 |
d<   |                                 |
d<   t/          ||||||	|
          S )zB
    Extract a TensorMetadata NamedTuple describing `result`.
    r#   N)r   qschemescale
zero_pointaxis)r   r   r   r	   r   r   contiguous_formatchannels_lastchannels_last_3dr   r   r)   per_tensor_affineper_tensor_symmetricq_scaleq_zero_pointper_channel_affine per_channel_affine_float_qparamsper_channel_symmetricq_per_channel_scalestolistq_per_channel_zero_pointsq_per_channel_axisr   )r&   include_contiguityr   r   r   r   r   memory_formatsquery_formatr   r   r)   s               r%   _extract_tensor_metadatar>   (   s    LELE(M$1&$9$9AV]]___rFM -"7"7 #"

 + 	 	L7l    !-	 &L G :..""$	u.0JKKK%~~//GG$*$7$7$9$9GL!!$2'
 
 
  &::<<CCEEGG$*$D$D$F$F$M$M$O$OGL!$7799GFOumV]L'  r$   c                   B     e Zd ZdZd fd	Zdedef fdZ fdZ xZ	S )	r   aE  
    Execute an FX graph Node-by-Node and
    record the shape and type of the result
    into the corresponding node.

    Example:
         In this example, we record the shape
         and data type of a module given
         an example input ``torch.randn(50, D_in)``.
         We print the name, shape and dtype of each node.

        class TwoLayerNet(torch.nn.Module):
            def __init__(self, D_in, H, D_out):
                super().__init__()
                self.linear1 = torch.nn.Linear(D_in, H)
                self.linear2 = torch.nn.Linear(H, D_out)
            def forward(self, x):
                h_relu = self.linear1(x).clamp(min=0)
                y_pred = self.linear2(h_relu)
                return y_pred
        N, D_in, H, D_out = 64, 1000, 100, 10
        x = torch.randn(N, D_in)
        y = torch.randn(N, D_out)
        model = TwoLayerNet(D_in, H, D_out)
        gm = torch.fx.symbolic_trace(model)
        sample_input = torch.randn(50, D_in)
        ShapeProp(gm).propagate(sample_input)

        for node in gm.graph.nodes:
            print(node.name, node.meta['tensor_meta'].dtype,
                node.meta['tensor_meta'].shape)

        The output of this code is:

        x torch.float32 torch.Size([50, 1000])
        linear1 torch.float32 torch.Size([50, 100])
        clamp_1 torch.float32 torch.Size([50, 100])
        linear2 torch.float32 torch.Size([50, 10])
        output torch.float32 torch.Size([50, 10])

    Args:
         module (GraphModule): The module to be executed
         fake_mode (FakeTensorMode): A fake mode for copying the gm

    Nc                     t                                          |           |t                      }|$ddlm}  || j        |          | _        || _        nd | _        d | _        | j        | _        d S )Nr   )deepcopy_to_fake_tensor)	super__init__r   torch._dynamo.utilsrA   modulefake_module	fake_modereal_module)selfgmrG   rA   	__class__s       r%   rC   zShapeProp.__init__   s    (**I CCCCCC  76t{INND&DNN#D!DN;r$   nr'   c                 @  
 ddl m}m} 	 | j        | j        | _        	 | j        ~| j        5  t                      5  t                                          |          } || j        j	        ||           d d d            n# 1 swxY w Y   d d d            n# 1 swxY w Y   n!t                                          |          }| j
        | _        n# | j
        | _        w xY wnR# t          $ rE}t          j                     t          d|                                 d|j                   |d }~ww xY wd

fd}t#          ||          }
r
||j        d<   | j        r&| j        j	        x}r |||          x}	r
|	|j        d<   t%          |          |j        d	<   |S )
Nr   )compute_unbacked_bindingsrebind_unbackedzShapeProp error for: node=z with meta=Fc                 ^    t          | t          j                  rdt          |           S | S )NT)
isinstancer   Tensorr>   )objfound_tensors    r%   extract_tensor_metaz/ShapeProp.run_node.<locals>.extract_tensor_meta   s/    #u|,, #/444
r$   tensor_metaunbacked_bindingstype)%torch.fx.experimental.symbolic_shapesrN   rO   rF   rE   rG   r   rB   run_node	shape_envrH   	Exception	traceback	print_excRuntimeErrorformat_nodemetar   rX   )rI   rL   rN   rO   r&   erU   ra   r[   symbol_to_pathrT   rK   s             @r%   rZ   zShapeProp.run_node   s   	
 	
 	
 	
 	
 	
 	
 	

	+ #./>- M M)A)C)C M M!&!1!1!!4!4'(@!VLLLM M M M M M M M M M M M M M M M M M M M M M M M M M M M M M #WW--a00F".d..... 	 	 	!!!QQ]]__QQQQ 	 	 	 	 	 	 V%899 	)$(AF=!> 	=!^55	 =";";Iv"N"NN= /=*+fvsu   C% C B9B6BB	B	B	
BC BC  B!%C C% C!!C% %
D4/A D//D4c                 b      j          fd|D             }n|} t                      j        | S )a  
        Run `module` via interpretation and return the result and
        record the shape and type of each node.

        Args:
            *args (Tensor): the sample input.

        Returns:
            Any: The value returned from executing the Module
        Nc                 |    g | ]8}t          |t          j                  rj                            |          n|9S r#   )rQ   r   rR   rG   from_tensor).0trI   s     r%   
<listcomp>z'ShapeProp.propagate.<locals>.<listcomp>   sP        2<Au|1L1LS**1---RS  r$   )rG   rB   run)rI   args	fake_argsrK   s   `  r%   	propagatezShapeProp.propagate   sR     >%     II
 Iuww{I&&r$   )N)
r   r   r   __doc__rC   r   r   rZ   rm   __classcell__)rK   s   @r%   r   r   [   s        , ,\' ' ' ' ' '0/$ /3 / / / / / /b' ' ' ' ' ' ' ' 'r$   )T)r]   typingr   r   r   r   torch.fxtorch._dispatch.pythonr   torch._guardsr   torch._prims_commonr   torch._subclasses.meta_utilsr	   torch.fx._compatibilityr
   torch.fx.noder   r   __all__r   rR   r>   fxInterpreterr   r#   r$   r%   <module>r{      s       , , , , , , , , , ,   ; ; ; ; ; ; * * * * * * H H H H H H 6 6 6 6 6 6 1 1 1 1 1 1 - - - - - - - - [
) d+++    Z   ,+* .20 0L00 0 0 0f d+++J' J' J' J' J'$ J' J' ,+J' J' J'r$   