Class Tensor¶

Defined in File TensorBody.h

Page Contents

Nested Relationships
- Nested Types
Class Documentation

Nested Relationships¶

Nested Types¶

Struct Tensor::unsafe_borrow_t

Class Documentation¶

class at::Tensor¶

Public Types

using hook_return_void_t = std::enable_if_t<std::is_void<typename std::result_of<T&(Tensor)>::type>::value, unsigned>¶

using hook_return_var_t = std::enable_if_t<std::is_same<typename std::result_of<T&(Tensor)>::type, Tensor>::value, unsigned>¶

Public Functions

Tensor()¶

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

Tensor(const Tensor&) = default¶

Tensor(Tensor&&) = default¶

int64_t dim() const¶

int64_t storage_offset() const¶

Tensor contiguous(MemoryFormat memory_format = MemoryFormat::Contiguous) 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.

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.

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

bool is_complex() const¶

bool is_floating_point() const¶

bool is_signed() 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()¶

Tensor &operator=(const Tensor &x) &¶

Tensor &operator=(Tensor &&x) &¶

Tensor &operator=(Scalar v) &&¶

Tensor &operator=(const Tensor&) &&¶

Tensor &operator=(Tensor&&) &&¶

bool is_same(const Tensor &other) const noexcept¶

size_t use_count() const noexcept¶

size_t weak_use_count() const noexcept¶

std::string toString() const¶

IntArrayRef sizes() 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¶

int64_t numel() const¶

size_t itemsize() const¶

int64_t element_size() const¶

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

DispatchKeySet key_set() const¶

ScalarType scalar_type() const¶

bool has_storage() const¶

const Storage &storage() const¶

bool is_alias_of(const at::Tensor &other) 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

Layout layout() const noexcept¶: Returns a Tensor’s layout.

caffe2::TypeMeta dtype() const noexcept¶: Returns a Tensor’s dtype (TypeMeta).

Device device() const¶: Returns a Tensor’s device.

int64_t get_device() const¶: Returns a Tensor’s device index.

bool is_cpu() const¶: Returns if a Tensor has CPU backend.

bool is_cuda() const¶: Returns if a Tensor has CUDA backend.

bool is_xpu() const¶: Returns if a Tensor has XPU backend.

bool is_xla() const¶: Returns if a Tensor has XLA backend.

bool is_hip() const¶: Returns if a Tensor has HIP backend.

bool is_sparse() const¶: Returns if a Tensor has sparse backend.

bool is_sparse_csr() const¶: Returns is a Tensor has a sparse CSR backend.

bool is_mkldnn() const¶: Returns if a Tensor is mkldnn tensor.

bool is_mlc() const¶: Returns if a Tensor is mlc tensor.

bool is_vulkan() const¶: Returns if a Tensor is vulkan tensor.

bool is_metal() const¶: Returns if a Tensor is metal tensor.

bool is_quantized() const¶: Returns if a Tensor has quantized backend.

bool is_meta() const¶

Returns if a Tensor is a meta tensor.

Meta tensors can also have other designations.

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.

bool has_names() const¶: Returns if a Tensor has any dimension names.

const NamedTensorMeta *get_named_tensor_meta() const¶: Returns a Tensor’s dimension names data structure.

NamedTensorMeta *get_named_tensor_meta()¶

TensorOptions options() const¶

Returns the TensorOptions corresponding to this Tensor.

Defined in TensorOptions.h.

void *data_ptr() const¶

template<typename T> T *data_ptr() const¶

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¶

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¶

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+=(Scalar other)¶

Tensor &operator-=(const Tensor &other)¶

Tensor &operator-=(Scalar other)¶

Tensor &operator*=(const Tensor &other)¶

Tensor &operator*=(Scalar other)¶

Tensor &operator/=(const Tensor &other)¶

Tensor &operator/=(Scalar other)¶

Tensor &operator&=(const Tensor &other)¶

Tensor &operator|=(const Tensor &other)¶

Tensor &operator^=(const Tensor &other)¶

Tensor operator[](Scalar index) const¶

Tensor operator[](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 vulkan() const¶

Tensor metal() 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.

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. All the provided inputs must be leaf Tensors.

const Tensor &set_requires_grad(bool requires_grad) const¶

bool requires_grad() const¶

Tensor &mutable_grad() const¶

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.

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.

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

const Tensor &_fw_grad(uint64_t level) const¶: This function returns the forward gradient for this Tensor at the given level.

void _set_fw_grad(const Tensor &new_grad, uint64_t level, bool is_inplace_op) const¶

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

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¶

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 conj() 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 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¶

const at::Tensor &as_strided_(at::IntArrayRef size, at::IntArrayRef stride, c10::optional<int64_t> 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 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(at::IntArrayRef 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¶

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<std::string> rounding_mode) const¶

at::Tensor &div_(const at::Tensor &other, c10::optional<std::string> 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<std::string> rounding_mode) const¶

at::Tensor &div_(const at::Scalar &other, c10::optional<std::string> 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<std::string> rounding_mode) const¶

at::Tensor &divide_(const at::Tensor &other, c10::optional<std::string> rounding_mode) const¶

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

at::Tensor &divide_(const at::Scalar &other, c10::optional<std::string> 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_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_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_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¶

const at::Tensor &resize_(at::IntArrayRef 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_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, c10::optional<at::DimnameList> names = c10::nullopt) 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 inverse() 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¶

at::Tensor isreal() const¶

bool is_nonzero() const¶

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

bool __dispatch_is_signed() 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 logdet() 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> 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::IntArrayRef 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 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(int64_t dim, int64_t start, int64_t length) const¶

at::Tensor narrow(int64_t dim, const at::Tensor &start, int64_t 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¶

bool is_pinned() const¶

at::Tensor pin_memory() 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_interleave(const at::Tensor &repeats, c10::optional<int64_t> dim = c10::nullopt) const¶

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

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

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

at::Tensor round() const¶

at::Tensor &round_() const¶

at::Tensor relu() const¶

at::Tensor &relu_() const¶

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

std::tuple<at::Tensor, at::Tensor> prelu_backward(const at::Tensor &grad_output, 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 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.

The result will never require gradient.

at::Tensor &detach_() const¶

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

Views cannot be detached in-place.

int64_t size(at::Dimname dim) const¶

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

std::tuple<at::Tensor, at::Tensor> slogdet() 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> split(int64_t 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> split_with_sizes(at::IntArrayRef 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_() const¶

at::Tensor &squeeze_(int64_t 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::nullopt, c10::optional<int64_t> win_length = c10::nullopt, const c10::optional<at::Tensor> &window = {}, 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::IntArrayRef 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(c10::optional<at::ScalarType> dtype = c10::nullopt) const¶

at::Tensor nansum(at::IntArrayRef dim, 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 = true) const¶

at::Tensor std(at::IntArrayRef dim, bool unbiased = true, bool keepdim = false) const¶

at::Tensor std(at::DimnameList dim, bool unbiased = true, 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 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 = true) const¶

at::Tensor var(at::IntArrayRef dim, bool unbiased = true, bool keepdim = false) const¶

at::Tensor var(at::DimnameList dim, bool unbiased = true, 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 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¶

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¶

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¶

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¶

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() 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 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_(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(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::Tensor &index_add_(int64_t dim, const at::Tensor &index, const at::Tensor &source, const at::Scalar &alpha) const¶

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

at::Tensor index_add(int64_t dim, const at::Tensor &index, const at::Tensor &source, const at::Scalar &alpha) 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_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(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_(int64_t dim, const at::Tensor &index, const at::Tensor &src, std::string reduce) const¶

at::Tensor &scatter_(int64_t dim, const at::Tensor &index, const at::Scalar &value, std::string reduce) 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 &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 __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 &tril_(int64_t diagonal = 0) const¶

at::Tensor &triu_(int64_t diagonal = 0) const¶

at::Tensor &digamma_() const¶

at::Tensor &renorm_(const at::Scalar &p, int64_t dim, const at::Scalar &maxnorm) 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 &fmod_(const at::Scalar &other) const¶

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

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

at::Tensor &remainder_(const at::Tensor &other) 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 &addcdiv_(const at::Tensor &tensor1, const at::Tensor &tensor2, const at::Scalar &value = 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 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¶

std::tuple<at::Tensor, at::Tensor> lstsq(const at::Tensor &A) 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> symeig(bool eigenvectors = false, bool upper = true) const¶

std::tuple<at::Tensor, at::Tensor> eig(bool eigenvectors = 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¶

std::tuple<at::Tensor, at::Tensor> solve(const at::Tensor &A) 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 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¶

at::Tensor fmod(const at::Scalar &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::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(double q, c10::optional<int64_t> dim = c10::nullopt, bool keepdim = false) const¶

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

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

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

at::Tensor quantile(double q, c10::optional<int64_t> dim, bool keepdim, std::string interpolation) const¶

at::Tensor quantile(const at::Tensor &q, c10::optional<int64_t> dim, bool keepdim, std::string interpolation) const¶

at::Tensor nanquantile(double q, c10::optional<int64_t> dim, bool keepdim, std::string interpolation) const¶

at::Tensor nanquantile(const at::Tensor &q, c10::optional<int64_t> dim, bool keepdim, std::string interpolation) 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(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 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¶

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

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

at::Tensor ger(const at::Tensor &vec2) 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.

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.

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.

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.

const std::shared_ptr<torch::autograd::Node> &grad_fn() const¶

Gets the gradient function of the Variable.

If this is a leaf variable, the pointer returned will be null.

For View Variables: Gets the up-to-date grad_fn. If the shared data or base was modified, we re-create the grad_fn to express the up-to-date view relationship between this and the base Variable.

template<typename T> hook_return_void_t<T> 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

template<typename T> hook_return_var_t<T> register_hook(T &&hook) const¶

void remove_hook(unsigned pos) const¶: Remove hook at given position.

bool is_leaf() const¶

All Tensors that have requires_grad() which is false will be leaf Tensors by convention.

For Tensors that have requires_grad() which is true, they will be leaf Tensors if they were created by the user. This means that they are not the result of an operation and so grad_fn() is nullptr.

Only leaf Tensors will have their grad() populated during a call to backward(). To get grad() populated for non-leaf Tensors, you can use retain_grad().

Example:

auto a = torch::rand(10, torch::requires_grad());
std::cout << a.is_leaf() << std::endl; // prints `true`

auto b = torch::rand(10, torch::requires_grad()).to(torch::kCUDA);
std::cout << b.is_leaf() << std::endl; // prints `false`
// b was created by the operation that cast a cpu Tensor into a cuda Tensor

auto c = torch::rand(10, torch::requires_grad()) + 2;
std::cout << c.is_leaf() << std::endl; // prints `false`
// c was created by the addition operation

auto d = torch::rand(10).cuda();
std::cout << d.is_leaf() << std::endl; // prints `true`
// d does not require gradients and so has no operation creating it (that is tracked by the autograd engine)

auto e = torch::rand(10).cuda().requires_grad_();
std::cout << e.is_leaf() << std::endl; // prints `true`
// e requires gradients and has no operations creating it

auto f = torch::rand(10, torch::device(torch::kCUDA).requires_grad(true));
std::cout << f.is_leaf() << std::endl; // prints `true`
// f requires grad, has no operation creating it

int64_t output_nr() const¶

void set_data(const Tensor &new_data) const¶

Tensor data() const¶

int64_t _version() const¶

void retain_grad() const¶: Enables .grad() for non-leaf Tensors.

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¶

bool is_view() const¶: Returns true if this Variable is a view of another Variable.

const Tensor &_base() const¶

Returns the Variable that this Variable is a view of.

If this Variable is not a view, throw a std::runtime_error.

const std::string &name() const¶

template<typename T> auto register_hook(T &&hook) const -> Tensor::hook_return_void_t<T>¶

Public Members

N

PtrTraits

Public Static Functions

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

Protected Functions

void enforce_invariants()¶

Protected Attributes

c10::intrusive_ptr<TensorImpl, UndefinedTensorImpl> impl_¶

Class Tensor¶

Nested Relationships¶

Nested Types¶

Class Documentation¶

Docs

Tutorials

Resources