PhNKUddlZddlmZmZmZmZmZmZddlZddl m Z ddl Z ddl Z ddl mZmZmZmZmZGddZdZdZdd eefd Zdd eeee j.j0ffd Zej4dd eefd Zej4d ZGddeZdZdZdZ e GddZ!e GddZ"iZ#eee"fe$d<de"fdZ%dZ&y)N)OptionalUnionListSetDictAny) dataclass)_len_torch_dispatch_stack_get_dispatch_stack_at_pop_torch_dispatch_stack_push_on_torch_dispatch_stack DispatchKeyc<eZdZdZddZd dZdZdZedZ y) TorchDispatchModea A ``TorchDispatchMode`` allows you to override the meaning of all ``__torch_dispatch__`` overrideable functions within a dynamic scope, without having to actually create a tensor subclass or manually monkey-patch functions in the PyTorch API. Some common situations where you should use a mode: * You want to override the meaning of factory functions, or other functions that do not otherwise take a tensor as an argument (these cannot be overridden with tensor subclasses). * You want to override the behavior of all functions without needing to wrap your inputs in tensor subclasses; e.g., if you are just interested in logging intermediate computations. * You want to control the order of execution of various tensor subclasses explicitly, rather than implicitly via the return of ``NotImplemented``. Independent subclasses of :class:`TorchDispatchMode` are compositional: modes can be pushed onto a stack using ``with MyMode():``. When you call functions in the PyTorch API inside your ``__torch_dispatch__`` implementation, by default, they will forward on to the next mode on the mode stack. If you want recursively call back into your current ``__torch_dispatch__`` implementation, either explicitly invoke ``self.__torch_dispatch__(...)``, or use the context manager ``__torch_dispatch__(self)`` to make PyTorch API self-referential (beware of infinite loops, in this case!) Nct|6t|tjjsJ||jd<yyN _dispatch_key) isinstancetorch_Cr__dict__)selfrs gC:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\site-packages\torch/utils/_python_dispatch.py__init__zTorchDispatchMode.__init__1s5  $mUXX-A-AB BB-:DMM/ * %ctN)NotImplementedErrorrfunctypesargskwargss r__torch_dispatch__z$TorchDispatchMode.__torch_dispatch__6s !##rcRt||jjdd|Sr) _push_moderget)rs r __enter__zTorchDispatchMode.__enter__9s"4**?DAB rc|jjdd}||jjdd}t|y)Nr _mode_key)rr' _pop_mode)rexc_typeexc_valexc_tbmb_dk_or_mode_keys r__exit__zTorchDispatchMode.__exit__=sA MM--otD  $!% 1 1+t D #$rc@tjd||i|}|S)NzP`Mode.push()` is no longer necessary and can be replaced with just `with Mode()`)warningswarn)clsr"r#instances rpushzTorchDispatchMode.pushEs# hi''rrN) __name__ __module__ __qualname____doc__rr$r(r0 classmethodr6r8rrrrs/<; $%rrc>t}|dkDrt|dz SyNr)r r ) stack_lens r_get_current_dispatch_moderBKs#)+I1}%i!m44 rcdt}t|Dcgc] }t|c}Scc}wr)r ranger )rAis r _get_current_dispatch_mode_stackrFSs/)+I/4Y/? @/?! "1 %/? @@ @s-kc|Uddlm}m}tjj |}|D]}|D]}|j ||||yt|y)Nr)push_mode_for_keyget_cached_ops) torch._opsrIrJrr_functionality_to_backend_keys_uncache_dispatchr )moderGrIrJksopkeys rr&r&WsY}@XX 4 4Q 7 "B$$S)# !T"%d+rc|$t|tjjr t |Sddlm}||S)Nr)pop_mode_for_key)rrr_TorchDispatchModeKeyr rKrS)rGrSs rr+r+es5yJq%(("@"@A(+++ A rc#fKt|} |t||y#t||wxYwwr)r+r&)rGolds r_pop_mode_temporarilyrWos- A,C 3 3s 1 1.1c#Kt}t|Dcgc] }t}} |t|D] }t |ycc}w#t|D] }t |wxYwwr)r rDr+reversedr&)mode_len_ old_modesrNs r_disable_current_modesr]xsh(*H&+Ho6ooI6Y'D t ( 7 Y'D t (s%A3AA3A!A3A00A3ceZdZddZy)BaseTorchDispatchModeNc|i}||i|Srr8rs rr$z(BaseTorchDispatchMode.__torch_dispatch__s >FT$V$$rr7)r9r:r;r$r8rrr_r_s%rr_ct|tjxrt|tjk7}|xrt |dxr t |dS)a Returns whether or not a tensor subclass that implements __torch_dispatch__ is 'traceable' with torch.compile. In order for a tensor subclass to support TorchDispatchMode-style tracing in PT2, It must implement two magic methods: __tensor_flatten__ and __tensor_unflatten__. It is also expected to obey some restrictions around traceability and aliasing (TODO: add clear documentation around this.) __tensor_flatten____tensor_unflatten__)rrTensortypehasattr)t is_subclasss ris_traceable_wrapper_subclassrisFQ -I$q'U\\2IK  b71&:; bKa@bbrc|j\}}i}|D]}||t||||<t|j||S)a Given a traceable, wrapper tensor subclass ``t`` that implements ``__torch_dispatch__`` and holds some inner tensors, and a callback of type ``Callable[[str, torch.Tensor], torch.Tensor]``, `transform_subclass` will construct a fresh instance of the wrapper tensor subclass. It will do so by grabbing each inner tensor attribute from the wrapper, passing them into ``callback`` to get a transformed tensor, and putting each transformed tensor into the fresh tensor subclass instance. Note: this function will not handle ensuring that the fresh subclass gets the same (autograd, and aliasing) metadata as the original tensor. This is generally handled in other subsystems like AOTAutograd. )rbgetattrrerc)rgcallbackattrsctxtransformed_tensors_dictattrs rtransform_subclassrqsW%%'JE3!)1$48H)I & 7 ' '(@# FFrc*ttjjsJt|tsJt|t tfsJtj jj|}fd}d}tjj}tjj}t|D]E} t|D]5} ||j| |j| s'||| || 7Gy)a Given: an OpOverload, a SchemaInfo (cached information from torchgen about schema), and the inputs/outputs to the OpOverload, this function checks to see if func is a view operator (by checking if any of the outputs in the op's schema are immutable aliases of inputs). If so, this function manually aliases the storage of the output tensor with its corresponding input tensor alias. It does this by unsafely overwriting the storage field of the output tensor to be the same storage as the input. c ht|s t|r_t|tr|n|g}|D]E}t|t|k(rJdt dt|dt|dt j jj5t jj}t jjd t|trd|D]^}t jjjj||j!|j#|j$`nt|t j&sJdt|t jjjj||j!|j#|j$t jj| dddy#t jj|wxYw#1swYyxYw)NzCalled z with input of type z and output of type z. But expected types to match.Tztype: )rirlistrestrrutils _mode_utils no_dispatchr_meta_in_tls_dispatch_include!_set_meta_in_tls_dispatch_includeopsatenset_source_Storage_storage_offsetuntyped_storagestorage_offsetshaperd)argretret_listr meta_in_tlsr s ralias_non_inplace_storagez<_correct_storage_aliasing..alias_non_inplace_storages ) -1Ns1S(d3s#HCyDG+@T CWX\]`XaWbcI;<.@@+ [[ $ $ 0 0 2 ((@@BK HH 6 6t < Hc4(  ++II!SM`M`MbdedtdtdvxyxxA!&c5<<8NF49+:NN8IINN''EEc3K^K^K`bebtbtbvx{yByBC::;G+3 2*::;G+3 2s%>H(C=HH(!H%%H((H1cn|j|jz}t|dkDxr |j S)Nr) alias_setlenis_write)rrshared_aliasess ris_read_only_alias_matchz;_correct_storage_aliasing..is_read_only_alias_matchs06>"Q&;s||+;;rN)rr_ops OpOverloadtuplertrv_pytree tree_leavesr_schema argumentsreturnsrDr"outs) r schema_infor"r flat_outsrrnum_args num_returnsarg_idx return_idxs ` r_correct_storage_aliasingrs dEJJ11 22 2 dE "" " dT5M ** * ##//5I$HL<4<<))*Hdll**+K? ,J' (8(8(A;CSCST^C_`)$w-j9IJ-#rc8eZdZUeeed<eed<eeed<y) AliasInforrnameN)r9r:r;rru__annotations__boolrr8rrrrs3xN 3-rrc.eZdZUeeed<eeed<y) SchemaInfor"rN)r9r:r;rrrr8rrrrs y/ y/rrparsed_schema_mapreturnc0|tvr t|S|jdk(rt|j}|j dsJ|dd}ddl}|j dd|}|j dd|}|jd d }tjjj|}|jjDcgc]q}t|j t!nt!|jj"|jduxr|jj$|j& s}}|j(Dcgc]q}t|j t!nt!|jj"|jduxr|jj$|j& s}}n |jjDcgc]q}t|j* t!nt!|j*j,|j*duxr|j*j$|j& s}}|jj(Dcgc]q}t|j* t!nt!|j*j,|j*duxr|j*j$|j& s}}t/|| }|t|<|Scc}wcc}wcc}wcc}w) Nr|zaten::rz =\[[0, ]+\]z=0z =\[[1, ]+\]z=1z=[0, 1]z=[0,1])rrr)r"r)r namespacerur startswithresubreplacetorchgenmodelFunctionSchemaparserflat_allr annotationsetrrrr alias_info before_setr)r torchgen_schema_strrtorchgen_schemaa arg_schemas out_schemasrs rget_alias_infors    && ~~!$,,/"--h7772!"5!ff^T;NO ff^T;NO199)XN"..77==>QR #,,55 76a ! ||3ceQ\\=S=S9T\\-G!,,2G2G 6 7#** ,+a ! ||3ceQ\\=S=S9T\\-G!,,2G2G + ,<<)) +*a ! ||3ceQ\\=T=T9U\\-G!,,2G2G * +<<'' )(a ! ||3ceQ\\=T=T9U\\-G!,,2G2G ( ) +K@K)d 17 ,+ )s A6LA6L $A6L4A6Lc .t}dfd}t||t|ts|fn|tj j jvrt|Dcgc]\}}|j||}}}t|dk(sJddl m } t|d| stjjj5tj j#} tj j%d |i|tj j%|  dddt'fd|j(Ds|St+fd |j(Ds!t-d t/j0ztj0j2dk(r||j(d|||St5|t7t|j(|D cgc]0\\}} } | ||j(||||n| 2c} } }} | Scc}}w#tj j%| wxYw#1swYAxYwcc} } }w) aZ This function should be used by wrapper tensor ``__torch_dispatch__`` subclasses that would like to work with torch.compile. It ensures that the subclass properly implements the aliasing behavior of every op, which is needed for correctness in AOTAutograd. This function will handle: * When we see a view op, we will alias the storages of any input and output tensor subclasses * When we see an inplace or out= op, we will directly return the corresponding input tensor, instead of returning a (potentially) fresh output tensor. ct|jdk(ryt|j}t|dk(sJ|jr|dSyr?)rrrtr)xrs rget_write_aliasz4return_and_correct_aliasing..get_write_aliasAsJ q{{ q % 9~""" ::Q< rc|tjjj ||\}}t |j Dcgc]\}}||j vr|}}}t|dk(sJ|d} |j | } | j| j|vr|| jS|| Scc}}w)N)r"r#r@r) rfxoperator_schemasnormalize_function enumerater"rrr) output_aliasrr"r#new_args new_kwargsrEr arg_indicesidxarg_infor s rget_arg_from_aliasz7return_and_correct_aliasing..get_arg_from_aliasKs$xx88KKDW[djKk*$K$4$45 5$!Qq{{* 5  ;1$$$!n##C( == $*)Dhmm, ,} s B8Nr@r)FunctionalTensorTc32K|]}|duywrr8.0rrs r z.return_and_correct_aliasing..yH7G!q!-7Gc32K|]}|duywrr8rs rrz.return_and_correct_aliasing..}rrzUnsupported schema: )rrrrrTag inplace_viewtagsrr"r#torch._subclasses.functional_tensorrrvrwrxrryrzanyrall RuntimeErrorrurrrezip)r r"r#outrrrEr mutated_argsrrroouts_to_returnrs` @rreturn_and_correct_aliasingr-sI$!&K "dKZPSUZE[vade yy*'0ojodaIYIYZ[I\9]9io j< A%%% I,q/+;<((446$hhDDF ::4@L$)&)HH>>{K7 H{7G7GH H  H{7G7GH H1C 4EEFF 4<<   A%!/+2B2B12E"F UY[abbT#Yy)9)9:C@ AKVaQ 1  ) ?;+;+;A+>?dTZ[/0 1@ N Mk"HH>>{K760 s6+I I>JI$J5J !JJJ r)' contextlibtypingrrrrrrr2 dataclassesr rrtorch._Cr r r r rrrBrFr&rrTr+contextmanagerrWr]r_rirqrrrrrrrr8rrrs.88! JJ77rA ,- ,% UXX-K-K KLM Xk2   %-% cG(@KJ      ,.4Z(-+J+Z\r