
    Ph                        d dl Z d dlZ d dlZd dlmZ d dlmZmZ d dlm	Z	m
Z
mZmZmZ d dlmZ d dlmZ ddgZ ed	
       G d de             Zde j(                  defdZ ed	
       G d de j,                  j.                               Zy)    N)enable_python_dispatcher)Nodemap_aggregate)AnyTuple
NamedTupleOptionalDict)compatibility)detect_fake_mode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<   y	)
r   shapedtyperequires_grad.stridememory_formatis_quantizedqparamsN)__name__
__module____qualname__torchSize__annotations__r   boolr   intr	   r   r
   strr        eC:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\site-packages\torch/fx/passes/shape_prop.pyr   r      sS     JJKK38_U0011 #s(^r"   resultreturnc           	         | j                   }| j                  }| j                  }| j                         }t        j
                  t        j                  t        j                  h}d}|D ]  }| j                  |      s|} n | j                  }i }	|r| j                         }
|
|	d<   |
t        j                  t        j                  hv r'| j                         |	d<   | j                         |	d<   n|
t        j                  t        j                   t        j"                  hv rU| j%                         j'                         |	d<   | j)                         j'                         |	d<   | j+                         |	d<   t-        |||||||	      S )zB
    Extract a TensorMetadata NamedTuple describing `result`.
    N)r   qschemescale
zero_pointaxis)r   r   r   r   r   contiguous_formatchannels_lastchannels_last_3dis_contiguousr   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$   r   r   r   r   memory_formatsr   query_formatr   r   r'   s              r#   _extract_tensor_metadatar<      sn    LLELLE((M]]_F 	N M&l;(M '
 &&L G.."$	u..0J0JKK%~~/GG$*$7$7$9GL!1153Y3Y[`[v[vww  &::<CCEGG$*$D$D$F$M$M$OGL!$779GFOumV]L'S S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

    c                     t         |   |       |
t               }|&ddlm}  || j
                  |      | _        || _        nd | _        d | _        | j
                  | _        y )Nr   )deepcopy_to_fake_tensor)	super__init__r   torch._dynamo.utilsr?   modulefake_module	fake_modereal_module)selfgmrE   r?   	__class__s       r#   rA   zShapeProp.__init__u   s^    (*I C  7t{{IND&DN#D!DN;;r"   nr%   c                    	 | j                   | j                   | _        	 | j                  8| j                  5  t               5  t        |   |      }d d d        d d d        nt        |   |      }| j                  | _        	 dfd}t        |      }r||j                  d<   t        |      |j                  d<   |S # 1 sw Y   qxY w# 1 sw Y   exY w# | j                  | _        w xY w# t        $ rC}t        j                          t        d|j                          d|j                         |d }~ww xY w)NzShapeProp error for: node=z with meta=Fc                 V    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
r"   tensor_metatype)rD   rC   rE   r   r@   run_noderF   	Exception	traceback	print_excRuntimeErrorformat_nodemetar   rS   )rG   rJ   r$   erQ   rZ   rP   rI   s         @r#   rT   zShapeProp.run_node   s%   	+ #../>>-)A)C!&!1!!4 *D #W-a0F".. 	 V%89$(AFF=!fv9 *D)C
 #.. 	!,Q]]_,= >x! 	s]   C3 C CCCC 5C3 C	
CCC C00C3 3	D?<>D::D?c                     | j                   E|D cg c]9  }t        |t        j                        r| j                   j	                  |      n|; }}n|}t        |   | S c c}w )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
        )rE   rM   r   rN   from_tensorr@   run)rG   argst	fake_argsrI   s       r#   	propagatezShapeProp.propagate   sb     >>%fjkfjab*Q:U33A6[\\fjIkIw{I&& ls   >A!)N)
r   r   r   __doc__rA   r   r   rT   rb   __classcell__)rI   s   @r#   r   r   F   s,    ,Z'.$4 $C $L' 'r"   )r   torch.fxrV   torch._dispatch.pythonr   torch.fx.noder   r   typingr   r   r   r	   r
   torch.fx._compatibilityr   torch._guardsr   __all__r   rN   r<   fxInterpreterr   r!   r"   r#   <module>rn      s       ; - 9 9 1 *[
)d+Z  ,'Sell 'S~ 'SR d+z'$$ z' ,z'r"   