o Zhj @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__rCrCL/var/www/auris/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)rsrttodoZ 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) rrattrsrZflattened_tensorsZall_fakeZany_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)rxZt_namerrCrDrsz'maybe_get_fake_mode..c3s|]}|uVqdSrarCr)mrCrDr|rz&maybe_get_fake_mode..)rrrr fake_moder'rrrrrrkrrlrrrrr)rrZinner_tensor_namesrmodesrrrC)rrrDrs*       rrZr;torch._C._SchemaInfocCstj|jSra)rkrlZ _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)rrZ flat_valsrCrrDtree_flatten_onlys rcCs@t|tuo|jtjko|jp|jpt|pt|pt | Sra) rrlayoutrkstrided is_sparseZ 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!rrZ _fix_weakrefr)rMrrZweak_tensor_reftenrCrCrDinvalidate_constant_aliases0s   z/FakeTensorConverter.invalidate_constant_aliasesrOptional[FakeTensor]cCs(|jjj|}|durdS|j|Sra)r describerZ lookup_tensorgetr)rMrtidrCrCrD _get_memo?s zFakeTensorConverter._get_memovcCs|jj|}||jj|<dSra)rrZ 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)rZ dynamic_dimr)hintr)rrrrrGr),rkZ_guardsZTracingContextZtry_getZtensor_to_context%torch.fx.experimental.symbolic_shapesrrZ tensor_sourcer is_quantizedrSrnn ParameterrNotImplementedZtorch._dynamo.sourcerrrdimrdtypeZint64Zint32Zint16Zint8Zfloat64rrrr&itemmathisnanisinfbaseZcreate_unspecified_symbolZDYNAMICcreate_symintnode item_memoZcreate_symfloatnoder)rMrrrrrrrZtracing_contextr maybe_memorrtrvaluerrrZ 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)rMrrrrrtrCrCrDfrom_meta_and_devices   z(FakeTensorConverter.from_meta_and_device)rGr)rrrrrGrH)rrrGrH)rrrGrH)rrrGr)rrrrrGrH)FN)rrrrrrrrrrrrrrrGr)rrrrrrrGr) r@rArBpropertyrrWrNrrrrrr rCrCrCrDrs(      rrrrHcCsDtjs tjr tjjdurtjd|dntjd|ddSdS)Nr1r)rkcuda is_availablexpuversionZhipemptyzerosr rCrCrDinit_gpu_contexts  rrrGenerator[None, None, None]c cs|j}tj}||ksJ|d|tj<d|_tjtjdzdVW||_n||_wWdn1sBwYWddSWddS1sZwYdS)N, T)in_kernel_invocationrkrlZ_meta_in_tls_dispatch_includeZ_DisableTorchDispatchZ_PreserveDispatchKeyGuardZ!_set_meta_in_tls_dispatch_include)rZprev_in_kernelZ meta_in_tlsrCrCrDin_kernel_invocation_managers    "rcCs$tj|ddddS)Nz::.r)rkrlZ _should_allow_numbers_as_tensorsnamesplitrrCrCrDshould_allow_numbers_as_tensorssrc@seZdZejdddkZdS)FakeTensorConfigZTORCH_FAKE_TENSOR_DEBUG01N)r@rArBosenvironrdebugrCrCrCrDrsrc@sneZdZUded<ded<ddd!d d Zd"ddZd#ddZd#ddZd#ddZ d$d%ddZ d&dd Z dS)'SymNumberMemoDescriptorrT_namer_is_nested_intF is_nested_intr&rGrHcC ||_dSra)r$)rMr&rCrCrDrN0rbz SymNumberMemoDescriptor.__init__ownerrcCs ||_dSrar#)rMr(rrCrCrD __set_name__3rbz$SymNumberMemoDescriptor.__set_name__objrcCs d|jS)Nrr)rMr+rCrCrD_memo6rizSymNumberMemoDescriptor._memocCd|jdS)NrZ_vcr)r,rCrCrD_memo_vc9z SymNumberMemoDescriptor._memo_vccCr.)Nr_epochr)r,rCrCrD _memo_epoch@r0z#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)rwr-rrkrnoderr$r/_versionr2repochsetattr)rMr+r3rrCrCrD__get__CszSymNumberMemoDescriptor.__get__rcCs|dur!t|||dt|||dt|||ddS|r(|jrKt|||||js>t||||jt||||jjdSdSra) r9r-r/r2 is_inferencer$r7rr8)rMr+rrCrCrD__set__YszSymNumberMemoDescriptor.__set__)r&rrGrH)r(rTrrTrGrH)r+rrGrTra)r+rr3r4rGr5)r+rrr5rGrH) r@rArBrWrNr*r-r/r2r;r=rCrCrCrDr"&s      r"cseZdZUdZded<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_tensorTr%rGcCs|jjr tdS|jSNr)rrrkrr>rLrCrCrDrs zFakeTensor.devicerrHcCtraNotImplementedErrorrMrrCrCrDr list[str]cCstd)Nz+torch.compile doesn't support named tensors)rSrLrCrCrDnamesszFakeTensor.namescCrBrarCrErCrCrDrHrFNrrrr 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)Zdispatch_deviceZdevice_for_backend_keysr)r rr hpurZmps:z:0)!rZ_make_subclass requires_grad_allow_unsafe_data_ptr_accessrkrlZ_set_throw_on_mutable_data_ptrZ(_set_warn_deprecated_on_mutable_data_ptrrrr allow_metarZ_get_privateuse1_backend_nameindexrwZis_initializedZcurrent_devicer>rrrr@ nonzero_memor unique_memounique_consecutive_memonested_int_memorr!r0extractZ _debug_trace)clsrrrrr@rMrCrCrD__new__sL     zFakeTensor.__new__argsrkwargscstdSra)superrN)rMrVrW __class__rCrDrNr0zFakeTensor.__init__rcCs ||Sra) from_tensor)rrrCrCrDr[s 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)Nr1rrcSs"g|] }t|ts|tur|qSrC) issubclassrrrxrrCrCrDr%s z1FakeTensor.__torch_dispatch__..z(FakeTensor unrecognized subclass(es): %sz(FakeTensor mode already active: %s in %s)rkopsprimrdefaultlenrrrrr>_DISPATCH_META_HANDLERSrnot_implemented_logr!rrZarg_tree_leavesrl_get_dispatch_modernro) rTrZr\rVrWhandlerunrecognized_typesrargZmaybe_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 r)rrr RuntimeError)rZt_is_cpu_zero_dim common_devicerorZZis_cpu_zero_dimrCrD merge_devices]s(  z5FakeTensor._find_common_device..merge_devicesTrz!Could not find common device for rrrGr)rrrGrH)rrkr)rZrmhas_scalar_only_inputsrsrkrCrqrD_find_common_deviceMs  "  zFakeTensor._find_common_devicer1)coeffrwUnion[int, torch.SymInt] torch.SymIntcCs6|jdur |jjdd|_t|jtjsJ|j|S)N nt_tensor_id)rRrcreate_symbolic_nested_intrrkr)rMrwrCrCrDget_nested_ints  zFakeTensor.get_nested_intrcCs<|dkr |S|dkrdd|DSdd|DS)Nrr1cSg|]}|qSrC)rrrCrCrDrz%FakeTensor.tolist..cSr~rC)tolistrrCrCrDrr)rrrLrCrCrDrs  zFakeTensor.tolist)rGr)rrrGrH)rGrG)rrGrGrH)NN) rrrrrrrr?r@r?rGr )rVrrWrrGrH)rrrrrGr rZr;r\r]rVr^rWr_rGr)rZr;rmr^rGrn)rwrxrGry)rGr) r@rArB__doc__rWr"rOrrPrQrRrkrlrnro _mode_keyr rsetterrH staticmethodrUrNr[ classmethodr/rrlrvr}r __classcell__rCrCrYrDrgsJ       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, ...]shapestriderrz torch.layoutrzOptional[torch.memory_format] memory_format_MetadataIntLikestorage_offsetzOptional[_MetadataIntLike] storage_bytesrrKris_conjis_negr<rr_ is_coalesced Optional[int] dense_dim sparse_dimresult list[object]moderstater2rGrHcCsdt|D]*}t||j}t|tttjfr| |||qt|t r*| ||q| |qdSra) dataclassesfieldsrwrrtuplelistrkSize_prep_args_for_hashrconvert_sym_intr)rMrrrfieldrrCrCrD _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_stridesrZ is_contiguousrrrrrrkrrruntyped_storagenbytesrKrrrr<rrrr)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_bypassesr8Frr static_shapesrrz Optional[str]_stackrMrnt_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),logr!idrXrNrZtorch._dynamo.configZtorch._functorch.configrconfigZ"fake_tensor_propagate_real_tensorspropagate_real_tensorsrfake_tensor_converterrZallow_scalar_outputsZ(fake_tensor_allow_unsafe_data_ptr_accessrLZfake_tensor_allow_metarM_dynamoZfake_tensor_cache_enabled cache_enabledZ$fake_tensor_cache_crosscheck_enabledcache_crosscheck_enabledrr enter_stackr traceback extract_stack _stack_tracerrlrnror$torch.nested._internal.nested_tensornested _internalZ nested_tensorZ_tensor_id_counterrr)rMrrrrrrkrYrCrDrNnsF          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)NrI)rkrZ _is_compiledr r hasattrrIrLrCrCrDavoid_device_inits   z FakeTensorMode.avoid_device_initrTcCs$|jdurdt|j|_|jS)N)rjoinr format_listrrLrCrCrDstacks zFakeTensorMode.stackrCrZr;r\r]rVr^rWr_cCsLtjtjjjdusJ|z |||||WSty%tdw)Nzfake tensor raised TypeError) rkrlrhrnrodispatch TypeErrorr exception)rMrZr\rVrWrCrCrDrls   z!FakeTensorMode.__torch_dispatch__r cs|ddl}d}|jr|j}|jd|j|j}||ur-|jd||ft S|j ||jdd|f|S)NrTF) rrrlZ_only_lift_cpu_tensors_set_only_lift_cpu_tensorsrmrrrrX __enter__rp)rMrkZprev_only_lift_cpu_tensorsmaybe_prev_fake_moderYrCrDrs    zFakeTensorMode.__enter__aOptional[type[BaseException]]bOptional[BaseException]cOptional[TracebackType]csX|j\}}}|r(t||||durtj||dur*tj|dSdSdSra)rr~rX__exit__rkrlrpr)rMrrrliverZ maybe_prev_only_lift_cpu_tensorsrYrCrDrs  zFakeTensorMode.__exit__cCsdSrerCrTrCrCrD is_infra_mode0rFzFakeTensorMode.is_infra_modercCsttjtjttjttjS)z8 Query the state of the dispatch cache. )rrrrrfrrerrrCrCrD cache_info4s zFakeTensorMode.cache_infocCs$d|_d|_|j|jdS)z+ Clear the dispatch cache. rN)rrrclearrrrCrCrD 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_keyZcache_on_shape_envZfake_tensor_cacherrr_output_from_cache_entryrr_crosscheck_cache_output_validate_cache_key_dispatch_impl_make_cache_entryrrrrrU) rMrZr\rVrWoutputrryrentryerCrCrD_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) rkZget_default_dtyperlZ_get_default_deviceZis_inference_mode_enabledrsettingsrrr)rMrrZrVrW key_valuesrCrCrDrus  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 viewZliftzinductor::resize_storage_bytes_z non-builtinCompositeImplicitAutogradN)rkTagZdata_dependent_outputtagsrZdynamic_output_shape inplace_viewatenZ _unsafe_viewrdlift_fnsr_libraryutils is_builtinis_viewrlZ%_dispatch_has_kernel_for_dispatch_keyZ DispatchKeyr)rMrZrVrWrCrCrDrs&     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)rMrrVrrkrrCrCrDrs6       z"FakeTensorMode._prep_args_for_hashryrrcCslt|ts td|jdurtd|jrtdt|r!td|D]}t|t|kr3tdq%dS)Nznon-FakeTensor outputrz sparse outputzsparse compressed outputzkwarg aliases output)rrrrrrrr)rMrryrZrVrWrZkvalrCrCrD _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..c3rrarrrrCrDr|(r}Frrzdispatch_key_set mismatch)rangererrr  enumeraterrrrrrrrrrkrlZ_dispatch_key_setr)rMrryrZrVrWridxrZidxsrrZentry_for_synth_outputZ synth_outputZ synth_key_setZkey_setrCrrD _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. NrFrc s g|] }|qSrC)r)rxZout_elemrVrZryrWrMrrCrDrls  z4FakeTensorMode._make_cache_entry..T)rrrrrr) rMrryrZrVrWr output_infoZ out_elementrrCrrDrKs:     z FakeTensorMode._make_cache_entryrc 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)Nrrrr2rGUnion[IntLikeType]cs8t|tr|jdus J||jSt|trJ|Sra)rr4rrSr3)rrryrCrD check_values zGFakeTensorMode._get_output_tensor_from_cache_entry..check_valuec3|]}|VqdSrarCrr#rrCrDr|r}zEFakeTensorMode._get_output_tensor_from_cache_entry..c3r$rarCrr%rCrDr|r}r)rrrrKT)rrrr2rGr!) rrrrrrrrrr contextlib nullcontextrZsuppress_guardsrrk empty_stridedrrrKrrlZ _set_conjrZ_set_negr rrrrset_r)rMrrryrZrVZ inplace_argrrrrZmaybe_suppressrZview_argZstoragerC)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*)rxr rVrZryrMrrCrDrsz;FakeTensorMode._output_from_cache_entry..r)rrrr*)rMrrryrZrVZoutputsrCr,rDrs  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) r Exceptionrprrreziprr) rMrrZr\rVrWZ true_outputrrrrCrCrDrsN   z'FakeTensorMode._crosscheck_cache_outputcCs|pi}ttd|||Wdn1swY|tvr)t||Sttjkrtd|d|ddSdSt|tttfrW||krYtd|d|ddSdS)NT)Z compute_hintzmismatch between fake value z and real value r/)rrrrr6exprZ free_symbols var_to_valrunbacked_var_to_valZ_maybe_evaluate_staticEqStruer]rfloatr)r6r7)rMsympyrCrD_check_fake_real_vals/s6   z?FakeTensorMode._maybe_infer_fake.._check_fake_real_valsReal tensor propagation foundFT)contextsizesstridesrrKmismatched_fake_kernelctjdSNoprUrTrUrCexcrZrCrDYz2FakeTensorMode._maybe_infer_fake..Z metadata_fnzFReal tensor propagation found a metadata mismatch between fake tensor z and real tensor z , at outputz , for func: crHrIrLrCrMrCrDrOnrPzIReal 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 )r6rr7rrGrH)rAtorch._subclasses.fake_utilsr9rrkrr]rr*generate_fake_kernels_from_real_mismatchesr_infer_fake_from_real_tensorr*rr.r) rMrZr5r6r7r9rBjZs_fakeZs_realrC)rNrZrMrArD_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_unbackedrCrGcstdjdS)Nz>Mismatched aliasing spec between fake kernel and real kernel: rJrLrCrMrCrDrOs zIFakeTensorMode._maybe_infer_fake_kernel_from_pytree_out..rQcs t|SrarTrrZrMrCrDrOs zGReal tensor propagation found an aliasing mismatch between fake output z and real output z , for func: cs$g|]\\}}}|||qSrC)rV)rxZ _fake_pathZ _fake_outZ _real_outrcrCrDrs zKFakeTensorMode._maybe_infer_fake_kernel_from_pytree_out..rQ)rRr\rrr^rZtree_flatten_with_path tree_flattenr]rkrrrSrr,r.rtree_unflatten)rMrZrWrXrYrZr\raZfake_paths_leavesZ fake_specZ real_leavesrZ fake_leavesZ overridesrC)rNrZr`rMrD(_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)rrarLrCrDrrcss|]}|jVqdSra)r)rxrrCrCrDr|s z0FakeTensorMode._dispatch_impl..css|]}t|tVqdSra)rrrxrrCrCrDr|r}rrcs|]}|jduVqdSrarrarCrCrDr|s  z. should not have fake inputs without constantsc g|] }|r |jn|qSrCrrrhrLrCrDr Trr1r/FrrcsrirarrxrrCrCrDr|Cr}crjrCrkrhrLrCrDrLrlcSsg|] }t|tr|qSrCrrarCrCrDrWrc3rra)may_turn_constrarLrCrDr|Xr}csj|ddS)NTrm)rr) converterrMrCrDrO]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) rrr@r$rr6Zpytyper:Zxreplacer;r<rZreal_objrrLrCrDmaybe_to_real_tensorks   z;FakeTensorMode._dispatch_impl..maybe_to_real_tensor)compute_unbacked_bindingsfree_unbacked_symbolscsrira)r@rnrCrCrDr|r}c3sF|]}t|to|ojduotfddDVqdS)Nc3s|] }|jjvVqdSra)rr<rxsrLrCrDr|z:FakeTensorMode._dispatch_impl...)rrrrrh)rtrMsymsrCrDr|s  zpropagate_real_tensors %scg|]}|qSrCrCrh)rrrCrDrrz9real-tensor fallback failed for %s: %s; silently ignoringz,SKIPPED propagate_real_tensors %s(%s, %s) %srYcsddltdd  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)rrrr!rr@r.rrrr$r6r:SymbolrZset_unbacked_var_to_valr=lhsrhsr)rrzrvZreal_s)rtgorMrArCrDr~s0     zOFakeTensorMode._dispatch_impl..maybe_propagate_real_tensors..goT)peek)rrrzrrGrH)rArr!rkrrrSrfrrrr-rrrdr)rY) rVrsrtrZrWnil real_args real_kwargsrZrM)r~rArDmaybe_propagate_real_tensorssB      zCFakeTensorMode._dispatch_impl..maybe_propagate_real_tensors) meta_tablercss|]}t| VqdSra)rrnrCrCrDr| r}zprims::prim_meta_implZmissing_fake_kernelcs dtiS)NrK)rTrCrrCrDrOG srQcsSrarCrC)ctxrCrDrOT serrorOptional[RuntimeError]rcsHtjjr dSsst|durt}t|Sra)rkr r Zcan_generate_trivial_fake_implcan_run_unsafe_fallbackr\run_fallback_kernel)r) args_specrmrZhas_symbolic_sizesrMrCrDmaybe_run_unsafe_fallbacka sz@FakeTensorMode._dispatch_impl..maybe_run_unsafe_fallbackz*failed while attempting to run meta for %sr )rrErGrq)rYrErGrEra)rrrGr)Yrrd_check_for_subclassrgr!rrrrrkrbrZ_to_copyrdrrrrrrreror&clonerrerprimsZ device_put%validate_and_convert_non_fake_tensorsrZnondeterministic_seededrrrZ tree_map_onlyrinvalidate_written_to_constantsrrsrtrrr library_utilsr ZMutationCheckerZeroDivisionErrorcheckZcheck_aliasing_constraintr#rr<get_fast_op_implsrrrcpp_meta_supports_symintrrZ decomposerrrstride_incorrect_oprrrZ_custom_ops_profiledataZgeneric_fake_kernelZhas_fake_kernel"inferred_fake_kernel_from_real_outrr Zsimple_registryZ singletonfind fake_implZkernelZ FakeImplCtxZset_ctx_getterop_implementations_checkshas_metarrDr-r+wrap_meta_outputs_with_default_device_logic)%rMrZr\rVrWZhas_unrecognized_typesrjflat_arg_fake_tensorsZ is_lift_funcZ!device_conversion_skip_const_propZconst_flat_argsZ const_argsZ const_kwargsrtZavoiding_device_initZ all_constantZflat_outZflat_out_tensorsrZreal_flat_argsr Zmutation_checkerrNrZ fast_implrrr:ZprofilesrZmaybe_fake_implZrun_impl_checkZop_implZ op_impl_outrfallbackZnot_implemented_errorrC)rVrrsrprrmrtrZrrWrrrrrrZrMrxrDrs     *         K      "  "         P       zFakeTensorMode._dispatch_implZ debugprimsrrZxlaZvisionZ torchtextZ torchaudioZ quantizedcCs"|jsdS|j|jvp|dkS)NFz fbgemm::gmm)r namespace+_can_run_unsafe_fallback_allowed_namespacesrrMrZrCrCrDr s   z&FakeTensorMode.can_run_unsafe_fallbackrprrmrr.%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 )rrrrkrrrrreAssertionErrorrfake_tensor_tlsr`rrrrr)rrVrWrrt)rrprrmrZrMrCrDvalidate s2     zFFakeTensorMode.validate_and_convert_non_fake_tensors..validatecryrCrCrh)rrCrDr rzHFakeTensorMode.validate_and_convert_non_fake_tensors..N)rrErGrrC)rMrZrprmrZvalidated_argsrC)rrprrmrZrMrrDr s  z4FakeTensorMode.validate_and_convert_non_fake_tensorsr:rrr+cs2jdddfdd }t||S) NFrrErGrcsttsSdurt\}|r-tjkfddtt SdurBr9 S p@SS)NcsdjdS)Nz-FakeTensor is wrapped to wrong device, found z , expected r rC)rrrrCrDrO zZFakeTensorMode.wrap_meta_outputs_with_default_device_logic..wrap..) rrrrvrrk_checkrrrErr )rrrrrprrmrZrurMrrDwrap s*       zHFakeTensorMode.wrap_meta_outputs_with_default_device_logic..wraprrErGr)rr,)rMr:rZrmrrrCrrDr s  !z:FakeTensorMode.wrap_meta_outputs_with_default_device_logicrzr{rrycCsddl}ddlm}|dur|j}|jsJd|jd7_|||d}|jjd}|j dus5J|j j |j j ||d||d}|S)Nr) NestedIntNodez1should only called while FakeTensorMode is activer1Zintermediate_offsets_or_lengths)valr)symrr) rZ!torch.nested._internal.nested_intrrrrrrZEphemeralSourcerrZ create_symbol)rMr{rkrrsrcretrCrCrDr| s$ z)FakeTensorMode.create_symbolic_nested_intcCstjj|jvr dS||jvSre)rkrZ view_copyr_cpp_meta_supports_symintrrCrCrDr, s z'FakeTensorMode.cpp_meta_supports_symintrcCs0|tkot| o|| o|jjdk SrA)ZnumelCONSTANT_NUMEL_LIMITrrrrrrCrCrDro3 s   zFakeTensorMode.may_turn_constrSequence[FakeTensor]c Cstdd|D}t|}|rI|rKt|||dd\}}|D]+\} } | dks.|| r0| nd} || rH|| rH| jdurH|j | jq!dSdSdS)NcsrirarrnrCrCrDr|B r}zAFakeTensorMode.invalidate_written_to_constants..T)rVrWZnormalize_to_only_use_kwargsinputrM) rrZ is_mutabler rcZ has_argumentrrrr) rMrZrrVrWZ any_constantZ schema_inforZ 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)rMrrrrrrrCrCrDr[Q s   zFakeTensorMode.from_tensor) rrrrrrrr_rrrGrHrQ)rrrGr)rGr)rGrTr)rGr )rrrrrrrGrH)rGr) rr2rZr;rVr^rWr_rGr)rZr;rVr^rWr_rGrH)rrrVr rr2rGrH)rr2ryrrZr;rVr^rWr_rrrGrH)rr2ryrrZr;rVr^rWr_rrrGr)rr2ryrrZr;rVr^rWr_rrrGr) rr2rrryrrZr;rVr^rGr) rr2rrryrrZr;rVr^rGr+) rr+rZr;r\r]rVr^rWr_rGrH) rZr;r5r)r6rr7rrGr8) rZr;rWrrXrrYrrZrrGr[) rZr;r\r]rVr^rWr_rGrrZr;rGr) rZr;rprrmr^rr.rGr) r:rrZr;rmr^rrrGr+)r{rrGryrt) rZr;rrrVr^rWr_rGrH) rrrr_rrrrrrrGr)Ir@rArBrrWrrrrrr8rrrrNrrr rrr/rrlrrrrrrrrrrrrrr*rrrrVrfrrhrrrrr|rrrr(rdZas_strided_scatterZ as_stridedZ as_strided_rdetachZ view_as_realZview_as_complexr)Zsource_Storage_storage_offsetZ(_sparse_coo_tensor_with_dims_and_tensorsrrZ lift_freshZlift_fresh_copyrrorr[rrCrCrYrDrVs        _       + " * . < 3 B ) ! a L@ 11   rmr^rorig_not_implemented_exceptionrpc stjj|jvr it(d fdd fdd|D}t||\}}||i|}Wdn1s9wYt|D]}t|t rVt |sV | j qCd fd d } t| |S)NrrErGUnion[T, Tensor]csB|rtj||jd}|jr|||t|<|S|S)Nr )rrkZ zeros_liker>rZ _coalesced_rr)rrt)r inp_implsrCrDto_real_tensor s  z+run_fallback_kernel..to_real_tensorcryrCrCrh)rrCrDr rz'run_fallback_kernel..rcsdt|vrt|trt|s|jvrt|tr0t|vr)t|Sj|S|Sra)rrrrr_cdatarrr)rrrstoragesrCrDmap_out s    z$run_fallback_kernel..map_out)rrErGrr)rkrrrr&rrer]rrraddrrr,) rrZrmrrrVrWr:rrrC)rrrrrrDrp s"    rc@s&eZdZdddZ  ddddZdS) FakeCopyModerrrGrHcCr'ra)r)rMrrCrCrDrN rbzFakeCopyMode.__init__rCNrZr;r\r]rVr^rWOptional[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)rkrlZ TensorBaserrrrr[ __deepcopy__rerrfrrrZDisableTorchFunctionSubclass)rMrZr\rVrWrmemortrCrCrD__torch_function__ s(       $zFakeCopyMode.__torch_function__)rrrGrH)rCN) rZr;r\r]rVr^rWrrGr)r@rArBrNrrCrCrCrDr s  rrVcCs>t|dkr t|dtsJ|djjrtdS|djS)Nr1rr)rerrrrrkrr>rVrCrCrD_device_handler s   rcCstdd|DS)Ncsrra)rgrrCrCrDr| rz&_check_for_subclass..)r)rmrCrCrDr srcCs2t|t ot|tot|tuot|tjjuSra)rrrrrkrrrrCrCrDrg s  rgcC tddtt|dDS)NcsrrarrurCrCrDr|  ..r)rrrrrrCrCrDrO rOcCr)NcsrrarrurCrCrDr| rrr)rrrrrrCrCrDrO rcCsttt|dS)Nr)rrrrrrCrCrDrO s)_device_not_kwarg_ops_is_tensor_constructor_like_tensor_constructorscontains_tensor_typesrrrrcCstdtdtjtdtjtj}|rBtdtdd|D}t|ddd D]\}}td |d |d |q0dSdS) NzFakeTensor cache stats:z cache_hits: %sz cache_misses: %sz cache_bypasses:csrra)re)rxrrCrCrDr|! rz#dump_cache_stats..cSs |d SrIrC)rrCrCrDrO" s z"dump_cache_stats..r"z %-*s %sr1rJ) rinforrrrmaxsortedrc)rwidthrrrCrCrDdump_cache_stats s  rrrKtorch._ops.OpOverloadrZ 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.)rpr#)rU)rKrCrD unsupported) sz1_infer_fake_from_real_tensor..unsupportedrz'a return has a non-zero storage offset csg|] }tjjjqSrC)rkr rZ allocate_sizer)rxr)rrCrDr> sz0_infer_fake_from_real_tensor..rcSsg|]\}}||fqSrCrC)rxrrvrCrCrDrK cSs|d|d fS)Nrr1rCrrCrCrDrOL rz._infer_fake_from_real_tensor..r"r1z(a return was not dense in memory (sizes z strides ))rrr)rUrTrGrH) rrrrrsortrrkr(rrr) rrKrZrZ fake_shapeZ fake_stridesrFexpectedZ fake_stridervrrCrrKrDrT& s<     $rTrcs^jdusJt|\}}tdd|Dstdjfdd|D}t||S)Ncss|] }t|tjVqdSra)rrkrrarCrCrDr|k rwz5inferred_fake_kernel_from_real_out..zPpropagate_real_tensors: we don't support operators that return non-Tensors. Got csg|]}t|qSrCrbrarrCrDrq rz6inferred_fake_kernel_from_real_out..)rrrdrrprre)rrKrZZ real_flat_outspecZ fake_flat_outrCrrDrb s r)rcrErGrd)rGrj)rsrrtrurGru)rrrGr)rrrGr)rZr;rGrr)rrrr+rGr)rrrGr)rrrGrH)rrrGr)rrrGr) rrrZr;rmr^rr+rrprGr)rVr^rGr)rmr^rGr)rrrGrrQ)rrrKrrZrrGr)rrrKrrZrrGr) __future__ratexitr&r functoolsr1rr threadingrtypingr collectionsrrrrrrr r r r Ztyping_extensionsr rrrkZtorch._library.utilsr r rrrrrZtorch._C._functorchrrZ"torch._library.fake_class_registryrZtorch._loggingrZtorch._prims_commonrZtorch._subclasses.meta_utilsrrrrrZ torch._utilsrZtorch.fx.immutable_collectionsrZtorch.fx.operator_schemasr Z torch.multiprocessing.reductionsr!Ztorch.overridesr"Z torch.typesr#r$Ztorch.utils._backport_slotsr%Ztorch.utils._mode_utilsr&Ztorch.utils._python_dispatchr'r(Ztorch.utils._pytreer)r*r+r,r-r.Ztorch.utils._statsr/Ztorch.utils._tracebackr0Z_fake_tensor_utilsr2r3r4collections.abcr5r6r7r8r\r9Z torch._guardsr:Z torch._opsr;rr<r= getLoggerr@rZ_loggingZgetArtifactLoggerrg ValueErrorrrTr?rrZDimListZ_pytreerrEZ_opsrbrrrKrFrprSrYr[r\r]localr^rrhcontextmanagerrrrrr lru_cacherrrrrrrrrr"rrrrrrrr-rrrrZ_StoragePointerrrrrrgrcrrdrrrrfrrrr3Ztorch._subclasses.fake_implsrrrrrrrrregisterrrTrrCrCrCrDs2   (                             b   A? +& " B #      (  <