U 9%e@M @sUddlZddlZddlZddlZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZmZddlmZddlmZddlmZmZerddlmZdd d d d d dgZeddGddde ZiZe ee ejfed<ddZeeej<GdddZ ej!ej"ej#ej$ej%j&ej'ej(e e)de*dd Z+e,eD]Z-e.ee-e+e-<qDdedddZ/ej0j1ejdddZ2eddee d e e3d!fd"d#d Z4eddd1ee5d$d%d Z6eddd&d Z7eddeed'd(d Z8eddd2ee ee e e3efe e ee e e3efe5e ed)d*d Z9eddd3ej:j;e3e ee e e3efe5e ed+d,dZg}dd}|t|tddd}|t||S)NcSsdSNr )selfr r r!nonzero sz!_nonzero_schemas..nonzero)as_tuplecSsdSr#r )r$r&r r r!r%$s)appendinspect signaturebool) signaturesr%r r r!_nonzero_schemass r,c@seZdZddZdS)_FakeGlobalNamespacecCs|dkr tStddS)Ntorchz!Expected a torch namespace lookup)r. RuntimeError)r$namer r r! __getattr__-sz _FakeGlobalNamespace.__getattr__N)rrrr1r r r r!r-,sr-t) TensorZDeviceZLayoutnumberFutureZ AnyEnumTypeZQSchemeZ __torch__ZNoneTyper2ztorch._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)r6r r r! _torchscript_type_to_python_type:sr:) ts_schemar7c Cs ddlm}g}|jD]}t|j}|r2|jn|j}|jdkrH|jnd}|j rX|j n|j }|dkr||j kstt |j }t|D]4\}} | j|j kst || j|j | j| jd||<q||||||dqdd|jD} t| dkrd} n t| d kr | d} nt| } tj|| d S) Nr) Parameterr$inputfrom)r0kinddefault annotationcSsg|]}t|jqSr )r:type).0retr r r! Zsz4_torchscript_schema_to_signature..r )return_annotation)r(r< argumentsr:rBZhas_default_value default_valueemptyr0Z kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDAssertionErrorPOSITIONAL_ONLY enumerater?r@rAr'Zreturnslentuple Signature) r;r< parametersargarg_typer@r0r?idxpZ return_types return_typer r r! _torchscript_schema_to_signatureBs*     rX)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/)schemar r r!throw_if_mutableusz5check_for_mutable_operation..throw_if_mutablerr )rzipbindr' TypeErrorrO) rYrrr+schemasmatched_schemascandidate_signaturer[er\_Zschema_to_checkr r r!rds"    )oprZcsttrjg}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)rCoverloadrer r!rEsz.get_signature_for_torch_op..N)NNcSsg|] }t|qSr )rXrCr[r r r!rEs) isinstancerrgrZ overloadsr"getr.jitZ _builtinsZ _find_builtin_CZ_jit_get_schemas_for_operator)rerZr`overrideZaten_fnr+r rir!rs      c Cszt|ttfrt|tr$dd}ndd}t|dkrB|tWS|d}|D]0}t||r`qNqNt||rp|}qN|tWSqN||WSWn2tk r}ztd|W5d}~XYnX|S)NcSst|Sr#)rxr r r!ret_typesz"create_type_hint..ret_typecSs t|dfS)N.)rrpr r r!rrsrz@We were not able to successfully create type hint from the type ) rklistrPrOr issubclass Exceptionwarningswarn)rqrrZ base_typer2rcr r r!rs&      )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#)rrCc)ryr r! sztype_matches..rz.Does not support nested parametric types, got z. Please file a bug.FcsBt|ddtthkrdS|j}|jdkr,dStfdd|DS)NrzF)r Tc3s |]}|tkpt|VqdSr#)Ellipsisrtr{ sig_el_typer r!r}sz=type_matches..is_homogeneous_tuple..)rfrPr__args__all)r2 containedrr r!is_homogeneous_tuples  z*type_matches..is_homogeneous_tuple)rftypingUnionranyrintrsr(isclassrvrwrtr.ZdtypenumbersNumberfloat)rxryZsig_origin_typeZ sig_containedrr )ryrr!rs4      )rYrr arg_types kwarg_typesnormalize_to_only_use_kwargsr7c CsV|dkr i}d}t|tjst|ttfs|}|tkr~t|trDtt|}|d|d} } t | j t | j krzdS| }t |stt t |} t | |||}nt |stt|} g} | rR| D]L}z|j||| |Wqtk r}z WYqW5d}~XYqXqt| dkr.n$t| dkrRt | d|||}n|dk sf|dk r$|rp|n tttd}|r|ni}| D]}d}zB|j||}|jD]&\}}|j |}|ot|j|}qWn(tk r}zd}W5d}~XYnX|rt ||||}qRqn.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 r TF css|]}t|VqdSr#)rrjr r r!r}Qsz%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: )rktypesBuiltinFunctionTyperrr rrLr(r)rRcallableunwrap&_args_kwargs_to_normalized_args_kwargsrr^r'r_rOr rrrGitemsrrAjoinr/r.typename)rYrrrrrnew_args_and_kwargsZtarget_for_analysisZ dispatchedrrsigZtorch_op_schemasrarbrcZ sig_matchesZ bound_typesZarg_namerTparamZschema_printoutsr r r!rsj         )rootrYrrrr7c Csz||}Wn4tk rB}ztd|d|W5d}~XYnXt|jdr|jj}ttj|d|jkrt t |j }|dkri}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!Nr)Z get_submoduleAttributeErrorr/hasattr __class__rrfr.nnr(r)rforwardr) rrYrrrZsubmodrc classnamerrr r r!rXs" .)rrrrr7c stjjtjjhtfdd|jDrJt|jddddgkrJdS|j ||}| i}g}t |jD]8\}}|s|t |kr| |j|qp|j|||<qptt||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: sig (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#)r?)rCrVZsupported_parameter_typesr r!r}sz9_args_kwargs_to_normalized_args_kwargs..r=r>to generatorN)r(r<rKrJrrRvaluesrskeysr^apply_defaultsrNrOr'rGrrP) rrrrZ bound_argsZ new_kwargsnew_argsirr rr!rs r)F)NNNF)NF)>r.r(rrrenumrvrrrrrrrr r Ztorch._jit_internalr Z_compatibilityr Z torch._opsrrnoder__all__rr"rQrr,r%r-r3ZdeviceZlayoutrrmr5EnumZqschemerBTypeVarr9dirkrfr:rnZFunctionSchemarXrrr*rrrrrModulerrr r r r!s,      " #! / a&