U
    D‹Ñh¥¯  ã                   @   s¦  d dl 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	m
Z
mZmZmZmZmZmZ d dlZd dlm  mZ d dlm  mZ d dlmZ d dlmZ d dlmZmZm Z m!Z!m"Z"m#Z# d d	l$m%Z% d d
lm&Z&m'Z' ddddgZ(G dd„ deƒZ)d@eej*ej+f ej,j-e.e)e/dœdd„Z0G dd„ dej,j-ƒZ1G dd„ de j2ƒZ3G dd„ dej,j-ƒZ4dAeee3 e4dœdd„Z5ejj6ddœdd„Z7dd„ Z8e.e.e.dœd d!„Z9ej,j-ej,j-d"œd#d$„Z:ej,j-e.d%œd&d'„Z;ej,j-ejj<d%œd(d)„Z=ej,j-ejj<d%œd*d+„Z>ej,j-e.d,œd-d.„Z?ej,j-e.ej,j-d/œd0d1„Z@G d2d3„ d3ƒZAejj6e4d4œd5d6„ZBdBej,j-ee.eCf e.d8œd9d:„ZDej,j-ee.ee. f ee. d;œd<d=„ZEd>d?„ ZFdS )Cé    N)Údefaultdict)Údeepcopy)ÚEnum)ÚAnyÚcastÚDictÚListÚOptionalÚSetÚTupleÚUnion)ÚFakeScriptObject)Úreorder_kwargs)ÚConstantArgumentÚExportedProgramÚ	InputKindÚModuleCallSignatureÚSymIntArgumentÚTensorArgument)Úis_fx_tracing)Ú
GetAttrKeyÚSequenceKeyÚInterpreterModuleÚUnflattenedModuleÚ	unflattenÚFlatArgsAdapterc                   @   s   e Zd ZdZdZdZdS )Ú	_AttrKindZ	parameterÚbufferÚconstantN)Ú__name__Ú
__module__Ú__qualname__Ú	PARAMETERÚBUFFERÚCONSTANT© r%   r%   úD/tmp/user/2202/pip-unpacked-wheel-bf9o3bgk/torch/export/unflatten.pyr      s   r   T)Úfrom_objÚ	to_moduleÚtargetÚ	attr_kindÚ
persistentc           	      C   sà   |  d¡�^ }}|D ]2}t||d ƒ}|d krBtj ¡ }t|||ƒ |}q|tjkrrt| tjj	ƒsdt
‚| || ¡ nj|tjkržt| tjƒsŒt
‚|j|| |d� n>|tjkrÜt| tƒrºt
dƒ‚t| tjtjfƒsÐt
‚t||| ƒ d S )NÚ.)r+   z2FakeScriptObject should only exist during tracing.)ÚsplitÚgetattrÚtorchÚnnÚModuleÚsetattrr   r"   Ú
isinstanceÚ	ParameterÚAssertionErrorZregister_parameterr#   ÚTensorZregister_bufferr$   r   ÚScriptObject)	r'   r(   r)   r*   r+   ÚprefixÚfieldÚitemÚtr%   r%   r&   Ú_assign_attr%   s6    



 ÿþþþr<   c                       s:   e Zd ZdZejjdœ‡ fdd„Zdd„ Zdd„ Z	‡  Z
S )	r   zÈA module that uses torch.fx.Interpreter to execute instead of the usual
    codegen that GraphModule uses. This provides better stack trace information
    and makes it easier to debug execution.
    ©Úgraphc                    s   t ƒ  ¡  || _| | j_d S ©N)ÚsuperÚ__init__r>   Zowning_module)Úselfr>   ©Ú	__class__r%   r&   rA   O   s    
zInterpreterModule.__init__c                 O   sº   | j d k	stdƒ‚tj ¡ r(| j ||ŽS |r˜t|ƒ}| jt|ƒd … }|D ]}||krJ| || ¡ qJt|ƒt|ƒkszt‚t|ƒt| jƒks�t‚t	|ƒ}tj
j| | jd�j|ddiŽS d S )Nz&Didn't finalize this InterpreterModuler=   Úenable_io_processingF)Úgraph_moduler5   r/   ÚcompilerZis_dynamo_compilingÚlistÚ	arg_namesÚlenÚappendÚtupleÚfxÚInterpreterr>   Úrun)rB   ÚargsÚkwargsÚarg_listZkwarg_namesZ
kwarg_namer%   r%   r&   ÚforwardW   s"    
ÿÿzInterpreterModule.forwardc                 C   sP   t j | | j¡| jd< | j ¡  g | _| jjD ]}|jdkr.| j 	|j
¡ q.d S )NrF   Úplaceholder)r/   rM   ZGraphModuler>   Ú__dict__ZlintrI   ÚnodesÚoprK   r)   ©rB   Únoder%   r%   r&   Úfinalizet   s    

zInterpreterModule.finalize)r   r    r!   Ú__doc__r/   rM   ÚGraphrA   rS   rZ   Ú__classcell__r%   r%   rC   r&   r   I   s
   þc                   @   s6   e Zd ZdZejejejee	 ee	 dœdd„ƒZ
dS )r   zN
    Adapts input arguments with ``input_spec`` to align ``target_spec``.
    )Útarget_specÚ
input_specÚ
input_argsÚreturnc                 C   s   dS )z=NOTE: This adapter may mutate given ``input_args_with_path``.Nr%   )rB   r^   r_   r`   r%   r%   r&   Úadapt‹   s    zFlatArgsAdapter.adaptN)r   r    r!   r[   ÚabcÚabstractmethodÚpytreeZTreeSpecr   r   rb   r%   r%   r%   r&   r   †   s   ûc                       s:   e Zd Zd	eee dœ‡ fdd„Zdd„ Zdd„ Z‡  Z	S )
r   N)Úexport_moduleÚflat_args_adapterc           !         s²  t ƒ  ¡  |jjd k	rtdƒ‚dd„ |jD ƒ}|d dks>t‚t|jƒ}t|jƒ| _t	j
 ¡ | _t|jƒ| _|| _d| _t|| jƒ t|| ƒ |j| _g | _|j}tƒ }i }| jjD ]T}|| }	t|	ƒ|krät	j |	 ¡ ¡|t|	ƒ< t|t|	ƒ | |tjd� | |¡ q´t| jjƒ}
tƒ }i }| jjD ]x}||
k�rFd}|j| }nd}|| }t|ƒ|k�rt| ¡ |f|t|ƒ< t|t|ƒ d | |tj |d	� | |¡ �q(| !¡ D ]Â\}}||k�sª||k�rÊ�qªd}t|ƒ|k�sìt"|t	jjƒ�sðd}|�r6t|ƒ|k�r|df|t|ƒ< t|t|ƒ d | |tj dd	� n4t|ƒ|k�rP||t|ƒ< t|t|ƒ | |tjd� �qªi }|j !¡ D ]X\}}t|ƒ|k�r´t"|t	j#ƒ�r¨| ¡ }||t|ƒ< |t|ƒ }t|| |tj$d� �q|t%t&ƒ‰tƒ }‡fd
d„}tƒ }| jj'D �]}|j(t)jk�s(|j(t)j k�r„|j*�r„t+|j,dƒ�s:t‚t"|j-t.ƒ�sLt‚|t|j|j- ƒ|j,j/|j-ƒ | |j-¡ | |j-¡ n€|j(t)j k�rš|j*�r¶|j(t)j0k�s¶|j(t)j1k�rþt+|j,dƒ�sÈt‚t"|j-t.ƒ�sÚt‚|t|j|j- ƒ|j,j/|j-ƒ | |j-¡ �qþ|j !¡ D ]Z\}}||k�rt|ƒˆk�s:tdƒ‚ˆt|ƒ d \}}|t|ƒ||ƒ | |j-¡ �q|j !¡ D ]J\}}||k�rxt|ƒˆk�rœ�qxˆt|ƒ d \}}|t|ƒ||ƒ �qxi ‰ˆ 2¡ D ],}dd„ |D ƒ}|D ]\}}|ˆ|< �qæ�qÐt3| ˆg ƒ ‡ ‡fdd„‰ ˆ | g ƒ dd„ | jj4D ƒ| _5d| _6dd„ t7|ƒD ƒ} | j8dd�D ] \}}|| k�rZt9| ƒ| |< �qZt:| | ƒ dd„ | j8dd�D ƒt&|  ;¡ ƒk�s®t‚d S )Nz%Unflattening on JointExportModule NYIc                 S   s   g | ]
}|j ‘qS r%   )Úfqn©Ú.0Úentryr%   r%   r&   Ú
<listcomp>    s     z.UnflattenedModule.__init__.<locals>.<listcomp>r   Ú F)r*   T)r*   r+   c                    s   ˆ |  }|  ||f¡ d S r?   )rK   )Zobj_idZ	node_nameZtarget_nameÚ	name_list)Ú
consts_mapr%   r&   Úadd_to_consts_map  s    z5UnflattenedModule.__init__.<locals>.add_to_consts_mapÚnamez?Constants should be either aliased or appear in graph signaturec                 S   s   g | ]}|d  ‘qS ©é   r%   )rj   r;   r%   r%   r&   rl   P  s     c                    sŽ   t | dƒrd| jjD ]P}|jdkr|jˆkrt‡ fdd„ˆ|j D ƒƒrt|j› dˆ › d| j› �ƒ‚q|  ¡ D ]\}}ˆ  |¡ ˆ|ˆ ƒ qld S )Nr>   rT   c                 3   s(   | ] }|  d ¡dtˆ ƒ… ˆ kV  qdS )r,   N)r-   rJ   )rj   rh   ©Úscoper%   r&   Ú	<genexpr>c  s   ÿzJUnflattenedModule.__init__.<locals>.check_module_inputs.<locals>.<genexpr>z was not sunk into the module z which has the graph: )	Úhasattrr>   rV   rW   rq   Úanyr5   Znamed_childrenrK   )Úmoduleru   rY   rq   Úsubmod)Úcheck_module_inputsÚinputs_to_statert   r&   r{   W  s     
ÿþþýÿ
z7UnflattenedModule.__init__.<locals>.check_module_inputsc                 S   s   g | ]}|j d kr|‘qS ©rT   ©rW   ©rj   rY   r%   r%   r&   rl   v  s    
 c                 S   s   i | ]\}}||“qS r%   r%   )rj   Úirh   r%   r%   r&   Ú
<dictcomp>{  s      z.UnflattenedModule.__init__.<locals>.<dictcomp>)Zremove_duplicatec                 S   s   g | ]\}}|‘qS r%   r%   )rj   rh   Ú_r%   r%   r&   rl   �  s     )<r@   rA   Úgraph_signatureZbackward_signatureÚ
ValueErrorÚmodule_call_graphr5   r   r>   r/   rM   r\   rg   ÚadaptedÚ_inplace_buffer_mutationsÚ_outline_submodulesÚrange_constraintsZequality_constraintsÚ
state_dictÚsetÚ
parametersÚidr0   r4   Úcloner<   r   r"   ÚaddÚnon_persistent_buffersÚbuffersÚ	constantsr#   Úitemsr3   r6   r$   r   rH   Zinput_specsÚkindr   r+   rw   Úargr)   Ústrrq   ZCONSTANT_TENSORZ
CUSTOM_OBJÚvaluesÚ_sink_paramsrV   Úinput_placeholdersÚcheck_input_constraintsÚ	enumerateÚnamed_modulesrJ   Ú_reorder_submodulesÚkeys)!rB   rf   rg   Zfqn_listZexport_graphrŠ   Zassigned_paramsZid_to_paramrq   Úparamr�   Zassigned_buffersZid_to_bufferr+   r   ZtensorZ	is_bufferZid_to_constrh   r   Z	_constantZconsts_targetsrp   Zadded_params_buffersÚsZ
const_nameÚconstZph_namer‚   Znode_targetÚtargetsÚnÚ	fqn_orderrC   )r{   ro   r|   r&   rA   —   sD   



üþ
û ÿ
ÿþû
ü
ü
	
ÿÿ  ÿ
ÿÿ
þ
ý  ÿ

ÿþ

ÿ

ÿzUnflattenedModule.__init__c                 C   sF   |   ¡ D ]8\}}t|d ƒ t|dƒrt|jtjjƒrt|jƒ qd S )Nú:r>   )rœ   Úprintrw   r3   r>   r/   rM   r\   )rB   rh   Úmodr%   r%   r&   Ú_print_graph…  s    zUnflattenedModule._print_graphc                 O   s„  | j d j}t||jƒ}t ||f¡\}}dd„ |D ƒ}tƒ r~tjj	| | j
d�j|ddiŽ}t|tƒrzt|ƒdkrz|d S |S ||jk�r| jsªtd|› d	�d
|j› �ƒ | jd kr¾tdƒ‚nV| jsÌtdƒ | jj|j||d�}d| _t|ƒ|jjk�rtdt|ƒ› d|jj› �ƒ‚| j�rXddlm}	 | jdk�rDdd„ |D ƒ}
n|}
|	| j|
| jƒ tjj	| | j
d�j|ddiŽ}t ||j¡S )Nr   c                 S   s   g | ]}|d  ‘qS rr   r%   )rj   Úxr%   r%   r&   rl   “  s     z-UnflattenedModule.forward.<locals>.<listcomp>r=   rE   Frs   zGInput treespec does not match with exported module's: 
Input treespec: z. zExported module treespec: zeThere is no flat args adapter sepcified. Are you sure you are calling this with the right arguments? z5Adapting flat arg to match exported module's treespec)r^   r_   r`   Tz<Flat args adaption failed, number of args mismatch Adatped: z 
Exported module: )Ú"_check_input_constraints_for_graphc                 S   s$   g | ]}t d d�tdd�f|f‘qS )r   )Úidxz<unknown location>)rq   )r   r   ©rj   r•   r%   r%   r&   rl   Â  s   ÿ)r…   Ú	signaturer   Úin_specre   Ztree_flatten_with_pathr   r/   rM   rN   r>   rO   r3   rL   rJ   r†   r¦   rg   Ú	TypeErrorrb   Z
num_leavesrš   Ztorch._export.utilsrª   r™   r‰   Útree_unflattenÚout_spec)rB   rP   rQ   r­   Zreordered_kwargsZflat_args_with_pathr®   Ú	flat_argsÚ
return_valrª   Znew_flat_args_with_pathZtree_outr%   r%   r&   rS   ‹  sn    ÿÿÿ

ý
ÿýÿþ  ÿÿÿzUnflattenedModule.forward)N)
r   r    r!   r   r	   r   rA   r¨   rS   r]   r%   r%   rC   r&   r   –   s    ýý o)ry   rg   ra   c                 C   s
   t | |ƒS )aü  Unflatten an ExportedProgram, producing a module with the same module
    hierarchy as the original eager module. This can be useful if you are trying
    to use :mod:`torch.export` with another system that expects a module
    hierachy instead of the flat graph that :mod:`torch.export` usually produces.

    .. note:: The args/kwargs of unflattened modules will not necessarily match
        the eager module, so doing a module swap (e.g. :code:`self.submod =
        new_mod`) will not necessarily work. If you need to swap a module out, you
        need to set the :code:`preserve_module_call_signature` parameter of
        :func:`torch.export.export`.

    Args:
        module (ExportedProgram): The ExportedProgram to unflatten.
        flat_args_adapter (Optional[FlatArgsAdapter]): Adapt flat args if input TreeSpec does not match with exported module's.

    Returns:
        An instance of :class:`UnflattenedModule`, which has the same module
        hierarchy as the original eager module pre-export.
    )r   )ry   rg   r%   r%   r&   r   Ò  s    ©r>   ra   c              
      s  t tt| jƒƒƒ}|jdkr*t|jƒdks.t‚|jd }|j}|dt|ƒ… }dd„ |j	 
¡ D ƒ}dd„ | jD ƒ}|D ]~}||j }	||	 }
||
 }|  |¡�< |  dtjjj||f¡‰ |j 
¡ D ]\}}|ˆ j|< qÂW 5 Q R X | ˆ ‡ fd	d
„¡ qvt|t|ƒd… ƒ}|f|_dS )a  Transform buffer mutations from their functionalized form into a copy_
    node in the graph.

    Functionalization represents buffer mutation by passing the buffer as an input and output. So for example, the eager code:
        def forward(self, x):
            self.buffer += x
            return x * x

    Will become a graph that looks like:
        def forward(self, buffer, x):
            mutated_buffer = aten.add(buffer, x)
            mul = aten.mul(x, x)
            return (mutated_buffer, mul)

    We want to inplace this into something that looks like the original eager code:
        def forward(self, buffer, x):
            mutated_buffer = aten.add(buffer, x)
            buffer.copy_(mutated_buffer)
            mul = aten.mul(x, x)
            return (mul,)
    Úoutputrs   r   Nc                 S   s   i | ]\}}||“qS r%   r%   )rj   ÚkÚvr%   r%   r&   r�     s      z-_inplace_buffer_mutations.<locals>.<dictcomp>c                 S   s   i | ]}|j d kr|j|“qS r}   )rW   rq   r   r%   r%   r&   r�     s    
  Úcall_functionc                    s   | ˆ k	S r?   r%   )r©   ©Únew_noder%   r&   Ú<lambda>  ó    z+_inplace_buffer_mutations.<locals>.<lambda>)ÚnextÚiterÚreversedrV   rW   rJ   rP   r5   Zbuffers_to_mutateZinputs_to_buffersr“   rq   Úinserting_afterÚcreate_noder/   ÚopsZatenZcopy_ÚmetaÚreplace_all_uses_withrL   )r>   rƒ   Zoutput_nodeZreturn_argsZmutation_node_to_bufferZ	mutationsZbuffers_to_inputsZinput_name_to_nodeZmutationZbuffer_nameZ
input_nameZ
input_noder¶   r·   Zuser_outputsr%   r¹   r&   r‡   ë  s4    
ÿ
  ÿÿr‡   c                 C   s$   t | ƒt |ƒk o"|dt | ƒ… | kS )z2Check whether `candidate` is a prefix of `target`.N)rJ   )Ú	candidater)   r%   r%   r&   Ú
_is_prefix#  s    rÆ   )Ú
parent_fqnÚ	child_fqnra   c                 C   s`   | dkr|S |   d¡}|  d¡}|d t|ƒ… |ksJtd|› d| › d�ƒ‚d |t|ƒd … ¡S )Nrm   r,   zChild module 'z(' is not a descendant of parent module 'ú')r-   rJ   r5   Újoin)rÇ   rÈ   Zparent_splitZchild_splitr%   r%   r&   Ú_compute_accessor(  s    

ÿþrË   )r©   Úyc                 C   s0   t jjtdœdd„}|| jƒ||jƒks,t‚d S )Nr´   c                    sº   g }i ‰ t dœ‡ fdd„}t| jƒD ]Š\}}dd„ t ||j¡D ƒ}|dd„ t ||j¡ ¡ D ƒ7 }|jdkrt|j	nd}| 
|› d	|j› d
|› dd |¡› d�¡ |ˆ t|ƒ< q$d |¡S )N)ra   c                    s*   t | tjjƒr"dtˆ t| ƒ ƒ S t| ƒS )Nú%)r3   r/   rM   ÚNoder–   r�   )r•   ©Z	nodes_idxr%   r&   Úarg_dump;  s    z?_verify_graph_equivalence.<locals>.graph_dump.<locals>.arg_dumpc                 S   s   g | ]}t |ƒ‘qS r%   )r–   r¬   r%   r%   r&   rl   A  s     zA_verify_graph_equivalence.<locals>.graph_dump.<locals>.<listcomp>c                 S   s   g | ]\}}|› d |› �‘qS )ú=r%   )rj   ÚkeyÚvaluer%   r%   r&   rl   B  s   ÿr¸   rm   z: ú[z](z, ú)Ú
)r–   r›   rV   re   Ztree_maprP   rQ   r“   rW   r)   rK   rÊ   r�   )r>   ÚretrÐ   r€   rY   Z	args_dumpr)   r%   rÏ   r&   Ú
graph_dump7  s    þ*z-_verify_graph_equivalence.<locals>.graph_dump)r/   rM   r\   r–   r>   r5   )r©   rÌ   rØ   r%   r%   r&   Ú_verify_graph_equivalence6  s    rÙ   )Úgmra   c                 C   s8   d}t | d|› �ƒr|d7 }qd|› �}t| ||ƒ |S )Nr   Ú_spec_rs   )rw   r2   )rÚ   Úspecr€   rq   r%   r%   r&   Ú	_add_specN  s    

rÝ   c                 C   s*   t | |ƒ}| j |¡}| j tj||f¡S r?   )rÝ   r>   Úget_attrr¸   Ú	fx_pytreeZtree_flatten_spec)rÚ   rY   rÜ   rq   Ú	spec_noder%   r%   r&   Ú_generate_flattenW  s    
rá   c                 C   s*   t | |ƒ}| j |¡}| j tj||f¡S r?   )rÝ   r>   rÞ   r¸   re   r°   )rÚ   rV   rÜ   rq   rà   r%   r%   r&   Ú_generate_unflatten]  s    
râ   )r§   r)   c                 C   sX   |  d¡�^ }}|D ]6}t| |d ƒ}|d kr2 d S t|tjjƒsF d S |} qt| |d ƒS )Nr,   )r-   r.   r3   r/   r0   r1   )r§   r)   r8   r9   r:   rz   r%   r%   r&   Ú_get_submodulec  s    rã   )r§   r)   Úmodule_to_addc                 C   sl   |  d¡�^ }}|D ]F}t| |d ƒ}|d krBtj ¡ }t| ||ƒ t|tjjƒsV dS |} q|  ||¡ d S )Nr,   F)r-   r.   r/   r0   r1   r2   r3   Z
add_module)r§   r)   rä   r8   r9   r:   rz   r%   r%   r&   Ú_add_submodulet  s    
rå   c                   @   sf   e Zd Zdeeef eejj	 dœdd„Z
dd„ Zdd„ Zd	d
„ Zdd„ Zdd„ Zdd„ Zdd„ ZdS )Ú_ModuleFrameN)r…   ry   c
              	      st  |ˆ_ |ˆ_|ˆ_|ˆ_|ˆ_|ˆ_|ˆ_|ˆ_dˆ_ˆjd ˆ_	|	d k	rR|	ˆ_
nttj ¡ ƒˆ_
ˆjˆjkr~ˆjˆj ˆ_nd ˆ_ˆj
ˆjˆj< ˆj
jˆ_i ˆ_i ˆ_d ˆ_|d k	ròt|j	ˆj	ƒ}
t|j
|
ˆjd krÜˆj
nˆjƒ |j |
¡ˆ_| ˆj	¡}|d k	�rpˆjd k	�rp|jjdk�s&t‚|jjd }|jjd }|jd k�sNt‚|jd k	�s^t‚ˆj d ¡�î g }t|jƒD ]}| ˆj  d|› �¡¡ �qzi }|jD ]}ˆj  |¡||< �q¤t!ˆj
t"|ƒ|f|jƒ}t#|j$ƒD ]t\}}ˆjj%dt&j'||ft(|t)ƒ�s
|j*nd|› �d	�}t(|t)ƒ�r(�qÞt+ +ˆj|j* j,¡|_,|ˆjˆj|j* < �qÞW 5 Q R X ˆjj -ˆj¡�Ø g }|j$D ]X}t(|t)ƒ�r¢|j.d k�r¢| d ¡ n.t(|t/t0fƒ�s¶t‚| ˆj 1ˆj|j* ¡¡ �qzt2ˆjj
||jƒ}ˆjj 3t&j'|df¡‰ ˆjj 3t&j'|df¡‰‡ ‡fd
d„t|jƒD ƒ}‡‡fdd„|jD ƒ}W 5 Q R X ˆjd k	�s\t‚t"|ƒˆj_4|ˆj_5d S )NFéÿÿÿÿé   r   rs   Z_positional_arg_r¸   Z
_constant_)rW   r)   rP   rq   c                    s"   g | ]}ˆj j tjˆ |f¡‘qS r%   ©Úparentr>   r¸   ÚoperatorÚgetitem)rj   r€   )Ú	args_noderB   r%   r&   rl   ø  s   ÿz)_ModuleFrame.__init__.<locals>.<listcomp>c                    s$   i | ]}|ˆj j tjˆ |f¡“qS r%   ré   )rj   r¶   )Úkwargs_noderB   r%   r&   r�   ü  s   ý  ÿz)_ModuleFrame.__init__.<locals>.<dictcomp>)6Ú
flat_graphrV   Ú
seen_nodesÚseen_modulesrê   Úmodule_stackÚ	module_idr…   Úverboserh   ry   r   r/   rM   r\   Úcached_graph_moduler>   Únode_mapÚnode_to_placeholderÚparent_call_modulerË   rå   Úcall_moduleÚgetr®   Znum_childrenr5   Zchildren_specsÚcontextrÀ   ÚrangerK   rT   rá   rL   r›   ÚinputsrÁ   rë   rì   r3   r   rq   ÚcopyrÃ   Úinserting_beforerÓ   r   r   Úremap_inputrâ   r¸   rP   rQ   )rB   rï   rV   rð   rñ   rê   rò   ró   r…   ry   Úaccessorr­   Z	args_specZkwargs_specZ	arg_nodesr«   Zkwarg_nodesrq   r²   r•   Zflat_arg_nodeZinput_nodesÚinputZinputs_noder%   )rí   rî   rB   r&   rA   ‡  s¼    
ÿú	

ýÿ
ù
 
ÿý ÿ ÿþüz_ModuleFrame.__init__c              	   C   sr   | j dkstd|› d�ƒ‚|j| jks*t‚| j d ¡� | jj|j|jd�}W 5 Q R X t |j	¡|_	|| j
|< d S )Nrm   zCannot add placeholder z to root module)Z	type_expr)rh   r5   r>   rï   rÿ   rT   rq   Útyperþ   rÃ   r÷   )rB   r©   Zplaceholder_noder%   r%   r&   Úadd_placeholder  s    z_ModuleFrame.add_placeholderc                 C   sb   |j | jkst‚|| jkr$| j| S || jkrX|  |¡ | jd k	rX| j d| j 	|¡¡ | j| S )Nr   )
r>   rï   r5   rö   r÷   r  rø   Z
insert_argrê   r   )rB   r©   r%   r%   r&   r     s    




z_ModuleFrame.remap_inputc                    sð  g }ˆ j  ˆ j¡}|d k	rœˆ jd k	rœ|jD ]4}t|ttfƒrP| ˆ j	|j
 ¡ q*td|› �ƒ‚q*tˆ jt‡ fdd„|D ƒƒ|jƒ}tˆ jjˆ j|jƒ}|}nfg }ˆ j ¡ D ]:}|jD ].}|j
ˆ j	kr´| |¡ | ˆ j| ¡  qªq´qªˆ j}t|ƒdk�r|d }t|ttjjfƒ�st‚ˆ j |¡ |d k�r4d S t|tjjƒ�rP|j d¡ndd„ |D ƒ|jd< t|ƒdk�rŽ|d k�rŽ|ˆ jj|d < nDt|ƒD ]:\}	}
tj |¡|	 j }|
j d¡|jd< |ˆ jj|
< �q–ˆ j!d k	�rìt"ˆ j!ˆ jƒ d S )	Nz'Unsupported data type for output node: c                 3   s    | ]}ˆ j ˆ j|j  V  qd S r?   )rö   rð   rq   )rj   rµ   ©rB   r%   r&   rv   ,  s   ÿz0_ModuleFrame.finalize_outputs.<locals>.<genexpr>rs   r   Úvalc                 S   s   g | ]}|j  d ¡‘qS )r  )rÃ   rú   )rj   Úor%   r%   r&   rl   P  s     z1_ModuleFrame.finalize_outputs.<locals>.<listcomp>)#r…   rú   rh   rê   Úoutputsr3   r   r   rK   rð   rq   ÚRuntimeErrorrâ   ry   rL   r±   rá   rø   rö   rž   ÚusersrJ   rH   r/   rM   rÎ   r5   r>   rµ   rÃ   r›   ZProxyrY   rõ   rÙ   )rB   Zorig_outputsr­   rµ   Ztree_out_nodeZ
parent_outZgraph_outputsZ	orig_nodeZ	user_noder€   Zorig_outputZ	proxy_outr%   r  r&   Úfinalize_outputs  s`    
ÿþú  ÿ


ÿýz_ModuleFrame.finalize_outputsc                 C   s6   |   d| ¡ ¡ | j || j¡| j|< || j|j< d S )NÚcopying)r¦   Úformat_noder>   Z	node_copyr   rö   rð   rq   rX   r%   r%   r&   Ú	copy_node_  s    z_ModuleFrame.copy_nodec                 C   sš   d}| j jD ]&}|  ||j d¡| ¡ ¡ |d7 }qd}| j| }|jdkrj|  |¡ |d7 }| j| }qB|  |¡ | j jD ]}|jdkr||  |¡ q|d S )Nr   Únn_module_stackrs   rT   rµ   )	rï   rV   r¦   rÃ   rú   r  rW   r  Úrun_from)rB   r€   rY   Únode_idxr%   r%   r&   Ú	run_outerd  s    





z_ModuleFrame.run_outerc                 O   s   | j rt||Ž d S r?   )rô   r¦   )rB   rP   rQ   r%   r%   r&   r¦   y  s    z_ModuleFrame.printc              
   C   sÖ  d}|t | jƒk �rÒ| j| }|jdks,t‚|  ¡  |  d|| ¡ ¡ |  | j¡ |jdkrzt | jƒdkrn|S |  ¡  |S t |j 	di ¡ƒdkržt
d|› �ƒ‚|jd }ddlm} t |ƒdkrÐ||krÐ| j}nd	d
„ |jd  ¡ D ƒ}|d t | jƒ… | jk�r(|  ¡  |  d| j¡ |  | j¡ |S |d k	�s6t‚t| j|ƒ�r®|t | jƒ }|  d|¡ t| j| j| j| j| | j|g t|jd  ¡ ƒt | jƒ | jƒ |¡}|d7 }q|| jk�s¾t‚|  |¡ |d7 }qd S )Nr   rT   ZSTEPrµ   rs   r  z(Unable to find nn_module_stack for node )Ú_EMPTY_NN_MODULE_STACK_KEYc                 S   s   g | ]\}}|‘qS r%   r%   )rj   ÚpathÚtyr%   r%   r&   rl   ¡  s    z)_ModuleFrame.run_from.<locals>.<listcomp>Z	outliningzCreating new stack frame for)rJ   rV   rW   r5   r¦   r  rò   r  rÃ   rú   r	  Z(torch._export.passes._node_metadata_hookr  r—   rh   r>   rÆ   ræ   rï   rð   rñ   rH   rž   r…   r  r  )rB   r  Z
module_idxrY   r  r  Znode_module_stackZnext_moduler%   r%   r&   r  }  sd    



ÿþÿ
ø	÷

z_ModuleFrame.run_from)N)r   r    r!   r   r–   r   r	   r/   r0   r1   rA   r  r   r  r  r  r¦   r  r%   r%   r%   r&   ræ   †  s    ö	

öBræ   )Ú
orig_graphÚroot_modulec                 C   s>   i }i }t | t| jƒ||d dgddd„ |jD ƒ|d�	 ¡  d S )Nrm   c                 S   s   i | ]}|j r|j|j “qS r%   )r­   rh   ri   r%   r%   r&   r�   Ø  s   þ z'_outline_submodules.<locals>.<dictcomp>)ry   )ræ   rL   rV   r…   r  )r  r  rð   rñ   r%   r%   r&   rˆ   Í  s    þórˆ   rm   )rê   r¤   r8   c                 C   sÒ   |dkrBt | ¡ ƒdd … D ]$}t| |ƒd krt| |tj ¡ ƒ qg }t | j ¡ ƒD ]J\}}|d krfqT|| }t	|||d d� t
| |ƒ | || ||f¡ qT|jt d¡d� |D ]\}}}|  ||¡ q¶d S )Nrm   rs   r,   )r8   r   )rÒ   )rH   rž   rã   rå   r/   r0   r1   Ú_modulesr“   r�   ÚdelattrrK   Úsortrë   Ú
itemgetterZregister_module)rê   r¤   r8   rh   Úchildrenrq   Úchildr‚   r%   r%   r&   r�   á  s    
r�   )ry   r|   ru   c              
      s  t tƒ‰ | j ¡ D ]D\}‰tttjjˆƒ|||g ƒ}| ¡ D ]\}}ˆ |  	|¡ q>qt
| dƒsfˆ S | j}ttdd„ |jƒƒ}|d }	tdd„ |jƒ}
|
D ]F}t| |j d¡ƒ‰ˆdk	rœtˆƒˆ krœtt‡ ‡fdd„|jƒƒ|_qœi }|D ]d}|j|krüqìd}||j D ]0}| d¡}|dt|ƒ… |k�r
|} �q<�q
|dk�rHqì|||< qìg }| ¡ D ]˜\}}t|jƒd	k�rÞ|t|ƒd… }t| |ƒ}t|tjtjfƒ�s¨t‚| |	¡� | d
d |¡¡}W 5 Q R X |j|dd� | |¡ |  |j¡ �q^t| t!ƒ�r|  "¡  t| ƒ|iS )aT  Sink params, buffers, and constants from graph inputs into get_attr nodes.

    Exported modules are purely functional, so they pass their parameters and
    buffers in as inputs to the graph.

    To replicate eager's semantics, we need to get them from the module state
    via get_attr instead.

    module: GraphModule, potentially containining nested submodules.
    inputs_to_state: mapping graph input names to the corresponding key in the state_dict.
    scope: tracks where we are in the module hierarchy, so that we can emit the
        right `getattr(self, "foo.bar")` calls, etc.
    r>   c                 S   s
   | j dkS )NrT   r~   ©r£   r%   r%   r&   r»     r¼   z_sink_params.<locals>.<lambda>rç   c                 S   s
   | j dkS )Nrù   r~   r  r%   r%   r&   r»      r¼   r,   Nc                    s   | j ˆ tˆƒ kS r?   )rq   r�   r  ©Zmodule_id_to_inputs_removedÚ	submoduler%   r&   r»   (  r¼   r   rÞ   T)Zpropagate_meta)#r   rH   r  r“   r˜   r   r/   r0   r1   Úextendrw   r>   ÚfilterrV   Ú_recursive_getattrr)   r-   r�   rL   rP   rq   rJ   r
  r3   r6   r7   r5   rÀ   rÁ   rÊ   rÄ   Z
erase_noderK   r   rZ   )ry   r|   ru   rq   Zsubmod_id_to_inputs_removedr¶   r·   r>   rý   Zthe_last_inputZcall_module_nodesrY   Zinputs_to_state_of_scopeZ
state_nameZsnZsn_splitZinputs_removedÚ	attr_pathZ
state_attrrº   r%   r  r&   r˜   ÷  sf      ÿ
þÿ






r˜   c                 C   s(   |D ]}t | |ƒs d S t| |ƒ} q| S r?   )rw   r.   )Úobjr$  Úattrr%   r%   r&   r#  `  s
    
r#  )T)N)rm   )Grc   rþ   rë   Úcollectionsr   r   Úenumr   Útypingr   r   r   r   r	   r
   r   r   r/   Ztorch.fx._pytreerM   Z_pytreerß   Ztorch.utils._pytreeÚutilsre   Z"torch._library.fake_class_registryr   Ztorch.export._tree_utilsr   Ztorch.export.exported_programr   r   r   r   r   r   Ztorch.fx._symbolic_tracer   r   r   Ú__all__r   r6   r7   r0   r1   r–   Úboolr<   r   ÚABCr   r   r   r\   r‡   rÆ   rË   rÙ   rÝ   rÎ   rá   râ   rã   rå   ræ   rˆ   Úintr�   r˜   r#  r%   r%   r%   r&   Ú<module>   sv   (  ûû$=  ? ÿ þ8	  I ÿ 
 ÿýi