o I hj @s ddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZddlmZddl mZmZmZmZmZmZmZmZddlmZmZddl mZddlZddlmmZ ddlm!Z!m"Z"m#Z#m$Z$dd l%m&Z&m'Z'dd l(m)Z)dd l*m+Z+dd l,m-Z-dd l.m/Z/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?m@Z@ddlAmBZBddlCmDZDddlEmFZFmGZGddlHmIZImJZJmKZKmLZLmMZMmNZNddlOmPZPddlQmRZRddlSmTZTmUZUmVZVer*ddlWmXZXmYZYmZZZm[Z[ddl\m]Z]ddl^m_Z_ddl`maZadd lbmcZcmdZdeeefZgz ejhiefd!ZjWn!ekyYZlzd"emelvrMddlZjnelWYdZl[lndZl[lwwGd#d$d$ZnenZoepZqejjrZsed%ZtejujvjwZwdZxdayGd&d'd'ZzeGd(d)d)e{Z|eGd*d+d+e{Z}eGd,d-d-e{Z~eGd.d/d/e{ZeGd0d1d1e{ZGd2d3d3e jZeZdd7d8Zejdd:d;Zdd@dAZddEdFZddIdJZedddNdOZedddQdRZddXdYZddZd[ZGd\d]d]ZedddadbZejddfdgZddhdiZGdjdkdkZGdldmdmZGdndodoe$Zee?dpdqfZeBeGdrdsdsZddtduZeBeGdvdwdwZeBedxdyGdzd{d{ZeBedxdyGd|d}d}ZeBedxdyGd~ddeZeBedxdyGdddZGdddddeGZeZdddZGddde=ZdddZdddZdddZejvjjjeejvjwjjddejvjwjjddejvjwjjddiZeejvjwjjejvjwjjejvjwjjZddlmZmZmZmZmZmZmZmZejdddZdddZdddZdS)) annotationsN) defaultdict) dataclass)AnyCallablecastLiteralOptional TYPE_CHECKINGTypeVarUnion)Self TypeGuard) ReferenceType)SymBoolSymFloatSymIntTensor)is_functorch_wrapped_tensoris_legacy_batchedtensor)FakeScriptObject)dtrace_structured)suggest_memory_format) assert_eqassert_metadata_eq is_sparse_anyis_sparse_compressed MetaConverter) render_call)immutable_dict)normalize_function)StorageWeakRef)TorchFunctionMode) IntLikeType py_sym_types)dataclass_slots) no_dispatch)is_traceable_wrapper_subclassTorchDispatchMode)KeyPathkeystrPyTreetree_map tree_map_TreeSpec)count)CapturedTraceback)_CacheKeyState_PySymInputStub_SymIntOutputStub) GeneratorIterableMappingSequence) TracebackType)Source) OpOverload)ShapeEnvSymbolicContextnot_implementedz 'not_implemented' not registeredc@s eZdZdS) _UnassignedN)__name__ __module__ __qualname__rCrCQ/var/www/vscode/kcb/lib/python3.10/site-packages/torch/_subclasses/fake_tensor.pyr?Ksr?Tc@s eZdZdddZdddZdS) IncrementRecursionCountreturnNonecCs td7adSNr1RECURSION_COUNTselfrCrCrD__init__b z IncrementRecursionCount.__init__cCs td8adSrIrJrLrCrCrD__del__frOzIncrementRecursionCount.__del__NrGrH)r@rArBrNrPrCrCrCrDrFas rFc@eZdZUded<dS)UnsupportedFakeTensorExceptionstrreasonNr@rArB__annotations__rCrCrCrDrSk rSc@rR)DynamicOutputShapeExceptionr;funcNrVrCrCrCrDrYprXrYc@rR)DataDependentOutputExceptionr;rZNrVrCrCrCrDr[urXr[c@rR)UnsupportedOperatorExceptionr;rZNrVrCrCrCrDr\zrXr\c@rR)MetadataMismatchErrorrTrUNrVrCrCrCrDr]rXr]c@s eZdZUded<dddZdS) FakeTensorTLSOptional[bool]allow_non_fake_inputs_overriderGrHcCs d|_dSN)r`rLrCrCrDrN zFakeTensorTLS.__init__NrQ)r@rArBrWrNrCrCrCrDr^s r^itemsrGdict[T, Literal[True]]cGs t|dSNT)dictfromkeys)rcrCrCrD ordered_set rh2Generator[Optional[TorchDispatchMode], None, None]c csRtjtjjj}z|VW|durtj|dSdS|dur(tj|wwra)torch_C_unset_dispatch_mode_TorchDispatchModeKeyFAKE_set_dispatch_mode)oldrCrCrDunset_fake_temporarilys rrsubclassrout list[Union[Tensor, int, SymInt]]csV|g}|r)|ts|q\}}|fddt|D|s|S)Nc3s|]}t|VqdSragetattr).0keycurrrCrD z$get_plain_tensors..)popr'append__tensor_flatten__extendreversed)rsrttodo inner_keys_rCrzrDget_plain_tensorss   rxobjectTypeGuard[Tensor]c sddlm}ttr dStr?t\}}fdd|D}tdd|D}tdd|D}||ks=Jd |St|rIt j Stt rdt rdt j}t jj|}t |Stt rxtrxt jj}t |Sd S) NrFunctionalTensorTcsg|]}t|qSrCrv)rxattrrrCrD szis_fake..cs|]}t|VqdSrais_fakerxrrCrCrDr|zis_fake..csrrarrrCrCrDr|rz got mixed fake and real tensors!F)#torch._subclasses.functional_tensorr isinstance FakeTensorr'typerallanyrelemrrk_is_functional_tensorrl$_functionalization_reapply_views_tls _functorch_unwrap_functional_tensorr get_unwrapped) rrattrsrflattened_tensorsall_fakeany_fake reapply_views unwrappedrCrrDrs(     rtOptional[FakeTensorMode]csddlm}ttrjStr4\}}fdd|D}|dtfdd|Ds2JSt|r>tj Stt rYt rYt j }t j j|}t|Stt rmtrmt j j}t|SdS)Nrrcsg|] }tt|qSrC)maybe_get_fake_moderw)rxt_namerrCrDrsz'maybe_get_fake_mode..c3s|]}|uVqdSrarCr)mrCrDr|rz&maybe_get_fake_mode..)rrrr fake_moder'rrrrrrkrrlrrrrr)rrinner_tensor_namesrmodesrrrC)rrrDrs*       rrZr;torch._C._SchemaInfocCstj|jSra)rkrl _SchemaInfo_schemarZrCrCrDget_schema_infosrboolcCs6ddlm}tjj}||jdo||jt|vS)Nrdecomposition_tablez torch._decomp) torch._decomprrk_decompdecompositionsrA startswithr@dir)rZrrrCrCrDtorch_decomp_decompositionss  rtytype[T]treer+list[T]cst|}fdd|DS)Ncsg|] }t|r|qSrC)rrxrrrCrDrz%tree_flatten_only..)pytree tree_leaves)rr flat_valsrCrrDtree_flatten_onlys rcCs@t|tuo|jtjko|jp|jpt|pt|pt | Sra) rrlayoutrkstrided is_sparse is_nestedrrrrrCrCrD_is_plain_tensors  rc@seZdZUed3ddZded<ded<d ed <d d d d4ddZd5ddZd6ddZd7ddZ d8ddZ d9d d d!d"d:d-d.Z d;d1d2Z d S)<FakeTensorConverterrGweakref.WeakValueDictionarycCs|jjSra)meta_converter tensor_memorLrCrCrDrszFakeTensorConverter.tensor_memorrz)dict[StorageWeakRef, list[ReferenceType]]constant_storage_mappingrexportF copy_datarrrHcCst|d|_||_i|_dS)N)r)rrrr)rMrrrCrCrDrNs  zFakeTensorConverter.__init__ fake_tensorrcCsTt|tr |jdus Jt|j}||jvrg|j|<|j|t|dSra) rrconstantr!_typed_storagerrweakrefref)rMrweak_strCrCrDadd_constant_storage_mapping"s   z0FakeTensorConverter.add_constant_storage_mappingtensorrcCs`t|trJt|}||jvrdS|j|D]}|}|dur)|d|_q|j|=dSra)rrr!rr _fix_weakrefr)rMrrweak_tensor_reftenrCrCrDinvalidate_constant_aliases0s   z/FakeTensorConverter.invalidate_constant_aliasesrOptional[FakeTensor]cCs(|jjj|}|durdS|j|Sra)r describer lookup_tensorgetr)rMrtidrCrCrD _get_memo?s zFakeTensorConverter._get_memovcCs|jj|}||jj|<dSra)rr get_tensor_idr)rMrrrrCrCrDset_tensor_memoEsz#FakeTensorConverter.set_tensor_memoNT)sourcesymbolic_contexttracerFakeTensorMode make_constant shape_envOptional[ShapeEnv]rOptional[Source]rOptional[SymbolicContext]rcs0|s(|s(|r(tjj}r(||jvr(|j|}ddlm} t|| s%J|j}| |} | dur3| S|j r:t dt |tj jurF|rFJ|rJ|nddfd d } |j||| |||d } | turgt d ddlm} d}|jst|r|dkr|jj dkr|jtjtjtjtjtjfvr|durt|| s|durddlm}m}ddlm}t |!}Wdn1swYt"#|st"$|st||r|j%}n||}|j&|||j'|d}|jtjkr|j(|||d| _)n|jtjkr|j*|||d| _)|r|+| | S)Nr)StatefulSymbolicContextzquantized nyi in meta tensors make_meta_tCallable[[], object]deviceUnion[torch.device, str]rGrcs<tt||dWdS1swYdS)Nr)r&r)rrrrrCrDmk_fake_tensorts $z.mk_fake_tensor)rcallbackrrrzmeta converter nyi)RandomValueSourcecpu)CallMethodItemSourceFloatTensorSource) DimDynamic)r dynamic_dimr)hintr)rrrrrGr),rk_guardsTracingContexttry_gettensor_to_context%torch.fx.experimental.symbolic_shapesrr tensor_sourcer is_quantizedrSrnn ParameterrNotImplementedtorch._dynamo.sourcerrrdimrdtypeint64int32int16int8float64rrrr&itemmathisnanisinfbasecreate_unspecified_symbolDYNAMICcreate_symintnode item_memocreate_symfloatnoder)rMrrrrrrrtracing_contextr maybe_memorrtrvaluerrr item_sourcesymbolrCrrDfrom_real_tensorOs               z$FakeTensorConverter.from_real_tensorr torch.devicecCsR|jjdksJd|jjd||}|dur|St|||}||||S)Nmetaz$tensor's device must be `meta`, got z instead)rrrrr)rMrrrr rtrCrCrDfrom_meta_and_devices   z(FakeTensorConverter.from_meta_and_device)rGr)rrrrrGrH)rrrGrH)rrrGrH)rrrGr)rrrrrGrH)FN)rrrrrrrrrrrrrrrGr)rrrrrr%rGr) r@rArBpropertyrrWrNrrrrr$r'rCrCrCrDrs(      rrr%rHcCsDtjs tjr tjjdurtjd|dntjd|ddSdS)Nr1r)rkcuda is_availablexpuversionhipemptyzerosr)rCrCrDinit_gpu_contexts  r1rrGenerator[None, None, None]c cs|j}tj}||ksJ|d|tj<d|_tjtjdzdVW||_n||_wWdn1sBwYWddSWddS1sZwYdS)N, T)in_kernel_invocationrkrl_meta_in_tls_dispatch_include_DisableTorchDispatch_PreserveDispatchKeyGuard!_set_meta_in_tls_dispatch_include)rprev_in_kernel meta_in_tlsrCrCrDin_kernel_invocation_managers    "r;cCs$tj|ddddS)Nz::.r)rkrl _should_allow_numbers_as_tensorsnamesplitrrCrCrDshould_allow_numbers_as_tensorssrAc@seZdZejdddkZdS)FakeTensorConfigTORCH_FAKE_TENSOR_DEBUG01N)r@rArBosenvironrdebugrCrCrCrDrBsrBc@sneZdZUded<ded<ddd!d d Zd"ddZd#ddZd#ddZd#ddZ d$d%ddZ d&dd Z dS)'SymNumberMemoDescriptorrT_namer_is_nested_intF is_nested_intrMrGrHcC ||_dSra)rK)rMrMrCrCrDrN0rbz SymNumberMemoDescriptor.__init__ownerr?cCs ||_dSrarJ)rMrOr?rCrCrD __set_name__3rbz$SymNumberMemoDescriptor.__set_name__objrcCs d|jS)NrrPrMrRrCrCrD_memo6rizSymNumberMemoDescriptor._memocCd|jdS)Nr_vcrPrSrCrCrD_memo_vc9z SymNumberMemoDescriptor._memo_vccCrU)Nr_epochrPrSrCrCrD _memo_epoch@rXz#SymNumberMemoDescriptor._memo_epochNobjtypeOptional[type[FakeTensor]]-Optional[Union[torch.SymInt, torch.SymFloat]]cCst|||}durdSt|tjr|jjdur|S|js*t||||j ks9|jsDt|| ||j j krDt |||ddS|Sra)rwrTrrkrnoderrKrW_versionrZrepochsetattr)rMrRr[rrCrCrD__get__CszSymNumberMemoDescriptor.__get__r!cCs|dur!t|||dt|||dt|||ddS|r(|jrKt|||||js>t||||jt||||jjdSdSra) rarTrWrZ is_inferencerKr_rr`)rMrRr!rCrCrD__set__YszSymNumberMemoDescriptor.__set__)rMrrGrH)rOrTr?rTrGrH)rRrrGrTra)rRrr[r\rGr])rRrr!r]rGrH) r@rArBrWrNrQrTrWrZrcrerCrCrCrDrI&s      rIcseZdZUdZded<ded<ded<ded<eZeZeZeZ ed d Z e j j jZed;d d ZejdddZe  d?d@ddZdAfdd ZedBd"d#Zeed$efdCd+d,ZedDd/d0Zd1d2dEd6d7ZdFd9d:ZZS)Gral 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_devicerrOptional[Tensor]r real_tensorTrLrGcCs|jjr tdS|jSNr&)rr4rkrrfrLrCrCrDrs zFakeTensor.devicerrHcCtraNotImplementedErrorrMrrCrCrDr list[str]cCstd)Nz+torch.compile doesn't support named tensors)rSrLrCrCrDnamesszFakeTensor.namescCrjrarkrmrCrCrDrprnNrrrr cCsZtj|||jd|d}|jstj|ntj||jj dks'J|jj t |tjr/|nt|}|j s>|j dks>J|j dvrGt ||j ddddtj fvr|jdur|j dkrxtt|j rxt|j d tt|j }n t|j d }||_||_||_t |trJ||_d|_d|_d|_d|_d|_tjrt|_ |S) NT)dispatch_devicedevice_for_backend_keysr&)r*r,r*hpur,mps:z:0)!r_make_subclass requires_grad_allow_unsafe_data_ptr_accessrkrl_set_throw_on_mutable_data_ptr(_set_warn_deprecated_on_mutable_data_ptrrrr allow_metar1_get_privateuse1_backend_nameindexrwis_initializedcurrent_devicerfrrrrh nonzero_memor unique_memounique_consecutive_memonested_int_memorBrHr0extract _debug_trace)clsrrrrrhrMrCrCrD__new__sL     zFakeTensor.__new__argsrkwargscstdSra)superrN)rMrr __class__rCrDrNrXzFakeTensor.__init__rcCs ||Sra) from_tensor)rrrCrCrDrs zFakeTensor.from_tensorrCrZr;typesSequence[type]Sequence[object]Mapping[str, object]c Cs(|tjjjjkr't|dkrt|dtsJ|djj r"tdS|dj St |}r2||Sdd|D}|rCt d|tSd}tj|i|D] }t|trY|j}nqM|dus`Jtjtjjj} | rtt d|| tS|j ryJ|||i|WdS1swYdS)Nr1rr&cSs"g|] }t|ts|tur|qSrC) issubclassrrrxrrCrCrDr%s z1FakeTensor.__torch_dispatch__..z(FakeTensor unrecognized subclass(es): %sz(FakeTensor mode already active: %s in %s)rkopsprimrdefaultlenrrrr4rf_DISPATCH_META_HANDLERSrnot_implemented_logrHr rarg_tree_leavesrl_get_dispatch_modernro) rrZrrrhandlerunrecognized_typesrargmaybe_cur_fake_moderCrCrD__torch_dispatch__sH          $zFakeTensor.__torch_dispatch__ flat_argstuple[torch.device, bool]csxdd}dddddfd d }|D]}||qtr-dur-d }td dus8Jd|fS)NFrrrGrcSs|jjdko |dkS)Nrr)rrrrrCrCrD cpu_zero_dimZsz4FakeTensor._find_common_device..cpu_zero_dimrrHcs|t|tsdSdur|j|dS|}|jkr#r!|dS|r'dSr0|j|dStddd|j)Nz,Unhandled FakeTensor Device Propagation for z, found two different devices r3)rrr RuntimeError)rt_is_cpu_zero_dim common_devicerrZis_cpu_zero_dimrCrD merge_devices]s(  z5FakeTensor._find_common_device..merge_devicesTrz!Could not find common device for rrrGr)rrrGrH)rArkr)rZrhas_scalar_only_inputsrrrCrrD_find_common_deviceMs  "  zFakeTensor._find_common_devicer1)coeffrUnion[int, torch.SymInt] torch.SymIntcCs6|jdur |jjdd|_t|jtjsJ|j|S)N nt_tensor_id)rrcreate_symbolic_nested_intrrkr)rMrrCrCrDget_nested_ints  zFakeTensor.get_nested_intrcCs<|dkr |S|dkrdd|DSdd|DS)Nrr1cSg|]}|qSrC)rrrCrCrDrz%FakeTensor.tolist..cSrrC)tolistrrCrCrDrr)rrrLrCrCrDrs  zFakeTensor.tolist)rGr%)rr%rGrH)rGro)rrorGrH)NN) rrrrrr%rrgrhrgrGr )rrrrrGrH)rrrrrGr rZr;rrrrrrrGr)rZr;rrrGr)rrrGr)rGr) r@rArB__doc__rWrIrrrrrrkrlrnro _mode_keyr(rsetterrp staticmethodrrNr classmethodr/rrrrr __classcell__rCrCrrDrgsJ       O I C rr3r4c@seZdZUdZded<ded<ded<ded<d ed <d ed <d ed<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<d(d%d&Zd'S))TensorMetadatazK The Tensor metadata relevant to hashing FakeTensors when caching. z torch.dtyperztuple[_MetadataIntLike, ...]shapestrider%rz torch.layoutrzOptional[torch.memory_format] memory_format_MetadataIntLikestorage_offsetzOptional[_MetadataIntLike] storage_bytesrrwr is_conjis_negrdrr_ is_coalesced Optional[int] dense_dim sparse_dimresult list[object]moderstater2rGrHcCsdt|D]*}t||j}t|tttjfr| |||qt|t r*| ||q| |qdSra) dataclassesfieldsrwr?rtuplelistrkSize_prep_args_for_hashrconvert_sym_intr)rMrrrfieldr!rCrCrD _flatten_intos   zTensorMetadata._flatten_intoN)rrrrrr2rGrH)r@rArBrrWrrCrCrCrDrs( rcCst|}|jst|s|j|dsd}|}t|j|j|jt j kr&| nd|j |j||t|s7| nd|j|j||||j|jrN|ndt|rW|ndt|ra|SdS)z1 Extract the TensorMetadata of a tensor. )rNrC)r_has_symbolic_sizes_stridesr is_contiguousrrrrrrkrrruntyped_storagenbytesrwr rrrdrrrr)rrrrCrCrDextract_tensor_metadatas< rc@sJeZdZUdZded<ded<dd d ZdddZdddZdddZdS)_DispatchCacheKeyz0 Key for the FakeTensor dispatch cache. tuple[object, ...]ryint hashvaluetuprGrHcCs||_t||_dSra)ryhashr)rMrrCrCrDrNsz_DispatchCacheKey.__init__otherrrcCst|to |j|jkSra)rrry)rMrrCrCrD__eq__sz_DispatchCacheKey.__eq__cCs|jSra)rrLrCrCrD__hash__ sz_DispatchCacheKey.__hash__cCs"|jD] }t|tr|qdSra)ryrr3strip_shape_env)rMrrCrCrDrs  z!_DispatchCacheKey.strip_shape_envN)rrrGrH)rrrGr)rGrrQ) r@rArBrrWrNrrrrCrCrCrDrs    rT)frozenc@s*eZdZUdZded<ded<ded<dS)_DispatchCacheEntryOutputInfoaV Entry type for the FakeTensor dispatch cache for an output. Accounts for two 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. r inplace_idxzOptional[TensorMetadata]metadataview_idxNr@rArBrrWrCrCrCrDrs   rc@s&eZdZUdZded<dZded<dS)_DispatchCacheEntryz 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_infosFris_output_tupleN)r@rArBrrWrrCrCrCrDr's rc@seZdZUdZded<dS)_BypassDispatchCachez< Signals cases that should skip FakeTensor caching. rTrUNrrCrCrCrDr6s  rc@s2eZdZUdZded<ded<ded<ded<dS) DispatchCacheInfozG Information about the state of the FakeTensor dispatch cache. rhitsmissesdict[str, int]bypassessizeNrrCrCrCrDr@s  rc seZdZUiZded<dZded<dZded<eeZ ded<dZ ded <d Z d ed <d ed <ded<ded<d ed<dZ ded<dZ ded<dd ddd ddfdd Zdd!d"Zdd&d'Zedd(d)Zedd+d,Zed-efdd6d7Zdfd9d: ZdfdAdB ZeddCdDZeddFdGZeddHdIZddJdKZddOdPZddQdRZddVdWZ dd[d\Z!dd_d`Z"ddbdcZ#ddedfZ$ddhdiZ%ddjdkZ&d-efddldmZ'ddsdtZ(ddzd{Z)dd|d}Z*e+d~dddddddZ,dddZ-dddZ.dddZ/dddddZ0e+e1j2j3e1j4j5e1j6j5e1j7j5e1j8j5e1j9j5e1j:j5e1j;j5e1je1j?j5 Z@dddZAe+e1jBj5e1jCj5ZDdddZEdddZFddddddddZGZHS)rz,dict[_DispatchCacheKey, _DispatchCacheEntry]cacherr cache_hits cache_missesrcache_bypassesr`Frr4 static_shapesrrz Optional[str]_stackr{r<nt_tensor_id_counternt_tensor_id_initial_countTN)allow_fallback_kernelsallow_non_fake_inputsrrrrrr_rrGrHcstdt|t||_ddl}ddl}|jj j |_ t |j |d|_ |dur.||_n|du|_d|_|jj j|_|jj j|_|jj joJ|j |_|jj j|_||_d|_g|_||_t|_d|_ |j!j"j#|_$ddl%}|j&j'j(j)|_*|j*|_+dS)Nzcreate_mode 0x%xrrF),logrHidrrNrtorch._dynamo.configtorch._functorch.configrconfig"fake_tensor_propagate_real_tensorspropagate_real_tensorsrfake_tensor_converterrallow_scalar_outputs(fake_tensor_allow_unsafe_data_ptr_accessrxfake_tensor_allow_metar{_dynamofake_tensor_cache_enabled cache_enabled$fake_tensor_cache_crosscheck_enabledcache_crosscheck_enabledrr4 enter_stackr traceback extract_stack _stack_tracerrlrnror$torch.nested._internal.nested_tensornested _internal nested_tensor_tensor_id_counterrr)rMrrrrrrkrrCrDrNnsF          zFakeTensorMode.__init__cCs |j|_dSra)rrrLrCrCrDreset_nt_tensor_id_counterriz)FakeTensorMode.reset_nt_tensor_id_counterrrTypeGuard[FakeTensor]cCst|to |j|uSra)rrrrMrrCrCrD is_our_fakeszFakeTensorMode.is_our_fakecCsDtjrtjr Jtj Stjp ttdo tj S)Nrs)rkr, _is_compiledr*r+hasattrrsrLrCrCrDavoid_device_inits   z FakeTensorMode.avoid_device_initrTcCs$|jdurdt|j|_|jS)N)rjoinr format_listrrLrCrCrDstacks zFakeTensorMode.stackrCrZr;rrrrrrcCsLtjtjjjdusJ|z |||||WSty%tdw)Nzfake tensor raised TypeError) rkrlrrnrodispatch TypeErrorr exception)rMrZrrrrCrCrDrs   z!FakeTensorMode.__torch_dispatch__r cs|ddl}d}|jr|j}|jd|j|j}||ur-|jd||ft S|j ||jdd|f|S)NrTF) rr rl_only_lift_cpu_tensors_set_only_lift_cpu_tensorsrmrrrr __enter__rp)rMrkprev_only_lift_cpu_tensorsmaybe_prev_fake_moderrCrDr*s    zFakeTensorMode.__enter__aOptional[type[BaseException]]bOptional[BaseException]cOptional[TracebackType]csX|j\}}}|r(t||||durtj||dur*tj|dSdSdSra)rr~r__exit__rkrlrpr))rMr-r/r1liver, maybe_prev_only_lift_cpu_tensorsrrCrDr3s  zFakeTensorMode.__exit__cCsdSrerCrrCrCrD is_infra_mode0rnzFakeTensorMode.is_infra_modercCsttjtjttjttjS)z8 Query the state of the dispatch cache. )rrrrrfrrrr6rCrCrD cache_info4s zFakeTensorMode.cache_infocCs$d|_d|_|j|jdS)z+ Clear the dispatch cache. rN)rrrclearrr6rCrCrD cache_clear@s zFakeTensorMode.cache_clearc Cs<t}zqt|j}|||||}|r |jdusJ|jj}ntj}||d} | durJ| || |||}tj d7_ |j rI| |||||n(| ||||||||}|||||||} || ||<tjd7_Wnty} ztj| jd7<WYd} ~ nd} ~ ww|tur|||||}|S)z Lookup a cache entry for the given arguments. If none exists, dispatch and cache the result (if the result is eligible for caching). Nr1) _UNASSIGNEDr2r _cache_keycache_on_shape_envfake_tensor_cacherrr_output_from_cache_entryrr_crosscheck_cache_output_validate_cache_key_dispatch_impl_make_cache_entryrrrrrU) rMrZrrroutputrryrentryerCrCrD_cached_dispatch_implJs:     z$FakeTensorMode._cached_dispatch_implrr2rcCsZ|ttjt|jr|jjndg}|r|||||r'||||tt |S)z Create a cache key given the dispatch args. Raises _BypassDispatchCache for any situation that precludes caching. N) rkget_default_dtyperl_get_default_deviceis_inference_mode_enabledrsettingsrrr)rMrrZrr key_valuesrCrCrDr<us  zFakeTensorMode._cache_keycCstjj|jvr tdtjj|jvrtdtjj|jvr!td|tjj kr+td||j vr4td| dkr>tdtj j |sItd|jr\tj| tjjjr^tdd Sd S) za Validate that the cache key generated by _cache_key will be reasonable. zdata dependent outputzdynamic output shapez inplace viewz unsafe viewliftzinductor::resize_storage_bytes_z non-builtinCompositeImplicitAutogradN)rkTagdata_dependent_outputtagsrdynamic_output_shape inplace_viewaten _unsafe_viewrlift_fnsr?_libraryutils is_builtinis_viewrl%_dispatch_has_kernel_for_dispatch_key DispatchKeyrN)rMrZrrrCrCrDrAs&     z"FakeTensorMode._validate_cache_keyrr?Union[Mapping[str, object], Sequence[object], Iterable[object]]cCs0t|tr||||||||dS|D]z}t|trY||s+td|jdur4tdt |r@t|j dt| t rMtdt|}||||qt|trbtdt|t rn|||qt|ttfrytdt|tttfr||||q|t|||qdS)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. Nz not our fakeconstant attributez tensorzsymbolic nbytesznon-fake tensorzsymbolic shape)rrfrkeysvaluesrrrrrrrrrrrrrrrrrrr)rMrrrrrrCrCrDrs6       z"FakeTensorMode._prep_args_for_hashryrDrcCslt|ts td|jdurtd|jrtdt|r!td|D]}t|t|kr3tdq%dS)Nznon-FakeTensor outputr^z sparse outputzsparse compressed outputzkwarg aliases output)rrrrrrr`r)rMrryrZrrrDkvalrCrCrD _validate_output_for_cache_entrys   z/FakeTensorMode._validate_output_for_cache_entryrrcs,tt|D]}t||t|krt|dddSqd}|jr6ddt|D} t| dks2J| d}t|} tfdd| jD| _tfdd| j D| _ | j | _ | j durbdn | j | _ td| |d} t | fd d } || |||} tj| }tj|}||krtd | S) NrrrcSsg|] \}}t|tr|qSrCrr)rxirrCrCrDr"szCFakeTensorMode._get_output_info_for_cache_entry..r1rc3|]}|VqdSraconvert_outputrxrrrCrDr|'r}zBFakeTensorMode._get_output_info_for_cache_entry..c3rfrargrirjrCrDr|(r}Frrzdispatch_key_set mismatch)rangerrrrZ enumeraterrrrrhrrrr?rkrl_dispatch_key_setr)rMrryrZrrrDidxridxsrrEentry_for_synth_output synth_output synth_key_setkey_setrCrjrD _get_output_info_for_cache_entrysF        z/FakeTensorMode._get_output_info_for_cache_entryrc s|durtdddd}t|fddSt|tr'|D] }|qn |t|trLfdd|D} tt| ddS|}t|fddS)z Make a cache entry object for the given 'output' Tensor. Raises _BypassDispatchCache if the output tensor has characteristics that prevent caching it. NrcFrkc s g|] }|qSrC)ru)rxout_elemrrZryrrMrrCrDrls  z4FakeTensorMode._make_cache_entry..T)rrrrrbru) rMrryrZrrrD output_info out_elementrrCrwrDrCKs:     z FakeTensorMode._make_cache_entryrEc s|jdur||j}t|tsJ|S|j}|durdSt|r"Jdfdd tfd d |jD}tfd d |jD} |j} |j durT|j t j } |j dur`|j j } t|)| tj|| |j|jd |jd } Wdn1swYWdn1swY|jrtj| d|jrtj| d|jr|tt|j} t| tsJ| }t|#| | || || Wdn1swYWdn1swYt|| |jS)Nr!rrr2rGUnion[IntLikeType]cs8t|tr|jdus J||jSt|trJ|Sra)rr4rrr3)r!rryrCrD check_values zGFakeTensorMode._get_output_tensor_from_cache_entry..check_valuec3|]}|VqdSrarCrir|rrCrDr|r}zEFakeTensorMode._get_output_tensor_from_cache_entry..c3r}rarCrir~rCrDr|r}r&)rrrrwT)r!rrr2rGrz) rrrrrrrrrr contextlib nullcontextrsuppress_guardsr;rk empty_stridedrrrwrrl _set_conjr_set_negrZrrrrset_r)rMrrEryrZr inplace_argrrrrmaybe_suppressr/view_argstoragerC)r|ryrrD#_get_output_tensor_from_cache_entry~sV         z2FakeTensorMode._get_output_tensor_from_cache_entry=Union[Optional[FakeTensor], tuple[Optional[FakeTensor], ...]]csB|jrfdd|jD}t|S|jdS)z? Create a new FakeTensor from the cache entry. c sg|] }|qSrC)r)rxrxrrZryrMrrCrDrsz;FakeTensorMode._output_from_cache_entry..r)rrrr)rMrrEryrZroutputsrCrrDr?s  z'FakeTensorMode._output_from_cache_entryc Csz |||||}Wnty'}ztd|d|d|d||d}~wwzI|durc|durct|trSt|t|ks@Jt||D] \}} tt|| qEWdSt|trZJtt||WdS|dusiJ|dusoJWdSty}ztd|d|d||d}~ww)z Helper to validate that the output synthesized from the cache matches the output created by normal dispatch. z*FakeTensor cache crosscheck failure: func=z, args=z , kwargs=z: Dispatch raised=N) rB Exceptionrrrrziprr) rMrDrZrrr true_outputrFr-r/rCrCrDr@sN   z'FakeTensorMode._crosscheck_cache_outputcCs|pi}ttd|||Wdn1swY|tvr)t||Sttjkrtd|d|ddSdSt|tttfrW||krYtd|d|ddSdS)NT) compute_hintzmismatch between fake value z and real value r)rrrrr^expr free_symbols var_to_valr_unbacked_var_to_val_maybe_evaluate_staticEqStruer]rfloatr)rr)rMsympyrCrD_check_fake_real_vals/s6   z?FakeTensorMode._maybe_infer_fake.._check_fake_real_valsReal tensor propagation foundFT)contextsizesstridesrrwmismatched_fake_kernelctjdSNoprUrTrUrCexcrZrCrDYz2FakeTensorMode._maybe_infer_fake.. metadata_fnzFReal tensor propagation found a metadata mismatch between fake tensor z and real tensor z , at outputz , for func: crrrrCrrCrDrnrzIReal tensor propagation found an output size mismatch between fake shape z and real shape z , at outputz.size(z ), for func: zQReal tensor propagation found an output value mismatch between fake output value z and real output value )rrrrrGrH)rtorch._subclasses.fake_utilsrrrkrr]rr*generate_fake_kernels_from_real_mismatchesr_infer_fake_from_real_tensorr*rmrr) rMrZrrrrrjs_fakes_realrC)rrZrMrrD_maybe_infer_fake#s     "   z FakeTensorMode._maybe_infer_fakefake_inreal_infake_outreal_outOptional[object]c sddlm}djrtjjdfdd }t|\}} t|\} } z |d||||Wn=tynz1t j j j r\t d fd d d |tfd d |WYdStd|d|ddwwtfddt|| D\} } t| rr|t| | S)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_infoNrGrHcsttjjj_dSra)rsetrpending_fresh_unbacked_symbols differencerC)pending_unbackedrMrCrD_clear_pending_unbackeds   zXFakeTensorMode._maybe_infer_fake_kernel_from_pytree_out.._clear_pending_unbackedrrcstdjdS)Nz>Mismatched aliasing spec between fake kernel and real kernel: rrrCrrCrDrs zIFakeTensorMode._maybe_infer_fake_kernel_from_pytree_out..rcs t|SrarrrZrMrCrDrs zGReal tensor propagation found an aliasing mismatch between fake output z and real output z , for func: cs$g|]\\}}}|||qSrC)r)rx _fake_path _fake_out _real_outrrCrDrs zKFakeTensorMode._maybe_infer_fake_kernel_from_pytree_out..rQ)rrrrrrtree_flatten_with_path tree_flattenr]rkrrrrr,rrtree_unflatten)rMrZrrrrrrfake_paths_leaves fake_spec real_leavesr fake_leaves overridesrC)rrZrrMrD(_maybe_infer_fake_kernel_from_pytree_outs^         z7FakeTensorMode._maybe_infer_fake_kernel_from_pytree_outc% st f\t}|rddD}td|tSfddD}tdd|Dp8tddDjjv}t j j j j uoXtdt joXdjjd k} |r]|rgtrs|s| std d|DswJd fd dD} t| \} } | i| } t| tur| rt | } Wdn1swYj| d dS|rt dkrtdksJd tdturdSd}jrt j j j j krd vr ddkrd }t j jjj krd }\} tdd|D}t jjj vrt jj!j vr|rt|dkrs|sfddD} t| \} } t| i| } Wdn 1sawYt"| }dd|D}tfdd|D}|rt#tfdd| S|D]}$|qt\ %| d:fdd dd l&m'm(t) j*r1td!d|Dr1tfd"dDs1t+d# fd$dD}t|\ t,-}|st,.|}z  i Wnt/y }z t+d%|WYd}~nd}~ww|s0|0t,1j2nj*rFt+d&|j3rCj3j4ndd; f d(d) }rqt56}|durq||gRi Sdd*l7m8}|vr9sdd+l7m:}|vrst;rtd,d|Dr||i WdS1swY j<i }|tur||WdSWdn 1swYd-j=j>vrt?d.rt@s|jAi WdS1swYt jBjCjD}|dur4|jEvr4|jFgRi Sj*rc urct,-scj3durct,GsctH}tId/fd0dd1||St jJjKjLM>jNjO}|rt jJjNPt jJjNQfd2d-|i }||WdWdS1swYWdn 1swYtRD]!\}} |r| gRi }!|!tur||!Sq dNcSsg|] }t|rt|qSrC)_check_for_subclass_argrrrCrCrDrs z1FakeTensorMode._dispatch_impl..z,FakeTensorMode unrecognized subclass(es): %scsg|] }|r|qSrC)rrrLrCrDrrcss|]}|jVqdSra)r)rxrerCrCrDr|s z0FakeTensorMode._dispatch_impl..css|]}t|tVqdSra)rrrxr-rCrCrDr|r}rr&cs|]}|jduVqdSrarrrCrCrDr|s  z. should not have fake inputs without constantsc g|] }|r |jn|qSrCrrrrLrCrDr Trr1rFrrcsrrarrxrFrCrCrDr|Cr}crrCrrrLrCrDrLrcSsg|] }t|tr|qSrCrdrrCrCrDrWrc3rfra)may_turn_constrrLrCrDr|Xr}csj|ddS)NTr)r$r) converterrMrCrDr]sz/FakeTensorMode._dispatch_impl..rrErG1Optional[Union[T, Tensor, torch._C.ScriptObject]]cs`t|tr|jSt|tr&jdusJ|j|jjjj jj St|t r.|j S|Sra) rrrhr$rr^pytyperxreplacerrrreal_objrrLrCrDmaybe_to_real_tensorks   z;FakeTensorMode._dispatch_impl..maybe_to_real_tensor)compute_unbacked_bindingsfree_unbacked_symbolscsrra)rhrrCrCrDr|r}c3sF|]}t|to|ojduotfddDVqdS)Nc3s|] }|jjvVqdSra)rrrxsrLrCrDr|z:FakeTensorMode._dispatch_impl...)rrrrr)rrMsymsrCrDr|s  zpropagate_real_tensors %scg|]}|qSrCrCr)rrCrDrrz9real-tensor fallback failed for %s: %s; silently ignoringz,SKIPPED propagate_real_tensors %s(%s, %s) %srcsddltdd  fd d uritjjjs+ f f| n f f| }t|t s[t t s[t |t kr[t t t |t t  nt |  j|d d |S)Nrzmaybe_propagate_real_tensors %srrreal_trrGrHcs2t|trDtdt|t|||_t||D] \}}||qt||D] \}}||q/| | dSt|t r|rt|j j j rgjdus\Jj|j j |dSt|j j }jrt|jj r|jdkrjdusJj|t|dSdSdSdSdSdS)Nz%maybe_propagate_real_tensors %s -> %sr1)rrrrHrrhrrrrr$r^rSymbolrset_unbacked_var_to_valrlhsrhsr)rrrreal_s)rgorMrrCrDrs0     zOFakeTensorMode._dispatch_impl..maybe_propagate_real_tensors..goT)peek)rrrrrGrH)rrrHrkrrrrrrrr-rrrr)r) rrrrZrnil real_args real_kwargsrrM)rrrDmaybe_propagate_real_tensorssB      zCFakeTensorMode._dispatch_impl..maybe_propagate_real_tensors) meta_tablercss|]}t| VqdSra)rrrCrCrDr| r}zprims::prim_meta_implmissing_fake_kernelcs dtiS)Nr)rTrCrrCrDrG srcsSrarCrC)ctxrCrDrT serrorOptional[RuntimeError]rcsHtjjr dSsst|durt}t|Sra)rkrWrXcan_generate_trivial_fake_implcan_run_unsafe_fallbackr\run_fallback_kernel)r) args_specrrZhas_symbolic_sizesrMrCrDmaybe_run_unsafe_fallbacka sz@FakeTensorMode._dispatch_impl..maybe_run_unsafe_fallbackz*failed while attempting to run meta for %sr))rrErGr)rrErGrEra)rrrGr)Yrr_check_for_subclassrrHr rrrVrkrrT_to_copyrrrrrrArrrr&cloner$rr prims device_put%validate_and_convert_non_fake_tensorsrOnondeterministic_seededrQrSr tree_map_onlyrinvalidate_written_to_constantsrrrrrr library_utilsrYMutationCheckerZeroDivisionErrorcheckcheck_aliasing_constraintrJrrget_fast_op_implsrrrcpp_meta_supports_symintrr decomposerr?rstride_incorrect_oprr r_custom_ops_profiledatageneric_fake_kernelhas_fake_kernel"inferred_fake_kernel_from_real_outrrWsimple_registry singletonfind fake_implkernel FakeImplCtxset_ctx_getterop_implementations_checkshas_metar;rlrr'+wrap_meta_outputs_with_default_device_logic)%rMrZrrrhas_unrecognized_typesrflat_arg_fake_tensors is_lift_func!device_conversion_skip_const_propconst_flat_args const_args const_kwargsrtavoiding_device_init all_constantflat_outflat_out_tensorsrreal_flat_argsrYmutation_checkerrr fast_implrrrbprofilesrmaybe_fake_implrun_impl_checkop_impl op_impl_outrfallbacknot_implemented_errorrC)rrrrrrrrZrrrrrrrrMrrDrBs     *         K      "  "         P       zFakeTensorMode._dispatch_impl debugprimsr rTxlavision torchtext torchaudio quantizedcCs"|jsdS|j|jvp|dkS)NFz fbgemm::gmm)r namespace+_can_run_unsafe_fallback_allowed_namespacesr?rMrZrCrCrDr s   z&FakeTensorMode.can_run_unsafe_fallbackrrrrr.%tuple[list[object], list[FakeTensor]]cs6gd fdd fddD}|fS) 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. rrErGUnion[T, FakeTensor]cst|ts|S|s[tjjjvr&t\}}t dt ||t j dur.j nt j }|sTt|trA|jurAt dt\}}t dt |||}n|}||S)NzECan't call metadata mutating ops on non-Fake Tensor inputs. Found in zMixing fake modes NYIzuPlease convert all Tensors to FakeTensors first or instantiate FakeTensorMode with 'allow_non_fake_inputs'. Found in )rrrrkrOrSrQrrAssertionErrorrfake_tensor_tlsr`rrrr$r)rrrrrt)rrr(rrZrMrCrDvalidate s2     zFFakeTensorMode.validate_and_convert_non_fake_tensors..validatecrrCrCr)rIrCrDr rzHFakeTensorMode.validate_and_convert_non_fake_tensors..N)rrErGrFrC)rMrZrrrvalidated_argsrC)rrr(rrZrMrIrDr  s  z4FakeTensorMode.validate_and_convert_non_fake_tensorsrbrr%r+cs2jdddfdd }t||S) NFrFrErGrFcsttsSdurt\}|r-tjkfddtt SdurBr9 S p@SS)NcsdjdS)Nz-FakeTensor is wrapped to wrong device, found z , expected r)rC)rrFrCrDr zZFakeTensorMode.wrap_meta_outputs_with_default_device_logic..wrap..) rrrrrrk_checkrrrEr$r')rFrrrrrrZrrMrFrDwrap s*       zHFakeTensorMode.wrap_meta_outputs_with_default_device_logic..wraprFrErGrF)rr,)rMrbrZrrrOrCrMrDr& s  !z:FakeTensorMode.wrap_meta_outputs_with_default_device_logicrrrrcCsddl}ddlm}|dur|j}|jsJd|jd7_|||d}|jjd}|j dus5J|j j |j j ||d||d}|S)Nr) NestedIntNodez1should only called while FakeTensorMode is activer1intermediate_offsets_or_lengths)valr)symrr) r!torch.nested._internal.nested_intrQrrrr rEphemeralSourcerr create_symbol)rMrrkrQrsrcretrCrCrDr s$ z)FakeTensorMode.create_symbolic_nested_intcCstjj|jvr dS||jvSre)rkrO view_copyrQ_cpp_meta_supports_symintrDrCrCrDr, s z'FakeTensorMode.cpp_meta_supports_symintrcCs0|tkot| o|| o|jjdk Sri)numelCONSTANT_NUMEL_LIMITrrrrrrCrCrDr3 s   zFakeTensorMode.may_turn_constr(Sequence[FakeTensor]c Cstdd|D}t|}|rI|rKt|||dd\}}|D]+\} } | dks.|| r0| nd} || rH|| rH| jdurH|j | jq!dSdSdS)NcsrrarrrCrCrDr|B r}zAFakeTensorMode.invalidate_written_to_constants..T)rrnormalize_to_only_use_kwargsinputrM) rr is_mutabler rc has_argumentrrrr) rMrZr(rr any_constant schema_infor new_kwargskrrCrCrDr; s"   z.FakeTensorMode.invalidate_written_to_constants)rrrrrrrrrrcCsD|j}|dur |j}|r|dusJdd}|jj||||||dS)Nz2cannot set both static_shapes and symbolic_context)rrrr)rrrr$)rMrrrrrrrCrCrDrQ s   zFakeTensorMode.from_tensor) rrrrrrrr_rrrGrHrQ)rrrGr)rGr)rGrTr)rGr )r-r.r/r0r1r2rGrH)rGr) rr2rZr;rrrrrGr)rZr;rrrrrGrH)rrrr]rr2rGrH)rr2ryrrZr;rrrrrDrrGrH)rr2ryrrZr;rrrrrDrrGr)rr2ryrrZr;rrrrrDrrGr) rr2rErryrrZr;rrrGr) rr2rErryrrZr;rrrGr) rDrrZr;rrrrrrrGrH) rZr;rr)rrrrrGr) rZr;rrrrrrrrrGr) rZr;rrrrrrrGrrZr;rGr) rZr;rrrrrr.rGrE) rbrrZr;rrrr%rGr+)rrrGrr) rZr;r(r^rrrrrGrH) rrrr_rrrrrrrGr)Ir@rArBrrWrrrrrr`r4rrrNrrr(r r$r/rrr*r3rr7r8r:rGr<rArrbrurCrr?r@r%rrrBrhrCrr r&rrTr/rrras_strided_scatter as_strided as_strided_r0detach view_as_realview_as_complexrsource_Storage_storage_offset(_sparse_coo_tensor_with_dims_and_tensorsr[r lift_freshlift_fresh_copyrVrrrrrCrCrrDrVs        _       + " * . < 3 B ) ! a L@ 11   rrrorig_not_implemented_exceptionrc stjj|jvr it(d fdd fdd|D}t||\}}||i|}Wdn1s9wYt|D]}t|t rVt |sV | j qCd fd d } t| |S)NrFrErGUnion[T, Tensor]csB|rtj||jd}|jr|||t|<|S|S)Nr))rrk zeros_likerfr _coalesced_rr)rFrt)r inp_implsrCrDto_real_tensor s  z+run_fallback_kernel..to_real_tensorcrrCrCr)rwrCrDr rz'run_fallback_kernel..rFcsdt|vrt|trt|s|jvrt|tr0t|vr)t|Sj|S|Sra)rrrrr_cdatarr$rN)rrvrrstoragesrCrDmap_out s    z$run_fallback_kernel..map_out)rFrErGrsrP)rkrOrSrQr&rrrrrraddrrxr,) rrZrrrrrrrbrFrzrC)rrvrrryrwrDrp s"    rc@s&eZdZdddZ  ddddZdS) FakeCopyModerrrGrHcCrNra)r)rMrrCrCrDrN rbzFakeCopyMode.__init__rCNrZr;rrrrrOptional[Mapping[str, object]]rcCs |r|ni}|tjjjkr&t|dtsJ||jj|dddfi|S|tjkrgt |dkr7t |dks9Jt t|d}t t t t f|d}t||vrW|t|S|jj|dd}||t|<|Stj||i|WdS1s~wYdS)NrT)rr1)rkrl TensorBaserrrrr __deepcopy__rrrfrrrDisableTorchFunctionSubclass)rMrZrrrrmemortrCrCrD__torch_function__ s(       $zFakeCopyMode.__torch_function__)rrrGrH)rCN) rZr;rrrrrr}rGr)r@rArBrNrrCrCrCrDr| s  r|rcCs>t|dkr t|dtsJ|djjrtdS|djS)Nr1rr&)rrrrr4rkrrfrrCrCrD_device_handler s   rcCstdd|DS)Ncsrra)rrrCrCrDr| rz&_check_for_subclass..)r)rrCrCrDr srcCs2t|t ot|tot|tuot|tjjuSra)rrrrrkr r rrCrCrDr s  rcC tddtt|dDS)NcsrrarrrCrCrDr|  ..r)rrrrrrCrCrDr rcCr)NcsrrarrrCrCrDr| rrr)rrrrrrCrCrDr rcCsttt|dS)Nr)rrrrrrCrCrDr s)_device_not_kwarg_ops_is_tensor_constructor_like_tensor_constructorscontains_tensor_typesrr%r$rcCstdtdtjtdtjtj}|rBtdtdd|D}t|ddd D]\}}td |d |d |q0dSdS) NzFakeTensor cache stats:z cache_hits: %sz cache_misses: %sz cache_bypasses:csrra)r)rxrfrCrCrDr|! rz#dump_cache_stats..cSs |d SrIrC)rerCrCrDr" s z"dump_cache_stats..r{z %-*s %sr1ru) rinforrrrmaxsortedrc)rwidthrfrrCrCrDdump_cache_stats s  rrrtorch._ops.OpOverloadr torch.Tensorc sdfdd }|dkr|d|fd d t|D}d g|}d d t|D}|jd ddd}|}|D]'\} } | |krY|d|jd|d||| <||j| }||| }qCtj|||j |j |j dWdS1swYdS)NrUrTrGrHcstdjd|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.)rrJ)rU)rrCrD unsupported) sz1_infer_fake_from_real_tensor..unsupportedrz'a return has a non-zero storage offset csg|] }tjjjqSrC)rkrWr  allocate_sizer)rxr)rrCrDr> sz0_infer_fake_from_real_tensor..r<cSsg|]\}}||fqSrCrC)rxrorrCrCrDrK cSs|d|d fS)Nrr1rCrrCrCrDrL rKz._infer_fake_from_real_tensor..r{r1z(a return was not dense in memory (sizes z strides ))rrr)rUrTrGrH) rrlrrmrsortrrkrrrr) rrrr fake_shape fake_stridesrexpected fake_striderrorCrrrDr& s<     $rrcs^jdusJt|\}}tdd|Dstdjfdd|D}t||S)Ncss|] }t|tjVqdSra)rrkrrrCrCrDr|k rz5inferred_fake_kernel_from_real_out..zPpropagate_real_tensors: we don't support operators that return non-Tensors. Got csg|]}t|qSrCrrrrCrDrq rz6inferred_fake_kernel_from_real_out..)rrrrrrr)rrr real_flat_outspec fake_flat_outrCrrDrb s r)rcrErGrd)rGrj)rsrrtrurGru)rrrGr)rrrGr)rZr;rGrrg)rrrr+rGr)rrrGr)rr%rGrH)rrrGr2)rrrGr) rrrZr;rrrr+rrrrGr)rrrGr%)rrrGr)rrrGrrQ)rrrrrrrGr)rrrrrrrGr) __future__ratexitrr functoolsrrrF threadingrtypingr collectionsrrrrrrr r r r typing_extensionsr rrrktorch._library.utilsrWrXrrrrrtorch._C._functorchrr"torch._library.fake_class_registryrtorch._loggingrtorch._prims_commonrtorch._subclasses.meta_utilsrrrrr torch._utilsrtorch.fx.immutable_collectionsrtorch.fx.operator_schemasr torch.multiprocessing.reductionsr!torch.overridesr" torch.typesr#r$torch.utils._backport_slotsr%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_utilsr2r3r4collections.abcr5r6r7r8rr9 torch._guardsr: torch._opsr;rr<r= getLoggerr@r_logginggetArtifactLoggerr ValueErrorrFrTr?r;rDimList_pytreerrE_opsrrTr]rKrFrrSrYr[r\r]localr^rHrhcontextmanagerrrrrr lru_cacherrrrrr1r;rArBrIrrrrrrrrrrrr_StoragePointerrr|rrrrrrrrrrrrrrtorch._subclasses.fake_implsrrrrrr%r$rregisterrrrrCrCrCrDs2   (                             b   A? +& " B #      (  <