o 0 h@sddlmZddlZddlZddlmZddlmZmZddl Z ddl m Z ddl m Z mZmZmZmZmZmZmZmZmZmZmZmZmZddlmZddlmZdd lm Z m!Z!m"Z"dd l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*dd l+m,Z,m-Z-dd l.m/Z/d dl0m1Z1d dl2m3Z3erddl4m5Z5m6Z6gdZ7dde7DZ8gdZ9edddZ:dddZ;dd"d#Zdd(d)Z?dd*d+Z@dd,d-ZAdd.d/ZBdd0d1ZCdd2d3ZDd4d5dd=d>ZEddCdDZFd4d5ddKdLZGddMdNZHddOdPZId4d5ddSdTZJdUdUdVdd[d\ZKdd^d_ZLedd`daZMddcddZNddfdgZOddidjZPedkZQedlZRedmZSednZTd4d5ddodpZUddrdsZVedtZWd4d5ddydzZXdd|d}ZYdd~dZZd4d5dddZ[d4d5dddZ\d4d5dddZ]dS)) annotationsN) defaultdict)Callable TYPE_CHECKING)cpp)arg_parser_output_exprscpp_dispatch_exprscpp_dispatch_targetdispatch_lambda_argsdispatch_lambda_exprsdispatch_lambda_return_strhas_tensor_optionsPythonSignaturePythonSignatureDeprecatedPythonSignatureGroup!PythonSignatureNativeFunctionPair signaturesignature_from_schemastructseq_fieldnames) CodeTemplatewith_native_function) cpp_stringparse_native_yamlparse_tags_yaml)ArgumentBaseOperatorNameFunctionSchemaNativeFunction SchemaKindTypeVariant) FileManagersplit_name_params) YamlLoader)is_tensor_list_type) should_trace)IterableSequence)Salias contiguousis_cuda is_sparse is_sparse_csrsizestridesym_size sym_stridesym_storage_offset sym_numelz .*_backwardz#.*_backward_(out|input|weight|bias)z .*_forwardz.*_forward_outz.*_jvp _unsafe_viewtensorz2_?sparse_(coo|compressed|csr|csc|bsr|bsc)_tensor.*z_range.*_sparse_add_outz _sparse_div.*z _sparse_mul.*z _sparse_sub.*_sparse_dense_add_outindex index_outunique_dim_consecutivez _cumsum.*z _cumprod.*z_sum.*z_prod.*z_th_.*z_thnn_.*zrange.*z_solve.*z _inverse.*z _cholesky.*z_triangular_solve.*z_qr.*z_svd.*sliceitem_local_scalar_denseto_to_copy _to_copy_out _reshape_copy_reshape_copy_outcopy_sparse_to_sparse_copy_ _foreach_copynumpy_Tmatrix_HmTmHznonzero(_(out|numpy))?set_dataz.*_overrideabledatais_leaf output_nr_versionrequires_grad_ retains_gradset_ _fw_primal)fake_quantize_per_tensor_affine_cachemask*fake_quantize_per_channel_affine_cachemask!_new_zeros_with_same_feature_meta_has_same_storage_numel_reshape_aliasreplace_copyz fill.Tensorz fill.Scalarzlift.*normal_functionalnbytesitemsize_batch_norm_with_update_batch_norm_with_update_out_batch_norm_no_updatecCsg|] }td|dqS)^$)recompile).0patternrgc/var/www/vscode/kcb/lib/python3.10/site-packages/torchgen/packaged/autograd/gen_python_functions.py sri)z?add.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> TensorzHadd_.Scalar(Tensor(a!) self, Scalar other, Scalar alpha=1) -> Tensor(a!)z?sub.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> TensorzHsub_.Scalar(Tensor(a!) self, Scalar other, Scalar alpha=1) -> Tensor(a!)z/mul.Scalar(Tensor self, Scalar other) -> Tensorz8mul_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)z/div.Scalar(Tensor self, Scalar other) -> Tensorz8div_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)frreturnboolcCsdd|jvr d|jvr dSt|j}tD] }||rdSqt|j}tD] }||kr/dSq&dS)N generated view_copyFT)tagsrnamefuncSKIP_PYTHON_BINDINGSmatchstrSKIP_PYTHON_BINDINGS_SIGNATURES)rjrp skip_regexrrfrgrgrhshould_generate_py_bindings   rwrprrtcCs d|S)N THPVariable_rgrprgrgrh get_pycname rz overloads+Sequence[PythonSignatureNativeFunctionPair]cCst|dko|djdkS)Nr%r)lenrarguments_count)r|rgrgrhis_noargsrcC|jduo tj|jvSN) python_moduler!methodvariantsrjrgrgrhis_py_variable_methodrcCrr)rr!functionrrrgrgrhis_py_torch_functionrrcC |jdkS)Nnnrrrgrgrhis_py_nn_functionr{rcCr)Nfftrrrgrgrhis_py_fft_functionr{rcCr)Nlinalgrrrgrgrhis_py_linalg_functionr{rcCr)Nnestedrrrgrgrhis_py_nested_functionr{rcCr)Nsparserrrgrgrhis_py_sparse_functionr{rcCr)Nspecialrrrgrgrhis_py_special_functionr{rTsymintoutnative_yaml_pathtags_yaml_pathdeprecated_yaml_path template_pathrNonec s>t||dd}t||j}ttt|}t||dd}t||tddd|dt||dd} t || t dddd |d t|| t d d d|dt|| t d dd|dt|| t ddd|dt|| tddddt|| tddd|dt|| tddd|dt|| dddt|| dddt|d!fdd } |d | dS)"NF) install_dir template_dirdry_runTrzpython_variable_methods.cpprrtorchzpython_torch_functions.cpp)r num_shardsrtorch.nnzpython_nn_functions.cpp torch.fftzpython_fft_functions.cpp torch.linalgzpython_linalg_functions.cpp torch.nestedzpython_nested_functions.cpp torch.sparsezpython_sparse_functions.cpp torch.specialzpython_special_functions.cppcSdSNTrgfnrgrgrhqzgen..zpython_return_types.cppcSrrrgrrgrgrhrtrzpython_return_types.hrkdict[str, str]csddddtDiS)Nenum_of_valid_tagscSsg|] }d|d|dqS)z .value("z ", at::Tag::)rg)retagrgrgrhri}sz.gen..gen_tags_enum..)joinsortedrg valid_tagsrgrh gen_tags_enumys zgen..gen_tags_enumzpython_enum_tag.cpp)rkr)r"rnative_functionslistfilterrwload_signaturescreate_python_bindingsrcreate_python_bindings_shardedrrrrrrr"create_python_return_type_bindings)create_python_return_type_bindings_headerrwrite) rrrrrrfmrmethods functionsrrgrrhgen s           rpairspred Callable[[NativeFunction], bool]?dict[BaseOperatorName, list[PythonSignatureNativeFunctionPair]]cCs6tt}|D]}||jr||jjjj|q|Sr)rrrrqrpappend)rrgroupedpairrgrgrhgroup_filter_overloadss rrr"module str | Nonefilenamerc sggggt||}t|tdD]1}||} t||| ||dt||| |dt|| |dd|j dq fdddS) +Generates Python bindings to ATen functionskeyrr#include cs$ddddS)N@generated from /)generated_comment ops_headers py_forwards py_methodspy_method_defstemplate_dir_for_commentsrgrrrrrrrgrhrsz(create_python_bindings..N) rrkeysrtr method_impl method_defextend forward_declsbasewrite_with_template) rrrrrrrrrpr|rgrrhrs$  rc sggt||}t|tdD]$}||}t|\}}|s#dnd||s/dnd|qfdddS)z Generate function to initialize and return named tuple for native functions which returns named tuple and registration invocations in `python_return_types.cpp`. rr cs ddddS)Nrrr)rpy_return_typespy_return_types_registrationsrrgrrpy_return_types_definitionrrgrhrs z4create_python_return_type_bindings..N)rrrrt1generate_return_type_definition_and_registrationsrrr) rrrrrrpr| definitions registrationsrgrrhrs&  rcsjgt||}t|tdD]}||}t|}|sdnd|qfdddS)z Generate function to initialize and return named tuple for native functions which returns named tuple and relevant entry for the map in `python_return_types.cpp`. rrrcsddddS)Nrrr)rpy_return_types_declarationsrrgrrrrgrhrs z;create_python_return_type_bindings_header..N)rrrrt!generate_return_type_declarationsrrr)rrrrrrpr| declarationsrgrrhrs rrintc sbt||}ddd} dfdd } |j||d d d |d |i| | |hdddS)rkv@tuple[BaseOperatorName, list[PythonSignatureNativeFunctionPair]]rkrtcSs |djS)Nr)r)rrgrgrhkey_funcs z0create_python_bindings_sharded..key_funcdict[str, list[str]]c sN|\}}d|jdgtt||dt||dgt||dgdS)Nrrrr)rrrr)rrrrr)rrpfn_pairsrrrrgrhenv_funcsz0create_python_bindings_sharded..env_funcrrrr>rrrr)base_envkey_fn env_callabler sharded_keysN)rrrkrt)rrrkr)r write_shardeditemsr) rrrrrrrrrrrrgrrhrs   rF)skip_deprecatedpyirlist[NativeFunction]rr csBtdfdd }tt||}t||d}|r|S||S) Nrjrrkrcstt|d|dS)Nrr rr)rrrr rgrhgen_signature_pairs8s z,load_signatures..gen_signature_pairsr )rjrrkr)rrmapload_deprecated_signatures)rrrrr r r deprecatedrgr rhr0sr'list[PythonSignatureNativeFunctionPair]cstt}|D] }||jj|qg}t|}tj|td}Wdn1s*wY|D]} t | dt | d\} | drO| dd} dt didd jjDD]} | vsr| vsrJd | qadfdd } d} || D]3}| |jjsqd} t|jj||d}|tt|j|j|j|j|j|jt|jd |jdq| sJd| dtq1|S)N)Loaderrpaten_outr1ScalarcSsi|]}|j|qSrgryreargrgrh iz.load_deprecated_signatures..z*deprecation definiton: Unrecognized value aten_schemarrkrlcsr t|jj|jj}n|jj}t|D]9\}}|tkrF|}|vr.|}d}n |}|j}|j }||jksB||j krEdSq|j durNdSqtj t|j koft ddt j |j DS)NFcss|] \}}||kVqdSrrg)rerbrgrgrh s  zKload_deprecated_signatures..is_schema_compatible..) itertoolschain argumentsr flat_non_outflat_all enumerater~type annotationdefaultreturnsallzip)rr iargarg_name schema_typeschema_annotation schema_arg call_argsis_outknown_constantsschemaschema_args_by_namergrhis_schema_compatibleqs.    z8load_deprecated_signatures..is_schema_compatibleFT)category_overriderr ) rp input_args input_kwargs output_argstensor_options_argsrdeprecated_schemadeprecated_args_exprsr'r zNo native function with name z matched signature: )rrrkrl)rrrrpropenyamlloadr$rparser#endswithreplacer r r"rrqrr7rrr8r9r:r;rtupler'rt)rrrr rrresultsrjdeprecated_defsr aten_namerpr6any_schema_found python_sigrgr0rhrFsj        rcCs(t|j}t|jj}d|g|S)N_)rrprqrr'r)rjrp fieldnamesrgrgrhgen_structseq_typename_keys  rL tuple[list[str], dict[str, str]]cCsi}g}|D]<}t|jjj}|sqt|jj}t|j}||}|durBd|s,dnt|}|||<| d|d|dq||fS)zr Generate block of named tuple type def inits, and add typeref snippets to declarations that use them N NamedTuplerzstatic PyTypeObject* z = generated::get_ _structseq(); rrrqr'rrprLgetr~r)r| typenamestypedefsoverloadrKrptn_keytypenamergrgrhemit_structseq_calls,   rWtuple[list[str], list[str]]c Csi}g}g}|D]h}t|jjj}|sqddd|D}t|jj}t|j}||} | durp|d|s:dnt |} | ||<| d|d|d | d |d t |d | d | d| d| d|d|dq||fS)z Generate block of function in `python_return_types.cpp` to initialize and return named tuple for a native function which returns named tuple and registration invocations in same file. , css|] }d|dVqdS){"z", ""}Nrg)rerrgrgrhrszDgenerate_return_type_definition_and_registrations..NrNrPyTypeObject* get_zI_structseq() { static PyStructSequence_Field NamedTuple_fields[] = { z(, {nullptr} }; static PyTypeObject zh; static bool is_initialized = false; static PyStructSequence_Desc desc = { "torch.return_types.z", nullptr, NamedTuple_fields, zB }; if (!is_initialized) { PyStructSequence_InitType(&z, &desc); zm.tp_repr = (reprfunc)torch::utils::returned_structseq_repr; is_initialized = true; } return &z; } z$addReturnType(return_types_module, "z", generated::get_z_structseq());) rrrqr'rrrprLrQr~r) r|rRrrrTrKfieldsrprUrVrgrgrhrsN    r list[str]cCsi}g}|D];}t|jjj}|sqt|jj}t|j}||}|durA|d|s.dnt|}|||<| d|dq|S)z Generate block of function declarations in `python_return_types.h` to initialize and return named tuple for a native function. NrNrr[rOrP)r|rRrrTrKrprUrVrgrgrhrs"   ra\ // ${name} static PyObject * ${pycname}(PyObject* self_, PyObject* args, PyObject* kwargs) { ${method_header} static PythonArgParser parser({ ${signatures} }, /*traceable=*/${traceable}); ParsedArgs<${max_args}> parsed_args; auto _r = parser.parse(${self_}, args, kwargs, parsed_args); ${check_has_torch_function} switch (_r.idx) { ${dispatch} } ${method_footer} } z&case ${overload_index}: { ${body} } ao// ${name} static PyObject * ${pycname}(PyObject* self_, PyObject* args, PyObject* kwargs) { ${method_header} static PythonArgParser parser({ ${signatures} }, /*traceable=*/${traceable}); ParsedArgs<${max_args}> parsed_args; auto _r = parser.parse(${self_}, args, kwargs, parsed_args); ${check_has_torch_function} ${dispatch} ${method_footer} } z// ${name} static PyObject * ${pycname}(PyObject* self_, PyObject* args) { ${method_header} ${check_has_torch_function} ${dispatch} ${method_footer} } c CsHt|}t|}t|\}}dg} | |7} | |rdgng7} |r"gndgdg} tdd|Dr3dnd} t||d } t| d k} g}g}t| D],\}}|jj|d }| t t |d t |||d }| | srt j||d n|qI|r{t}n| rt}nt}|j||| td d|D|| t||||d|| |rdd Sdd S)z? Generate a python binding for all overloads of an op. HANDLE_TH_ERRORSz/const Tensor& self = THPVariable_Unpack(self_);Py_RETURN_NONE;END_HANDLE_TH_ERRORScss|]}t|jVqdSr)r'rreorgrgrhrzmethod_impl..truefalserr%,)overload_indexbodycss|]}|jVqdSr)rrrargrgrhrrc)rprnoargrself_nullptr) rppycname method_headermax_args signatures traceablecheck_has_torch_functiondispatch method_footerrj)rzrrWr(group_overloadsr~r#r signature_strrrrtemit_dispatch_casePY_VARIABLE_CASE substitutePY_VARIABLE_METHOD_NOARGS$PY_VARIABLE_METHOD_VARARGS_SINGLETONPY_VARIABLE_METHOD_VARARGSmaxgen_has_torch_function_check)rprr|rrrlristructseq_initsstructseq_typenamesrmrsrpgrouped_overloads is_singletonrorrrgrTr dispatch_bodytemplatergrgrhrsf    rricCs`|r |r d|dSdS|rdnd}|r dddd d d d d |nd}d|d|d|p,ddS)NzMif(check_has_torch_function(self_)) { return handle_torch_function(self_, "z"); } rrjrkTHPVariableFunctionsModuleTHPNNVariableFunctionsModuleTHPFFTVariableFunctionsModule THPLinalgVariableFunctionsModule THPNestedVariableFunctionsModule THPSparseVariableFunctionsModule!THPSpecialVariableFunctionsModule)rrrrrrrTHPVariableClasszAif(_r.has_torch_function()) { return handle_torch_function(_r, z, args, kwargs, z, "z torch.Tensorrg)rprrirrj namespacergrgrhr}s8   r}zRif (_r.isNone(${out_idx})) { ${call_dispatch} } else { ${call_dispatch_out} } rTrrrc CsT|jdur tj|jt|j|j||dt|j|j||ddSt|j|j||dS)a0 Emit dispatch code for a single parsed signature. This corresponds to either a single native function, or a pair that differ only in output params. In the latter case, a single python signature is used for both and dispatching switches on the presence/absence of passed output args. Nr)out_idx call_dispatchcall_dispatch_out)outplacePY_VARIABLE_OUTrxr output_idxemit_single_dispatchr)rTrrrgrgrhrvs   rvtuple[str, ...]cCs4|rdSt|}t|rd|dfSd|dfS)Nrgzstatic PyObject * z#(PyObject* self_, PyObject* args); z5(PyObject* self_, PyObject* args, PyObject* kwargs); )rzr)rpr|rrlrgrgrhrsrcCsht|}|jr d|d}t|r|rdnd}nd|d}d}|dkr(|d7}d |d |d |d S) z$ Generate method def entry. zTypeError_to_NotImplemented_<> METH_NOARGSzMETH_VARARGS | METH_KEYWORDSzcastPyCFunctionWithKeywords(rrz | METH_STATICrZz", rYz , nullptr},)rz dunder_methodr)rprr|rrlflagsrgrgrhr<s   rSequence[PythonSignatureGroup]c s`i}i|D]C}|jjd|d}|jjr0|vr+td|jjd|jjd||<q||vrEtd|jjd||jjd|||<qD]P\}}||vrg}|D]'}t|jjjjt|jjjjkr|jjs|jj s| |jjd|dqZ|jj|d}td|d|d d d d |DqNfd d|D}t ||dS)NT) skip_outputsrz(Found duplicated function definition: - z. Existing definition: - .rz4While identifying overloads, we found an out schema z] without a corresponding non-out variant. We expected the non-out variant to have schema: - zy Please check that you spelled the schema correctly in native_functions.yaml. We discovered the following candidate(s): rcss|]}d|VqdS)z- Nrg)re candidatergrgrhrrcz"group_overloads..cs$g|]\}}tj||dqS)) functionalr)r from_pairsrQ)resigr outplacesrgrhrisz#group_overloads..) rrurrq is_out_fn RuntimeErrorrrtrprrrsort_overloads) r|rbasesrTrr candidatesout_sigrrgrrhrt_sb          rtrc sddddfd d }tfd ddtttD]\}}tD]\}}||j|jr8||q&qs@tSt}ttfddt |}t |D]"} || } t D]} | } | | | sv| =| | qaqUfdd|DS)Nt1r t2rkrlcSst|dkr t|dkpbt|dkot|dkpbdt|vo#dt|vpbt|dko5t|dkp5t|dkpbt|d koDt|d d kpbt|d koPt|dkpbt|d ks]t|dkobt|dkS)NrTensorzScalar?zTensor?Dimnamezint[]rzint?zTensor[]z[]zSymInt[]SymInt)rtfind)rrrgrgrhis_arg_smallers*           z&sort_overloads..is_arg_smallers1rs2csl|jdd|jdd}}t|t|krdStddt||D}tfddt||D}|o5| S)z-Returns True if s1 < s2 in the partial order.T)rFcss |] \}}|j|jkVqdSr)r$rearg1arg2rgrgrhrsz5sort_overloads..is_smaller..c3s6|]\}}t|jt|jkp|j|jVqdSr)rtr$rrrgrhrs  )r r~r(r))rrargs1args2equalsmaller_or_equalrrgrh is_smallers  z"sort_overloads..is_smallercs|jjdS)Nr)rruxrrgrhrsz sort_overloads..rcs|vSrrgr) larger_thanrgrhrscsg|]}|qSrgrg)rer)rrgrhrirz"sort_overloads..)rr rr rkrl)rrrrrkrl) rrsetr#raddrr~rrangerdiscardr) rrri1 overload1i2 overload2N sorted_idsidxr*jlargerrg)rrrrrhrs6     rpsrcstdfdd }||S) z: Emit dispatch code for a single native function. rjrrkrtcsttr dj}nd|j}t|j}dddt|dD}t|}t |}dt |d}t |d}t |d}d|j } d|j} jo`t| p`jo`d |v} | rld |d jd nd } |d kr|jjj} t|jjdr|jtjkr| durt| jjsJd}nd}|d| d|d|d|d|d|d|d| d | d|dSt|}|dur|dnd }|d| d|d|d|d|d|d|d|d| d | dS)Nz// [deprecated] aten::z // aten::rYcss"|] }|jd|jVqdS) N)type_strrprrgrgrhr2s z3emit_single_dispatch..go..r)python_signaturer requires_gradz.set_requires_grad(rrvoid _foreach_z\PyObject* self_tensorlist = _r.args[0]; Py_INCREF(self_tensorlist); return self_tensorlist; r_z auto dispatch_z = [](z) -> z, { pybind11::gil_scoped_release no_gil; (z); }; dispatch_z; z3 { pybind11::gil_scoped_release no_gil; return z); }; return wrap( dispatch_z); ) isinstancerr<rqrrprr r r rrr initsexprsr;r rexprr self_argrt startswithkindrinplacer&argumentr$rQrL)rjschema_commentrplambda_formals lambda_returndispatch_callee dispatch_argsparser_outputslambda_arg_exprsr lambda_argsneed_set_requires_gradset_requires_gradr return_stmtrVstructseq_typerefrrrrgrhgo(s            z emit_single_dispatch..goNrjrrkrtr)rrjrrrrgrrhrs Sr)rjrrkrl)rprrkrt)r|r}rkrl)rrtrrtrrtrrtrrtrrlrkr)rr}rrrkr)rr"rr}rrrrrrtrrlrrlrkr) rr"rr}rrrrtrkr)rr"rr}rrrrrrtrrlrrrrlrkr) rr rrtrrlrrlr rlrkr}) rr}rrtrrlr rlrkrr)r|r}rkrM)r|r}rkrX)r|r}rkr]) rprrrr|r}rrlrrlrkrt) rprrrrirlrrlrkrt)rTrrrrrlrkrt)rprr|r}rrlrkr) rprrrr|r}rrlrkrt)r|r}rrlrkr)rrrrlrkr) rrrjrrrrrlrkrt)^ __future__rrrc collectionsrtypingrrr? torchgen.apirtorchgen.api.pythonrrr r r r r rrrrrrrtorchgen.code_templatertorchgen.contextr torchgen.genrrrtorchgen.modelrrrrrr r!torchgen.utilsr"r#torchgen.yaml_utilsr$gen_inplace_or_view_typer&gen_trace_typer'collections.abcr(r)_SKIP_PYTHON_BINDINGSrrrurwrzrrrrrrrrrrrrrrrrrrLrWrrr{rwrzryrr}rrvrrrtrrrgrgrgrhs !  @  $    V            | ) ')3 v    3&  E$ ( $g]