tj*UddlZddlZddlZddlZddlZddlZddlmZmZm Z m Z ddlm Z m Z m Z mZmZddlmZmZddlZddlmZmZmZddlmZmZmZddlmZdd lmZd d l m!Z!e rd d l"m#Z#gd Z$ej%e&Z'ee(e)e*e+e,ej-ej.ej/ej0ej1ejj2ej3ej4ej5fZ6ej7e6Z8ede fe(zZ9ee:d<e ee;de de e(dfeede>Z?edZ@edZAeBCgdZDejEjFejGjHejGjIgZJeKede fe:d<ejLejMejNjMjOejNjPjQejNjRjQejNjSjQejNjTjQejUjVejUjVjQejUjWejUjWjQejUjXejUjXjYejZj[jQej\heJZ]e^ede fe:d<e_ejZdr$e]`ejZjajQe!ddee@eAfdee@eAffdZbd ede fde(fd!Zcd"edde(fd#Zed$ede fde(fd%Zfe*d&fd'edd(e*de(fd)Zge!d*Gd+deZhe!d*d,e?deehge>fde?fd-Zie!d*d,e?dee>ge>fde?fd.ZjdS)/N)CallableIterableMappingSequence)AnyOptional TYPE_CHECKING TypeAliasUnion) ParamSpecTypeVar)_fx_map_aggregate _fx_map_arg _NodeBase)ArgsKwargsPairnormalize_functionnormalize_module) dtype_abbrs)ops) compatibility)Graph)Nodemap_arg map_aggregatehas_side_effect.TargetArgument.r r ArgumentT)bound_P_R) placeholder call_method call_module call_functionget_attroutputroot1_side_effectful_need_to_be_preserved_pre_dispatch_side_effectful_functionsresize_storage_bytes_Fis_backward_compatiblefnreturnc:t||S)a Registers a function to not be dead code eliminated by fx.graph.eliminate_dead_code NOTE: For new operators, please do not add to this set! Instead, consider using the effects system via torch.library._register_effectful_op() for operators. This _side_effectful_functions set is only for: - Legacy functions that aren't operators (e.g., profiler ops, asserts) - Things that cannot be marked via the normal effects system )r-add)r1s K/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/torch/fx/node.pyrrzs!!"%%% I orig_methodc|j}|j}||SttjjfD]}t ||d|ur |jcSt d|)Nzcannot find module for )__name__ __module__torchnn functionalgetattr RuntimeError)r7namemoduleguesss r5_find_module_of_methodrCsw  D  #F  ,-"" 5$ % % 4 4> ! ! ! 5 >>> ? ??r6objct|tr=t|tjs#|jdkr|jS|jd|jS|durdSt|tjr|jSt|S)a:Return the repr() of an object, special-casing types (internal helper). If obj is a type, we return a shorter version than the default type.__repr__, based on the module and qualified name, which is typically enough to uniquely identify a type. For everything else, we fall back on repr(obj). builtins..z...) isinstancetypetypes GenericAliasr: __qualname__ FunctionTyper9repr)rDs r5 _type_reprrOs#t6ZU5G%H%H6 >Z ' '# #.553#3555 czzu#u)**| 99r6funcctt|jd|ur|jSt|tjtjfr"|ttj|jdus-|j tj jkr|j d|jkr d|jS|j}|dkrc tj |dd}n"#t $r}t#d|d}~wwxYwt%|}|dd}|d kr |d krd |z}|d kr|d vr|d }|d|S)NzTensor.z torch.Tensor.z=rzUnable to represent lambdaz torch._opsz torch.opsr;segment_reduce_ztorch.nn.functional) _ScalingType _SwizzleTyperG)r>rFr9rHrJMethodDescriptorTypeWrapperDescriptorTyper;Tensorr:_tensorrLinspect getsourcesplitstrip Exceptionr?rCreplace removeprefix)rPr@erAs r5_get_qualified_namercsx--55} 4%4e6QRSS/ GEL$->> > > 5=111  !:4=!:!: : :.t}... =D z D$T**0055a8>>@@DD D D D;<z_format_arg..@  %sA3;M;MKNN;M;M;M;M  r6rz, ...[total_len=][c3HK|]\}}|k t|VdSrkrlrns r5rrz_format_arg..rsr6,()c3DK|]\}}|dt|VdS): Nrl)rokvs r5rrz_format_arg..s:OO41a66k!nn66OOOOOOr6{}%) hasattrrhrHlistjoin enumeratelentupledictitemsrstr)rerfr maybe_len maybe_comma items_strs ` r5rmrmss())"%%''' C  "     )23     c((\A---BB3Qc#hh3Q3Q3Q '5&)&&&& C   "     )23     c((\A---BB3Qc#hh3Q3Q3Q !XX]]cc 353+3y3333 C  "IIOO399;;OOOOO !I!!!!#tSXX~3xxr6Tc4eZdZUdZeded<eedfed<ded<eed<eed <d ed <ed ed <ed ed<edzed<eed<e dgefdzed<eeefed<e d dOddded ed d deddeedfdedzddffd Z deeeffdZ deeefddfdZ edPdZedPdZe ddQd!Ze ddQd"Zedeed#ffd$Zejd%eed#fddfd&Zedeeeffd'Zejd(eeefddfd)Zededfd*Ze dd+ed,eddfd-Ze dd+ed,eddfd.Ze dd/ed,eddfd0Zededzfd1Zejd2edzddfd3Zdefd4Zed e defd5Z!e d dRd6d7d8eedzd9eedzd:e"dedzfd;Z#e d dOd6d<d=dd>e dge"fdzd?e"dedfd@Z$e d6dSdAe"de"fdBZ%e d6 dTdCe&j'j(dDeedzdEeeefdzdFe"de)dzf dGZ*e ddUdJZ+dKeddfdLZ,dedMeddfdNZ-xZ.S)Vrao ``Node`` is the data structure that represents individual operations within a ``Graph``. For the most part, Nodes represent callsites to various entities, such as operators, methods, and Modules (some exceptions include nodes that specify function inputs and outputs). Each ``Node`` has a function specified by its ``op`` property. The ``Node`` semantics for each value of ``op`` are as follows: - ``placeholder`` represents a function input. The ``name`` attribute specifies the name this value will take on. ``target`` is similarly the name of the argument. ``args`` holds either: 1) nothing, or 2) a single argument denoting the default parameter of the function input. ``kwargs`` is don't-care. Placeholders correspond to the function parameters (e.g. ``x``) in the graph printout. - ``get_attr`` retrieves a parameter from the module hierarchy. ``name`` is similarly the name the result of the fetch is assigned to. ``target`` is the fully-qualified name of the parameter's position in the module hierarchy. ``args`` and ``kwargs`` are don't-care - ``call_function`` applies a free function to some values. ``name`` is similarly the name of the value to assign to. ``target`` is the function to be applied. ``args`` and ``kwargs`` represent the arguments to the function, following the Python calling convention - ``call_module`` applies a module in the module hierarchy's ``forward()`` method to given arguments. ``name`` is as previous. ``target`` is the fully-qualified name of the module in the module hierarchy to call. ``args`` and ``kwargs`` represent the arguments to invoke the module on, *excluding the self argument*. - ``call_method`` calls a method on a value. ``name`` is as similar. ``target`` is the string name of the method to apply to the ``self`` argument. ``args`` and ``kwargs`` represent the arguments to invoke the module on, *including the self argument* - ``output`` contains the output of the traced function in its ``args[0]`` attribute. This corresponds to the "return" statement in the Graph printout. r_argsr _kwargsrgraphr@oprtarget)rN _input_nodesusersNrI _sort_key_repr_fnmetaTr/argskwargs return_typer2c |dkr>t|s.td|d|d|dtj|d n_|tvrt d|dt |ts.td|d|d|dtj|d t |||||| ||d S) a} Instantiate an instance of ``Node``. Note: most often, you want to use the Graph APIs, i.e. ``Graph.call_module``, ``Graph.call_method``, etc. rather than instantiating a ``Node`` directly. Args: graph (Graph): The ``Graph`` to which this ``Node`` should belong. name (str): The name to which the output of this ``Node`` should be assigned op (str): The opcode for this ``Node``. Can be one of 'placeholder', 'call_method', 'call_module', 'call_function', 'get_attr', 'output' target ('Target'): The target this op should call. See the broader ``Node`` docstring for more details. args (Tuple['Argument']): The args to be passed to ``target`` kwargs (Dict[str, 'Argument']): The kwargs to be passed to ``target`` return_type (Optional[Any]): The python type expression representing the type of the output of this node. This field can be used for annotation of values in the generated code or for other types of analyses. r(zNode [graph = z , name = 'z '] target z has type z but a Callable is expectedzop 'z' is not in _legal_opsz but a str is expectedN) callable ValueErrorr;typename _legal_opsAssertionErrorrHrsuper__init___update_args_kwargs) selfrr@rrrrr __class__s r5rz Node.__init__0sOJ  F##  1U11d11f11X]XfgmXnXn111  ##$%FB%F%F%FGGGfc**  ,U,,d,,f,,X]XfgmXnXn,,, b&+>>>   v.....r6ci|j|j|j|j|j|j|j|j|j|j |j |j |j |j |j|jdS)N)rr@rrrIrrr_erased_prev_nextrrrr)__dict__rr@rrrIrrrrrrrrrrrs r5 __getstate__zNode.__getstate__fsq m ZI'kIZ||ZZ -Z I!    r6statec\|D]\}}t|||dSrk)rsetattr)rrr}r~s r5 __setstate__zNode.__setstate__zs<KKMM  DAq D!Q      r6c|jS)z Returns the next ``Node`` in the linked list of Nodes. Returns: The next ``Node`` in the linked list of Nodes. )rrs r5nextz Node.next~ zr6c|jS)z Returns the previous ``Node`` in the linked list of Nodes. Returns: The previous ``Node`` in the linked list of Nodes. )rrs r5prevz Node.prevrr6xc0||dS)aD Insert x before this node in the list of nodes in the graph. Example:: Before: p -> self bx -> x -> ax After: p -> x -> self bx -> ax Args: x (Node): The node to put before this node. Must be a member of the same graph. N)_prependrrs r5prependz Node.prepends ar6c:|j|dS)z Insert ``x`` after this node in the list of nodes in the graph. Equivalent to ``self.next.prepend(x)`` Args: x (Node): The node to put after this node. Must be a member of the same graph. N)rrrs r5appendz Node.appends  Ar6.c|jS)a@ The tuple of arguments to this ``Node``. The interpretation of arguments depends on the node's opcode. See the :class:`Node` docstring for more information. Assignment to this property is allowed. All accounting of uses and users is updated automatically on assignment. )rrs r5rz Node.argss zr6rqc<|||jdS)z Set the tuple of arguments to this Node. The interpretation of arguments depends on the node's opcode. See the ``fx.Graph`` docstring for more information. N)rr)rrqs r5rz Node.argss"   DL11111r6c|jS)aG The dict of keyword arguments to this ``Node``. The interpretation of arguments depends on the node's opcode. See the :class:`Node` docstring for more information. Assignment to this property is allowed. All accounting of uses and users is updated automatically on assignment. )rrs r5rz Node.kwargss |r6r}c<||j|dS)z Set the dict of kwargs to this Node. The interpretation of arguments depends on the node's opcode. See the ``fx.Graph`` docstring for more information. N)rr)rr}s r5rz Node.kwargss"   Q/////r6cNt|jS)aE Return all Nodes that are inputs to this Node. This is equivalent to iterating over ``args`` and ``kwargs`` and only collecting the values that are Nodes. Returns: List of ``Nodes`` that appear in the ``args`` and ``kwargs`` of this ``Node``, in that order. )rrkeysrs r5all_input_nodeszNode.all_input_nodess!D%**,,---r6rprec`t|j}|||<t||_dS)a3 Update an existing positional argument to contain the new value ``arg``. After calling, ``self.args[idx] == arg``. Args: idx (int): The index into ``self.args`` of the element to update arg (Argument): The new argument value to write into ``args`` N)rrr)rrprers r5 update_argzNode.update_args+DIS $KK r6cvd|cxkrt|jksntd||jd|}|j|d}||fz|z|_i}t ||j|D]?}||jvr4|j||j|@dS)a Insert a positional argument to the argument list with given index. Args: idx (int): The index of the element in ``self.args`` to be inserted before. arg (Argument): The new argument value to insert into ``args`` rzrcr:)rr@s r5_pretty_print_targetzNode._pretty_print_target:s fc " " M 6< ( ( *6:t44D| +6222 J..)4)))"k11)4)))"6***r6F)include_tensor_metadataplaceholder_namesmaybe_return_typenamerc|jdkrt|jts$t dt |j|j}||jr|dt |jzndz }|r||dS|jrt |jdnd}|jr dt|jdzd znd}d |j d |d t|j d |jd|jd| S|jdkrf|jt |jdnd}d |j d |d t|j d |jd| |jd S|jdkr3|jr|rdt |j|d<d|jdSdttdtfd}|jd|jd|jdd}d} |rt|t"jrp|jt"jt"jfvrQ||} |j} dt0|j||j| | d} n |jt |jdnd} d |j d | d t|j d |jd| |jdt7|jdt7|jd S)aO Return a descriptive string representation of ``self``. This method can be used with no arguments as a debugging utility. This function is also used internally in the ``__str__`` method of ``Graph``. Together, the strings in ``placeholder_names`` and ``maybe_return_typename`` make up the signature of the autogenerated ``forward`` function in this Graph's surrounding GraphModule. ``placeholder_names`` and ``maybe_return_typename`` should not be used otherwise. Args: placeholder_names: A list that will store formatted strings representing the placeholders in the generated ``forward`` function. Internal use only. maybe_return_typename: A single-element list that will store a formatted string representing the output of the generated ``forward`` function. Internal use only. include_tensor_metadata: Whether to include tensor metadata Returns: str: If 1) we're using ``format_node`` as an internal helper in the ``__str__`` method of ``Graph``, and 2) ``self`` is a placeholder Node, return ``None``. Otherwise, return a descriptive string representation of the current Node. r%z/Expected target to be str for placeholder, got r|rtN z (default=rrzrz : z [num_users=z] = z[target=rur)r*z -> zreturn shaper2cHddd|DdS)Nrvric,g|]}t|S)r)rors r5 z=Node.format_node..stringify_shape..s%<%<%<c!ff%<%<%.stringify_shapes.@499%<%:?OOHN<[<[?(?*;???  4893Hz$),,////b YDIYY/YYc$*ooYY7YY$($=$=dk$J$JYY%di00YY=H=U=UYYY r6)propagate_meta replace_withdelete_user_cbrc|rPt|jdkrtd|jD]\}}||j|<g|j}t |jjdd}g}|D]U} | || s|| |r|D]} | ||j | | ||V|S)a Replace all uses of ``self`` in the Graph with the Node ``replace_with``. Args: replace_with (Node): The node to replace all uses of ``self`` with. delete_user_cb (Callable): Callback that is called to determine whether a given user of the self node should be removed. propagate_meta (bool): Whether or not to copy all properties on the .meta field of the original node onto the replacement node. For safety, this is only valid to do if the replacement node doesn't already have an existing .meta field. Returns: The list of Nodes on which this change was made. rzmCalled node.replace_all_uses_with(replace_with, propagate_meta=True), but replace_with already has .meta keys_replace_hooksNoldnewuser) rrrrrr>r owning_modulerr@_replace_input_with) rrrrr}r~ to_process replace_hooksresultuse_node replace_hooks r5replace_all_uses_withzNode.replace_all_uses_withs2  )<$%%**$> )) ) )1'( !!$$"tz]  8:JDQQ " = =H)..2J2J) MM( # # # Q$1QQL LT|/@xPPPPP  ( (| < < < < r6 impure_randomc|jdvrdS|jdkr|jjtdt |jt s$tdt|j|jj|j}|td|jt|dd S|jd kr$d d l m }||j|j |j | Sd S)a3 Returns whether this op is impure, i.e. if its op is a placeholder or output, or if a call_function or call_module which is impure. Args: impure_random (bool): Whether to treat rand op as impure. Returns: bool: If the op is impure or not. >r*r%Tr'Nz1self.graph.owning_module not set for purity check)Expected str target for call_module, got z'Did not find expected submodule target _is_impureFr(r) is_impure)rrr )rrrrrHrrrI get_submoduler>torch._library.utilsr rr)rr  target_modr s r5r zNode.is_impures+ 7/ / /4 7m # #z'/$Gdk3// $ST[@Q@QSS1?? LLJ!$KdkKK:|U;; ; 7o % % 6 6 6 6 6 69 Y{+  ur6r+ arg_types kwarg_typesnormalize_to_only_use_kwargsc|jdkr\t|js$tdt |jt |j|j|j|||S|jdkrat|jts$tdt |jt||j|j|j|SdS)a Returns normalized arguments to Python targets. This means that `args/kwargs` will be matched up to the module/functional's signature and return exclusively kwargs in positional order if `normalize_to_only_use_kwargs` is true. Also populates default values. Does not support positional-only parameters or varargs parameters. Supports module calls. May require `arg_types` and `kwarg_types` in order to disambiguate overloads. Args: root (torch.nn.Module): Module upon which to resolve module targets. arg_types (Optional[Tuple[Any]]): Tuple of arg types for the args kwarg_types (Optional[Dict[str, Any]]): Dict of arg types for the kwargs normalize_to_only_use_kwargs (bool): Whether to normalize to only use kwargs. Returns: Returns NamedTuple ArgsKwargsPair, or `None` if not successful. r(zExpected callable target, got )rr'r N) rrrrrIrrrrHrr)rr+rrrs r5normalized_argumentszNode.normalized_argumentss< 7o % %DK(( $HT$+5F5FHH&   -I  W % %dk3// $ST[@Q@QSS$   -I  tr6 old_input new_inputc|jj}t|ddr|jD]}|||j||||dS)a Loop through input nodes of ``self``, and replace all instances of ``old_input`` with ``new_input``. Args: old_input (Node): The old input node to be replaced. new_input (Node): The new input node to replace ``old_input``. rNr)rrr>rr@r)rrrmrs r5replace_input_withzNode.replace_input_withPsp J $ 1& - - K ! 0 K K   TJJJJJ   I66666r6 candidatec||jkrdS|jj|d}||_|jj||dSrk)r@r_graph_namespace create_name_rename_object)rrr@s r5_renamez Node._renamecsV  ! ! Fz*66y$GG  #224>>>>>r6valuecB|dkrt|drs|jj}t|ddrVt |t st dt||jD]}|j D]}||||d}t||rDt|jdr/||jj vr!d}|jj |t ||||r!|jj |dSdS)Nr@rzExpected value to be str, got rF_find_nodes_lookup_tableT)rrrr>rHrrrIrrr#removeobject __setattr__insert)rr@r!rrrupdates r5r&zNode.__setattr__jsU 6>>gdF33> (Aq*D11 E!%--Y()W$u++)W)WXXX JEED()(8EE $ 5tDDDDDE D$   = $>?? = ;;;F J / 6 6t < < <4u---  = J / 6 6t < < < < < = =r6rk)r2r)rrr2N)NN)T)NNF)rrrrr2N)/r9r:rL__doc__r__annotations__rrrrrrrrpropertyrrrrr rsetterrrrintrrrrr staticmethodr%rboolrrr r;r<Modulerrrr r& __classcell__)rs@r5rrsF6  !!!! #z/ """" NNN III GGG |$$$$   *NNNx}%,,,, sCx.]$///#'3/3/3/3/  3/  3/ O$ 3/S*_%3/4Z3/ 3/3/3/3/3/0/3/j d38n    ( $sCx. T    XX]$///   0/ ]$///   0/  eHcM*   X  [2eHcM*2t222[2 S(]+   X  ]0S(]+0000]0 .f . . .X .]$///  c    T    0/  ]$////c//T///0//4]$/// 0 0( 0t 0 0 00/ 0 2S4Z 2 2 2X 2)t)))))# +V++++\+0]$////326^ ). ^^^9t+^ $Cy4/^ "& ^ t ^^^0/^@]$///;?, % ,,,,!&4047,  , f ,,,0/,\]%00000t0t000100d]%000(,-1-2 77ho7:$7#s(^d* 7 '+ 7 $  777107r]$///7770/7$??????==C=D========r6rqc^t|stdt||S)z Apply fn recursively to each Node appearing in arg. arg may be a list, tuple, slice, or dict with string keys: the return value will have the same type and structure. z.torch.fx.map_arg(a, fn): fn must be a callable)rrrrqr1s r5rrs2 B<<OMNNN q"  r6c"t||S)z Apply fn recursively to each object appearing in arg. arg may be a list, tuple, slice, or dict with string keys: the return value will have the same type and structure. )rr3s r5rrs Q # ##r6)krFr[loggingoperatorrJtypingcollections.abcrrrrrrr r r typing_extensionsr r r;torch._Crrrtorch.fx.operator_schemasrrrtorch.utils._dtype_abbrsr_opsr_compatibilityrrr__all__ getLoggerr9logrr-floatr/complexrrYr memory_formatr OpOverloadSymIntSymBoolSymFloatBaseArgumentTypesget_args base_typesrr*rsliceranger r!r#r$rfromkeysr_C_set_grad_enabledamp_enter_autocast_exit_autocastr,r_assert _assert_asyncatenmsg_assert_scalardefault_assert_tensor_metadatasym_constrain_rangesym_constrain_range_for_sizeprofiler_record_function_enter_record_function_enter_new_record_function_exit_RecordFunctioninductoraccumulate_grad_setitemr-setrr4r.rrCr%rOrcrmrrrrr6r5rfs AAAAAAAAAAAAAAAAAAAAAAAAAA00000000 >>>>>>>>>> 100000)))))) A A Ag!!   K L L  L J L M N  V_. / / S#X&, ,,,   oZ       GKx 0 0 0 Yt__ WT]] ]]    H I IO14c8J3K" M II$I%-I!)I*2M(M(0M,M,4M'M'7M"* 6 7!63xS12& 74=122O!!$-"E"MNNNe,,,R(Xb"f-=-,$@c(:@s@@@@Fs(hsCx0SB495<<V5C<d+++O =O =O =O =O =9O =O =,+O =dd+++ y hvx'78 Y   ,+ d+++$Y$HhZ-A$B$y$$$,+$$$r6