at::Tensor Class Reference

#include <TensorBody.h>

Inheritance diagram for at::Tensor:

Public Types
template<typename T >
using	hook_return_void_t = std::enable_if_t< std::is_void< typename c10::invoke_result_t< T &, Tensor > >::value, unsigned >
template<typename T >
using	hook_return_var_t = std::enable_if_t< std::is_same< typename c10::invoke_result_t< T &, Tensor >, Tensor >::value, unsigned >
Public Types inherited from at::TensorBase
template<typename T >
using	hook_return_void_t = std::enable_if_t< std::is_void< typename c10::invoke_result_t< T &, TensorBase > >::value, unsigned >
template<typename T >
using	hook_return_var_t = std::enable_if_t< std::is_same< typename c10::invoke_result_t< T &, TensorBase >, TensorBase >::value, unsigned >

Public Member Functions
	Tensor ()=default
	Tensor (c10::intrusive_ptr< TensorImpl, UndefinedTensorImpl > tensor_impl)
	Tensor (const Tensor &tensor)=default
	Tensor (Tensor &&tensor)=default
	Tensor (const TensorBase &base)
	Tensor (TensorBase &&base)
Tensor	contiguous (MemoryFormat memory_format=MemoryFormat::Contiguous) const
Tensor	conj () const
c10::MaybeOwned< Tensor >	expect_contiguous (MemoryFormat memory_format=MemoryFormat::Contiguous) const &
	Should be used if *this can reasonably be expected to be contiguous and performance is important. More...
c10::MaybeOwned< Tensor >	expect_contiguous (MemoryFormat memory_format=MemoryFormat::Contiguous) &&=delete
Tensor &	operator= (const TensorBase &x) &
Tensor &	operator= (TensorBase &&x) &noexcept
Tensor &	operator= (const Tensor &x) &
Tensor &	operator= (Tensor &&x) &noexcept
Tensor &	operator= (const Scalar &v) &&
Tensor &	operator= (const Tensor &rhs) &&
Tensor &	operator= (Tensor &&rhs) &&
	C10_DEPRECATED_MESSAGE ("Tensor.type() is deprecated. Instead use Tensor.options(), which in many cases (e.g. in a constructor) is a drop-in replacement. If you were using data from type(), that is now available from Tensor itself, so instead of tensor.type().scalar_type(), use tensor.scalar_type() instead and instead of tensor.type().backend() use tensor.device().") DeprecatedTypeProperties &type() const
Tensor	toType (ScalarType t) const
Tensor	toBackend (Backend b) const
	C10_DEPRECATED_MESSAGE ("Tensor.is_variable() is deprecated; everything is a variable now. (If you want to assert that variable has been appropriately handled already, use at::impl::variable_excluded_from_dispatch())") bool is_variable() const noexcept
template<typename T >
	C10_DEPRECATED_MESSAGE ("Tensor.data<T>() is deprecated. Please use Tensor.data_ptr<T>() instead.") T *data() const
template<typename T >
T	item () const
template<typename T , size_t N, template< typename U > class PtrTraits = DefaultPtrTraits, typename index_t = int64_t>
	C10_DEPRECATED_MESSAGE ("packed_accessor is deprecated, use packed_accessor32 or packed_accessor64 instead") GenericPackedTensorAccessor< T
index_t	packed_accessor () const &
template<typename T , size_t N, template< typename U > class PtrTraits = DefaultPtrTraits, typename index_t = int64_t>
	C10_DEPRECATED_MESSAGE ("packed_accessor is deprecated, use packed_accessor32 or packed_accessor64 instead") GenericPackedTensorAccessor< T
index_t	packed_accessor () &&=delete
Tensor	operator~ () const
Tensor	operator- () const
Tensor &	operator+= (const Tensor &other)
Tensor &	operator+= (const Scalar &other)
Tensor &	operator-= (const Tensor &other)
Tensor &	operator-= (const Scalar &other)
Tensor &	operator*= (const Tensor &other)
Tensor &	operator*= (const Scalar &other)
Tensor &	operator/= (const Tensor &other)
Tensor &	operator/= (const Scalar &other)
Tensor &	operator&= (const Tensor &other)
Tensor &	operator|= (const Tensor &other)
Tensor &	operator^= (const Tensor &other)
Tensor	operator[] (const Scalar &index) const
Tensor	operator[] (const Tensor &index) const
Tensor	operator[] (int64_t index) const
Tensor	index (ArrayRef< at::indexing::TensorIndex > indices) const
Tensor	index (std::initializer_list< at::indexing::TensorIndex > indices) const
Tensor &	index_put_ (ArrayRef< at::indexing::TensorIndex > indices, Tensor const &rhs)
Tensor &	index_put_ (ArrayRef< at::indexing::TensorIndex > indices, const Scalar &v)
Tensor &	index_put_ (std::initializer_list< at::indexing::TensorIndex > indices, Tensor const &rhs)
Tensor &	index_put_ (std::initializer_list< at::indexing::TensorIndex > indices, const Scalar &v)
Tensor	cpu () const
Tensor	cuda () const
Tensor	hip () const
Tensor	ve () const
Tensor	vulkan () const
Tensor	metal () const
Tensor	meta () const
void	backward (const Tensor &gradient={}, c10::optional< bool > retain_graph=c10::nullopt, bool create_graph=false, c10::optional< TensorList > inputs=c10::nullopt) const
	Computes the gradient of current tensor with respect to graph leaves. More...
const Tensor &	set_requires_grad (bool requires_grad) const
Tensor &	mutable_grad () const
	Return a mutable reference to the gradient. More...
const Tensor &	grad () const
	This function returns an undefined tensor by default and returns a defined tensor the first time a call to backward() computes gradients for this Tensor. More...
const Tensor &	_fw_grad (uint64_t level) const
	This function returns the forward gradient for this Tensor at the given level. More...
void	_set_fw_grad (const TensorBase &new_grad, uint64_t level, bool is_inplace_op) const
	This function can be used to set the value of the forward grad. More...
void	__dispatch__backward (at::TensorList inputs, const c10::optional< at::Tensor > &gradient={}, c10::optional< bool > retain_graph=c10::nullopt, bool create_graph=false) const
void	__dispatch_set_data (const at::Tensor &new_data) const
at::Tensor	__dispatch_data () const
bool	__dispatch_is_leaf () const
int64_t	__dispatch_output_nr () const
int64_t	__dispatch__version () const
at::Tensor &	__dispatch_requires_grad_ (bool requires_grad=true) const
void	__dispatch_retain_grad () const
bool	__dispatch_retains_grad () const
at::Tensor	_fw_primal (int64_t level) const
at::Tensor &	rename_ (c10::optional< at::DimnameList > names) const
at::Tensor	rename (c10::optional< at::DimnameList > names) const
at::Tensor	align_to (at::DimnameList names) const
at::Tensor	align_to (at::DimnameList order, int64_t ellipsis_idx) const
at::Tensor	align_as (const at::Tensor &other) const
at::Tensor	refine_names (at::DimnameList names) const
at::Tensor	abs () const
at::Tensor &	abs_ () const
at::Tensor	absolute () const
at::Tensor &	absolute_ () const
at::Tensor	angle () const
at::Tensor	sgn () const
at::Tensor &	sgn_ () const
at::Tensor	chalf (c10::optional< at::MemoryFormat > memory_format=c10::nullopt) const
at::Tensor	_conj () const
at::Tensor	__dispatch_conj () const
at::Tensor	_conj_physical () const
at::Tensor	conj_physical () const
at::Tensor &	conj_physical_ () const
at::Tensor	resolve_conj () const
at::Tensor	resolve_neg () const
at::Tensor	_neg_view () const
at::Tensor	acos () const
at::Tensor &	acos_ () const
at::Tensor	arccos () const
at::Tensor &	arccos_ () const
at::Tensor	add (const at::Tensor &other, const at::Scalar &alpha=1) const
at::Tensor &	add_ (const at::Tensor &other, const at::Scalar &alpha=1) const
at::Tensor	add (const at::Scalar &other, const at::Scalar &alpha=1) const
at::Tensor &	add_ (const at::Scalar &other, const at::Scalar &alpha=1) const
at::Tensor	addmv (const at::Tensor &mat, const at::Tensor &vec, const at::Scalar &beta=1, const at::Scalar &alpha=1) const
at::Tensor &	addmv_ (const at::Tensor &mat, const at::Tensor &vec, const at::Scalar &beta=1, const at::Scalar &alpha=1) const
at::Tensor	addr (const at::Tensor &vec1, const at::Tensor &vec2, const at::Scalar &beta=1, const at::Scalar &alpha=1) const
at::Tensor &	addr_ (const at::Tensor &vec1, const at::Tensor &vec2, const at::Scalar &beta=1, const at::Scalar &alpha=1) const
at::Tensor	_is_all_true () const
at::Tensor	_is_any_true () const
at::Tensor	all (int64_t dim, bool keepdim=false) const
at::Tensor	all (at::Dimname dim, bool keepdim=false) const
bool	allclose (const at::Tensor &other, double rtol=1e-05, double atol=1e-08, bool equal_nan=false) const
at::Tensor	any (int64_t dim, bool keepdim=false) const
at::Tensor	any (at::Dimname dim, bool keepdim=false) const
at::Tensor	argmax (c10::optional< int64_t > dim=c10::nullopt, bool keepdim=false) const
at::Tensor	argmin (c10::optional< int64_t > dim=c10::nullopt, bool keepdim=false) const
at::Tensor	acosh () const
at::Tensor &	acosh_ () const
at::Tensor	arccosh () const
at::Tensor &	arccosh_ () const
at::Tensor	asinh () const
at::Tensor &	asinh_ () const
at::Tensor	arcsinh () const
at::Tensor &	arcsinh_ () const
at::Tensor	atanh () const
at::Tensor &	atanh_ () const
at::Tensor	arctanh () const
at::Tensor &	arctanh_ () const
at::Tensor	as_strided (at::IntArrayRef size, at::IntArrayRef stride, c10::optional< int64_t > storage_offset=c10::nullopt) const
at::Tensor	as_strided_symint (c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional< c10::SymInt > storage_offset=c10::nullopt) const
const at::Tensor &	as_strided_ (at::IntArrayRef size, at::IntArrayRef stride, c10::optional< int64_t > storage_offset=c10::nullopt) const
const at::Tensor &	as_strided__symint (c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional< c10::SymInt > storage_offset=c10::nullopt) const
at::Tensor	asin () const
at::Tensor &	asin_ () const
at::Tensor	arcsin () const
at::Tensor &	arcsin_ () const
at::Tensor	atan () const
at::Tensor &	atan_ () const
at::Tensor	arctan () const
at::Tensor &	arctan_ () const
at::Tensor	baddbmm (const at::Tensor &batch1, const at::Tensor &batch2, const at::Scalar &beta=1, const at::Scalar &alpha=1) const
at::Tensor &	baddbmm_ (const at::Tensor &batch1, const at::Tensor &batch2, const at::Scalar &beta=1, const at::Scalar &alpha=1) const
at::Tensor	bernoulli (c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor &	bernoulli_ (const at::Tensor &p, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor &	bernoulli_ (double p=0.5, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor	bernoulli (double p, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor	bincount (const c10::optional< at::Tensor > &weights={}, int64_t minlength=0) const
at::Tensor	bitwise_not () const
at::Tensor &	bitwise_not_ () const
at::Tensor	copysign (const at::Tensor &other) const
at::Tensor &	copysign_ (const at::Tensor &other) const
at::Tensor	copysign (const at::Scalar &other) const
at::Tensor &	copysign_ (const at::Scalar &other) const
at::Tensor	logical_not () const
at::Tensor &	logical_not_ () const
at::Tensor	logical_xor (const at::Tensor &other) const
at::Tensor &	logical_xor_ (const at::Tensor &other) const
at::Tensor	logical_and (const at::Tensor &other) const
at::Tensor &	logical_and_ (const at::Tensor &other) const
at::Tensor	logical_or (const at::Tensor &other) const
at::Tensor &	logical_or_ (const at::Tensor &other) const
at::Tensor	bmm (const at::Tensor &mat2) const
at::Tensor	broadcast_to (at::IntArrayRef size) const
at::Tensor	broadcast_to_symint (c10::SymIntArrayRef size) const
at::Tensor	ceil () const
at::Tensor &	ceil_ () const
::std::vector< at::Tensor >	unsafe_chunk (int64_t chunks, int64_t dim=0) const
::std::vector< at::Tensor >	chunk (int64_t chunks, int64_t dim=0) const
::std::vector< at::Tensor >	tensor_split (int64_t sections, int64_t dim=0) const
::std::vector< at::Tensor >	tensor_split_symint (c10::SymInt sections, int64_t dim=0) const
::std::vector< at::Tensor >	tensor_split (at::IntArrayRef indices, int64_t dim=0) const
::std::vector< at::Tensor >	tensor_split_symint (c10::SymIntArrayRef indices, int64_t dim=0) const
::std::vector< at::Tensor >	tensor_split (const at::Tensor &tensor_indices_or_sections, int64_t dim=0) const
at::Tensor	clamp (const c10::optional< at::Scalar > &min, const c10::optional< at::Scalar > &max=c10::nullopt) const
at::Tensor	clamp (const c10::optional< at::Tensor > &min={}, const c10::optional< at::Tensor > &max={}) const
at::Tensor &	clamp_ (const c10::optional< at::Scalar > &min, const c10::optional< at::Scalar > &max=c10::nullopt) const
at::Tensor &	clamp_ (const c10::optional< at::Tensor > &min={}, const c10::optional< at::Tensor > &max={}) const
at::Tensor	clamp_max (const at::Scalar &max) const
at::Tensor	clamp_max (const at::Tensor &max) const
at::Tensor &	clamp_max_ (const at::Scalar &max) const
at::Tensor &	clamp_max_ (const at::Tensor &max) const
at::Tensor	clamp_min (const at::Scalar &min) const
at::Tensor	clamp_min (const at::Tensor &min) const
at::Tensor &	clamp_min_ (const at::Scalar &min) const
at::Tensor &	clamp_min_ (const at::Tensor &min) const
at::Tensor	clip (const c10::optional< at::Scalar > &min, const c10::optional< at::Scalar > &max=c10::nullopt) const
at::Tensor	clip (const c10::optional< at::Tensor > &min={}, const c10::optional< at::Tensor > &max={}) const
at::Tensor &	clip_ (const c10::optional< at::Scalar > &min, const c10::optional< at::Scalar > &max=c10::nullopt) const
at::Tensor &	clip_ (const c10::optional< at::Tensor > &min={}, const c10::optional< at::Tensor > &max={}) const
at::Tensor	__dispatch_contiguous (at::MemoryFormat memory_format=MemoryFormat::Contiguous) const
at::Tensor &	copy_ (const at::Tensor &src, bool non_blocking=false) const
at::Tensor	cos () const
at::Tensor &	cos_ () const
at::Tensor	cosh () const
at::Tensor &	cosh_ () const
at::Tensor	count_nonzero (at::IntArrayRef dim) const
at::Tensor	count_nonzero (c10::optional< int64_t > dim=c10::nullopt) const
at::Tensor	cov (int64_t correction=1, const c10::optional< at::Tensor > &fweights={}, const c10::optional< at::Tensor > &aweights={}) const
at::Tensor	corrcoef () const
::std::tuple< at::Tensor, at::Tensor >	cummax (int64_t dim) const
::std::tuple< at::Tensor, at::Tensor >	cummax (at::Dimname dim) const
::std::tuple< at::Tensor, at::Tensor >	cummin (int64_t dim) const
::std::tuple< at::Tensor, at::Tensor >	cummin (at::Dimname dim) const
at::Tensor	cumprod (int64_t dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor &	cumprod_ (int64_t dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	cumprod (at::Dimname dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor &	cumprod_ (at::Dimname dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	cumsum (int64_t dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor &	cumsum_ (int64_t dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	cumsum (at::Dimname dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor &	cumsum_ (at::Dimname dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	diag_embed (int64_t offset=0, int64_t dim1=-2, int64_t dim2=-1) const
at::Tensor	diagflat (int64_t offset=0) const
at::Tensor	diagonal (int64_t offset=0, int64_t dim1=0, int64_t dim2=1) const
at::Tensor	diagonal (at::Dimname outdim, at::Dimname dim1, at::Dimname dim2, int64_t offset=0) const
at::Tensor &	fill_diagonal_ (const at::Scalar &fill_value, bool wrap=false) const
at::Tensor	diff (int64_t n=1, int64_t dim=-1, const c10::optional< at::Tensor > &prepend={}, const c10::optional< at::Tensor > &append={}) const
at::Tensor	div (const at::Tensor &other) const
at::Tensor &	div_ (const at::Tensor &other) const
at::Tensor	div (const at::Tensor &other, c10::optional< c10::string_view > rounding_mode) const
at::Tensor &	div_ (const at::Tensor &other, c10::optional< c10::string_view > rounding_mode) const
at::Tensor	div (const at::Scalar &other) const
at::Tensor &	div_ (const at::Scalar &other) const
at::Tensor	div (const at::Scalar &other, c10::optional< c10::string_view > rounding_mode) const
at::Tensor &	div_ (const at::Scalar &other, c10::optional< c10::string_view > rounding_mode) const
at::Tensor	divide (const at::Tensor &other) const
at::Tensor &	divide_ (const at::Tensor &other) const
at::Tensor	divide (const at::Scalar &other) const
at::Tensor &	divide_ (const at::Scalar &other) const
at::Tensor	divide (const at::Tensor &other, c10::optional< c10::string_view > rounding_mode) const
at::Tensor &	divide_ (const at::Tensor &other, c10::optional< c10::string_view > rounding_mode) const
at::Tensor	divide (const at::Scalar &other, c10::optional< c10::string_view > rounding_mode) const
at::Tensor &	divide_ (const at::Scalar &other, c10::optional< c10::string_view > rounding_mode) const
at::Tensor	true_divide (const at::Tensor &other) const
at::Tensor &	true_divide_ (const at::Tensor &other) const
at::Tensor	true_divide (const at::Scalar &other) const
at::Tensor &	true_divide_ (const at::Scalar &other) const
at::Tensor	dot (const at::Tensor &tensor) const
at::Tensor	vdot (const at::Tensor &other) const
at::Tensor	new_empty (at::IntArrayRef size, at::TensorOptions options={}) const
at::Tensor	new_empty (at::IntArrayRef size, c10::optional< at::ScalarType > dtype, c10::optional< at::Layout > layout, c10::optional< at::Device > device, c10::optional< bool > pin_memory) const
at::Tensor	new_empty_symint (c10::SymIntArrayRef size, at::TensorOptions options={}) const
at::Tensor	new_empty_symint (c10::SymIntArrayRef size, c10::optional< at::ScalarType > dtype, c10::optional< at::Layout > layout, c10::optional< at::Device > device, c10::optional< bool > pin_memory) const
at::Tensor	new_empty_strided (at::IntArrayRef size, at::IntArrayRef stride, at::TensorOptions options={}) const
at::Tensor	new_empty_strided (at::IntArrayRef size, at::IntArrayRef stride, c10::optional< at::ScalarType > dtype, c10::optional< at::Layout > layout, c10::optional< at::Device > device, c10::optional< bool > pin_memory) const
at::Tensor	new_empty_strided_symint (c10::SymIntArrayRef size, c10::SymIntArrayRef stride, at::TensorOptions options={}) const
at::Tensor	new_empty_strided_symint (c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional< at::ScalarType > dtype, c10::optional< at::Layout > layout, c10::optional< at::Device > device, c10::optional< bool > pin_memory) const
at::Tensor	new_full (at::IntArrayRef size, const at::Scalar &fill_value, at::TensorOptions options={}) const
at::Tensor	new_full (at::IntArrayRef size, const at::Scalar &fill_value, c10::optional< at::ScalarType > dtype, c10::optional< at::Layout > layout, c10::optional< at::Device > device, c10::optional< bool > pin_memory) const
at::Tensor	new_full_symint (c10::SymIntArrayRef size, const at::Scalar &fill_value, at::TensorOptions options={}) const
at::Tensor	new_full_symint (c10::SymIntArrayRef size, const at::Scalar &fill_value, c10::optional< at::ScalarType > dtype, c10::optional< at::Layout > layout, c10::optional< at::Device > device, c10::optional< bool > pin_memory) const
at::Tensor	new_zeros (at::IntArrayRef size, at::TensorOptions options={}) const
at::Tensor	new_zeros (at::IntArrayRef size, c10::optional< at::ScalarType > dtype, c10::optional< at::Layout > layout, c10::optional< at::Device > device, c10::optional< bool > pin_memory) const
at::Tensor	new_zeros_symint (c10::SymIntArrayRef size, at::TensorOptions options={}) const
at::Tensor	new_zeros_symint (c10::SymIntArrayRef size, c10::optional< at::ScalarType > dtype, c10::optional< at::Layout > layout, c10::optional< at::Device > device, c10::optional< bool > pin_memory) const
at::Tensor	new_ones (at::IntArrayRef size, at::TensorOptions options={}) const
at::Tensor	new_ones (at::IntArrayRef size, c10::optional< at::ScalarType > dtype, c10::optional< at::Layout > layout, c10::optional< at::Device > device, c10::optional< bool > pin_memory) const
at::Tensor	new_ones_symint (c10::SymIntArrayRef size, at::TensorOptions options={}) const
at::Tensor	new_ones_symint (c10::SymIntArrayRef size, c10::optional< at::ScalarType > dtype, c10::optional< at::Layout > layout, c10::optional< at::Device > device, c10::optional< bool > pin_memory) const
const at::Tensor &	resize_ (at::IntArrayRef size, c10::optional< at::MemoryFormat > memory_format=c10::nullopt) const
const at::Tensor &	resize__symint (c10::SymIntArrayRef size, c10::optional< at::MemoryFormat > memory_format=c10::nullopt) const
at::Tensor	erf () const
at::Tensor &	erf_ () const
at::Tensor	erfc () const
at::Tensor &	erfc_ () const
at::Tensor	exp () const
at::Tensor &	exp_ () const
at::Tensor	exp2 () const
at::Tensor &	exp2_ () const
at::Tensor	expm1 () const
at::Tensor &	expm1_ () const
at::Tensor	expand (at::IntArrayRef size, bool implicit=false) const
at::Tensor	expand_symint (c10::SymIntArrayRef size, bool implicit=false) const
at::Tensor	expand_as (const at::Tensor &other) const
at::Tensor	flatten (int64_t start_dim=0, int64_t end_dim=-1) const
at::Tensor	flatten (int64_t start_dim, int64_t end_dim, at::Dimname out_dim) const
at::Tensor	flatten (at::Dimname start_dim, at::Dimname end_dim, at::Dimname out_dim) const
at::Tensor	flatten (at::DimnameList dims, at::Dimname out_dim) const
at::Tensor	unflatten (int64_t dim, at::IntArrayRef sizes) const
at::Tensor	unflatten (at::Dimname dim, at::IntArrayRef sizes, at::DimnameList names) const
at::Tensor &	fill_ (const at::Scalar &value) const
at::Tensor &	fill_ (const at::Tensor &value) const
at::Tensor	floor () const
at::Tensor &	floor_ () const
at::Tensor	floor_divide (const at::Tensor &other) const
at::Tensor &	floor_divide_ (const at::Tensor &other) const
at::Tensor	floor_divide (const at::Scalar &other) const
at::Tensor &	floor_divide_ (const at::Scalar &other) const
at::Tensor	frac () const
at::Tensor &	frac_ () const
at::Tensor	gcd (const at::Tensor &other) const
at::Tensor &	gcd_ (const at::Tensor &other) const
at::Tensor	lcm (const at::Tensor &other) const
at::Tensor &	lcm_ (const at::Tensor &other) const
at::Tensor	index (const c10::List< c10::optional< at::Tensor > > &indices) const
at::Tensor &	index_copy_ (int64_t dim, const at::Tensor &index, const at::Tensor &source) const
at::Tensor	index_copy (int64_t dim, const at::Tensor &index, const at::Tensor &source) const
at::Tensor &	index_copy_ (at::Dimname dim, const at::Tensor &index, const at::Tensor &source) const
at::Tensor	index_copy (at::Dimname dim, const at::Tensor &index, const at::Tensor &source) const
at::Tensor &	index_put_ (const c10::List< c10::optional< at::Tensor > > &indices, const at::Tensor &values, bool accumulate=false) const
at::Tensor	index_put (const c10::List< c10::optional< at::Tensor > > &indices, const at::Tensor &values, bool accumulate=false) const
at::Tensor	isclose (const at::Tensor &other, double rtol=1e-05, double atol=1e-08, bool equal_nan=false) const
at::Tensor	isnan () const
bool	is_distributed () const
bool	__dispatch_is_floating_point () const
bool	__dispatch_is_complex () const
bool	__dispatch_is_conj () const
bool	__dispatch__is_zerotensor () const
bool	__dispatch_is_neg () const
at::Tensor	isreal () const
bool	is_nonzero () const
bool	is_same_size (const at::Tensor &other) const
bool	__dispatch_is_signed () const
bool	__dispatch_is_inference () const
at::Tensor	kron (const at::Tensor &other) const
::std::tuple< at::Tensor, at::Tensor >	kthvalue (int64_t k, int64_t dim=-1, bool keepdim=false) const
::std::tuple< at::Tensor, at::Tensor >	kthvalue (int64_t k, at::Dimname dim, bool keepdim=false) const
at::Tensor	nan_to_num (c10::optional< double > nan=c10::nullopt, c10::optional< double > posinf=c10::nullopt, c10::optional< double > neginf=c10::nullopt) const
at::Tensor &	nan_to_num_ (c10::optional< double > nan=c10::nullopt, c10::optional< double > posinf=c10::nullopt, c10::optional< double > neginf=c10::nullopt) const
at::Tensor	ldexp (const at::Tensor &other) const
at::Tensor &	ldexp_ (const at::Tensor &other) const
at::Tensor	log () const
at::Tensor &	log_ () const
at::Tensor	log10 () const
at::Tensor &	log10_ () const
at::Tensor	log1p () const
at::Tensor &	log1p_ () const
at::Tensor	log2 () const
at::Tensor &	log2_ () const
at::Tensor	logaddexp (const at::Tensor &other) const
at::Tensor	logaddexp2 (const at::Tensor &other) const
at::Tensor	xlogy (const at::Tensor &other) const
at::Tensor	xlogy (const at::Scalar &other) const
at::Tensor &	xlogy_ (const at::Tensor &other) const
at::Tensor &	xlogy_ (const at::Scalar &other) const
at::Tensor	log_softmax (int64_t dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	log_softmax (at::Dimname dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	logcumsumexp (int64_t dim) const
at::Tensor	logcumsumexp (at::Dimname dim) const
at::Tensor	logsumexp (at::IntArrayRef dim, bool keepdim=false) const
at::Tensor	logsumexp (at::DimnameList dim, bool keepdim=false) const
at::Tensor	matmul (const at::Tensor &other) const
at::Tensor	matrix_power (int64_t n) const
at::Tensor	matrix_exp () const
::std::tuple< at::Tensor, at::Tensor >	aminmax (c10::optional< int64_t > dim=c10::nullopt, bool keepdim=false) const
::std::tuple< at::Tensor, at::Tensor >	max (int64_t dim, bool keepdim=false) const
::std::tuple< at::Tensor, at::Tensor >	max (at::Dimname dim, bool keepdim=false) const
at::Tensor	amax (at::IntArrayRef dim={}, bool keepdim=false) const
at::Tensor	mean (c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	mean (at::OptionalIntArrayRef dim, bool keepdim=false, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	mean (at::DimnameList dim, bool keepdim=false, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	nanmean (at::OptionalIntArrayRef dim=c10::nullopt, bool keepdim=false, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	median () const
::std::tuple< at::Tensor, at::Tensor >	median (int64_t dim, bool keepdim=false) const
::std::tuple< at::Tensor, at::Tensor >	median (at::Dimname dim, bool keepdim=false) const
at::Tensor	nanmedian () const
::std::tuple< at::Tensor, at::Tensor >	nanmedian (int64_t dim, bool keepdim=false) const
::std::tuple< at::Tensor, at::Tensor >	nanmedian (at::Dimname dim, bool keepdim=false) const
::std::tuple< at::Tensor, at::Tensor >	min (int64_t dim, bool keepdim=false) const
::std::tuple< at::Tensor, at::Tensor >	min (at::Dimname dim, bool keepdim=false) const
at::Tensor	amin (at::IntArrayRef dim={}, bool keepdim=false) const
at::Tensor	mm (const at::Tensor &mat2) const
::std::tuple< at::Tensor, at::Tensor >	mode (int64_t dim=-1, bool keepdim=false) const
::std::tuple< at::Tensor, at::Tensor >	mode (at::Dimname dim, bool keepdim=false) const
at::Tensor	mul (const at::Tensor &other) const
at::Tensor &	mul_ (const at::Tensor &other) const
at::Tensor	mul (const at::Scalar &other) const
at::Tensor &	mul_ (const at::Scalar &other) const
at::Tensor	multiply (const at::Tensor &other) const
at::Tensor &	multiply_ (const at::Tensor &other) const
at::Tensor	multiply (const at::Scalar &other) const
at::Tensor &	multiply_ (const at::Scalar &other) const
at::Tensor	mv (const at::Tensor &vec) const
at::Tensor	mvlgamma (int64_t p) const
at::Tensor &	mvlgamma_ (int64_t p) const
at::Tensor	narrow_copy (int64_t dim, int64_t start, int64_t length) const
at::Tensor	narrow_copy_symint (int64_t dim, c10::SymInt start, c10::SymInt length) const
at::Tensor	narrow (int64_t dim, int64_t start, int64_t length) const
at::Tensor	narrow_symint (int64_t dim, c10::SymInt start, c10::SymInt length) const
at::Tensor	narrow (int64_t dim, const at::Tensor &start, int64_t length) const
at::Tensor	narrow_symint (int64_t dim, const at::Tensor &start, c10::SymInt length) const
at::Tensor	permute (at::IntArrayRef dims) const
at::Tensor	movedim (at::IntArrayRef source, at::IntArrayRef destination) const
at::Tensor	movedim (int64_t source, int64_t destination) const
at::Tensor	moveaxis (at::IntArrayRef source, at::IntArrayRef destination) const
at::Tensor	moveaxis (int64_t source, int64_t destination) const
at::Tensor	numpy_T () const
at::Tensor	matrix_H () const
at::Tensor	mT () const
at::Tensor	mH () const
at::Tensor	adjoint () const
bool	is_pinned (c10::optional< at::Device > device=c10::nullopt) const
at::Tensor	pin_memory (c10::optional< at::Device > device=c10::nullopt) const
at::Tensor	pinverse (double rcond=1e-15) const
at::Tensor	rad2deg () const
at::Tensor &	rad2deg_ () const
at::Tensor	deg2rad () const
at::Tensor &	deg2rad_ () const
at::Tensor	ravel () const
at::Tensor	reciprocal () const
at::Tensor &	reciprocal_ () const
at::Tensor	neg () const
at::Tensor &	neg_ () const
at::Tensor	negative () const
at::Tensor &	negative_ () const
at::Tensor	repeat (at::IntArrayRef repeats) const
at::Tensor	repeat_symint (c10::SymIntArrayRef repeats) const
at::Tensor	repeat_interleave (const at::Tensor &repeats, c10::optional< int64_t > dim=c10::nullopt, c10::optional< int64_t > output_size=c10::nullopt) const
at::Tensor	repeat_interleave (int64_t repeats, c10::optional< int64_t > dim=c10::nullopt, c10::optional< int64_t > output_size=c10::nullopt) const
at::Tensor	repeat_interleave_symint (c10::SymInt repeats, c10::optional< int64_t > dim=c10::nullopt, c10::optional< int64_t > output_size=c10::nullopt) const
at::Tensor	reshape (at::IntArrayRef shape) const
at::Tensor	reshape_symint (c10::SymIntArrayRef shape) const
at::Tensor	_reshape_alias (at::IntArrayRef size, at::IntArrayRef stride) const
at::Tensor	_reshape_alias_symint (c10::SymIntArrayRef size, c10::SymIntArrayRef stride) const
at::Tensor	reshape_as (const at::Tensor &other) const
at::Tensor	round () const
at::Tensor &	round_ () const
at::Tensor	round (int64_t decimals) const
at::Tensor &	round_ (int64_t decimals) const
at::Tensor	relu () const
at::Tensor &	relu_ () const
at::Tensor	prelu (const at::Tensor &weight) const
at::Tensor	hardshrink (const at::Scalar &lambd=0.5) const
at::Tensor	hardshrink_backward (const at::Tensor &grad_out, const at::Scalar &lambd) const
at::Tensor	rsqrt () const
at::Tensor &	rsqrt_ () const
at::Tensor	select (at::Dimname dim, int64_t index) const
at::Tensor	select (int64_t dim, int64_t index) const
at::Tensor	select_symint (int64_t dim, c10::SymInt index) const
at::Tensor	sigmoid () const
at::Tensor &	sigmoid_ () const
at::Tensor	logit (c10::optional< double > eps=c10::nullopt) const
at::Tensor &	logit_ (c10::optional< double > eps=c10::nullopt) const
at::Tensor	sin () const
at::Tensor &	sin_ () const
at::Tensor	sinc () const
at::Tensor &	sinc_ () const
at::Tensor	sinh () const
at::Tensor &	sinh_ () const
at::Tensor	detach () const
	Returns a new Tensor, detached from the current graph. More...
at::Tensor &	detach_ () const
	Detaches the Tensor from the graph that created it, making it a leaf. More...
int64_t	size (at::Dimname dim) const
at::Tensor	slice (int64_t dim=0, c10::optional< int64_t > start=c10::nullopt, c10::optional< int64_t > end=c10::nullopt, int64_t step=1) const
at::Tensor	slice_symint (int64_t dim=0, c10::optional< c10::SymInt > start=c10::nullopt, c10::optional< c10::SymInt > end=c10::nullopt, c10::SymInt step=1) const
at::Tensor	slice_scatter (const at::Tensor &src, int64_t dim=0, c10::optional< int64_t > start=c10::nullopt, c10::optional< int64_t > end=c10::nullopt, int64_t step=1) const
at::Tensor	slice_scatter_symint (const at::Tensor &src, int64_t dim=0, c10::optional< c10::SymInt > start=c10::nullopt, c10::optional< c10::SymInt > end=c10::nullopt, c10::SymInt step=1) const
at::Tensor	select_scatter (const at::Tensor &src, int64_t dim, int64_t index) const
at::Tensor	select_scatter_symint (const at::Tensor &src, int64_t dim, c10::SymInt index) const
at::Tensor	diagonal_scatter (const at::Tensor &src, int64_t offset=0, int64_t dim1=0, int64_t dim2=1) const
at::Tensor	as_strided_scatter (const at::Tensor &src, at::IntArrayRef size, at::IntArrayRef stride, c10::optional< int64_t > storage_offset=c10::nullopt) const
at::Tensor	as_strided_scatter_symint (const at::Tensor &src, c10::SymIntArrayRef size, c10::SymIntArrayRef stride, c10::optional< c10::SymInt > storage_offset=c10::nullopt) const
at::Tensor	smm (const at::Tensor &mat2) const
at::Tensor	softmax (int64_t dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	softmax (at::Dimname dim, c10::optional< at::ScalarType > dtype=c10::nullopt) const
::std::vector< at::Tensor >	unsafe_split (int64_t split_size, int64_t dim=0) const
::std::vector< at::Tensor >	unsafe_split_symint (c10::SymInt split_size, int64_t dim=0) const
::std::vector< at::Tensor >	split (int64_t split_size, int64_t dim=0) const
::std::vector< at::Tensor >	split_symint (c10::SymInt split_size, int64_t dim=0) const
::std::vector< at::Tensor >	split (at::IntArrayRef split_size, int64_t dim=0) const
::std::vector< at::Tensor >	split_symint (c10::SymIntArrayRef split_size, int64_t dim=0) const
::std::vector< at::Tensor >	unsafe_split_with_sizes (at::IntArrayRef split_sizes, int64_t dim=0) const
::std::vector< at::Tensor >	unsafe_split_with_sizes_symint (c10::SymIntArrayRef split_sizes, int64_t dim=0) const
::std::vector< at::Tensor >	split_with_sizes (at::IntArrayRef split_sizes, int64_t dim=0) const
::std::vector< at::Tensor >	split_with_sizes_symint (c10::SymIntArrayRef split_sizes, int64_t dim=0) const
::std::vector< at::Tensor >	hsplit (int64_t sections) const
::std::vector< at::Tensor >	hsplit (at::IntArrayRef indices) const
::std::vector< at::Tensor >	vsplit (int64_t sections) const
::std::vector< at::Tensor >	vsplit (at::IntArrayRef indices) const
::std::vector< at::Tensor >	dsplit (int64_t sections) const
::std::vector< at::Tensor >	dsplit (at::IntArrayRef indices) const
at::Tensor	squeeze () const
at::Tensor	squeeze (int64_t dim) const
at::Tensor	squeeze (at::Dimname dim) const
at::Tensor	squeeze (at::IntArrayRef dim) const
at::Tensor &	squeeze_ () const
at::Tensor &	squeeze_ (int64_t dim) const
at::Tensor &	squeeze_ (at::IntArrayRef dim) const
at::Tensor &	squeeze_ (at::Dimname dim) const
at::Tensor	sspaddmm (const at::Tensor &mat1, const at::Tensor &mat2, const at::Scalar &beta=1, const at::Scalar &alpha=1) const
at::Tensor	stft (int64_t n_fft, c10::optional< int64_t > hop_length, c10::optional< int64_t > win_length, const c10::optional< at::Tensor > &window, bool normalized, c10::optional< bool > onesided=c10::nullopt, c10::optional< bool > return_complex=c10::nullopt) const
at::Tensor	stft (int64_t n_fft, c10::optional< int64_t > hop_length=c10::nullopt, c10::optional< int64_t > win_length=c10::nullopt, const c10::optional< at::Tensor > &window={}, bool center=true, c10::string_view pad_mode="reflect", bool normalized=false, c10::optional< bool > onesided=c10::nullopt, c10::optional< bool > return_complex=c10::nullopt) const
at::Tensor	istft (int64_t n_fft, c10::optional< int64_t > hop_length=c10::nullopt, c10::optional< int64_t > win_length=c10::nullopt, const c10::optional< at::Tensor > &window={}, bool center=true, bool normalized=false, c10::optional< bool > onesided=c10::nullopt, c10::optional< int64_t > length=c10::nullopt, bool return_complex=false) const
int64_t	stride (at::Dimname dim) const
at::Tensor	sum (c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	sum (at::OptionalIntArrayRef dim, bool keepdim=false, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	sum (at::DimnameList dim, bool keepdim=false, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	nansum (at::OptionalIntArrayRef dim=c10::nullopt, bool keepdim=false, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	sum_to_size (at::IntArrayRef size) const
at::Tensor	sqrt () const
at::Tensor &	sqrt_ () const
at::Tensor	square () const
at::Tensor &	square_ () const
at::Tensor	std (bool unbiased) const
at::Tensor	std (at::OptionalIntArrayRef dim, bool unbiased, bool keepdim=false) const
at::Tensor	std (at::OptionalIntArrayRef dim=c10::nullopt, c10::optional< int64_t > correction=c10::nullopt, bool keepdim=false) const
at::Tensor	std (at::DimnameList dim, bool unbiased, bool keepdim=false) const
at::Tensor	std (at::DimnameList dim, c10::optional< int64_t > correction=c10::nullopt, bool keepdim=false) const
at::Tensor	prod (c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	prod (int64_t dim, bool keepdim=false, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	prod (at::Dimname dim, bool keepdim=false, c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	t () const
at::Tensor &	t_ () const
at::Tensor	tan () const
at::Tensor &	tan_ () const
at::Tensor	tanh () const
at::Tensor &	tanh_ () const
at::Tensor	tile (at::IntArrayRef dims) const
at::Tensor	transpose (int64_t dim0, int64_t dim1) const
at::Tensor	transpose (at::Dimname dim0, at::Dimname dim1) const
at::Tensor &	transpose_ (int64_t dim0, int64_t dim1) const
at::Tensor	flip (at::IntArrayRef dims) const
at::Tensor	fliplr () const
at::Tensor	flipud () const
at::Tensor	roll (at::IntArrayRef shifts, at::IntArrayRef dims={}) const
at::Tensor	rot90 (int64_t k=1, at::IntArrayRef dims={0, 1}) const
at::Tensor	_nested_tensor_size () const
at::Tensor	_nested_tensor_strides () const
::std::vector< int64_t >	_nested_tensor_offsets () const
at::Tensor	trunc () const
at::Tensor &	trunc_ () const
at::Tensor	fix () const
at::Tensor &	fix_ () const
at::Tensor	type_as (const at::Tensor &other) const
at::Tensor	unsqueeze (int64_t dim) const
at::Tensor &	unsqueeze_ (int64_t dim) const
at::Tensor	var (bool unbiased) const
at::Tensor	var (at::OptionalIntArrayRef dim, bool unbiased, bool keepdim=false) const
at::Tensor	var (at::OptionalIntArrayRef dim=c10::nullopt, c10::optional< int64_t > correction=c10::nullopt, bool keepdim=false) const
at::Tensor	var (at::DimnameList dim, bool unbiased, bool keepdim=false) const
at::Tensor	var (at::DimnameList dim, c10::optional< int64_t > correction=c10::nullopt, bool keepdim=false) const
at::Tensor	view_as (const at::Tensor &other) const
at::Tensor	where (const at::Tensor &condition, const at::Tensor &other) const
at::Tensor	where (const at::Tensor &condition, const at::Scalar &other) const
at::Tensor	norm (const c10::optional< at::Scalar > &p, at::ScalarType dtype) const
at::Tensor	norm (const at::Scalar &p=2) const
at::Tensor	norm (const c10::optional< at::Scalar > &p, at::IntArrayRef dim, bool keepdim, at::ScalarType dtype) const
at::Tensor	norm (const c10::optional< at::Scalar > &p, at::IntArrayRef dim, bool keepdim=false) const
at::Tensor	norm (const c10::optional< at::Scalar > &p, at::DimnameList dim, bool keepdim, at::ScalarType dtype) const
at::Tensor	norm (const c10::optional< at::Scalar > &p, at::DimnameList dim, bool keepdim=false) const
::std::tuple< at::Tensor, at::Tensor >	frexp () const
at::Tensor	clone (c10::optional< at::MemoryFormat > memory_format=c10::nullopt) const
at::Tensor	positive () const
const at::Tensor &	resize_as_ (const at::Tensor &the_template, c10::optional< at::MemoryFormat > memory_format=c10::nullopt) const
const at::Tensor &	resize_as_sparse_ (const at::Tensor &the_template) const
at::Tensor &	zero_ () const
at::Tensor	sub (const at::Tensor &other, const at::Scalar &alpha=1) const
at::Tensor &	sub_ (const at::Tensor &other, const at::Scalar &alpha=1) const
at::Tensor	sub (const at::Scalar &other, const at::Scalar &alpha=1) const
at::Tensor &	sub_ (const at::Scalar &other, const at::Scalar &alpha=1) const
at::Tensor	subtract (const at::Tensor &other, const at::Scalar &alpha=1) const
at::Tensor &	subtract_ (const at::Tensor &other, const at::Scalar &alpha=1) const
at::Tensor	subtract (const at::Scalar &other, const at::Scalar &alpha=1) const
at::Tensor &	subtract_ (const at::Scalar &other, const at::Scalar &alpha=1) const
at::Tensor	heaviside (const at::Tensor &values) const
at::Tensor &	heaviside_ (const at::Tensor &values) const
at::Tensor	addmm (const at::Tensor &mat1, const at::Tensor &mat2, const at::Scalar &beta=1, const at::Scalar &alpha=1) const
at::Tensor &	addmm_ (const at::Tensor &mat1, const at::Tensor &mat2, const at::Scalar &beta=1, const at::Scalar &alpha=1) const
at::Tensor	_addmm_activation (const at::Tensor &mat1, const at::Tensor &mat2, const at::Scalar &beta=1, const at::Scalar &alpha=1, bool use_gelu=false) const
const at::Tensor &	sparse_resize_ (at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) const
const at::Tensor &	sparse_resize_and_clear_ (at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) const
at::Tensor	sparse_mask (const at::Tensor &mask) const
at::Tensor	to_dense (c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	_to_dense (c10::optional< at::ScalarType > dtype=c10::nullopt) const
int64_t	sparse_dim () const
int64_t	_dimI () const
int64_t	dense_dim () const
int64_t	_dimV () const
int64_t	_nnz () const
at::Tensor	coalesce () const
bool	is_coalesced () const
at::Tensor	_indices () const
at::Tensor	_values () const
at::Tensor &	_coalesced_ (bool coalesced) const
at::Tensor	indices () const
at::Tensor	values () const
at::Tensor	crow_indices () const
at::Tensor	col_indices () const
at::Tensor	ccol_indices () const
at::Tensor	row_indices () const
::std::vector< at::Tensor >	unbind (int64_t dim=0) const
::std::vector< at::Tensor >	unbind (at::Dimname dim) const
at::Tensor	to_sparse (int64_t sparse_dim) const
at::Tensor	to_sparse (c10::optional< at::Layout > layout=c10::nullopt, at::OptionalIntArrayRef blocksize=c10::nullopt, c10::optional< int64_t > dense_dim=c10::nullopt) const
at::Tensor	to_sparse_csr (c10::optional< int64_t > dense_dim=c10::nullopt) const
at::Tensor	to_sparse_csc (c10::optional< int64_t > dense_dim=c10::nullopt) const
at::Tensor	to_sparse_bsr (at::IntArrayRef blocksize, c10::optional< int64_t > dense_dim=c10::nullopt) const
at::Tensor	to_sparse_bsc (at::IntArrayRef blocksize, c10::optional< int64_t > dense_dim=c10::nullopt) const
at::Tensor	to_mkldnn (c10::optional< at::ScalarType > dtype=c10::nullopt) const
at::Tensor	dequantize () const
double	q_scale () const
int64_t	q_zero_point () const
at::Tensor	q_per_channel_scales () const
at::Tensor	q_per_channel_zero_points () const
int64_t	q_per_channel_axis () const
at::Tensor	int_repr () const
at::QScheme	qscheme () const
at::Tensor	_autocast_to_reduced_precision (bool cuda_enabled, bool cpu_enabled, at::ScalarType cuda_dtype, at::ScalarType cpu_dtype) const
at::Tensor	_autocast_to_full_precision (bool cuda_enabled, bool cpu_enabled) const
at::Tensor	to (at::TensorOptions options={}, bool non_blocking=false, bool copy=false, c10::optional< at::MemoryFormat > memory_format=c10::nullopt) const
at::Tensor	to (c10::optional< at::ScalarType > dtype, c10::optional< at::Layout > layout, c10::optional< at::Device > device, c10::optional< bool > pin_memory, bool non_blocking, bool copy, c10::optional< at::MemoryFormat > memory_format) const
at::Tensor	to (at::Device device, at::ScalarType dtype, bool non_blocking=false, bool copy=false, c10::optional< at::MemoryFormat > memory_format=c10::nullopt) const
at::Tensor	to (at::ScalarType dtype, bool non_blocking=false, bool copy=false, c10::optional< at::MemoryFormat > memory_format=c10::nullopt) const
at::Tensor	to (const at::Tensor &other, bool non_blocking=false, bool copy=false, c10::optional< at::MemoryFormat > memory_format=c10::nullopt) const
at::Scalar	item () const
at::Tensor &	set_ (at::Storage source) const
at::Tensor &	set_ (at::Storage source, int64_t storage_offset, at::IntArrayRef size, at::IntArrayRef stride={}) const
at::Tensor &	set__symint (at::Storage source, c10::SymInt storage_offset, c10::SymIntArrayRef size, c10::SymIntArrayRef stride={}) const
at::Tensor &	set_ (const at::Tensor &source, int64_t storage_offset, at::IntArrayRef size, at::IntArrayRef stride={}) const
at::Tensor &	set__symint (const at::Tensor &source, c10::SymInt storage_offset, c10::SymIntArrayRef size, c10::SymIntArrayRef stride={}) const
at::Tensor &	set_ (const at::Tensor &source) const
at::Tensor &	set_ () const
bool	is_set_to (const at::Tensor &tensor) const
at::Tensor &	masked_fill_ (const at::Tensor &mask, const at::Scalar &value) const
at::Tensor	masked_fill (const at::Tensor &mask, const at::Scalar &value) const
at::Tensor &	masked_fill_ (const at::Tensor &mask, const at::Tensor &value) const
at::Tensor	masked_fill (const at::Tensor &mask, const at::Tensor &value) const
at::Tensor &	masked_scatter_ (const at::Tensor &mask, const at::Tensor &source) const
at::Tensor	masked_scatter (const at::Tensor &mask, const at::Tensor &source) const
at::Tensor	view (at::IntArrayRef size) const
at::Tensor	view_symint (c10::SymIntArrayRef size) const
at::Tensor	view (at::ScalarType dtype) const
at::Tensor &	put_ (const at::Tensor &index, const at::Tensor &source, bool accumulate=false) const
at::Tensor	put (const at::Tensor &index, const at::Tensor &source, bool accumulate=false) const
at::Tensor &	index_add_ (int64_t dim, const at::Tensor &index, const at::Tensor &source, const at::Scalar &alpha=1) const
at::Tensor	index_add (int64_t dim, const at::Tensor &index, const at::Tensor &source, const at::Scalar &alpha=1) const
at::Tensor	index_add (at::Dimname dim, const at::Tensor &index, const at::Tensor &source, const at::Scalar &alpha=1) const
at::Tensor &	index_reduce_ (int64_t dim, const at::Tensor &index, const at::Tensor &source, c10::string_view reduce, bool include_self=true) const
at::Tensor	index_reduce (int64_t dim, const at::Tensor &index, const at::Tensor &source, c10::string_view reduce, bool include_self=true) const
at::Tensor &	index_fill_ (int64_t dim, const at::Tensor &index, const at::Scalar &value) const
at::Tensor	index_fill (int64_t dim, const at::Tensor &index, const at::Scalar &value) const
at::Tensor &	index_fill_ (int64_t dim, const at::Tensor &index, const at::Tensor &value) const
at::Tensor	index_fill (int64_t dim, const at::Tensor &index, const at::Tensor &value) const
at::Tensor &	index_fill_ (at::Dimname dim, const at::Tensor &index, const at::Scalar &value) const
at::Tensor &	index_fill_ (at::Dimname dim, const at::Tensor &index, const at::Tensor &value) const
at::Tensor	index_fill (at::Dimname dim, const at::Tensor &index, const at::Scalar &value) const
at::Tensor	index_fill (at::Dimname dim, const at::Tensor &index, const at::Tensor &value) const
at::Tensor	scatter (int64_t dim, const at::Tensor &index, const at::Tensor &src) const
at::Tensor &	scatter_ (int64_t dim, const at::Tensor &index, const at::Tensor &src) const
at::Tensor	scatter (int64_t dim, const at::Tensor &index, const at::Scalar &value) const
at::Tensor &	scatter_ (int64_t dim, const at::Tensor &index, const at::Scalar &value) const
at::Tensor	scatter (int64_t dim, const at::Tensor &index, const at::Tensor &src, c10::string_view reduce) const
at::Tensor &	scatter_ (int64_t dim, const at::Tensor &index, const at::Tensor &src, c10::string_view reduce) const
at::Tensor	scatter (int64_t dim, const at::Tensor &index, const at::Scalar &value, c10::string_view reduce) const
at::Tensor &	scatter_ (int64_t dim, const at::Tensor &index, const at::Scalar &value, c10::string_view reduce) const
at::Tensor	scatter (at::Dimname dim, const at::Tensor &index, const at::Tensor &src) const
at::Tensor	scatter (at::Dimname dim, const at::Tensor &index, const at::Scalar &value) const
at::Tensor	scatter_add (int64_t dim, const at::Tensor &index, const at::Tensor &src) const
at::Tensor &	scatter_add_ (int64_t dim, const at::Tensor &index, const at::Tensor &src) const
at::Tensor	scatter_add (at::Dimname dim, const at::Tensor &index, const at::Tensor &src) const
at::Tensor	scatter_reduce (int64_t dim, const at::Tensor &index, const at::Tensor &src, c10::string_view reduce, bool include_self=true) const
at::Tensor &	scatter_reduce_ (int64_t dim, const at::Tensor &index, const at::Tensor &src, c10::string_view reduce, bool include_self=true) const
at::Tensor &	eq_ (const at::Scalar &other) const
at::Tensor &	eq_ (const at::Tensor &other) const
at::Tensor	bitwise_and (const at::Scalar &other) const
at::Tensor	bitwise_and (const at::Tensor &other) const
at::Tensor &	bitwise_and_ (const at::Scalar &other) const
at::Tensor &	bitwise_and_ (const at::Tensor &other) const
at::Tensor	__and__ (const at::Scalar &other) const
at::Tensor	__and__ (const at::Tensor &other) const
at::Tensor &	__iand__ (const at::Scalar &other) const
at::Tensor &	__iand__ (const at::Tensor &other) const
at::Tensor	bitwise_or (const at::Scalar &other) const
at::Tensor	bitwise_or (const at::Tensor &other) const
at::Tensor &	bitwise_or_ (const at::Scalar &other) const
at::Tensor &	bitwise_or_ (const at::Tensor &other) const
at::Tensor	__or__ (const at::Scalar &other) const
at::Tensor	__or__ (const at::Tensor &other) const
at::Tensor &	__ior__ (const at::Scalar &other) const
at::Tensor &	__ior__ (const at::Tensor &other) const
at::Tensor	bitwise_xor (const at::Scalar &other) const
at::Tensor	bitwise_xor (const at::Tensor &other) const
at::Tensor &	bitwise_xor_ (const at::Scalar &other) const
at::Tensor &	bitwise_xor_ (const at::Tensor &other) const
at::Tensor	__xor__ (const at::Scalar &other) const
at::Tensor	__xor__ (const at::Tensor &other) const
at::Tensor &	__ixor__ (const at::Scalar &other) const
at::Tensor &	__ixor__ (const at::Tensor &other) const
at::Tensor	__lshift__ (const at::Scalar &other) const
at::Tensor	__lshift__ (const at::Tensor &other) const
at::Tensor &	__ilshift__ (const at::Scalar &other) const
at::Tensor &	__ilshift__ (const at::Tensor &other) const
at::Tensor	bitwise_left_shift (const at::Tensor &other) const
at::Tensor &	bitwise_left_shift_ (const at::Tensor &other) const
at::Tensor	bitwise_left_shift (const at::Scalar &other) const
at::Tensor &	bitwise_left_shift_ (const at::Scalar &other) const
at::Tensor	__rshift__ (const at::Scalar &other) const
at::Tensor	__rshift__ (const at::Tensor &other) const
at::Tensor &	__irshift__ (const at::Scalar &other) const
at::Tensor &	__irshift__ (const at::Tensor &other) const
at::Tensor	bitwise_right_shift (const at::Tensor &other) const
at::Tensor &	bitwise_right_shift_ (const at::Tensor &other) const
at::Tensor	bitwise_right_shift (const at::Scalar &other) const
at::Tensor &	bitwise_right_shift_ (const at::Scalar &other) const
at::Tensor &	tril_ (int64_t diagonal=0) const
at::Tensor &	triu_ (int64_t diagonal=0) const
at::Tensor &	digamma_ () const
at::Tensor &	lerp_ (const at::Tensor &end, const at::Scalar &weight) const
at::Tensor &	lerp_ (const at::Tensor &end, const at::Tensor &weight) const
at::Tensor &	addbmm_ (const at::Tensor &batch1, const at::Tensor &batch2, const at::Scalar &beta=1, const at::Scalar &alpha=1) const
at::Tensor	addbmm (const at::Tensor &batch1, const at::Tensor &batch2, const at::Scalar &beta=1, const at::Scalar &alpha=1) const
at::Tensor &	random_ (int64_t from, c10::optional< int64_t > to, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor &	random_ (int64_t to, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor &	random_ (c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor &	uniform_ (double from=0, double to=1, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor &	cauchy_ (double median=0, double sigma=1, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor &	log_normal_ (double mean=1, double std=2, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor &	exponential_ (double lambd=1, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor &	geometric_ (double p, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor	diag (int64_t diagonal=0) const
at::Tensor	cross (const at::Tensor &other, c10::optional< int64_t > dim=c10::nullopt) const
at::Tensor	triu (int64_t diagonal=0) const
at::Tensor	tril (int64_t diagonal=0) const
at::Tensor	trace () const
at::Tensor	ne (const at::Scalar &other) const
at::Tensor	ne (const at::Tensor &other) const
at::Tensor &	ne_ (const at::Scalar &other) const
at::Tensor &	ne_ (const at::Tensor &other) const
at::Tensor	not_equal (const at::Scalar &other) const
at::Tensor	not_equal (const at::Tensor &other) const
at::Tensor &	not_equal_ (const at::Scalar &other) const
at::Tensor &	not_equal_ (const at::Tensor &other) const
at::Tensor	eq (const at::Scalar &other) const
at::Tensor	eq (const at::Tensor &other) const
at::Tensor	ge (const at::Scalar &other) const
at::Tensor	ge (const at::Tensor &other) const
at::Tensor &	ge_ (const at::Scalar &other) const
at::Tensor &	ge_ (const at::Tensor &other) const
at::Tensor	greater_equal (const at::Scalar &other) const
at::Tensor	greater_equal (const at::Tensor &other) const
at::Tensor &	greater_equal_ (const at::Scalar &other) const
at::Tensor &	greater_equal_ (const at::Tensor &other) const
at::Tensor	le (const at::Scalar &other) const
at::Tensor	le (const at::Tensor &other) const
at::Tensor &	le_ (const at::Scalar &other) const
at::Tensor &	le_ (const at::Tensor &other) const
at::Tensor	less_equal (const at::Scalar &other) const
at::Tensor	less_equal (const at::Tensor &other) const
at::Tensor &	less_equal_ (const at::Scalar &other) const
at::Tensor &	less_equal_ (const at::Tensor &other) const
at::Tensor	gt (const at::Scalar &other) const
at::Tensor	gt (const at::Tensor &other) const
at::Tensor &	gt_ (const at::Scalar &other) const
at::Tensor &	gt_ (const at::Tensor &other) const
at::Tensor	greater (const at::Scalar &other) const
at::Tensor	greater (const at::Tensor &other) const
at::Tensor &	greater_ (const at::Scalar &other) const
at::Tensor &	greater_ (const at::Tensor &other) const
at::Tensor	lt (const at::Scalar &other) const
at::Tensor	lt (const at::Tensor &other) const
at::Tensor &	lt_ (const at::Scalar &other) const
at::Tensor &	lt_ (const at::Tensor &other) const
at::Tensor	less (const at::Scalar &other) const
at::Tensor	less (const at::Tensor &other) const
at::Tensor &	less_ (const at::Scalar &other) const
at::Tensor &	less_ (const at::Tensor &other) const
at::Tensor	take (const at::Tensor &index) const
at::Tensor	take_along_dim (const at::Tensor &indices, c10::optional< int64_t > dim=c10::nullopt) const
at::Tensor	index_select (int64_t dim, const at::Tensor &index) const
at::Tensor	index_select (at::Dimname dim, const at::Tensor &index) const
at::Tensor	masked_select (const at::Tensor &mask) const
at::Tensor	nonzero () const
::std::vector< at::Tensor >	nonzero_numpy () const
at::Tensor	argwhere () const
at::Tensor	gather (int64_t dim, const at::Tensor &index, bool sparse_grad=false) const
at::Tensor	gather (at::Dimname dim, const at::Tensor &index, bool sparse_grad=false) const
at::Tensor	addcmul (const at::Tensor &tensor1, const at::Tensor &tensor2, const at::Scalar &value=1) const
at::Tensor &	addcmul_ (const at::Tensor &tensor1, const at::Tensor &tensor2, const at::Scalar &value=1) const
at::Tensor	addcdiv (const at::Tensor &tensor1, const at::Tensor &tensor2, const at::Scalar &value=1) const
at::Tensor &	addcdiv_ (const at::Tensor &tensor1, const at::Tensor &tensor2, const at::Scalar &value=1) const
::std::tuple< at::Tensor, at::Tensor >	triangular_solve (const at::Tensor &A, bool upper=true, bool transpose=false, bool unitriangular=false) const
::std::tuple< at::Tensor, at::Tensor, at::Tensor >	svd (bool some=true, bool compute_uv=true) const
at::Tensor	swapaxes (int64_t axis0, int64_t axis1) const
at::Tensor &	swapaxes_ (int64_t axis0, int64_t axis1) const
at::Tensor	swapdims (int64_t dim0, int64_t dim1) const
at::Tensor &	swapdims_ (int64_t dim0, int64_t dim1) const
at::Tensor	cholesky (bool upper=false) const
at::Tensor	cholesky_solve (const at::Tensor &input2, bool upper=false) const
at::Tensor	cholesky_inverse (bool upper=false) const
::std::tuple< at::Tensor, at::Tensor >	qr (bool some=true) const
::std::tuple< at::Tensor, at::Tensor >	geqrf () const
at::Tensor	orgqr (const at::Tensor &input2) const
at::Tensor	ormqr (const at::Tensor &input2, const at::Tensor &input3, bool left=true, bool transpose=false) const
at::Tensor	lu_solve (const at::Tensor &LU_data, const at::Tensor &LU_pivots) const
at::Tensor	multinomial (int64_t num_samples, bool replacement=false, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor &	lgamma_ () const
at::Tensor	lgamma () const
at::Tensor	digamma () const
at::Tensor	polygamma (int64_t n) const
at::Tensor &	polygamma_ (int64_t n) const
at::Tensor	erfinv () const
at::Tensor &	erfinv_ () const
at::Tensor	i0 () const
at::Tensor &	i0_ () const
at::Tensor	sign () const
at::Tensor &	sign_ () const
at::Tensor	signbit () const
at::Tensor	dist (const at::Tensor &other, const at::Scalar &p=2) const
at::Tensor &	atan2_ (const at::Tensor &other) const
at::Tensor	atan2 (const at::Tensor &other) const
at::Tensor	arctan2 (const at::Tensor &other) const
at::Tensor &	arctan2_ (const at::Tensor &other) const
at::Tensor	lerp (const at::Tensor &end, const at::Scalar &weight) const
at::Tensor	lerp (const at::Tensor &end, const at::Tensor &weight) const
at::Tensor	histc (int64_t bins=100, const at::Scalar &min=0, const at::Scalar &max=0) const
::std::tuple< at::Tensor, at::Tensor >	histogram (const at::Tensor &bins, const c10::optional< at::Tensor > &weight={}, bool density=false) const
::std::tuple< at::Tensor, at::Tensor >	histogram (int64_t bins=100, c10::optional< at::ArrayRef< double > > range=c10::nullopt, const c10::optional< at::Tensor > &weight={}, bool density=false) const
at::Tensor	fmod (const at::Scalar &other) const
at::Tensor &	fmod_ (const at::Scalar &other) const
at::Tensor	fmod (const at::Tensor &other) const
at::Tensor &	fmod_ (const at::Tensor &other) const
at::Tensor	hypot (const at::Tensor &other) const
at::Tensor &	hypot_ (const at::Tensor &other) const
at::Tensor	igamma (const at::Tensor &other) const
at::Tensor &	igamma_ (const at::Tensor &other) const
at::Tensor	igammac (const at::Tensor &other) const
at::Tensor &	igammac_ (const at::Tensor &other) const
at::Tensor	nextafter (const at::Tensor &other) const
at::Tensor &	nextafter_ (const at::Tensor &other) const
at::Tensor	remainder (const at::Scalar &other) const
at::Tensor &	remainder_ (const at::Scalar &other) const
at::Tensor	remainder (const at::Tensor &other) const
at::Tensor &	remainder_ (const at::Tensor &other) const
at::Tensor	min () const
at::Tensor	fmin (const at::Tensor &other) const
at::Tensor	max () const
at::Tensor	fmax (const at::Tensor &other) const
at::Tensor	maximum (const at::Tensor &other) const
at::Tensor	max (const at::Tensor &other) const
at::Tensor	minimum (const at::Tensor &other) const
at::Tensor	min (const at::Tensor &other) const
at::Tensor	quantile (const at::Tensor &q, c10::optional< int64_t > dim=c10::nullopt, bool keepdim=false, c10::string_view interpolation="linear") const
at::Tensor	quantile (double q, c10::optional< int64_t > dim=c10::nullopt, bool keepdim=false, c10::string_view interpolation="linear") const
at::Tensor	nanquantile (const at::Tensor &q, c10::optional< int64_t > dim=c10::nullopt, bool keepdim=false, c10::string_view interpolation="linear") const
at::Tensor	nanquantile (double q, c10::optional< int64_t > dim=c10::nullopt, bool keepdim=false, c10::string_view interpolation="linear") const
::std::tuple< at::Tensor, at::Tensor >	sort (int64_t dim=-1, bool descending=false) const
::std::tuple< at::Tensor, at::Tensor >	sort (c10::optional< bool > stable, int64_t dim=-1, bool descending=false) const
::std::tuple< at::Tensor, at::Tensor >	sort (at::Dimname dim, bool descending=false) const
::std::tuple< at::Tensor, at::Tensor >	sort (c10::optional< bool > stable, at::Dimname dim, bool descending=false) const
at::Tensor	msort () const
at::Tensor	argsort (int64_t dim=-1, bool descending=false) const
at::Tensor	argsort (bool stable, int64_t dim=-1, bool descending=false) const
at::Tensor	argsort (at::Dimname dim, bool descending=false) const
::std::tuple< at::Tensor, at::Tensor >	topk (int64_t k, int64_t dim=-1, bool largest=true, bool sorted=true) const
at::Tensor	all () const
at::Tensor	any () const
at::Tensor	renorm (const at::Scalar &p, int64_t dim, const at::Scalar &maxnorm) const
at::Tensor &	renorm_ (const at::Scalar &p, int64_t dim, const at::Scalar &maxnorm) const
at::Tensor	unfold (int64_t dimension, int64_t size, int64_t step) const
bool	equal (const at::Tensor &other) const
at::Tensor	pow (const at::Tensor &exponent) const
at::Tensor	pow (const at::Scalar &exponent) const
at::Tensor &	pow_ (const at::Scalar &exponent) const
at::Tensor &	pow_ (const at::Tensor &exponent) const
at::Tensor	float_power (const at::Tensor &exponent) const
at::Tensor	float_power (const at::Scalar &exponent) const
at::Tensor &	float_power_ (const at::Scalar &exponent) const
at::Tensor &	float_power_ (const at::Tensor &exponent) const
at::Tensor &	normal_ (double mean=0, double std=1, c10::optional< at::Generator > generator=c10::nullopt) const
at::Tensor	alias () const
at::Tensor	isfinite () const
at::Tensor	isinf () const
void	record_stream (at::Stream s) const
at::Tensor	isposinf () const
at::Tensor	isneginf () const
at::Tensor	det () const
::std::tuple< at::Tensor, at::Tensor >	slogdet () const
at::Tensor	logdet () const
at::Tensor	inverse () const
at::Tensor	inner (const at::Tensor &other) const
at::Tensor	outer (const at::Tensor &vec2) const
at::Tensor	ger (const at::Tensor &vec2) const
at::Tensor	to_padded_tensor (double padding, at::OptionalIntArrayRef output_size=c10::nullopt) const
at::Tensor	to_padded_tensor_symint (double padding, at::OptionalSymIntArrayRef output_size=c10::nullopt) const
Tensor	var (int dim) const
Tensor	std (int dim) const
Tensor	to (caffe2::TypeMeta type_meta, bool non_blocking=false, bool copy=false) const
Tensor	to (Device device, caffe2::TypeMeta type_meta, bool non_blocking=false, bool copy=false) const
template<typename F , typename... Args>
decltype(auto)	m (F func, Args &&... params) const
at::Tensor	tensor_data () const
	NOTE: This is similar to the legacy .data() function on Variable, and is intended to be used from functions that need to access the Variable's equivalent Tensor (i.e. More...
at::Tensor	variable_data () const
	NOTE: var.variable_data() in C++ has the same semantics as tensor.data in Python, which create a new Variable that shares the same storage and tensor metadata with the original Variable, but with a completely new autograd history. More...
template<typename T >
hook_return_void_t< T >	register_hook (T &&hook) const
	Registers a backward hook. More...
template<typename T >
hook_return_var_t< T >	register_hook (T &&hook) const
Tensor	data () const
void	_backward (TensorList inputs, const c10::optional< Tensor > &gradient, c10::optional< bool > keep_graph, bool create_graph) const
const Tensor &	requires_grad_ (bool _requires_grad=true) const
template<typename T >
auto	register_hook (T &&hook) const -> Tensor::hook_return_void_t< T >
int64_t	size (int64_t dim) const
c10::SymInt	sym_size (int64_t dim) const
int64_t	stride (int64_t dim) const
Public Member Functions inherited from at::TensorBase
	TensorBase ()=default
	TensorBase (c10::intrusive_ptr< TensorImpl, UndefinedTensorImpl > tensor_impl)
	TensorBase (const TensorBase &)=default
	TensorBase (TensorBase &&)=default
int64_t	dim () const
int64_t	storage_offset () const
TensorBase	contiguous (MemoryFormat memory_format=MemoryFormat::Contiguous) const
c10::MaybeOwned< TensorBase >	expect_contiguous (MemoryFormat memory_format=MemoryFormat::Contiguous) const &
	Should be used if *this can reasonably be expected to be contiguous and performance is important. More...
c10::MaybeOwned< TensorBase >	expect_contiguous (MemoryFormat memory_format=MemoryFormat::Contiguous) &&=delete
const TensorBase &	fill_ (const c10::Scalar &scalar) const
const TensorBase &	zero_ () const
TensorBase	to (at::TensorOptions options={}, bool non_blocking=false, bool copy=false, c10::optional< at::MemoryFormat > memory_format=c10::nullopt) const
bool	is_complex () const
bool	is_floating_point () const
bool	is_signed () const
c10::SymInt	sym_size (int64_t dim) const
c10::SymInt	sym_stride (int64_t dim) const
int64_t	size (int64_t dim) const
int64_t	stride (int64_t dim) const
TensorImpl *	unsafeGetTensorImpl () const
TensorImpl *	unsafeReleaseTensorImpl ()
const c10::intrusive_ptr< TensorImpl, UndefinedTensorImpl > &	getIntrusivePtr () const
c10::intrusive_ptr< TensorImpl, UndefinedTensorImpl >	unsafeReleaseIntrusivePtr ()
bool	defined () const
void	reset ()
TensorBase &	operator= (const TensorBase &x) &
TensorBase &	operator= (TensorBase &&x) &noexcept
TensorBase &	operator= (const TensorBase &) &&=delete
TensorBase &	operator= (TensorBase &&) &&noexcept=delete
bool	is_same (const TensorBase &other) const noexcept
size_t	use_count () const noexcept
size_t	weak_use_count () const noexcept
std::string	toString () const
IntArrayRef	sizes () const
c10::SymIntArrayRef	sym_sizes () const
c10::SymIntArrayRef	sym_strides () const
IntArrayRef	strides () const
c10::optional< DimnameList >	opt_names () const
DimnameList	names () const
int64_t	ndimension () const
bool	is_contiguous (at::MemoryFormat memory_format=at::MemoryFormat::Contiguous) const
bool	is_non_overlapping_and_dense () const
at::MemoryFormat	suggest_memory_format (bool channels_last_strides_exact_match=false) const
size_t	nbytes () const
c10::SymInt	sym_nbytes () const
int64_t	numel () const
c10::SymInt	sym_numel () const
c10::SymInt	sym_storage_offset () const
size_t	itemsize () const
int64_t	element_size () const
DispatchKeySet	key_set () const
ScalarType	scalar_type () const
bool	has_storage () const
const Storage &	storage () const
bool	is_alias_of (const at::TensorBase &other) const
bool	_is_zerotensor () const
void	_set_zero (bool zero) const
bool	is_conj () const
void	_set_conj (bool conjugate) const
bool	is_neg () const
void	_set_neg (bool negative) const
Layout	layout () const
	Returns a Tensor's layout. More...
caffe2::TypeMeta	dtype () const
	Returns a Tensor's dtype (TypeMeta). More...
Device	device () const
	Returns a Tensor's device. More...
int64_t	get_device () const
	Returns a Tensor's device index. More...
bool	is_cpu () const
	Returns if a Tensor has CPU backend. More...
bool	is_cuda () const
	Returns if a Tensor has CUDA backend. More...
bool	is_ipu () const
	Returns if a Tensor has IPU backend. More...
bool	is_xpu () const
	Returns if a Tensor has XPU backend. More...
bool	is_xla () const
	Returns if a Tensor has XLA backend. More...
bool	is_hpu () const
	Returns if a Tensor has HPU backend. More...
bool	is_lazy () const
	Returns if a Tensor has Lazy backend. More...
bool	is_hip () const
	Returns if a Tensor has HIP backend. More...
bool	is_ve () const
	Returns if a Tensor has VE backend. More...
bool	is_sparse () const
	Returns if a Tensor has sparse backend. More...
bool	is_sparse_csr () const
	Returns is a Tensor has a sparse CSR backend. More...
bool	is_mkldnn () const
	Returns if a Tensor is mkldnn tensor. More...
bool	is_mps () const
	Returns if a Tensor is mps tensor. More...
bool	is_ort () const
	Returns if a Tensor is ort tensor. More...
bool	is_vulkan () const
	Returns if a Tensor is vulkan tensor. More...
bool	is_metal () const
	Returns if a Tensor is metal tensor. More...
bool	is_quantized () const
	Returns if a Tensor has quantized backend. More...
bool	is_meta () const
	Returns if a Tensor is a meta tensor. More...
bool	is_inference () const
	Returns if a Tensor is an inference tensor. More...
bool	is_nested () const
QuantizerPtr	quantizer () const
	If a tensor is a quantized tensor, returns its quantizer TODO: it's not in native_functions.yaml yet as it's not exposed to python. More...
bool	has_names () const
	Returns if a Tensor has any dimension names. More...
const NamedTensorMeta *	get_named_tensor_meta () const
	Returns a Tensor's dimension names data structure. More...
NamedTensorMeta *	get_named_tensor_meta ()
TensorOptions	options () const
	Returns the TensorOptions corresponding to this Tensor. More...
void *	data_ptr () const
template<typename T >
T *	data_ptr () const
void	print () const
template<typename T , size_t N>
TensorAccessor< T, N >	accessor () const &
template<typename T , size_t N>
TensorAccessor< T, N >	accessor () &&=delete
template<typename T , size_t N, template< typename U > class PtrTraits = DefaultPtrTraits, typename index_t = int64_t>
GenericPackedTensorAccessor< T, N, PtrTraits, index_t >	generic_packed_accessor () const &
template<typename T , size_t N, template< typename U > class PtrTraits = DefaultPtrTraits, typename index_t = int64_t>
GenericPackedTensorAccessor< T, N >	generic_packed_accessor () &&=delete
template<typename T , size_t N, template< typename U > class PtrTraits = DefaultPtrTraits>
PackedTensorAccessor32< T, N, PtrTraits >	packed_accessor32 () const &
template<typename T , size_t N, template< typename U > class PtrTraits = DefaultPtrTraits>
PackedTensorAccessor32< T, N, PtrTraits >	packed_accessor32 () &&=delete
template<typename T , size_t N, template< typename U > class PtrTraits = DefaultPtrTraits>
PackedTensorAccessor64< T, N, PtrTraits >	packed_accessor64 () const &
template<typename T , size_t N, template< typename U > class PtrTraits = DefaultPtrTraits>
PackedTensorAccessor64< T, N, PtrTraits >	packed_accessor64 () &&=delete
const TensorBase &	set_requires_grad (bool requires_grad) const
bool	requires_grad () const
const Tensor &	_fw_grad (uint64_t level) const
	This function returns the forward gradient for this Tensor at the given level. More...
void	_set_fw_grad (const TensorBase &new_grad, uint64_t level, bool is_inplace_op) const
	This function can be used to set the value of the forward grad. More...
at::TensorBase	tensor_data () const
	NOTE: This is similar to the legacy .data() function on Variable, and is intended to be used from functions that need to access the Variable's equivalent Tensor (i.e. More...
at::TensorBase	variable_data () const
	NOTE: var.variable_data() in C++ has the same semantics as tensor.data in Python, which create a new Variable that shares the same storage and tensor metadata with the original Variable, but with a completely new autograd history. More...
const std::shared_ptr< torch::autograd::Node > &	grad_fn () const
	Gets the gradient function of the Variable. More...
template<typename T >
hook_return_void_t< T >	register_hook (T &&hook) const
	Registers a backward hook. More...
template<typename T >
hook_return_var_t< T >	register_hook (T &&hook) const
void	remove_hook (unsigned pos) const
	Remove hook at given position. More...
bool	is_leaf () const
	All Tensors that have requires_grad() which is false will be leaf Tensors by convention. More...
int64_t	output_nr () const
void	set_data (const TensorBase &new_data) const
TensorBase	data () const
int64_t	_version () const
void	retain_grad () const
	Enables this Tensor to have their :attr:grad populated during :func:backward. More...
bool	retains_grad () const
	Is true if this Tensor is non-leaf and its :attr:grad is enabled to be populated during :func:backward, false otherwise. More...
const TensorBase &	requires_grad_ (bool _requires_grad=true) const
bool	is_view () const
	Returns true if this Variable is a view of another Variable. More...
const TensorBase &	_base () const
	Returns the Variable that this Variable is a view of. More...
const std::string &	name () const
template<typename T >
auto	register_hook (T &&hook) const -> TensorBase::hook_return_void_t< T >

Static Public Member Functions
static Tensor	wrap_tensor_impl (c10::intrusive_ptr< TensorImpl, UndefinedTensorImpl > tensor_impl)
Static Public Member Functions inherited from at::TensorBase
static TensorBase	wrap_tensor_impl (c10::intrusive_ptr< TensorImpl, UndefinedTensorImpl > tensor_impl)

Public Attributes
	N
	PtrTraits

Protected Member Functions
	Tensor (unsafe_borrow_t, const TensorBase &rhs)
Protected Member Functions inherited from at::TensorBase
	TensorBase (unsafe_borrow_t, const TensorBase &rhs)
unsigned	_register_hook (std::function< TensorBase(const TensorBase &)> hook) const
void	enforce_invariants ()

Protected Attributes
friend	MaybeOwnedTraits< Tensor >
friend	OptionalTensorRef
Protected Attributes inherited from at::TensorBase
friend	MaybeOwnedTraits< TensorBase >
c10::intrusive_ptr< TensorImpl, UndefinedTensorImpl >	impl_

Member Typedef Documentation

hook_return_var_t

template<typename T >

using at::Tensor::hook_return_var_t = std::enable_if_t<std::is_same<typename c10::invoke_result_t<T&, Tensor>, Tensor>::value, unsigned>

hook_return_void_t

template<typename T >

using at::Tensor::hook_return_void_t = std::enable_if_t<std::is_void<typename c10::invoke_result_t<T&, Tensor> >::value, unsigned>

Constructor & Destructor Documentation

Tensor() [1/7]

at::Tensor::Tensor ( unsafe_borrow_t  , const TensorBase &  rhs  )

inlineexplicitprotected

Tensor() [2/7]

at::Tensor::Tensor ( )

default

Tensor() [3/7]

at::Tensor::Tensor ( c10::intrusive_ptr< TensorImpl, UndefinedTensorImpl >  tensor_impl )

inlineexplicit

Tensor() [4/7]

at::Tensor::Tensor ( const Tensor &  tensor )

default

Tensor() [5/7]

at::Tensor::Tensor ( Tensor &&  tensor )

default

Tensor() [6/7]

at::Tensor::Tensor ( const TensorBase &  base )

inlineexplicit

Tensor() [7/7]

at::Tensor::Tensor ( TensorBase &&  base )

inline

Member Function Documentation

__and__() [1/2]

at::Tensor at::Tensor::__and__ ( const at::Scalar &  other ) const

inline

__and__() [2/2]

at::Tensor at::Tensor::__and__ ( const at::Tensor &  other ) const

inline

__dispatch__backward()

void at::Tensor::__dispatch__backward ( at::TensorList  inputs, const c10::optional< at::Tensor > &  gradient = {}, c10::optional< bool >  retain_graph = c10::nullopt, bool  create_graph = false  ) const

inline

__dispatch__is_zerotensor()

bool at::Tensor::__dispatch__is_zerotensor ( ) const

inline

__dispatch__version()

int64_t at::Tensor::__dispatch__version ( ) const

inline

__dispatch_conj()

at::Tensor at::Tensor::__dispatch_conj ( ) const

inline

__dispatch_contiguous()

at::Tensor at::Tensor::__dispatch_contiguous ( at::MemoryFormat  memory_format = MemoryFormat::Contiguous ) const

inline

__dispatch_data()

at::Tensor at::Tensor::__dispatch_data ( ) const

inline

__dispatch_is_complex()

bool at::Tensor::__dispatch_is_complex ( ) const

inline

__dispatch_is_conj()

bool at::Tensor::__dispatch_is_conj ( ) const

inline

__dispatch_is_floating_point()

bool at::Tensor::__dispatch_is_floating_point ( ) const

inline

__dispatch_is_inference()

bool at::Tensor::__dispatch_is_inference ( ) const

inline

__dispatch_is_leaf()

bool at::Tensor::__dispatch_is_leaf ( ) const

inline

__dispatch_is_neg()

bool at::Tensor::__dispatch_is_neg ( ) const

inline

__dispatch_is_signed()

bool at::Tensor::__dispatch_is_signed ( ) const

inline

__dispatch_output_nr()

int64_t at::Tensor::__dispatch_output_nr ( ) const

inline

__dispatch_requires_grad_()

at::Tensor & at::Tensor::__dispatch_requires_grad_ ( bool  requires_grad = true ) const

inline

__dispatch_retain_grad()

void at::Tensor::__dispatch_retain_grad ( ) const

inline

__dispatch_retains_grad()

bool at::Tensor::__dispatch_retains_grad ( ) const

inline

__dispatch_set_data()

void at::Tensor::__dispatch_set_data ( const at::Tensor &  new_data ) const

inline

__iand__() [1/2]

at::Tensor & at::Tensor::__iand__ ( const at::Scalar &  other ) const

inline

__iand__() [2/2]

at::Tensor & at::Tensor::__iand__ ( const at::Tensor &  other ) const

inline

__ilshift__() [1/2]

at::Tensor & at::Tensor::__ilshift__ ( const at::Scalar &  other ) const

inline

__ilshift__() [2/2]

at::Tensor & at::Tensor::__ilshift__ ( const at::Tensor &  other ) const

inline

__ior__() [1/2]

at::Tensor & at::Tensor::__ior__ ( const at::Scalar &  other ) const

inline

__ior__() [2/2]

at::Tensor & at::Tensor::__ior__ ( const at::Tensor &  other ) const

inline

__irshift__() [1/2]

at::Tensor & at::Tensor::__irshift__ ( const at::Scalar &  other ) const

inline

__irshift__() [2/2]

at::Tensor & at::Tensor::__irshift__ ( const at::Tensor &  other ) const

inline

__ixor__() [1/2]

at::Tensor & at::Tensor::__ixor__ ( const at::Scalar &  other ) const

inline

__ixor__() [2/2]

at::Tensor & at::Tensor::__ixor__ ( const at::Tensor &  other ) const

inline

__lshift__() [1/2]

at::Tensor at::Tensor::__lshift__ ( const at::Scalar &  other ) const

inline

__lshift__() [2/2]

at::Tensor at::Tensor::__lshift__ ( const at::Tensor &  other ) const

inline

__or__() [1/2]

at::Tensor at::Tensor::__or__ ( const at::Scalar &  other ) const

inline

__or__() [2/2]

at::Tensor at::Tensor::__or__ ( const at::Tensor &  other ) const

inline

__rshift__() [1/2]

at::Tensor at::Tensor::__rshift__ ( const at::Scalar &  other ) const

inline

__rshift__() [2/2]

at::Tensor at::Tensor::__rshift__ ( const at::Tensor &  other ) const

inline

__xor__() [1/2]

at::Tensor at::Tensor::__xor__ ( const at::Scalar &  other ) const

inline

__xor__() [2/2]

at::Tensor at::Tensor::__xor__ ( const at::Tensor &  other ) const

inline

_addmm_activation()

at::Tensor at::Tensor::_addmm_activation ( const at::Tensor &  mat1, const at::Tensor &  mat2, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1, bool  use_gelu = false  ) const

inline

_autocast_to_full_precision()

at::Tensor at::Tensor::_autocast_to_full_precision ( bool  cuda_enabled, bool  cpu_enabled  ) const

inline

_autocast_to_reduced_precision()

at::Tensor at::Tensor::_autocast_to_reduced_precision ( bool  cuda_enabled, bool  cpu_enabled, at::ScalarType  cuda_dtype, at::ScalarType  cpu_dtype  ) const

inline

_backward()

void at::Tensor::_backward	(	TensorList	inputs,
		const c10::optional< Tensor > &	gradient,
		c10::optional< bool >	keep_graph,
		bool	create_graph
	)		const

_coalesced_()

at::Tensor & at::Tensor::_coalesced_ ( bool  coalesced ) const

inline

_conj()

at::Tensor at::Tensor::_conj ( ) const

inline

_conj_physical()

at::Tensor at::Tensor::_conj_physical ( ) const

inline

_dimI()

int64_t at::Tensor::_dimI ( ) const

inline

_dimV()

int64_t at::Tensor::_dimV ( ) const

inline

_fw_grad()

const Tensor & at::Tensor::_fw_grad ( uint64_t  level ) const

inline

This function returns the forward gradient for this Tensor at the given level.

_fw_primal()

at::Tensor at::Tensor::_fw_primal ( int64_t  level ) const

inline

_indices()

at::Tensor at::Tensor::_indices ( ) const

inline

_is_all_true()

at::Tensor at::Tensor::_is_all_true ( ) const

inline

_is_any_true()

at::Tensor at::Tensor::_is_any_true ( ) const

inline

_neg_view()

at::Tensor at::Tensor::_neg_view ( ) const

inline

_nested_tensor_offsets()

std::vector< int64_t > at::Tensor::_nested_tensor_offsets ( ) const

inline

_nested_tensor_size()

at::Tensor at::Tensor::_nested_tensor_size ( ) const

inline

_nested_tensor_strides()

at::Tensor at::Tensor::_nested_tensor_strides ( ) const

inline

_nnz()

int64_t at::Tensor::_nnz ( ) const

inline

_reshape_alias()

at::Tensor at::Tensor::_reshape_alias ( at::IntArrayRef  size, at::IntArrayRef  stride  ) const

inline

_reshape_alias_symint()

at::Tensor at::Tensor::_reshape_alias_symint ( c10::SymIntArrayRef  size, c10::SymIntArrayRef  stride  ) const

inline

_set_fw_grad()

void at::Tensor::_set_fw_grad ( const TensorBase &  new_grad, uint64_t  level, bool  is_inplace_op  ) const

inline

This function can be used to set the value of the forward grad.

Note that the given new_grad might not be used directly if it has different metadata (size/stride/storage offset) compared to this Tensor. In that case, new_grad content will be copied into a new Tensor

_to_dense()

at::Tensor at::Tensor::_to_dense ( c10::optional< at::ScalarType >  dtype = c10::nullopt ) const

inline

_values()

at::Tensor at::Tensor::_values ( ) const

inline

abs()

at::Tensor at::Tensor::abs ( ) const

inline

abs_()

at::Tensor & at::Tensor::abs_ ( ) const

inline

absolute()

at::Tensor at::Tensor::absolute ( ) const

inline

absolute_()

at::Tensor & at::Tensor::absolute_ ( ) const

inline

acos()

at::Tensor at::Tensor::acos ( ) const

inline

acos_()

at::Tensor & at::Tensor::acos_ ( ) const

inline

acosh()

at::Tensor at::Tensor::acosh ( ) const

inline

acosh_()

at::Tensor & at::Tensor::acosh_ ( ) const

inline

add() [1/2]

at::Tensor at::Tensor::add ( const at::Scalar &  other, const at::Scalar &  alpha = 1  ) const

inline

add() [2/2]

at::Tensor at::Tensor::add ( const at::Tensor &  other, const at::Scalar &  alpha = 1  ) const

inline

add_() [1/2]

at::Tensor & at::Tensor::add_ ( const at::Scalar &  other, const at::Scalar &  alpha = 1  ) const

inline

add_() [2/2]

at::Tensor & at::Tensor::add_ ( const at::Tensor &  other, const at::Scalar &  alpha = 1  ) const

inline

addbmm()

at::Tensor at::Tensor::addbmm ( const at::Tensor &  batch1, const at::Tensor &  batch2, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1  ) const

inline

addbmm_()

at::Tensor & at::Tensor::addbmm_ ( const at::Tensor &  batch1, const at::Tensor &  batch2, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1  ) const

inline

addcdiv()

at::Tensor at::Tensor::addcdiv ( const at::Tensor &  tensor1, const at::Tensor &  tensor2, const at::Scalar &  value = 1  ) const

inline

addcdiv_()

at::Tensor & at::Tensor::addcdiv_ ( const at::Tensor &  tensor1, const at::Tensor &  tensor2, const at::Scalar &  value = 1  ) const

inline

addcmul()

at::Tensor at::Tensor::addcmul ( const at::Tensor &  tensor1, const at::Tensor &  tensor2, const at::Scalar &  value = 1  ) const

inline

addcmul_()

at::Tensor & at::Tensor::addcmul_ ( const at::Tensor &  tensor1, const at::Tensor &  tensor2, const at::Scalar &  value = 1  ) const

inline

addmm()

at::Tensor at::Tensor::addmm ( const at::Tensor &  mat1, const at::Tensor &  mat2, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1  ) const

inline

addmm_()

at::Tensor & at::Tensor::addmm_ ( const at::Tensor &  mat1, const at::Tensor &  mat2, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1  ) const

inline

addmv()

at::Tensor at::Tensor::addmv ( const at::Tensor &  mat, const at::Tensor &  vec, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1  ) const

inline

addmv_()

at::Tensor & at::Tensor::addmv_ ( const at::Tensor &  mat, const at::Tensor &  vec, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1  ) const

inline

addr()

at::Tensor at::Tensor::addr ( const at::Tensor &  vec1, const at::Tensor &  vec2, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1  ) const

inline

addr_()

at::Tensor & at::Tensor::addr_ ( const at::Tensor &  vec1, const at::Tensor &  vec2, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1  ) const

inline

adjoint()

at::Tensor at::Tensor::adjoint ( ) const

inline

alias()

at::Tensor at::Tensor::alias ( ) const

inline

align_as()

at::Tensor at::Tensor::align_as ( const at::Tensor &  other ) const

inline

align_to() [1/2]

at::Tensor at::Tensor::align_to ( at::DimnameList  names ) const

inline

align_to() [2/2]

at::Tensor at::Tensor::align_to ( at::DimnameList  order, int64_t  ellipsis_idx  ) const

inline

all() [1/3]

at::Tensor at::Tensor::all ( ) const

inline

all() [2/3]

at::Tensor at::Tensor::all ( at::Dimname  dim, bool  keepdim = false  ) const

inline

all() [3/3]

at::Tensor at::Tensor::all ( int64_t  dim, bool  keepdim = false  ) const

inline

allclose()

bool at::Tensor::allclose ( const at::Tensor &  other, double  rtol = 1e-05, double  atol = 1e-08, bool  equal_nan = false  ) const

inline

amax()

at::Tensor at::Tensor::amax ( at::IntArrayRef  dim = {}, bool  keepdim = false  ) const

inline

amin()

at::Tensor at::Tensor::amin ( at::IntArrayRef  dim = {}, bool  keepdim = false  ) const

inline

aminmax()

std::tuple< at::Tensor, at::Tensor > at::Tensor::aminmax ( c10::optional< int64_t >  dim = c10::nullopt, bool  keepdim = false  ) const

inline

angle()

at::Tensor at::Tensor::angle ( ) const

inline

any() [1/3]

at::Tensor at::Tensor::any ( ) const

inline

any() [2/3]

at::Tensor at::Tensor::any ( at::Dimname  dim, bool  keepdim = false  ) const

inline

any() [3/3]

at::Tensor at::Tensor::any ( int64_t  dim, bool  keepdim = false  ) const

inline

arccos()

at::Tensor at::Tensor::arccos ( ) const

inline

arccos_()

at::Tensor & at::Tensor::arccos_ ( ) const

inline

arccosh()

at::Tensor at::Tensor::arccosh ( ) const

inline

arccosh_()

at::Tensor & at::Tensor::arccosh_ ( ) const

inline

arcsin()

at::Tensor at::Tensor::arcsin ( ) const

inline

arcsin_()

at::Tensor & at::Tensor::arcsin_ ( ) const

inline

arcsinh()

at::Tensor at::Tensor::arcsinh ( ) const

inline

arcsinh_()

at::Tensor & at::Tensor::arcsinh_ ( ) const

inline

arctan()

at::Tensor at::Tensor::arctan ( ) const

inline

arctan2()

at::Tensor at::Tensor::arctan2 ( const at::Tensor &  other ) const

inline

arctan2_()

at::Tensor & at::Tensor::arctan2_ ( const at::Tensor &  other ) const

inline

arctan_()

at::Tensor & at::Tensor::arctan_ ( ) const

inline

arctanh()

at::Tensor at::Tensor::arctanh ( ) const

inline

arctanh_()

at::Tensor & at::Tensor::arctanh_ ( ) const

inline

argmax()

at::Tensor at::Tensor::argmax ( c10::optional< int64_t >  dim = c10::nullopt, bool  keepdim = false  ) const

inline

argmin()

at::Tensor at::Tensor::argmin ( c10::optional< int64_t >  dim = c10::nullopt, bool  keepdim = false  ) const

inline

argsort() [1/3]

at::Tensor at::Tensor::argsort ( at::Dimname  dim, bool  descending = false  ) const

inline

argsort() [2/3]

at::Tensor at::Tensor::argsort ( bool  stable, int64_t  dim = -1, bool  descending = false  ) const

inline

argsort() [3/3]

at::Tensor at::Tensor::argsort ( int64_t  dim = -1, bool  descending = false  ) const

inline

argwhere()

at::Tensor at::Tensor::argwhere ( ) const

inline

as_strided()

at::Tensor at::Tensor::as_strided ( at::IntArrayRef  size, at::IntArrayRef  stride, c10::optional< int64_t >  storage_offset = c10::nullopt  ) const

inline

as_strided_()

const at::Tensor & at::Tensor::as_strided_ ( at::IntArrayRef  size, at::IntArrayRef  stride, c10::optional< int64_t >  storage_offset = c10::nullopt  ) const

inline

as_strided__symint()

const at::Tensor & at::Tensor::as_strided__symint ( c10::SymIntArrayRef  size, c10::SymIntArrayRef  stride, c10::optional< c10::SymInt >  storage_offset = c10::nullopt  ) const

inline

as_strided_scatter()

at::Tensor at::Tensor::as_strided_scatter ( const at::Tensor &  src, at::IntArrayRef  size, at::IntArrayRef  stride, c10::optional< int64_t >  storage_offset = c10::nullopt  ) const

inline

as_strided_scatter_symint()

at::Tensor at::Tensor::as_strided_scatter_symint ( const at::Tensor &  src, c10::SymIntArrayRef  size, c10::SymIntArrayRef  stride, c10::optional< c10::SymInt >  storage_offset = c10::nullopt  ) const

inline

as_strided_symint()

at::Tensor at::Tensor::as_strided_symint ( c10::SymIntArrayRef  size, c10::SymIntArrayRef  stride, c10::optional< c10::SymInt >  storage_offset = c10::nullopt  ) const

inline

asin()

at::Tensor at::Tensor::asin ( ) const

inline

asin_()

at::Tensor & at::Tensor::asin_ ( ) const

inline

asinh()

at::Tensor at::Tensor::asinh ( ) const

inline

asinh_()

at::Tensor & at::Tensor::asinh_ ( ) const

inline

atan()

at::Tensor at::Tensor::atan ( ) const

inline

atan2()

at::Tensor at::Tensor::atan2 ( const at::Tensor &  other ) const

inline

atan2_()

at::Tensor & at::Tensor::atan2_ ( const at::Tensor &  other ) const

inline

atan_()

at::Tensor & at::Tensor::atan_ ( ) const

inline

atanh()

at::Tensor at::Tensor::atanh ( ) const

inline

atanh_()

at::Tensor & at::Tensor::atanh_ ( ) const

inline

backward()

void at::Tensor::backward ( const Tensor &  gradient = {}, c10::optional< bool >  retain_graph = c10::nullopt, bool  create_graph = false, c10::optional< TensorList >  inputs = c10::nullopt  ) const

inline

Computes the gradient of current tensor with respect to graph leaves.

The graph is differentiated using the chain rule. If the tensor is non-scalar (i.e. its data has more than one element) and requires gradient, the function additionally requires specifying gradient. It should be a tensor of matching type and location, that contains the gradient of the differentiated function w.r.t. this Tensor.

This function accumulates gradients in the leaves - you might need to zero them before calling it.

Parameters

gradient	Gradient w.r.t. the tensor. If it is a tensor, it will be automatically converted to a Tensor that does not require grad unless create_graph is True. None values can be specified for scalar Tensors or ones that don't require grad. If a None value would be acceptable then this argument is optional.
retain_graph	If false, the graph used to compute the grads will be freed. Note that in nearly all cases setting this option to True is not needed and often can be worked around in a much more efficient way. Defaults to the value of create_graph.
create_graph	If true, graph of the derivative will be constructed, allowing to compute higher order derivative products. Defaults to false.
inputs	Inputs w.r.t. which the gradient will be accumulated into at::Tensor::grad. All other Tensors will be ignored. If not provided, the gradient is accumulated into all the leaf Tensors that were used to compute the current tensor. When inputs are provided and a given input is not a leaf, the current implementation will call its grad_fn (even though it is not strictly needed to get this gradients). It is an implementation detail on which the user should not rely. See https://github.com/pytorch/pytorch/pull/60521#issuecomment-867061780 for more details.

baddbmm()

at::Tensor at::Tensor::baddbmm ( const at::Tensor &  batch1, const at::Tensor &  batch2, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1  ) const

inline

baddbmm_()

at::Tensor & at::Tensor::baddbmm_ ( const at::Tensor &  batch1, const at::Tensor &  batch2, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1  ) const

inline

bernoulli() [1/2]

at::Tensor at::Tensor::bernoulli ( c10::optional< at::Generator >  generator = c10::nullopt ) const

inline

bernoulli() [2/2]

at::Tensor at::Tensor::bernoulli ( double  p, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

bernoulli_() [1/2]

at::Tensor & at::Tensor::bernoulli_ ( const at::Tensor &  p, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

bernoulli_() [2/2]

at::Tensor & at::Tensor::bernoulli_ ( double  p = 0.5, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

bincount()

at::Tensor at::Tensor::bincount ( const c10::optional< at::Tensor > &  weights = {}, int64_t  minlength = 0  ) const

inline

bitwise_and() [1/2]

at::Tensor at::Tensor::bitwise_and ( const at::Scalar &  other ) const

inline

bitwise_and() [2/2]

at::Tensor at::Tensor::bitwise_and ( const at::Tensor &  other ) const

inline

bitwise_and_() [1/2]

at::Tensor & at::Tensor::bitwise_and_ ( const at::Scalar &  other ) const

inline

bitwise_and_() [2/2]

at::Tensor & at::Tensor::bitwise_and_ ( const at::Tensor &  other ) const

inline

bitwise_left_shift() [1/2]

at::Tensor at::Tensor::bitwise_left_shift ( const at::Scalar &  other ) const

inline

bitwise_left_shift() [2/2]

at::Tensor at::Tensor::bitwise_left_shift ( const at::Tensor &  other ) const

inline

bitwise_left_shift_() [1/2]

at::Tensor & at::Tensor::bitwise_left_shift_ ( const at::Scalar &  other ) const

inline

bitwise_left_shift_() [2/2]

at::Tensor & at::Tensor::bitwise_left_shift_ ( const at::Tensor &  other ) const

inline

bitwise_not()

at::Tensor at::Tensor::bitwise_not ( ) const

inline

bitwise_not_()

at::Tensor & at::Tensor::bitwise_not_ ( ) const

inline

bitwise_or() [1/2]

at::Tensor at::Tensor::bitwise_or ( const at::Scalar &  other ) const

inline

bitwise_or() [2/2]

at::Tensor at::Tensor::bitwise_or ( const at::Tensor &  other ) const

inline

bitwise_or_() [1/2]

at::Tensor & at::Tensor::bitwise_or_ ( const at::Scalar &  other ) const

inline

bitwise_or_() [2/2]

at::Tensor & at::Tensor::bitwise_or_ ( const at::Tensor &  other ) const

inline

bitwise_right_shift() [1/2]

at::Tensor at::Tensor::bitwise_right_shift ( const at::Scalar &  other ) const

inline

bitwise_right_shift() [2/2]

at::Tensor at::Tensor::bitwise_right_shift ( const at::Tensor &  other ) const

inline

bitwise_right_shift_() [1/2]

at::Tensor & at::Tensor::bitwise_right_shift_ ( const at::Scalar &  other ) const

inline

bitwise_right_shift_() [2/2]

at::Tensor & at::Tensor::bitwise_right_shift_ ( const at::Tensor &  other ) const

inline

bitwise_xor() [1/2]

at::Tensor at::Tensor::bitwise_xor ( const at::Scalar &  other ) const

inline

bitwise_xor() [2/2]

at::Tensor at::Tensor::bitwise_xor ( const at::Tensor &  other ) const

inline

bitwise_xor_() [1/2]

at::Tensor & at::Tensor::bitwise_xor_ ( const at::Scalar &  other ) const

inline

bitwise_xor_() [2/2]

at::Tensor & at::Tensor::bitwise_xor_ ( const at::Tensor &  other ) const

inline

bmm()

at::Tensor at::Tensor::bmm ( const at::Tensor &  mat2 ) const

inline

broadcast_to()

at::Tensor at::Tensor::broadcast_to ( at::IntArrayRef  size ) const

inline

broadcast_to_symint()

at::Tensor at::Tensor::broadcast_to_symint ( c10::SymIntArrayRef  size ) const

inline

C10_DEPRECATED_MESSAGE() [1/5]

template<typename T , size_t N, template< typename U > class PtrTraits = DefaultPtrTraits, typename index_t = int64_t>

at::Tensor::C10_DEPRECATED_MESSAGE	(	"packed_accessor is	deprecated,
		use packed_accessor32 or packed_accessor64 instead"
	)

C10_DEPRECATED_MESSAGE() [2/5]

template<typename T , size_t N, template< typename U > class PtrTraits = DefaultPtrTraits, typename index_t = int64_t>

at::Tensor::C10_DEPRECATED_MESSAGE	(	"packed_accessor is	deprecated,
		use packed_accessor32 or packed_accessor64 instead"
	)

C10_DEPRECATED_MESSAGE() [3/5]

template<typename T >

at::Tensor::C10_DEPRECATED_MESSAGE ( "Tensor.data<T>() is deprecated. Please use Tensor.data_ptr<T>() instead."  ) const

inline

C10_DEPRECATED_MESSAGE() [4/5]

at::Tensor::C10_DEPRECATED_MESSAGE ( "Tensor.is_variable() is deprecated; everything is a variable now. (If you want to assert that variable has been appropriately handled already, use at::impl::variable_excluded_from_dispatch())"  ) const

inlinenoexcept

C10_DEPRECATED_MESSAGE() [5/5]

at::Tensor::C10_DEPRECATED_MESSAGE ( "Tensor.  type) is deprecated. Instead use Tensor.options(, which in many   casese.g. in a constructor) is a drop-in replacement. If you were using data from type(, that is now available from Tensor  itself, so instead of tensor.  type).scalar_type(, use tensor.scalar_type() instead and instead of tensor.type().backend() use tensor.device()."    ) const &

inline

cauchy_()

at::Tensor & at::Tensor::cauchy_ ( double  median = 0, double  sigma = 1, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

ccol_indices()

at::Tensor at::Tensor::ccol_indices ( ) const

inline

ceil()

at::Tensor at::Tensor::ceil ( ) const

inline

ceil_()

at::Tensor & at::Tensor::ceil_ ( ) const

inline

chalf()

at::Tensor at::Tensor::chalf ( c10::optional< at::MemoryFormat >  memory_format = c10::nullopt ) const

inline

cholesky()

at::Tensor at::Tensor::cholesky ( bool  upper = false ) const

inline

cholesky_inverse()

at::Tensor at::Tensor::cholesky_inverse ( bool  upper = false ) const

inline

cholesky_solve()

at::Tensor at::Tensor::cholesky_solve ( const at::Tensor &  input2, bool  upper = false  ) const

inline

chunk()

std::vector< at::Tensor > at::Tensor::chunk ( int64_t  chunks, int64_t  dim = 0  ) const

inline

clamp() [1/2]

at::Tensor at::Tensor::clamp ( const c10::optional< at::Scalar > &  min, const c10::optional< at::Scalar > &  max = c10::nullopt  ) const

inline

clamp() [2/2]

at::Tensor at::Tensor::clamp ( const c10::optional< at::Tensor > &  min = {}, const c10::optional< at::Tensor > &  max = {}  ) const

inline

clamp_() [1/2]

at::Tensor & at::Tensor::clamp_ ( const c10::optional< at::Scalar > &  min, const c10::optional< at::Scalar > &  max = c10::nullopt  ) const

inline

clamp_() [2/2]

at::Tensor & at::Tensor::clamp_ ( const c10::optional< at::Tensor > &  min = {}, const c10::optional< at::Tensor > &  max = {}  ) const

inline

clamp_max() [1/2]

at::Tensor at::Tensor::clamp_max ( const at::Scalar &  max ) const

inline

clamp_max() [2/2]

at::Tensor at::Tensor::clamp_max ( const at::Tensor &  max ) const

inline

clamp_max_() [1/2]

at::Tensor & at::Tensor::clamp_max_ ( const at::Scalar &  max ) const

inline

clamp_max_() [2/2]

at::Tensor & at::Tensor::clamp_max_ ( const at::Tensor &  max ) const

inline

clamp_min() [1/2]

at::Tensor at::Tensor::clamp_min ( const at::Scalar &  min ) const

inline

clamp_min() [2/2]

at::Tensor at::Tensor::clamp_min ( const at::Tensor &  min ) const

inline

clamp_min_() [1/2]

at::Tensor & at::Tensor::clamp_min_ ( const at::Scalar &  min ) const

inline

clamp_min_() [2/2]

at::Tensor & at::Tensor::clamp_min_ ( const at::Tensor &  min ) const

inline

clip() [1/2]

at::Tensor at::Tensor::clip ( const c10::optional< at::Scalar > &  min, const c10::optional< at::Scalar > &  max = c10::nullopt  ) const

inline

clip() [2/2]

at::Tensor at::Tensor::clip ( const c10::optional< at::Tensor > &  min = {}, const c10::optional< at::Tensor > &  max = {}  ) const

inline

clip_() [1/2]

at::Tensor & at::Tensor::clip_ ( const c10::optional< at::Scalar > &  min, const c10::optional< at::Scalar > &  max = c10::nullopt  ) const

inline

clip_() [2/2]

at::Tensor & at::Tensor::clip_ ( const c10::optional< at::Tensor > &  min = {}, const c10::optional< at::Tensor > &  max = {}  ) const

inline

clone()

at::Tensor at::Tensor::clone ( c10::optional< at::MemoryFormat >  memory_format = c10::nullopt ) const

inline

coalesce()

at::Tensor at::Tensor::coalesce ( ) const

inline

col_indices()

at::Tensor at::Tensor::col_indices ( ) const

inline

conj()

Tensor at::Tensor::conj ( ) const

inline

conj_physical()

at::Tensor at::Tensor::conj_physical ( ) const

inline

conj_physical_()

at::Tensor & at::Tensor::conj_physical_ ( ) const

inline

contiguous()

Tensor at::Tensor::contiguous ( MemoryFormat  memory_format = MemoryFormat::Contiguous ) const

inline

copy_()

at::Tensor & at::Tensor::copy_ ( const at::Tensor &  src, bool  non_blocking = false  ) const

inline

copysign() [1/2]

at::Tensor at::Tensor::copysign ( const at::Scalar &  other ) const

inline

copysign() [2/2]

at::Tensor at::Tensor::copysign ( const at::Tensor &  other ) const

inline

copysign_() [1/2]

at::Tensor & at::Tensor::copysign_ ( const at::Scalar &  other ) const

inline

copysign_() [2/2]

at::Tensor & at::Tensor::copysign_ ( const at::Tensor &  other ) const

inline

corrcoef()

at::Tensor at::Tensor::corrcoef ( ) const

inline

cos()

at::Tensor at::Tensor::cos ( ) const

inline

cos_()

at::Tensor & at::Tensor::cos_ ( ) const

inline

cosh()

at::Tensor at::Tensor::cosh ( ) const

inline

cosh_()

at::Tensor & at::Tensor::cosh_ ( ) const

inline

count_nonzero() [1/2]

at::Tensor at::Tensor::count_nonzero ( at::IntArrayRef  dim ) const

inline

count_nonzero() [2/2]

at::Tensor at::Tensor::count_nonzero ( c10::optional< int64_t >  dim = c10::nullopt ) const

inline

cov()

at::Tensor at::Tensor::cov ( int64_t  correction = 1, const c10::optional< at::Tensor > &  fweights = {}, const c10::optional< at::Tensor > &  aweights = {}  ) const

inline

cpu()

Tensor at::Tensor::cpu ( ) const

inline

cross()

at::Tensor at::Tensor::cross ( const at::Tensor &  other, c10::optional< int64_t >  dim = c10::nullopt  ) const

inline

crow_indices()

at::Tensor at::Tensor::crow_indices ( ) const

inline

cuda()

Tensor at::Tensor::cuda ( ) const

inline

cummax() [1/2]

std::tuple< at::Tensor, at::Tensor > at::Tensor::cummax ( at::Dimname  dim ) const

inline

cummax() [2/2]

std::tuple< at::Tensor, at::Tensor > at::Tensor::cummax ( int64_t  dim ) const

inline

cummin() [1/2]

std::tuple< at::Tensor, at::Tensor > at::Tensor::cummin ( at::Dimname  dim ) const

inline

cummin() [2/2]

std::tuple< at::Tensor, at::Tensor > at::Tensor::cummin ( int64_t  dim ) const

inline

cumprod() [1/2]

at::Tensor at::Tensor::cumprod ( at::Dimname  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

cumprod() [2/2]

at::Tensor at::Tensor::cumprod ( int64_t  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

cumprod_() [1/2]

at::Tensor & at::Tensor::cumprod_ ( at::Dimname  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

cumprod_() [2/2]

at::Tensor & at::Tensor::cumprod_ ( int64_t  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

cumsum() [1/2]

at::Tensor at::Tensor::cumsum ( at::Dimname  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

cumsum() [2/2]

at::Tensor at::Tensor::cumsum ( int64_t  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

cumsum_() [1/2]

at::Tensor & at::Tensor::cumsum_ ( at::Dimname  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

cumsum_() [2/2]

at::Tensor & at::Tensor::cumsum_ ( int64_t  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

data()

Tensor at::Tensor::data ( ) const

inline

deg2rad()

at::Tensor at::Tensor::deg2rad ( ) const

inline

deg2rad_()

at::Tensor & at::Tensor::deg2rad_ ( ) const

inline

dense_dim()

int64_t at::Tensor::dense_dim ( ) const

inline

dequantize()

at::Tensor at::Tensor::dequantize ( ) const

inline

det()

at::Tensor at::Tensor::det ( ) const

inline

detach()

at::Tensor at::Tensor::detach ( ) const

inline

Returns a new Tensor, detached from the current graph.

The result will never require gradient.

detach_()

at::Tensor & at::Tensor::detach_ ( ) const

inline

Detaches the Tensor from the graph that created it, making it a leaf.

Views cannot be detached in-place.

diag()

at::Tensor at::Tensor::diag ( int64_t  diagonal = 0 ) const

inline

diag_embed()

at::Tensor at::Tensor::diag_embed ( int64_t  offset = 0, int64_t  dim1 = -2, int64_t  dim2 = -1  ) const

inline

diagflat()

at::Tensor at::Tensor::diagflat ( int64_t  offset = 0 ) const

inline

diagonal() [1/2]

at::Tensor at::Tensor::diagonal ( at::Dimname  outdim, at::Dimname  dim1, at::Dimname  dim2, int64_t  offset = 0  ) const

inline

diagonal() [2/2]

at::Tensor at::Tensor::diagonal ( int64_t  offset = 0, int64_t  dim1 = 0, int64_t  dim2 = 1  ) const

inline

diagonal_scatter()

at::Tensor at::Tensor::diagonal_scatter ( const at::Tensor &  src, int64_t  offset = 0, int64_t  dim1 = 0, int64_t  dim2 = 1  ) const

inline

diff()

at::Tensor at::Tensor::diff ( int64_t  n = 1, int64_t  dim = -1, const c10::optional< at::Tensor > &  prepend = {}, const c10::optional< at::Tensor > &  append = {}  ) const

inline

digamma()

at::Tensor at::Tensor::digamma ( ) const

inline

digamma_()

at::Tensor & at::Tensor::digamma_ ( ) const

inline

dist()

at::Tensor at::Tensor::dist ( const at::Tensor &  other, const at::Scalar &  p = 2  ) const

inline

div() [1/4]

at::Tensor at::Tensor::div ( const at::Scalar &  other ) const

inline

div() [2/4]

at::Tensor at::Tensor::div ( const at::Scalar &  other, c10::optional< c10::string_view >  rounding_mode  ) const

inline

div() [3/4]

at::Tensor at::Tensor::div ( const at::Tensor &  other ) const

inline

div() [4/4]

at::Tensor at::Tensor::div ( const at::Tensor &  other, c10::optional< c10::string_view >  rounding_mode  ) const

inline

div_() [1/4]

at::Tensor & at::Tensor::div_ ( const at::Scalar &  other ) const

inline

div_() [2/4]

at::Tensor & at::Tensor::div_ ( const at::Scalar &  other, c10::optional< c10::string_view >  rounding_mode  ) const

inline

div_() [3/4]

at::Tensor & at::Tensor::div_ ( const at::Tensor &  other ) const

inline

div_() [4/4]

at::Tensor & at::Tensor::div_ ( const at::Tensor &  other, c10::optional< c10::string_view >  rounding_mode  ) const

inline

divide() [1/4]

at::Tensor at::Tensor::divide ( const at::Scalar &  other ) const

inline

divide() [2/4]

at::Tensor at::Tensor::divide ( const at::Scalar &  other, c10::optional< c10::string_view >  rounding_mode  ) const

inline

divide() [3/4]

at::Tensor at::Tensor::divide ( const at::Tensor &  other ) const

inline

divide() [4/4]

at::Tensor at::Tensor::divide ( const at::Tensor &  other, c10::optional< c10::string_view >  rounding_mode  ) const

inline

divide_() [1/4]

at::Tensor & at::Tensor::divide_ ( const at::Scalar &  other ) const

inline

divide_() [2/4]

at::Tensor & at::Tensor::divide_ ( const at::Scalar &  other, c10::optional< c10::string_view >  rounding_mode  ) const

inline

divide_() [3/4]

at::Tensor & at::Tensor::divide_ ( const at::Tensor &  other ) const

inline

divide_() [4/4]

at::Tensor & at::Tensor::divide_ ( const at::Tensor &  other, c10::optional< c10::string_view >  rounding_mode  ) const

inline

dot()

at::Tensor at::Tensor::dot ( const at::Tensor &  tensor ) const

inline

dsplit() [1/2]

std::vector< at::Tensor > at::Tensor::dsplit ( at::IntArrayRef  indices ) const

inline

dsplit() [2/2]

std::vector< at::Tensor > at::Tensor::dsplit ( int64_t  sections ) const

inline

eq() [1/2]

at::Tensor at::Tensor::eq ( const at::Scalar &  other ) const

inline

eq() [2/2]

at::Tensor at::Tensor::eq ( const at::Tensor &  other ) const

inline

eq_() [1/2]

at::Tensor & at::Tensor::eq_ ( const at::Scalar &  other ) const

inline

eq_() [2/2]

at::Tensor & at::Tensor::eq_ ( const at::Tensor &  other ) const

inline

equal()

bool at::Tensor::equal ( const at::Tensor &  other ) const

inline

erf()

at::Tensor at::Tensor::erf ( ) const

inline

erf_()

at::Tensor & at::Tensor::erf_ ( ) const

inline

erfc()

at::Tensor at::Tensor::erfc ( ) const

inline

erfc_()

at::Tensor & at::Tensor::erfc_ ( ) const

inline

erfinv()

at::Tensor at::Tensor::erfinv ( ) const

inline

erfinv_()

at::Tensor & at::Tensor::erfinv_ ( ) const

inline

exp()

at::Tensor at::Tensor::exp ( ) const

inline

exp2()

at::Tensor at::Tensor::exp2 ( ) const

inline

exp2_()

at::Tensor & at::Tensor::exp2_ ( ) const

inline

exp_()

at::Tensor & at::Tensor::exp_ ( ) const

inline

expand()

at::Tensor at::Tensor::expand ( at::IntArrayRef  size, bool  implicit = false  ) const

inline

expand_as()

at::Tensor at::Tensor::expand_as ( const at::Tensor &  other ) const

inline

expand_symint()

at::Tensor at::Tensor::expand_symint ( c10::SymIntArrayRef  size, bool  implicit = false  ) const

inline

expect_contiguous() [1/2]

c10::MaybeOwned< Tensor > at::Tensor::expect_contiguous ( MemoryFormat  memory_format = MemoryFormat::Contiguous ) &&

delete

expect_contiguous() [2/2]

c10::MaybeOwned< Tensor > at::Tensor::expect_contiguous ( MemoryFormat  memory_format = MemoryFormat::Contiguous ) const &

inline

Should be used if *this can reasonably be expected to be contiguous and performance is important.

Compared to contiguous, it saves a reference count increment/decrement if *this is already contiguous, at the cost in all cases of an extra pointer of stack usage, an extra branch to access, and an extra branch at destruction time.

expm1()

at::Tensor at::Tensor::expm1 ( ) const

inline

expm1_()

at::Tensor & at::Tensor::expm1_ ( ) const

inline

exponential_()

at::Tensor & at::Tensor::exponential_ ( double  lambd = 1, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

fill_() [1/2]

at::Tensor & at::Tensor::fill_ ( const at::Scalar &  value ) const

inline

fill_() [2/2]

at::Tensor & at::Tensor::fill_ ( const at::Tensor &  value ) const

inline

fill_diagonal_()

at::Tensor & at::Tensor::fill_diagonal_ ( const at::Scalar &  fill_value, bool  wrap = false  ) const

inline

fix()

at::Tensor at::Tensor::fix ( ) const

inline

fix_()

at::Tensor & at::Tensor::fix_ ( ) const

inline

flatten() [1/4]

at::Tensor at::Tensor::flatten ( at::Dimname  start_dim, at::Dimname  end_dim, at::Dimname  out_dim  ) const

inline

flatten() [2/4]

at::Tensor at::Tensor::flatten ( at::DimnameList  dims, at::Dimname  out_dim  ) const

inline

flatten() [3/4]

at::Tensor at::Tensor::flatten ( int64_t  start_dim, int64_t  end_dim, at::Dimname  out_dim  ) const

inline

flatten() [4/4]

at::Tensor at::Tensor::flatten ( int64_t  start_dim = 0, int64_t  end_dim = -1  ) const

inline

flip()

at::Tensor at::Tensor::flip ( at::IntArrayRef  dims ) const

inline

fliplr()

at::Tensor at::Tensor::fliplr ( ) const

inline

flipud()

at::Tensor at::Tensor::flipud ( ) const

inline

float_power() [1/2]

at::Tensor at::Tensor::float_power ( const at::Scalar &  exponent ) const

inline

float_power() [2/2]

at::Tensor at::Tensor::float_power ( const at::Tensor &  exponent ) const

inline

float_power_() [1/2]

at::Tensor & at::Tensor::float_power_ ( const at::Scalar &  exponent ) const

inline

float_power_() [2/2]

at::Tensor & at::Tensor::float_power_ ( const at::Tensor &  exponent ) const

inline

floor()

at::Tensor at::Tensor::floor ( ) const

inline

floor_()

at::Tensor & at::Tensor::floor_ ( ) const

inline

floor_divide() [1/2]

at::Tensor at::Tensor::floor_divide ( const at::Scalar &  other ) const

inline

floor_divide() [2/2]

at::Tensor at::Tensor::floor_divide ( const at::Tensor &  other ) const

inline

floor_divide_() [1/2]

at::Tensor & at::Tensor::floor_divide_ ( const at::Scalar &  other ) const

inline

floor_divide_() [2/2]

at::Tensor & at::Tensor::floor_divide_ ( const at::Tensor &  other ) const

inline

fmax()

at::Tensor at::Tensor::fmax ( const at::Tensor &  other ) const

inline

fmin()

at::Tensor at::Tensor::fmin ( const at::Tensor &  other ) const

inline

fmod() [1/2]

at::Tensor at::Tensor::fmod ( const at::Scalar &  other ) const

inline

fmod() [2/2]

at::Tensor at::Tensor::fmod ( const at::Tensor &  other ) const

inline

fmod_() [1/2]

at::Tensor & at::Tensor::fmod_ ( const at::Scalar &  other ) const

inline

fmod_() [2/2]

at::Tensor & at::Tensor::fmod_ ( const at::Tensor &  other ) const

inline

frac()

at::Tensor at::Tensor::frac ( ) const

inline

frac_()

at::Tensor & at::Tensor::frac_ ( ) const

inline

frexp()

std::tuple< at::Tensor, at::Tensor > at::Tensor::frexp ( ) const

inline

gather() [1/2]

at::Tensor at::Tensor::gather ( at::Dimname  dim, const at::Tensor &  index, bool  sparse_grad = false  ) const

inline

gather() [2/2]

at::Tensor at::Tensor::gather ( int64_t  dim, const at::Tensor &  index, bool  sparse_grad = false  ) const

inline

gcd()

at::Tensor at::Tensor::gcd ( const at::Tensor &  other ) const

inline

gcd_()

at::Tensor & at::Tensor::gcd_ ( const at::Tensor &  other ) const

inline

ge() [1/2]

at::Tensor at::Tensor::ge ( const at::Scalar &  other ) const

inline

ge() [2/2]

at::Tensor at::Tensor::ge ( const at::Tensor &  other ) const

inline

ge_() [1/2]

at::Tensor & at::Tensor::ge_ ( const at::Scalar &  other ) const

inline

ge_() [2/2]

at::Tensor & at::Tensor::ge_ ( const at::Tensor &  other ) const

inline

geometric_()

at::Tensor & at::Tensor::geometric_ ( double  p, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

geqrf()

std::tuple< at::Tensor, at::Tensor > at::Tensor::geqrf ( ) const

inline

ger()

at::Tensor at::Tensor::ger ( const at::Tensor &  vec2 ) const

inline

grad()

const Tensor & at::Tensor::grad ( ) const

inline

This function returns an undefined tensor by default and returns a defined tensor the first time a call to backward() computes gradients for this Tensor.

The attribute will then contain the gradients computed and future calls to backward() will accumulate (add) gradients into it.

greater() [1/2]

at::Tensor at::Tensor::greater ( const at::Scalar &  other ) const

inline

greater() [2/2]

at::Tensor at::Tensor::greater ( const at::Tensor &  other ) const

inline

greater_() [1/2]

at::Tensor & at::Tensor::greater_ ( const at::Scalar &  other ) const

inline

greater_() [2/2]

at::Tensor & at::Tensor::greater_ ( const at::Tensor &  other ) const

inline

greater_equal() [1/2]

at::Tensor at::Tensor::greater_equal ( const at::Scalar &  other ) const

inline

greater_equal() [2/2]

at::Tensor at::Tensor::greater_equal ( const at::Tensor &  other ) const

inline

greater_equal_() [1/2]

at::Tensor & at::Tensor::greater_equal_ ( const at::Scalar &  other ) const

inline

greater_equal_() [2/2]

at::Tensor & at::Tensor::greater_equal_ ( const at::Tensor &  other ) const

inline

gt() [1/2]

at::Tensor at::Tensor::gt ( const at::Scalar &  other ) const

inline

gt() [2/2]

at::Tensor at::Tensor::gt ( const at::Tensor &  other ) const

inline

gt_() [1/2]

at::Tensor & at::Tensor::gt_ ( const at::Scalar &  other ) const

inline

gt_() [2/2]

at::Tensor & at::Tensor::gt_ ( const at::Tensor &  other ) const

inline

hardshrink()

at::Tensor at::Tensor::hardshrink ( const at::Scalar &  lambd = 0.5 ) const

inline

hardshrink_backward()

at::Tensor at::Tensor::hardshrink_backward ( const at::Tensor &  grad_out, const at::Scalar &  lambd  ) const

inline

heaviside()

at::Tensor at::Tensor::heaviside ( const at::Tensor &  values ) const

inline

heaviside_()

at::Tensor & at::Tensor::heaviside_ ( const at::Tensor &  values ) const

inline

hip()

Tensor at::Tensor::hip ( ) const

inline

histc()

at::Tensor at::Tensor::histc ( int64_t  bins = 100, const at::Scalar &  min = 0, const at::Scalar &  max = 0  ) const

inline

histogram() [1/2]

std::tuple< at::Tensor, at::Tensor > at::Tensor::histogram ( const at::Tensor &  bins, const c10::optional< at::Tensor > &  weight = {}, bool  density = false  ) const

inline

histogram() [2/2]

std::tuple< at::Tensor, at::Tensor > at::Tensor::histogram ( int64_t  bins = 100, c10::optional< at::ArrayRef< double > >  range = c10::nullopt, const c10::optional< at::Tensor > &  weight = {}, bool  density = false  ) const

inline

hsplit() [1/2]

std::vector< at::Tensor > at::Tensor::hsplit ( at::IntArrayRef  indices ) const

inline

hsplit() [2/2]

std::vector< at::Tensor > at::Tensor::hsplit ( int64_t  sections ) const

inline

hypot()

at::Tensor at::Tensor::hypot ( const at::Tensor &  other ) const

inline

hypot_()

at::Tensor & at::Tensor::hypot_ ( const at::Tensor &  other ) const

inline

i0()

at::Tensor at::Tensor::i0 ( ) const

inline

i0_()

at::Tensor & at::Tensor::i0_ ( ) const

inline

igamma()

at::Tensor at::Tensor::igamma ( const at::Tensor &  other ) const

inline

igamma_()

at::Tensor & at::Tensor::igamma_ ( const at::Tensor &  other ) const

inline

igammac()

at::Tensor at::Tensor::igammac ( const at::Tensor &  other ) const

inline

igammac_()

at::Tensor & at::Tensor::igammac_ ( const at::Tensor &  other ) const

inline

index() [1/3]

Tensor at::Tensor::index

(

ArrayRef< at::indexing::TensorIndex >

indices

)

const

index() [2/3]

at::Tensor at::Tensor::index ( const c10::List< c10::optional< at::Tensor > > &  indices ) const

inline

index() [3/3]

Tensor at::Tensor::index

(

std::initializer_list< at::indexing::TensorIndex >

indices

)

const

index_add() [1/2]

at::Tensor at::Tensor::index_add ( at::Dimname  dim, const at::Tensor &  index, const at::Tensor &  source, const at::Scalar &  alpha = 1  ) const

inline

index_add() [2/2]

at::Tensor at::Tensor::index_add ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  source, const at::Scalar &  alpha = 1  ) const

inline

index_add_()

at::Tensor & at::Tensor::index_add_ ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  source, const at::Scalar &  alpha = 1  ) const

inline

index_copy() [1/2]

at::Tensor at::Tensor::index_copy ( at::Dimname  dim, const at::Tensor &  index, const at::Tensor &  source  ) const

inline

index_copy() [2/2]

at::Tensor at::Tensor::index_copy ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  source  ) const

inline

index_copy_() [1/2]

at::Tensor & at::Tensor::index_copy_ ( at::Dimname  dim, const at::Tensor &  index, const at::Tensor &  source  ) const

inline

index_copy_() [2/2]

at::Tensor & at::Tensor::index_copy_ ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  source  ) const

inline

index_fill() [1/4]

at::Tensor at::Tensor::index_fill ( at::Dimname  dim, const at::Tensor &  index, const at::Scalar &  value  ) const

inline

index_fill() [2/4]

at::Tensor at::Tensor::index_fill ( at::Dimname  dim, const at::Tensor &  index, const at::Tensor &  value  ) const

inline

index_fill() [3/4]

at::Tensor at::Tensor::index_fill ( int64_t  dim, const at::Tensor &  index, const at::Scalar &  value  ) const

inline

index_fill() [4/4]

at::Tensor at::Tensor::index_fill ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  value  ) const

inline

index_fill_() [1/4]

at::Tensor & at::Tensor::index_fill_ ( at::Dimname  dim, const at::Tensor &  index, const at::Scalar &  value  ) const

inline

index_fill_() [2/4]

at::Tensor & at::Tensor::index_fill_ ( at::Dimname  dim, const at::Tensor &  index, const at::Tensor &  value  ) const

inline

index_fill_() [3/4]

at::Tensor & at::Tensor::index_fill_ ( int64_t  dim, const at::Tensor &  index, const at::Scalar &  value  ) const

inline

index_fill_() [4/4]

at::Tensor & at::Tensor::index_fill_ ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  value  ) const

inline

index_put()

at::Tensor at::Tensor::index_put ( const c10::List< c10::optional< at::Tensor > > &  indices, const at::Tensor &  values, bool  accumulate = false  ) const

inline

index_put_() [1/5]

Tensor & at::Tensor::index_put_	(	ArrayRef< at::indexing::TensorIndex >	indices,
		const Scalar &	v
	)

index_put_() [2/5]

Tensor & at::Tensor::index_put_	(	ArrayRef< at::indexing::TensorIndex >	indices,
		Tensor const &	rhs
	)

index_put_() [3/5]

at::Tensor & at::Tensor::index_put_ ( const c10::List< c10::optional< at::Tensor > > &  indices, const at::Tensor &  values, bool  accumulate = false  ) const

inline

index_put_() [4/5]

Tensor & at::Tensor::index_put_	(	std::initializer_list< at::indexing::TensorIndex >	indices,
		const Scalar &	v
	)

index_put_() [5/5]

Tensor & at::Tensor::index_put_	(	std::initializer_list< at::indexing::TensorIndex >	indices,
		Tensor const &	rhs
	)

index_reduce()

at::Tensor at::Tensor::index_reduce ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  source, c10::string_view  reduce, bool  include_self = true  ) const

inline

index_reduce_()

at::Tensor & at::Tensor::index_reduce_ ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  source, c10::string_view  reduce, bool  include_self = true  ) const

inline

index_select() [1/2]

at::Tensor at::Tensor::index_select ( at::Dimname  dim, const at::Tensor &  index  ) const

inline

index_select() [2/2]

at::Tensor at::Tensor::index_select ( int64_t  dim, const at::Tensor &  index  ) const

inline

indices()

at::Tensor at::Tensor::indices ( ) const

inline

inner()

at::Tensor at::Tensor::inner ( const at::Tensor &  other ) const

inline

int_repr()

at::Tensor at::Tensor::int_repr ( ) const

inline

inverse()

at::Tensor at::Tensor::inverse ( ) const

inline

is_coalesced()

bool at::Tensor::is_coalesced ( ) const

inline

is_distributed()

bool at::Tensor::is_distributed ( ) const

inline

is_nonzero()

bool at::Tensor::is_nonzero ( ) const

inline

is_pinned()

bool at::Tensor::is_pinned ( c10::optional< at::Device >  device = c10::nullopt ) const

inline

is_same_size()

bool at::Tensor::is_same_size ( const at::Tensor &  other ) const

inline

is_set_to()

bool at::Tensor::is_set_to ( const at::Tensor &  tensor ) const

inline

isclose()

at::Tensor at::Tensor::isclose ( const at::Tensor &  other, double  rtol = 1e-05, double  atol = 1e-08, bool  equal_nan = false  ) const

inline

isfinite()

at::Tensor at::Tensor::isfinite ( ) const

inline

isinf()

at::Tensor at::Tensor::isinf ( ) const

inline

isnan()

at::Tensor at::Tensor::isnan ( ) const

inline

isneginf()

at::Tensor at::Tensor::isneginf ( ) const

inline

isposinf()

at::Tensor at::Tensor::isposinf ( ) const

inline

isreal()

at::Tensor at::Tensor::isreal ( ) const

inline

istft()

at::Tensor at::Tensor::istft ( int64_t  n_fft, c10::optional< int64_t >  hop_length = c10::nullopt, c10::optional< int64_t >  win_length = c10::nullopt, const c10::optional< at::Tensor > &  window = {}, bool  center = true, bool  normalized = false, c10::optional< bool >  onesided = c10::nullopt, c10::optional< int64_t >  length = c10::nullopt, bool  return_complex = false  ) const

inline

item() [1/2]

template<typename T >

T at::Tensor::item

(

)

const

item() [2/2]

at::Scalar at::Tensor::item ( ) const

inline

kron()

at::Tensor at::Tensor::kron ( const at::Tensor &  other ) const

inline

kthvalue() [1/2]

std::tuple< at::Tensor, at::Tensor > at::Tensor::kthvalue ( int64_t  k, at::Dimname  dim, bool  keepdim = false  ) const

inline

kthvalue() [2/2]

std::tuple< at::Tensor, at::Tensor > at::Tensor::kthvalue ( int64_t  k, int64_t  dim = -1, bool  keepdim = false  ) const

inline

lcm()

at::Tensor at::Tensor::lcm ( const at::Tensor &  other ) const

inline

lcm_()

at::Tensor & at::Tensor::lcm_ ( const at::Tensor &  other ) const

inline

ldexp()

at::Tensor at::Tensor::ldexp ( const at::Tensor &  other ) const

inline

ldexp_()

at::Tensor & at::Tensor::ldexp_ ( const at::Tensor &  other ) const

inline

le() [1/2]

at::Tensor at::Tensor::le ( const at::Scalar &  other ) const

inline

le() [2/2]

at::Tensor at::Tensor::le ( const at::Tensor &  other ) const

inline

le_() [1/2]

at::Tensor & at::Tensor::le_ ( const at::Scalar &  other ) const

inline

le_() [2/2]

at::Tensor & at::Tensor::le_ ( const at::Tensor &  other ) const

inline

lerp() [1/2]

at::Tensor at::Tensor::lerp ( const at::Tensor &  end, const at::Scalar &  weight  ) const

inline

lerp() [2/2]

at::Tensor at::Tensor::lerp ( const at::Tensor &  end, const at::Tensor &  weight  ) const

inline

lerp_() [1/2]

at::Tensor & at::Tensor::lerp_ ( const at::Tensor &  end, const at::Scalar &  weight  ) const

inline

lerp_() [2/2]

at::Tensor & at::Tensor::lerp_ ( const at::Tensor &  end, const at::Tensor &  weight  ) const

inline

less() [1/2]

at::Tensor at::Tensor::less ( const at::Scalar &  other ) const

inline

less() [2/2]

at::Tensor at::Tensor::less ( const at::Tensor &  other ) const

inline

less_() [1/2]

at::Tensor & at::Tensor::less_ ( const at::Scalar &  other ) const

inline

less_() [2/2]

at::Tensor & at::Tensor::less_ ( const at::Tensor &  other ) const

inline

less_equal() [1/2]

at::Tensor at::Tensor::less_equal ( const at::Scalar &  other ) const

inline

less_equal() [2/2]

at::Tensor at::Tensor::less_equal ( const at::Tensor &  other ) const

inline

less_equal_() [1/2]

at::Tensor & at::Tensor::less_equal_ ( const at::Scalar &  other ) const

inline

less_equal_() [2/2]

at::Tensor & at::Tensor::less_equal_ ( const at::Tensor &  other ) const

inline

lgamma()

at::Tensor at::Tensor::lgamma ( ) const

inline

lgamma_()

at::Tensor & at::Tensor::lgamma_ ( ) const

inline

log()

at::Tensor at::Tensor::log ( ) const

inline

log10()

at::Tensor at::Tensor::log10 ( ) const

inline

log10_()

at::Tensor & at::Tensor::log10_ ( ) const

inline

log1p()

at::Tensor at::Tensor::log1p ( ) const

inline

log1p_()

at::Tensor & at::Tensor::log1p_ ( ) const

inline

log2()

at::Tensor at::Tensor::log2 ( ) const

inline

log2_()

at::Tensor & at::Tensor::log2_ ( ) const

inline

log_()

at::Tensor & at::Tensor::log_ ( ) const

inline

log_normal_()

at::Tensor & at::Tensor::log_normal_ ( double  mean = 1, double  std = 2, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

log_softmax() [1/2]

at::Tensor at::Tensor::log_softmax ( at::Dimname  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

log_softmax() [2/2]

at::Tensor at::Tensor::log_softmax ( int64_t  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

logaddexp()

at::Tensor at::Tensor::logaddexp ( const at::Tensor &  other ) const

inline

logaddexp2()

at::Tensor at::Tensor::logaddexp2 ( const at::Tensor &  other ) const

inline

logcumsumexp() [1/2]

at::Tensor at::Tensor::logcumsumexp ( at::Dimname  dim ) const

inline

logcumsumexp() [2/2]

at::Tensor at::Tensor::logcumsumexp ( int64_t  dim ) const

inline

logdet()

at::Tensor at::Tensor::logdet ( ) const

inline

logical_and()

at::Tensor at::Tensor::logical_and ( const at::Tensor &  other ) const

inline

logical_and_()

at::Tensor & at::Tensor::logical_and_ ( const at::Tensor &  other ) const

inline

logical_not()

at::Tensor at::Tensor::logical_not ( ) const

inline

logical_not_()

at::Tensor & at::Tensor::logical_not_ ( ) const

inline

logical_or()

at::Tensor at::Tensor::logical_or ( const at::Tensor &  other ) const

inline

logical_or_()

at::Tensor & at::Tensor::logical_or_ ( const at::Tensor &  other ) const

inline

logical_xor()

at::Tensor at::Tensor::logical_xor ( const at::Tensor &  other ) const

inline

logical_xor_()

at::Tensor & at::Tensor::logical_xor_ ( const at::Tensor &  other ) const

inline

logit()

at::Tensor at::Tensor::logit ( c10::optional< double >  eps = c10::nullopt ) const

inline

logit_()

at::Tensor & at::Tensor::logit_ ( c10::optional< double >  eps = c10::nullopt ) const

inline

logsumexp() [1/2]

at::Tensor at::Tensor::logsumexp ( at::DimnameList  dim, bool  keepdim = false  ) const

inline

logsumexp() [2/2]

at::Tensor at::Tensor::logsumexp ( at::IntArrayRef  dim, bool  keepdim = false  ) const

inline

lt() [1/2]

at::Tensor at::Tensor::lt ( const at::Scalar &  other ) const

inline

lt() [2/2]

at::Tensor at::Tensor::lt ( const at::Tensor &  other ) const

inline

lt_() [1/2]

at::Tensor & at::Tensor::lt_ ( const at::Scalar &  other ) const

inline

lt_() [2/2]

at::Tensor & at::Tensor::lt_ ( const at::Tensor &  other ) const

inline

lu_solve()

at::Tensor at::Tensor::lu_solve ( const at::Tensor &  LU_data, const at::Tensor &  LU_pivots  ) const

inline

m()

template<typename F , typename... Args>

decltype(auto) at::Tensor::m ( F  func, Args &&...  params  ) const

inline

masked_fill() [1/2]

at::Tensor at::Tensor::masked_fill ( const at::Tensor &  mask, const at::Scalar &  value  ) const

inline

masked_fill() [2/2]

at::Tensor at::Tensor::masked_fill ( const at::Tensor &  mask, const at::Tensor &  value  ) const

inline

masked_fill_() [1/2]

at::Tensor & at::Tensor::masked_fill_ ( const at::Tensor &  mask, const at::Scalar &  value  ) const

inline

masked_fill_() [2/2]

at::Tensor & at::Tensor::masked_fill_ ( const at::Tensor &  mask, const at::Tensor &  value  ) const

inline

masked_scatter()

at::Tensor at::Tensor::masked_scatter ( const at::Tensor &  mask, const at::Tensor &  source  ) const

inline

masked_scatter_()

at::Tensor & at::Tensor::masked_scatter_ ( const at::Tensor &  mask, const at::Tensor &  source  ) const

inline

masked_select()

at::Tensor at::Tensor::masked_select ( const at::Tensor &  mask ) const

inline

matmul()

at::Tensor at::Tensor::matmul ( const at::Tensor &  other ) const

inline

matrix_exp()

at::Tensor at::Tensor::matrix_exp ( ) const

inline

matrix_H()

at::Tensor at::Tensor::matrix_H ( ) const

inline

matrix_power()

at::Tensor at::Tensor::matrix_power ( int64_t  n ) const

inline

max() [1/4]

at::Tensor at::Tensor::max ( ) const

inline

max() [2/4]

std::tuple< at::Tensor, at::Tensor > at::Tensor::max ( at::Dimname  dim, bool  keepdim = false  ) const

inline

max() [3/4]

at::Tensor at::Tensor::max ( const at::Tensor &  other ) const

inline

max() [4/4]

std::tuple< at::Tensor, at::Tensor > at::Tensor::max ( int64_t  dim, bool  keepdim = false  ) const

inline

maximum()

at::Tensor at::Tensor::maximum ( const at::Tensor &  other ) const

inline

mean() [1/3]

at::Tensor at::Tensor::mean ( at::DimnameList  dim, bool  keepdim = false, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

mean() [2/3]

at::Tensor at::Tensor::mean ( at::OptionalIntArrayRef  dim, bool  keepdim = false, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

mean() [3/3]

at::Tensor at::Tensor::mean ( c10::optional< at::ScalarType >  dtype = c10::nullopt ) const

inline

median() [1/3]

at::Tensor at::Tensor::median ( ) const

inline

median() [2/3]

std::tuple< at::Tensor, at::Tensor > at::Tensor::median ( at::Dimname  dim, bool  keepdim = false  ) const

inline

median() [3/3]

std::tuple< at::Tensor, at::Tensor > at::Tensor::median ( int64_t  dim, bool  keepdim = false  ) const

inline

meta()

Tensor at::Tensor::meta ( ) const

inline

metal()

Tensor at::Tensor::metal ( ) const

inline

mH()

at::Tensor at::Tensor::mH ( ) const

inline

min() [1/4]

at::Tensor at::Tensor::min ( ) const

inline

min() [2/4]

std::tuple< at::Tensor, at::Tensor > at::Tensor::min ( at::Dimname  dim, bool  keepdim = false  ) const

inline

min() [3/4]

at::Tensor at::Tensor::min ( const at::Tensor &  other ) const

inline

min() [4/4]

std::tuple< at::Tensor, at::Tensor > at::Tensor::min ( int64_t  dim, bool  keepdim = false  ) const

inline

minimum()

at::Tensor at::Tensor::minimum ( const at::Tensor &  other ) const

inline

mm()

at::Tensor at::Tensor::mm ( const at::Tensor &  mat2 ) const

inline

mode() [1/2]

std::tuple< at::Tensor, at::Tensor > at::Tensor::mode ( at::Dimname  dim, bool  keepdim = false  ) const

inline

mode() [2/2]

std::tuple< at::Tensor, at::Tensor > at::Tensor::mode ( int64_t  dim = -1, bool  keepdim = false  ) const

inline

moveaxis() [1/2]

at::Tensor at::Tensor::moveaxis ( at::IntArrayRef  source, at::IntArrayRef  destination  ) const

inline

moveaxis() [2/2]

at::Tensor at::Tensor::moveaxis ( int64_t  source, int64_t  destination  ) const

inline

movedim() [1/2]

at::Tensor at::Tensor::movedim ( at::IntArrayRef  source, at::IntArrayRef  destination  ) const

inline

movedim() [2/2]

at::Tensor at::Tensor::movedim ( int64_t  source, int64_t  destination  ) const

inline

msort()

at::Tensor at::Tensor::msort ( ) const

inline

mT()

at::Tensor at::Tensor::mT ( ) const

inline

mul() [1/2]

at::Tensor at::Tensor::mul ( const at::Scalar &  other ) const

inline

mul() [2/2]

at::Tensor at::Tensor::mul ( const at::Tensor &  other ) const

inline

mul_() [1/2]

at::Tensor & at::Tensor::mul_ ( const at::Scalar &  other ) const

inline

mul_() [2/2]

at::Tensor & at::Tensor::mul_ ( const at::Tensor &  other ) const

inline

multinomial()

at::Tensor at::Tensor::multinomial ( int64_t  num_samples, bool  replacement = false, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

multiply() [1/2]

at::Tensor at::Tensor::multiply ( const at::Scalar &  other ) const

inline

multiply() [2/2]

at::Tensor at::Tensor::multiply ( const at::Tensor &  other ) const

inline

multiply_() [1/2]

at::Tensor & at::Tensor::multiply_ ( const at::Scalar &  other ) const

inline

multiply_() [2/2]

at::Tensor & at::Tensor::multiply_ ( const at::Tensor &  other ) const

inline

mutable_grad()

Tensor & at::Tensor::mutable_grad ( ) const

inline

Return a mutable reference to the gradient.

This is conventionally used as t.grad() = x to set a gradient to a completely new tensor. Note that this function work with a non-const Tensor and is not thread safe.

mv()

at::Tensor at::Tensor::mv ( const at::Tensor &  vec ) const

inline

mvlgamma()

at::Tensor at::Tensor::mvlgamma ( int64_t  p ) const

inline

mvlgamma_()

at::Tensor & at::Tensor::mvlgamma_ ( int64_t  p ) const

inline

nan_to_num()

at::Tensor at::Tensor::nan_to_num ( c10::optional< double >  nan = c10::nullopt, c10::optional< double >  posinf = c10::nullopt, c10::optional< double >  neginf = c10::nullopt  ) const

inline

nan_to_num_()

at::Tensor & at::Tensor::nan_to_num_ ( c10::optional< double >  nan = c10::nullopt, c10::optional< double >  posinf = c10::nullopt, c10::optional< double >  neginf = c10::nullopt  ) const

inline

nanmean()

at::Tensor at::Tensor::nanmean ( at::OptionalIntArrayRef  dim = c10::nullopt, bool  keepdim = false, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

nanmedian() [1/3]

at::Tensor at::Tensor::nanmedian ( ) const

inline

nanmedian() [2/3]

std::tuple< at::Tensor, at::Tensor > at::Tensor::nanmedian ( at::Dimname  dim, bool  keepdim = false  ) const

inline

nanmedian() [3/3]

std::tuple< at::Tensor, at::Tensor > at::Tensor::nanmedian ( int64_t  dim, bool  keepdim = false  ) const

inline

nanquantile() [1/2]

at::Tensor at::Tensor::nanquantile ( const at::Tensor &  q, c10::optional< int64_t >  dim = c10::nullopt, bool  keepdim = false, c10::string_view  interpolation = "linear"  ) const

inline

nanquantile() [2/2]

at::Tensor at::Tensor::nanquantile ( double  q, c10::optional< int64_t >  dim = c10::nullopt, bool  keepdim = false, c10::string_view  interpolation = "linear"  ) const

inline

nansum()

at::Tensor at::Tensor::nansum ( at::OptionalIntArrayRef  dim = c10::nullopt, bool  keepdim = false, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

narrow() [1/2]

at::Tensor at::Tensor::narrow ( int64_t  dim, const at::Tensor &  start, int64_t  length  ) const

inline

narrow() [2/2]

at::Tensor at::Tensor::narrow ( int64_t  dim, int64_t  start, int64_t  length  ) const

inline

narrow_copy()

at::Tensor at::Tensor::narrow_copy ( int64_t  dim, int64_t  start, int64_t  length  ) const

inline

narrow_copy_symint()

at::Tensor at::Tensor::narrow_copy_symint ( int64_t  dim, c10::SymInt  start, c10::SymInt  length  ) const

inline

narrow_symint() [1/2]

at::Tensor at::Tensor::narrow_symint ( int64_t  dim, c10::SymInt  start, c10::SymInt  length  ) const

inline

narrow_symint() [2/2]

at::Tensor at::Tensor::narrow_symint ( int64_t  dim, const at::Tensor &  start, c10::SymInt  length  ) const

inline

ne() [1/2]

at::Tensor at::Tensor::ne ( const at::Scalar &  other ) const

inline

ne() [2/2]

at::Tensor at::Tensor::ne ( const at::Tensor &  other ) const

inline

ne_() [1/2]

at::Tensor & at::Tensor::ne_ ( const at::Scalar &  other ) const

inline

ne_() [2/2]

at::Tensor & at::Tensor::ne_ ( const at::Tensor &  other ) const

inline

neg()

at::Tensor at::Tensor::neg ( ) const

inline

neg_()

at::Tensor & at::Tensor::neg_ ( ) const

inline

negative()

at::Tensor at::Tensor::negative ( ) const

inline

negative_()

at::Tensor & at::Tensor::negative_ ( ) const

inline

new_empty() [1/2]

at::Tensor at::Tensor::new_empty ( at::IntArrayRef  size, at::TensorOptions  options = {}  ) const

inline

new_empty() [2/2]

at::Tensor at::Tensor::new_empty ( at::IntArrayRef  size, c10::optional< at::ScalarType >  dtype, c10::optional< at::Layout >  layout, c10::optional< at::Device >  device, c10::optional< bool >  pin_memory  ) const

inline

new_empty_strided() [1/2]

at::Tensor at::Tensor::new_empty_strided ( at::IntArrayRef  size, at::IntArrayRef  stride, at::TensorOptions  options = {}  ) const

inline

new_empty_strided() [2/2]

at::Tensor at::Tensor::new_empty_strided ( at::IntArrayRef  size, at::IntArrayRef  stride, c10::optional< at::ScalarType >  dtype, c10::optional< at::Layout >  layout, c10::optional< at::Device >  device, c10::optional< bool >  pin_memory  ) const

inline

new_empty_strided_symint() [1/2]

at::Tensor at::Tensor::new_empty_strided_symint ( c10::SymIntArrayRef  size, c10::SymIntArrayRef  stride, at::TensorOptions  options = {}  ) const

inline

new_empty_strided_symint() [2/2]

at::Tensor at::Tensor::new_empty_strided_symint ( c10::SymIntArrayRef  size, c10::SymIntArrayRef  stride, c10::optional< at::ScalarType >  dtype, c10::optional< at::Layout >  layout, c10::optional< at::Device >  device, c10::optional< bool >  pin_memory  ) const

inline

new_empty_symint() [1/2]

at::Tensor at::Tensor::new_empty_symint ( c10::SymIntArrayRef  size, at::TensorOptions  options = {}  ) const

inline

new_empty_symint() [2/2]

at::Tensor at::Tensor::new_empty_symint ( c10::SymIntArrayRef  size, c10::optional< at::ScalarType >  dtype, c10::optional< at::Layout >  layout, c10::optional< at::Device >  device, c10::optional< bool >  pin_memory  ) const

inline

new_full() [1/2]

at::Tensor at::Tensor::new_full ( at::IntArrayRef  size, const at::Scalar &  fill_value, at::TensorOptions  options = {}  ) const

inline

new_full() [2/2]

at::Tensor at::Tensor::new_full ( at::IntArrayRef  size, const at::Scalar &  fill_value, c10::optional< at::ScalarType >  dtype, c10::optional< at::Layout >  layout, c10::optional< at::Device >  device, c10::optional< bool >  pin_memory  ) const

inline

new_full_symint() [1/2]

at::Tensor at::Tensor::new_full_symint ( c10::SymIntArrayRef  size, const at::Scalar &  fill_value, at::TensorOptions  options = {}  ) const

inline

new_full_symint() [2/2]

at::Tensor at::Tensor::new_full_symint ( c10::SymIntArrayRef  size, const at::Scalar &  fill_value, c10::optional< at::ScalarType >  dtype, c10::optional< at::Layout >  layout, c10::optional< at::Device >  device, c10::optional< bool >  pin_memory  ) const

inline

new_ones() [1/2]

at::Tensor at::Tensor::new_ones ( at::IntArrayRef  size, at::TensorOptions  options = {}  ) const

inline

new_ones() [2/2]

at::Tensor at::Tensor::new_ones ( at::IntArrayRef  size, c10::optional< at::ScalarType >  dtype, c10::optional< at::Layout >  layout, c10::optional< at::Device >  device, c10::optional< bool >  pin_memory  ) const

inline

new_ones_symint() [1/2]

at::Tensor at::Tensor::new_ones_symint ( c10::SymIntArrayRef  size, at::TensorOptions  options = {}  ) const

inline

new_ones_symint() [2/2]

at::Tensor at::Tensor::new_ones_symint ( c10::SymIntArrayRef  size, c10::optional< at::ScalarType >  dtype, c10::optional< at::Layout >  layout, c10::optional< at::Device >  device, c10::optional< bool >  pin_memory  ) const

inline

new_zeros() [1/2]

at::Tensor at::Tensor::new_zeros ( at::IntArrayRef  size, at::TensorOptions  options = {}  ) const

inline

new_zeros() [2/2]

at::Tensor at::Tensor::new_zeros ( at::IntArrayRef  size, c10::optional< at::ScalarType >  dtype, c10::optional< at::Layout >  layout, c10::optional< at::Device >  device, c10::optional< bool >  pin_memory  ) const

inline

new_zeros_symint() [1/2]

at::Tensor at::Tensor::new_zeros_symint ( c10::SymIntArrayRef  size, at::TensorOptions  options = {}  ) const

inline

new_zeros_symint() [2/2]

at::Tensor at::Tensor::new_zeros_symint ( c10::SymIntArrayRef  size, c10::optional< at::ScalarType >  dtype, c10::optional< at::Layout >  layout, c10::optional< at::Device >  device, c10::optional< bool >  pin_memory  ) const

inline

nextafter()

at::Tensor at::Tensor::nextafter ( const at::Tensor &  other ) const

inline

nextafter_()

at::Tensor & at::Tensor::nextafter_ ( const at::Tensor &  other ) const

inline

nonzero()

at::Tensor at::Tensor::nonzero ( ) const

inline

nonzero_numpy()

std::vector< at::Tensor > at::Tensor::nonzero_numpy ( ) const

inline

norm() [1/6]

at::Tensor at::Tensor::norm ( const at::Scalar &  p = 2 ) const

inline

norm() [2/6]

at::Tensor at::Tensor::norm ( const c10::optional< at::Scalar > &  p, at::DimnameList  dim, bool  keepdim, at::ScalarType  dtype  ) const

inline

norm() [3/6]

at::Tensor at::Tensor::norm ( const c10::optional< at::Scalar > &  p, at::DimnameList  dim, bool  keepdim = false  ) const

inline

norm() [4/6]

at::Tensor at::Tensor::norm ( const c10::optional< at::Scalar > &  p, at::IntArrayRef  dim, bool  keepdim, at::ScalarType  dtype  ) const

inline

norm() [5/6]

at::Tensor at::Tensor::norm ( const c10::optional< at::Scalar > &  p, at::IntArrayRef  dim, bool  keepdim = false  ) const

inline

norm() [6/6]

at::Tensor at::Tensor::norm ( const c10::optional< at::Scalar > &  p, at::ScalarType  dtype  ) const

inline

normal_()

at::Tensor & at::Tensor::normal_ ( double  mean = 0, double  std = 1, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

not_equal() [1/2]

at::Tensor at::Tensor::not_equal ( const at::Scalar &  other ) const

inline

not_equal() [2/2]

at::Tensor at::Tensor::not_equal ( const at::Tensor &  other ) const

inline

not_equal_() [1/2]

at::Tensor & at::Tensor::not_equal_ ( const at::Scalar &  other ) const

inline

not_equal_() [2/2]

at::Tensor & at::Tensor::not_equal_ ( const at::Tensor &  other ) const

inline

numpy_T()

at::Tensor at::Tensor::numpy_T ( ) const

inline

operator&=()

Tensor & at::Tensor::operator&= ( const Tensor &  other )

inline

operator*=() [1/2]

Tensor & at::Tensor::operator*= ( const Scalar &  other )

inline

operator*=() [2/2]

Tensor & at::Tensor::operator*= ( const Tensor &  other )

inline

operator+=() [1/2]

Tensor & at::Tensor::operator+= ( const Scalar &  other )

inline

operator+=() [2/2]

Tensor & at::Tensor::operator+= ( const Tensor &  other )

inline

operator-()

Tensor at::Tensor::operator- ( ) const

inline

operator-=() [1/2]

Tensor & at::Tensor::operator-= ( const Scalar &  other )

inline

operator-=() [2/2]

Tensor & at::Tensor::operator-= ( const Tensor &  other )

inline

operator/=() [1/2]

Tensor & at::Tensor::operator/= ( const Scalar &  other )

inline

operator/=() [2/2]

Tensor & at::Tensor::operator/= ( const Tensor &  other )

inline

operator=() [1/7]

Tensor & at::Tensor::operator= ( const Scalar &  v ) &&

inline

operator=() [2/7]

Tensor & at::Tensor::operator= ( const Tensor &  rhs ) &&

inline

operator=() [3/7]

Tensor & at::Tensor::operator= ( const Tensor &  x ) &

inline

operator=() [4/7]

Tensor & at::Tensor::operator= ( const TensorBase &  x ) &

inline

operator=() [5/7]

Tensor & at::Tensor::operator= ( Tensor &&  rhs ) &&

inline

operator=() [6/7]

Tensor & at::Tensor::operator= ( Tensor &&  x ) &

inlinenoexcept

operator=() [7/7]

Tensor & at::Tensor::operator= ( TensorBase &&  x ) &

inlinenoexcept

operator[]() [1/3]

Tensor at::Tensor::operator[] ( const Scalar &  index ) const

inline

operator[]() [2/3]

Tensor at::Tensor::operator[] ( const Tensor &  index ) const

inline

operator[]() [3/3]

Tensor at::Tensor::operator[] ( int64_t  index ) const

inline

operator^=()

Tensor & at::Tensor::operator^= ( const Tensor &  other )

inline

operator|=()

Tensor & at::Tensor::operator|= ( const Tensor &  other )

inline

operator~()

Tensor at::Tensor::operator~ ( ) const

inline

orgqr()

at::Tensor at::Tensor::orgqr ( const at::Tensor &  input2 ) const

inline

ormqr()

at::Tensor at::Tensor::ormqr ( const at::Tensor &  input2, const at::Tensor &  input3, bool  left = true, bool  transpose = false  ) const

inline

outer()

at::Tensor at::Tensor::outer ( const at::Tensor &  vec2 ) const

inline

packed_accessor() [1/2]

index_t at::Tensor::packed_accessor ( ) &&

delete

packed_accessor() [2/2]

index_t at::Tensor::packed_accessor ( ) const &

inline

permute()

at::Tensor at::Tensor::permute ( at::IntArrayRef  dims ) const

inline

pin_memory()

at::Tensor at::Tensor::pin_memory ( c10::optional< at::Device >  device = c10::nullopt ) const

inline

pinverse()

at::Tensor at::Tensor::pinverse ( double  rcond = 1e-15 ) const

inline

polygamma()

at::Tensor at::Tensor::polygamma ( int64_t  n ) const

inline

polygamma_()

at::Tensor & at::Tensor::polygamma_ ( int64_t  n ) const

inline

positive()

at::Tensor at::Tensor::positive ( ) const

inline

pow() [1/2]

at::Tensor at::Tensor::pow ( const at::Scalar &  exponent ) const

inline

pow() [2/2]

at::Tensor at::Tensor::pow ( const at::Tensor &  exponent ) const

inline

pow_() [1/2]

at::Tensor & at::Tensor::pow_ ( const at::Scalar &  exponent ) const

inline

pow_() [2/2]

at::Tensor & at::Tensor::pow_ ( const at::Tensor &  exponent ) const

inline

prelu()

at::Tensor at::Tensor::prelu ( const at::Tensor &  weight ) const

inline

prod() [1/3]

at::Tensor at::Tensor::prod ( at::Dimname  dim, bool  keepdim = false, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

prod() [2/3]

at::Tensor at::Tensor::prod ( c10::optional< at::ScalarType >  dtype = c10::nullopt ) const

inline

prod() [3/3]

at::Tensor at::Tensor::prod ( int64_t  dim, bool  keepdim = false, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

put()

at::Tensor at::Tensor::put ( const at::Tensor &  index, const at::Tensor &  source, bool  accumulate = false  ) const

inline

put_()

at::Tensor & at::Tensor::put_ ( const at::Tensor &  index, const at::Tensor &  source, bool  accumulate = false  ) const

inline

q_per_channel_axis()

int64_t at::Tensor::q_per_channel_axis ( ) const

inline

q_per_channel_scales()

at::Tensor at::Tensor::q_per_channel_scales ( ) const

inline

q_per_channel_zero_points()

at::Tensor at::Tensor::q_per_channel_zero_points ( ) const

inline

q_scale()

double at::Tensor::q_scale ( ) const

inline

q_zero_point()

int64_t at::Tensor::q_zero_point ( ) const

inline

qr()

std::tuple< at::Tensor, at::Tensor > at::Tensor::qr ( bool  some = true ) const

inline

qscheme()

at::QScheme at::Tensor::qscheme ( ) const

inline

quantile() [1/2]

at::Tensor at::Tensor::quantile ( const at::Tensor &  q, c10::optional< int64_t >  dim = c10::nullopt, bool  keepdim = false, c10::string_view  interpolation = "linear"  ) const

inline

quantile() [2/2]

at::Tensor at::Tensor::quantile ( double  q, c10::optional< int64_t >  dim = c10::nullopt, bool  keepdim = false, c10::string_view  interpolation = "linear"  ) const

inline

rad2deg()

at::Tensor at::Tensor::rad2deg ( ) const

inline

rad2deg_()

at::Tensor & at::Tensor::rad2deg_ ( ) const

inline

random_() [1/3]

at::Tensor & at::Tensor::random_ ( c10::optional< at::Generator >  generator = c10::nullopt ) const

inline

random_() [2/3]

at::Tensor & at::Tensor::random_ ( int64_t  from, c10::optional< int64_t >  to, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

random_() [3/3]

at::Tensor & at::Tensor::random_ ( int64_t  to, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

ravel()

at::Tensor at::Tensor::ravel ( ) const

inline

reciprocal()

at::Tensor at::Tensor::reciprocal ( ) const

inline

reciprocal_()

at::Tensor & at::Tensor::reciprocal_ ( ) const

inline

record_stream()

void at::Tensor::record_stream ( at::Stream  s ) const

inline

refine_names()

at::Tensor at::Tensor::refine_names ( at::DimnameList  names ) const

inline

register_hook() [1/3]

template<typename T >

hook_return_void_t< T > at::Tensor::register_hook

(

T &&

hook

)

const

Registers a backward hook.

The hook will be called every time a gradient with respect to the Tensor is computed. The hook should have one of the following signature:

hook(Tensor grad) -> Tensor

hook(Tensor grad) -> void

The hook should not modify its argument, but it can optionally return a new gradient which will be used in place of grad.

This function returns the index of the hook in the list which can be used to remove hook.

Example:

auto v = torch::tensor({0., 0., 0.}, torch::requires_grad());
auto h = v.register_hook([](torch::Tensor grad){ return grad * 2; }); // double the gradient
v.backward(torch::tensor({1., 2., 3.}));
// This prints:
// ```
//  2
//  4
//  6
// [ CPUFloatType{3} ]
// ```
std::cout << v.grad() << std::endl;
v.remove_hook(h);  // removes the hook

register_hook() [2/3]

template<typename T >

hook_return_var_t< T > at::Tensor::register_hook

(

T &&

hook

)

const

register_hook() [3/3]

template<typename T >

auto at::Tensor::register_hook

(

T &&

hook

)

const -> Tensor::hook_return_void_t<T>

relu()

at::Tensor at::Tensor::relu ( ) const

inline

relu_()

at::Tensor & at::Tensor::relu_ ( ) const

inline

remainder() [1/2]

at::Tensor at::Tensor::remainder ( const at::Scalar &  other ) const

inline

remainder() [2/2]

at::Tensor at::Tensor::remainder ( const at::Tensor &  other ) const

inline

remainder_() [1/2]

at::Tensor & at::Tensor::remainder_ ( const at::Scalar &  other ) const

inline

remainder_() [2/2]

at::Tensor & at::Tensor::remainder_ ( const at::Tensor &  other ) const

inline

rename()

at::Tensor at::Tensor::rename ( c10::optional< at::DimnameList >  names ) const

inline

rename_()

at::Tensor & at::Tensor::rename_ ( c10::optional< at::DimnameList >  names ) const

inline

renorm()

at::Tensor at::Tensor::renorm ( const at::Scalar &  p, int64_t  dim, const at::Scalar &  maxnorm  ) const

inline

renorm_()

at::Tensor & at::Tensor::renorm_ ( const at::Scalar &  p, int64_t  dim, const at::Scalar &  maxnorm  ) const

inline

repeat()

at::Tensor at::Tensor::repeat ( at::IntArrayRef  repeats ) const

inline

repeat_interleave() [1/2]

at::Tensor at::Tensor::repeat_interleave ( const at::Tensor &  repeats, c10::optional< int64_t >  dim = c10::nullopt, c10::optional< int64_t >  output_size = c10::nullopt  ) const

inline

repeat_interleave() [2/2]

at::Tensor at::Tensor::repeat_interleave ( int64_t  repeats, c10::optional< int64_t >  dim = c10::nullopt, c10::optional< int64_t >  output_size = c10::nullopt  ) const

inline

repeat_interleave_symint()

at::Tensor at::Tensor::repeat_interleave_symint ( c10::SymInt  repeats, c10::optional< int64_t >  dim = c10::nullopt, c10::optional< int64_t >  output_size = c10::nullopt  ) const

inline

repeat_symint()

at::Tensor at::Tensor::repeat_symint ( c10::SymIntArrayRef  repeats ) const

inline

requires_grad_()

const Tensor & at::Tensor::requires_grad_ ( bool  _requires_grad = true ) const

inline

reshape()

at::Tensor at::Tensor::reshape ( at::IntArrayRef  shape ) const

inline

reshape_as()

at::Tensor at::Tensor::reshape_as ( const at::Tensor &  other ) const

inline

reshape_symint()

at::Tensor at::Tensor::reshape_symint ( c10::SymIntArrayRef  shape ) const

inline

resize_()

const at::Tensor & at::Tensor::resize_ ( at::IntArrayRef  size, c10::optional< at::MemoryFormat >  memory_format = c10::nullopt  ) const

inline

resize__symint()

const at::Tensor & at::Tensor::resize__symint ( c10::SymIntArrayRef  size, c10::optional< at::MemoryFormat >  memory_format = c10::nullopt  ) const

inline

resize_as_()

const at::Tensor & at::Tensor::resize_as_ ( const at::Tensor &  the_template, c10::optional< at::MemoryFormat >  memory_format = c10::nullopt  ) const

inline

resize_as_sparse_()

const at::Tensor & at::Tensor::resize_as_sparse_ ( const at::Tensor &  the_template ) const

inline

resolve_conj()

at::Tensor at::Tensor::resolve_conj ( ) const

inline

resolve_neg()

at::Tensor at::Tensor::resolve_neg ( ) const

inline

roll()

at::Tensor at::Tensor::roll ( at::IntArrayRef  shifts, at::IntArrayRef  dims = {}  ) const

inline

rot90()

at::Tensor at::Tensor::rot90 ( int64_t  k = 1, at::IntArrayRef  dims = {0,1}  ) const

inline

round() [1/2]

at::Tensor at::Tensor::round ( ) const

inline

round() [2/2]

at::Tensor at::Tensor::round ( int64_t  decimals ) const

inline

round_() [1/2]

at::Tensor & at::Tensor::round_ ( ) const

inline

round_() [2/2]

at::Tensor & at::Tensor::round_ ( int64_t  decimals ) const

inline

row_indices()

at::Tensor at::Tensor::row_indices ( ) const

inline

rsqrt()

at::Tensor at::Tensor::rsqrt ( ) const

inline

rsqrt_()

at::Tensor & at::Tensor::rsqrt_ ( ) const

inline

scatter() [1/6]

at::Tensor at::Tensor::scatter ( at::Dimname  dim, const at::Tensor &  index, const at::Scalar &  value  ) const

inline

scatter() [2/6]

at::Tensor at::Tensor::scatter ( at::Dimname  dim, const at::Tensor &  index, const at::Tensor &  src  ) const

inline

scatter() [3/6]

at::Tensor at::Tensor::scatter ( int64_t  dim, const at::Tensor &  index, const at::Scalar &  value  ) const

inline

scatter() [4/6]

at::Tensor at::Tensor::scatter ( int64_t  dim, const at::Tensor &  index, const at::Scalar &  value, c10::string_view  reduce  ) const

inline

scatter() [5/6]

at::Tensor at::Tensor::scatter ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  src  ) const

inline

scatter() [6/6]

at::Tensor at::Tensor::scatter ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  src, c10::string_view  reduce  ) const

inline

scatter_() [1/4]

at::Tensor & at::Tensor::scatter_ ( int64_t  dim, const at::Tensor &  index, const at::Scalar &  value  ) const

inline

scatter_() [2/4]

at::Tensor & at::Tensor::scatter_ ( int64_t  dim, const at::Tensor &  index, const at::Scalar &  value, c10::string_view  reduce  ) const

inline

scatter_() [3/4]

at::Tensor & at::Tensor::scatter_ ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  src  ) const

inline

scatter_() [4/4]

at::Tensor & at::Tensor::scatter_ ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  src, c10::string_view  reduce  ) const

inline

scatter_add() [1/2]

at::Tensor at::Tensor::scatter_add ( at::Dimname  dim, const at::Tensor &  index, const at::Tensor &  src  ) const

inline

scatter_add() [2/2]

at::Tensor at::Tensor::scatter_add ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  src  ) const

inline

scatter_add_()

at::Tensor & at::Tensor::scatter_add_ ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  src  ) const

inline

scatter_reduce()

at::Tensor at::Tensor::scatter_reduce ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  src, c10::string_view  reduce, bool  include_self = true  ) const

inline

scatter_reduce_()

at::Tensor & at::Tensor::scatter_reduce_ ( int64_t  dim, const at::Tensor &  index, const at::Tensor &  src, c10::string_view  reduce, bool  include_self = true  ) const

inline

select() [1/2]

at::Tensor at::Tensor::select ( at::Dimname  dim, int64_t  index  ) const

inline

select() [2/2]

at::Tensor at::Tensor::select ( int64_t  dim, int64_t  index  ) const

inline

select_scatter()

at::Tensor at::Tensor::select_scatter ( const at::Tensor &  src, int64_t  dim, int64_t  index  ) const

inline

select_scatter_symint()

at::Tensor at::Tensor::select_scatter_symint ( const at::Tensor &  src, int64_t  dim, c10::SymInt  index  ) const

inline

select_symint()

at::Tensor at::Tensor::select_symint ( int64_t  dim, c10::SymInt  index  ) const

inline

set_() [1/5]

at::Tensor & at::Tensor::set_ ( ) const

inline

set_() [2/5]

at::Tensor & at::Tensor::set_ ( at::Storage  source ) const

inline

set_() [3/5]

at::Tensor & at::Tensor::set_ ( at::Storage  source, int64_t  storage_offset, at::IntArrayRef  size, at::IntArrayRef  stride = {}  ) const

inline

set_() [4/5]

at::Tensor & at::Tensor::set_ ( const at::Tensor &  source ) const

inline

set_() [5/5]

at::Tensor & at::Tensor::set_ ( const at::Tensor &  source, int64_t  storage_offset, at::IntArrayRef  size, at::IntArrayRef  stride = {}  ) const

inline

set__symint() [1/2]

at::Tensor & at::Tensor::set__symint ( at::Storage  source, c10::SymInt  storage_offset, c10::SymIntArrayRef  size, c10::SymIntArrayRef  stride = {}  ) const

inline

set__symint() [2/2]

at::Tensor & at::Tensor::set__symint ( const at::Tensor &  source, c10::SymInt  storage_offset, c10::SymIntArrayRef  size, c10::SymIntArrayRef  stride = {}  ) const

inline

set_requires_grad()

const Tensor & at::Tensor::set_requires_grad ( bool  requires_grad ) const

inline

sgn()

at::Tensor at::Tensor::sgn ( ) const

inline

sgn_()

at::Tensor & at::Tensor::sgn_ ( ) const

inline

sigmoid()

at::Tensor at::Tensor::sigmoid ( ) const

inline

sigmoid_()

at::Tensor & at::Tensor::sigmoid_ ( ) const

inline

sign()

at::Tensor at::Tensor::sign ( ) const

inline

sign_()

at::Tensor & at::Tensor::sign_ ( ) const

inline

signbit()

at::Tensor at::Tensor::signbit ( ) const

inline

sin()

at::Tensor at::Tensor::sin ( ) const

inline

sin_()

at::Tensor & at::Tensor::sin_ ( ) const

inline

sinc()

at::Tensor at::Tensor::sinc ( ) const

inline

sinc_()

at::Tensor & at::Tensor::sinc_ ( ) const

inline

sinh()

at::Tensor at::Tensor::sinh ( ) const

inline

sinh_()

at::Tensor & at::Tensor::sinh_ ( ) const

inline

size() [1/2]

int64_t at::Tensor::size ( at::Dimname  dim ) const

inline

size() [2/2]

int64_t at::TensorBase::size ( int64_t  dim ) const

inline

slice()

at::Tensor at::Tensor::slice ( int64_t  dim = 0, c10::optional< int64_t >  start = c10::nullopt, c10::optional< int64_t >  end = c10::nullopt, int64_t  step = 1  ) const

inline

slice_scatter()

at::Tensor at::Tensor::slice_scatter ( const at::Tensor &  src, int64_t  dim = 0, c10::optional< int64_t >  start = c10::nullopt, c10::optional< int64_t >  end = c10::nullopt, int64_t  step = 1  ) const

inline

slice_scatter_symint()

at::Tensor at::Tensor::slice_scatter_symint ( const at::Tensor &  src, int64_t  dim = 0, c10::optional< c10::SymInt >  start = c10::nullopt, c10::optional< c10::SymInt >  end = c10::nullopt, c10::SymInt  step = 1  ) const

inline

slice_symint()

at::Tensor at::Tensor::slice_symint ( int64_t  dim = 0, c10::optional< c10::SymInt >  start = c10::nullopt, c10::optional< c10::SymInt >  end = c10::nullopt, c10::SymInt  step = 1  ) const

inline

slogdet()

std::tuple< at::Tensor, at::Tensor > at::Tensor::slogdet ( ) const

inline

smm()

at::Tensor at::Tensor::smm ( const at::Tensor &  mat2 ) const

inline

softmax() [1/2]

at::Tensor at::Tensor::softmax ( at::Dimname  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

softmax() [2/2]

at::Tensor at::Tensor::softmax ( int64_t  dim, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

sort() [1/4]

std::tuple< at::Tensor, at::Tensor > at::Tensor::sort ( at::Dimname  dim, bool  descending = false  ) const

inline

sort() [2/4]

std::tuple< at::Tensor, at::Tensor > at::Tensor::sort ( c10::optional< bool >  stable, at::Dimname  dim, bool  descending = false  ) const

inline

sort() [3/4]

std::tuple< at::Tensor, at::Tensor > at::Tensor::sort ( c10::optional< bool >  stable, int64_t  dim = -1, bool  descending = false  ) const

inline

sort() [4/4]

std::tuple< at::Tensor, at::Tensor > at::Tensor::sort ( int64_t  dim = -1, bool  descending = false  ) const

inline

sparse_dim()

int64_t at::Tensor::sparse_dim ( ) const

inline

sparse_mask()

at::Tensor at::Tensor::sparse_mask ( const at::Tensor &  mask ) const

inline

sparse_resize_()

const at::Tensor & at::Tensor::sparse_resize_ ( at::IntArrayRef  size, int64_t  sparse_dim, int64_t  dense_dim  ) const

inline

sparse_resize_and_clear_()

const at::Tensor & at::Tensor::sparse_resize_and_clear_ ( at::IntArrayRef  size, int64_t  sparse_dim, int64_t  dense_dim  ) const

inline

split() [1/2]

std::vector< at::Tensor > at::Tensor::split ( at::IntArrayRef  split_size, int64_t  dim = 0  ) const

inline

split() [2/2]

std::vector< at::Tensor > at::Tensor::split ( int64_t  split_size, int64_t  dim = 0  ) const

inline

split_symint() [1/2]

std::vector< at::Tensor > at::Tensor::split_symint ( c10::SymInt  split_size, int64_t  dim = 0  ) const

inline

split_symint() [2/2]

std::vector< at::Tensor > at::Tensor::split_symint ( c10::SymIntArrayRef  split_size, int64_t  dim = 0  ) const

inline

split_with_sizes()

std::vector< at::Tensor > at::Tensor::split_with_sizes ( at::IntArrayRef  split_sizes, int64_t  dim = 0  ) const

inline

split_with_sizes_symint()

std::vector< at::Tensor > at::Tensor::split_with_sizes_symint ( c10::SymIntArrayRef  split_sizes, int64_t  dim = 0  ) const

inline

sqrt()

at::Tensor at::Tensor::sqrt ( ) const

inline

sqrt_()

at::Tensor & at::Tensor::sqrt_ ( ) const

inline

square()

at::Tensor at::Tensor::square ( ) const

inline

square_()

at::Tensor & at::Tensor::square_ ( ) const

inline

squeeze() [1/4]

at::Tensor at::Tensor::squeeze ( ) const

inline

squeeze() [2/4]

at::Tensor at::Tensor::squeeze ( at::Dimname  dim ) const

inline

squeeze() [3/4]

at::Tensor at::Tensor::squeeze ( at::IntArrayRef  dim ) const

inline

squeeze() [4/4]

at::Tensor at::Tensor::squeeze ( int64_t  dim ) const

inline

squeeze_() [1/4]

at::Tensor & at::Tensor::squeeze_ ( ) const

inline

squeeze_() [2/4]

at::Tensor & at::Tensor::squeeze_ ( at::Dimname  dim ) const

inline

squeeze_() [3/4]

at::Tensor & at::Tensor::squeeze_ ( at::IntArrayRef  dim ) const

inline

squeeze_() [4/4]

at::Tensor & at::Tensor::squeeze_ ( int64_t  dim ) const

inline

sspaddmm()

at::Tensor at::Tensor::sspaddmm ( const at::Tensor &  mat1, const at::Tensor &  mat2, const at::Scalar &  beta = 1, const at::Scalar &  alpha = 1  ) const

inline

std() [1/6]

at::Tensor at::Tensor::std ( at::DimnameList  dim, bool  unbiased, bool  keepdim = false  ) const

inline

std() [2/6]

at::Tensor at::Tensor::std ( at::DimnameList  dim, c10::optional< int64_t >  correction = c10::nullopt, bool  keepdim = false  ) const

inline

std() [3/6]

at::Tensor at::Tensor::std ( at::OptionalIntArrayRef  dim, bool  unbiased, bool  keepdim = false  ) const

inline

std() [4/6]

at::Tensor at::Tensor::std ( at::OptionalIntArrayRef  dim = c10::nullopt, c10::optional< int64_t >  correction = c10::nullopt, bool  keepdim = false  ) const

inline

std() [5/6]

at::Tensor at::Tensor::std ( bool  unbiased ) const

inline

std() [6/6]

Tensor at::Tensor::std ( int  dim ) const

inline

stft() [1/2]

at::Tensor at::Tensor::stft ( int64_t  n_fft, c10::optional< int64_t >  hop_length, c10::optional< int64_t >  win_length, const c10::optional< at::Tensor > &  window, bool  normalized, c10::optional< bool >  onesided = c10::nullopt, c10::optional< bool >  return_complex = c10::nullopt  ) const

inline

stft() [2/2]

at::Tensor at::Tensor::stft ( int64_t  n_fft, c10::optional< int64_t >  hop_length = c10::nullopt, c10::optional< int64_t >  win_length = c10::nullopt, const c10::optional< at::Tensor > &  window = {}, bool  center = true, c10::string_view  pad_mode = "reflect", bool  normalized = false, c10::optional< bool >  onesided = c10::nullopt, c10::optional< bool >  return_complex = c10::nullopt  ) const

inline

stride() [1/2]

int64_t at::Tensor::stride ( at::Dimname  dim ) const

inline

stride() [2/2]

int64_t at::TensorBase::stride ( int64_t  dim ) const

inline

sub() [1/2]

at::Tensor at::Tensor::sub ( const at::Scalar &  other, const at::Scalar &  alpha = 1  ) const

inline

sub() [2/2]

at::Tensor at::Tensor::sub ( const at::Tensor &  other, const at::Scalar &  alpha = 1  ) const

inline

sub_() [1/2]

at::Tensor & at::Tensor::sub_ ( const at::Scalar &  other, const at::Scalar &  alpha = 1  ) const

inline

sub_() [2/2]

at::Tensor & at::Tensor::sub_ ( const at::Tensor &  other, const at::Scalar &  alpha = 1  ) const

inline

subtract() [1/2]

at::Tensor at::Tensor::subtract ( const at::Scalar &  other, const at::Scalar &  alpha = 1  ) const

inline

subtract() [2/2]

at::Tensor at::Tensor::subtract ( const at::Tensor &  other, const at::Scalar &  alpha = 1  ) const

inline

subtract_() [1/2]

at::Tensor & at::Tensor::subtract_ ( const at::Scalar &  other, const at::Scalar &  alpha = 1  ) const

inline

subtract_() [2/2]

at::Tensor & at::Tensor::subtract_ ( const at::Tensor &  other, const at::Scalar &  alpha = 1  ) const

inline

sum() [1/3]

at::Tensor at::Tensor::sum ( at::DimnameList  dim, bool  keepdim = false, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

sum() [2/3]

at::Tensor at::Tensor::sum ( at::OptionalIntArrayRef  dim, bool  keepdim = false, c10::optional< at::ScalarType >  dtype = c10::nullopt  ) const

inline

sum() [3/3]

at::Tensor at::Tensor::sum ( c10::optional< at::ScalarType >  dtype = c10::nullopt ) const

inline

sum_to_size()

at::Tensor at::Tensor::sum_to_size ( at::IntArrayRef  size ) const

inline

svd()

std::tuple< at::Tensor, at::Tensor, at::Tensor > at::Tensor::svd ( bool  some = true, bool  compute_uv = true  ) const

inline

swapaxes()

at::Tensor at::Tensor::swapaxes ( int64_t  axis0, int64_t  axis1  ) const

inline

swapaxes_()

at::Tensor & at::Tensor::swapaxes_ ( int64_t  axis0, int64_t  axis1  ) const

inline

swapdims()

at::Tensor at::Tensor::swapdims ( int64_t  dim0, int64_t  dim1  ) const

inline

swapdims_()

at::Tensor & at::Tensor::swapdims_ ( int64_t  dim0, int64_t  dim1  ) const

inline

sym_size()

c10::SymInt at::TensorBase::sym_size ( int64_t  dim ) const

inline

t()

at::Tensor at::Tensor::t ( ) const

inline

t_()

at::Tensor & at::Tensor::t_ ( ) const

inline

take()

at::Tensor at::Tensor::take ( const at::Tensor &  index ) const

inline

take_along_dim()

at::Tensor at::Tensor::take_along_dim ( const at::Tensor &  indices, c10::optional< int64_t >  dim = c10::nullopt  ) const

inline

tan()

at::Tensor at::Tensor::tan ( ) const

inline

tan_()

at::Tensor & at::Tensor::tan_ ( ) const

inline

tanh()

at::Tensor at::Tensor::tanh ( ) const

inline

tanh_()

at::Tensor & at::Tensor::tanh_ ( ) const

inline

tensor_data()

at::Tensor at::Tensor::tensor_data ( ) const

inline

NOTE: This is similar to the legacy .data() function on Variable, and is intended to be used from functions that need to access the Variable's equivalent Tensor (i.e.

Tensor that shares the same storage and tensor metadata with the Variable).

One notable difference with the legacy .data() function is that changes to the returned Tensor's tensor metadata (e.g. sizes / strides / storage / storage_offset) will not update the original Variable, due to the fact that this function shallow-copies the Variable's underlying TensorImpl.

tensor_split() [1/3]

std::vector< at::Tensor > at::Tensor::tensor_split ( at::IntArrayRef  indices, int64_t  dim = 0  ) const

inline

tensor_split() [2/3]

std::vector< at::Tensor > at::Tensor::tensor_split ( const at::Tensor &  tensor_indices_or_sections, int64_t  dim = 0  ) const

inline

tensor_split() [3/3]

std::vector< at::Tensor > at::Tensor::tensor_split ( int64_t  sections, int64_t  dim = 0  ) const

inline

tensor_split_symint() [1/2]

std::vector< at::Tensor > at::Tensor::tensor_split_symint ( c10::SymInt  sections, int64_t  dim = 0  ) const

inline

tensor_split_symint() [2/2]

std::vector< at::Tensor > at::Tensor::tensor_split_symint ( c10::SymIntArrayRef  indices, int64_t  dim = 0  ) const

inline

tile()

at::Tensor at::Tensor::tile ( at::IntArrayRef  dims ) const

inline

to() [1/7]

at::Tensor at::Tensor::to ( at::Device  device, at::ScalarType  dtype, bool  non_blocking = false, bool  copy = false, c10::optional< at::MemoryFormat >  memory_format = c10::nullopt  ) const

inline

to() [2/7]

at::Tensor at::Tensor::to ( at::ScalarType  dtype, bool  non_blocking = false, bool  copy = false, c10::optional< at::MemoryFormat >  memory_format = c10::nullopt  ) const

inline

to() [3/7]

at::Tensor at::Tensor::to ( at::TensorOptions  options = {}, bool  non_blocking = false, bool  copy = false, c10::optional< at::MemoryFormat >  memory_format = c10::nullopt  ) const

inline

to() [4/7]

at::Tensor at::Tensor::to ( c10::optional< at::ScalarType >  dtype, c10::optional< at::Layout >  layout, c10::optional< at::Device >  device, c10::optional< bool >  pin_memory, bool  non_blocking, bool  copy, c10::optional< at::MemoryFormat >  memory_format  ) const

inline

to() [5/7]

Tensor at::Tensor::to ( caffe2::TypeMeta  type_meta, bool  non_blocking = false, bool  copy = false  ) const

inline

to() [6/7]

at::Tensor at::Tensor::to ( const at::Tensor &  other, bool  non_blocking = false, bool  copy = false, c10::optional< at::MemoryFormat >  memory_format = c10::nullopt  ) const

inline

to() [7/7]

Tensor at::Tensor::to ( Device  device, caffe2::TypeMeta  type_meta, bool  non_blocking = false, bool  copy = false  ) const

inline

to_dense()

at::Tensor at::Tensor::to_dense ( c10::optional< at::ScalarType >  dtype = c10::nullopt ) const

inline

to_mkldnn()

at::Tensor at::Tensor::to_mkldnn ( c10::optional< at::ScalarType >  dtype = c10::nullopt ) const

inline

to_padded_tensor()

at::Tensor at::Tensor::to_padded_tensor ( double  padding, at::OptionalIntArrayRef  output_size = c10::nullopt  ) const

inline

to_padded_tensor_symint()

at::Tensor at::Tensor::to_padded_tensor_symint ( double  padding, at::OptionalSymIntArrayRef  output_size = c10::nullopt  ) const

inline

to_sparse() [1/2]

at::Tensor at::Tensor::to_sparse ( c10::optional< at::Layout >  layout = c10::nullopt, at::OptionalIntArrayRef  blocksize = c10::nullopt, c10::optional< int64_t >  dense_dim = c10::nullopt  ) const

inline

to_sparse() [2/2]

at::Tensor at::Tensor::to_sparse ( int64_t  sparse_dim ) const

inline

to_sparse_bsc()

at::Tensor at::Tensor::to_sparse_bsc ( at::IntArrayRef  blocksize, c10::optional< int64_t >  dense_dim = c10::nullopt  ) const

inline

to_sparse_bsr()

at::Tensor at::Tensor::to_sparse_bsr ( at::IntArrayRef  blocksize, c10::optional< int64_t >  dense_dim = c10::nullopt  ) const

inline

to_sparse_csc()

at::Tensor at::Tensor::to_sparse_csc ( c10::optional< int64_t >  dense_dim = c10::nullopt ) const

inline

to_sparse_csr()

at::Tensor at::Tensor::to_sparse_csr ( c10::optional< int64_t >  dense_dim = c10::nullopt ) const

inline

toBackend()

Tensor at::Tensor::toBackend ( Backend  b ) const

inline

topk()

std::tuple< at::Tensor, at::Tensor > at::Tensor::topk ( int64_t  k, int64_t  dim = -1, bool  largest = true, bool  sorted = true  ) const

inline

toType()

Tensor at::Tensor::toType ( ScalarType  t ) const

inline

trace()

at::Tensor at::Tensor::trace ( ) const

inline

transpose() [1/2]

at::Tensor at::Tensor::transpose ( at::Dimname  dim0, at::Dimname  dim1  ) const

inline

transpose() [2/2]

at::Tensor at::Tensor::transpose ( int64_t  dim0, int64_t  dim1  ) const

inline

transpose_()

at::Tensor & at::Tensor::transpose_ ( int64_t  dim0, int64_t  dim1  ) const

inline

triangular_solve()

std::tuple< at::Tensor, at::Tensor > at::Tensor::triangular_solve ( const at::Tensor &  A, bool  upper = true, bool  transpose = false, bool  unitriangular = false  ) const

inline

tril()

at::Tensor at::Tensor::tril ( int64_t  diagonal = 0 ) const

inline

tril_()

at::Tensor & at::Tensor::tril_ ( int64_t  diagonal = 0 ) const

inline

triu()

at::Tensor at::Tensor::triu ( int64_t  diagonal = 0 ) const

inline

triu_()

at::Tensor & at::Tensor::triu_ ( int64_t  diagonal = 0 ) const

inline

true_divide() [1/2]

at::Tensor at::Tensor::true_divide ( const at::Scalar &  other ) const

inline

true_divide() [2/2]

at::Tensor at::Tensor::true_divide ( const at::Tensor &  other ) const

inline

true_divide_() [1/2]

at::Tensor & at::Tensor::true_divide_ ( const at::Scalar &  other ) const

inline

true_divide_() [2/2]

at::Tensor & at::Tensor::true_divide_ ( const at::Tensor &  other ) const

inline

trunc()

at::Tensor at::Tensor::trunc ( ) const

inline

trunc_()

at::Tensor & at::Tensor::trunc_ ( ) const

inline

type_as()

at::Tensor at::Tensor::type_as ( const at::Tensor &  other ) const

inline

unbind() [1/2]

std::vector< at::Tensor > at::Tensor::unbind ( at::Dimname  dim ) const

inline

unbind() [2/2]

std::vector< at::Tensor > at::Tensor::unbind ( int64_t  dim = 0 ) const

inline

unflatten() [1/2]

at::Tensor at::Tensor::unflatten ( at::Dimname  dim, at::IntArrayRef  sizes, at::DimnameList  names  ) const

inline

unflatten() [2/2]

at::Tensor at::Tensor::unflatten ( int64_t  dim, at::IntArrayRef  sizes  ) const

inline

unfold()

at::Tensor at::Tensor::unfold ( int64_t  dimension, int64_t  size, int64_t  step  ) const

inline

uniform_()

at::Tensor & at::Tensor::uniform_ ( double  from = 0, double  to = 1, c10::optional< at::Generator >  generator = c10::nullopt  ) const

inline

unsafe_chunk()

std::vector< at::Tensor > at::Tensor::unsafe_chunk ( int64_t  chunks, int64_t  dim = 0  ) const

inline

unsafe_split()

std::vector< at::Tensor > at::Tensor::unsafe_split ( int64_t  split_size, int64_t  dim = 0  ) const

inline

unsafe_split_symint()

std::vector< at::Tensor > at::Tensor::unsafe_split_symint ( c10::SymInt  split_size, int64_t  dim = 0  ) const

inline

unsafe_split_with_sizes()

std::vector< at::Tensor > at::Tensor::unsafe_split_with_sizes ( at::IntArrayRef  split_sizes, int64_t  dim = 0  ) const

inline

unsafe_split_with_sizes_symint()

std::vector< at::Tensor > at::Tensor::unsafe_split_with_sizes_symint ( c10::SymIntArrayRef  split_sizes, int64_t  dim = 0  ) const

inline

unsqueeze()

at::Tensor at::Tensor::unsqueeze ( int64_t  dim ) const

inline

unsqueeze_()

at::Tensor & at::Tensor::unsqueeze_ ( int64_t  dim ) const

inline

values()

at::Tensor at::Tensor::values ( ) const

inline

var() [1/6]

at::Tensor at::Tensor::var ( at::DimnameList  dim, bool  unbiased, bool  keepdim = false  ) const

inline

var() [2/6]

at::Tensor at::Tensor::var ( at::DimnameList  dim, c10::optional< int64_t >  correction = c10::nullopt, bool  keepdim = false  ) const

inline

var() [3/6]

at::Tensor at::Tensor::var ( at::OptionalIntArrayRef  dim, bool  unbiased, bool  keepdim = false  ) const

inline

var() [4/6]

at::Tensor at::Tensor::var ( at::OptionalIntArrayRef  dim = c10::nullopt, c10::optional< int64_t >  correction = c10::nullopt, bool  keepdim = false  ) const

inline

var() [5/6]

at::Tensor at::Tensor::var ( bool  unbiased ) const

inline

var() [6/6]

Tensor at::Tensor::var ( int  dim ) const

inline

variable_data()

at::Tensor at::Tensor::variable_data ( ) const

inline

NOTE: var.variable_data() in C++ has the same semantics as tensor.data in Python, which create a new Variable that shares the same storage and tensor metadata with the original Variable, but with a completely new autograd history.

NOTE: If we change the tensor metadata (e.g. sizes / strides / storage / storage_offset) of a variable created from var.variable_data(), those changes will not update the original variable var. In .variable_data(), we set allow_tensor_metadata_change_ to false to make such changes explicitly illegal, in order to prevent users from changing metadata of var.variable_data() and expecting the original variable var to also be updated.

vdot()

at::Tensor at::Tensor::vdot ( const at::Tensor &  other ) const

inline

ve()

Tensor at::Tensor::ve ( ) const

inline

view() [1/2]

at::Tensor at::Tensor::view ( at::IntArrayRef  size ) const

inline

view() [2/2]

at::Tensor at::Tensor::view ( at::ScalarType  dtype ) const

inline

view_as()

at::Tensor at::Tensor::view_as ( const at::Tensor &  other ) const

inline

view_symint()

at::Tensor at::Tensor::view_symint ( c10::SymIntArrayRef  size ) const

inline

vsplit() [1/2]

std::vector< at::Tensor > at::Tensor::vsplit ( at::IntArrayRef  indices ) const

inline

vsplit() [2/2]

std::vector< at::Tensor > at::Tensor::vsplit ( int64_t  sections ) const

inline

vulkan()

Tensor at::Tensor::vulkan ( ) const

inline

where() [1/2]

at::Tensor at::Tensor::where ( const at::Tensor &  condition, const at::Scalar &  other  ) const

inline

where() [2/2]

at::Tensor at::Tensor::where ( const at::Tensor &  condition, const at::Tensor &  other  ) const

inline

wrap_tensor_impl()

static Tensor at::Tensor::wrap_tensor_impl ( c10::intrusive_ptr< TensorImpl, UndefinedTensorImpl >  tensor_impl )

inlinestatic

xlogy() [1/2]

at::Tensor at::Tensor::xlogy ( const at::Scalar &  other ) const

inline

xlogy() [2/2]

at::Tensor at::Tensor::xlogy ( const at::Tensor &  other ) const

inline

xlogy_() [1/2]

at::Tensor & at::Tensor::xlogy_ ( const at::Scalar &  other ) const

inline

xlogy_() [2/2]

at::Tensor & at::Tensor::xlogy_ ( const at::Tensor &  other ) const

inline

zero_()

at::Tensor & at::Tensor::zero_ ( ) const

inline

Member Data Documentation

MaybeOwnedTraits< Tensor >

friend at::Tensor::MaybeOwnedTraits< Tensor >

protected

N

at::Tensor::N

OptionalTensorRef

friend at::Tensor::OptionalTensorRef

protected

PtrTraits

at::Tensor::PtrTraits

---

The documentation for this class was generated from the following files:

• build/aten/src/ATen/core/TensorBody.h
• aten/src/ATen/core/Tensor.h