U MhS@sddlZddlZddlmZddlmZmZmZmZm Z m Z m Z m Z ddl Z ddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlm Z ddl!m"Z"ddl#m$Z$m%Z%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.dd l/m0Z0m1Z1dd l2m3Z3d d l4m5Z5d dl6m7Z7dddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dagSZ8dbdce8DZ9dddedfdgdhdidjdkgZ:e"e+e;dldmdnZe ee;drdsdtZ?e+e;dldudvZ@e+e;dldwdxZAe+e;dldydzZBe+e;dld{d|ZCe+e;dld}d~ZDe+e;dlddZEe+e;dlddZFe+e;dlddZGdde=e=e=e=e=e;ddddZHe eee+ge;fee)eefdddZIdde0e eee+ge;fe e=e=e;e;ddddZJe0e eee+ge;fe=ddddZKe0e eee+ge;fe=ddddZLdde0e eee+ge;fe e=e=e;eMe;dd ddZNdddee+e=e;e;e;e edddZOe ee=e;e;eedddZPe"e+e=dlddZQe ee ee=ee=e=ffdrddZRe ee ee=ee=fdrddZSe eee=drddZTe dZUe dZVe dZWe dZXdde)e e=e ee;e;e=dddZYe)e e=e;e;e=dddZZe dZ[ddeee=e=fe;e=dddZ\e)e ee;e e=dfdddZ]e)e e=e ee;e=dddZ^dde ee;e edddZ_dde ee;e eddd„Z`ddee+ee=e=fe;e=dÜddńZadS)N) defaultdict)CallableDictIterableListOptionalSequenceSetTuple)cpp)arg_parser_output_exprscpp_dispatch_exprscpp_dispatch_targetdispatch_lambda_argsdispatch_lambda_exprsdispatch_lambda_return_strhas_tensor_optionsPythonSignaturePythonSignatureDeprecatedPythonSignatureGroup!PythonSignatureNativeFunctionPair signaturesignature_from_schemastructseq_fieldnames) CodeTemplate)with_native_function) cpp_stringparse_native_yamlparse_tags_yaml)ArgumentBaseOperatorNameFunctionSchemaNativeFunction SchemaKindTypeVariant) FileManagersplit_name_params) YamlLoader)is_tensor_list_type) should_tracealias contiguousZis_cudaZ is_sparseZ is_sparse_csrsizeZstrideZsym_sizeZ sym_strideZsym_storage_offsetZ sym_numelz .*_backwardz#.*_backward_(out|input|weight|bias)z .*_forwardz.*_forward_outz.*_jvpZ _unsafe_viewZtensorz2_?sparse_(coo|compressed|csr|csc|bsr|bsc)_tensor.*z_range.*Z_sparse_add_outz _sparse_div.*z _sparse_mul.*z _sparse_sub.*Z_sparse_dense_add_outindexZ index_outZunique_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.*sliceitemZ_local_scalar_densetoZ_to_copyZ _to_copy_outZ _reshape_copyZ_reshape_copy_outZcopy_sparse_to_sparse_Zcopy_Z _foreach_copyZnumpy_TZmatrix_HZmTZmHznonzero(_(out|numpy))?set_dataz.*_overrideabledataZis_leafZ output_nr_versionZrequires_grad_Z retains_gradset_Z _fw_primalZ)fake_quantize_per_tensor_affine_cachemaskZ*fake_quantize_per_channel_affine_cachemaskZ!_new_zeros_with_same_feature_metaZ_has_same_storage_numelZ_reshape_aliasZreplace_copyz fill.Tensorz fill.Scalarzlift.*Znormal_functionalnbytesitemsizeZ_batch_norm_with_updateZ_batch_norm_with_update_outZ_batch_norm_no_updatecCsg|]}td|dqS)^$)recompile).0patternr@a/var/www/html/venv/lib/python3.8/site-packages/torchgen/packaged/autograd/gen_python_functions.py srBz?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!)freturncCsdd|jkrd|jkrdSt|j}tD]}||r(dSq(t|j}tD]}||krLdSqLdS)N generatedZ view_copyFT)tagsr namefuncSKIP_PYTHON_BINDINGSmatchstrSKIP_PYTHON_BINDINGS_SIGNATURES)rDrHZ skip_regexrr?r@r@rAshould_generate_py_bindings   rN)rHrEcCs d|S)NZ THPVariable_r@rHr@r@rA get_pycnamesrP) overloadsrEcCst|dko|djdkS)Nr)r)lenrarguments_count)rQr@r@rAis_noargsrTcCs|jdkotj|jkSN) python_moduler%methodvariantsrDr@r@rAis_py_variable_methodsrZcCs|jdkotj|jkSrU)rVr%functionrXrYr@r@rAis_py_torch_functionsr\cCs |jdkS)NnnrVrYr@r@rAis_py_nn_functionsr_cCs |jdkS)NZfftr^rYr@r@rAis_py_fft_functionsr`cCs |jdkS)NZlinalgr^rYr@r@rAis_py_linalg_functionsracCs |jdkS)Nnestedr^rYr@r@rAis_py_nested_functionsrccCs |jdkS)Nsparser^rYr@r@rAis_py_sparse_functionsrecCs |jdkS)Nspecialr^rYr@r@rAis_py_special_functionsrgTsymint)outnative_yaml_pathtags_yaml_pathdeprecated_yaml_path template_pathrirEc sJt||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|tttfdfdd } |d| dS) NF)Z install_dirZ template_dirdry_runTrWzpython_variable_methods.cpprWritorchzpython_torch_functions.cpp)rW num_shardsritorch.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.cppcSsdSNTr@fnr@r@rAlzgen..zpython_return_types.cppcSsdSr{r@r|r@r@rAr~orzpython_return_types.h)rEcsddddtDiS)NZenum_of_valid_tagscSsg|]}d|d|dqS)z .value("z ", at::Tag::)r@)r>tagr@r@rArBxsz.gen..gen_tags_enum..)joinsortedr@ valid_tagsr@rA gen_tags_enumts zgen..gen_tags_enumzpython_enum_tag.cpp)r&rnative_functionslistfilterrNload_signaturescreate_python_bindingsrZcreate_python_bindings_shardedr\r_r`rarcrerg"create_python_return_type_bindings)create_python_return_type_bindings_headerrrrLwrite) rjrkrlrmrnrifmrmethodsZ functionsrr@rrAgens         r)pairspredrEcCs6tt}|D]$}||jr ||jjjj|q |SrU)rrr[rIrHappend)rrgroupedpairr@r@rAgroup_filter_overloadss  r)rrrmodulefilenamerWrirEc sggggt||}t|tdD]b}||} t||| ||dt||| |dt|| |dd|j dq* fdddS) +Generates Python bindings to ATen functionskeyrqrp#include cs$ddddS)N@generated from /)generated_comment ops_headers py_forwards py_methodspy_method_defstemplate_dir_for_commentsr@rrrrrrr@rAr~sz(create_python_bindings..N) rrkeysrLr method_impl method_defextend forward_declsbasewrite_with_template) rrrrrrWrirrHrQr@rrArs$  r)rrrrrEc sggt||}t|tdD]H}||}t|\}}|sFdnd||s^dnd|q"fdddS)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)rZpy_return_typespy_return_types_registrationsrr@rrZpy_return_types_definitionrr@rAr~s z4create_python_return_type_bindings..N)rrrrL1generate_return_type_definition_and_registrationsrrr) rrrrrrHrQ definitions registrationsr@rrArs&  rcsjgt||}t|tdD],}||}t|}|s>dnd|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_declarationsrr@rrrr@rAr~s z;create_python_return_type_bindings_header..N)rrrrL!generate_return_type_declarationsrrr)rrrrrrHrQ declarationsr@rrArs  r) rrrrrrWrtrirEc st||}ttttftddd} ttttfttttfdfdd } |j||ddd| d |i| | |d d d d hddS)r)kvrEcSs |djS)Nr)r)rr@r@rAkey_func sz0create_python_bindings_sharded..key_funcc sN|\}}d|jdgtt||dt||dgt||dgdS)Nrrrprq)rrrr)rrrrr)rrHZfn_pairsrWrrir@rAenv_funcsz0create_python_bindings_sharded..env_funcrrrrrrrr)Zbase_envZkey_fnZ env_callablertZ sharded_keysN) rr r rrrLrZ write_shardeditemsr) rrrrrrWrtrirrrr@rrArs(    rF)skip_deprecatedpyi)rrmrWrrrEcsHtttdfdd }tt||}t||d}|r@|S||S)NrCcstt|d|dS)NrWrrr[)rrrYrr@rAgen_signature_pairs3s z,load_signatures..gen_signature_pairsr)rr"rrmapload_deprecated_signatures)rrmrWrrrr deprecatedr@rrAr+sr)rrmrWrrEcstt}|D]}||jj|q g}t|}tj|td}W5QRX|D]2} t | dt | d\} | dr| dd} dt didd jjDD]"} | ks| kstd | qt td fd d } d} || D]h}| |jjsqd} t|jj||d}|tt|j|j|j|j|j|jt|jd |jdq| sNtd| dt qN|S)N)LoaderrHZatenZ_outr1ScalarcSsi|] }|j|qSr@rOr>ar@r@rA dsz.load_deprecated_signatures..z*deprecation definiton: Unrecognized value ) aten_schemarEcsrt|jj|jj}n|jj}t|D]r\}}|tkr|}|kr\|}d}n|}|j}|j }||jks||j krdSq*|j dkr*dSq*tj t|j kot ddt j |j DS)NFcss|]\}}||kVqdSrUr@)r>rbr@r@rA szKload_deprecated_signatures..is_schema_compatible..) itertoolschain argumentsrjZ flat_non_outflat_all enumeraterRtype annotationdefaultreturnsallzip)rriargarg_nameZ schema_typeZschema_annotationZ schema_argZ call_argsZis_outZknown_constantsZschemaZschema_args_by_namer@rAis_schema_compatiblels,   z8load_deprecated_signatures..is_schema_compatibleFT)category_overriderWr) rH input_args input_kwargs output_argstensor_options_argsrWdeprecated_schemaZdeprecated_args_exprsrrzNo native function with name z matched signature: )!rrrrHropenyamlloadr(r!parser'endswithreplacer$rrAssertionErrorboolr[rIrrrrrrrrrWtuplerrL)rrmrWrrrresultsrDZdeprecated_defsrZ aten_namerHrZany_schema_foundZ python_sigr@rrArAst        rcCs(t|j}t|jj}d|g|S)N_)r rHrIrrr)rDrH fieldnamesr@r@rAgen_structseq_typename_keys  rcCsi}g}|D]x}t|jjj}|s$q t|jj}t|j}||}|dkr d|sXdnt|}|||<| 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(); rr[rIrr rHrgetrRr)rQ typenamesZtypedefsoverloadrrHtn_keytypenamer@r@rAemit_structseq_calls*   rc Csi}g}g}|D]}t|jjj}|s(qddd|D}t|jj}t|j}||} | dkr|d|stdnt |} | ||<| 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", ""}Nr@)r>r}r@r@rArszDgenerate_return_type_definition_and_registrations..NrrPyTypeObject* 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());) rr[rIrrr rHrrrRr) rQrrrrrfieldsrHrrr@r@rArsL   rcCsi}g}|D]v}t|jjj}|s$q t|jj}t|j}||}|dkr |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. Nrrrrr)rQrrrrrHrrr@r@rArs   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} } )rHrrQrWrirEc CsHt|}t|}t|\}}dg} | |7} | |r6dgng7} |rDgndgdg} tdd|Drfdnd} t||d } t| d k} g}g}t| D]X\}}|jj|d }| t t |d t |||d }| | st j||d n|q|rt}n| rt}nt}|j||| td d|D|| t||||d|| |r@dndd S)z? Generate a python binding for all overloads of an op. ZHANDLE_TH_ERRORSz/const Tensor& self = THPVariable_Unpack(self_);Py_RETURN_NONE;ZEND_HANDLE_TH_ERRORScss|]}t|jVqdSrU)r+r[r>or@r@rArszmethod_impl..truefalserhr),)overload_indexbodycss|]}|jVqdSrU)rrSrr@r@rArs)rHrnoargrWself_nullptr) rHpycname method_headerZmax_args signatures traceableZcheck_has_torch_functiondispatch method_footerr )rPrTrrgroup_overloadsrRrr signature_strrrrLemit_dispatch_casePY_VARIABLE_CASE substitutePY_VARIABLE_METHOD_NOARGS$PY_VARIABLE_METHOD_VARARGS_SINGLETONPY_VARIABLE_METHOD_VARARGSmaxgen_has_torch_function_check)rHrrQrWrirr Zstructseq_initsstructseq_typenamesrrrgrouped_overloadsZ is_singletonrrr rrZ dispatch_bodytemplater@r@rAr|sf     r)rHrr rWrEcCs`|r|rd|dSdS|r dnd}|r@dddd d d d d |nd}d|d|d|pXddS)NzMif(check_has_torch_function(self_)) { return handle_torch_function(self_, "z"); } rr r ZTHPVariableFunctionsModuleZTHPNNVariableFunctionsModuleZTHPFFTVariableFunctionsModuleZ THPLinalgVariableFunctionsModuleZ THPNestedVariableFunctionsModuleZ THPSparseVariableFunctionsModuleZ!THPSpecialVariableFunctionsModule)rrrurvrwrxryrzZTHPVariableClasszAif(_r.has_torch_function()) { return handle_torch_function(_r, z, args, kwargs, z, "z torch.Tensorr@)rHrr rWr  namespacer@r@rArs8  rzRif (_r.isNone(${out_idx})) { ${call_dispatch} } else { ${call_dispatch_out} } )rrrirEc CsX|jdk r@tj|jt|j|j||dt|j|j||ddSt|j|j||dSdS)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. Nrh)Zout_idxZ call_dispatchZcall_dispatch_out)ZoutplacePY_VARIABLE_OUTrrZ output_idxemit_single_dispatchr)rrrir@r@rArs, r.)rHrQrWrEcCs8|rdSt|}t|r&d|dfSd|dfSdS)Nr@zstatic PyObject * z#(PyObject* self_, PyObject* args); z5(PyObject* self_, PyObject* args, PyObject* kwargs); )rPrT)rHrQrWrr@r@rArsr)rHrrQrWrEcCsht|}|jrd|d}t|r0|r*dnd}nd|d}d}|dkrP|d7}d |d |d |d S) z$ Generate method def entry. zTypeError_to_NotImplemented_<>Z METH_NOARGSzMETH_VARARGS | METH_KEYWORDSzcastPyCFunctionWithKeywords(rrrz | METH_STATICrz", rz, NULL},)rPZ dunder_methodrT)rHrrQrWrflagsr@r@rAr7s   r)rQrirEc s`i}i|D]}|jjd|d}|jjr`|krVtd|jjd|jjd||<q ||krtd|jjd||jjd|||<q D]\}}||krg}|D]N}t|jjjjt|jjjjkr|jjs|jj s| |jjd|dq|jj|d}td|d|d d d d |Dqfd d|D}t ||dS)NT) skip_outputsriz(Found duplicated function definition: - z. Existing definition: - .rhz4While 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- Nr@)r> candidater@r@rArsz"group_overloads..cs$g|]\}}tj||dqS))Z functionalrj)rZ from_pairsr)r>sigrZ outplacesr@rArBs z#group_overloads..) rrr[rIZ is_out_fn RuntimeErrorrrLrHrrrsort_overloads) rQribasesrr)rj candidatesZout_sigrr@r*rArZsV     r)rrirEc stttdddtttdfdd }tfddd tttD]6\}}tD]$\}}||j|jr\||q\qLst St }t t fd dt |}t |D]D} || } t D]*} | } | | | s҈| =|| qqfd d |DS) N)t1t2rEcSst|dkrt|dkpt|dkr0t|dkpdt|krHdt|kpt|dkrlt|dkpt|dkpt|d krt|d d kpt|d krt|dkpt|d kst|dkot|dkS)NrZTensorzScalar?zTensor?ZDimnamezint[]intzint?zTensor[]z[]zSymInt[]ZSymInt)rLfind)r/r0r@r@rAis_arg_smallers*           z&sort_overloads..is_arg_smaller)s1s2rEcsl|jdd|jdd}}t|t|kr.dStddt||D}tfddt||D}|oj| S)z-Returns True if s1 < s2 in the partial order.T)r&Fcss|]\}}|j|jkVqdSrU)rr>Zarg1Zarg2r@r@rArsz5sort_overloads..is_smaller..c3s4|],\}}t|jt|jkp*|j|jVqdSrU)rLrr7r4r@rArs)rrRrr)r5r6Zargs1Zargs2equalZsmaller_or_equalr8r@rA is_smallers z"sort_overloads..is_smallercs|jjdS)Nrh)rrxrhr@rAr~rz sort_overloads..rcs|kSrUr@r;) larger_thanr@rAr~rcsg|] }|qSr@r@)r>r<)rr@rArBsz"sort_overloads..)r$rrrrsetrraddrrRrrangerdiscardr) rrir:i1Z overload1i2Z overload2NZ sorted_idsidxrjZlargerr@)rr4r=rirAr,s0   r,)psrDrrirEcs$tttdfdd }||S)z: Emit dispatch code for a single native function. rCcsttrdj}n d|j}jr.dnd}t|j}dddt|dD}t |}t |}dt |d }t |d}t |d} d | j} d| j} jot| pΈjod |k} | rd |d jd nd} |dkr|jjj}t|jjdrF|jtjkrF|dk r.go..rh)Zpython_signaturerZ requires_gradz.set_requires_grad(rvoidZ _foreach_z\PyObject* self_tensorlist = _r.args[0]; Py_INCREF(self_tensorlist); return self_tensorlist; rz 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(Z dispatch_z); )! isinstancerrrIrr rHrrrrr r rinitsZexprsrrrWexprrself_argrL startswithkindr#Zinplacer*argumentrrrr)rDZschema_commentrrHZlambda_formalsZ lambda_returnZdispatch_calleeZ dispatch_argsZparser_outputsZlambda_arg_exprsrLZ lambda_argsZneed_set_requires_gradZset_requires_gradrNZ return_stmtrZstructseq_typerefrGrrir@rAgo#s              z emit_single_dispatch..go)rr"rL)rGrDrrirSr@rRrAr#s Ur#)brr< collectionsrtypingrrrrrrr r rZ torchgen.apir Ztorchgen.api.pythonr r rrrrrrrrrrrrZtorchgen.code_templaterZtorchgen.contextrZ torchgen.genrrrZtorchgen.modelrr r!r"r#r$r%Ztorchgen.utilsr&r'Ztorchgen.yaml_utilsr(Zgen_inplace_or_view_typer*Zgen_trace_typer+Z_SKIP_PYTHON_BINDINGSrJrMrrNrLrPrTrZr\r_r`rarcrergrrrrrr1rrrrrrrrrrrrrr"rrrrr,r#r@r@r@rA"s ( @  $    V  }    *  (  )  3  v  4 &  F $  )  $ g ]