U ʹj @sjUddlmZddlZddlZddlZddlZddlZddlZddlZddl 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@mAZAmBZBmCZCnd>e|Zd?d@ZdAdBdCdDZedd1ddfdAdBdEdFZdGdHZGdIdJdJejcZdKdLZdMdNZdod1ddd1ddPdQdRZe!dSdTdUdVZGdWdXdXe"j6jjZGdYdZdZeZd[d\Zd]d^Zd1d1dd_dd1dTd`dad3d3dbdcddd3d3dedf dgdhZe_make)r?Z cache_listr;r;r<rEesrEcsZeZdZdZddfdd 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. ztorch.nn.Module)modcs"t||_||_|dSN)super__init__ _orig_mod dynamo_ctx _initialize)selfrJrO __class__r;r<rMss zOptimizedModule.__init__cCsjt|jjtjr:tt|jjr:| t |j|_n| |jj |_t |jdrf|j|_|j|_dS)N_initialize_hook) isinstancerNforwardtypes MethodTyper*checkinspect getsourcefilerOr) wrap_inline__call__hasattr_forward_call_lazy_checkrQr;r;r<rPzs  zOptimizedModule._initializecCs&t|j}|dd|dd|S)NrVr])dict__dict__poprQstater;r;r< __getstate__s   zOptimizedModule.__getstate__cCs||_|dSrK)rcrPrer;r;r< __setstate__szOptimizedModule.__setstate__cCs|dkr|jdSt|j|S)NrN)Z_modulesgetattrrN)rQnamer;r;r< __getattr__s zOptimizedModule.__getattr__cOs8t|jdr,t|dkst|j|j||j||S)NrTr)r^rNlenAssertionErrorZ_infer_parametersr_)rQargskwargsr;r;r<r`s z OptimizedModule._call_lazy_checkcs&|jfddtDS)Ncsg|]}|kr|qSr;r;).0attrZorig_mod_attrsr;r< sz+OptimizedModule.__dir__..)rN__dir__rLrarRrrr<rts  zOptimizedModule.__dir__) r7r8r9__doc__rMrPrgrhrkr`rt __classcell__r;r;rRr<rIms rIcCsnt|tjrt|nTt|dr,t|jn>tt|dddrLt|jjnddlm }|t d|dS)zA Make sure f.__code__ is not cached to force a recompile __code__rVNrresetz#could not determine __code__ for %s) rUrWCodeTyper r^rwrirVrylogwarning)fryr;r;r<remove_from_caches     rcCsdSrKr;r;r;r;r<nothingsrcCs&|}t|dr"|j}t|stq|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)r^rcallablerm)fnZ unaltered_fnr;r;r< innermost_fns  rFzOptional[bool]boolenableexportc csX|dkrdVnD|r4tjdd dVW5QRXn tjddd dVW5QRXdS)NF)assume_static_by_defaultT)automatic_dynamic_shapesr)r'rrr;r;r<enable_dynamicsrcsNeZdZeeedfddddddfddZdd Zd d Zd d ZZ S)_TorchDynamoContextFNrdynamiccompiler_configr1callbackc s`tt|s&|dks&|dks&t||_t|_||_||_||_ ||_ ||_ ||_ |dSNF) rLrMrrmrunsetprioron_enterextra_ctx_ctor first_ctxrrr) rQrrbackend_ctx_ctorpatch_fnrrrrrRr;r<rMs 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'Zraise_on_ctx_manager_usage RuntimeErrorrr!rrr backend_ctx __enter__rrr dynamic_ctxrar;r;r<rs   z_TorchDynamoContext.__enter__cCsB|jtk stt|jt|_|j||||j|||dSrK)rrrmr!r__exit__r)rQexc_typeexc_valexc_tbr;r;r<rs  z_TorchDynamoContext.__exit__csNfdd}tttjjrP}t|}|j|_t|drFt ||_ |St s\t zt }Wntk rd}YnX|dkst|rtdddkr|tkrtjjjtfdd}ttrd |_n|_|_t|drt ||_ d krJtd s@ttd d t j!<|S) NcsjSrK)rr;rar;r<get_compiler_config sz9_TorchDynamoContext.__call__..get_compiler_configrr7r{)Z _call_implZ_wrapped_call_implc stts0tjjr0tjr&tdn ||St }}| t j j }| z||WSt ||ddd|dddXdS)NzvDetected that you are using FX to symbolically trace a dynamo-optimized function. This is not supported at the moment.)rUDisableContextrAfx_symbolic_traceZ is_fx_tracingr'Zerror_on_nested_fx_tracerr!rrrrr)rnrorrrrrrrrQr;r<_fn3s(  z)_TorchDynamoContext.__call__.._fnTrrwa 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) )"rrUrAnnModulerIrVrr^rmrrrZr[ TypeErrorr*rYriDONT_WRAP_FILESr)r\rrr functoolswrapsrZ_torchdynamo_disableZ_torchdynamo_inlinertextwrapdedentalways_optimize_code_objectsrw)rQrrrJnew_modfilenamerr;rr<r] sV        ! z_TorchDynamoContext.__call__) r7r8r9r null_contextrMrrr]rvr;r;rRr<rsrcs4eZdZeddZdddddfdd ZZS) OptimizeContextcCs||kp|dk SrKr;)oldnewr;r;r<_different_backendsz"OptimizeContext._different_backendFNrc s6fdd}t|tj|||tj||||ddS)Ncs2ttr$tjrtn tdatdS)Nz`changing options to `torch.compile()` may require calling `torch._dynamo.reset()` to take effect) rrr=r'Zraise_on_backend_changer-warningswarnr0r; compiler_fnr;r<rs z*OptimizeContext.__init__..on_enter)rrrrrrrr)rrLrM TorchPatcherr)rQrrrrrrrrRrr<rMs zOptimizeContext.__init__)F)r7r8r9 staticmethodrrMrvr;r;rRr<rs rcseZdZfddZZS)RunOnlyContextcsdd}tjd|ddS)NcSstjjjjd7_dS)Nr)rArCmutation_guardZGenerationTrackerZ generationr;r;r;r<rsz)RunOnlyContext.__init__..on_enterF)rrrLrM)rQrrRr;r<rMszRunOnlyContext.__init__r7r8r9rMrvr;r;rRr<rsrcseZdZfddZZS)rcstjdddS)NrrrarRr;r<rMszDisableContext.__init__rr;r;rRr<rsrcCsBtjdkrdSt|D]}|jdkr|jdSqtddS)N) rRESUMErz$RESUME instruction not found in code)sys version_infodisget_instructionsopnameoffsetr)r?instr;r;r<first_real_inst_idxs   rrhookscs"tfdd}|_|S)Nc s |dk s t|jt|jks0t|jjs0tjrJt d|jj |jjdS|jjdkrf|jj dkrfdStj rt }|rtVddlm}||jjd}tdstd|j}||||W5QRSQRXt:t(|||W5QRW5QRSQRXW5QRXdS) Nzskipping %s %sz__new__r) DDPOptimizer)bucket_bytes_capZbackend_compile_fn_clone_with_backendzJDDPOptimizer only supports callback fns that know how to clone themselves.)rmf_lastirf_coder*rY co_filenamer'disabler|debugco_nameZ optimize_ddprZ_get_active_ddp_module compile_lockZ"torch._dynamo.backends.distributedrrrr^r compile_fnr4)frame cache_entryZ frame_stateZ ddp_modulerZ ddp_optimizerZhijacked_callbackrrr;r< catch_errorss@    z*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}nt|tr.|}nd}t|}|||S)Nr)wrap_backend_debug compiler_name)Zrepro.after_dynamorr^rrUstrr)rrZ compiler_strr;r;r<get_compiler_fns   rc@seZdZddZdS)_NullDecoratorcCst|s t|SrK)rrm)rQrr;r;r<r]s z_NullDecorator.__call__N)r7r8r9r]r;r;r;r<rsrcCs(tjdkrtdtjdkr$tddS)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(z tWdStk r"YdSXdS)NTF)r Exceptionr;r;r;r<is_dynamo_supporteds rinductor)nopythonguard_export_fn guard_fail_fnrrcCstt||d}tjd|s4tjdddkr:tSt |}t |dt }|r`t |||dSt tj||d|||t|d r|nd 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): ... rrztorch._dynamo.optimizeZTORCHDYNAMO_DISABLEr{1r)rrrrN)rr)rrrArB_log_api_usage_onceosenvirongetrrriroptimize_assertrr(r^r)backendrrrrrrrr;r;r<optimize$s,#     rz&torch._dynamo.symbolic_convert.explainTcs0fdd}|s|r(td|||S|SdS)Nc s8ddlm}|ggdggddfdd }fdd }ttd d"t|d |d }|||W5QRXt}i}D]}|jd } ||t| <qd} t| D]>\} } d t | j} | dd| j d| d}| |7} q|d}tdd}|ddlm}||||S)Nrrxrtorch.fx.GraphModulegmcs,ddlm}||\}|jS)Nr)_explain_graph_detail)backends.debuggingrrV)rexample_inputsr) break_reasonsgraphsop_count ops_per_graphr;r<"dynamo_graph_accumulating_compilerws zBexplain..inner..dynamo_graph_accumulating_compilercs|dSrK)extendguards out_guardsr;r<guard_export_printsz2explain..inner..guard_export_print.most_recent_backendF)rrr{z . Reason: z User Stack:  r)repr) ExplainOutput)r{ryrr7rrlZ user_stackr  enumeratevaluesr traceback format_listreasonr2rr)rnroryrr opt_fZ graph_countZdeduped_reasonsrZinnermost_frameZformatted_listidxZ break_reasonZformatted_stackmsgZgraph_break_countZ compile_timerr~)rrrrrr<innerksT      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_kwargsrr;rr<explainis J rcsNeZdZddddddddfdd Zd d Zfd d ZfddZZS)FlattenInputOutputSignatureNrz Tuple[Any]z List[int]zList[torch.Tensor]z$Optional[fake_tensor.FakeTensorMode])m flat_args matched_input_elements_positions!matched_output_elements_positionsexample_fake_inputs fake_modec st|fddt|D}g_tdt|D]n}td|di} ||krj||| jjd<n.|dk rt ||t j r| ||| jjd<j | q6fdd|D_|_dS) Ncsi|]\}}||qSr;r;)rpZixval)r"r;r< sz8FlattenInputOutputSignature.__init__..rargr;r$c3s|]}j|VqdSrK)new_argsrpirar;r< sz7FlattenInputOutputSignature.__init__..)rLrMrr'rangerl placeholdernodemetarUrATensor from_tensorappend old_args_genr!) rQrrr r!r"r#Zmatched_input_elements_to_faker)r&rR)r"rQr<rMs  z$FlattenInputOutputSignature.__init__cCsNt|j}d|jjkr*|jjd|jjd<d|jjkrJ|jjd|jjd<|S)Nr$Z tensor_dict)nextr2 current_noder.r-)rQtargetrnror&r;r;r<r,s    z'FlattenInputOutputSignature.placeholdercs8|d}||jfdd|jD}t||fiS)Nrcsg|] }|qSr;r;r(lookupr;r<rssz6FlattenInputOutputSignature.output..)r'r!rLoutput)rQr5rnroZdynamo_result_flatZnew_result_flatrRr6r<r8s z"FlattenInputOutputSignature.outputcs6||_t|}d|jjkr2|jjd|jjd<|S)Nr$)r4rLrun_noder.r-)rQnrrRr;r<r9s   z$FlattenInputOutputSignature.run_node)N)r7r8r9rMr,r8r9rvr;r;rRr<rs  rc@seZdZUded<ded<dS) ExportResultrZ graph_moduleSet[_guards.Guard]rN)r7r8r9__annotations__r;r;r;r<r<s r<c Csg}|jjD]}|jdkr t|ds(t|j}|j|}|dkrDq t|dksTtd}|D]}t|dkrnq\|}qxq\|dkr| d}nJd t |}d} t|dkrdt|dd} | d || }| |q |rttjd d |dS) Nr,_dynamo_sourcerz, a closed over free variabler{rz(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 )graphZnodesopr^rmr?_source_to_user_stacksrrlrjrrrr1r.r/Z INVALID_INPUT) r@Z input_errorsr-sourceZ user_stacksstacksrtbextrar;r;r<check_signature_rewritables<      rHc Cst||\} } dd} | d|id|id} t|\} }|dk sFt| t||dd| id}t||| |||}dd d d }tt||| | |||j _ | |S) Nc SsBddd|D}dd|D}g}t}t|D]\}}||t|<q<|D]\}} t| D]\}}t|tjrt |dkrt||kr| |t|nJt| |kr| |t| n"t |d|dt |d|qjt||kr(t |d|dt |d|| |t|qjqZ|S) Nz or cSs0g|](\}}|dddd|DdqS) (z, cSsg|]}tt|qSr;)rtype)rpr&r;r;r<rs6szJrewrite_signature..produce_matching...))r)rpdescrnr;r;r<rs5sz?rewrite_signature..produce_matching..cSsg|]}|D]}|q qSr;r;)rprnr&r;r;r<rs:srz #rIz) is not among )ritemsrrbridrUrAr/Znumelr1itemrmrJ) sources candidatesZ source_typesZ source_argsZmatched_elements_positionsZdict_of_source_argsr)r&Zcandidate_descZcandidate_argsr;r;r<produce_matching3s8 z+rewrite_signature..produce_matching original argszgraph-captured input)rPrQ)zgraph-captured outputsrSz traced resultz List[str])r@cs dddd}||jdt|}t|tjkrvjdk sLtd|fddtdt|t|D7}nLt|tjkrˆjt|tjpg D]}||kstd |q|t|7}jD],}j pi}||ks||kstd |q|S) Nzinspect.Signature)sigc Sst|j}dd|D}dd|D}tdd|Dd}tdd|Dd}tdd|D}dd |D}i}|jrd |ji}|D]} | j|| j<qt |||||||S) NcSs g|]}|jtjjkr|jqSr;)kindrZ ParameterPOSITIONAL_OR_KEYWORDrjrppr;r;r<rsvsz_rewrite_signature..argument_names..signature_to_fullargspec..cSs g|]}|jtjjkr|jqSr;)rUrZrV KEYWORD_ONLYrjrXr;r;r<rs{scss"|]}|jtjjkr|jVqdSrK)rUrZrVVAR_POSITIONALrjrXr;r;r<r*sz^rewrite_signature..argument_names..signature_to_fullargspec..css"|]}|jtjjkr|jVqdSrK)rUrZrV VAR_KEYWORDrjrXr;r;r<r*scss0|](}|jtjjkr|jtjjk r|jVqdSrK)rUrZrVrWdefaultemptyrXr;r;r<r*scSs2i|]*}|jtjjkr|jtjjk r|j|jqSr;)rUrZrVrZr]r^rjrXr;r;r<r%s z_rewrite_signature..argument_names..signature_to_fullargspec..r@) rF parametersrr3tuplereturn_annotation annotationrjrZ FullArgSpec) rTparamsrn kwonlyargsvarargsvarkwdefaultskwonlydefaultsrZ parameterr;r;r<signature_to_fullargspecrsF   zKrewrite_signature..argument_names..signature_to_fullargspeczMore arguments than expectedcsg|]}jd|qS)_)rfr(Z fullargspecr;r<rssz=rewrite_signature..argument_names..rzMissing argument zMissing keyword only argument ) rnrlrfrmr+rhrFkeysreri)f_sigrnrorjZ input_strsZunprovided_argZ kwonly_argrir;rlr<argument_namesqs0,     z)rewrite_signature..argument_names) pytreeZtree_unflatten tree_flattenrmrFrZ transformrrr@Z_codegenZ recompile)rnr@r#rin_specr"graph_captured_inputZgraph_captured_outputZdynamo_traced_result orig_argsZ orig_kwargsrRr Zflat_results_tracedZout_spec_tracedr!Z new_graphror;r;r<rewrite_signature&s@ $  R rusymbolic) aten_graph pre_dispatchdecomposition_table tracing_mode constraintsrsame_signaturezCallable[..., Any]z9Optional[Dict[torch._ops.OpOverload, Callable[..., Any]]]rzOptional[List[Constraint]]zCallable[..., ExportResult]) r~rwrxryrzr{rr|r@c sF||fdd} |s*| r>td| || S| SdS)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 dk r.s.td r>s>tdt|}t|tjjrZ|j n|}t |}dddddddfdd }gdd fd d }t ||f\}} t|d} d krd }ttddztjd |dd d dZt|t|ddd d|} z| ||} Wn(tk rP} z| } W5d} ~ XYnXW5QRXW5QRXt|tdd}dk rZ|j}dk rZtt |sZ||||}|}|rd|d|}| r| jd|f| _n|rt|} n t d||j!"D]:}t|t#j$rtd%t&'|j(|d|d} q| rd| dk svtdt)dstdk stddk st rt*fddD}r^fd d!}t+zt,hXzt-| d"d dd#|Wn4t.k r>} zt/t0j1t2| W5d} ~ XYnXW5QRXW5QRXW5QRX r|t3||| ||  rd$d Dngj4d%<t5S)&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=rcsdkstd|dS)Nz3whole graph export entails exactly one guard export)rmrrr;r<r s z1export..inner..guard_export_printrrcs6dkstd|t|fdd}|S)Nz\Tried to emit a second graph during export. Tracing through 'f' must produce a single graph.c s|dk sttjdd}tjdd}t|dk rHt|n}|pt^t|t|}t}|D]\}}|j|dd||<qxt |j|}t j ||W5QRXW5QRXS)NF)Zremove_duplicateT)Z static_shapes)rmrbnamed_parameters named_buffersrdetect_fake_moder3rMr0rpZtree_maprAfuncZfunctional_call) Z graph_inputsr}r~Zambient_fake_modeZparams_and_buffersZfake_params_buffersrjvalueZfake_graph_inputs)r#r@rsgraph_captured_resultr;r<result_capturing_wrapper3s8   zhexport..inner..dynamo_normalization_capturing_compiler..result_capturing_wrapper)rmrr)rZinner_example_inputsr)rr#r@rsrr;r<'dynamo_normalization_capturing_compiler!s%zFexport..inner..dynamo_normalization_capturing_compilerrvTr F)Zspecialize_intrrZ capture_dynamic_output_shape_opsZcapture_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:%sr{zk 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.rBz'Failed to produce guards during tracingcsg|]}|qSr;)r0)rpt)r#r;r<rssz)export..inner..c s6tjj tjj|W5QRSQRXdSrK)rArrZpreserve_node_metaZ Interpreterrun)rn)r@r;r<graph_with_interpretersz5export..inner..graph_with_interpreterreal)ryrzZ_allow_non_fake_inputsrxZ_allow_fake_constantcSsg|] }|jqSr;)Zserializable_spec)rp constraintr;r;r<rssZinput_shape_constraints)6rrArBrrmrrUrrrVrZ signaturerprqrrr7r'rrr5ridim_constraintsr*rYr[ZsolveZ remove_redundant_dynamic_resultsZprettify_resultsforced_specializationsrnr|infoZ var_to_rangermsympyIntegerrrrZ var_to_stackr^rHrr3rr,r.r/ZDYNAMIC_CONTROL_FLOWrrur.r<)rnror~rZcall_to_inspectZoriginal_signaturer rrrrZconstraint_violation_errorrZ result_tracederrrrkr"rZ_assume_static_by_default_frwr{ryrxr|rz)rr#r@rsrrr<rs   ; *      @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).Nr) r~rwrxryrzr{rr|rrrr;rr<rs3X r)rrrrcCs2t|}t|dt}ttj|||d||||dS)zF The same as `torch._dynamo.optimize(backend, nopython=True)` r)rr)rr)rrirrr(Zconvert_frame_assert)rrrrrrr;r;r<rs  rc@s.eZdZeedddZeddZdS)rNc Cs ddlm}|tjjtj_|tjjtj_|tjjtj_|tjjj jtjjj _tj j dddl m}m}m}m}m}m}m}m}m} m} m} m} m} ||||||||| | | | | h }||| | h}|D]t}|jdd}d|}d |}t||r ||kr t|||t||t||rt|||t||qd d tj j !D}tj j"tj j#tj j$h}|D]j}||kr||j%|_%t|d r||j&|_&t|j%d d}|rt|j%dd}|r||_%d|j%_'qrtj(j)j*+tj(j)j*,tj(j)j-.dS)Nr)rFr) adadeltaadagradadamadamaxadamwasgdlbfgsnadamradamrmsproprpropsgd sparse_adam.r Z_multi_tensor_Z_fused_cSs(g|] }t|rt|tjjr|qSr;)rZisclass issubclassrAoptimZ Optimizer)rpoptr;r;r<rsLs z&TorchPatcher.patch.. _init_grouphooked __wrapped__T)/Z decoratorsrrAZjittraceZ trace_moduleZ_get_trace_graphrrZTracer distributions DistributionZset_default_validate_argsrrrrrrrrrrrrrrr7splitr^setattrrircrZ SparseAdamZRAdamZLBFGSsteprrrC variableslistsZ"_register_dynamo_list_to_tree_specZ#_register_dynamo_tuple_to_tree_specZdictsZ"_register_dynamo_dict_to_tree_spec)rrrrrrrrrrrrrrZoptimizer_modulesZ!disabled_multi_tensor_opt_modulesZopt_modopt_nameZmulti_tensor_fn_nameZ fused_fn_nameZoptimizer_classesZexcluded_optimizer_classesrrZunwrapped_stepr;r;r<rs  <           zTorchPatcher.patchcsfdd}|S)Ncstjdtdd||S)Nignoreztorch.distributed)categorymodule)rfilterwarnings UserWarning)rnrorr;r<inner_fnqs zBTorchPatcher.suppress_torch_distributed_warnings..inner_fnr;)rrr;rr<#suppress_torch_distributed_warningsos z0TorchPatcher.suppress_torch_distributed_warnings)r7r8r9rr lru_cacherrr;r;r;r<rs  kr)NF)r) __future__r contextlibrrrZloggingrrr threadingrrWr collectionsrenumros.pathrrtypingrrr r r r r rrrZ unittest.mockrrAZtorch.fxZtorch.utils._pytreer+Z_pytreerpZtorch.utils.checkpointrZtorch._subclassesrZ torch.exportrZ"torch.fx.experimental.proxy_tensorrrZtorch.fx.graphrrZtorch.nn.parallel.distributedrrrZbackends.registryrrrrZtorch._C._dynamo.eval_framer r!r"r#r$r%dirrBrCrDrj startswithriglobalsr{r'r(r)r*excr,r-r.r/rr0r1r2 getLoggerr7r|Ztorch._dispatch.pythonr3Ztorch.utils._python_dispatchr4ZExactWeakKeyDictionaryr nullcontextrrZ%torch.fx.experimental.symbolic_shapesr5r6r:rRLockrr=r>r[__file__rr>rErrrIrrrcontextmanagerrrrrrrrrrrrrrr interpreterZ Transformerrr<rHrurrrr;r;r;r<s   0       "           > ,)  ,   E V5*,"