U zha@s~ UddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlmZddlmZmZddlmZddlmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.ddl/m0Z0z ddl1Z2Wne3k rxdZ2YnXzddl4Z5ddl6m7Z8ddl9m:Z:dd l4m;Z;d d le2j?e2j@fZAe+ejBd feCd <e2e8e2j>e8j>e2j?e8j?e2j@e8j@iZDn eEZAiZDddlFmGZGmHZHmIZIWneJk r6YnXddlKZKddl5Z5ddlLZ5ddlMZ5ddlNmOmPZQddl5mRZRddlSmTZTddl9mUZUddlVmWZWddlXmYZYddlZm[Z[m\Z\ddl]m^Z^ddl_m`Z`maZaebej"Zce#ede"edfeCd<iZee%edefeCd<dZfdZgdegdZhe iejZkiZle%ede(emfeCd<ebddZne%ede%edemffeCd <e oZpd!d"Zqdard#d$Zsd%d&Ztdaud'd(Zvd)d*Zwd+d,Zxd-d.Zydgd0d1Zzdhd4d5Z{ej|d6d7Z}e5j~e5je5jmfe5je5je5jfe5je5je5jfe5je5jfe5je5jfe5je5jfe5je5je5jfe5je5je5jfe5je5je5jfe5je5jfi ZGd8d9d9ZeZd:d;Zdd?Zd@dAZdBdCZdDdEZeRjdFdGdHZdIdJZdKdLZdMdNZGdOdPdPZdQdRZejdSkrejejejejejejfZdTdUZdVdWZdXdYZdZd[Zd\d]Zd^d_Zd`daZdbdcZdddeZdfdgZedhdidjZdidkdlZdmdnZejGdodpdpZejGdqdrdrZdsZejedtae$e-eefeCdu<e-eefdvdwdxZeddydzd{Zdd|d}d~Ze(e-eefd|ddZejGdddZGdddeZeǃe_ddZddddZddZe5jdddZeddZddZϐdjddZddZddZddZed ddZddZՐdkddZddZedddZeemeeedeedejeje5je5je5je5jh Zear&ddlZeejjddZddZddZddZddZddZddZeeZe,e'eeCd<eeZe,e.eeCd<eeZe,e.eeCd<eeeEZe,e&eeCd<ejZejZddZddZddZeZddZddZddÄZddńZddDŽZdlddɄZdd˄Zdd̈́Zedd|ddτZ edd|ddфZ dҐZ ddӐl m Z ddՄZddׄZddلZdd3dd3d/d3d3ekjfdd܄ZddބZejddZeZebeZe#ee(efeCd<eZe(deCd<eZGdddZedddZddZdmddZddZddZdnddZ e!Z"ddZ#eddZ$ddZ%ddZ&ddZ'edddZ(ddZ)ejBdddZ*edddZ+edddZ,Gd d d ej-Z.e.d d d Z/e-e5jefede+ee)e.fdddZ0ddZ1ddZ2ddgZ3ddgZ4ddddgZ5e3e4e5Z6ddZ7dod d!Z8dpd"d#Z9d$d%Z:d&d'Z;Gd(d)d)Z<d*d+Z=Gd,d-d-Z>Gd.d/d/Z?d0d1Z@d2d3ZAd4d5ZBd6d7ZCedeed8d9d:ZDejGd;d<d<ZEede)eEd=d>d?ZFejejGedd@dAdBZHdCdDZIdEdFZJdGdHZKdIdJZLdKedLdMdNZMdOdPZNdQdRZOejdSdTZPdUdVZQdWdXZRGdYdZdZe5jSjTZUe5jRjVd[d\d]ZWd^d_ZXd`daZYGdbdcdcZZe[Z\e*edeCdd<dqdedfZ]dS(rN)contextmanager) lru_cachewraps)MethodWrapperType)AnyCallablecastClassVarCounter DefaultDictDequeDictIteratorKeysViewListOptionalSetTupleTypeUnion ValuesView)RemovableHandle)detect_fake_mode LazyString)config.NP_SUPPORTED_MODULES) FakeTensoris_fakemaybe_get_fake_mode)fx)enable_python_dispatcher)TracingContext)is_sparse_compressed)log_compilation_event)_format_graph_codelazy_format_graph_code)LazyModuleMixin) has_tritonhas_triton_packagecountersoptimus_scuba_logzAhttps://pytorch.org/docs/main/torch.compiler_troubleshooting.htmlz;https://pytorch.org/docs/main/torch.compiler_nn_module.htmlzSee z& for more information and limitations.compilation_time_metricscCs ttSN) collections defaultdictfloatr3r3E/var/www/html/venv/lib/python3.8/site-packages/torch/_dynamo/utils.pywr5frame_phase_timingc CsPzddl}|j||dWStk rJdddt|g|DYSXdS)Nrheaders css|]}dtt|VqdS), N)joinmapstr).0rowr3r3r4 sztabulate..)tabulate ImportErrorr< itertoolschain)rowsr9rBr3r3r4rB}s  rBcCs tdadSNr) curr_framer3r3r3r4increment_framesrIcCsttdadSNr)r7clearr.rHr3r3r3r4reset_frame_countsrLcCs t|7adSr/)op_count)Zcntr3r3r4increment_op_countsrNcCsVd}i}tD]@}|D]2\}}||7}||kr>|||<q|||7<qq|S)Ng)r7valuesitems)total total_by_keyZtimingskeyZtimingr3r3r4calculate_time_spents  rTcCsBt}d}|D]"\}}|d|dt|d}qt|dS)NzTIMING: :)rTrProundprint)rRoutrSvaluer3r3r4print_time_reports r\cCst|||7<dSr/)r7)rS phase_name time_spentr3r3r4_add_time_spentsr_Tcsfdd}|r||S|S)Ncstfdd}|S)Nc sj}|tkrgt|<d}d}td}zzNtj|d$t} ||} t| }W5QRXt||Wn8tk r}ztt|}t|}W5d}~XYnXW5rtt}r|dkrt||ntjj dk rttjj j }d|ksd|kr,|dkr,t||nd|krttjj }|dkr\t||dkr|dkrt| dd} t| dd} nd} d} t|| | ||} t| X| S)Nz-infforwardZ inferenceZbackwardZinductor_compileZcode_genz (dynamo_timed)) __qualname__r.r2r>rHr_torch_guardsr$try_getgetaot_graph_nameZCompileContextZcurrent_compile_idr7BwdCompilationMetricsrecord_compilation_metricsZprofilerZrecord_functiontimeappend Exceptiontype)argskwargsrS fail_type fail_reasonr^ frame_keyrf compile_idZinductor_compile_timeZ code_gen_timemetricst0re)funcfwd_onlyr]r3r4 time_wrappers|           z>dynamo_timed..dynamo_timed_inner..time_wrapper)r)rwryrxr])rwr4dynamo_timed_innersFz(dynamo_timed..dynamo_timed_innerr3)Zoriginal_functionr]rxr{r3rzr4 dynamo_timedsJr|r>Fcs|ddffdd |dkrFfddtD}d}|t|d d 7}|S|d krxfd dtD}tt}||fSd S)a Get metrics about torchdynamo frontend/backend compilation times. Accumulates information from functions tagged with `@dynamo_timed`. repr='str' returns a printable string for user interaction, and 'csv' returns headers, rows which can be logged for output aggregate causes values from multiple compilations (e.g. split graphs) to be accumulated into one value. If false, expect more than one value per metric. cSs|Sr/r3xr3r3r4r57r6zcompile_times..cs r|t|Sdt||S)Nr;)sumr<r=)rOitem_fn) aggregater3r4fmt_fn7s zcompile_times..fmt_fnr>cs$g|]}|t|dddfqS)cSs|dS)Nz.4fr3r}r3r3r4r5>r6*compile_times...r)r.r?krr3r4 =sz!compile_times..z!TorchDynamo compilation metrics: )Functionz Runtimes (s)r8csvcsg|]}|dddqS)cSs|dS)Nz.6fr3r}r3r3r4r5Fr6rrr3)r?vrr3r4rEsN)r.rBrOlistkeys)reprrrFrZrOr9r3)rrr4 compile_times)s   rcCsttddddS)Nr>T)rr)loginforr3r3r3r4dump_compile_timesMsrc@s&eZdZd ddZddZddZdS) DuplicateWarningCheckercCs||_|dSr/)maxsizereset)selfrr3r3r4__init__asz DuplicateWarningChecker.__init__cCst|_dSr/)r0 OrderedDictsetrr3r3r4reszDuplicateWarningChecker.resetcCsT||jkr&|jj|ddtjsPdSn*d|j|<t|j|jkrP|jjddq0dS)NT)lastF)r move_to_endrverboselenrpopitemrrSr3r3r4addhs  zDuplicateWarningChecker.addN)r)__name__ __module__rarrrr3r3r3r4r`s rcCs$tjdddk}|rtStS)NZTORCH_COMPILE_DEBUG01)osenvironreadd_file_handler contextlib ExitStack)Z compile_debugr3r3r4setup_compile_debugwsrcCs tdSr/)graph_break_dup_warning_checkerrr3r3r3r4reset_graph_break_dup_checkersrcsftjtd}tj|ddttj|dtdt }| fdd|S)NZ torchdynamoTexist_okz debug.logz torch._dynamocs Sr/ removeHandlerr3Zlog_file_handlerloggerr3r4r5r6z"add_file_handler..) rpathr< get_debug_dirmakedirslogging FileHandler getLogger addHandlerrrcallback)log_path exitstackr3rr4rs  rcsVt}tjdk rRttjtjj D]" | fddq*|S|S)Ncs Sr/rr3rr3r4r5r6z setup_log_file..) rrrZ log_file_namerrrb_logging _internalZ get_loggersrr)rr3rr4setup_log_files   rcCs(td|jdt|jd|jdS)Nz/error_recordings/_z.rec)rco_namerlrco_firstlineno)exccoder3r3r4gen_record_file_namesrc CszzTtj|rtd|n6tjtj|ddt|d}||W5QRXWn t k rtt d|YnXdS)Nz9Unable to write execution record %s; file already exists.Trwbz#Unable to write execution record %s) rrexistsrwarningrdirnameopendumprk exception)filenameZ exec_recordfr3r3r4write_record_to_files  r)gcCs&d}|jD]}d|jkr |d7}q |S)Nrcallr)nodesop)rcnr3r3r4 count_callss    rcCs|Sr/r3r}r3r3r4identitysrcCs>zt|WdStk r$YdStk r8YdSXdS)NTF)hash TypeError ValueErrorr}r3r3r4hashablesrcOsdSr/r3rmrnr3r3r4nothingsrc@sJeZdZdZddZddZdddZd d Zd d Zd dZ ddZ dS)ExactWeakKeyDictionaryz\Similar to weakref.WeakKeyDictionary, but use `is`/`id` rather than `==` to compare equalitycCst|_t|_dSr/)dictrOrefsrr3r3r4rszExactWeakKeyDictionary.__init__cCs|jt|Sr/)rOidrr3r3r4 __getitem__sz"ExactWeakKeyDictionary.__getitem__NcCs|jt||Sr/)rOrer)rrSdefaultr3r3r4reszExactWeakKeyDictionary.getcCst||jkSr/)rrOrr3r3r4 __contains__sz#ExactWeakKeyDictionary.__contains__cs<t|jkr.t|fddj<|j<dS)Ncs Sr/) _remove_id)refidxrr3r4r5r6z4ExactWeakKeyDictionary.__setitem__..)rrweakrefrrO)rrSr[r3rr4 __setitem__s z"ExactWeakKeyDictionary.__setitem__cCs(||jkr|j|=||jkr$|j|=dSr/)rOr)rrr3r3r4rs  z!ExactWeakKeyDictionary._remove_idcCs|j|jdSr/)rrKrOrr3r3r4rKs zExactWeakKeyDictionary.clear)N) rrra__doc__rrrerrrrKr3r3r3r4rs rcCs(t|tttfrt||kSt||kS)zisinstance() without subclasses) isinstancetuplerrrl)objZ allowed_typesr3r3r4istypes r cCs.tjdkrt|trdSt|tjp,|tjkS)NrT)sys version_infor_builtin_final_typing_classestyping_FinalGenericr[r3r3r4 is_typings rc Cs2tsdSt|tjtjtjtjtjtjtjtj fSNF) nprint8int16int32int64uint8Zuint16Zuint32Zuint64rr3r3r4is_numpy_int_typesrcCstsdSt|tjtjtjfSr)rrfloat16float32float64rr3r3r4is_numpy_float_type!srcCs:t|p8t|tjr$tt|dp8t|tjjtjj fS)N __wrapped__) is_functionr functools_lru_cache_wrapperinspectgetattr_staticrb_opsZOpOverloadPacket OpOverloadrr3r3r4is_function_or_wrapper/s  rcCs t|tjtjtjtjtjjfSr/) rtypes FunctionTypeBuiltinFunctionTypeMethodDescriptorTypeWrapperDescriptorTyperbjitScriptFunctionrr3r3r4r 8sr cCs t|dSrJ) unwrap_with_attr_name_if_wrapper)fnr3r3r4unwrap_if_wrapperEsrcCs~t|tjrt|d}d}nXt|rHt|ddrHt|d|}d}n.t|rrt|ddrrt|d|}d}nd}||fS)Nr Z_torchdynamo_inlineFZ__script_if_tracing_wrapperZ __original_fn)rr r r rr )r attr_namer3r3r4rIs   rcCstsdSt|tjSr)rrndarrayrr3r3r4is_numpy_ndarray]srcCs,tjtjjftj}|tjjf}t||S)zCheck of obj is a tensor) rbTensornn ParameterrZtraceable_tensor_subclasses _subclassesrr)rZ tensor_listr3r3r4istensordsr#cCs t|tSr/)rr)modr3r3r4is_lazy_moduleosr&rcGs t|dSr/)rY)rmr3r3r4 print_oncessr'cs6|fdd}|jdk r(t|jdks,t|jdS)zNSome black magic to create a cell object that usually only exists in a closurecsSr/r3r3r}r3r4r|szmake_cell..fNrr) __closure__rAssertionError)valrr3r}r4 make_cellxs r+c Csz.tdd|D}dd|D}||fWStk r}zDddlm}ddlm}|d||d |t||d W5d}~XYnXdS) Ncss|]}|VqdSr/as_proxyr?argr3r3r4rAsz$proxy_args_kwargs..cSsi|]\}}||qSr3r,)r?rSr/r3r3r4 sz%proxy_args_kwargs..r unimplemented)typestrzcall_function args: rUZfrom_exc) rrPNotImplementedErrorrr2Zvariables.baser3rrO)rmrnZ proxy_args proxy_kwargsrvr2r3r3r3r4proxy_args_kwargss   r7c@seZdZUeed<eed<eed<eed<eed<eed<eed<eeed<eeed <eeed <eeed <eeed <eed <eeed<eeed<eeed<eeed<eeed<eeed<eeed<eeed<eeed<eeed<eeed<eed<e ed<dS)CompilationMetricsrrrqr co_filenamerZ cache_sizeZaccumulated_cache_sizeZ guard_countZshape_env_guard_countZgraph_op_countZgraph_node_countZgraph_input_count start_timeZentire_frame_compile_time_sZbackend_compile_time_sinductor_compile_time_scode_gen_time_srorpZfail_user_frame_filenameZfail_user_frame_linenoZnon_compliant_opsZcompliant_custom_opsZrestart_reasonsZdynamo_time_before_restart_sZhas_guarded_codeN) rrrar>__annotations__intrr2rboolr3r3r3r4r8s4                 r8c@sFeZdZUeed<eeed<eeed<eeed<eeed<dS)rgrrr;r<rorpN)rrrar>r=rr2r3r3r3r4rgs    rg@maxlen_compilation_metricscompilation_metricscsPtttrd}nd}ttrLtj|fddtjrLt dS)NrEZbwd_compilation_metricscsddtDS)NcSs(i|] \}}|t|tr t|n|qSr3)rrr)r?rrr3r3r4r0sz@record_compilation_metrics....) dataclassesasdictrPr3rDr3r4r5s z,record_compilation_metrics..) rCrjrr8rbrZtrace_structuredrZlog_compilation_metricsr&)rEnamer3rDr4rhs    rh)new_sizereturncCs,tt|krtqtjt|d}|adS)NrA)rrCpopleftr0deque)rIZ new_dequer3r3r4set_compilation_metrics_limits  rM)rJcCs tdSr/)rCrKr3r3r3r4clear_compilation_metricssrNcCsttSr/)rrCr3r3r3r4get_compilation_metricssrOc@s>eZdZUdZeeefed<eed<ddZe ddZ dS) CleanupHookz,Remove a global variable when hook is calledscoperHcGs$tdk rtjd8_|j|j=dSrG)CleanupManagercountrQrHrrmr3r3r4__call__szCleanupHook.__call__cCs,||ks ttjd7_|||<t||SrG)r)rRrSrP)rQrHr*r3r3r4creates zCleanupHook.createN) rrrarr r>rr=rU staticmethodrVr3r3r3r4rPs rPcs.eZdZUdZeded<fddZZS)rRrinstancecs&|j|D] }|q t|dSr/)rOsuperr)rrhook __class__r3r4rszCleanupManager._remove_id)rrrarSr r=r __classcell__r3r3r[r4rRs  rRcCs0||j}|jr,|jdk r,|j|_|S)z!Clone the tensor and its gradientN)clonerequires_grad_ requires_gradis_leafgradr~yr3r3r4 clone_tensors redtypec s(t|r |Sfdd}t|jjdkrD||W5QRS|jtjkrtj|||| |j | dW5QRSt |r|jtj tjhkr|}|}n|}|}tj|||||||j |jdW5QRStddt||D}|jr0t|df|}ntj|dpD|j|jd }||d|}||||zJ| |!|j"r|#|j$|j"r|j%d k rt&|j%d |_%Wn*t'k r||YW5QRSXt(|d r|j)*|_)|W5QRSQRXd S) zcopy while preserving stridescsVt|}|jr||j|jr<|jdk r.torch_cloneZxla) is_coalesced)layoutcss|]\}}|d|VqdS)rNr3)r?shapestrider3r3r4rACszclone_input.. )rgdeviceNrfrh)+r rbno_gradrrrlrnZ sparse_cooZsparse_coo_tensorZ_indicesZ_valuesrormr%Z sparse_csrZ sparse_bsrZ crow_indicesZ col_indicesZ ccol_indicesZ row_indicesZsparse_compressed_tensorrOrzipsizerpZ is_quantizedZempty_quantizedemptyrgdata_ptrZ element_sizeZ as_strided_copy_r^rar_r`rbri RuntimeErrorrjrhrk)r~rgrlZcompressed_indicesZ plain_indicesZ needed_sizeresultZcache_line_offsetr3rfr4risf           ricCst|tkrft|}|D]D\}}t|tr.MarkerindexNrrrar>r=r3r3r3r4Markers rrNrr)slicerrr)rjrrF dataclassrr=r|n_fieldsdirrrr)rrrfieldsrHr3r3r4namedtuple_fieldss    rc stfttjtjr4ttjgt| | D]} ||j t|fqLW5QRXfdd}|S)Nc s^tLtjtjr,tjD]\}}}|j|kr0||q0W5QRXdSr/)rbrsrrrr_versionrx)paramversionoriginal_valuerr saved_stater3r4restores     z"checkpoint_params..restore) rbrsr^rrrrrDrE parametersbuffersrjr)gmrrr3rr4checkpoint_paramss  $ rcCshtjrtjj}nt}|ttdt }t |D]}||}|q@t }|||fS)Ni9) rbrr synchronizergcZcollectZ manual_seedri perf_counterr|)rr}timesrrtrrzt1r3r3r4timeds    rcCs tddt||dDS)Ncss|] }|jVqdSr/)Zis_cudar?r~r3r3r4rA sz check_is_cuda..T)allrDrEr)rr}r3r3r4 check_is_cuda srrqcCsn|dks tddt|D}t|dd|dd}tdd|dd|d}d |d |_|S) NrcSsg|]}d|qSrr3)r?rr3r3r4rsz rot_n_helper..zlambda ,z: ()Zrot_Z_helper)r)r|reversedevalr<r)rvarsZrotatedrr3r3r4 rot_n_helper s  "rcCs<t|ttfrttt|St|tjt fp:t|t t hBSr/) rr frozensetrr=is_safe_constantrenumEnumrlcommon_constant_typesrrr3r3r4r-s rcCs,ddlm}m}t||r(||S|S)Nr)ConstantVariableSymNodeVariable) variablesrrrrVZ evaluate_expr)r/rrr3r3r4specialize_symnode6s rcCs*ddlm}t|}t||r&|S|S)Nrr)rrrras_python_constant)r/rr3r3r4 guard_if_dyn@s   rcCstddt||DS)Ncss|]}|VqdSr/)is_python_constantrr3r3r4rALsz&check_constant_args..)rrDrErOrr3r3r4check_constant_argsKsrcCs^ddlm}ddlm}d}t||D](}t||rD|d7}q,t||s,dSq,|dkS)NrrUnspecializedPythonVariablerF)Zvariables.constantrvariables.tensorrrDrErOr)rmrnrrZ unspec_countr~r3r3r4check_unspec_python_argsOs     rcCs>ddlm}t||D]}|st||sdSqdS)NrrFT)rrrDrErOrr)rmrnrr~r3r3r4check_unspec_or_constant_args\s  rcs.ddlmtfddt||DS)NrNumpyNdarrayVariablec3s|]}t|VqdSr/)rrrr3r4rAjsz+check_numpy_ndarray_args..)rranyrDrErOrr3rr4check_numpy_ndarray_argsgs  r dict_keys dict_values odict_valuestuple_iteratorcCst|}tjj||Sr/) object_newrbr Moduler)rrr3r3r4 nn_module_newxsrcCsttj|dSrG)r reduceoperatormul)itr3r3r4product~srcCs|\}\}}|||Sr/) __reduce__)rrrrrr3r3r4tuple_iterator_getitemsrcCs ||Sr/)Z as_subclass)trr3r3r4 to_subclasssrcCsttt|||dSrG)nextrDisliceiter)drr3r3r4dict_keys_getitemsrcCs2|jj}|j}|rdnd}|d|d|}|S)NLGz["z"].)r\rrH)r[localrHr*rQZ local_namer3r3r4 enum_reprs  rcCs:||jd<tjj}tjjj ||}r6||jd<dS)N example_valueZunbacked_bindings) metar$re fake_mode shape_envrbr" experimentalsymbolic_shapesZcompute_unbacked_bindings)noderrZsymbol_to_pathr3r3r4set_example_values   rcCs2|jjd}t|s.ddlm}|d|S)Nrrr1z:Cannot check Tensor object identity without its fake value)r-rrrer rr2)vt fake_tensorr2r3r3r4_get_fake_tensors  rc sddlm}m}m}m}r@tfdd|D}||Sd} |r^t|r^d} t d} |D]l} | rt| |r҈t | kr|dSqf|t j  || gi} | dkr| } qf|t j  || | gi} qf| dkr|d} | S)Nr)BuiltinVariablerTensorVariableVariableTrackerc3s&|]}|o|kVqdSr/)rrrsearchr3r4rAsz iter_contains..FT)rrrrr rrrVrrreq call_functionor_) rPr txZcheck_tensor_identityrrrr Z found_constZmust_check_tensor_idfoundr~checkr3r r4 iter_containss6      rcCst|tjtjjtfS)z4Returns whether it indexes dictionaries using its id)rrbrr rr)rr3r3r4 key_is_idsrcCsdd|DS)NcSs g|]}t|rt|n|qSr3)rrrr3r3r4rszkey_to_id..)rrr3r3r4 key_to_idsrcsddlm}t|ttfr|dfdd|D}t|trHd|dSt|tsVtt|dkrnd|d Sd|d SnNt|tj rt |d  d d S||r|j St|t rdd}||S|SdS)Nr)is_builtin_callablerc3s|]}t|dVqdSrN const_reprr?srr3r4rAszconst_repr..[](z,)rr'rcSs(|j}|j}|dkr|jS|d|jS)Nbuiltins.)r\rra)oklassrr3r3r4fullnames zconst_repr..fullname)Z trace_rulesrrrrr<r)rrrrreplacerrl)r~rrZ elems_reprr$r3rr4rs"       rcs$dfdd|D}d|dS)Nrc3s|]}t|dVqdSrrrrr3r4rAsz!dict_keys_repr..rrr<)Z const_keysrZkeys_strr3rr4dict_keys_reprsr'Z __dict_key)UnsupportedFakeTensorExceptionc Cs`z|WStk rZ}z4ddlm}d|jd}t||||dW5d}~XYnXdS)Nrr1z Unsupported: z with fake tensor propagation.r4)r(rr2reasonrr)rrvr2msgr3r3r4wrap_fake_exceptions  r+c s6tjj|tfddW5QRSQRXdS)Ncs tSr/)rkdeepcopyr3rr3r4r5r6z)deepcopy_to_fake_tensor..)rbr"rZ FakeCopyModer+)rrr3rr4deepcopy_to_fake_tensorsr-cCsttt||S)z+ Calculate root mean squared error )rbsqrtZmeanZsquare)rr~r3r3r4rmse"sr/g-C6?c  sdkr ttttjjtjfrtttfsNtdtdtt t krjddSt t kot  fddt DStj dkrt jjj d Sttr~ttstttks,td td ttD]@} t | | |  d s8d | dSq8dSttjtfrJttjjrtttjjrtdd fddfD\jrjstttjs,tdtdtrjjkrTdjjdSjtjkrrldStjjtjdjtjd d} | sd| Sr&tjtjtj ddrdStjj j!ddd} | dkrt"#d| $%&| dkSs8jtj drRdSjtj'kr.t(&} t)*| rt"#dt(&}jtj+krdnd},dksj-dkrj.d j.d!krd"ksn d#krd}|||  d$k}|s*d%|| /j| |Sr8dSd& dSn\tt0t1tdttj2frrpdSk} | sd't| St3st4rrt3st4sʈ&ttkok} | sd(| St5r>ttko.ZQuestionAnsweringModelOutputr0zkeys mismatch z == r3r8r4r5r7r6r1zAccuracy failed for key name %sTcSst|tjr|St|Sr/)rrbrtensorrr3r3r4 to_tensorwszsame..to_tensorc3s|]}|VqdSr/r3)r?r*)r<r3r4rAzszdtype mismatch %s, %srf)ZatolZrtolr4z+Accuracy failed: uint8 tensor did not matchrgư>)dimepsgGz?zSimilarity score=%sz=Found nan in reference. Consider running in higher precision.g@g@irrg{Gz?g$@z\RMSE (res-fp64): %.5f, (ref-fp64): %.5f and shape=%s. res.dtype: %s, multiplier: %f, tol: %fz+Accuracy failed: allclose not within tol=%szAccuracy failed (%s): %s != %sz!Accuracy failed (numpy): %s != %s) ZMaskedLMOutputZSeq2SeqLMOutputZ!CausalLMOutputWithCrossAttentionsZLongformerMaskedLMOutputZ InstancesZSquashedNormalZBoxesZNormalZ TanhTransformZFooVariablec 3s<|]4}tt|t|t| d VqdS)r9N)r2r)r?rS) r3r4r5fp64_refr6r1rr7r~r8r3r4rAs zunsupported type: )9rrrrbr Z ParameterListSizer)rlrrrtrr2Zlossrrrsortedrr2r"rZ is_sparseZto_densergr?ZallclosetorflattenrZ functionalZcosine_similarityrrcpudetachitemrr/mathisnanbfloat16Znumelndimrorur>r>rrrrr as_tensor__dict__ry)rr~rBr3r8r4r5r7r6r1rruZscoreZ ref_errorZ res_errorZ multiplierZ passes_testr3) r3r4r5rBr6r1rr7r~r<r8r4r2)s@ *(       *                r2cCs,|jdd}d|jd|d|jdS)N/rrz' (rVr)r9splitrr)rZshort_filenamer3r3r4format_func_infosrRccs:tj}tjt_tj}tjt_z dVW5|t_|t_XdSr/)rZcache_size_limitrrZaccumulated_cache_size_limit)ZpriorZprior_acc_limitr3r3r4disable_cache_limits rSguard_failuresz-torch._dynamo.output_graph.GraphCompileReasongraph_break_reasonsc@sJeZdZdZddZejjdddZddZ d d Z d d Z d dZ dS)CompileProfilerzUtility for profiling how and what dynamo would compile. Can be used for * diagnosing recompilation issues * determining an appropriate compile cache limit * (TODO)confirming which functions got compiled/skipped cCsd|_d|_t|_dSrJ) frame_countrMrSZbackend_ctx_ctorrr3r3r4r?szCompileProfiler.__init__rcCs:|jd7_|jjD]}d|jkr|jd7_q|jS)Nrr)rWgraphrrrMr`)rrr}rr3r3r4rUDs   zCompileProfiler.__call__cCs|Sr/r3rr3r3r4 __enter__LszCompileProfiler.__enter__cCsdSr/r3)rtypr* tracebackr3r3r4__exit__OszCompileProfiler.__exit__cCsdtiS)NrT)rTrr3r3r4 get_metricsRszCompileProfiler.get_metricscs|}|dfddfddfddDdd }fd d }td }||phd 7}|td7}||pd7}|S)NrTcs t|Sr/)rrgfr3r4num_recompilesYsz.CompileProfiler.report..num_recompilescsddd|DS)Nr:cSsg|] }t|qSr3)r>rr3r3r4r]szECompileProfiler.report..recompile_reasons..r&r_r`r3r4recompile_reasons\sz1CompileProfiler.report..recompile_reasonscs"g|]}t|||gqSr3)rRr?r)rbrcr3r4r_sz*CompileProfiler.report..cs2dtkr.tdtfddDddgdSdS)NZ graph_breakcsg|]}||gqSr3r3)r?r*Z graph_breaksr3r4rhszFCompileProfiler.report..graph_break_report..zGraph Break ReasonZCountr8)r,rBr3r3rer4graph_break_reportds z2CompileProfiler.report..graph_break_reportcsJtrFtfddD}tdddgd}|td|dSdS) Nc3s|]}|VqdSr/r3rd)rbr3r4rAnszGCompileProfiler.report..recompilation_report..rZ RecompileszRecompile Reasonsr8zC Set torch._dynamo.config.cache_size_limit to z/ to avoid being cache limited. )rmaxrBtextwrapdedent)Zmax_recompilesZ recomp_table)rarb summarized_gfr3r4recompilation_reportlsz4CompileProfiler.report..recompilation_reporta Torchdynamo Profiler Report =========================== Graph Breaks ------------ Graph breaks happen when torchdynamo encounters code it can't safely trace. If you want to find out why breaks are happening, check below for each break reason You may gain additional insight by passing `fullgraph=True` to torch.compile, to stop at the first break. zNo graph breaks detected.a+ Recompilation ------------- These subgraphs were recompiled more than once due to guard failures Guard failures indicate some condition assumed to be static by the tracer changed, making it unsafe to reuse the compiled program. zNo recompilation detected. )r^rhri)rrsrfrkreportr3)rarbrcrjr4rlUs$    zCompileProfiler.reportN) rrrarrrbr" GraphModulerUrZr]r^rlr3r3r3r4rV6srVcCs2dtjddtt}tj||S)NZrun_z%Y_%m_%d_%H_%M_%S_%fz-pid_)datetimenowstrftimer>rgetpidrr<)root_dirdir_namer3r3r4_get_debug_dirs rtcCstj}t|Sr/)rZdebug_dir_rootrt)Z debug_rootr3r3r4rsrcCsDd|jkr"t|jdr"|jdS|r.visit)rbr"Nodermap_arg)rrr{r|r3rzr4get_fake_values_from_nodess rc s:ddlm}ddlm}m}m}m}m}j} dj krPt j drPj dSt j j f|\d| dkrtdkrtdtjjrtdjftdd| dkrjjjtrtd rtjzBj0ttfd d } W5QRXW5QRXWn|k rPYntk r} z| } | jdk rz| j} t| tj j!j"r|d | j#d nLt| tj j!j$rtj%j&j's|d| j#dn|d| j#dnt| tj j!j(rp| j#} d} t| tj)j*rVtj+,| j-j.| j-j/}|dk rV|\}}d|d|d|d} |d| j#d| dn~t| tj0j1j2j3r||j4d| ddnRt| |r||j4| j d| n0t| t5rdt6| kr|djd| |t6| 7| j8dW5d} ~ XYnX|s6t9:tj;td| }| S) az Run the computation represented by `node` using fake tensors and return the result. allow_non_graph_fake: whether to allow the return result to be: 1. non-fake or 2. fake that is not created by this instance of Dynamo. If `True`, you must be prepared to deal with such return values, ideally by further wrapping them as this graph's fakes. r)ValueRangeErrorr)TorchRuntimeErrorr2 Unsupported UserError UserErrorTyperN call_method call_moduleZ_initialize_hookcstjSr/)run_nodeoutputr3rmrnnnmodulerrr3r4r5r6z get_fake_value..zdata dependent operator: zC; to enable, set torch._dynamo.config.capture_scalar_outputs = Truezdynamic shape operator: zM; to enable, set torch._dynamo.config.capture_dynamic_output_shape_ops = Truezm; Operator does not have a meta kernel that supports dynamic output shapes, please report an issue to PyTorchrz:It's possible that the support was implemented in module `z` and you may need to `import z`(z ), otherwise zunsupported operator: z (z~see https://docs.google.com/document/d/1GgvOe7C8_NVOMLOCwDaYV1mXXyHMXY7ExoewHqooxrs/edit#heading=h.64r4npvq0w0 for how to fix)aTried to use data-dependent value in the subsequent computation. This can happen when we encounter unbounded dynamic value that is unknown during tracing time. You will need to explicitly give hint to the compiler. Please take a look at torch._check OR torch._check_is_size APIs. Zconstrain_as_size_example)Z case_nameargumentz TypeError z: )r)?Ztorch.utils._sympy.value_rangesrrrr2rrrrrr rrmrnrrrbr rr-rrr nn_modulestargetr&rjZ_infer_parametersr#r+ry __cause__r"rZDataDependentOutputExceptionrwZDynamicOutputShapeException_dynamorZ capture_dynamic_output_shape_opsZUnsupportedOperatorExceptionrrrZ_dispatch_pystubZ_schemarHZ overload_namer"rrZGuardOnDataDependentSymNodeZCONSTRAINT_VIOLATIONrr>with_traceback __traceback__pytreeZ tree_map_onlyrr partialrw)rrr{rrr2rrrrZret_valrvcauseZimport_suggestionZ maybe_pystubrctxrr3rr4rys   &"          ( rycCs ttddS)Nr[)r _current_noder3r3r3r4get_current_nodeIsrccs$t}|t_z dVW5|t_XdSr/)rrr[)roldr3r3r4set_current_nodeMs  rc sjtpfdd}zڈdkrHjWW5QRSdkr|tdjddWW5QRSdkr|dk st|WW5QRSd kr|jjWW5QRSd krd jkstjd WW5QRSWn|tt fk rB}z dd l m }||||d W5d}~XYn:t k rz}zt |||j|W5d}~XYnXW5QRXtdS)a Runs a given node, with the given args and kwargs. Behavior is dictated by a node's op. run_node is useful for extracting real values out of nodes. See get_real_value for more info on common usage. Note: The tracer arg is only used for 'get_attr' ops Note: The nnmodule arg is only used for 'call_module' ops Nodes that are not call_function, call_method, call_module, or get_attr will raise an AssertionError. c s(ddjddd t|S)NzFailed running rUz(*z, **z): )rr>)rvrmrnrrr3r4make_error_messagejsz$run_node..make_error_messager rrrNrZget_attr placeholderrr1r4)rrrrr) output_graphZ get_submodulerr5r(rr2rkryrr)tracerrrmrnrrrvr2r3rr4rWs4 ,     rc sddlm}j}||kr"||S|j}tjj|j|j ffdd\}}|dkrjd|j krj|j dj S|dkrj j |j}t|st|}q|||nd}zt||||}|||<Wn8tk r} z|t| | jdW5d} ~ XYnX|S) z Run the actual computation represented by `node` and return the result. This will execute any dependent nodes in the graph as well. r)rcs t|Sr/)get_real_valuerxrr3r4r5r6z get_real_value..rZgraphargrN)rrZreal_value_cacherrbr"rr~rmrnrexamplerrrr&rkr,rryr>rr) rrrcacherrmrnZ nn_module real_valuervr3rr4rs.       (rcsddlmm}fdd}|D](\}}||r$td|d||q$|D](\}}||rVtd|d||qVdS)Nr)FakeTensorConfigr cs(jr ddl}d||jSdSdS)Nrz"FAKE TENSOR CREATION TRACEBACK: zNEnable TORCH_FAKE_TENSOR_DEBUG=1 to get creation stack traces on fake tensors.)debugr\ format_listZ _debug_trace)rr\rr3r4 stack_or_hintsz7assert_no_fake_params_or_buffers..stack_or_hintzUnexpected fake buffer rUzUnexpected fake param )torch._subclasses.fake_tensorrr Z named_buffersr)Znamed_parameters)rr rrHbufferrr3rr4 assert_no_fake_params_or_bufferss rrcCs|jd|jS)z9 Returns the fully qualified name of the object. r!)rrarr3r3r4fqnsrcCstjjjr|S|SdSr/)rbrrZassume_static_by_default)Zcount1Zcount2r3r3r4ifdynstaticdefaults rr$cCs\tttjtt|jD]8}|dr|ddkrt |j d|ddqdS)z@ Ensure all the files in a given submodule are imported z.pyrrr!N) rDrlistdirrrrr>__file__endswith importlib import_moduler)r%rr3r3r4import_submodules"rrcCs<z"ttt|dtjr WdSWntk r6YnXdS)N__getattribute__TF)rr rrlrrAttributeErrorrr3r3r4object_has_getattributes rcCsDztt|d}Wntk r,d}YnX|tjjjkr@d}|S)N __getattr__)r rrlrrbr rr)r[Z getattr_fnr3r3r4get_custom_getattrs rc@seZdZdZdZdZdS)TensorStaticReasonrr?rWN)rrra PARAMETER NOT_TENSORNN_MODULE_PROPERTYr3r3r3r4rsrr)cCs<|tjkrdS|tjkrdS|tjkr*dStd|dS)Nz>mark_dynamic on parameter, parameters are always static today.z2mark_dynamic on a non tensor, how did this happen?z4tensor is static because it is nn module associated.zIllegal reason )rrrrr)rr3r3r4tensor_static_reason_to_messages   rztorch._guards.GuardSource)r: is_tensor guard_sourcerJcCsJ|rtjrdtjfSt|tjjkr8tj r8dtj fS|sFdtj fSdS)a@ Given a tensor, source, and is_tensor flag, determine if a shape should be static. Args: tensor - the real tensor to evaluate, parameters force a static shape. is_tensor - internal dynamo check, essentially "is_tensor": target_cls is TensorVariable, tensors not in a TensorVariable for whatever reason are forced static. Returns a tuple, where the first element is the bool of whether or not this tensor should have a static shape. The second element is a TensorStaticReason, useful for passing to tensor_static_reason_to_message if needed. T)FN) Z is_nn_modulerZ&force_nn_module_property_static_shapesrrrlrbr r!Zforce_parameter_static_shapesrr)r:rrr3r3r4tensor_always_has_static_shapes   rcsfdd}t|S)Ncsrzddlm}Wn&tk r6dttYSXddjjD}||dddd d gd }tjjj |S) Nr)rBzkTabulate module missing, please install tabulate to log the graph in tabular format, logging code instead: cSs$g|]}|j|j|j|j|jgqSr3)rrHrrmrn)r?rr3r3r4r%sz.inner..opcoderHrrmrnr8) rBrCr>r(rYrr'r`__code__r9)rBZ node_specsZ graph_strfn_namerr3r4inners  z(lazy_format_graph_tabular..innerr)rrrr3rr4lazy_format_graph_tabularsrc Cs,|d|d|d|dt|d S)NrUz line z r:)disBytecode)prefixrHrline_norr3r3r4format_bytecode0srZ_forward_pre_hooksZ_forward_hooksZ_backward_pre_hooksZ_backward_hooksZ_state_dict_pre_hooksZ_state_dict_hooksZ_load_state_dict_pre_hooksZ_load_state_dict_post_hookscCs ttjjjjpttjjjjSr/)rrbr modulesrZ_global_backward_hooksZ_global_backward_pre_hooksr3r3r3r4nn_module_has_global_hooks?s rc Cstjjjj}g}| o | o | }|s*|r4|t|s<|rF|t|rT|tg}|D],}t ||g} | D]} | | } | | qpq\|Sr/) rbrr eval_frame reset_codeextendforward_hook_namesbackward_hook_namesstate_dict_hook_namesrrj) r%check_forward_hookscheck_backward_hookscheck_state_dict_hooksrZhook_dicts_to_checkZcheck_all_hooksZ all_hooksZhook_dict_namehooks hook_namerZr3r3r4nn_module_get_all_hooksGs(     rcCst||||d}t|S)zL Helper function to check if a module has any hooks attached to it. )rrr)rr?)r%rrrrr3r3r4nnmodule_has_hooksis rcCsft|r |St|tjr"t|jSt|tjr:|jddSt|t t fr^t |dd|DS|SdS)z0Convert tensor and tnp.ndarray to numpy.ndarray.T)forcecss|]}t|VqdSr/)to_numpy_helperr?rr3r3r4rAsz"to_numpy_helper..N) r rtnprrr:rbrnumpyrrrlrr3r3r4r{s    rcCs`tdk s tt|tjr"t|St|tjr4|jSt|tt frXt |dd|DS|SdS)zeConvert tnp.ndarray to tensor, leave other types intact. If a list/tuple, loop through it to convert.Ncss|]}t|VqdSr/)numpy_to_tensorrr3r3r4rAsz"numpy_to_tensor..) rr)rrrbrNrr:rrrlrr3r3r4rs    rc@s$eZdZddZddZddZdS)numpy_to_tensor_wrappercCs||_d|jj|_dSNZwrapped_rr)rrr3r3r4rsz numpy_to_tensor_wrapper.__init__cCsd|jjdS)Nz>rrr3r3r4__repr__sz numpy_to_tensor_wrapper.__repr__cOs|j||}t|Sr/)rrrrmrnrZr3r3r4rUs z numpy_to_tensor_wrapper.__call__N)rrrarrrUr3r3r3r4rsrcCsFt|tjrt||}t|St|tjrBtt||}t|SdSr/)rrrrrrbr)rrHrZr3r3r4numpy_attr_wrappers    rc@s.eZdZdZedddZddZddZd S) numpy_method_wrapperzgConvert obj from torch.Tensor to tnp.ndarray and call method. Then convert result back to torch.Tensor.methodcCs||_d|j|_dSr)rr)rrr3r3r4rsznumpy_method_wrapper.__init__cCsd|jdS)NzrrrUr3r3r3r4rsrc@s6eZdZdZedefdddZddZdd Zd S) numpy_operator_wrapperzQImplements dunder methods for tnp.ndarray via functions from the operator library.)rcCs||_d|j|_dSr)rr)rrr3r3r4rsznumpy_operator_wrapper.__init__cCsd|jdS)Nz.)r)rrrr3r3r4rUs  znumpy_operator_wrapper.__call__N) rrrarrrrrrUr3r3r3r4rsrcCst|ts|S|jrg}|D]4}t|tjrJ||jj |jj q ||q g}| D]4}t|tjr||jj |jj qb||qbn|}| }tj |||j |j|jd}||S)N)rgrrr`)rrZ_has_symbolic_sizes_stridesrurbZSymIntrjrrZ size_hintexprrpZ empty_stridedrgrrr`Zzero_)r~rurrprdr3r3r4defakes0      rcCsddl}||jjjkSrJ)Ztorch.utils.checkpointr checkpoint)rrbr3r3r4is_utils_checkpointsrcKsBddlmm}ddlm}|j}tjjj r4|j }|j |f|S)Nrr) TorchHigherOrderOperatorVariable) Ztorch._higher_order_ops.wrapZ_higher_order_opswrapZvariables.higher_order_opsrZtag_activation_checkpointrbZ _functorchrZfunctionalize_rng_opsZwrap_activation_checkpointmake)optionsZhigher_order_opsrZactivation_checkpoint_opr3r3r4build_checkpoint_variables  rcCs8ddlm}|}|dkrn|dkr0|r0t}nd}|S)Nr)is_dynamo_supportedrGrF)rrr*)Z device_typerZcompile_supportedr3r3r4is_compile_supported s  r)r>offsetrJcCs$|d}t|d|jdddS)z Convert byte offset `offset` of `str` into character offset. Byte offset is used for 3.11+ instruction column data. Takes things like unicode characters into consideration. Unchanged from CPython implementation. zutf-8Nr%)errors)encoderdecode)r>rZas_utf8r3r3r4 _fix_offset s rc@s.eZdZUeed<eed<eed<eed<dS)_Anchorsleft_end_linenoleft_end_offsetright_start_linenoright_start_offsetNrr3r3r3r4r) s r)segmentrJcstjdkstddl}z|d|d}Wntk rBYdSXt|jdkrVdS|dfdd }fd d fd d }fdd}|jd}t ||j r|j }t ||j rt t|jjd}|||jj} || \}} || } s| dkr8| dkr(||| \}} q||| \}} q| d} | t|krz|| } sz| dkrz| d7} t|| || St ||jrt t|j jd} || |j j} | | \} } | | dkr|| | \} } qt t|jd}|||j} t| | || St ||jrt t|jjd} || |jj} | | \} } | | dkrr|| | \} } qNt t|jd}|||j} t| | || SdS)a Given source code `segment` corresponding to a bytecode instruction, determine: - for binary ops, the location of the binary op - for indexing, the location of the brackets. `segment` is expected to be a valid Python expression )r rNz( z )rr:cst||Sr/)r)linenorlinesr3r4 normalizeM sz-_extract_anchors_from_expr..normalizecsR|tkr*|t|kr*d}|d7}q|tkrF|t|ksJt||fSrrr)rcolrr3r4next_valid_charR s   z3_extract_anchors_from_expr..next_valid_charcs>|d7}||\}}|tkr2|t|ks6t||fSrGr r rr r3r4 incrementZ s z-_extract_anchors_from_expr..incrementcsBd}|d7}||\}}|tkr6|t|ks:t||fSrr r rr3r4nextlinea s  z,_extract_anchors_from_expr..nextlinerz)\#z\#rr)rrr)astparse SyntaxErrorrbodyrQrExprr[BinOprr>left end_linenoend_col_offsetisspacer SubscriptCallrw)rrtreer rrZ statementrZ cur_linenoZcur_colchZ right_colZ left_linenoZleft_colZ right_linenor3rr4_extract_anchors_from_expr3 sh        r)rinstrJcCs@|jdk st|jjdkrdSt|j|jj}|jjdkrD|S|jjdks\|jj dkr`|St ||jj}d}d}g}|jj|jjkrt ||jj }|||}| d|d||n||dd}| d|dt ||t|j|jj}t ||jj }t |jjd|jjD]V}t|j|} || d7}t | t | } | d| dt | | q(||d|7}t |t |} | d| d|| d} z t|} Wntk rYnX| dkrdd|D}nd d|D} | jd kr(| j|7_| jd krB| j|7_t t |D]}t t | |D]|} || jkrvqb|| jkr| | jkrqb|| jkr| | jkrqb|| jkrqb| || dkrbd | || <qbqNd d| D}d}t t |D]8}|t|j|jj|d7}|||d7}q|S) a Python 3.11+ only. Returns lines of source code (from code object `code`) corresponding to `inst`'s location data, and underlines relevant code to `inst`. Example: CALL on `g`: f(g( ^^ h(x))) ^^^^^ We need our own implementation since `format_frame_summary` in Python's `traceback` module doesn't handle multi-line expressions (and their anchor extraction code is not completely correct). NrrU~r:rcSsg|]}|ddqS)r!^)r%r?markerr3r3r4r sz.get_instruction_source_311..cSsg|] }t|qSr3)rr#r3r3r4r srr"cSsg|]}d|qS)rr&r#r3r3r4r s)Z positionsr)r linecachegetliner9rstripr col_offsetrrrjrr|lstriprrrrr)rr  first_lineZ start_offset end_offsetrmarkers last_linerline num_spacesanchorsZmutable_markersr rzrr3r3r4get_instruction_source_311 s    "      r1cCst|tjrt|ddSdS)NZ_dynamo_static_input_type)rrbrrr;r3r3r4get_static_address_type s  r2cCsDtjjjtjjtjtjjf}tjjjtjjtjtjjf}|||kSr/) rbr GeneratorZ get_stateZdefault_generatorrrZ set_stater)r[getterssettersr3r3r4is_rng_state_getter_or_setter sr6cCs&t|tjo$|jdko$|jjtjjkS)N__get__) rrrr__self__ __objclass__rbrZ _TensorBaserr3r3r4is_tensor_base_attr_getter0 s  r:cCs t|dS)N__torch_function__)rjrr3r3r4is_torch_function_object8 sr<z,torch._dynamo.variables.base.VariableTracker)rrJcCsTddlm}m}ddlm}t||r*dSt||r>||t||oRt|jdS)Nr)LazyVariableTrackerUserDefinedObjectVariable)TensorWithTFOverrideVariableTr;) Ztorch._dynamo.variablesr=r>Z&torch._dynamo.variables.torch_functionr?rZrealizerjr[)rr=r>r?r3r3r4has_torch_function< s     r@cCsDd}d}tjj}r2||jkr2|j|}|j}|j|d||dS)NF)Z static_shapessymbolic_contextsource)rbrcr$rdZtensor_to_contextZ tensor_sourceZ from_tensor)rrrArBZtracing_contextr3r3r4to_fake_tensorL s  rCcGs8|D]}t||rt||Sqt|d|dS)zX Return the first available attribute or throw an exception if none is present. z% does not has any of the attributes: N)rjrr))rattrsattrr3r3r4get_first_attrY s rFc cs8dd}|r.tjj| }|VW5QRXndVdS)NcSsdd}tj||dddS)NcSs(tjjjddd7<tj||S)Ncompiled_autogradZcompilesr)rbrrr,Z _inductorcompile)Zgm_Zexample_inputs_r3r3r4inner_compilerg szKmaybe_enable_compiled_autograd..compiler_fn..inner_compilerT)backendZ fullgraphZdynamic)rbrH)rrIr3r3r4 compiler_fnf sz3maybe_enable_compiled_autograd..compiler_fn)rbrrGenable)Z should_enablerKrr3r3r4maybe_enable_compiled_autogradd s rMcCsGdddt}t|S)Nc@s eZdZdS)z*invalid_removeable_handle..InvalidN)rrrar3r3r3r4Invalidv srN)rr)rNr3r3r4invalid_removeable_handlet srOcCs>t|tjjs|St|tjjr$|S|j|j}|j|_|Sr/) rrbr rr"rmr\__new__rO)r%proxyr3r3r4nn_module_proxy srRcs$eZdZfddZddZZS) GmWrappercst||_||_dSr/)rYrrspec)rrrTr[r3r4r s zGmWrapper.__init__cGst|}|jt||jSr/)rrrZtree_unflattenrTrTr3r3r4r` szGmWrapper.forward)rrrarr`r]r3r3r[r4rS s rSrXcsFt|\}}|t|||ddt|jjDfdd}|S)z Mutate inputs so that they are flat and wrap gm such that it accepts those inputs. This is needed for graphs that take bumpy inputs. cSs,g|]$\}}|jdkr|jddr|qS)rZ steal_argF)rrre)r?rrr3r3r4r s z(flatten_graph_inputs..cs(tj|}D]}||q|Sr/)rZarg_tree_leavesrK)rmZ flat_argsrZ compiled_fnZ idx_to_stealr3r4wrapper s z%flatten_graph_inputs..wrapper)rZ tree_flattenrS enumeraterYr)rinputsZ compile_gmrTrVr3rUr4flatten_graph_inputs s  rYcCs*t|tjjrt|dsgS|jdgS)Nrlocals_to_steal)rrbr"rmrjrre)Zmaybe_gmr3r3r4get_locals_to_steal sr[cCs||jd<dS)NrZ)r)rrZr3r3r4set_locals_to_steal sr\c@seZdZddZddZdS)LitcCs ||_dSr/r)rrr3r3r4r sz Lit.__init__cCs|jSr/r^rr3r3r4r sz Lit.__repr__N)rrrarrr3r3r3r4r] sr]warn_once_cachecCs,|tkr dSt|tj||dddS)Nr) stacklevel)r_rwarningswarn)r*r`r3r3r4 warn_once s rc)NNT)r>F)N)F)r)F)T)F)FFF)FFF)r(^atexitr0rrkrFrnrrr rr rDr%rrJrrrrrh threadingrirrrarrrrrrrrr r r r r rrrrrrrrrZ utils.hooksrrrModuleNotFoundErrorZtorch._loggingrbZ torch._numpyZ_numpyrZ torch._guardsrrrrZfftZlinalgrr ModuleTyper=ZNP_TO_TNP_MODULErrrr r!rCrZtorch._functorch.configZ%torch.fx.experimental.symbolic_shapesZtorch.utils._pytreerZ_pytreerr"Ztorch._dispatch.pythonr#r$Ztorch._subclasses.meta_utilsr%Ztorch._utils_internalr&Ztorch.fx._utilsr'r(Ztorch.nn.modules.lazyr)Ztorch.utils._tritonr*r+r1r,r>r-Ztroubleshooting_urlZnnmodule_doc_urlZnnmodule_doc_url_msgrrrr.r2r7rSZ timer_counterrBrHrIrLrMrNrTr\r_r|rregisterrZ FloatTensorrZ DoubleTensorrdoubleZ HalfTensorrZhalfZBFloat16TensorrLZ ByteTensorrZ CharTensorrZ LongTensorrlongZ IntTensorrr>Z ShortTensorrshortZ BoolTensorr?Ztensortype_to_dtyperrrrrrrrZGraphrrrrrrr ParamSpecArgsParamSpecKwargs ParamSpecTypeVar TypeVarTuple TypeAliasTyperrrrrr rrrr#r&r'r+r7rr8rgZ!DEFAULT_COMPILATION_METRICS_LIMITrLrCrhrMrNrOrPrRrXrerir{rrrrrrrrrrrrrcomplexbytesrlEllipsisr\CodeTyperrrgZ memory_formatrnrZtritonrlanguagerrrrrrrrrrrOrrrrr__length_hint__Ztuple_iterator_lenobjectrPrrrrrZ iter_nextrrrrrrrrrr'ZGLOBAL_KEY_PREFIXZtorch._subclassesr(r+r-r/rr2rRrSZ orig_code_maprrTrUZ seen_code_maprVrtrrvrwrryrrrrrrrrrrrrrrrrrrrrrZall_hook_namesrrrrrrrrrrrrrrrr Instructionr1r2r6r:r<r@rCrFrMrOrRr rrSrmrYr[r\r]rr_rcr3r3r3r4s  L                   P $           !            J                 )  !   m  "c   }   1 '       $      y l