o h@s<UddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZddlmZddlmZmZddlmZmZmZmZmZmZmZmZmZmZddl m!Z!ddl"Z"ddl#Z"ddl$m%m&Z'ddl(Z"ddl"m)Z)dd l*m+Z+dd l,m-Z-dd l.m/Z/m0Z0dd l1m2Z2m3Z3dd l4m5Z5ddl6m7Z7ddl8m9Z9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBmCZCneDe"jEjFjGD]ZHeHIdrqeJe"jEjFjGeHeKeH<qddlLmMZMmNZNmOZOmPZPm%Z%ddlQmRZRmSZSmTZTmUZUddlVmWZWddl mXZXddl%mYZYeZe[Z\ddl]m^Z^ddl_m`Z`e%aZbejcZdddleZeddlfmgZgGdddeZhehjiZje kZldamdend <eoe7eeeepd!hZqed"d#Zrdvd(d)ZsGd*d+d+e"jtjuZvd,d-Zwd.d/Zxd0d1Zyejzdwdxd7d8Z{Gd9d:d:Z|Gd;d<dd>e|Z~Gd?d@d@e|ZdAdBZdydEdFZedd2ddfdydGdHZdIdJZGdKdLdLejcZdMdNZdOdPZ Qdzd2ddd2ddRdSdTZe!dUdVdWdXZGdYdZdZe"j6jjZGd[d\d\eZd]d^Zd_d`Zd2d2ddadd2dVdbd{dpd5Ze_make)r? cache_listr;r;r<rGesrGcsVeZdZdZdfdd ZddZdd Zd d Zd d ZddZ fddZ Z S)OptimizedModulezx Wraps the original nn.Module object and later patches its forward method to optimized self.forward method. modtorch.nn.Modulecs"t||_||_|dSN)super__init__ _orig_mod dynamo_ctx _initialize)selfrMrS __class__r;r<rQss  zOptimizedModule.__init__cCsnt|jjtjrtt|jjr| t |j|_n| |jj |_t |jdr5|j|_|j|_dSdS)N_initialize_hook) isinstancerRforwardtypes MethodTyper*checkinspect getsourcefilerSr) wrap_inline__call__hasattr_forward_call_lazy_checkrUr;r;r<rTzs   zOptimizedModule._initializecCs&t|j}|dd|dd|S)NrZra)dict__dict__poprUstater;r;r< __getstate__s   zOptimizedModule.__getstate__cCs||_|dSrO)rgrTrir;r;r< __setstate__s zOptimizedModule.__setstate__cCs|dkr |jdSt|j|S)NrR)_modulesgetattrrR)rUnamer;r;r< __getattr__s  zOptimizedModule.__getattr__cOs<t|jdrt|dksJ|j|j||j|i|S)NrXr)rbrRlen_infer_parametersrc)rUargskwargsr;r;r<rds z OptimizedModule._call_lazy_checkcs&|jfddtDS)Ncsg|]}|vr|qSr;r;).0attrorig_mod_attrsr;r< sz+OptimizedModule.__dir__..)rR__dir__rPrerVrwr<rzs  zOptimizedModule.__dir__)rMrN) r7r8r9__doc__rQrTrkrlrprdrz __classcell__r;r;rVr<rLms rLcCstt|tjr t|dSt|drt|jdStt|dddr)t|jjdSddlm }|t d|dS)zA Make sure f.__code__ is not cached to force a recompile __code__rZNrresetz#could not determine __code__ for %s) rYr[CodeTyper rbr}rnrZrlogwarning)frr;r;r<remove_from_caches    rcCsdSrOr;r;r;r;r<nothingsrcCs.|}t|dr|j}t|sJt|ds|S)z In case of nesting of _TorchDynamoContext calls, find the innermost function. TorchDynamo caches on fn.__code__ object, so its necessary to find the innermost function to pass on the optimize, run, disable etc. _torchdynamo_orig_callable)rbrcallable)fn unaltered_fnr;r;r< innermost_fns    rFenableOptional[bool]exportboolccs|dur dVdS|r(tjdd dVWddS1s!wYdStjddd dVWddS1s>wYdS)NF)assume_static_by_defaultT)automatic_dynamic_shapesr)r'r)rrr;r;r<enable_dynamics ""rcsJeZdZeeedfdddddfddZdd Zd d Zd d ZZ S)_TorchDynamoContextFNrdynamiccompiler_configcallbackr1c s`tt|s|dus|dusJ||_t|_||_||_||_||_ ||_ ||_ |dSNF) rPrQrrunsetprioron_enterextra_ctx_ctor first_ctxrrr) rUrrbackend_ctx_ctorpatch_fnrrrrrVr;r<rQs  z_TorchDynamoContext.__init__cCsTtjrtd|t|j|_||_|j t |j |j |_ |j dS)Nztorch._dynamo.optimize(...) is used with a context manager. Please refer to https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html to use torch._dynamo.optimize(...) as an annotation/decorator. )r'raise_on_ctx_manager_usage RuntimeErrorrr!rrr backend_ctx __enter__rrr dynamic_ctxrer;r;r<rs   z_TorchDynamoContext.__enter__cCsB|jtusJt|jt|_|j||||j|||dSrO)rrr!r__exit__r)rUexc_typeexc_valexc_tbr;r;r<rs  z_TorchDynamoContext.__exit__csFfdd}tttjjr(}t|}|j|_t|dr#J||_ |St s.Jzt }Wn t y@d}Ynw|dusJt|r[tdddvr[|tvr[tjjjtfdd}ttr|d |_n|_|_t|drJ||_ d vrtd sttd d tj <|S) NcsjSrO)rr;rer;r<get_compiler_config sz9_TorchDynamoContext.__call__..get_compiler_configrr7r) _call_impl_wrapped_call_implc sttstjjrtjrtd|i|St }}| t j j }| z|i|Wt ||ddd|dddSt ||ddd|dddw)NzvDetected that you are using FX to symbolically trace a dynamo-optimized function. This is not supported at the moment.)rYDisableContextrCfx_symbolic_trace is_fx_tracingr'error_on_nested_fx_tracerr!rrrrr)rsrtrrrrrrrrUr;r<_fn3s. z)_TorchDynamoContext.__call__.._fnTrr}a torch._dynamo.optimize is called on a non function object. If this is a callable class, please wrap the relevant code into a function and optimize the wrapper function. >> class CallableClass: >> def __init__(self): >> super().__init__() >> self.relu = torch.nn.ReLU() >> >> def __call__(self, x): >> return self.relu(torch.sin(x)) >> >> def print_hello(self): >> print("Hello world") >> >> mod = CallableClass() If you want to optimize the __call__ function and other code, wrap that up in a function >> def wrapper_fn(x): >> y = mod(x) >> return y.sum() and then optimize the wrapper_fn >> opt_wrapper_fn = torch._dynamo.optimize(wrapper_fn) )!rrYrCnnModulerLrZrrbrrr^r_ TypeErrorr*r]rnDONT_WRAP_FILESr)r`rrr functoolswrapsr_torchdynamo_disable_torchdynamo_inlinertextwrapdedentalways_optimize_code_objectsr})rUrrrMnew_modfilenamerr;rr<ra sN        !z_TorchDynamoContext.__call__)rr1) r7r8r9r null_contextrQrrrar|r;r;rVr<rsrcs6eZdZeddZ dddddfdd ZZS) OptimizeContextcCs||kp|du SrOr;)oldnewr;r;r<_different_backendsz"OptimizeContext._different_backendFNrc s6fdd}t|tj|||tj||||ddS)Ncs0ttrtjr ttdatdS)Nz`changing options to `torch.compile()` may require calling `torch._dynamo.reset()` to take effect) rrr=r'raise_on_backend_changer-warningswarnr0r; compiler_fnr;r<rs  z*OptimizeContext.__init__..on_enter)rrrrrrrr)rrPrQ TorchPatcherr)rUrrrrrrrrVrr<rQs   zOptimizeContext.__init__)F)r7r8r9 staticmethodrrQr|r;r;rVr<rs rceZdZfddZZS)RunOnlyContextcsdd}tjd|ddS)NcSstjjjjd7_dS)Nr)rCrEmutation_guardGenerationTracker generationr;r;r;r<rsz)RunOnlyContext.__init__..on_enterF)rrrPrQ)rUrrVr;r<rQszRunOnlyContext.__init__r7r8r9rQr|r;r;rVr<rrcr)rcstjdddS)N)rrrerVr;r<rQszDisableContext.__init__rr;r;rVr<rrrcCs>tjdkrdSt|D]}|jdkr|jdSq td)N) rRESUMErz$RESUME instruction not found in code)sys version_infodisget_instructionsopnameoffsetr)r?instr;r;r<first_real_inst_idxs  rhooksrcs"tfdd}|_|S)Nc sP|dusJ|jt|jkst|jjstjr%t d|jj |jjdS|jjdkr3|jj dkr3dStj rrt }|rrt,ddlm}||jjd}tdsVJd|j}||||WdS1smwYt*t|||WdWdS1swYWddS1swYdS) Nzskipping %s %sz__new__r) DDPOptimizer)bucket_bytes_capbackend_compile_fn_clone_with_backendzJDDPOptimizer only supports callback fns that know how to clone themselves.)f_lastirf_coder*r] co_filenamer'disablerdebugco_name optimize_ddpr_get_active_ddp_module compile_lock"torch._dynamo.backends.distributedrrrrbr compile_fnr4)frame cache_entry frame_state ddp_moduler ddp_optimizerhijacked_callbackrrr;r< catch_errorss@      Rz*catch_errors_wrapper..catch_errors)rrr)rrrr;rr<catch_errors_wrappers#rcCstt|||d|||dS)NT)rrrrr)rr)rrrrrrr;r;r<_optimize_catch_errorssrcCsDddlm}t|dr|j}n t|tr|}nd}t|}|||S)Nr)wrap_backend_debug compiler_name)repro.after_dynamorrbrrYstrr)rr compiler_strr;r;r<get_compiler_fns    rc@seZdZddZdS)_NullDecoratorcCst|sJ|SrO)r)rUrr;r;r<ras z_NullDecorator.__call__N)r7r8r9rar;r;r;r<rs rcCs(tjdkr tdtjdkrtddS)Nwin32z+Windows not yet supported for torch.compile)r z0Python 3.12+ not yet supported for torch.compile)rplatformrrr;r;r;r<check_if_dynamo_supporteds  rcCs"ztWdStyYdSw)NTF)r Exceptionr;r;r;r<is_dynamo_supporteds  rinductor)nopythonguard_export_fn guard_fail_fnrrcCstt||d}tjd|stjdddkrtSt |}t |dt }|r0t |||dSt tj||d|||t|d rE|d Sd d S) a The main entrypoint of TorchDynamo. Do graph capture and call backend() to optimize extracted graphs. Args: backend: One of the two things: - Either, a function/callable taking a torch.fx.GraphModule and example_inputs and returning a python callable that runs the graph faster. One can also provide additional context for the backend, like torch.jit.fuser("fuser2"), by setting the backend_ctx_ctor attribute. See AOTAutogradMemoryEfficientFusionWithContext for the usage. - Or, a string backend name in `torch._dynamo.list_backends()` nopython: If True, graph breaks will be errors and there will be a single whole-program graph. disable: If True, turn this decorator into a no-op dynamic: If True, upfront compile as dynamic a kernel as possible. If False, disable all dynamic shapes support (always specialize). If None, automatically detect when sizes vary and generate dynamic kernels upon recompile. Example Usage:: @torch._dynamo.optimize() def toy_example(a, b): ... r r ztorch._dynamo.optimizeTORCHDYNAMO_DISABLEr1r)rr)rrN)rr)rrrCrD_log_api_usage_onceosenvirongetrrrnroptimize_assertrr(rbr)backendrr r rrrrr;r;r<optimize$s.#    rz&torch._dynamo.symbolic_convert.explainTcs0fdd}|s |rtd||i|S|S)Nc sLddlm}|ggdggdfdd }fdd }ttd dt|d |d }||i|Wdn1sFwYt}i}D] }|jd } ||t| <qSd} t| D]\} } d t | j} | dd| j d| d}| |7} qi|d}tdd}|ddlm}||||S)Nrr~rgmtorch.fx.GraphModulecs,ddlm}||\}|jS)Nr)_explain_graph_detail)backends.debuggingrrZ)rexample_inputsr) break_reasonsgraphsop_count ops_per_graphr;r<"dynamo_graph_accumulating_compilerws  zBexplain..inner..dynamo_graph_accumulating_compilercs|dSrO)extendguards out_guardsr;r<guard_export_printsz2explain..inner..guard_export_print.most_recent_backendF)rr rz . Reason: z User Stack:  r)repr) ExplainOutputrr)rrrr7rrq user_stackr( enumeratevaluesr traceback format_listreasonr2rr))rsrtrrr$opt_f graph_countdeduped_reasonsr0innermost_frameformatted_listidx break_reasonformatted_stackmsggraph_break_count compile_timer)r)rrrrr#r<innerksV       zexplain..innerzexplain(f, *args, **kwargs) is deprecated, use explain(f)(*args, **kwargs) instead. If you don't migrate, we may break your explain call in the future if your user defined kwargs conflict with future kwargs added to explain(f).rr)r extra_args extra_kwargsr=r;r<r<explainis JrAcsBeZdZ ddfd d ZddZfddZfddZZS)FlattenInputOutputSignatureNmr flat_args Tuple[Any] matched_input_elements_positions List[int]!matched_output_elements_positionsexample_fake_inputsList[torch.Tensor] fake_mode$Optional[fake_tensor.FakeTensorMode]c st|fddt|D}g_tdt|D]7}td|di} ||vr5||| jjd<n|durLt ||t j rL| ||| jjd<j | qfdd|D_|_dS) Ncsi|] \}}||qSr;r;)ruixval)rIr;r< sz8FlattenInputOutputSignature.__init__..rargr;rNc3s|]}j|VqdSrO)new_argsruirer;r< sz7FlattenInputOutputSignature.__init__..)rPrQr,rQrangerq placeholdernodemetarYrCTensor from_tensorappend old_args_genrH) rUrCrDrFrHrIrKmatched_input_elements_to_fakerSrPrV)rIrUr<rQs  z$FlattenInputOutputSignature.__init__cCsNt|j}d|jjvr|jjd|jjd<d|jjvr%|jjd|jjd<|S)NrN tensor_dict)nextr\ current_noderXrW)rUtargetrsrtrPr;r;r<rVs   z'FlattenInputOutputSignature.placeholdercs<|d}g||jfdd|jD}t||fiS)Nrcsg|]}|qSr;r;rRlookupr;r<rysz6FlattenInputOutputSignature.output..)rQrHrPoutput)rUrarsrtdynamo_result_flatnew_result_flatrVrbr<rdsz"FlattenInputOutputSignature.outputcs6||_t|}d|jjvr|jjd|jjd<|S)NrN)r`rPrun_noderXrW)rUnrrVr;r<rgs   z$FlattenInputOutputSignature.run_noderO) rCrrDrErFrGrHrGrIrJrKrL)r7r8r9rQrVrdrgr|r;r;rVr<rBs  rBc@seZdZUded<ded<dS) ExportResultr graph_moduleSet[_guards.Guard]r!N)r7r8r9__annotations__r;r;r;r<rjs  rjc Csg}|jjD]j}|jdkrpt|dsJ|j}|j|}|dur"qt|dks*Jd}|D] }t|dkr7q.|}|durF|d}n%d t |}d} t|dkr`dt|dd} |d || }| |q|r~t tjd d |dS) NrV_dynamo_sourcerz, a closed over free variablerrz(elided z more accesses)z, accessed at: aCannot export model which references tensors that are neither buffers/parameters/constants nor are direct inputs. For each tensor, if you'd like this tensor to be an explicit input, add it as a dummy argument to the top-level model definition you are exporting; if you would like its value to be embedded as an exported constant, wrap its access in a function marked with @assume_constant_result. z )graphnodesoprbrn_source_to_user_stacksrrqrorr.r/r[r.r/ INVALID_INPUT) ro input_errorsrWsource user_stacksstacksr9tbextrar;r;r<check_signature_rewritables@      r{c Cst||\} } dd} | d|id|id} t|\} }|dus#J| t||dd| id}t||| |||}d d d }tt||| | |||j_ | |S) Nc Ss>ddd|D}dd|D}g}t}t|D] \}}||t|<q|D]o\}} t| D]f\}}t|tjr{t |dkr{t||vrV| |t|q5t| |vrj| |t| q5t |d|dt |d|t||vrt |d|dt |d|| |t|q5q-|S) Nz or cSs0g|]\}}|dddd|DdqS) (z, cSsg|]}tt|qSr;)rtype)rurPr;r;r<ry6szJrewrite_signature..produce_matching...))r)rudescrsr;r;r<ry5sz?rewrite_signature..produce_matching..cSsg|] }|D]}|qqSr;r;)rursrPr;r;r<ry:srz #r|z) is not among )ritemsr-rfr,idrYrCrYnumelr[itemAssertionErrorr}) sources candidates source_types source_argsmatched_elements_positionsdict_of_source_argsrSrPcandidate_desccandidate_argsr;r;r<produce_matching3s:  z+rewrite_signature..produce_matching original argszgraph-captured input)rr)zgraph-captured outputsrz traced resultrA List[str]csd dd}||jdt|}t|tjkr9jdus$Jd|fddtdt|t|D7}n&t|tjkr_jt|tjpLg D] }||vs^Jd |qQ|t|7}jD]}jppi}||vs||vsJd |qj|S) Nsiginspect.Signaturec Sst|j}dd|D}dd|D}tdd|Dd}tdd|Dd}tdd|D}dd |D}i}|jrCd |ji}|D]} | j|| j<qEt |||||||S) NcS g|] }|jtjjkr|jqSr;)kindr^ ParameterPOSITIONAL_OR_KEYWORDrorupr;r;r<ryvs z_rewrite_signature..argument_names..signature_to_fullargspec..cSrr;)rr^r KEYWORD_ONLYrorr;r;r<ry{scs$|] }|jtjjkr|jVqdSrO)rr^rVAR_POSITIONALrorr;r;r<rT"z^rewrite_signature..argument_names..signature_to_fullargspec..csrrO)rr^r VAR_KEYWORDrorr;r;r<rTrcss2|]}|jtjjkr|jtjjur|jVqdSrO)rr^rrdefaultemptyrr;r;r<rTscSs2i|]}|jtjjkr|jtjjur|j|jqSr;)rr^rrrrrorr;r;r<rOs z_rewrite_signature..argument_names..signature_to_fullargspec..rA) rH parametersr-r_tuplereturn_annotation annotationror^ FullArgSpec) rparamsrs kwonlyargsvarargsvarkwdefaultskwonlydefaultsr parameterr;r;r<signature_to_fullargspecrs:   zKrewrite_signature..argument_names..signature_to_fullargspeczMore arguments than expectedcsg|] }jd|qS)_)rrR fullargspecr;r<rysz=rewrite_signature..argument_names..rzMissing argument zMissing keyword only argument )rr) rsrqrrUrrHkeysrr)f_sigrsrtr input_strsunprovided_arg kwonly_argrr;rr<argument_namesqs* ,    z)rewrite_signature..argument_names)rAr) pytreetree_unflatten tree_flattenrHrB transformrrro_codegen recompile)rrorKrDin_specrIgraph_captured_inputgraph_captured_outputdynamo_traced_result orig_args orig_kwargsrrFflat_results_tracedout_spec_tracedrH new_graphrr;r;r<rewrite_signature&sD $  R rsymbolic) aten_graph pre_dispatchdecomposition_table tracing_mode constraintsrsame_signaturerCallable[..., Any]rrr9Optional[Dict[torch._ops.OpOverload, Callable[..., Any]]]rrrOptional[List[Constraint]]rrCallable[..., ExportResult]c sF||fdd} |s| r!td| |i| S| S)a Export an input function f to a format that can be executed outside of PyTorch using the FX graph. Args: f (callable): A PyTorch function to be exported. aten_graph (bool): If True, exports a graph with ATen operators. If False, exports a graph with Python operators. Default is False. pre_dispatch (bool): If True, exports a graph with ATen operators, but before any logic in the PyTorch dispatcher has run. This can be useful if you want to apply further transformations on a graph before running it through autograd, autocast, or any other functionalities that are integrated into the dispatcher. This flag is only valid if aten_graph=True is set. Default is False. decomposition_table (dict): A dictionary that maps operators to their decomposition functions. Required if aten_graph or tracing_mode is specified. Default is None. tracing_mode (str): If "symbolic", turn on dynamic shapes support. Default is "symbolic". same_signature (bool): If True, rewrite the returned graph's signature to be the same as f. Returns: A function that given args and kwargs, returns a tuple of (graph, guards) Graph: An FX graph representing the execution of the input PyTorch function with the provided arguments and options. Guards: The guards we accumulated during tracing f above Raises: AssertionError: If decomposition_table is specified without setting aten_graph=True, or if graph breaks during tracing in export. AssertionError: If Dynamo input and output is not consistent with traced input/output. Note - this headerdoc was authored by ChatGPT, with slight modifications by the author. c s}}ttjd dursJd rsJdt|}t|tjjr-|jn|}t |}dddddd&fdd }gd'fd d }t ||f\}} t |d} d krgd }ttddNtjd |dd d d4t|t|ddd d|} z | |i|} Wnty} z| } WYd} ~ nd} ~ wwWdn1swYWdn1swYt |tdd}dur?|j}dur?tt |s?||||}|}|rd|d|}| r| jd|f| _n|rt|} ntd||j !D]}t|t"j#r=td$t%&|j'|d|d} q!| rD| dusMJdt(dsUJdus^JdduseJ rlt)fddD}r݇fd d!}t*St+?,zt,| d"d dd#|Wnt-y} zt.t/j0t1| d} ~ wwWdn 1swYWdn 1swYWdn 1swY rt2||| ||  rd$d Dngj3d%<t4S)(Nztorch._dynamo.exportzaSpecifying a decomposition_table table or tracing mode is illegal without setting aten_graph=Truez7pre_dispatch=True can only be used when aten_graph=Truer!rlcsdusJd|dS)Nz3whole graph export entails exactly one guard exportr;r r"r;r<r$s z1export..inner..guard_export_printrrcs6dusJd|t|fdd}|S)Nz\Tried to emit a second graph during export. Tracing through 'f' must produce a single graph.c s|dusJtjdd}tjdd}t|dur$t|n}|Rt6it|t|}t}|D] \}}|j|dd||<q>t |j|}t j ||Wdn1sewYWdSWdS1s}wYS)NF)remove_duplicateT) static_shapes) rfnamed_parameters named_buffersrdetect_fake_moder3rrZrtree_maprCfuncfunctional_call) graph_inputsrrambient_fake_modeparams_and_buffersfake_params_buffersrovaluefake_graph_inputs)rKrorgraph_captured_resultr;r<result_capturing_wrapper3s>   ( zhexport..inner..dynamo_normalization_capturing_compiler..result_capturing_wrapper)rr)rinner_example_inputsr)rrKrorrr;r<'dynamo_normalization_capturing_compiler!s %zFexport..inner..dynamo_normalization_capturing_compilerrTr%F)specialize_intrr capture_dynamic_output_shape_opscapture_scalar_outputsr )rrexport_constraints shape_envzuSome dynamic dimensions need to be specialized because the constraints inferred for them are too complex to specify. r'rz#Summary of dimension constraints:%srzk It appears that you're trying to set a constraint on a value which we evaluated to have a static value of z1. Scroll up to see where this constraint was set.zZFailed to produce a graph during tracing. Tracing through 'f' must produce a single graph.rrz'Failed to produce guards during tracingcsg|]}|qSr;)rZ)rut)rKr;r<rysz)export..inner..csBtjjtjj|WdS1swYdSrO)rCrr.preserve_node_meta Interpreterrun)rs)ror;r<graph_with_interpreters$z5export..inner..graph_with_interpreterreal)rr_allow_non_fake_inputsr_allow_fake_constantcSsg|]}|jqSr;)serializable_spec)ru constraintr;r;r<rysinput_shape_constraints)r!rlr*)5rrCrDrrrYrrrZr^ signaturerrrrr7r'rrr5rndim_constraintsr*r]r_solve remove_redundant_dynamic_resultsprettify_resultsforced_specializationsrsrinfo var_to_rangersympyIntegerrr.r/ var_to_stackrbr{rr3rr,r.r/DYNAMIC_CONTROL_FLOWrrrXrj)rsrtrrcall_to_inspectoriginal_signaturer$rrDrconstraint_violation_errorr1 result_tracederrr9rkrIr_assume_static_by_default_frrrrrr)rrKrorrr#r<r=s   ;       zexport..innerzexport(f, *args, **kwargs) is deprecated, use export(f)(*args, **kwargs) instead. If you don't migrate, we may break your export call in the future if your user defined kwargs conflict with future kwargs added to export(f).r>) rrrrrrrrr?r@r=r;rr<rs3X)rrrrcCs2t|}t|dt}ttj|||d||||dS)zF The same as `torch._dynamo.optimize(backend, nopython=True)` r)rr)rr)rrnrrr(convert_frame_assert)rrrrrrr;r;r<rs rc@s.eZdZeedddZeddZdS)rNc Csddlm}|tjjtj_|tjjtj_|tjjtj_|tjjj jtjjj _tj j dddl m}m}m}m}m}m}m}m}m} m} m} m} m} ||||||||| | | | | h }||| | h}|D]8}|jdd}d|}d |}t||r||vrt|||t||t||rt|||t||qfd d tj j !D}tj j"tj j#tj j$h}|D]0}||vr||j%|_%t|d r||j&|_&t|j%d d}|rt|j%dd}|r||_%d|j%_'qtj(j)j*+tj(j)j*,tj(j)j-.dS)Nr)rFr) adadeltaadagradadamadamaxadamwasgdlbfgsnadamradamrmsproprpropsgd sparse_adam.r&_multi_tensor__fused_cSs(g|]}t|rt|tjjr|qSr;)r^isclass issubclassrCoptim Optimizer)ruoptr;r;r<ryLs z&TorchPatcher.patch.. _init_grouphooked __wrapped__T)/ decoratorsrrCjittrace trace_module_get_trace_graphrrTracer distributions Distributionset_default_validate_argsrrr r r r r rrrrrrrr7splitrbsetattrrnrgr- SparseAdamRAdamLBFGSsteprrrE variableslists"_register_dynamo_list_to_tree_spec#_register_dynamo_tuple_to_tree_specdicts"_register_dynamo_dict_to_tree_spec)rrr r r r r rrrrrrroptimizer_modules!disabled_multi_tensor_opt_modulesopt_modopt_namemulti_tensor_fn_name fused_fn_nameoptimizer_classesexcluded_optimizer_classesrrunwrapped_stepr;r;r<rs   <         zTorchPatcher.patchcsfdd}|S)Ncstjdtdd|i|S)Nignoreztorch.distributed)categorymodule)rfilterwarnings UserWarning)rsrtrr;r<inner_fnqszBTorchPatcher.suppress_torch_distributed_warnings..inner_fnr;)rrDr;rCr<#suppress_torch_distributed_warningsos z0TorchPatcher.suppress_torch_distributed_warnings)r7r8r9rr lru_cacherrEr;r;r;r<rs  kr)r?r@rArBr)rrrr)rr)r)rrrrrrrrrrrrrrrrrAr) __future__r contextlibrrr^loggingrrr threadingr.r[r collectionsrenumros.pathrrtypingrrr r r r r rrr unittest.mockrrCtorch.fxtorch.utils._pytreer+_pytreertorch.utils.checkpointrtorch._subclassesr torch.exportr"torch.fx.experimental.proxy_tensorrrtorch.fx.graphrrtorch.nn.parallel.distributedrrrbackends.registryrrrrtorch._C._dynamo.eval_framer r!r"r#r$r%dirrDrErFro startswithrnglobalsrr'r(r)r*excr,r-r.r/rr0r1r2 getLoggerr7rtorch._dispatch.pythonr3torch.utils._python_dispatchr4ExactWeakKeyDictionaryr nullcontextrr%torch.fx.experimental.symbolic_shapesr5r6r:rRLockrr=rmr___file__rr>rGrrrLrrrcontextmanagerrrrrrrrrrrrrrrA interpreter TransformerrBrjr{rrrrr;r;r;r<s  0       "           > ,)  ,    E V5*,