Ei<D%SSKrSSKrSSKrSSKrSSKrSSKrSSKJrJrJ r J r SSKJ r J r J r JrJr SSKJrJr SSKrSSKJrJrJr SSKJrJrJr SSKJr SS KJr S S K J!r! \ (aS S K"J#r# /S Qr$\RJ"\&5r'\\(\)\*\+\,\RZ\R\\R^\R`\Rb\R<Rd\Rf\Rh\Rj4r6\Rn"\65r8\\S\ 4\(4r9\\:S'\ \\;S\ S\ \(S4\<\=S\64r>\"S\>S9r?\"S5r@\"S5rA\BR/SQ5rD\RR\RR\RR/rJ\K\S\ 4\:S'\R\R\RRR\RRR\RRR\RRR\RRR\RR\RRR\RR\RRR\RR\RRR\RRR\R1\Jkr]\^\S\ 4\:S'\_"\RS5(a/\]R\RRR5 \!"SS9S\\@\A4S\\@\A44Sj5rbS \S\ 4S\(4S!jrcS"\dS\(4S#jreS$\S\ 4S\(4S%jrf\*"S&54S'\dS(\*S\(4S)jjrg\!"S*S9"S+S\55rh\!"S*S9S,\?S\\h/\>4S\?4S-j5ri\!"S*S9S,\?S\\>/\>4S\?4S.j5rjg)/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_compatiblefnreturnc0[RU5 U$)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 J/home/mande/repo/quber/.venv/lib/python3.13/site-packages/torch/fx/node.pyrrzs!!"% I orig_methodcURnURnUbU$[[RR4H n[ X1S5ULdMURs $ [ SU35e)Nzcannot find module for )__name__ __module__torchnn functionalgetattr RuntimeError)r7namemoduleguesss r5_find_module_of_methodrCsj   D  # #F  ,,- 5 % 4>> !. 0 > ??r6objcP[U[5(aV[U[R5(d7URS:Xa UR $URSUR 3$USLag[U[R 5(a UR$[U5$)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#tZU5G5G%H%H >>Z '## #..!3#3#3"455 cz#u))**|| 9r6funcc[[URS5ULa UR$[U[R [R 45(a(U[[RURS5LdEUR[RR:Xa,URSUR3:XaSUR3$URnUS:Xa7[R"U5RS5SR5n[%U5nUR'SS5nUS :Xa US :XaS U-nUS :XaUS ;aUR)S 5nUSU3$![ an[#S5UeSnAff=f)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_namercshx-5}} 4%44e6Q6QRSS GELL$--> > 5==111   74==/!: :t}}o.. ==D z D$$T*005a8>>@D$D )F ^^kFT%55Tz &&43S+S  %XQtf  D;# UHupUT:dM [U5v M g7fN _format_arg.0idxarfs r5 _format_arg..% )7vs3;MNKNN %%rz, ...[total_len=][c3N># UHupUT:dM [U5v M g7frkrlrns r5rrrsrtru,()c3F# UHupUS[U53v M g7f): Nrl)rokvs r5rrrss"O;412k!n%56;s!{}%) hasattrrhrHlistjoin enumeratelentupledictitemsrstr)rerfr maybe_len maybe_comma items_strs ` r5rmrmses())%%'' C    )23  c(\A--B5Ec#hZq3Q 5')A&& C    )23  c(\A--B5Ec#hZq3Q !X]c 5'+yk33 C  IIO399;OO I;b!!#tSX~3xr6Tc2^\rSrSr%Sr\S\S'\\S4\S'S\S'\\S '\\S 'S \S '\S \S'\S \S'\ \ \S'\ \S'\ \ S/\4\S'\\\ 4\S'\ "SS9SNSSS \S \S S S\SS\\S4S\ \ SS4U4Sjjj5r S\\\ 44SjrS\\\ 4SS4Sjr\SOSj5r\SOS j5r\ "SS9SPS!j5r\ "SS9SPS"j5r\S\\S#44S$j5r\R.S%\\S#4SS4S&j5r\S\\\44S'j5r\R.S(\\\4SS4S)j5r\S\S4S*j5r\ "SS9S+\S,\SS4S-j5r\ "SS9S+\S,\SS4S.j5r\ "SS9S/\S,\SS4S0j5r\S\ \4S1j5r\R.S2\ \SS4S3j5rS\4S4jr \!S \"S\4S5j5r#\ "SS9SQS6S7.S8\ \\S9\ \\S:\$S\ \4S;jjj5r%\ "SS9SNS6S<.S=SS>\ \ S/\$4S?\$S\S4S@jjj5r&\ "S6S9SRSA\$S\$4SBjj5r'\ "S6S9SSSC\(RRRTSD\ \\ SE\ \\\ 4SF\$S\ \+4 SGjj5r,\ "SS9STSHj5r-SI\SS4SJjr.S \SK\ SS4SLjr/SMr0U=r1$)Ura ``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_nodesusersrI _sort_key_repr_fnmetaTr/Nargskwargs return_typer2c >US:Xa=[U5(d,[SUSUSUS[R"U5S3 5eOZU[;a[ SUS35e[ U[5(d,[SUSUSUS[R"U5S 3 5e[TU]%XX4U5 URXV5 g ) 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 r5r Node.__init__.sJ  F## $UG:dV:fXZX]XfXfgmXnWop11$ #$tB4/E%FGGfc** $UG:dV:fXZX]XfXfgmXnWop,, b+>   .r6cn0UREURURURURUR UR URURURURURURURURURS.E$)N)rr@rrrIrrr_erased_prev_nextrrrr)__dict__rr@rrrIrrrrrrrrrrrs r5 __getstate__Node.__getstate__ds mm ZZII''kkIIZZ||||ZZZZ --ZZ II!  r6statecNUR5Hup#[XU5 M grk)rsetattr)rrrrs r5 __setstate__Node.__setstate__xsKKMDA DQ "r6cUR$)zv Returns the next ``Node`` in the linked list of Nodes. Returns: The next ``Node`` in the linked list of Nodes. )rrs r5next Node.next|zzr6cUR$)z~ Returns the previous ``Node`` in the linked list of Nodes. Returns: The previous ``Node`` in the linked list of Nodes. )rrs r5prev Node.prevrr6c&URU5 g)a 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)_prependrxs r5prepend Node.prepends ar6c:URRU5 g)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 r5append Node.appends Ar6.cUR$)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 r5r Node.argsszzr6rqc:URXR5 g)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 r5rrs   LL1r6cUR$)a 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 r5r Node.kwargss||r6rc<URURU5 g)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)rrs r5rrs   Q/r6cH[URR55$)a  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_nodesNode.all_input_nodessD%%**,--r6rprecV[UR5nX#U'[U5Ulg)a 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_argNode.update_args#DIIS $K r6cSUs=::a[UR5::dO [SU35eURSUnURUSnX24-U-Ul0n[ X%R 5 UHJnX`R ;dMUR R U5 URR U5 ML g)z Insert an 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_targetNode._pretty_print_target8s fc " "M 6< ( (6:t4D| +622  J."4&))""k1"4&))"6**r6F)include_tensor_metadataplaceholder_namesmaybe_return_typenamercURS:XGa6[UR[5(d![ S[ UR535eURnX@R (aUS[ UR 53-OS- nU(aURU5 gUR (a[ UR 5S3OSnUR(aS[URS5-S -OSnS URS US [UR5S URSURSU3 $URS:XayUR b[ UR 5S3OSnS URS US [UR5S URSURUR5S3 $URS:XaEUR (a"U(aS[ UR 53US'SURS3$S[S[4SjnURRSURRSURRSS555nSn U(a[U[ R"5(aUR$[ R&[ R(4;aRU"UR+55n UR,n S[.UR0U"UR25U U S3n O'UR b[ UR 5S3OSn S URS U S [UR5S URSURUR5S[5UR5S[5UR65S 3$)a 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~rvN z (default=rr|rz : z [num_users=z] = z[target=rwr)r*z -> zreturn shaper2c jSSRUVs/sHn[U5PM sn5S3$s snf)Nrxrirw)rr)rrs r5stringify_shape)Node.format_node..stringify_shapes1499e%a@@%>:;OHNN<[;\()*;)r owning_modulerr@_replace_input_with) rr r r rr to_process replace_hooksresultuse_node replace_hooks r5replace_all_uses_withNode.replace_all_uses_withs2 <$$%*$> )'(!!!$*"tzz]  8 8:JDQ "H).2J2J MM( #$1L T/@/@xP%2  ( ( <# r6 impure_randomcURS;agURS:XayURRc [S5eURRR UR 5nUc[SUR 35e[ USS5$URS:Xa-S S KJn U"UR URURUS 9$g) z 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'z1self.graph.owning_module not set for purity checkz'Did not find expected submodule target _is_impureFr(r) is_impure)rrr) rrrr get_submodulerr>torch._library.utilsrrr)rr target_modrs r5rNode.is_impures 77/ / 77m #zz''/$G11?? LJ!$=dkk]K:|U; ; 77o % 6 YY{{+  r6r+ arg_types kwarg_typesnormalize_to_only_use_kwargsc URS:Xag[UR5(d![S[ UR535e[ URUR URUUUS9$URS:Xak[UR[5(d![S[ UR535e[UURUR URUS9$g)a1 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 )r&r'z)Expected str target for call_module, got N) rrrrrIrrrrHrr)rr+r$r%r&s r5normalized_argumentsNode.normalized_argumentss< 77o %DKK(($4T$++5F4GH&   -I  WW %dkk3//$?T[[@Q?RS$   -I  r6cURRn[USS5(a$URHnU"XRUS9 M UR X5 g)z 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)r old_input new_inputmrs r5replace_input_withNode.replace_input_withJsQ JJ $ $ 1& - - ! 0 0 TJ!1   6r6 candidatecXR:XagURRRUS5nX lURRR X5 grk)r@r_graph_namespace create_name_rename_object)rr0r@s r5_rename Node._rename]sH  ! zz**66y$G  ##224>r6valuecUS:Xa[US5(aURRn[USS5(aY[ U[ 5(d[ S[U535eURHnURH nU"XUS9 M M Sn[X5(a[[URS5(a@XRR;a'SnURRRU5 [RXU5 U(a&URRRU5 gg)Nr@rzExpected value to be str, got rF_find_nodes_lookup_tableT)rrrr>rHrrrIrrr9removeobject __setattr__insert)rr@r7r-rrupdates r5r<Node.__setattr__ds 6>gdF33 ((Aq*D11!%--(+I$u+)WXX JJD()(8(8 $tD)9' D   $>?? ;;;F JJ / / 6 6t <4u-  JJ / / 6 6t < r6)rrrr@rk)r2r)rrr2N)NN)T)NNF)r+rr,rr2N)2r9r:rL__firstlineno____doc__r__annotations__rrrrrrrrrpropertyrrrrr rsetterrrrintrrrrr staticmethodr;rboolrrrr;r<Modulerr(r.r5r<__static_attributes__ __classcell__)rs@r5rrs6  !! #z/ "" N I G |$$   3-Nx# .// sCx.$/&*3/3/3/  3/  3/ O$ 3/S*_%3/c]3/ 3/03/j d38n ( $sCx. T $/ 0 $/ 0  eHcM*   [[2eHcM*2t22 S(]+   ]]0S(]+000 .f . .$/  c    T  0  $//c//T/0/4$/ 0 0( 0t 00 0 2Xc] 2 2)#)4))# +V+++0$/2659^ ). ^#DI.^ (S 2^ "& ^ # ^0^@$/>B, % ,,!6(D.!9:,  , f ,0,\%0,t,t,1,\%0+/04-2 7hhoo7E#J'7d38n- 7 '+ 7 . ! 717r$/707$???==C=D==r6rqcN[U5(d [S5e[X5$)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 r5rrzs$ B<<MNN q r6c[X5$)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. )rrLs r5rrs Q ##r6)krFr[loggingoperatorrJtypingcollections.abcrrrrrrr r r typing_extensionsr r r;torch._Crrrtorch.fx.operator_schemasrrrtorch.utils._dtype_abbrsr_opsr_compatibilityrrr__all__ getLoggerr9logrrEfloatrGcomplexrrYr memory_formatr OpOverloadSymIntSymBoolSymFloatBaseArgumentTypesget_args base_typesrrBrsliceranger 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;rOrcrmrrrr6r5rs7 AAAA0 >> 1) A !   KK LL LL  LL JJ LL MM NN  __. / (38,c12 2   oZ       Kx 0 t_ T] ]]   HH II IIO14c8J3K" MM IIII$$II%%--II!!))II**22MM((MM((00MM,,MM,,44MM''MM''77MM""** 6 7!63xS12& 4==122!!$--"E"E"M"MNe,R(Xb"f-=-$@c(:@s@Fs(hsCx0S@49<V5C<d+J =9J =,J =Zd+ y hvx'78 Y , d+$Y$HhZ-A$B$y$,$r6