neulab/docprompting-conala huggingface dataset:
torch.sum(input, *, dtype=None) → Tensor  
Returns the sum of all elements in the input tensor.  Parameters 
input (Tensor) – the input tensor.  Keyword Arguments 
dtype (torch.dtype, optional) – the desired data type of returned tensor. If specified, the input tensor is casted to dtype before the operation is performed. This is useful for preventing data type overflows. Default: None.   Example: >>> a = torch.randn(1, 3)
>>> a
tensor([[ 0.1133, -0.9567,  0.2958]])
>>> torch.sum(a)
tensor(-0.5475)
  
torch.sum(input, dim, keepdim=False, *, dtype=None) → Tensor 
 Returns the sum of each row of the input tensor in the given dimension dim. If dim is a list of dimensions, reduce over all of them. If keepdim is True, the output tensor is of the same size as input except in the dimension(s) dim where it is of size 1. Otherwise, dim is squeezed (see torch.squeeze()), resulting in the output tensor having 1 (or len(dim)) fewer dimension(s).  Parameters 
 
input (Tensor) – the input tensor. 
dim (int or tuple of python:ints) – the dimension or dimensions to reduce. 
keepdim (bool) – whether the output tensor has dim retained or not.   Keyword Arguments 
dtype (torch.dtype, optional) – the desired data type of returned tensor. If specified, the input tensor is casted to dtype before the operation is performed. This is useful for preventing data type overflows. Default: None.   Example: >>> a = torch.randn(4, 4)
>>> a
tensor([[ 0.0569, -0.2475,  0.0737, -0.3429],
        [-0.2993,  0.9138,  0.9337, -1.6864],
        [ 0.1132,  0.7892, -0.1003,  0.5688],
        [ 0.3637, -0.9906, -0.4752, -1.5197]])
>>> torch.sum(a, 1)
tensor([-0.4598, -0.1381,  1.3708, -2.6217])
>>> b = torch.arange(4 * 5 * 6).view(4, 5, 6)
>>> torch.sum(b, (2, 1))
tensor([  435.,  1335.,  2235.,  3135.])
torch.svd_lowrank(A, q=6, niter=2, M=None) [source]
 
Return the singular value decomposition (U, S, V) of a matrix, batches of matrices, or a sparse matrix AA  such that A≈Udiag(S)VTA \approx U diag(S) V^T . In case MM  is given, then SVD is computed for the matrix A−MA - M .  Note The implementation is based on the Algorithm 5.1 from Halko et al, 2009.   Note To obtain repeatable results, reset the seed for the pseudorandom number generator   Note The input is assumed to be a low-rank matrix.   Note In general, use the full-rank SVD implementation torch.svd for dense matrices due to its 10-fold higher performance characteristics. The low-rank SVD will be useful for huge sparse matrices that torch.svd cannot handle.   Args::

A (Tensor): the input tensor of size (∗,m,n)(*, m, n)  q (int, optional): a slightly overestimated rank of A.  niter (int, optional): the number of subspace iterations to

conduct; niter must be a nonnegative integer, and defaults to 2  M (Tensor, optional): the input tensor’s mean of size

(∗,1,n)(*, 1, n) .    References::

 Nathan Halko, Per-Gunnar Martinsson, and Joel Tropp, Finding structure with randomness: probabilistic algorithms for constructing approximate matrix decompositions, arXiv:0909.4061 [math.NA; math.PR], 2009 (available at arXiv).
torch.swapaxes(input, axis0, axis1) → Tensor  
Alias for torch.transpose(). This function is equivalent to NumPy’s swapaxes function. Examples: >>> x = torch.tensor([[[0,1],[2,3]],[[4,5],[6,7]]])
>>> x
tensor([[[0, 1],
        [2, 3]],

        [[4, 5],
        [6, 7]]])
>>> torch.swapaxes(x, 0, 1)
tensor([[[0, 1],
        [4, 5]],

        [[2, 3],
        [6, 7]]])
>>> torch.swapaxes(x, 0, 2)
tensor([[[0, 4],
        [2, 6]],

        [[1, 5],
        [3, 7]]])
torch.swapdims(input, dim0, dim1) → Tensor  
Alias for torch.transpose(). This function is equivalent to NumPy’s swapaxes function. Examples: >>> x = torch.tensor([[[0,1],[2,3]],[[4,5],[6,7]]])
>>> x
tensor([[[0, 1],
        [2, 3]],

        [[4, 5],
        [6, 7]]])
>>> torch.swapdims(x, 0, 1)
tensor([[[0, 1],
        [4, 5]],

        [[2, 3],
        [6, 7]]])
>>> torch.swapdims(x, 0, 2)
tensor([[[0, 4],
        [2, 6]],

        [[1, 5],
        [3, 7]]])
torch.symeig(input, eigenvectors=False, upper=True, *, out=None) -> (Tensor, Tensor)  
This function returns eigenvalues and eigenvectors of a real symmetric matrix input or a batch of real symmetric matrices, represented by a namedtuple (eigenvalues, eigenvectors). This function calculates all eigenvalues (and vectors) of input such that input=Vdiag(e)VT\text{input} = V \text{diag}(e) V^T . The boolean argument eigenvectors defines computation of both eigenvectors and eigenvalues or eigenvalues only. If it is False, only eigenvalues are computed. If it is True, both eigenvalues and eigenvectors are computed. Since the input matrix input is supposed to be symmetric, only the upper triangular portion is used by default. If upper is False, then lower triangular portion is used.  Note The eigenvalues are returned in ascending order. If input is a batch of matrices, then the eigenvalues of each matrix in the batch is returned in ascending order.   Note Irrespective of the original strides, the returned matrix V will be transposed, i.e. with strides V.contiguous().transpose(-1, -2).stride().   Warning Extra care needs to be taken when backward through outputs. Such operation is only stable when all eigenvalues are distinct and becomes less stable the smaller min⁡i≠j∣λi−λj∣\min_{i \neq j} |\lambda_i - \lambda_j|  is.   Parameters 
 
input (Tensor) – the input tensor of size (∗,n,n)(*, n, n)  where * is zero or more batch dimensions consisting of symmetric matrices. 
eigenvectors (bool, optional) – controls whether eigenvectors have to be computed 
upper (boolean, optional) – controls whether to consider upper-triangular or lower-triangular region   Keyword Arguments 
out (tuple, optional) – the output tuple of (Tensor, Tensor)  Returns 
A namedtuple (eigenvalues, eigenvectors) containing  
eigenvalues (Tensor): Shape (∗,m)(*, m) . The eigenvalues in ascending order. 
eigenvectors (Tensor): Shape (∗,m,m)(*, m, m) . If eigenvectors=False, it’s an empty tensor. Otherwise, this tensor contains the orthonormal eigenvectors of the input.   Return type 
(Tensor, Tensor)   Examples: >>> a = torch.randn(5, 5)
>>> a = a + a.t()  # To make a symmetric
>>> a
tensor([[-5.7827,  4.4559, -0.2344, -1.7123, -1.8330],
        [ 4.4559,  1.4250, -2.8636, -3.2100, -0.1798],
        [-0.2344, -2.8636,  1.7112, -5.5785,  7.1988],
        [-1.7123, -3.2100, -5.5785, -2.6227,  3.1036],
        [-1.8330, -0.1798,  7.1988,  3.1036, -5.1453]])
>>> e, v = torch.symeig(a, eigenvectors=True)
>>> e
tensor([-13.7012,  -7.7497,  -2.3163,   5.2477,   8.1050])
>>> v
tensor([[ 0.1643,  0.9034, -0.0291,  0.3508,  0.1817],
        [-0.2417, -0.3071, -0.5081,  0.6534,  0.4026],
        [-0.5176,  0.1223, -0.0220,  0.3295, -0.7798],
        [-0.4850,  0.2695, -0.5773, -0.5840,  0.1337],
        [ 0.6415, -0.0447, -0.6381, -0.0193, -0.4230]])
>>> a_big = torch.randn(5, 2, 2)
>>> a_big = a_big + a_big.transpose(-2, -1)  # To make a_big symmetric
>>> e, v = a_big.symeig(eigenvectors=True)
>>> torch.allclose(torch.matmul(v, torch.matmul(e.diag_embed(), v.transpose(-2, -1))), a_big)
True
torch.t(input) → Tensor  
Expects input to be <= 2-D tensor and transposes dimensions 0 and 1. 0-D and 1-D tensors are returned as is. When input is a 2-D tensor this is equivalent to transpose(input, 0, 1).  Parameters 
input (Tensor) – the input tensor.   Example: >>> x = torch.randn(())
>>> x
tensor(0.1995)
>>> torch.t(x)
tensor(0.1995)
>>> x = torch.randn(3)
>>> x
tensor([ 2.4320, -0.4608,  0.7702])
>>> torch.t(x)
tensor([ 2.4320, -0.4608,  0.7702])
>>> x = torch.randn(2, 3)
>>> x
tensor([[ 0.4875,  0.9158, -0.5872],
        [ 0.3938, -0.6929,  0.6932]])
>>> torch.t(x)
tensor([[ 0.4875,  0.3938],
        [ 0.9158, -0.6929],
        [-0.5872,  0.6932]])
torch.take(input, index) → Tensor  
Returns a new tensor with the elements of input at the given indices. The input tensor is treated as if it were viewed as a 1-D tensor. The result takes the same shape as the indices.  Parameters 
 
input (Tensor) – the input tensor. 
indices (LongTensor) – the indices into tensor    Example: >>> src = torch.tensor([[4, 3, 5],
...                     [6, 7, 8]])
>>> torch.take(src, torch.tensor([0, 2, 5]))
tensor([ 4,  5,  8])
torch.tan(input, *, out=None) → Tensor  
Returns a new tensor with the tangent of the elements of input.  outi=tan⁡(inputi)\text{out}_{i} = \tan(\text{input}_{i})  
 Parameters 
input (Tensor) – the input tensor.  Keyword Arguments 
out (Tensor, optional) – the output tensor.   Example: >>> a = torch.randn(4)
>>> a
tensor([-1.2027, -1.7687,  0.4412, -1.3856])
>>> torch.tan(a)
tensor([-2.5930,  4.9859,  0.4722, -5.3366])
torch.tanh(input, *, out=None) → Tensor  
Returns a new tensor with the hyperbolic tangent of the elements of input.  outi=tanh⁡(inputi)\text{out}_{i} = \tanh(\text{input}_{i})  
 Parameters 
input (Tensor) – the input tensor.  Keyword Arguments 
out (Tensor, optional) – the output tensor.   Example: >>> a = torch.randn(4)
>>> a
tensor([ 0.8986, -0.7279,  1.1745,  0.2611])
>>> torch.tanh(a)
tensor([ 0.7156, -0.6218,  0.8257,  0.2553])
torch.tensor(data, *, dtype=None, device=None, requires_grad=False, pin_memory=False) → Tensor  
Constructs a tensor with data.  Warning torch.tensor() always copies data. If you have a Tensor data and want to avoid a copy, use torch.Tensor.requires_grad_() or torch.Tensor.detach(). If you have a NumPy ndarray and want to avoid a copy, use torch.as_tensor().   Warning When data is a tensor x, torch.tensor() reads out ‘the data’ from whatever it is passed, and constructs a leaf variable. Therefore torch.tensor(x) is equivalent to x.clone().detach() and torch.tensor(x, requires_grad=True) is equivalent to x.clone().detach().requires_grad_(True). The equivalents using clone() and detach() are recommended.   Parameters 
data (array_like) – Initial data for the tensor. Can be a list, tuple, NumPy ndarray, scalar, and other types.  Keyword Arguments 
 
dtype (torch.dtype, optional) – the desired data type of returned tensor. Default: if None, infers data type from data. 
device (torch.device, optional) – the desired device of returned tensor. Default: if None, uses the current device for the default tensor type (see torch.set_default_tensor_type()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types. 
requires_grad (bool, optional) – If autograd should record operations on the returned tensor. Default: False. 
pin_memory (bool, optional) – If set, returned tensor would be allocated in the pinned memory. Works only for CPU tensors. Default: False.    Example: >>> torch.tensor([[0.1, 1.2], [2.2, 3.1], [4.9, 5.2]])
tensor([[ 0.1000,  1.2000],
        [ 2.2000,  3.1000],
        [ 4.9000,  5.2000]])

>>> torch.tensor([0, 1])  # Type inference on data
tensor([ 0,  1])

>>> torch.tensor([[0.11111, 0.222222, 0.3333333]],
...              dtype=torch.float64,
...              device=torch.device('cuda:0'))  # creates a torch.cuda.DoubleTensor
tensor([[ 0.1111,  0.2222,  0.3333]], dtype=torch.float64, device='cuda:0')

>>> torch.tensor(3.14159)  # Create a scalar (zero-dimensional tensor)
tensor(3.1416)

>>> torch.tensor([])  # Create an empty tensor (of size (0,))
tensor([])
absolute_() → Tensor  
In-place version of absolute() Alias for abs_()
add(other, *, alpha=1) → Tensor  
Add a scalar or tensor to self tensor. If both alpha and other are specified, each element of other is scaled by alpha before being used. When other is a tensor, the shape of other must be broadcastable with the shape of the underlying tensor See torch.add()
addbmm(batch1, batch2, *, beta=1, alpha=1) → Tensor  
See torch.addbmm()
addbmm_(batch1, batch2, *, beta=1, alpha=1) → Tensor  
In-place version of addbmm()
addcdiv(tensor1, tensor2, *, value=1) → Tensor  
See torch.addcdiv()
addcdiv_(tensor1, tensor2, *, value=1) → Tensor  
In-place version of addcdiv()
addcmul(tensor1, tensor2, *, value=1) → Tensor  
See torch.addcmul()
addcmul_(tensor1, tensor2, *, value=1) → Tensor  
In-place version of addcmul()
addmm(mat1, mat2, *, beta=1, alpha=1) → Tensor  
See torch.addmm()
addmm_(mat1, mat2, *, beta=1, alpha=1) → Tensor  
In-place version of addmm()
addmv(mat, vec, *, beta=1, alpha=1) → Tensor  
See torch.addmv()
addmv_(mat, vec, *, beta=1, alpha=1) → Tensor  
In-place version of addmv()
addr(vec1, vec2, *, beta=1, alpha=1) → Tensor  
See torch.addr()
addr_(vec1, vec2, *, beta=1, alpha=1) → Tensor  
In-place version of addr()
add_(other, *, alpha=1) → Tensor  
In-place version of add()
align_as(other) → Tensor  
Permutes the dimensions of the self tensor to match the dimension order in the other tensor, adding size-one dims for any new names. This operation is useful for explicit broadcasting by names (see examples). All of the dims of self must be named in order to use this method. The resulting tensor is a view on the original tensor. All dimension names of self must be present in other.names. other may contain named dimensions that are not in self.names; the output tensor has a size-one dimension for each of those new names. To align a tensor to a specific order, use align_to(). Examples: # Example 1: Applying a mask
>>> mask = torch.randint(2, [127, 128], dtype=torch.bool).refine_names('W', 'H')
>>> imgs = torch.randn(32, 128, 127, 3, names=('N', 'H', 'W', 'C'))
>>> imgs.masked_fill_(mask.align_as(imgs), 0)


# Example 2: Applying a per-channel-scale
>>> def scale_channels(input, scale):
>>>    scale = scale.refine_names('C')
>>>    return input * scale.align_as(input)

>>> num_channels = 3
>>> scale = torch.randn(num_channels, names=('C',))
>>> imgs = torch.rand(32, 128, 128, num_channels, names=('N', 'H', 'W', 'C'))
>>> more_imgs = torch.rand(32, num_channels, 128, 128, names=('N', 'C', 'H', 'W'))
>>> videos = torch.randn(3, num_channels, 128, 128, 128, names=('N', 'C', 'H', 'W', 'D'))

# scale_channels is agnostic to the dimension order of the input
>>> scale_channels(imgs, scale)
>>> scale_channels(more_imgs, scale)
>>> scale_channels(videos, scale)
  Warning The named tensor API is experimental and subject to change.
align_to(*names) [source]
 
Permutes the dimensions of the self tensor to match the order specified in names, adding size-one dims for any new names. All of the dims of self must be named in order to use this method. The resulting tensor is a view on the original tensor. All dimension names of self must be present in names. names may contain additional names that are not in self.names; the output tensor has a size-one dimension for each of those new names. names may contain up to one Ellipsis (...). The Ellipsis is expanded to be equal to all dimension names of self that are not mentioned in names, in the order that they appear in self. Python 2 does not support Ellipsis but one may use a string literal instead ('...').  Parameters 
names (iterable of str) – The desired dimension ordering of the output tensor. May contain up to one Ellipsis that is expanded to all unmentioned dim names of self.   Examples: >>> tensor = torch.randn(2, 2, 2, 2, 2, 2)
>>> named_tensor = tensor.refine_names('A', 'B', 'C', 'D', 'E', 'F')

# Move the F and E dims to the front while keeping the rest in order
>>> named_tensor.align_to('F', 'E', ...)
  Warning The named tensor API is experimental and subject to change.
all(dim=None, keepdim=False) → Tensor  
See torch.all()
allclose(other, rtol=1e-05, atol=1e-08, equal_nan=False) → Tensor  
See torch.allclose()
amax(dim=None, keepdim=False) → Tensor  
See torch.amax()
amin(dim=None, keepdim=False) → Tensor  
See torch.amin()
any(dim=None, keepdim=False) → Tensor  
See torch.any()
apply_(callable) → Tensor  
Applies the function callable to each element in the tensor, replacing each element with the value returned by callable.  Note This function only works with CPU tensors and should not be used in code sections that require high performance.
arccosh_()  
acosh_() -> Tensor In-place version of arccosh()
argmax(dim=None, keepdim=False) → LongTensor  
See torch.argmax()
argmin(dim=None, keepdim=False) → LongTensor  
See torch.argmin()
argsort(dim=-1, descending=False) → LongTensor  
See torch.argsort()
as_strided(size, stride, storage_offset=0) → Tensor  
See torch.as_strided()
as_subclass(cls) → Tensor  
Makes a cls instance with the same data pointer as self. Changes in the output mirror changes in self, and the output stays attached to the autograd graph. cls must be a subclass of Tensor.
backward(gradient=None, retain_graph=None, create_graph=False, inputs=None) [source]
 
Computes the gradient of current tensor w.r.t. 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. self. This function accumulates gradients in the leaves - you might need to zero .grad attributes or set them to None before calling it. See Default gradient layouts for details on the memory layout of accumulated gradients.  Note If you run any forward ops, create gradient, and/or call backward in a user-specified CUDA stream context, see Stream semantics of backward passes.   Parameters 
 
gradient (Tensor or None) – 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 (bool, optional) – 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 (bool, optional) – If True, graph of the derivative will be constructed, allowing to compute higher order derivative products. Defaults to False. 
inputs (sequence of Tensor) – Inputs w.r.t. which the gradient will be accumulated into .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 attr::tensors. All the provided inputs must be leaf Tensors.
baddbmm(batch1, batch2, *, beta=1, alpha=1) → Tensor  
See torch.baddbmm()
baddbmm_(batch1, batch2, *, beta=1, alpha=1) → Tensor  
In-place version of baddbmm()
bernoulli(*, generator=None) → Tensor  
Returns a result tensor where each result[i]\texttt{result[i]}  is independently sampled from Bernoulli(self[i])\text{Bernoulli}(\texttt{self[i]}) . self must have floating point dtype, and the result will have the same dtype. See torch.bernoulli()
bernoulli_()  
 
bernoulli_(p=0.5, *, generator=None) → Tensor  
Fills each location of self with an independent sample from Bernoulli(p)\text{Bernoulli}(\texttt{p}) . self can have integral dtype. 
  
bernoulli_(p_tensor, *, generator=None) → Tensor  
p_tensor should be a tensor containing probabilities to be used for drawing the binary random number. The ith\text{i}^{th}  element of self tensor will be set to a value sampled from Bernoulli(p_tensor[i])\text{Bernoulli}(\texttt{p\_tensor[i]}) . self can have integral dtype, but p_tensor must have floating point dtype. 
 See also bernoulli() and torch.bernoulli()
bfloat16(memory_format=torch.preserve_format) → Tensor  
self.bfloat16() is equivalent to self.to(torch.bfloat16). See to().  Parameters 
memory_format (torch.memory_format, optional) – the desired memory format of returned Tensor. Default: torch.preserve_format.
bincount(weights=None, minlength=0) → Tensor  
See torch.bincount()
bitwise_and_() → Tensor  
In-place version of bitwise_and()
bitwise_not_() → Tensor  
In-place version of bitwise_not()
bitwise_or_() → Tensor  
In-place version of bitwise_or()
bitwise_xor_() → Tensor  
In-place version of bitwise_xor()
bool(memory_format=torch.preserve_format) → Tensor  
self.bool() is equivalent to self.to(torch.bool). See to().  Parameters 
memory_format (torch.memory_format, optional) – the desired memory format of returned Tensor. Default: torch.preserve_format.
byte(memory_format=torch.preserve_format) → Tensor  
self.byte() is equivalent to self.to(torch.uint8). See to().  Parameters 
memory_format (torch.memory_format, optional) – the desired memory format of returned Tensor. Default: torch.preserve_format.
cauchy_(median=0, sigma=1, *, generator=None) → Tensor  
Fills the tensor with numbers drawn from the Cauchy distribution:  f(x)=1πσ(x−median)2+σ2f(x) = \dfrac{1}{\pi} \dfrac{\sigma}{(x - \text{median})^2 + \sigma^2}
char(memory_format=torch.preserve_format) → Tensor  
self.char() is equivalent to self.to(torch.int8). See to().  Parameters 
memory_format (torch.memory_format, optional) – the desired memory format of returned Tensor. Default: torch.preserve_format.
cholesky_inverse(upper=False) → Tensor  
See torch.cholesky_inverse()
cholesky_solve(input2, upper=False) → Tensor  
See torch.cholesky_solve()
chunk(chunks, dim=0) → List of Tensors  
See torch.chunk()
clone(*, memory_format=torch.preserve_format) → Tensor  
See torch.clone()
coalesce() → Tensor  
Returns a coalesced copy of self if self is an uncoalesced tensor. Returns self if self is a coalesced tensor.  Warning Throws an error if self is not a sparse COO tensor.
contiguous(memory_format=torch.contiguous_format) → Tensor  
Returns a contiguous in memory tensor containing the same data as self tensor. If self tensor is already in the specified memory format, this function returns the self tensor.  Parameters 
memory_format (torch.memory_format, optional) – the desired memory format of returned Tensor. Default: torch.contiguous_format.
copy_(src, non_blocking=False) → Tensor  
Copies the elements from src into self tensor and returns self. The src tensor must be broadcastable with the self tensor. It may be of a different data type or reside on a different device.  Parameters 
 
src (Tensor) – the source tensor to copy from 
non_blocking (bool) – if True and this copy is between CPU and GPU, the copy may occur asynchronously with respect to the host. For other cases, this argument has no effect.
count_nonzero(dim=None) → Tensor  
See torch.count_nonzero()
cpu(memory_format=torch.preserve_format) → Tensor  
Returns a copy of this object in CPU memory. If this object is already in CPU memory and on the correct device, then no copy is performed and the original object is returned.  Parameters 
memory_format (torch.memory_format, optional) – the desired memory format of returned Tensor. Default: torch.preserve_format.
cuda(device=None, non_blocking=False, memory_format=torch.preserve_format) → Tensor  
Returns a copy of this object in CUDA memory. If this object is already in CUDA memory and on the correct device, then no copy is performed and the original object is returned.  Parameters 
 
device (torch.device) – The destination GPU device. Defaults to the current CUDA device. 
non_blocking (bool) – If True and the source is in pinned memory, the copy will be asynchronous with respect to the host. Otherwise, the argument has no effect. Default: False. 
memory_format (torch.memory_format, optional) – the desired memory format of returned Tensor. Default: torch.preserve_format.
cummax(dim) -> (Tensor, Tensor)  
See torch.cummax()
cummin(dim) -> (Tensor, Tensor)  
See torch.cummin()
cumprod(dim, dtype=None) → Tensor  
See torch.cumprod()
cumprod_(dim, dtype=None) → Tensor  
In-place version of cumprod()
cumsum_(dim, dtype=None) → Tensor  
In-place version of cumsum()
dense_dim() → int  
Return the number of dense dimensions in a sparse tensor self.  Warning Throws an error if self is not a sparse tensor.  See also Tensor.sparse_dim() and hybrid tensors.
dequantize() → Tensor  
Given a quantized Tensor, dequantize it and return the dequantized float Tensor.