U dMH @sUddlZddlZddlZddlZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZmZddlmZddlmZddlmZmZerddlmZedd Gd d d e ZiZe ee ejfed <d dZeeej<GdddZej ej!ej"ej#ej$j%ej&ej'ee(de)dd Z*e+eD]Z,e-ee,e*e,<q2dedddZ.ej/j0ejdddZ1edd ee de e2dfdddZ3edd d1ee4dd d!Z5edd d"d#Z6edd eed$d%d&Z7edd d2ee ee e e2efe e ee e e2efe4e ed'd(d)Z8edd d3ej9j:e2e ee e e2efe4e ed*d+d,Z;eje ed-fe e2efe4e ed.d/d0Zg}dd}|t|tddd}|t||S)NcSsdSNr)selfrrrnonzerosz!_nonzero_schemas..nonzero)as_tuplecSsdSrr)rr rrrr!s)appendinspect signaturebool) signaturesrrrr_nonzero_schemass r&c@seZdZddZdS)_FakeGlobalNamespacecCs|dkr tStddS)Ntorchz!Expected a torch namespace lookup)r( RuntimeError)rnamerrr __getattr__*sz _FakeGlobalNamespace.__getattr__N)rrrr+rrrrr')sr't) TensorZDeviceZLayoutnumberFutureZ AnyEnumTypeZQSchemeZ __torch__ZNoneTyper,ztorch._C.JitType)ts_typereturncCs t|jtS)z Convert a TorchScript type to a Python type (including subtypes) via eval'ing the annotation_str. _type_eval_globals sets up expressions like "List" and "Future" to map to actual types (typing.List and jit.Future) )evalZannotation_str_type_eval_globals)r0rrr _torchscript_type_to_python_type7sr4) ts_schemar1c Csg}|jD]f}t|j}|r&|jntjj}|jdkr>|jnd}|j rPtjj ntjj }| tj||||dq dd|j D}t|dkrd}nt|dkr|d}nt|}tj||dS) Nrinput)r*kinddefault annotationcSsg|]}t|jqSr)r4type).0retrrr Lsz4_torchscript_schema_to_signature..rr )return_annotation) argumentsr4r:Zhas_default_value default_valuer" Parameteremptyr*Z kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDr!Zreturnslentuple Signature) r5 parametersargarg_typer8r*r7Z return_types return_typerrr _torchscript_schema_to_signature?s     rL)r.r)targetrrc Cst|dd\}}|r|rg}t||D]R\}}z|j|||||fWq&tk rv}z WYq&W5d}~XYq&Xq&dd} t|dkrn"t|dkr|d\} } | | ndS)NT)return_schemascSs|jrtd|ddS)Nz!Tried to trace mutable operation z|. FX only supports functional code, so operations that mutate operands in-place (e.g. via `out` arguments) are not supported)Z is_mutabler))schemarrrthrow_if_mutablegsz5check_for_mutable_operation..throw_if_mutablerr )get_signature_for_torch_opzipbindr! TypeErrorrE) rMrrr%schemasmatched_schemascandidate_signaturerOerP_Zschema_to_checkrrrcheck_for_mutable_operationVs"    rZ)oprNcsttrjg}nnttr6fddD}nLt}|rT|rP|dfSdStjj }|dkrv|rrdSdStj |}dd|D}|r||fS|S)a Given an operator on the `torch` namespace, return a list of `inspect.Signature` objects corresponding to the overloads of that op.. May return `None` if a signature could not be retrieved. Args: op (Callable): An operator on the `torch` namespace to look up a signature for Returns: Optional[List[inspect.Signature]]: A list of signatures for the overloads of this operator, or None if the operator signatures could not be retrieved. If return_schemas=True, returns a tuple containing the optional Python signatures and the optional TorchScript Function signature csg|]}t|jqSr)getattr_schema)r;overloadr[rrr=sz.get_signature_for_torch_op..N)NNcSsg|] }t|qSr)rLr;rOrrrr=s) isinstancerr]rZ overloadsrgetr(jitZ _builtinsZ _find_builtin_CZ_jit_get_schemas_for_operator)r[rNrUoverrideZaten_fnr%rr_rrQzs      rQc Cszt|tst|trt|tr*dd}ndd}t|dkrH|tWS|d}|D]0}t||rfqTqTt||rv|}qT|tWSqT||WSWn4tk r}ztj d|W5d}~XYnX|S)NcSst|Sr)rxrrrret_typesz"create_type_hint..ret_typecSs t|dfS)N.)rrfrrrrhsrz@We were not able to successfully create type hint from the type ) ralistrFrEr issubclass Exceptionr(warningswarn)rgrhZ base_typer,rXrrrcreate_type_hints&      rn)signature_type argument_typecs.t|d|}|krdS|tjkrF|krF|j}tfdd|DS|ttkr^tkr^dSt|ddtthkr|jdt st d|ddStddtthkrt jdSfd d }|S|tkrt jkrdS|tjkrtthkrdSt r*t |r*t |SdS) N __origin__Tc3s|]}t|VqdSr) type_matchesr;c)rprr sztype_matches..rz.Does not support nested parametric types, got z. Please file a bug.FcsBt|ddtthkrdS|j}|jdkr,dStfdd|DS)NrqF)rTc3s |]}|tkpt|VqdSr)Ellipsisrjrs sig_el_typerrrusz=type_matches..is_homogeneous_tuple..)r\rFr__args__all)r,Z containedrwrris_homogeneous_tuples  z*type_matches..is_homogeneous_tuple)r\typingUnionryanyrintrir"isclassrlrmrjr(ZdtypenumbersNumberfloat)rorpZsig_origin_typeZ sig_containedr{r)rprxrrrs4      rr)rMrr arg_types kwarg_typesnormalize_to_only_use_kwargsr1c Cs\|dkr i}d}t|tjst|tst|ts|}|tkrt|trJtt|}|d|d} } t | j t | j krdS| }t |stt t |} t | |||}nt |stt|} g} | rX| D]L}z|j||| |Wqtk r}z WYqW5d}~XYqXqt| dkr4n$t| dkrXt | d|||}n|dk sl|dk r*|rv|n tttd}|r|ni}| D]}d}zB|j||}|jD]&\}}|j |}|ot|j|}qWn(tk r}zd}W5d}~XYnX|rt ||||}qXqn.d d d | D}td t|d ||S)a Returns normalized arguments to PyTorch functions. This means that `args/kwargs` will be matched up to the 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 (*args, **kwargs). Does not support modules. May require `arg_types` and `kwarg_types` in order to disambiguate overloads. Args: target (Callable): Function that we are normalizing args (Tuple[Any]): Tuple of args to the function kwargs (Optional[Dict[str, Any]]): Dict of kwargs to the function 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 normalized_args_and_kwargs, or `None` if not successful. Nif_trueif_falserr rTF css|]}t|VqdSr)rr`rrrruCsz%normalize_function..z Tried to normalize arguments to zy but the schema match was ambiguous! Please provide argument types to the normalize_arguments() call. Available schemas: )ratypesBuiltinFunctionTyperrr rAssertionErrorr"r#rHcallableunwrap&_args_kwargs_to_normalized_args_kwargsrQrSr!rTrEr rrr?itemsrrr9joinr)r(typename)rMrrrrrnew_args_and_kwargsZtarget_for_analysisZ dispatchedrrsigZtorch_op_schemasrVrWrXZ sig_matchesZ bound_typesZarg_namerJparamZschema_printoutsrrrnormalize_functionsn        r)rootrMrrrr1c Csz||}Wn$tk r2td|dYnXt|jdr|jj}ttj|d|jkrt t |j }|dkrzi}t ||||}|SdS)a( Returns normalized arguments to PyTorch modules. This means that `args/kwargs` will be matched up to the 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 (*args, **kwargs). Args: root (nn.Module): root module upon which we query modules target (Callable): Function that we are normalizing args (Tuple[Any]): Tuple of args to the function kwargs (Optional[Dict[str, Any]]): Dict of kwargs to the function normalize_to_only_use_kwargs (bool): Whether to normalize to only use kwargs. Returns: Returns normalized_args_and_kwargs, or `None` if not successful. z$Tried to normalize node with target z# but root did not have that target!rN)Z get_submoduleAttributeErrorr)hasattr __class__rr\r(nnr"r#rZforwardr) rrMrrrZsubmod classnamerrrrrnormalize_moduleJs r.)rrrrr1c stjjtjjhtfdd|jDr0dS|j||}|i}g}t |jD]8\}}|s|t |kr| |j |qV|j |||<qVt t||S)a Given a call target, args, and kwargs, return the arguments normalized into an ArgsKwargsPair, or None if the type signature is not supported by this normalization. Args: target (inspect.Signature): Signature object for the target args (Tuple): Arguments that appear at the callsite for `target` kwargs (Dict): Keyword arguments that appear at the callsite for `target` normalize_to_only_use_kwargs (bool): Whether to normalize to only use kwargs. Returns: Optional[ArgsKwargsPair]: Normalized args and kwargs for `target`, or `None` if this target is not supported. c3s|]}|jkVqdSr)r7)r;pZsupported_parameter_typesrrrusz9_args_kwargs_to_normalized_args_kwargs..N)r"rArDrCr~rHvaluesrSapply_defaults enumeraterEr!r?rrF) rrrrZ bound_argsZ new_kwargsnew_argsirrrrrqs r)F)NNNF)NF)=r(r"rrr|enumrlrrrrrrrr r Ztorch._jit_internalr Z_compatibilityr Z torch._opsrrnoderrrrGrr&rr'r-ZdeviceZlayoutrrcr/EnumZqschemer:TypeVarr3dirkr\r4rdZFunctionSchemarLrrZr$rQrnrrrrModulerrrrrrs,       #! / a&