tjQ` \ddlZddlZddlZddlmZmZmZddlmZm Z m Z ddl Z ddl m cmZddlZddl mZmZddlmZejGddZGdd Zd ed efd Zd ed eeeffdZd ed efdZded efdZded efdZ ded efdZ!dddeded efdZ"ded efdZ#ded efdZ$defdZ%dZ&dej'deedfd e(eefd eeej)effd!Z*d"Z+ded efd#Z,defd$Z-d efd%Z.d&Z/dej'fd'Z0dej'fd(Z1dej'd efd)Z2dej'd edzfd*Z3 dBdeed e(eefd,ed ee j4fd-Z5d.fd/Z6d0fd1Z7Gd2d3Z8d4e j4d e j4fd5Z9de j:jd efd6Z;dej'd eej?ej>j@ej>jAej>jBgZCe d8d9d:ed;e d8d ej>fd<ZDe d:ed;e dd ej>dzfd=ZDd8d9d>ZDe jEe jFe jGe jHe jIe jJe jKe jLe jMe jNe jOh ZPddd8d?dedeedfdzd e(eefdzd@ed ef dAZQdS)CN)CallableIterableIterator)AnyLiteraloverload)_C_utils_internal) OpOverloadc.eZdZUdZeed<eed<dZdS)Kernelz$Models a (function, source location)funcsourcec|j|i|SN)r)selfargskwargss R/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/torch/_library/utils.py__call__zKernel.__call__sty$)&)))N)__name__ __module__ __qualname____doc__r__annotations__strrrrr r s=.. NNN KKK*****rr c&eZdZdZdefdZddZdS)RegistrationHandlez2Does something when someone calls .destroy() on it on_destroyc||_dSr _on_destroy)rr!s r__init__zRegistrationHandle.__init__s%rreturnNc.|dSrr#)rs rdestroyzRegistrationHandle.destroy s r)r&N)rrrrrr%r(rrrr r sI<<&8&&&&rr stacklevelr&cttjtj|}|jd|j}|S)zGet a string that represents the caller. Example: "/path/to/foo.py:42" Use stacklevel=1 to get the caller's source Use stacklevel=2 to get the caller's caller's source etc. :)inspect getframeinfosys _getframefilenamelineno)r)framers r get_sourcer3$s:  z!:!: ; ;E / / / /F Mrqualnamec|d}t|dkrtd|d|d|dfS)Nz::zAExpected `qualname` to be of the form "namespace::name", but got zf. The qualname passed to the torch.library APIs must consist of a namespace and a name, e.g. aten::sinr)splitlen ValueError)r4splitss rparse_namespacer<2sb ^^D ! !F 6{{a 9*2 9 9 9   !9fQi rct|\}}d|vr|d\}}nd}ttj|}t||}t||S)N.default)r<r8getattrtorchops)r4 namespacenamernspackets r lookup_oprG>sf%h//OIt d{{Chh I & &B R  F 68 $ $$ropc|t|tstdt||jdvS)Nop must be OpOverload, got >atenprimprims) isinstancer AssertionErrortyperCrHs r is_builtinrRIs@ b* % %GE488EEFFF <4 44rc2tjj|jvS)zReturns True if the operator has "out" semantics: its mutable arguments are write-only output buffers that are not read from.)rATagouttagsrQs ris_outrWOs 9=BG ##rc2tjj|jvS)zpReturns True if the operator has inplace semantics: it mutates its first positional argument and returns it.)rArTinplacerVrQs r is_inplacerZUs 9  ''rF)allow_valid_viewschemar[c6fd}t|tjjr ||Sddlm}t|t r||}t||stdt|||S)afCheck if the schema is functional. An operator is functional if: - it does not mutate any of its inputs - If no view are allowed - it does not return a view on any of its inputs - If valid views are allowed - it is not a view or a view with a single input Tensor and single output Tensor - it has at least one return c|jrdS|j}t|dkotd|D}d}d}t |t jr]|jD]&}t |jt j r|dz }'|jD]&}t |jt j r|dz }'ntt |tj jrU|jj D] }|j r|dz }!|jD] }|j r|dz }!|r o |dko|dkS|jsdSdS)NFrc3BK|]}|jduo |jj VdSr) alias_infois_write).0rs r z>is_functional_schema..is_functional..ksG5 5 GHAL $ BQ\-B)B5 5 5 5 5 5 rr7T) is_mutablereturnsr9anyrNrAFunctionSchema argumentsrP TensorTypetorchgenmodel flat_non_outis_tensor_like) r\retsis_non_mutating_viewnum_tensor_inputsnum_tensor_outputsargretargumentret_argr[s r is_functionalz+is_functional_schema..is_functionalgs   5~"4yy1} 5 5 LP5 5 5 2 2  fe2 3 3 ,' + +ch(899+%*%~ , ,ch(899,&!+& , = > > ,",9 + +=//11+%*%!> , ,<..00,&!+&  #!Q&B+=+B ~ 5trr)rhz#schema must be FunctionSchema, got ) rNrAr rhtorchgen.modelrparserOrP)r\r[rwrhs ` ris_functional_schemarz[s"""""H&%(122%}V$$$.-----&#.%%f-- fn - -SQ4<<QQRRR =  rtypc 2|tjtjkp|tjtjtjkp|tjtjtjkpW|tjtjtjtjkSr)r ListTyperjget OptionalTyper{s ris_tensorlist_like_typers r{2=,,../// U "+bobm.?.?.A.ABBCC C U "/"+bm.?.?.A.A"B"BCC C U "/"+bobm>O>O>Q>Q.R.R"S"STT T rc|tjkp3|tjtjkSr)r rjr~rrs ris_tensor_like_typers= "-##%% % T @Q@Q@S@S0T0T)TTrcT|jdkrdS|j}t|jdkrdS|jdjdS|jdjj}t|dkrdSt t|}t|jdkrdS|jd}|jdS|jj sdS|jj}t|dkrdS|t t|krdS|jddD] }|jdS dS)aNCheck if an op is an inplace aten op, i.e. it mutates and returns the first arg. TODO: torchgen/model.py's FunctionSchema.parse is the source of truth for this, but not all PyTorch builds have torchgen (due to the yaml dependency being weird). Figure this out. Example: add_(Tensor(a!) x, Tensor y) -> Tensor(a) rKFr7rNT) rC_schemar9rfr` after_setnextiterrira)rHr\ alias_setloc first_argrss rmutates_and_returns_first_argrsC |vu ZF 6>au ~a#+uq!,6I 9~~u tI  C 6 q  u #I#u   (u$.I 9~~u d4 ??####u# > %55 & 4rcg}i}tt|jD]}|j|}|jr/|j|vr||j||j<5|j||j<E|t|kr|||t||jt||fSr)ranger9ri kwarg_onlyrD default_valueappendtuple)r\rrnew_args new_kwargsiinfos r fill_defaultsrsHJ 3v'(( ) ) 4 4" ? 4yF""(.ty(9 49%%(,(: 49%%3t99}}Q(((( 23333 ??J &&rr.rc #&Kt|jt|t|zkrEtdt|jdt|dt|dtt|jD]r}|j|}|jr|j|vr|||jfV1|t|kr"|js|j|vr|||jfVf|||fVsdS)zzips schema.arguments and (args, kwargs) together. Assumes that (args, kwargs) were the inputs to some torch._ops.OpOverload: that is, (args, kwargs) must be bindable to the schema (args, kwargs). z schema has z arguments but got z args and z kwargsN)r9rirOrrrD)r\rrrrs r zip_schemars; 6 s4yy3v;;666 m#f.// m mCII m mY\]cYdYd m m m   3v'(( ) )  " ? yF""F49-----  D >>? .tyF':':F49----- DGm Frcddlm}|j}t|tjjstddg}|jD]}t|tj j tj j j fr| |Vt|tj j jtt fr"| fd|Dtdt#|t%j|jj|}|}||jt!|jt|fS)Nr)FunctionSchemaGenzfx_node's target must be a hop.c|jdd}|A|jdkrtd|jt |jj|j}|S)Nvalget_attrz1node.op must be 'get_attr' when val is None, got )metar~rHrOr@graph owning_moduletarget)nodemeta_vals r_collect_example_valz5hop_schema_from_fx_node.._collect_example_valsf9==--  w*$$$SSStz7EEHrc&g|] }|Srr)rbxrs r z+hop_schema_from_fx_node..s%"H"H"Hq#7#7#:#:"H"H"HrzUnsupported arg type )torchgen.gen_schema_utilsrrrNrA_opsHigherOrderOperator RuntimeErrorrfxNoderrimmutable_collectionsimmutable_listlistrrPr, signaturerbind from_example_nameriitems)rrhopexample_inputsrs bound_argsexample_outputrs @rhop_schema_from_fx_noders;;;;;; +C c5:9 : :><===NyDD cEHM58=+=> ? ? D  ! !"6"6s";"; < < < <  %(0?uM   D  ! !"H"H"H"HC"H"H"H I I I IBtCyyBBCC C*N):3<)H)H)M *J *)$//N  ) ) 5-335566n9M9M8O  rc(t|tstdt|t |rdS|j}t |rdSt|rdS|jsdSt|j dkrdSdS)NrJFTr) rNr rOrPrRrrWrZrer9rf)rHr\s rcan_generate_trivial_fake_implr%s b* % %GE488EEFFF"~~u ZF bzzt"~~t  u 6>Qu 4rct|rQ|j}t|\}}tfd|D}t |dkr|dS|St |r|dSdS)zGenerate the result of a trivial fake impl for the given op. For ops with no returns: returns None. For Tag.out ops: returns the out= kwargs in declaration order. For Tag.inplace ops: returns the first positional arg. c3(K|] }|V dSrr)rbrDrs rrdz-generate_trivial_fake_impl..Fs'BB$BBBBBBrr7rN)rWrmutated_args_kwargsrr9rZ)rHrrr\_out_kwarg_namesout_argss ` rgenerate_trivial_fake_implr<sbzz088?BBBB/BBBBB x==A  A; "~~Aw 4rc.ttddS)zIf an op was defined in C++ and extended from Python using the torch.library APIs, returns if we require that there have been a m.set_python_module("mylib.ops") call from C++ that associates the C++ op with a python module. REQUIRES_SET_PYTHON_MODULET)r@r rrrrequires_set_python_modulerOs ?$@$ G GGrcFt|tjjjst dt |tjj|| f\}}d|D}| ||||S)Nz)curr_mode must be TorchDispatchMode, got cg|]q}t|tjtj|tjjjbt|rSr) rNrATensorr _dispatch_keyshas DispatchKeyPythonrPrbas rrz(handle_dispatch_mode..bsp a & & H # #A & & * *58+?+F G G  Qr) rNrAutils_python_dispatchTorchDispatchModerOrP_pytree tree_flattenvalues__torch_dispatch__) curr_mode op_overloadrrargs_flattenedroverload_typess rhandle_dispatch_moderXs i!=!O P P  IY I I    +88$ 9PQQNA N  ' ' ^T6 R RRrc>td|jDS)Nc3$K|] }|jV dSr)rrs rrdz&has_kwarg_only_args..ns$66q|666666rrgrir\s rhas_kwarg_only_argsrms" 66V%5666 6 66rc|jD]5}t|jst|js+|js3dSdS)NTF)rirrPrr)r\rs rhas_kwarg_only_tensorsrqsT  #AF++ /Fqv/N/N  |  tt 5rc>td|jDS)z Given a schema, returns True if the schema has a Tensor arg. A Tensor arg is any arg with a type annotation that might involve Tensor. c3fK|],}t|jpt|jV-dSr)rrPrrs rrdz!has_tensor_arg..sP  QV $ $ G(?(G(Grrrs rhas_tensor_argr{s5 !  rct|jD]9\}}|jtjur|jdkr|cS:dS)zx Given a schema, returns the id of the `device: torch.device` argument. If it does not exist, returns None. deviceN) enumeraterirPr DeviceObjTyper~rD)r\indexrss rget_device_arg_indexrsY   011 s 8r'++-- - -#(h2F2FLLL 4rr7allowed_nestingc#Kfd}|D]}||Ed{V|D]}||Ed{VdS)Nc3Kt|tjr|VdSdkrEt|ttfr+t t|idz Ed{VdSdSdS)Nrr7)rNrArrr iter_tensors)rsrs rcheckziter_tensors..checks c5< ( ( IIIIII q ZeT]%C%C #E#JJOa4GHH H H H H H H H H H! r)r)rrrrrskwargs ` rrrsIIIII 5::  5<<  rcdSNz???rrrrrsUrcDd|D}|}t|ts|f}t|iD]h}|j}|j|vrt |d|d||idS)zO custom operators' outputs must not alias any inputs or other outputs. cth|]5}t|tj|j6Sr)rNrAruntyped_storage_cdata)rbts r z,check_aliasing_constraint..s8XXXqJq%,.s@   HIjEL99 CKNNNt   r)rH args_spec flat_argsreal_pre_hashes)rrHrrs rr%zMutationChecker.__init__s>""  MV   rcdjD}dtj|D}tj|j\}}t jj||D]^\}}fd}t|j r |||+t|j r|dnt|}|||_dS)Ncdg|]-}t|tjrt|nd.Srrrs rrz)MutationChecker.check..sC   )EL99 CKNNNt   rcFg|]\}}t|tjr}t|tjrctj|| oL|o%| ndSr)rNrArequalisnanall)rbpreposts rrz)MutationChecker.check..s   T#u|,, 1;D%,1O1O  C&& & ?YY[[__&&=4::<<+;+;+=+=>    rc |j|krdStjjd|jdjjd|jrdndd)Nz: for argument 'z': the operator's schema z specified that the operator mutateszdoes not mutatea* the argument, but this seems to be empirically wrong. Please make the schema and operator behavior consistent. You can specify that an operator mutates a Tensor by e.g. changing its schema type from 'Tensor name' to 'Tensor(a!) name'(use different identifiers (a, b, c, ...) for different Tensors))rarrHrrDr)r was_mutatedrs r check_onez(MutationChecker.check..check_ones~=K//F"w}XXdiXXwXX15$UIIDUXXX   rF) rziprpytreetree_unflattenrrrHrrrPrrg)rreal_post_hashesrwas_mutated_argswas_mutated_kwargsrrwas_any_mutateds` rrzMutationChecker.checks(  ^     !!57GHH    06/D 0 0 ,,", GO-/A" "  1 1 D+     #49-- 1 $ ,,,,(33 1+6+>%%C DTDT $000- 1 1rN)rrrrr%rrrrr r s<   %1%1%1%1%1rr rcr|S)zNSome inexpensive hash. Used as a quick and dirty indicator for tensor mutation)detachfloatmean)rs rrr s( 88::     " " $ $$rct|rdS|j}tj|drdStjj|}||tj|drdStjjj |}|j j dStj|drdSn |j dSdS)zIf an operator (that stays alive until FakeTensorMode) has a Fake kernel. Don't use this if the operator decomposes before FakeTensorMode. TCompositeImplicitAutogradNCompositeExplicitAutogradMetaF)rrrAr %_dispatch_has_kernel_for_dispatch_key_library custom_ops_maybe_get_opdefsimple_registry singletonfind fake_implkernel _abstract_fn)rHrDopdefentrys rhas_fake_kernelr;s&b))t 8D x55 )t N % 6 6t < >JJJ Q b>> *6) )++++++ux|V%OPPP 4rrr impure_randomrMcddlm}ddlm}t |t jjr,||vrdSt|dd}|t||||St |t jj r/t|dd}| |j rdS||vrdS||dSt |t jj rb|t j jjt j jjfvr|rt#|dkr |d|vS||dS||vrdSd S|rt|d d rdS|t$vrdSt|dd}| |j rdS||vrdSd S) a An operator is impure if it: - Mutates its inputs (has a mutable schema) - Has nondeterministic/random behavior that mutates RNG state - Is explicitly marked as effectful via torch.library._register_effectful_op Args: op: The operator to check (function, OpOverload, HigherOrderOperator, etc.) args: Optional arguments that would be passed to the callable kwargs: Optional keyword arguments that would be passed to the callable impure_random: Whether to treat random operations as impure (default: True) Returns: bool: True if the callable has side effects, False otherwise r) _get_effect)_side_effectful_functionsTr?NrLrF_nondeterministic_seeded)torch._higher_order_ops.effectsrO torch.fx.noderPrNrArOpOverloadPacketr@ is_impurer rerrB higher_orderauto_functionalizedauto_functionalized_v2r9_RANDOM_FUNCTIONS)rHrrrMrOrPr?r\s rrUrUps.<;;;;;777777"ej122 * * *4"i..  d6 "ej+,, Y--  &"3 4 * * *4 ;r?? &4"ej455 I " 6 I " 9    <D A Aw";;; ;r?? &4 * * *4u%?GGt t RD ) )F f/t &&&t 5r)r7)R dataclassesr,r.collections.abcrrrtypingrrrrAtorch.utils._pytreerrr!rkr r torch._opsr dataclassr r intrr3rr<rGboolrRrWrZrzrrrrrhdictArgumentrrrrrrrrrrrrrr r rrr;rrrTneeds_exact_stridesneeds_contiguous_stridesneeds_fixed_stride_orderrHrGrCrandrandnrandintrandperm rand_like randn_like randint_likenormalpoisson bernoulli multinomialrYrUrrrrrs 8888888888)))))))))) $$$$$$$$$%%%%%%%%!!!!!! ******** 3 3      c  eCHo     %% %%%%5:5$5555 $z$d$$$$ (:($(((( CH:!:!:!:!4:!D:!:!:!:!|USUTUUUU#j####L'''$   %*38_ >B38n  eBK$%&    :&&&Rzd.:&HDHHHHSSS*7 177772#42,!2sTzFG   *  "38n  ?B   el     >K]4IV     27171717171717171t%5<%EL%%%%  -$<  1 eDItCy