
    qi                      d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl	Z	d dl
Z
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mZmZmZmZmZmZmZ d dlmZ d dlmZ d dlZd dlmc mZ  d dlm!Z!m"Z"m#Z#m$Z$ d d	l%m&Z&m'Z' d d
l(m)Z) d dl*m+Z+ d dl,m-Z- d dl.m/Z/ d dl0m1Z1m2Z2m3Z3m4Z4m5Z5 d dl6m7Z7 d dl8m9Z9 d dl:m;Z; d dl<m=Z= d dl>m?Z? d dl@mAZAmBZB d dlCmDZD d dlEmFZFmGZG d dlHmIZImJZJmKZKmLZLmMZMmNZN d dlOmPZP d dlQmRZR ddlSmTZTmUZUmVZV er(d dlWmXZXmYZYmZZZm[Z[m\Z\ d dlm]Z] d dl^m_Z_ d dl`maZa d d lbmcZcmdZd  ej                  ef      Zgej                  j                  efd!      Zj	 ej                  j                  efd"      ZkeoZpej>                  j                  Zr ed%      Zsej                  j                  j                  ZvdZwd ax G d& d'      Zye G d( d)ez             Z{e G d* d+ez             Z|e G d, d-ez             Z}e G d. d/ez             Z~e G d0 d1ez             Ze G d2 d3ez             Z G d4 d5e	j                        Z e       Zdtd6Zej
                  dud7       Zej
                  dvd9       Z	 	 	 	 	 	 dwd:Zdxd;Zdyd<Zej                  dzd=       Zej                  d{d>       Zd|d?Zd}d@Z G dA dB      Zej                  d~dC       Zej
                  	 	 	 	 dvdD       Zd{dEZ G dF dG      Z G dH dI      Z G dJ dKe$      ZeeAdLdMf   Z edNO       G dP dQ             ZddRZ edNO       G dS dT             Z G dU dV      Z edNdNW       G dX dY             Z edNdNW       G dZ d[             Z edNdNW       G d\ d]             Zereeef   Z edNdNW       G d^ d_e             Z edNdNW       G d` da             Z G db d8eG      ZeZ	 	 	 	 	 	 ddcZ	 	 	 	 	 	 	 	 	 	 	 	 dddZ	 	 	 	 	 	 	 	 ddeZ	 	 	 	 	 	 	 	 ddfZ G dg dhe?      ZddiZddjZddkZej                  j\                  j^                  j`                  eej                  j                  jb                  j`                  dl ej                  j                  jd                  j`                  dm ej                  j                  jf                  j`                  dn iZ eej                  j                  jj                  j`                  ej                  j                  jl                  j`                  ej                  j                  jn                  j`                  ej                  jp                  jr                  jt                        Zd dolmZmZmZmZmZmZmZmZ ddpZej                  ddq       Z	 	 	 	 	 	 	 	 ddrZ	 	 	 	 	 	 	 	 ddsZy# el$ r-Zmd# enem      v r ej                  efd$z         ZknemY dZm[mdZm[mww xY w)    )annotationsN)defaultdict)	dataclass)AnycastLiteralOptionalTYPE_CHECKING	TypeGuardTypeVarUnion)Self)ReferenceType)SymBoolSymFloatSymIntTensor)is_functorch_wrapped_tensoris_legacy_batchedtensor)FakeScriptObject)MissingOpProfile)dtrace_structured)suggest_memory_format)	assert_eqassert_metadata_eqis_sparse_anyis_sparse_compressedMetaConverter)render_call)immutable_dict)normalize_function)StorageWeakRef)TorchFunctionMode)IntLikeTypepy_sym_types)no_dispatch)is_traceable_wrapper_subclassTorchDispatchMode)KeyPathkeystrPyTreetree_map	tree_map_TreeSpec)count)CapturedTraceback   )_CacheKeyState_PySymInputStub_SymIntOutputStub)Callable	GeneratorIterableMappingSequence)TracebackType)Source)
OpOverload)ShapeEnvSymbolicContexthierarchical_compilenot_implementedz 'not_implemented' not registeredz.not_implementedTc                      e Zd ZddZddZy)IncrementRecursionCountc                    t         dz  a y Nr1   RECURSION_COUNTselfs    c/home/ubuntu/crypto_trading_bot/.venv/lib/python3.12/site-packages/torch/_subclasses/fake_tensor.py__init__z IncrementRecursionCount.__init__g       1    c                    t         dz  a y rE   rF   rH   s    rJ   __del__zIncrementRecursionCount.__del__k   rL   rM   NreturnNone)__name__
__module____qualname__rK   rO    rM   rJ   rC   rC   f   s    rM   rC   c                      e Zd ZU ded<   y)UnsupportedFakeTensorExceptionstrreasonNrS   rT   rU   __annotations__rV   rM   rJ   rX   rX   p       KrM   rX   c                      e Zd ZU ded<   y)DynamicOutputShapeExceptionr<   funcNr[   rV   rM   rJ   r_   r_   u       
rM   r_   c                      e Zd ZU ded<   y)DataDependentOutputExceptionr<   r`   Nr[   rV   rM   rJ   rc   rc   z   ra   rM   rc   c                      e Zd ZU ded<   y)UnsupportedOperatorExceptionr<   r`   Nr[   rV   rM   rJ   re   re      ra   rM   re   c                      e Zd ZU ded<   y)$UnsupportedMutationAliasingExceptionrY   rZ   Nr[   rV   rM   rJ   rg   rg      r]   rM   rg   c                      e Zd ZU ded<   y)MetadataMismatchErrorrY   rZ   Nr[   rV   rM   rJ   ri   ri      r]   rM   ri   c                  *    e Zd ZU ded<   ded<   ddZy)FakeTensorTLSOptional[bool]allow_non_fake_inputs_overridezweakref.WeakSet%non_strict_export_fake_tensor_trackerc                D    d | _         t        j                         | _        y N)rm   weakrefWeakSetrn   rH   s    rJ   rK   zFakeTensorTLS.__init__   s    .2+5<__5F2rM   NrP   )rS   rT   rU   r\   rK   rV   rM   rJ   rk   rk      s     %32+::GrM   rk   c                 .    t         j                  | d      S NT)dictfromkeys)itemss    rJ   ordered_setrx      s    ==%%rM   c               #  *  K   t         j                  j                  t         j                  j                  j                        } 	 |  |  t         j                  j                  |        y y # |  t         j                  j                  |        w w xY wwrp   )torch_C_unset_dispatch_mode_TorchDispatchModeKeyFAKE_set_dispatch_mode)olds    rJ   unset_fake_temporarilyr      sl     
((
'
'(F(F(K(K
LC-	?HH'', 3?HH'', s   ABA, 	#B,$BBFakeTensorModec              #  b   K   | j                   }	 d| _         d  || _         y # || _         w xY ww)NF)cache_enabled)	fake_mode	old_values     rJ   disable_fake_tensor_cacher      s1     --I,"'	"+	)	s   /# /	,/c                   | g}|rf|j                         t              s|j                         /j                         \  }}|j	                  fdt        |      D               |rf|S )Nc              3  6   K   | ]  }t        |        y wrp   )getattr).0keycurrs     rJ   	<genexpr>z$get_plain_tensors.<locals>.<genexpr>   s     G3GD#&Gs   )popr'   append__tensor_flatten__extendreversed)subclassouttodo
inner_keys_r   s        @rJ   get_plain_tensorsr      sf     :D
xxz,T2JJt//1
AG(:2FGG  JrM   c                   ddl m} t        | t              ryt	        |       rht        |       j                  |       \  }}|D cg c]  }t        | |       }}t        d |D              }t        d |D              }||k(  sJ d       |S t        | |      rt        | j                        S t        | t              rht        j                  |       rSt        j                  j!                         }t        j                  j"                  j%                  | |      }	t        |	      S t        | t              r?t'        |       r4t        j                  j"                  j)                  |       }	t        |	      S yc c}w )Nr   FunctionalTensorTc              3  2   K   | ]  }t        |        y wrp   is_faker   xs     rJ   r   zis_fake.<locals>.<genexpr>        =awqz=   c              3  2   K   | ]  }t        |        y wrp   r   r   s     rJ   r   zis_fake.<locals>.<genexpr>   r   r   z got mixed fake and real tensors!F)#torch._subclasses.functional_tensorr   
isinstance
FakeTensorr'   typer   r   allanyr   elemr   rz   _is_functional_tensorr{   $_functionalization_reapply_views_tls
_functorch_unwrap_functional_tensorr   get_unwrapped)
r   r   attrsr   attrflattened_tensorsall_fakeany_fakereapply_views	unwrappeds
             rJ   r   r      s1   D!Z $Q'7--a0q:?@$WQ-@@=+<===+<==8#G%GG#	A'	(qvv	Av	5#>#>q#AEEGHH''AA!]S	y!!	Av	#>q#AHH''55a8	y!! As   E4c           	        ddl m} t        | t              r| j                  S t        |       rR| j                         \  }}|D cg c]  }t        t        | |             }}|d   t        fd|D              sJ S t        | |      rt        | j                        S t        | t              rht        j                  |       rSt        j                  j                         }t        j                  j                   j#                  | |      }t        |      S t        | t              r?t%        |       r4t        j                  j                   j'                  |       }t        |      S y c c}w )Nr   r   c              3  &   K   | ]  }|u  
 y wrp   rV   )r   r   ms     rJ   r   z&maybe_get_fake_mode.<locals>.<genexpr>   s     )a16)s   )r   r   r   r   r   r'   r   maybe_get_fake_moder   r   r   r   rz   r   r{   r   r   r   r   r   )	tr   inner_tensor_namesr   t_namemodesr   r   r   s	           @rJ   r   r      s*   D!Z {{$Q' ! 4 4 6ABT
8>6 23
 
 !H)5))))	A'	("166**	Av	5#>#>q#AEEGHH''AA!]S	"9--	Av	#>q#AHH''55a8	"9--
s   E*c                T    t         j                  j                  | j                        S rp   )rz   r{   _SchemaInfo_schemar`   s    rJ   get_schema_infor      s    88--rM   c                    ddl m} t        j                  j                  }||    j
                  j                  d      xr ||    j                  t        |      v S )Nr   decomposition_tableztorch._decomp)	torch._decompr   rz   _decompdecompositionsrT   
startswithrS   dir)r`   r   r   s      rJ   torch_decomp_decompositionsr      sV    1]]11N t$//:: D
d
#
,
,N0C
CDrM   c                p    t         j                  |      }|D cg c]  }t        ||       s| c}S c c}w rp   )pytreetree_leavesr   )tytree	flat_valsr   s       rJ   tree_flatten_onlyr     s/    ""4(I&?T*T2*>D???s   33c                    t        |       t        u xrk | j                  t        j                  k(  xrL | j
                  xs= | j                  xs/ t        |       xs" t        |       xs t        j                  |        S rp   )
r   r   layoutrz   strided	is_sparse	is_nestedr   r   r   )r   s    rJ   _is_plain_tensorr     sx    Q6 	
HH%	
 KK .{{.*1-. 'q). **1-

rM   c                      e Zd ZU e	 	 dd       Zded<   ded<   ded<   ddd	dd
ZddZddZddZ	ddZ
	 	 ddddd	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddZ	 	 d	 	 	 	 	 	 	 	 	 	 	 ddZy)FakeTensorConverterc                .    | j                   j                  S rp   )meta_convertertensor_memorH   s    rJ   r   zFakeTensorConverter.tensor_memo%  s     ""...rM   r   r   z)dict[StorageWeakRef, list[ReferenceType]]constant_storage_mappingboolexportF	copy_datar   c               B    t        |      | _        || _        i | _        y )N)r   )r   r   r   r   )rI   r   r   s      rJ   rK   zFakeTensorConverter.__init__1  s     +i@ )+%rM   c                "   t        |t              r|j                  J t        |j                  j	                               }|| j
                  vrg | j
                  |<   | j
                  |   j                  t        j                  |             y rp   )	r   r   constantr"   _typed_storager   r   rq   ref)rI   fake_tensorweak_sts      rJ   add_constant_storage_mappingz0FakeTensorConverter.add_constant_storage_mapping8  sz     +z2{7K7K7WWW !5!5!D!D!FG
 $77757D))'2%%g.55gkk+6NOrM   c                    t        |t              rJ t        |j                               }|| j                  vry | j                  |   D ]#  } |       }||j                          d |_        % | j                  |= y rp   )r   r   r"   r   r   _fix_weakrefr   )rI   tensorr   weak_tensor_reftens        rJ   invalidate_constant_aliasesz/FakeTensorConverter.invalidate_constant_aliasesF  s    fj111 !6!6!89$777#<<WE 	$O!#C  "#		$ ))'2rM   c                    | j                   j                  j                  j                  |      }|y | j                  j                  |      S rp   )r   	describerlookup_tensorgetr   )rI   r   tids      rJ   	_get_memozFakeTensorConverter._get_memoU  sC    !!++99==a@;##C((rM   c                    | j                   j                  j                  |      }|| j                   j                  |<   y rp   )r   r   get_tensor_idr   )rI   r   vr   s       rJ   set_tensor_memoz#FakeTensorConverter.set_tensor_memo[  s4    !!++99!</0'',rM   NT)sourcesymbolic_contexttracec                  |sk|si|rgt         j                  j                  j                         x}r=||j                  v r/|j                  |   }ddlm}	 t        ||	      sJ |j                  }| j                  |      }
|
|
S |j                  rt        d      t        |      t         j                  j                  u r|rJ |r|nd 	 	 	 	 	 	 dfd}| j                  ||||||      }|t         u rt        d      ddlm} d }| j&                  st)        |      r|j+                         dk(  r|j,                  j                  dk(  ru|j.                  t         j0                  t         j2                  t         j4                  t         j6                  t         j8                  fv r|t        ||      s|dd	lm}m} dd
lm} tA               5  |jC                         }d d d        tE        jF                  |      stE        jH                  |      st        ||      r|jJ                  }n ||      }|jM                  |||jN                  |      }|j.                  t         j0                  k(  r|jQ                  |||      |_)        n6|j.                  t         j8                  k(  r|jU                  |||      |_)        |r| jW                  |       |S # 1 sw Y   xY w)Nr   )StatefulSymbolicContextzquantized nyi in meta tensorsc                l    t               5  t         |        |      cd d d        S # 1 sw Y   y xY w)Nr   )r&   r   )make_meta_tdevicer   r   s     rJ   mk_fake_tensorz<FakeTensorConverter.from_real_tensor.<locals>.mk_fake_tensor  s7      
!M &	
 
 
s   *3)	shape_envcallbackr   r   r   zmeta converter nyi)RandomValueSourcecpu)CallMethodItemSourceFloatTensorSource)
DimDynamic)r   dynamic_dimr   )hintr   )r  zCallable[[], object]r  zUnion[torch.device, str]rQ   r   ),rz   _guardsTracingContexttry_gettensor_to_context%torch.fx.experimental.symbolic_shapesr  r   tensor_sourcer   is_quantizedrX   r   nn	Parameterr   NotImplementedtorch._dynamo.sourcer	  r   r   dimr  dtypeint64int32int16int8float64r  r  r  r&   itemmathisnanisinfbasecreate_unspecified_symbolDYNAMICcreate_symintnode	item_memocreate_symfloatnoder   )rI   r   r   make_constantr  r   r   r   tracing_contextr  
maybe_memor  r   r	  valuer  r  r  item_sourcesymbolr   s    `                  @rJ   from_real_tensorz$FakeTensorConverter.from_real_tensore  s     9"'--">">"F"F"HHH999'6'H'H'K$ &&68OPPP-;;F^^A&
!>>01PQQ7ehh((($$$%14
	-	7O		, !!#- " 
 . 01EFF: #1& U[[%++uzz5==QR"$ v'89 %TH !!::e$TZZ->f&78"(++K"6v">K"<<& * 2 2%5	 =  77ekk)$-$?$?"* %@ %CM
 WW-$-$A$A"* %B %CM
 --c2
?! !s   KK$c                    |j                   j                  dk(  sJ d|j                   j                   d       | j                  |      }||S t        |||||      }| j	                  ||       |S )Nmetaz$tensor's device must be `meta`, got z instead)pytypedispatch_keys)r  r   r   r   r   )rI   r   r   r  r5  r6  r.  r   s           rJ   from_meta_and_devicez(FakeTensorConverter.from_meta_and_device  s}     xx}}& 	
2188==/J	
&
 ^^A&
!q&}
 	Q$
rM   )rQ   zweakref.WeakValueDictionary)r   r   r   r   rQ   rR   )r   r   rQ   rR   )r   r   rQ   rR   )r   r   rQ   Optional[FakeTensor])r   r   r   r   rQ   rR   )FN)r   r   r   r   r,  r   r  Optional[ShapeEnv]r   Optional[Source]r   Optional[SymbolicContext]r   r   rQ   r   )NN)r   r   r   r   r  torch.devicer5  zOptional[type[torch.Tensor]]r6  Optional[torch.DispatchKeySet]rQ   r   )rS   rT   rU   propertyr   r\   rK   r   r   r   r   r2  r7  rV   rM   rJ   r   r   $  s   /	$/ / "!GGL,1% +P3)1 $(,O $(6:O!O O 	O
 &O !O 4O O 
On 048<!  	
 - 6 
rM   r   c                   t         j                  j                         st         j                  j                         rIt         j                  j
                  t        j                  d|       nt        j                  d|        y y )Nr1   r  )rz   cudais_availablexpuversionhipemptyzerosr@  s    rJ   init_gpu_contextrH    sY     zz EII$:$:$< }}  ( KK&)Qv.	 %=rM   c              #    K   | j                   }t        j                  j                         }||k(  sJ | d|        t        j                  j	                         5  d| _         t        j                  j                         5  t        j                  j                  d       	 d  || _         	 d d d        d d d        y # || _         w xY w# 1 sw Y   xY w# 1 sw Y   y xY ww)N, T)in_kernel_invocationrz   r{   _meta_in_tls_dispatch_include_DisableTorchDispatch_PreserveDispatchKeyGuard!_set_meta_in_tls_dispatch_include)r   prev_in_kernelmeta_in_tlss      rJ   in_kernel_invocation_managerrR    s     
 33N((88:K.(L[MN;K*LL(		'	'	) 	@)-	& XX//1 	@HH66t<@1?	.	@		@ 	@ 2@	.	@ 	@		@ 	@sN   AC$&C C#C 'C/C7	C$ 	C		CC	CC!C$c                    t         j                  j                  | j                         j	                  d      d   j	                  d      d         S )Nz::.r   )rz   r{    _should_allow_numbers_as_tensorsnamesplitr   s    rJ   should_allow_numbers_as_tensorsrY  0  sB    8844		$#))#.q1 rM   c                  J    e Zd Zej                  j                  dd      dk(  Zy)FakeTensorConfigTORCH_FAKE_TENSOR_DEBUG01N)rS   rT   rU   osenvironr   debugrV   rM   rJ   r[  r[  6  s    JJNN4c:cAErM   r[  c                  z    e Zd ZU ded<   ded<   ddddZddZdd	Zdd
ZddZ	 d	 	 	 	 	 ddZ		 	 	 	 	 	 ddZ
y)SymNumberMemoDescriptorrY   _namer   _is_nested_intFis_nested_intc                   || _         y rp   )re  )rI   rg  s     rJ   rK   z SymNumberMemoDescriptor.__init__O  s
    +rM   c                    || _         y rp   rd  )rI   ownerrW  s      rJ   __set_name__z$SymNumberMemoDescriptor.__set_name__R  s	    
rM   c                     d| j                    S )Nr   rj  rI   objs     rJ   _memozSymNumberMemoDescriptor._memoU  s    4::,rM   c                "    d| j                    dS )Nr   _vcrj  rn  s     rJ   _memo_vcz SymNumberMemoDescriptor._memo_vcX  s    4::,c""rM   c                "    d| j                    dS )Nr   _epochrj  rn  s     rJ   _memo_epochz#SymNumberMemoDescriptor._memo_epoch_  s    4::,f%%rM   Nc                   t        || j                  |            x}y t        |t        j                        r|j
                  j                  |S | j                  s(t        || j                  |            |j                  k7  s>| j                  sOt        || j                  |            |j                  j                  k7  rt        || j                  |      d        y |S rp   )r   rp  r   rz   r   noder  re  rs  _versionrv  r   epochsetattr)rI   ro  objtypers       rJ   __get__zSymNumberMemoDescriptor.__get__b  s     djjo..A7 a(QVV[[-DH
 ##T]]35G(HCLL(X##T--c23s}}7J7JJCC$/rM   c                   |Ut        || j                  |      d        t        || j                  |      d        t        || j                  |      d        y |j	                         r| j
                  rt        || j                  |      |       | j
                  s&t        || j                  |      |j                         t        || j                  |      |j                  j                         y y rp   )	r{  rp  rs  rv  is_inferencere  ry  r   rz  )rI   ro  r/  s      rJ   __set__zSymNumberMemoDescriptor.__set__x  s     =CC$/Cs+T2C))#.5!!#t':':CC%0&&T]]3/>C))#.0C0CD	 (;rM   )rg  r   rQ   rR   )rk  rY   rW  rY   rQ   rR   )ro  r   rQ   rY   rp   )ro  r   r|  zOptional[type[FakeTensor]]rQ   -Optional[Union[torch.SymInt, torch.SymFloat]])ro  r   r/  r  rQ   rR   )rS   rT   rU   r\   rK   rl  rp  rs  rv  r~  r  rV   rM   rJ   rc  rc  E  sp    J 05 , #& FJ(B	6,EE&SE	ErM   rc  c                       e Zd ZU dZded<   ded<   ded<   ded<    e       Z e       Z e       Z e       Z	 ed	
      Z
ded<   ded<   ej                  j                  j                  Zedd       Zej$                  dd       Zedd       Zej$                  d d       Ze	 	 	 	 d!	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d"d       Zd# fdZed$d       Zeed e       f	 	 	 	 	 	 	 	 	 d%d              Ze	 	 	 	 	 	 d&d       Zdd	 	 	 d'dZd(dZ xZS ))r   al  
    Meta tensors give you the ability to run PyTorch code without having to
    actually do computation through tensors allocated on a `meta` device.
    Because the device is `meta`, meta tensors do not model device propagation.
    FakeTensor extends MetaTensors to also carry an additional `fake_device`
    which tracks devices that would have been used.
    r<  fake_devicer   r   Optional[Tensor]r   real_tensorTrf  Optional[type[Tensor]]r5  r=  r6  c                p    | j                   j                  rt        j                  d      S | j                  S Nr4  )r   rK  rz   r  r  rH   s    rJ   r  zFakeTensor.device  s,     >>..<<''###rM   c                    t         rp   NotImplementedErrorrI   r   s     rJ   r  zFakeTensor.device      !!rM   c                    t        d      )Nz+torch.compile doesn't support named tensors)rX   rH   s    rJ   nameszFakeTensor.names  s     -9
 	
rM   c                    t         rp   r  r  s     rJ   r  zFakeTensor.names  r  rM   c                   t        j                  | ||j                  d|      }|j                  s t        j
                  j                  |       nt        j
                  j                  |       |j                  j                  dk(  sJ |j                  j                         t        |t        j                        r|nt	        j                  |      }|j                  s|j                  dk7  sJ |j                  dv rt        |       |j                  ddddd	t        j
                  j                         fv r|j                  |j                  dk7  rst        t        |j                        j!                         rKt	        j                  |j                   d
t        t        |j                        j#                                }n"t	        j                  |j                   d      }||_        ||_        ||_        ||_        ||_        t        |t.              rJ ||_        d |_        d |_        d |_        d |_        d |_        t<        j>                  rtA        jB                         |_"        |S )NT)dispatch_devicedevice_for_backend_keysr4  )rA  rC  rA  hpurC  mpsmtia:z:0)#r   _make_subclassrequires_grad_allow_unsafe_data_ptr_accessrz   r{   _set_throw_on_mutable_data_ptr(_set_warn_deprecated_on_mutable_data_ptrr  r   r   
allow_metarH  _get_privateuse1_backend_nameindexr   is_initializedcurrent_devicer  r   r   r5  r6  r   r  nonzero_memor*  unique_memounique_consecutive_memonested_int_memor[  ra  r0   extract_debug_trace)	clsr   r   r  r   r  r5  r6  rI   s	            rJ   __new__zFakeTensor.__new__  s     $$ $*
 66HH33D9HH==dC{{6);4;;+;+;;)%fell;fAU ##;;&(((;;/)V$ KK668 ${{e#v{{(C(R(R(T{{m1WUFKK%@%O%O%Q$RS R&89!" *k:666& '+$#!! 1 9 9 ;DrM   c                    t         |           t        j                  j	                         rEt        j
                  j                  j                  r t        j                  j                  |        y y y rp   )superrK   rz   compileris_exporting_exportconfig#detect_non_strict_fake_tensor_leaksfake_tensor_tlsrn   add)rI   argskwargs	__class__s      rJ   rK   zFakeTensor.__init__.  sP    NN'')$$HHAAEEdK I *rM   c                $    |j                  |       S rp   )from_tensor)r   r   s     rJ   r  zFakeTensor.from_tensor6  s    $$Q''rM   rV   c                   |t         j                  j                  j                  j                  u r`t        |      dk(  rt        |d   t              sJ |d   j                  j                  rt        j                  d      S |d   j                  S t        j                  |      x}r ||      S |D cg c]  }t        |t              r|t        us|  }}|rt        j!                  d|       t"        S d }t%        j&                  |i |D ]   }	t        |	t              s|	j                  } n |J t         j(                  j+                  t         j(                  j,                  j.                        }
|
rt        j!                  d||
       t"        S |j                  rJ |5   ||i |cd d d        S c c}w # 1 sw Y   y xY w)Nr1   r   r4  z(FakeTensor unrecognized subclass(es): %sz(FakeTensor mode already active: %s in %s)rz   opsprimr  defaultlenr   r   r   rK  r  _DISPATCH_META_HANDLERSr   
issubclassr   not_implemented_logra  r  r   arg_tree_leavesr{   _get_dispatch_moder}   r~   )r  r`   typesr  r  handlerr   unrecognized_typesr   argmaybe_cur_fake_modes              rJ   __torch_dispatch__zFakeTensor.__torch_dispatch__:  s    599>>((000t9>ja*&EEEAw  55||F++Aw*** .11$77774=  
Jq*$=!6/A
 
 %%:<N "!	))4:6: 	C#z*MM		
 $$$ $hh99HH**//
 %%:#
 "!1111 	)((	) 	)K
J	) 	)s   4F7
F7F7%F<<Gc                Z   	
 d d}d 	t        t        j                  j                        
t        t        j                  j                        ddd	fdd
 	
fd}|D ]
  } ||        t               rd}t        j                  d      
J d         |fS )NFc                     | j                   dk(  S )Nr
  )r   r@  s    rJ   check_cpu_devicez8FakeTensor._find_common_device.<locals>.check_cpu_device  s    ;;%''rM   c                R     | j                         xr | j                         dk(  S Nr   )r  r  )r   r  s    rJ   cpu_zero_dimz4FakeTensor._find_common_device.<locals>.cpu_zero_dim  s!    #AHH->!%%'Q,>rM   c                   t        | t              sy | j                   	|       y  	|       }| j                  k(  rr|y 
v }|r|sy r|s| j                  |y 
v r"t        t	        | j                  f            ry t
        j                  j                  j                  }|>|j                  v }|| j                  j                  v }|s|r| j                  |y |r|sy t        d
 d d| j                         )Nz,Unhandled FakeTensor Device Propagation for z, found two different devices rJ  )r   r   r  r   maprz   r   r  fake_tensor_prefer_device_typer   RuntimeError)r   t_is_cpu_zero_dim&is_bypass_zero_dim_cpu_tensor_check_opprefer_device_typecommon_has_preferredt_has_preferred$bypass_zero_dim_cpu_tensor_check_opsr  common_devicer  r`   is_cpu_zero_dimmixed_device_fnss         rJ   merge_devicesz5FakeTensor._find_common_device.<locals>.merge_devices  s;    a,$ !".q/ ,Qxx=("&7O << 3 !)O 'M !"3 ''s+mQXX-FGH "'!1!1!8!8!W!W!-'9]=O=O'O$"4"E+$%HHM&7O)/ >tfDbcpbqqstut|t|s}~ rM   Tr
  z!Could not find common device for )r  r<  rQ   r   r   r   rQ   r   )r   objectrQ   rR   )rx   aten_foreach_copyr  	nextafterrY  rz   r  )r`   	flat_argshas_scalar_only_inputsr  r  r  r  r  r  r  r  s   `    @@@@@@rJ   _find_common_devicezFakeTensor._find_common_device  s     !& '&&

 0;NN""0
,	(	?;	 ;	z  	C#	 +40]5J%)"!LL/M(T,MdV*TT(444rM   r1   )coeffc                   | j                   !| j                  j                  d       | _         t        | j                   t        j
                        sJ | j                   |z  S )Nnt_tensor_id)r  r   create_symbolic_nested_intr   rz   r   )rI   r  s     rJ   get_nested_intzFakeTensor.get_nested_int  s]    
 '#'>>#L#L! $M $D  $..===##e++rM   c                    | j                         dk(  r| j                         S | j                         dk(  r| D cg c]  }|j                          c}S | D cg c]  }|j                          c}S c c}w c c}w Nr   r1   )r  r"  tolist)rI   r   s     rJ   r  zFakeTensor.tolist  s^    88:?99;XXZ1_,01DDIIK11.23dDKKM33 23s   A3A8)rQ   r<  )r   r<  rQ   rR   )rQ   	list[str])r   r  rQ   rR   )NNNN)r   r   r   r   r  r<  r   r  r  r  r5  r  r6  r=  rQ   r   )r  r  r  r  rQ   rR   )r   r   r   r   rQ   r   
r`   r<   r  Sequence[type]r  Sequence[object]r  Mapping[str, object]rQ   r  )r`   r<   r  r  rQ   ztuple[torch.device, bool])r  zUnion[int, torch.SymInt]rQ   torch.SymInt)rQ   r   ) rS   rT   rU   __doc__r\   rc  r  r*  r  r  r  rz   r{   r}   r~   	_mode_keyr>  r  setterr  staticmethodr  rK   r  classmethodr/   r    r  r  r  r  __classcell__r  s   @rJ   r   r     s    !!
 +,L')I)+K57
 .DAO
 #"11 ..33I$ $ ]]" "& 
 

 \\" "  &*(,)-8<G!G G 	G
 #G &G 'G 6G 
G GvL ( ( 

 "$'5'7G)G) G) 	G)
 %G) 
G)  G)R f5f5%5f5	"f5 f5V +,
, (
, 
	
,4rM   r   r3   r4   T)slotsc                      e Zd ZU dZded<   ded<   ded<   ded<   d	ed
<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   	 	 	 	 	 	 	 	 ddZy) TensorMetadatazK
    The Tensor metadata relevant to hashing FakeTensors when caching.
    ztorch.dtyper  ztuple[_MetadataIntLike, ...]shapestrider<  r  ztorch.layoutr   zOptional[torch.memory_format]memory_format_MetadataIntLikestorage_offsetzOptional[_MetadataIntLike]storage_bytesr   r  r  is_conjis_negr  r   rl   is_coalescedOptional[int]	dense_dim
sparse_dimc                d   t        j                  |       D ]  }t        | |j                        }t	        |t
        t        t        j                  f      r'g }|j                  ||||       |j                          et	        |t              r|j                  ||       |j                  |        y rp   )dataclassesfieldsr   rW  r   tuplelistrz   Size_prep_args_for_hashclearr   convert_sym_intr   )rI   resultmodestatefieldr/  id_hashed_objectss          rJ   _flatten_intozTensorMetadata._flatten_into  s     !''- 	%ED%**-E%%uzz!:; 35!((?PQ!'')E6*%%fe4e$	%rM   N)r  list[object]r  r   r  r2   rQ   rR   )rS   rT   rU   r  r\   r  rV   rM   rJ   r  r    s     ''((00$$--MLO  %% % 	%
 
%rM   r  c                   t        |       }| j                  st        |       s| j                  |      sd}| j	                         }t        | j                  | j                  | j                  t        j                  k(  r| j                         nd| j                  | j                  ||t        |       s| j                         j                         nd| j                  | j                   | j#                         | j%                         | j'                         | j(                  | j(                  r| j+                         ndt        |       r| j-                         ndt        |       r| j/                               S d      S )z1
    Extract the TensorMetadata of a tensor.
    )r   NrV   )r   _has_symbolic_sizes_stridesr   is_contiguousr  r  r  r  r   rz   r   r  r  untyped_storagenbytesr  r  r  r  r  r   r  r  r	  )r   r   r  s      rJ   extract_tensor_metadatar  5  s    *!,M 	
%%];%%'N		hh%--/
R		,9!,<""$$						
		KKT&q)t'*% $ 15% rM   c                  F    e Zd ZU dZded<   ded<   ddZddZddZdd	Zy
)_DispatchCacheKeyz0
    Key for the FakeTensor dispatch cache.
    tuple[object, ...]r   int	hashvaluec                2    || _         t        |      | _        y rp   )r   hashr$  )rI   tups     rJ   rK   z_DispatchCacheKey.__init__d  s    crM   c                X    t        |t              xr | j                  |j                  k(  S rp   )r   r!  r   )rI   others     rJ   __eq__z_DispatchCacheKey.__eq__h  s"    %!23MEII8MMrM   c                    | j                   S rp   )r$  rH   s    rJ   __hash__z_DispatchCacheKey.__hash__k  s    ~~rM   c                h    | j                   D ]#  }t        |t              s|j                          % y rp   )r   r   r3   strip_shape_env)rI   r   s     rJ   r.  z!_DispatchCacheKey.strip_shape_envn  s-      	$A!_-!!#	$rM   N)r'  r"  rQ   rR   )r)  r  rQ   r   )rQ   r#  rP   )	rS   rT   rU   r  r\   rK   r*  r,  r.  rV   rM   rJ   r!  r!  [  s)     
N#N$rM   r!  c                      e Zd Zy)SingletonConstantN)rS   rT   rU   rV   rM   rJ   r0  r0  x  s    rM   r0  )frozenr  c                  >    e Zd ZU dZded<   ded<   ded<   eZded<   y	)
_DispatchCacheEntryOutputInfoa  
    Entry type for the FakeTensor dispatch cache for an output. Accounts for three
    possibilities:
    1) The op is inplace, and a hit means we need to alias the argument at a
       given index.
    2) We need to synthesize a new FakeTensor given tensor metadata. For view
       ops, we further capture the index of the arg to alias.
    3) if the tensor related fields are None, then it is a constant value (e.g.
    None or integer)
    r  inplace_idxzOptional[TensorMetadata]metadataview_idxzOptional[Any]constant_valueN)rS   rT   rU   r  r\   r0  r7  rV   rM   rJ   r3  r3  |  s%    	 &&$5NM5rM   r3  c                  *    e Zd ZU dZded<   dZded<   y)_DispatchCacheValidEntryz
    Entry type for the FakeTensor dispatch cache. It supports two types of outputs
    1) tensor
    2) tuple of tensors

    is_output_tuple flag helps in differentiating the return type
    z$tuple[_DispatchCacheEntryOutputInfo]output_infosFr   is_output_tupleN)rS   rT   rU   r  r\   r;  rV   rM   rJ   r9  r9    s     76!OT!rM   r9  c                      e Zd ZU dZded<   y)_DispatchCacheBypassEntryz0
    Entry type for a negative cache entry.
    rY   rZ   NrS   rT   rU   r  r\   rV   rM   rJ   r=  r=         KrM   r=  c                      e Zd ZU dZded<   y)_BypassDispatchCachez<
    Signals cases that should skip FakeTensor caching.
    rY   rZ   Nr>  rV   rM   rJ   rA  rA    r?  rM   rA  c                  :    e Zd ZU dZded<   ded<   ded<   ded<   y)	DispatchCacheInfozG
    Information about the state of the FakeTensor dispatch cache.
    r#  hitsmissesdict[str, int]bypassessizeNr>  rV   rM   rJ   rC  rC    s     IK
IrM   rC  c                      e Zd ZU i Zded<   dZded<   dZded<    ee      Z	ded<   dZ
ded	<   d
Zded<   ded<   ded<   ded<   ded<   dZded<   dZded<   dd
ddd
d	 	 	 	 	 	 	 	 	 	 	 dE fdZdFdZdGdZedHd       ZedId       Zed e       f	 	 	 	 	 	 	 	 	 dJd       ZdK fd Z	 	 	 	 	 	 	 	 dL fd!ZedHd"       ZedMd#       ZedFd$       Z	 	 	 	 	 	 	 	 	 	 dJd%Z	 	 	 	 	 	 	 	 	 	 dNd&Z	 	 	 	 	 	 	 	 dOd'Z	 	 	 	 	 	 	 	 	 	 dPd(Z 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dQd)Z!	 	 	 	 	 	 	 	 	 	 	 	 	 	 dRd*Z"	 	 	 	 	 	 	 	 	 	 	 	 	 	 dSd+Z#	 	 	 	 	 	 	 	 	 	 	 	 dTd,Z$	 	 	 	 	 	 	 	 	 	 	 	 dUd-Z%	 	 	 	 	 	 	 	 	 	 	 	 dVd.Z&d e       f	 	 	 	 	 	 	 	 	 dJd/Z'	 	 	 	 	 	 	 	 	 	 dWd0Z(	 	 	 	 	 	 	 	 	 	 	 	 dXd1Z)	 	 	 	 	 	 	 	 	 	 dYd2Z* e+d3d4d5d6d7d8d9d:      Z,dZd;Z-	 	 	 	 	 	 	 	 	 	 d[d<Z.	 	 	 	 	 	 	 	 	 	 d\d=Z/dd>	 	 	 d]d?Z0 e+e1jd                  jf                  e1jh                  jj                  e1jl                  jj                  e1jn                  jj                  e1jp                  jj                  e1jr                  jj                  e1jt                  jj                  e1jv                  jj                  e1jx                  jj                  e1jz                  j|                  e1j~                  jj                        Z@ e+e1j                  jj                  e1j                  jj                  e1j                  j                        ZEdZd@ZF e+e1j                  jj                  e1j                  jj                        ZId^dAZJ	 	 	 	 	 	 	 	 	 	 d_dBZKdddddC	 	 	 	 	 	 	 	 	 	 	 d`dDZL xZMS )ar   ,dict[_DispatchCacheKey, _DispatchCacheEntry]cacher   r#  
cache_hitscache_missesrF  cache_bypassesrz  Fr   rK  static_shapesr9  r  zOptional[str]_stackr  rT  nt_tensor_id_counternt_tensor_id_initial_countTN)allow_fallback_kernelsallow_non_fake_inputsr  rO  r   c                  t         j                  dt        |              t        |           || _        dd l}dd l}|j                  j                  j                  | _        t        | j                  |      | _        ||| _        n	|d u | _        d| _        |j                  j                  j                   | _        |j                  j                  j$                  | _        |j(                  j                  j*                  xr | j                   | _        |j(                  j                  j.                  | _        || _        d| _        g | _        || _        t;        j<                         | _        d | _         |jB                  jD                  jF                  | _$        dd l%}|jL                  jN                  jP                  jR                  | _*        | jT                  | _+        y )Nzcreate_mode 0x%xr   r   F),logra  idr  rK   rS  torch._dynamo.configtorch._functorch.configr   r  "fake_tensor_propagate_real_tensorspropagate_real_tensorsr   fake_tensor_converterrO  allow_scalar_outputs(fake_tensor_allow_unsafe_data_ptr_accessr  fake_tensor_allow_metar  _dynamofake_tensor_cache_enabledr   $fake_tensor_cache_crosscheck_enabledcache_crosscheck_enabledrT  rK  enter_stackr  	tracebackextract_stack_stack_tracerP  r{   r}   r~   r  $torch.nested._internal.nested_tensornested	_internalnested_tensor_tensor_id_counterrR  rQ  )rI   rS  rT  r  rO  r   rz   r  s          rJ   rK   zFakeTensorMode.__init__  s   $ 			$bh/&<##& ##FF 	# &911&
"
 $!.D!*d!2D %*! ##LL 	*  **11HHMM  :: 0/// 	
 MM  EE 	% &;" %*!  	 #%335 77<<3 LL""00CC 	' %)$C$C!rM   c                &    | j                   | _        y rp   )rR  rQ  rH   s    rJ   reset_nt_tensor_id_counterz)FakeTensorMode.reset_nt_tensor_id_counter?  s    $($C$C!rM   c                B    t        |t              xr |j                  | u S rp   )r   r   r   rI   r   s     rJ   is_our_fakezFakeTensorMode.is_our_fakeN  s    !Z(@Q[[D-@@rM   c                ^   t         j                  j                         r?t         j                  j                         rJ t         j                  j	                          S t         j                  j	                         xs0 t        t         d      xr t         j                  j	                          S )Nr  )rz   rC  _is_compiledrA  rB  hasattrr  rH   s    rJ   avoid_device_initz FakeTensorMode.avoid_device_initV  s|    99!!#zz..000yy--/// JJ##% Du%B%))*@*@*B
 	
rM   c                    | j                   3dj                  t        j                  | j                              | _         | j                   S )N )rP  joinre  format_listrg  rH   s    rJ   stackzFakeTensorMode.stacka  s7    ;;'')"7"78I8I"JKDK{{rM   rV   c                   t         j                  j                  t         j                  j                  j                        J |       	 | j                  ||||      S # t        $ r t        j                  d        w xY w)Nzfake tensor raised TypeError)	rz   r{   r  r}   r~   dispatch	TypeErrorrV  	exception)rI   r`   r  r  r  s        rJ   r  z!FakeTensorMode.__torch_dispatch__g  sr     HH''(F(F(K(KLT		T	==udF;; 	MM89	s   
A  A>c                   dd l }d }| j                  rO|j                  j                         }|j                  j	                  d       |j                  j                          |j                  j                  | j                        }| |ur,| j                  j                  d||f       t        | -         S |j                  j                  |        | j                  j                  dd |f       | S )Nr   TF)rh  ru  r{   _only_lift_cpu_tensors_set_only_lift_cpu_tensors_ensureCUDADeviceGuardSetr|   r  rd  r   r  	__enter__r   )rI   rz   prev_only_lift_cpu_tensorsmaybe_prev_fake_moder  s       rJ   r  zFakeTensorMode.__enter__{  s    3%)"!!).)H)H)J&HH//5
 HH..0$xx<<T^^L++##+-GH 7$&& HH''-##UD2L$MNrM   c                    | j                   j                         \  }}}|rUt        |   |||       |t        j
                  j                  |       | t        j
                  j                  |       y y y rp   )rd  r   r  __exit__rz   r{   r   r  )rI   abcliver   maybe_prev_only_lift_cpu_tensorsr  s          rJ   r  zFakeTensorMode.__exit__  sw       "		
 ,GQ1% $/++,@A/;334TU < rM   c                     yrt   rV   r  s    rJ   is_infra_modezFakeTensorMode.is_infra_mode  s    rM   c                    t        t        j                  t        j                  t	        t        j
                        t        t        j                              S )z8
        Query the state of the dispatch cache.
        )rC  r   rL  rM  ru   rN  r  rK  r  s    rJ   
cache_infozFakeTensorMode.cache_info  s?    
 !%%''../$$%	
 	
rM   c                    d| _         d| _        | j                  j                          | j                  j                          y)z+
        Clear the dispatch cache.
        r   N)rL  rM  rN  r  rK  r  s    rJ   cache_clearzFakeTensorMode.cache_clear  s3    
   "		rM   c                   d}d}	 t        | j                        }| j                  ||||      }|| j                  ||||      S |J |j                         r+|j                  J |j                  j                   }t"        }	nt        j$                  }t&        }	|j)                  |d      }
|
t	        |
t*              r9t        j                  |
j                  xx   dz  cc<   | j                  ||||      S | j-                  ||
|||      }t        xj.                  dz  c_        | j0                  r+t3        |       5  | j5                  |||||       ddd       |S |S | j                  ||||      }	 | j7                  ||||||      }
 |	|||
       t        xj8                  dz  c_        |S # t        $ r}t	        |t
        j                  j                        r7|j                         dk(  r$t        j                  d|d   |j                         t        j                  |j                  xx   dz  cc<   Y d}~d}~ww xY w# 1 sw Y   |S xY w# t        $ r}t	        |t
        j                  j                        r7|j                         dk(  r$t        j                  d|d   |j                         t        j                  |j                  xx   dz  cc<    |	||t+        |j                               |cY d}~S d}~ww xY w)z
        Lookup a cache entry for the given arguments. If none exists, dispatch
        and cache the result (if the result is eligible for caching).
        Ninvoke_subgraphz6Fake tensor cache failed: identifier = %s, reason = %sr1   )r2   r  
_cache_keyrA  r   rz   _opsHigherOrderOperatorrW  hc_logra  rZ   r   rN  _dispatch_implcache_on_shape_envfake_tensor_cache_set_cache_key_for_shape_envrK  _set_cache_keyr   r=  _output_from_cache_entryrL  rc  r   _crosscheck_cache_output_make_cache_entryrM  )rI   r`   r  r  r  r  r   erK  set_cache_keyentryoutputs               rJ   _cached_dispatch_implz$FakeTensorMode._cached_dispatch_impl  s    	9"4>>2E//%tV<C ;
 &&tUD&AA   ##%??...OO55E8M"((E*M		#t$%!:; --ell;q@;**4fEE 225%dDQF%%*%,, /t4 U11&$tVTU M6M $$T5$?	**5#tT66RE$ 	eS%(##q(#Y $ 	9 4!?!?@IIK#44LGHH
 ))!((3q833	9ZU M $ 	
 4!?!?@IIK#44LGHH
 ))!((3q83%&?&IJM	sC   )F. <I3I .	I7B H==II	LBK?9L?Lc                   t         j                  j                  j                  j	                         du}|t        j
                         t         j                  j                         t        j                         | j                  r| j                  j                  nd|g}|j                  r|j                  | j                         g }|r| j                  ||||       |r| j                  ||||       t        t!        |            }|D ]1  }	t#        j$                  |	t'        j(                  t*        |             3 |j-                          |S )z
        Create a cache key given the dispatch args. Raises _BypassDispatchCache
        for any situation that precludes caching.
        Nr   )rz   fxexperimentalproxy_tensorget_proxy_modeget_default_dtyper{   _get_default_deviceis_inference_mode_enabledr  settingsknown_symbolsr   rz  r  r!  r  rq   finalize	functoolspartialevict_fake_tensor_cache_keyr  )
rI   r  r`   r  r  
is_tracing
key_valuesr  r   id_hashed_objs
             rJ   r  zFakeTensorMode._cache_key"  s$    XX**77FFHPTT
 ##% HH((* ++- (,~~DNN##4 %

(  djj)*,$$Zu>OP$$Z@QRj 12. 	My001LRUV	 	!
rM   c                   ddl m} t        |t        j                  j
                        r||v ryt        j                  j                  |j                  v rt        d      t        j                  j                  |j                  v r|t        j                  j                  u rot        |||d      \  }}|d   D ]T  }t        |t        j                        s|j                  t        j                   t        j"                  fv sKt        d       yt        d      t        j                  j$                  |j                  v rt        d	      |t        j&                  j(                  u rt        d
      || j*                  v rt        d      |j-                         dk(  rt        d      t        j.                  j0                  j3                  |      st        d      |j4                  r\t        j6                  j9                  |j-                         t        j6                  j:                  j<                        rt        d      yy)za
        Validate that the cache key generated by _cache_key will be
        reasonable.
        r   registered_hop_fake_fnsNzdata dependent outputTr  r  normalize_to_only_use_kwargsindiceszdynamic output shapezinplace viewzunsafe viewliftzinductor::resize_storage_bytes_znon-builtinCompositeImplicitAutograd)torch._higher_order_ops.utilsr  r   rz   r  r  Tagdata_dependent_outputtagsrA  dynamic_output_shaper  r  r   r!   r  r   r   inplace_view_unsafe_viewr  lift_fnsrW  _libraryutils
is_builtinis_viewr{   %_dispatch_has_kernel_for_dispatch_keyDispatchKeyr  )rI   r`   r  r  r  r   
new_kwargsr  s           rJ   _validate_cache_keyz"FakeTensorMode._validate_cache_keyY  s    	J
 tUZZ;;<//
 99**dii7&'>??99))TYY6tzz((( 2!15	!: (	2 KE "%65;;



K < 33IJJK &'=>>99!!TYY.&~664$$,,,&}554== &v..99;;;&'HII~~##..t4&}55
 <<EHHJJIIK--GG
 ''BCC
<rM   c                \   ddl m} ddlm} t	        |t
        t        t        f      r7|j                  t        |             |j                  dt        |              t	        |t              rE| j                  ||j                         ||       | j                  ||j                         ||       y|D ]s  }t	        |t              ru| j                  |      st!        d      |j"                  t!        d      t%        |      rt!        |j&                   d      t)        |      }|j+                  || |       t	        |t,              rt!        d	      t	        |t.              r|j1                  ||       t	        |t2        t4        f      rt!        d
      t	        |t
        t        t        f      r| j                  ||||       t	        |t6        j8                        rt!        d      t	        |t:        j<                  j>                        rG|j                  t        |             |j                  tA        |             |j                  |       t	        ||      r7|j                  tC        |             |j                  |jD                         t	        ||      rQ|j                  t        |             |j                  tC        |             |j                  |jF                         I|j                  t        |             |j                  |       v y)a7  
        Translate the provided args into a form suitable for caching at FakeTensor
        dispatch, i.e., convert unhashable types like lists & dicts into tuples and
        convert FakeTensors into metadata. Raises _BypassDispatchCache to signal
        unsupported cases that should bypass caching.
        r   )FunctionalCallableWithEpilogue)FunctionalizeCtxWrapperlength_Nznot our fakeconstant attributez tensorznon-fake tensorzsymbolic shapezfunction argument)$*torch._higher_order_ops.auto_functionalizer  r  r  r   r  r  ru   r   r   r  r  keysvaluesr   rq  rA  r   r   r   r  r  r   r   r  r   r   r  FunctionTyperz   r  GraphModulerW  r&  subgraphorig_callable)	rI   r  r  r  r  r  r  r  r5  s	            rJ   r  z"FakeTensorMode._prep_args_for_hash  sj   	
 	JdT5$/0MM$t*%MMGCI;/0dD!$$VTYY[%ARS$$VT[[]ECTU *	#C#z*'',.~>><<+./CDD %.#**W/EFF237&&vtU;C(*+<==C(%%fc2C'8!45*+;<<C$t!45((e=NOC!3!34*+>??C!5!56 d3i(bg&!((-C!89 d3i( "((6C!?@d3i(d3i(!(():):;
 d3i(c"U*	#rM   c                   t        |t        t        d       f      ry t        ||       t        |t              st        d      |j                  t        d      |j                  rt        d      t        |      rt        d      |j                         D ]$  }t        |      t        |      k(  st        d       y )Nznon-FakeTensor outputr  zsparse outputzsparse compressed outputzkwarg aliases output)r   r#  r   %_validate_symbolic_output_for_cachingr   rA  r   r   r   r  rW  )rI   r  r   r`   r  r  r  kvals           rJ    _validate_output_for_cache_entryz/FakeTensorMode._validate_output_for_cache_entry  s     fsDJ/0 	.eV< &*-&'>?? ??&&';<< &77'&'ABB MMO 	CD$x2f:%*+ABB	CrM   c                j   t        |t        t        j                  t	        d       f      rt        d d d |      S t        t        |            D ],  }t        ||         t        |      k(  st        |d d       c S  d }t        |t        j                  j                        rO|j                  rCt        |      D 	
cg c]  \  }	}
t        |
t              s|	 }}	}
t        |      dk(  sJ |d   }t        |      }t        fd|j                   D              |_        t        fd|j"                  D              |_        j%                  |j&                        |_        |j(                  d nj%                  |j(                        |_        t        d ||      }t+        |fd      }dd	lm} 	 | j1                  ||||      }t        j4                  j7                  |      }t        j4                  j7                  |      }||k7  rt3        d      |S c c}
}	w # |$ r t3        d
      d w xY w)Nr4  r5  r6  r7  )r4  r5  r6  r1   r   c              3  @   K   | ]  }j                  |        y wrp   convert_outputr   r   r  s     rJ   r   zBFakeTensorMode._get_output_info_for_cache_entry.<locals>.<genexpr>-  s     O1u33A6O   c              3  @   K   | ]  }j                  |        y wrp   r  r  s     rJ   r   zBFakeTensorMode._get_output_info_for_cache_entry.<locals>.<genexpr>.  s     QA 4 4Q 7Qr  Fr:  r;  )GuardOnDataDependentSymNodezdata dependent symnodezdispatch_key_set mismatch)r   r#  rz   r   r   r3  ranger  rW  r  r<   r  	enumerater   r  r  r  r  r  r  r  r9  r  r  r  rA  r{   _dispatch_key_set)rI   r  r   r`   r  r  r  idxr6  ir   idxsr5  r  entry_for_synth_outputr  synth_outputsynth_key_setkey_sets    `                 rJ    _get_output_info_for_cache_entryz/FakeTensorMode._get_output_info_for_cache_entry  s    fsELL$t*=>0 4$v 
 T# 	C$s)}6
*4 #dT 	 dEJJ112t||"+D/K$!QZ65JAKDKt9>!>AwH*62OOOQQQ"'"6"6x7N7N"O %%- %%h&<&<= 	 .
 ":5"
 	V		K88-sD$L 22<@((,,V4G#&'BCCa LD + 	K
 ''?@dJ	Ks   >HH5H   H2c                   ddl m} ddlm | j	                  |||       t        |t        j                  j                        r;||v r7t        |t              sJ t        fd|D              }|rt        d| d      t        |t        t        j                  t        d      f      rt        ddd|      }	t!        |	fd	
      S t        |t              r|D ]  }
| j#                  ||||||
        n| j#                  ||||||       t        |t              r9|D cg c]  }| j%                  ||||||       }}t!        t        |      d
      S | j%                  ||||||      }	t!        |	fd	
      S c c}w )z
        Make a cache entry object for the given 'output' Tensor. Raises
        _BypassDispatchCache if the output tensor has characteristics that
        prevent caching it.
        r   r  )has_free_unbacked_symbolsc              3     K   | ]8  }t        |t        j                  t        j                  f      xr  |       : y wrp   )r   rz   r   r   )r   or  s     rJ   r   z3FakeTensorMode._make_cache_entry.<locals>.<genexpr>w  sA         1u||U\\:; 1-a01 s   >Azunbacked symbol in HOP z outputNr  Fr  T)r  r  r  r  r  r   rz   r  r  r  r   rA  r#  r   r   r3  r9  r  r  )rI   r  r   r`   r  r  r  r  non_cacheableoutput_infoout_elementout_elemr:  r  s                @rJ   r  z FakeTensorMode._make_cache_entryZ  s    	JS  tV4 tUZZ;;<//fe,,,      M
 *-DTF'+RSSfsELL$t*=>7 4$vK ,)^U  fe$% 	55	 11 fe$ !'  55L  ,"<0 $  ??K ,)^U 9s   E8c           
        |j                   8|j                  ,|j                   |j                  t        usJ |j                  S |j                   #||j                      }t        |t              sJ |S |j                  }|y t        |      rJ 	 	 	 	 	 	 dfdt        fd|j                  D              }t        fd|j                  D              }	 |j                        }
|j                   |j                         t        j                  }| j                  | j                  j                   }t#        |       5   |       5  t%        j&                  ||	|j(                  |j*                  d|j,                        }d d d        d d d        |j.                  r t$        j0                  j3                  d       |j4                  r t$        j0                  j7                  d       t        |t$        j8                  j:                        r|j<                  rw|t?        t@        |j                           }t        |t              sJ |jC                         }t#        |       5   |       5  jE                  ||
||	       d d d        d d d        t        | |jF                        S # 1 sw Y   (xY w# 1 sw Y   -xY w# 1 sw Y   BxY w# 1 sw Y   FxY w)Nc                    t        | t              r*|j                  J | j                  |j                        S t        | t              rJ | S rp   )r   r4   r  r  r3   )r/  r  r   s     rJ   check_valuezGFakeTensorMode._get_output_tensor_from_cache_entry.<locals>.check_value  sJ     %!23222}}S%//::%e_===rM   c              3  0   K   | ]  } |        y wrp   rV   r   r   r   r  s     rJ   r   zEFakeTensorMode._get_output_tensor_from_cache_entry.<locals>.<genexpr>  s     Dk!U+D   c              3  0   K   | ]  } |        y wrp   rV   r  s     rJ   r   zEFakeTensorMode._get_output_tensor_from_cache_entry.<locals>.<genexpr>  s     F{1e,Fr  r4  )r  r   r  r  T)r/  r  r  r2   rQ   zUnion[IntLikeType])$r4  r5  r6  r7  r0  r   r   r   r  r  r  r  r  
contextlibnullcontextr  suppress_guardsrR  rz   empty_stridedr  r   r  r  r{   	_set_conjr  _set_negr  r<   r  r   r#  r  set_r  )rI   r  r  r   r`   r  inplace_argr5  r  r  r  maybe_suppressrF  view_argstorager   s    ` `           @rJ   #_get_output_tensor_from_cache_entryz2FakeTensorMode._get_output_tensor_from_cache_entry  s    %&&''/@@@@'''(u001Kk:666 >> ***	#	,:		 DX^^DDFhooFF$X%<%<eD!!-..6>H>T>T>>%!^^;;N)$/ 	1A 	''nn&44E	 	 HHud+??HHeT*dEJJ112t||Denn56Hh
333..0G-d3 C^5E C

7NE6BC C $x77/	 	 	 	(C C C CsH   K:J4K0K8KK4J>	9KKK	KK#c           
         |j                   r7|j                  D cg c]  }| j                  |||||       }}t        |      S | j                  ||j                  d   |||      S c c}w )z?
        Create a new FakeTensor from the cache entry.
        r   )r;  r:  r  r  )rI   r  r  r   r`   r  r  outputss           rJ   r  z'FakeTensorMode._output_from_cache_entry  s       
 $)#5#5	   88;T4G  >!;;u))!,c4 s   A&c                    dfd	 | j                  ||||      }	  ||       y# t        $ r}t        d| d| d| d|       |d}~ww xY w# t        $ r}t        d| d| d|       |d}~ww xY w)z
        Helper to validate that the output synthesized from the cache matches
        the output created by normal dispatch.
        c                T   t        | t              rIt        |t              sJ t        |       t        |      k(  sJ t        | |      D ]  \  }} ||        y t        | t              rt        |t              r| |k(  sJ y | |J y t        | t
              r1t        |       t        |      u r| j                  |j                  u sJ y t        | t        j                        r.t        |t        j                        sJ t        t        | |       y t        dt        |              )NzUnsupported type )r   r  r  zipr#  r%   r   rx  rz   r   r   r   r  )r  r  lr}  assert_helpers       rJ   r  z>FakeTensorMode._crosscheck_cache_output.<locals>.assert_helper-  s    !U#!!U+++1vQ'''1I (DAq!!Q'(As#!!S)a1f44fy yA|,Aw$q')aff.>>>.>Au||,!!U\\222"9a3"%6tAwi#@AArM   z*FakeTensor cache crosscheck failure: func=z, args=z	, kwargs=z: Dispatch raised=N)r  r   r  r   rQ   rR   )r  	Exceptionr  )	rI   r  r`   r  r  r  true_outputr  r  s	           @rJ   r  z'FakeTensorMode._crosscheck_cache_output   s    	B$	--dE4HK	+v.  	<TF CvYvh.@E 	  	<TF CvYvh0 	s+   ( 	A 	AA		A	A4A//A4c                   |xs i }t               5  t        j                  d|||       d d d        |t        v rt        |   |      S t        j	                         t
        j                  k  r(t        j                  ddt        z  |       t               }|t        v rt        |       5   ||i |cd d d        S | j                  r| j                  ||||      S | j                  ||||      S # 1 sw Y   xY w# 1 sw Y   IxY w)Nz%s %s %sz'%sFakeTensorMode.__torch_dispatch__: %s )r&   rV  ra  r  getEffectiveLevelloggingDEBUGrG   rC   _DISPATCH_HANDLE_DIRECTLYrR  r   r  r  )rI   r`   r  r  r  incrs         rJ   r|  zFakeTensorMode.dispatchN  s     2] 	6IIj$f5	6 ***4066  "gmm3II93;PRV +,D ,,-d3 -T,V,- - --dE4HH&&tUD&AA/	6 	6"- -s   C.(C:.C7:Dc                `   
 ddl ddlm} d fd}t        t        j
                        rZ	  |ddddd       t        t        j                         j                                     D ]  \  }\  }}		  |||	        dfS get        j                  j                  j                  r!t        d	fd       t               dfS t        d d dt        |       d       	  |       dfS # t        $ ro
t        j                  j                  j                  r%t        d	
fd
       t               dfcY d

S t        d d dt        |       d       
d

ww xY w# t        $ rt
t        j                  j                  j                  r't        d	
fd       t               dfcY d

c S t        d| d|	 dt        |       d| d 
      
d

ww xY w# t        $ r&
t        d d dt        |       d       
d

ww xY w)z
        Helper to cross-check fake/real output properties & values,
        and create new fake vals if mismatched.
        Returns tuple of object & boolean, for whether or not it was overwrriten
        r   N)_check_fake_real_tensorsc                ^   t        | t        t        f      rj                  J | j                  j
                  j                  j                  j                  j                         z
  j                  j                  j                         z
  sjj                  j                  j                  | j                  j
                  |      d      j                  j                  urt        d|  d| d      y y t        | t        t         t"        f      r| |k7  rt        d|  d| d      y y )NT)compute_hintmismatch between fake value  and real value r  )r   r   r   r  rx  exprfree_symbols
var_to_valr  unbacked_var_to_val_maybe_evaluate_staticEqStrueri   r#  floatr   )fakerealrI   sympys     rJ   _check_fake_real_valsz?FakeTensorMode._maybe_infer_fake.<locals>._check_fake_real_vals{  s'   $ 23~~111		33nn//4467nn88==?@
 ==!HHTYY^^T: >   %ww||,
 4:4&@PQUPVVWX ,@ sE4( 4</6tf<LTFRST   rM   Real tensor propagation foundFT)contextsizesstridesr  r  mismatched_fake_kernelc                 4    t               j                  dS NoprZ   rY   rZ   excr`   s   rJ   <lambda>z2FakeTensorMode._maybe_infer_fake.<locals>.<lambda>  s    "%d)&)jj- rM   metadata_fnzFReal tensor propagation found a metadata mismatch between fake tensor z and real tensor z,  at outputz, for func: c                 4    t               j                  dS r:  r=  r>  s   rJ   r@  z2FakeTensorMode._maybe_infer_fake.<locals>.<lambda>  s    &)$i*-**1 rM   zIReal tensor propagation found an output size mismatch between fake shape z and real shape z, at outputz.size(z), for func: c                 ,    t              d  d dS )Nr%  r&  r;  rY   )r0  r`   r1  s   rJ   r@  z2FakeTensorMode._maybe_infer_fake.<locals>.<lambda>  s$    !$i$@FVW[V\"]) rM   zQReal tensor propagation found an output value mismatch between fake output value z and real output value )r0  r   r1  r   rQ   rR   )r2  torch._subclasses.fake_utilsr"  r   rz   r   ri   r   r  *generate_fake_kernels_from_real_mismatchesr   _infer_fake_from_real_tensorr*   r  r  rH  )rI   r`   pathr0  r1  r"  r3  js_fakes_realr?  r2  s   `` ``     @@rJ   _maybe_infer_fakez FakeTensorMode._maybe_infer_fakeo  s    	I	6 dELL)(;!#'"'2 (1TYY[$))+1N'O ##FF)&&9T U{1 \d.&&QQ!,! 4D$EtKK'#f$5dV <#D\N,tf> %dD1 U{u ) ##**UU%0% 8dDI4OO+##'&(9$ @!!'l4&B 	& - ''..YY)4)  <D$MtSS/&&,X-=fX F$$*4L>s-vO 	B ) +))-.EdV L  &t~\$A 	sa   D =	E>6	G> 	E;AE6E;!E66E;>	G;AG6
G;$G66G;>	H-!H((H-c                    ddl m} d j                  rt         j                  j                        d fd}t
        j                  |      \  }}	t
        j                  |      \  }
}	  |d||||       t        t        ||
      D cg c]  \  \  }}} j!                  |||       c}}} \  }}t#        |      r	r |        t
        j%                  ||	      S # t        $ rkt        j                  j                  j                  r-t        dfd        |        t         fd	|      cY dS t        d
| d| d       dww xY wc c}}}w )z
        Helper to cross-check fake/real output properties & values,
        and create new fake vals if mismatched, but at the kernel level.
        Means this handles pytree outputs & checks aliasing.
        r   )_check_alias_infoNc                     t        t        j                  j                        j	                               j                  _        y rp   )r  setr  pending_fresh_unbacked_symbols
difference)pending_unbackedrI   s   rJ   _clear_pending_unbackedzXFakeTensorMode._maybe_infer_fake_kernel_from_pytree_out.<locals>._clear_pending_unbacked  s4    <@DNNAABMM$=DNN9rM   r4  r8  c                 :    t              d j                   dS )Nz>Mismatched aliasing spec between fake kernel and real kernel: r;  r=  r>  s   rJ   r@  zIFakeTensorMode._maybe_infer_fake_kernel_from_pytree_out.<locals>.<lambda>	  s#    !$i\]`]g]g\hi) rM   rA  c                    t        |       S rp   )rH  )r   r`   rI   s    rJ   r@  zIFakeTensorMode._maybe_infer_fake_kernel_from_pytree_out.<locals>.<lambda>	  s    :4qI rM   zGReal tensor propagation found an aliasing mismatch between fake output z and real output z,  for func: rP   )rF  rO  r  r  rR  r   tree_flatten_with_pathtree_flattenri   rz   r   r  rG  r   r,   r  rM  r   tree_unflatten)rI   r`   fake_inreal_infake_outreal_outrO  rU  fake_paths_leaves	fake_specreal_leavesr   
_fake_path	_fake_out	_real_outfake_leaves	overridesr?  rT  s   ``               @@rJ   (_maybe_infer_fake_kernel_from_pytree_outz7FakeTensorMode._maybe_infer_fake_kernel_from_pytree_out  sx    	C  >>#DNN$Q$QR	 (.'D'DX'N$9,,X6Q	/7Hg> "% ;>%{; 6+ZY &&tZIN"
Y 	N/#%$$[)<<Q % 	&&QQ!,! ()I8  ,##+*,=hZ H""&) 	)	:s+   0C% !E%	E.AE9E?EEc                @   ,-./01234567 ddl m} t        j                  f      \  0,t	        0      }|r@0D cg c]  }t        |      st        |       }}t        j                  d|       t        S 0D 	cg c]  }	 j                  |	      s|	 }
}	t        d |
D              xs t        d 0D              2 j                  . j                  v }d} j                  rzt        j                   j"                  j$                  j&                  u rdv rd   j                  dk7  rd	}t        j                   j(                  j*                  j&                  u rd	}t        j                   j"                  j$                  j&                  u xr; t-        d   t        j.                        xr d   j0                  j                  d
k(  xs |}|r|
rt3              rȉ2s|
s|st5        d |
D              s
J  d       0D cg c]!  } j                  |      r|j6                  n|# }}t        j9                  |,      \  }} |i |}t        |      t.        u rH j;                  |      r7t=               5  |j?                         }d d d        .jA                   |d	      S |rQtC              dk(  rtC              dk(  sJ  d        t        d         t.        u r.jA                   d         S  jE                  .0,      \  0}
t5        d |
D              }t-        t        jF                  jH                        rct        jJ                  jL                  jN                  vr<t        jJ                  jP                  jN                  vr|rtC        |
      dk7  r2s |st"        jR                  j&                  ur0D cg c]!  } j                  |      r|j6                  n|# }}t        j9                  |,      \  }}t=               5   |i |}d d d        t        jU                        }|D 	cg c]  }	t-        |	t.              s|	 }}	t5         fd|D              }|rt        jW                  t.        . fd|      S |D ]  }.jY                  |        t        j9                  0,      \  t-        t        jF                  jZ                        r^|v rZ j\                  t^        j`                  n j\                  jb                  } 5   |       5   |   i cd d d        cd d d        S  je                  |
       	 	 	 	 d( fd}ddl3m4-m51 tm               336 jn                  rt5        d |
D              rt        1 7fd0D              stp        j                  d       0D cg c]
  } ||       }}t        j9                  |,      \  45ts        jt                        }|sts        jv                  |,      }	  4i 56|syj{                          ts        j|                  j~                  06       nG jn                  r;tp        j                  d|
0 j\                  r j\                  j                  nd        d)-13456 f
d}2r-t               j                        }| | | gi       S ddlCmD} |vr j                        s2r j                  v s}ddlCmG}  | v r<2st              r/t5        d |
D              r 5   | |    i       cd d d        S  5   j                  i }!|!t        ur ||!      cd d d        S 	 d d d        dj                  j                  v r;t        d      r/t              s$ 5   | j                  i       cd d d        S t        j                  j                  j                  }"|"%|"j                  v r |"j                   gi S  jn                  r_63ur[ts        jt                        sF j\                  :ts        j                        s%t         6      }#t        d fd!"        ||#      S t        j                  j                  j                  j                  j                               j                  j                  }$|$r}	 t        j                  j                  j                         /t        j                  j                  j                  /fd#      5   5   |$i }# ||#      cd d d        cd d d        S t        D ]-  \  }&}' |&      s |' gi }(|(t        us% ||(      c S  	 d*	 	 	 d+,02 fd%})t              s |)       }* ||*      S 	 t               5   i }!d d d         | j                  !0j                  d      '            S c c}w c c}	w c c}w # 1 sw Y   xY wc c}w # 1 sw Y   xY wc c}	w # 1 sw Y   nxY wd d d        # 1 sw Y   xY wc c}w # tx        $ r"}tp        j                  d|       Y d }~ed }~ww xY w# 1 sw Y   MxY w# 1 sw Y   #xY w# 1 sw Y   xY w# 1 sw Y   nxY wd d d        n# 1 sw Y   nxY wy# t        $ rb}% jn                  rO63urKts        jt                        s6 j\                  *t         6      }#t        d fd$"        ||#      cY d }%~%S |%d }%~%ww xY w# 1 sw Y   uxY w# t        $ r}+ |)|+      cY d }+~+S d }+~+wt        $ r tp        j                  d&        w xY w),Nr   r  z,FakeTensorMode unrecognized subclass(es): %sc              3  4   K   | ]  }|j                     y wrp   )r  )r   r  s     rJ   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>G	  s      !
./A))!
   c              3  <   K   | ]  }t        |t                y wrp   )r   r   )r   r  s     rJ   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>I	  s     :1Av&:s   Fr  r
  Tr4  c              3  8   K   | ]  }|j                   d u  y wrp   r  r   r   s     rJ   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>s	  s     M!qzz-M   z. should not have fake inputs without constantsr,  r1   r  c              3  8   K   | ]  }|j                   d u  y wrp   r  r   r  s     rJ   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>	       Qa1::T1Qrn  c              3  @   K   | ]  }j                  |        y wrp   )may_turn_const)r   r   rI   s     rJ   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>	  s     P!t2215Pr  c                ,    j                  | d      S )NTro  )r2  )r   	converterrI   s    rJ   r@  z/FakeTensorMode._dispatch_impl.<locals>.<lambda>	  s    i88qPT8U rM   c                   t        | t              r| j                  S t        | t              rj                  J | j
                  j                  | j
                  j                  j                  j                  j                        j                  j                  j                              S t        | t              r| j                  S | S rp   )r   r   r  r%   r  rx  r5  r'  xreplacer)  r*  r   real_obj)r   rI   s    rJ   maybe_to_real_tensorz;FakeTensorMode._dispatch_impl.<locals>.maybe_to_real_tensor	  s     !Z(}}$A|,~~111vv}}FFKK(()B)BCLL:: 
 A/0zz!rM   )compute_unbacked_bindingsfree_unbacked_symbolsc              3  8   K   | ]  }|j                   d u  y wrp   )r  rq  s     rJ   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>	  s     M!AMM-Mrn  c              3     K   | ]F  }t        |t              xr0  |      xxr$ j                  d uxr t        fdD               H y w)Nc              3  N   K   | ]  }|j                   j                  v  y wrp   )r  r*  )r   srI   s     rJ   r   z:FakeTensorMode._dispatch_impl.<locals>.<genexpr>.<genexpr>	  s      VAAT^^%G%GGVs   "%)r   r%   r  r   )r   r  r|  rI   symss     rJ   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>	  sd        q,/ W!6q!99Wd2W VQUVVWs   AAzpropagate_real_tensors %sz9real-tensor fallback failed for %s: %s; silently ignoringz,SKIPPED propagate_real_tensors %s(%s, %s) %sc           	     D  
 dd l t        j                  d       dfdurt        j                  j
                  j                  sj                  f	
f|        nj                  f	
f|       } t        | t              slt        t              s\t        |       t              urFt        t        t        j                  |             t        t        j                                     nt        |         j                  | d       | S )Nr   zmaybe_propagate_real_tensors %sc                   t        | t              rt        j                  dt	        |       t	        |             || _        t        | j                         |j                               D ]  \  }} ||        t        | j                         |j                               D ]  \  }} ||         | j                         |j                                y t        | t              r |       rt        | j                  j                  j                        r?j                  J j                  j                  | j                  j                  |       y t        | j                  j                  x}j                         ret        |j"                  j                        rD|j$                  dk(  r4j                  J j                  j                  |t'        |             y y y y y y )Nz%maybe_propagate_real_tensors %s -> %sr1   )r   r   rV  ra  rW  r  r  rH  r  r  r%   rx  r'  Symbolr  set_unbacked_var_to_valr,  lhsrhsr#  )r   real_tr  real_sr|  gorI   r2  s       rJ   r  zOFakeTensorMode._dispatch_impl.<locals>.maybe_propagate_real_tensors.<locals>.go0
  sw   a,II?A6
 %+AM%(6;;=%A &	61f&%(V]]_%E &	61f&q'')6+@+@+BC<05J15M!!&&++u||<#~~999>>qvv{{FS"#31UXX>&quuell;EEQJ#~~999>>q#f+N	 ' < ? 6N0rM   T)peek)r   r  r  r   rQ   rR   )r2  rV  ra  rz   r   r  rG  rg  r   r   r   r-   r  r   rY  r  )r]  r  r2  r  r{  r|  r`   r  nil	real_argsreal_kwargsr^  rI   s    @@rJ   maybe_propagate_real_tensorszCFakeTensorMode._dispatch_impl.<locals>.maybe_propagate_real_tensors+
  s   II7>O O2 s"''..YYAAv"K0    $LLv"K0   H #8V4&x8Xd8n< f11(;<f11(;< b(H5
 *$..(N OrM   )
meta_tabler   c              3  4   K   | ]  }t        |         y wrp   )r   rq  s     rJ   r   z0FakeTensorMode._dispatch_impl.<locals>.<genexpr>
  s     PQa 00Prj  zprims::prim_meta_implmissing_fake_kernelc                     dt               iS Nr<  rE  r   s   rJ   r@  z/FakeTensorMode._dispatch_impl.<locals>.<lambda>
  s    c$i) rM   rA  c                      S rp   rV   )ctxs   rJ   r@  z/FakeTensorMode._dispatch_impl.<locals>.<lambda>
  s    S rM   c                     dt               iS r  rE  r   s   rJ   r@  z/FakeTensorMode._dispatch_impl.<locals>.<lambda>
  s     #d)- rM   c                    t         j                  j                  j                        ry sj	                        st              | t              } t        |       S rp   )rz   r  r  can_generate_trivial_fake_implcan_run_unsafe_fallbackre   run_fallback_kernel)error	args_specr  r`   has_symbolic_sizesrI   s    rJ   maybe_run_unsafe_fallbackz@FakeTensorMode._dispatch_impl.<locals>.maybe_run_unsafe_fallback
  s]     ~~##BB4H!)E)Ed)K2488}4T:&tT9iOOrM   z*failed while attempting to run meta for %sr@  )r   rA   rQ   z1Optional[Union[T, Tensor, torch._C.ScriptObject]])r]  rA   rQ   rA   rp   )r  zOptional[RuntimeError]rQ   r8  )gr  r  r   rY  _check_for_subclass_check_for_subclass_argr   r  ra  r  rq  r   r\  r  ru  rz   r  r  _to_copyr  prims
device_putr   r   r  rY  r   r   rZ  rt  r&   cloner2  r  %validate_and_convert_non_fake_tensorsr  r<   r  nondeterministic_seededr  r  _nested_tensor_from_tensor_listr   tree_map_onlyr   r  r  r  r  ignore_fresh_unbacked_symbolsinvalidate_written_to_constantsr  r{  r|  r  r[  rV  library_utilsr  MutationCheckerZeroDivisionErrorcheckcheck_aliasing_constraintrd  r*  get_fast_op_implsr   r   r  cpp_meta_supports_symint#_unbacked_special_fake_handling_opsr   r   	decomposer   rW  rt  stride_incorrect_opr  r`  r  _custom_ops_profiledatageneric_fake_kernelhas_fake_kernel"inferred_fake_kernel_from_real_outr   r  simple_registry	singletonfind	fake_implkernelFakeImplCtxset_ctx_getterr   op_implementations_checkshas_metarR  r  r  r~  +wrap_meta_outputs_with_default_device_logic)8rI   r`   r  r  r  r  has_unrecognized_typesr   r  r   flat_arg_fake_tensorsis_lift_funcavoiding_device_init!device_conversion_skip_const_propr  const_flat_args
const_argsconst_kwargsr   all_constantflat_outflat_out_tensorsr   #maybe_ignore_fresh_unbacked_symbolsrz  real_flat_argsr  mutation_checkerr?  r  	fast_implr  r   r}  profilesr  maybe_fake_implr  run_impl_checkop_implop_impl_outr  fallbacknot_implemented_errorr  r{  rv  r  r  r|  r  r  r  r  r^  r  s8   `` ``                                       @@@@@@@@@@@@rJ   r  zFakeTensorMode._dispatch_impl)	  s    	J%22D&>B	9 "5Y!?!!*".Ea.HQ" "  %%>@R "!,5 Mq9I9I!9L M M  !
3H!
 
 ;:	:: 	 ..	t}},  %!!		//777&8$))U2'+$uyy11999'+$ EIINN++333 .47ELL1.Q##v--" "	 	* !6+D1&)5M7LMM &FGM CL=>d..q1

q8O  (.'<'<_i'X$J
3l3CCyF"t':':3'? !] &))+C& 11$41PP v;!#D	QJ4&&8JJ6DG}& 11$Q@@ .2-W-W)Y	.
*) & Q;PQQtUZZ223		11B		&&dii7)*a/&(D@@HHH CL=>d..q1

q8O  (.'<'<_i'X$J  8J7,78 ))#.H+3Maz!V7LMMP?OPPL++U  ( ;55c:;
 ,,Y	Bf tUZZ;;<//
 >>) &&^^AA 0  F:< F4.t4dEfEF F F 	,,T3H$PVW		>	"	

 h''M7LMM  #  II148?HI!215INI%+%:%:>9%U"I{&11$7J#0#@#@.)$ 
:k:  &&(77

IxX(( II>%6:nn22$H	 H	V )+//5I$3Id4TT4TV4TUU 	- 
"11$7"tt/W/W'W : **" 05P:OPP  71+D14B6B 
  ;"DNND3F3N*7:	; ; +; ***./'- 3'D''88 
 =='';;x}}$3x33D$PPPP ''#!,,T2* !006;D$Q!)! 4F;;  ..88BBGGIIK

)FF 	 nn..::4F^^--<<[I @4 @,d=f=F7?@ @ @8 (A 	E#NGd#%dDB4B6Bn47DD		E -1	P)	P!	P 	P" ~02H/99
	-d3 *$)&)* ,<<46::h+? = 
 	
a" !N`& &X8 8  N<F F F F FZ J %  		O 	F 
; ;" H@ @ @ @ @ $  // +)44T:2?dHUF%-% 8??G'n* *" 	D,-BCC 	MMFM	s@  hhhh&hh$&h1"	h6i"i*i2i=	ii+)i0  j"j+j83Ak( 	kk	k%	k( m# 	m#m# $h.6i i	ii(0	j9jjj(+j58kk	
k	k( k#k( (	m1Ammmmm m# #	n,m93n9$n
debugprimsr  r  xlavision	torchtext
torchaudio	quantizedc                v    | j                   sy|j                  | j                  v xs |j                         dk(  S )NFzfbgemm::gmm)rS  	namespace+_can_run_unsafe_fallback_allowed_namespacesrW  rI   r`   s     rJ   r  z&FakeTensorMode.can_run_unsafe_fallback$  s:    **
 NNdNNN ,yy{m+	
rM   c                d     g d fd}D cg c]
  } ||       }}|fS c c}w )z
        Checks if the list of tensors are fake tensors.
        If not, try to convert them to fake tensors.
        Returns the original args, kwargs, and a flattened list of (args, kwargs) that are fake tensors.
        c                v   t        | t              s| S 
j                  |       s t        	d      rXt        j
                  j                  	j                  v r2t        j                        \  }}t        dt        	||             t        j                  
j                  nt        j                  }|s[t        | t              r| j                   
urt        d      t        j                        \  }}t        dt        	||             j#                  
|       }n| }j%                  |       |S )Nr  zECan't call metadata mutating ops on non-Fake Tensor inputs. Found in zMixing fake modes NYIzuPlease convert all Tensors to FakeTensors first or instantiate FakeTensorMode with 'allow_non_fake_inputs'. Found in )r   r   rq  rt  rz   r  r  r  r   rZ  AssertionErrorr   r  rm   rT  r   r   r2  r   )r   r  r  rT  r   r  rv  r  r  r`   rI   s        rJ   validatezFFakeTensorMode.validate_and_convert_non_fake_tensors.<locals>.validate=  s<   a( ##A&4(UYY-C-Ctyy-P#)#8#8I#NLD&(_`klprvx~`  `A  B 
 'EEM ..(GG &
 -!!Z0Q[[5L,-DEE#)#8#8I#NLD&(BBMdTXZ`BaAbd 
  00q9!((-JrM   )r   rA   rQ   Union[T, FakeTensor]rV   )	rI   r`   rv  r  r  r  r  validated_argsr  s	   `````   @rJ   r  z4FakeTensorMode.validate_and_convert_non_fake_tensors/  s@     35	 	@ 099!(1+99444 :s   -c                `      j                   d dd fd}t        ||      S )NFc                R    t         t              s S t        j                        \  j	                         }|r7t        j                   j                  k(   fd       t        t               S +rj                         S j                   xs       S  S )Nc                 (    dj                    d  S )Nz-FakeTensor is wrapped to wrong device, found z, expected r@  )r  r  s   rJ   r@  zZFakeTensorMode.wrap_meta_outputs_with_default_device_logic.<locals>.wrap.<locals>.<lambda>~  s    KAHH:U`an`op rM   )r   r   r   r  rq  rz   _checkr  r   rA   r2  r7  )	r  rq  r  rv  r  r  r`   r  rI   s	   ` rJ   wrapzHFakeTensorMode.wrap_meta_outputs_with_default_device_logic.<locals>.wrapm  s     a($ 224C!* **1-KHH-p Aqz!&) %55dA>>$99a!8= 
 rM   r  rA   rQ   r  )r\  r,   )	rI   r}  r`   r  r  r  r  rv  r  s	   ` ``` @@@rJ   r  z:FakeTensorMode.wrap_meta_outputs_with_default_device_logic`  s7     ..	 !& 	  	D a  rM   r  c                  dd l }ddlm} |4| j                  }| j                  sJ d       | xj                  dz  c_         |j
                   ||d            }|j                  j                  j                  d      }| j                  J | j                  j                  | j                  j                  ||      ||      }|S )Nr   )NestedIntNodez1should only called while FakeTensorMode is activer1   intermediate_offsets_or_lengths)valr   )symr  r   )rh  !torch.nested._internal.nested_intr  rQ  rd  r   r`  r   EphemeralSourcer  r)  create_symbol)rI   r  rz   r  r  srcrets          rJ   r  z)FakeTensorMode.create_symbolic_nested_int  s    
 	4C44L##X%XX#%%*%u||M,:;mm""223TU~~)))nn..,, -   / 
 
rM   c                l    t         j                  j                  |j                  v ry|| j                  v S rt   )rz   r  	view_copyr  _cpp_meta_supports_symintr  s     rJ   r  z'FakeTensorMode.cpp_meta_supports_symint  s,    99$))+t5555rM   c                    |j                         t        k  xr; t        |       xr- | j                  |       xr |j                  j
                  dk7  S r  )numelCONSTANT_NUMEL_LIMITr   rq  r  r   rp  s     rJ   rt  zFakeTensorMode.may_turn_const  sS    GGI-- (!!$$($$Q''( '		
rM   c                   t        d |D              }t        |      }|r|j                         rt        |||d      \  }}|j	                         D ]u  \  }	}
|	dk7  s|j                  |	      r|	nd}	| j                  |
      s2|j                  |	      sD|
j                  Q| j                  j                  |
j                         w y y y )Nc              3  8   K   | ]  }|j                   d u  y wrp   r  rq  s     rJ   r   zAFakeTensorMode.invalidate_written_to_constants.<locals>.<genexpr>  rr  rn  Tr  inputrI   )
r   r   
is_mutabler!   rw   has_argumentrq  r   r\  r   )rI   r`   r  r  r  any_constantschema_infor   r  kr   s              rJ   r  z.FakeTensorMode.invalidate_written_to_constants  s     Q;PQQ%d+K224.-1	MAz #((* W1w,+*B*B1*EAF$$Q'#..q1

...JJ1::VW 5<rM   )rO  r   r   r   c                   | j                   }|| j                  }|r|J d       d }| j                  j                  | |||||      S )Nz2cannot set both static_shapes and symbolic_context)r  r   r   r   )r  rO  r\  r2  )rI   r   rO  r   r   r   r  s          rJ   r  zFakeTensorMode.from_tensor  sn     )-	  ..M#+ D+ I))::- ; 
 	
rM   )rS  r   rT  r   r  r9  rO  rl   r   r   rQ   rR   rP   )r   r  rQ   zTypeGuard[FakeTensor])rQ   r   )rQ   rY   r  )rQ   r   )r  zOptional[type[BaseException]]r  zOptional[BaseException]r  zOptional[TracebackType]rQ   rR   )rQ   rC  )
r  r2   r`   r<   r  r  r  r  rQ   r!  )r`   r<   r  r  r  r  rQ   rR   )
r  r  r  z?Union[Mapping[str, object], Sequence[object], Iterable[object]]r  r2   r  r  rQ   rR   )r  r2   r   r!  r`   r<   r  r  r  r  r  r8  rQ   rR   )r  r2   r   r!  r`   r<   r  r  r  r  r  r   rQ   r3  )r  r2   r   r!  r`   r<   r  r  r  r  r  r8  rQ   r9  )r  r2   r  r3  r   r!  r`   r<   r  r  rQ   r8  )r  r2   r  r9  r   r!  r`   r<   r  r  rQ   =Union[Optional[FakeTensor], tuple[Optional[FakeTensor], ...]])r  r  r`   r<   r  r  r  r  r  r  rQ   rR   )
r`   r<   rI  r)   r0  r  r1  r  rQ   ztuple[Optional[object], bool])r`   r<   r[  r  r\  r  r]  r  r^  r  rQ   zOptional[object])
r`   r<   r  r  r  r  r  r  rQ   r8  r`   r<   rQ   r   )
r`   r<   rv  r   r  r  r  r.   rQ   z%tuple[list[object], list[FakeTensor]])
r}  r  r`   r<   r  r  r  r<  rQ   r+   )r  r  rQ   r  r  )
r`   r<   r  zSequence[FakeTensor]r  r  r  r  rQ   rR   )r   r   rO  rl   r   r:  r   r;  r   r   rQ   r   )NrS   rT   rU   rK  r\   rL  rM  r   r#  rN  rz  rK  rQ  rR  rK   rn  rq  r>  ru  rz  r/   r    r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r|  rM  rg  r  rx   r  r  r  r  r  r  rF  r   r  r  as_strided_scatter
as_stridedas_strided_rG  detachview_as_realview_as_complexr  source_Storage_storage_offset(_sparse_coo_tensor_with_dims_and_tensorsr  viewr  slicer   r  r  
lift_freshlift_fresh_copyr  rt  r  r  r  r  s   @rJ   r   r     s   :<E7<JL#%0%5NN5 E3N!&$&!! !##"&((
 (,&+(,(, !]D !%]D  $	]D
 &]D &]D  !]D" 
#]D~DA 
 
  
  "$'5'7  	
 % 
 $6V(V #V #	V
 
V(   	
 	
  \\ \ 	\
 %\ 
\|55 5 	5
 %5 
5nDDDD DD %	DD
 
DDLE#E# NE# 	E#
 (E# 
E#N(C(C (C 	(C
 (C %(C %(C 
(CTHH H 	H
 H %H H 
'HTbb b 	b
 b %b %b 
"bHG8G8 -G8 	G8
 G8 G8 
G8R ( 	
   
G2,M, , 	,
 , %, 
,d "$'5'7BB B 	B
 %B 
BBll&-l5;lCIl	&l\J=J= J= 	J=
 J= J= 
J=Xi
i
 i
 	i

 %i
 
i
` 3>	3/	
/5/5 '/5 $	/5
 /5 
//5b/!/! /! $	/!
 /! 
/!d 04,	4 !,

  ""''  

!!$$		//55==! +6		!!

+'6
 4??22D4H4H4P4PQH
WW  4W 	W
 %W 
W: )-#'6:

 &	

 !
 4
 
 

rM   c                   ddl m}m} t        j                  j
                  j                  j                         du}|r ||      D ]  }t        d       y ||      D ],  }|j                  D ]  }|| j                  vst        d       . y)a  
    Validate symbolic content in output and raise _BypassDispatchCache if
    caching should be bypassed.

    Args:
        state: Cache key state containing known symbols
        output: Output to validate
        proxy_mode_active: Whether PROXY dispatch mode is currently active

    Raises: _BypassDispatchCache: If output contains symbolic content that
        prevents caching

    Details:

    If our output contains any symbols that didn't appear in the input then we
    need to bypass. Usually this will be unbacked symbols which can't be
    properly reconstructed but there could be "weird" cases where backed symbols
    spontaneously appear (from non-input state)?

    If we're proxy (symbol) tracing and the output contains ANY symbols then we
    need to bypass. The problem is that ProxyTorchDispatchMode relies on SymNode
    object identity and being able to see the construction of SymNodes.

    We could improve the proxy tracing case in a few ways:

    1. If the output SymNodes are directly copied from inputs then this is
       actually fine - they're already tracked. This would probably be the
       biggest bang/buck.

    2. If the output (tensors) are all direct copies of the inputs then this is
       also fine - since they're inputs they must be tracked. We already compute
       this we just don't plumb it around enough.

    3. If the output SymNodes are already tracked by the proxy then this is also
       actually fine - they're properly tracked. This probably wouldn't be
       common since for most outputs we use torch.empty_strided() and recompute
       strides.

    4. We could use the proxy to track "how" the SymNodes were computed and when
       using the cache we could "replay" them properly to teach the proxy how to
       build them.
    r   )_iterate_exprs_iterate_nodesNzProxy mode with SymNode outputzunrepresented symbol in output)r  r  r  rz   r  r  r  r  rA  r(  r  )r  r  r  r  r  r   r  r1  s           rJ   r  r    s    Z U&&33BBDDPJ  ' 	IA&'GHH	I  ' 	QA.. Q!4!44./OPPQ	QrM   c                    t         j                  j                  |j                  v ri t	               5  d fd}|D cg c]
  } ||       }}t
        j                  ||      \  }} ||i |}	d d d        t               |D ]H  }
t        |
t              st        |
      r j                  |
j                         j                         J d fd}t
        j                  |	      S c c}w # 1 sw Y   xY w)Nc                    j                  |       r\t        j                  | | j                        }| j                  r|j                  | j                                | t        |      <   |S | S )Nr@  )rq  rz   
zeros_liker  r   _coalesced_r  rW  )r  r   r   	inp_implss     rJ   to_real_tensorz+run_fallback_kernel.<locals>.to_real_tensorV  sY    $$Q'&&q?;;OOANN$45%&	"S'"
HrM   c                "   t        |       vr9t        | t              r)t        |       s| j	                         j
                  v rt        | t              r7t        |       v rt        |          S j                  j                  |       S | S rp   )rW  r   r   r   r   _cdatar\  r2  )r  r   r   orig_not_implemented_exceptionstoragess    rJ   map_outz$run_fallback_kernel.<locals>.map_outp  s    a5	!q&!!!$  "))X500a !u	! A'' 66GG	STUUHrM   )r  rA   rQ   zUnion[T, Tensor]r  )rz   r  r  r  r&   r   rZ  rQ  r   r   r   r  r   r#  r,   )r   r`   r  r  r$  r!  r  r  r  r}  r  r&  r   r%  s   `   `       @@rJ   r  r  C  s     yy*,,I 
 "	 1::1^A&:	:,,Y	Bf$!&!"  &)UH 8a  #Q--/6678   ??7A&&C ;" "s   C:C5#C:5C::Dc                .    |j                          || |<   y rp   )r.  rK  r   r  s      rJ   r  r    s    
 E#JrM   c                    || |<   y rp   rV   r(  s      rJ   r  r    s    
 E#JrM   c                  4    e Zd ZddZ	 	 d	 	 	 	 	 	 	 	 	 ddZy)FakeCopyModec                    || _         y rp   )r   )rI   r   s     rJ   rK   zFakeCopyMode.__init__  s	    "rM   Nc                   |r|ni }|t         j                  j                  j                  u r<t	        |d   t
              sJ  || j                  j                  |d   d      fi |S |t
        j                  u rt        |      dk(  rt        |      dk(  sJ t        t
        |d         }t        t        t        t        f   |d         }t        |      |v r|t        |         S | j                  j                  |d      }||t        |      <   |S t         j                  j                         5   ||i |cd d d        S # 1 sw Y   y xY w)Nr   T)rO     r1   )rz   r{   
TensorBaser  r   r   r   r  __deepcopy__r  r   ru   r#  r   rW  DisableTorchFunctionSubclass)rI   r`   r  r  r  r   memor   s           rJ   __torch_function__zFakeCopyMode.__torch_function__  s9    "r 588&&,,,d1gv...**47$*GKQ  V(((t9>c&kQ&666&$q'*FS*_-tAw7D&zT!BvJ''..,,V4,HC"DFJ668 -T,V,- - -s   2EE)r   r   rQ   rR   )rV   N)
r`   r<   r  r  r  r  r  zOptional[Mapping[str, object]]rQ   r   )rS   rT   rU   rK   r3  rV   rM   rJ   r+  r+    sD    # "$15-- - 	-
 /- 
-rM   r+  c                    t        |       dk(  rt        | d   t              sJ | d   j                  j                  rt        j                  d      S | d   j                  S )Nr1   r   r4  )r  r   r   r   rK  rz   r  r  r  s    rJ   _device_handlerr6    sT     t9>ja*===Aw--||F##Aw"""rM   c                &    t        d | D              S )Nc              3  2   K   | ]  }t        |        y wrp   )r  r   s     rJ   r   z&_check_for_subclass.<locals>.<genexpr>  s     =a&q)=r   )r   )r  s    rJ   r  r    s    =9===rM   c                    t        | t               xrJ t        | t              xr8 t        |       t        uxr% t        |       t        j
                  j                  uS rp   )r   r   r   r   rz   r  r  r   s    rJ   r  r    sQ    q*%% 	.q&!	.G6!	. G588---	rM   c                d    t        d t        t        | d         j                         D              S )Nc              3  2   K   | ]  }t        |        y wrp   r#  r   r  s     rJ   r   z<lambda>.<locals>.<genexpr>  s      4A4r   r   )r  r   r   rH  r5  s    rJ   r@  r@    s,    e 4VT!W-2244 / rM   c                d    t        d t        t        | d         j                         D              S )Nc              3  2   K   | ]  }t        |        y wrp   r=  r>  s     rJ   r   z<lambda>.<locals>.<genexpr>  s      6A6r   r   )r  r   r   r  r5  s    rJ   r@  r@    s,     6VT!W-4466 1 rM   c                V    t        t        t        | d         j                               S r  )r#  r   r   r  r5  s    rJ   r@  r@    s"    VT!W,,.9 rM   )_device_not_kwarg_ops_is_tensor_constructor_like_tensor_constructorscontains_tensor_typesr  r  r  r  c                h    | t         j                  v r t         j                  j                  |        y y rp   )r   rK  r   r  s    rJ   r  r     s)    
n"""  % #rM   c                    t         j                  d       t         j                  dt        j                         t         j                  dt        j                         t        j
                  } | rjt         j                  d       t        d | D              }t        | j                         d       D ]#  \  }}t         j                  d|d	z   | d
|       % y y )NzFakeTensor cache stats:z  cache_hits: %sz  cache_misses: %sz  cache_bypasses:c              3  2   K   | ]  }t        |        y wrp   )r  )r   r	  s     rJ   r   z#dump_cache_stats.<locals>.<genexpr>  s     -qCF-r   c                    | d    S rE   rV   )r  s    rJ   r@  z"dump_cache_stats.<locals>.<lambda>  s    AaD5 rM   r  z    %-*s %sr1   r  )	rV  infor   rL  rM  rN  maxsortedrw   )rG  widthr	  r   s       rJ   dump_cache_statsrN    s    HH&'HH!:!:;HH!>#>#>?,,H$%-H--8>>+A 	;DAqHH]EAI!Aw:	; rM   c                &   dfd}|j                         dk7  r |d|j                                 t        |j                               D cg c]5  }t        j                  j
                  j                  | j                        7 }}dg|j                         z  }t        |j                               D cg c]	  \  }}||f }	}}|	j                  d        d}
|
}|	D ]P  \  }}||
k7  r' |d|j                   d	|j                          d
       |||<   |
|j                  |   z  }
|||   z  }R | 5  t        j                  |||j                  |j                  |j                        cd d d        S c c}w c c}}w # 1 sw Y   y xY w)Nc                <    t        dj                   d|  d      )NzQpropagate_real_tensors: we cannot infer a Fake kernel (meta kernel) for operator z	 because z>. Please use torch.library.register_fake to add a Fake kernel.)r  rd  )rZ   r<  s    rJ   unsupportedz1_infer_fake_from_real_tensor.<locals>.unsupported  s1    **,((9VH EKL
 	
rM   r   z'a return has a non-zero storage offset rT  c                    | d   | d    fS r  rV   r:  s    rJ   r@  z._infer_fake_from_real_tensor.<locals>.<lambda>8  s    !qte} rM   r  r1   z(a return was not dense in memory (sizes z	 strides ))r  r  r   )rZ   rY   rQ   rR   )r  r  r  rz   r  r  allocate_sizer  r  r  sortr  r  r  r  r   )r  r<  r^  rQ  r   
fake_shapefake_stridesr  r  r7  expectedfake_strides    `          rJ   rH  rH    s   
  A%5h6M6M6O5PQ	
 x||~& 	  ..t~~>J  4(,,.(L&/0A&BCFC3xCGCLL,L-HK 43=:8>>:J)T\TcTcTeSffgh (ShnnS11!JsO34 
 
""??..??

 
5 D
 
s   :E<;F:8FFc                   | j                   J t        j                  |      \  }}t        d |D              st	        d|j
                         |D cg c]  }t        | ||       }}t        j                  ||      S c c}w )Nc              3  P   K   | ]  }t        |t        j                           y wrp   )r   rz   r   rm  s     rJ   r   z5inferred_fake_kernel_from_real_out.<locals>.<genexpr>W  s     Bqz!U\\*Bs   $&zPpropagate_real_tensors: we don't support operators that return non-Tensors. Got )r  r   rY  r   r  r   rH  rZ  )r  r<  r^  real_flat_outspecr   fake_flat_outs          rJ   r  r  N  s     >>%%%
 !--h7M4BMBB  "

|-
 	

 IVV11$A>VMV  55 Ws   B)rw   rA   rQ   zdict[T, Literal[True]])rQ   z2Generator[Optional[TorchDispatchMode], None, None])r   r   rQ   zGenerator[None, None, None])r   r   r    list[Union[Tensor, int, SymInt]]rQ   r_  )r   r  rQ   zTypeGuard[Tensor])r   r  rQ   zOptional[FakeTensorMode])r`   r<   rQ   ztorch._C._SchemaInfor  )r   ztype[T]r   r+   rQ   zlist[T])r   r  rQ   r   )r  r<  rQ   rR   )r   r   rQ   r  )r  r2   r  r   rQ   rR   )r   r   r`   r<   r  r  r  r+   r$  r  rQ   r   )rK  rJ  r   r!  r  _DispatchCacheEntryrQ   rR   )r  r  rQ   r<  )r  r  rQ   r   )r   r  rQ   r   )r   r!  rQ   rR   rP   )r  r   r<  torch._ops.OpOverloadr^  torch.TensorrQ   rb  )r  r   r<  ra  r^  r   rQ   r   )
__future__r   atexitr  r  r  r  r#  r_  	threadingre  r  typingrq   collectionsr   r   r   r   r   r	   r
   r   r   r   typing_extensionsr   r   rz   torch._library.utilsr  r  r  r   r   r   r   torch._C._functorchr   r   "torch._library.fake_class_registryr   torch._library.fake_profiler   torch._loggingr   torch._prims_commonr   torch._subclasses.meta_utilsr   r   r   r   r   torch._utilsr   torch.fx.immutable_collectionsr    torch.fx.operator_schemasr!    torch.multiprocessing.reductionsr"   torch.overridesr#   torch.typesr$   r%   torch.utils._mode_utilsr&   torch.utils._python_dispatchr'   r(   torch.utils._pytreer)   r*   r+   r,   r-   r.   torch.utils._statsr/   torch.utils._tracebackr0   _fake_tensor_utilsr2   r3   r4   collections.abcr5   r6   r7   r8   r9   r:   torch._guardsr;   
torch._opsr<   r  r=   r>   	getLoggerrS   rV  _logginggetArtifactLoggerr  r  
ValueErrorr  rY   r  DimList_pytreer   rA   r  r  r  r  rG   rC   r  rX   r_   rc   re   rg   ri   localrk   r  rx   contextmanagerr   r   r   r   r   rK  r   r   r   r   r   rH  rR  rY  r[  rc  r   r  r  r  r!  r0  r3  r9  r=  r`  r  rA  rC  r   r  _StoragePointerr  r  r  r  r+  r6  r  r  r  r  r  rH  r  r  r  r  r  r	  profiler_record_function_exit_RecordFunctionr  torch._subclasses.fake_implsrB  rC  rD  rE  r  r  r  r  r  registerrN  rH  r  rV   rM   rJ   <module>r     s   "       	      # !	 	 	 # !  , , 3 3 T ? 8 , 5  % 9 8 ; - 1 / W V $ 4 R R PP#$%Og!		)	)(4J	K..::8EVW 			CLzz~~   \   ,   <   <   <   L  GIOO G  /& - - , ,>%"02 . . 	D 	D@
$g gT 
 
 @@ @ @,B B>E >EB{4 {4| &79LLM  *% *% *%Z#L $ $ $8	 	 $d#6 6 $6$ $d#
" 
" $
" $d#  $  8:S ST $d#9  $ $d#  $(w
& w
t9 :Q:Q#-:Q	:Q|='='
='  =' 	='
 %1=' ='@7	  
	7	  
	 -$  -F#0> 
IINN!!?	IINN " 
IINN!! $ 
IINN!!)) ,  (	IINN''	IINN$$	IINN%% 
II,,<< 	 	 	&
 	; 	;9

9
39
?K9
9
x6
636?B66g  )SV3/g//;M0MN 	s   W X"W<<X