U
    Mh[}                     @   s  d dl mZmZmZmZ d dlmZmZmZm	Z	m
Z
 d dlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z! d dl"m#Z# d dl$m%Z%m&Z& d dl'm(Z( ddl)m*Z* e#d	Z+e#d
Z,e#dZ-e#dZ.e#dZ/e#dZ0e#dZ1e#dZ2e#dZ3e#dZ4e#dZ5e#dZ6e#dZ7e#dZ8e#dZ9e#dZ:e#dZ;e#dZ<e#dZ=dZ>dZ?dZ@dZAd ZBd!ZCd"ZDd#ZEd$ZFd%ZGd&ZHd'ZId(ZJd)ZKeeee<eEfeeee<eFfeee7eGfeeee<eGfeee7eHfeee7eJfeeee<eJfiZLe*ZMee&eeNef f ee d*d+d,ZOeNee&eeNef f eNd-d.d/d0ZPeNee&eeNef f eNd-d.d1d2ZQee#eNd3d4d5ZRd-S )6    )DictListSequenceTuple)
DerivativeDifferentiabilityInfoSavedAttributeuses_retain_variablesuses_single_grad)ArrayRefCTypeBaseCppType	BaseCTypeBindingboolTdoubleTintArrayRefTiTensorListRefT	ListCTypelongTMutRefCTypeOptionalCTypeoptionalIntArrayRefToptionalSymIntArrayRefTscalarTstringTsymIntArrayRefTSymIntTTENSOR_LIST_LIKE_CTYPEStensorListTtensorTVectorCType)CodeTemplate)ArgumentFunctionSchema)FileManager   )VIEW_FUNCTIONSa_  #ifdef _WIN32
struct ${op} : public ${superclass} {
  TORCH_API ${op}() = default;
#else
struct TORCH_API ${op} : public ${superclass} {
#endif
  using ${superclass}::${superclass};
  variable_list apply(variable_list&& grads) override;
  std::string name() const override { return "${op}"; }
  void release_variables() override {
    ${thread_lock}
    ${release_variables}
  }
  ${will_release_variables}
  void compiled_args(CompiledNodeArgs& args) override;
  variable_list apply_with_saved(const variable_list& inputs, SwapSavedVariables& saved) override;
  ${saved_variables}
  ${saved_list_sizes}
};
zebool retain_variables = true;
void will_release_variables() override {
  retain_variables = false;
}
a  variable_list ${op}::apply(variable_list&& grads) {
  ${thread_lock}
  ${asserts}
  IndexRangeGenerator gen;
  ${compute_index_ranges}
  variable_list grad_inputs(gen.size());
  ${body}
  return grad_inputs;
}
void ${op}::compiled_args(CompiledNodeArgs& args) {
    ${compiled_args}
}
variable_list ${op}::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
    ${apply_with_saved_before}
    variable_list result = apply(variable_list(grads));
    ${apply_with_saved_after}
    return result;
}
zB  auto grad_input_mask = std::array<bool, ${n}>{
    ${masks}
  };zif (task_should_compute_output({ ${name}_ix })) {
  auto grad_result = ${derivative};
  copy_range(grad_inputs, ${name}_ix, grad_result);
}
as  if (task_should_compute_output({ ${name}_ix })) {
  std::vector<Tensor> grad_result;
  grad_result.reserve(grads.size());
  for (const auto & i : c10::irange(grads.size())) {
    if (grads[i].defined()) {
      grad_result.emplace_back(${derivative});
    } else {
      grad_result.emplace_back(Tensor());
    }
  }
  copy_range(grad_inputs, ${name}_ix, grad_result);
}
z~  if (task_should_compute_output({ ${name}_ix })) {
    copy_range(grad_inputs, ${name}_ix, std::get<${i}>(grad_result));
  }
zif (task_should_compute_output({ ${idx_ranges} })) {
  ${grad_input_mask}
  auto grad_result = ${derivative};
  ${copy_ranges}
}
z`static PyTypeObject ${op}Class;
addClass<${op}>(module, ${op}Class, "${op}", ${op}_properties);
z${all_getter_definitions}

static struct PyGetSetDef ${op}_properties[] = {
  THP_FUNCTION_DEFAULT_PROPERTIES,
  ${all_getsetdef_structs}
  {nullptr} /* sentinel */
};

zU{(char*)"_saved_${name}", (getter)THP${op}_${name}_getter, nullptr, nullptr, nullptr}z]{(char*)"_raw_saved_${name}", (getter)THP${op}_${name}_raw_getter, nullptr, nullptr, nullptr}zPyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  auto prop = static_cast<${op}*>(self->cdata.get())->${name};
  ${body}
  END_HANDLE_TH_ERRORS
}
zPyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  const auto& prop = static_cast<${op}*>(self->cdata.get())->${name}_;
  ${body}
  END_HANDLE_TH_ERRORS
}
zPyObject* THP${op}_${name}_raw_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  const auto& prop = static_cast<${op}*>(self->cdata.get())->${name}_;
  ${body}
  END_HANDLE_TH_ERRORS
}
aW  PyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  const auto *node = static_cast<${op}*>(self->cdata.get());
  const auto& prop = node->${name}_;
  if (node->${name}_released_) {
    PyErr_SetString(PyExc_RuntimeError, ERR_BACKWARD_TWICE);
    return nullptr;
  }
  ${body}
  END_HANDLE_TH_ERRORS
}
a[  PyObject* THP${op}_${name}_raw_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  const auto *node = static_cast<${op}*>(self->cdata.get());
  const auto& prop = node->${name}_;
  if (node->${name}_released_) {
    PyErr_SetString(PyExc_RuntimeError, ERR_BACKWARD_TWICE);
    return nullptr;
  }
  ${body}
  END_HANDLE_TH_ERRORS
}
a  PyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  auto opt_prop = static_cast<${op}*>(self->cdata.get())->${name};
  if (!opt_prop.has_value()) {
    Py_RETURN_NONE;
  }
  auto prop = opt_prop.value();
  ${body}
  END_HANDLE_TH_ERRORS
}
a#  PyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  auto opt_prop = static_cast<${op}*>(self->cdata.get())->${name};
  if (!opt_prop.list.has_value()) {
    Py_RETURN_NONE;
  }
  auto prop = opt_prop.list.value();
  ${body}
  END_HANDLE_TH_ERRORS
}
z3return THPVariable_Wrap(prop.unpack(self->cdata));
zspybind11::object obj = pybind11::cast(prop, pybind11::return_value_policy::reference);
return obj.release().ptr();
zPyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i: c10::irange(prop.size())) {
  PyTuple_SetItem(tup, (Py_ssize_t) i, THPVariable_Wrap(prop[i].unpack(self->cdata)));
}
return tup;
a  PyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i : c10::irange(prop.size())) {
  pybind11::object obj = pybind11::cast(prop[i], pybind11::return_value_policy::reference);
  PyTuple_SetItem(tup, (Py_ssize_t) i, obj.release().ptr());
}
return tup;
zPyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i : c10::irange(prop.size())) {
  PyTuple_SetItem(tup, (Py_ssize_t) i, PyLong_FromUnsignedLong((uint64_t) prop[i]));
}
return tup;
at  PyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i : c10::irange(prop.size())) {
    auto si = prop[i];
    if (auto m = si.maybe_as_int()) {
      PyTuple_SetItem(tup, (Py_ssize_t) i, PyLong_FromUnsignedLong(*m));
    } else {
      auto py_symint = py::cast(si).release().ptr();
      PyTuple_SetItem(tup, (Py_ssize_t) i, py_symint);
    }
}
return tup;
zPyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i : c10::irange(prop.size())) {
  PyTuple_SetItem(tup, (Py_ssize_t) i, PyFloat_FromDouble((double) prop[i]));
}
return tup;
z0return PyLong_FromUnsignedLong((int64_t) prop);
z~if (auto m = prop.maybe_as_int()) {
  return PyLong_FromUnsignedLong(*m);
} else {
  return py::cast(prop).release().ptr();
}
z*return PyFloat_FromDouble((double) prop);
z<if (prop) {
  Py_RETURN_TRUE;
} else {
  Py_RETURN_FALSE;
}
z>return PyUnicode_FromStringAndSize(prop.data(), prop.size());
a  if (prop.isComplex()) {
  auto cprop = prop.to<c10::complex<double>>();
  return PyComplex_FromDoubles(cprop.real(), cprop.imag());
} else if (prop.isFloatingPoint()) {
  return PyFloat_FromDouble(prop.to<double>());
} else if (prop.isIntegral(/*includeBool=*/false)) {
  return PyLong_FromLong(prop.to<int64_t>());
} else if (prop.isBoolean()) {
  if (prop.to<bool>()) {
    Py_RETURN_TRUE;
  } else {
    Py_RETURN_FALSE;
  }
} else {
  PyErr_SetString(PyExc_RuntimeError, "Unknown scalar type");
  return nullptr;
}
a  PyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i: c10::irange(prop.size())) {
  if (prop[i].isComplex()) {
    auto cprop = prop[i].to<c10::complex<double>>();
    PyTuple_SetItem(tup, (Py_ssize_t) i, PyComplex_FromDoubles(cprop.real(), cprop.imag()));
  } else if (prop[i].isFloatingPoint()) {
    auto double_prop = prop[i].to<double>();
    PyTuple_SetItem(tup, (Py_ssize_t) i, PyFloat_FromDouble(double_prop));
  } else if (prop[i].isIntegral(/*includeBool=*/false)) {
    auto long_prop = prop[i].to<int64_t>();
    PyTuple_SetItem(tup, (Py_ssize_t) i, PyLong_FromLong(long_prop));
  } else if (prop[i].isBoolean()) {
    if (prop[i].to<bool>()) {
      PyTuple_SetItem(tup, (Py_ssize_t) i, Py_True);
    } else {
      PyTuple_SetItem(tup, (Py_ssize_t) i, Py_False);
    }
  } else {
    PyErr_SetString(PyExc_RuntimeError, "Unknown scalar type");
    return nullptr;
  }
}
return tup;
)differentiability_infosreturnc                 C   s$   dd |   D }ttdd |S )Nc                 S   s   g | ]}|  D ]}|qqS  )values).0Zdiffinfo_dictinfor)   r)   c/var/www/html/venv/lib/python3.8/site-packages/torchgen/packaged/autograd/gen_autograd_functions.py
<listcomp>  s   
 z3get_infos_with_derivatives_list.<locals>.<listcomp>c                 S   s   | j S N)args_with_derivativesr,   r)   r)   r-   <lambda>      z1get_infos_with_derivatives_list.<locals>.<lambda>)r*   listfilter)r'   Zdiff_info_listr)   r)   r-   get_infos_with_derivatives_list  s    r6   N)outr'   template_pathr(   c              	      sh   t |}dd |D  dd |D d}t| |dddD ](}||  fdd	 q:d
S )zFunctions.h and Functions.cpp body

    These contain the auto-generated subclasses of torch::autograd::Node
    for each every differentiable torch function.
    c                 S   s   g | ]}t |tqS r)   )process_functionFUNCTION_DECLARATIONr+   fr)   r)   r-   r.     s     z.gen_autograd_functions_lib.<locals>.<listcomp>c                 S   s   g | ]}t |tqS r)   )r9   FUNCTION_DEFINITIONr;   r)   r)   r-   r.     s     Z	FunctionsFZinstall_dirZtemplate_dirdry_run)z.hz.cppc                      s    dd   d   dS )N@generated from /)generated_commentZautograd_function_declarationsZautograd_function_definitions)template_dir_for_commentsr)   ZdeclarationsZdefinitionsfmfnamer)   r-   r2     s    z,gen_autograd_functions_lib.<locals>.<lambda>N)r6   r$   Zwrite_with_template)r7   r'   r8   infosZfile_basenamesuffixr)   rE   r-   gen_autograd_functions_lib  s    rJ   c              	      sl   t | |dd d d fdd t|} jd|dd d	d
d   d idd ddhd d S )NFr>      zpython_functions.hc                      s8   dd    d dd tD dd tD dS )Nr@   rA   z/python_functions.hc                 S   s   g | ]}d | dqS )z(void initialize_autogenerated_functions_z(PyObject* module);r)   r+   ir)   r)   r-   r.     s   zCgen_autograd_functions_python.<locals>.<lambda>.<locals>.<listcomp>c                 S   s   g | ]}d | dqS )Z#initialize_autogenerated_functions_z	(module);r)   rL   r)   r)   r-   r.     s   )rC   Zshard_forward_declareZ
shard_call)rD   ranger)   rF   
num_shardsr)   r-   r2     s    z/gen_autograd_functions_python.<locals>.<lambda>zpython_functions.cppc                 S   s   | j S r/   namer1   r)   r)   r-   r2     r3   rC   r@   rA   z/python_functions.cppc                 S   s   t | tgt | tgdS )N)py_function_initializerspy_function_props_and_getters)r9   PY_FUNCTION_DEFINITIONPY_FUNCTION_PROPS_AND_GETTERSr1   r)   r)   r-   r2     s
    rS   rT   )Zkey_fnZbase_envZenv_callablerP   Zsharded_keys)r$   writer6   Zwrite_shardedrD   )r7   r'   r8   rH   r)   rO   r-   gen_autograd_functions_python  s(     rX   )r,   templater(   c                    s>  g g g }g 	g g }g g g g g  j D ]N}|jtkrb|j d}|d|j d nd}|d|j d| d q2ttd d 	f
d	d
}tjdd dD ]}||dd qtj	dd dD ]}||dd qt
dkrd}nd}trt }	nd}	g }
tr<|
d n|
fddtjD  ttt tttf dfdd}|
	 d}jD ](}||j \}}|
| ||O }q|r|
t
j d jtkrd}nd}t
dkrdd nd}d }|jj||||	|
||| d!S )"NZ_size_zsize_t z_size_;1auto z_ix = gen.range();)var	is_outputr(   c           
   	      s  | j j}| j j}d}d}|}|ttks\|tttks\|ttttks\|ttkr|rd| d | d |rdnd}	d| d	| d
| d t	j
j|td tj
j|td d}| d}n|ttks|ttks|tttkr|tttkrJjjjjjdrF|sJtd| d d| d | d | d |rdnd}	d| d| d| d d| d tj
j|td tj
j|td d}| d}n|ttttkrԈd| d d| d | d | d 	d| d| d d| d tj
j|td tj
j|td d}| d}n|ttkrd| d tj
j|td n|ttkrLd| d tj
j|td nH|tt krd| d t!j
j|td n|tt"krĈd| d t!j
j|td n|tttkrd| d t!j
j|td n|tttkrDd| d t!j
j|td nP|tt#tt$krd | d t!j
j|t%d n|tt&kr̈|'  d!| d" tj
j|t(d n|tt)krd#| d tj
j|t*d n|tt+krDd$| d tj
j|t,d nP|ttt+krd%| d t-j
j|t,d n|t#tt.d&d'd(d)d*krd+| d d| d | d, t/d-j
j|t0d nd.|' 1 kr4d/|' 1 kr4d0|' kr4d1|' ksFt|'  d2|'  d!| d |t2krt2| \}}	|j
j||	d nd}|rt3j
j|d3 |r̈t4j
j|d3 d4| d d5| d  d6| d d S )7NTFzSavedVariable z_;z_.reset_data();zshared_from_this() r[   z = z	_.unpack(r\   )oprR   body_Z_foreachzstd::vector<SavedVariable> zbool z_released_ = false;z
_.clear();z_released_ = true;Znullptrz = unpack_list(z_, zTORCH_CHECK(!z _released_, ERR_BACKWARD_TWICE);z = unpack_opt_list(z_);zstd::vector<int64_t> ;zstd::vector<c10::SymInt> zc10::OptionalArray<int64_t> z c10::OptionalArray<c10::SymInt> zc10::OptionalArray<double>  z = 0;zc10::SymInt zstd::string zc10::optional<std::string> atZScalar)nsrR   )type)elemzstd::vector<at::Scalar> z	.clear();ar  PyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  const auto *node = static_cast<${op}*>(self->cdata.get());
  const auto& prop = node->${name};
  if (node->${name}_released_) {
    PyErr_SetString(PyExc_RuntimeError, ERR_BACKWARD_TWICE);
    return nullptr;
  }
  ${body}
  END_HANDLE_TH_ERRORS
}
                            refview*&z. looks like it contains a non-owning reference)r`   rR   zargs.collect(zsaved.before(zsaved.after()5nctyperR   rg   r   r   r   r   r   appendGETTER_DEFINITION_SAVEDVAR
substituter`   GETTER_BODY_SAVEDVARGETTER_DEFINITION_RAW_SAVEDVARGETTER_BODY_RAW_SAVEDVARr   r   r    funcbase
startswithAssertionErrorGETTER_DEFINITION_VEC_SAVEDVARGETTER_BODY_VEC_SAVEDVAR"GETTER_DEFINITION_RAW_VEC_SAVEDVARGETTER_BODY_RAW_VEC_SAVEDVARr   r   GETTER_DEFINITIONGETTER_BODY_ARRAYREF_LONGr   GETTER_BODY_ARRAYREF_SYMINTr   GETTER_DEFINITION_OPT_ARRAYREFr   r   r   GETTER_BODY_ARRAYREF_DOUBLEr   Zcpp_typeGETTER_BODY_INT64_Tr   GETTER_BODY_SYMINTr   GETTER_BODY_STRINGGETTER_DEFINITION_OPTr   r!   GETTER_BODY_VEC_SCALARlowerMISC_GETTER_DEFSPY_GETSETDEF_STRUCTPY_RAW_GETSETDEF_STRUCT)
r]   r^   rR   rg   Zshould_append_getsetdefZshould_append_raw_getsetdefZ
visit_nameZptrZ
getter_defra   
apply_with_saved_afterapply_with_saved_beforeassertscompiled_argsZgetter_definitionsr,   Zpy_getsetdef_structsrelease_variablessaved_variablesunpackr)   r-   save_var/  s   

    

                              



z"process_function.<locals>.save_varc                 S   s   t | jjS r/   strrm   rR   sar)   r)   r-   r2     r3   z"process_function.<locals>.<lambda>)keyF)r^   c                 S   s   t | jjS r/   r   r   r)   r)   r-   r2     r3   Tr   z)std::lock_guard<std::mutex> lock(mutex_);r_   zconst auto& grad = grads[0];c                 3   s(   | ] }d | d j | dV  qdS )zconst auto& z	 = grads[z];N)Zavailable_named_gradientsindex)r+   rR   r1   r)   r-   	<genexpr>0  s   z#process_function.<locals>.<genexpr>)
derivativer0   r(   c                    s(  | j }| j t dkrd}d|krv fdd|D }t|dkrv|d }t|jtrvt|jjdkrvd| d	 }d
}j	drt
}nt}||j d |dfS d|krdd  D }tj|t d}nd}ddd  D }	g }
t D ]\}}|
tj||d qdtj|	|
||dfS d S )Nr%   Fnot_implementedc                    s   g | ]}|j  d  kr|qS )r   rQ   )r+   arg	var_namesr)   r-   r.   >  s     z=process_function.<locals>.emit_derivative.<locals>.<listcomp>r   )ZTensorzTensor?zany_grad_defined ? (z) : Tensor()TZ	_foreach_)rR   r   grad_input_maskc                 S   s   g | ]}d | dqS )ztask_should_compute_output({ z_ix }),r)   r+   nr)   r)   r-   r.   S  s    )masksr   r_   z, c                 s   s   | ]}| d V  qdS )Z_ixNr)   r   r)   r)   r-   r   [  s     z<process_function.<locals>.emit_derivative.<locals>.<genexpr>)rR   rM   )
idx_rangescopy_rangesr   r   )formular   len
isinstanceargumentr"   r   rg   rR   rv   DERIVATIVE_SINGLE_FOREACHDERIVATIVE_SINGLErp   GRAD_INPUT_MASKjoin	enumeratern   DERIVATIVE_MULTI_COPY_RANGEDERIVATIVE_MULTI)r   r0   r   checks_any_grad_definedZmatching_argsr   Zderivative_templater   r   r   r   rM   r   r1   r   r-   emit_derivative5  sT    
 z)process_function.<locals>.emit_derivativez4bool any_grad_defined = any_variable_defined(grads);NodeZTraceableFunctionz,
,
)r`   compute_index_rangesr   r   saved_list_sizesr   thread_lockwill_release_variablesra   
superclassall_getter_definitionsall_getsetdef_structsr   r   r   )r0   rg   r   rR   rn   r   boolsortedZall_saved_inputsZall_saved_outputsr   r	   WILL_RELEASE_VARIABLESrp   r
   extendZused_named_gradientsr   r   r   r   r   ZderivativesinsertUNTRACEABLE_FUNCTIONSr   r`   )r,   rY   r   r   r   sizer   r]   r   r   ra   r   Zneed_any_grad_defined_varr   r   Zderivative_textr   r   r   r)   r   r-   r9     s    

( k



1

 


r9   )Stypingr   r   r   r   Ztorchgen.api.autogradr   r   r   r	   r
   Ztorchgen.api.typesr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    Ztorchgen.code_templater!   Ztorchgen.modelr"   r#   Ztorchgen.utilsr$   Zgen_inplace_or_view_typer&   r:   r   r=   r   r   r   r   r   rU   rV   r   r   r|   ro   rr   rx   rz   r   r   rq   rs   ry   r{   r}   r~   r   r   r   ZGETTER_BODY_DOUBLEZGETTER_BODY_BOOLr   ZGETTER_BODY_SCALARr   r   r   r   r6   rJ   rX   r9   r)   r)   r)   r-   <module>   s   `		
 
  
   
 #/