# Source code for torch.functional

import torch
import torch.nn.functional as F
from torch._six import inf
from itertools import product
import warnings

__all__ = [
'cartesian_prod',
'chain_matmul',
'einsum',
'gels',
'isfinite',
'isinf',
'lu',
'lu_unpack',
'norm',
'meshgrid',
'split',
'stft',
'tensordot',
'unique',
'unique_consecutive',
]

[docs]def broadcast_tensors(*tensors): r"""broadcast_tensors(*tensors) -> List of Tensors Broadcasts the given tensors according to :ref:broadcasting-semantics. Args: *tensors: any number of tensors of the same type .. warning:: More than one element of a broadcasted tensor may refer to a single memory location. As a result, in-place operations (especially ones that are vectorized) may result in incorrect behavior. If you need to write to the tensors, please clone them first. Example:: >>> x = torch.arange(3).view(1, 3) >>> y = torch.arange(2).view(2, 1) >>> a, b = torch.broadcast_tensors(x, y) >>> a.size() torch.Size([2, 3]) >>> a tensor([[0, 1, 2], [0, 1, 2]]) """ return torch._C._VariableFunctions.broadcast_tensors(tensors)
[docs]def split(tensor, split_size_or_sections, dim=0): r"""Splits the tensor into chunks. If :attr:split_size_or_sections is an integer type, then :attr:tensor will be split into equally sized chunks (if possible). Last chunk will be smaller if the tensor size along the given dimension :attr:dim is not divisible by :attr:split_size. If :attr:split_size_or_sections is a list, then :attr:tensor will be split into len(split_size_or_sections) chunks with sizes in :attr:dim according to :attr:split_size_or_sections. Arguments: tensor (Tensor): tensor to split. split_size_or_sections (int) or (list(int)): size of a single chunk or list of sizes for each chunk dim (int): dimension along which to split the tensor. """ # Overwriting reason: # This dispatches to two ATen functions depending on the type of # split_size_or_sections. The branching code is in tensor.py, which we # call here. return tensor.split(split_size_or_sections, dim)
[docs]def lu_unpack(LU_data, LU_pivots, unpack_data=True, unpack_pivots=True): r"""Unpacks the data and pivots from a LU factorization of a tensor. Returns a tuple of tensors as (the pivots, the L tensor, the U tensor). Arguments: LU_data (Tensor): the packed LU factorization data LU_pivots (Tensor): the packed LU factorization pivots unpack_data (bool): flag indicating if the data should be unpacked unpack_pivots (bool): flag indicating if the pivots should be unpacked Example:: >>> A = torch.randn(2, 3, 3) >>> A_LU, pivots = A.lu() >>> P, A_L, A_U = torch.lu_unpack(A_LU, pivots) >>> >>> # can recover A from factorization >>> A_ = torch.bmm(P, torch.bmm(A_L, A_U)) """ sz = LU_data.size(-1) if unpack_data: U = LU_data.triu() L = LU_data.tril() L.diagonal(dim1=-2, dim2=-1).fill_(1) else: L = U = None if unpack_pivots: LU_pivots_zero_idx = LU_pivots - 1 if LU_data.dim() > 2: P = torch.eye(sz, device=LU_data.device, dtype=LU_data.dtype).expand_as(LU_data).clone() for idx in product(*map(lambda x: list(range(x)), LU_data.shape[:-2])): final_order = list(range(sz)) for k, j in enumerate(LU_pivots_zero_idx[idx]): final_order[k], final_order[j] = final_order[j], final_order[k] P[idx] = P[idx].index_select(1, torch.as_tensor(final_order, device=LU_pivots.device)) else: P = torch.eye(sz, device=LU_data.device, dtype=LU_data.dtype) final_order = list(range(sz)) for k, j, in enumerate(LU_pivots_zero_idx): final_order[k], final_order[j] = final_order[j], final_order[k] P = P.index_select(1, torch.as_tensor(final_order, device=LU_pivots.device)) else: P = None return P, L, U
[docs]def einsum(equation, *operands): r"""einsum(equation, *operands) -> Tensor This function provides a way of computing multilinear expressions (i.e. sums of products) using the Einstein summation convention. Args: equation (string): The equation is given in terms of lower case letters (indices) to be associated with each dimension of the operands and result. The left hand side lists the operands dimensions, separated by commas. There should be one index letter per tensor dimension. The right hand side follows after -> and gives the indices for the output. If the -> and right hand side are omitted, it implicitly defined as the alphabetically sorted list of all indices appearing exactly once in the left hand side. The indices not apprearing in the output are summed over after multiplying the operands entries. If an index appears several times for the same operand, a diagonal is taken. Ellipses ... represent a fixed number of dimensions. If the right hand side is inferred, the ellipsis dimensions are at the beginning of the output. operands (list of Tensors): The operands to compute the Einstein sum of. Examples:: >>> x = torch.randn(5) >>> y = torch.randn(4) >>> torch.einsum('i,j->ij', x, y) # outer product tensor([[-0.0570, -0.0286, -0.0231, 0.0197], [ 1.2616, 0.6335, 0.5113, -0.4351], [ 1.4452, 0.7257, 0.5857, -0.4984], [-0.4647, -0.2333, -0.1883, 0.1603], [-1.1130, -0.5588, -0.4510, 0.3838]]) >>> A = torch.randn(3,5,4) >>> l = torch.randn(2,5) >>> r = torch.randn(2,4) >>> torch.einsum('bn,anm,bm->ba', l, A, r) # compare torch.nn.functional.bilinear tensor([[-0.3430, -5.2405, 0.4494], [ 0.3311, 5.5201, -3.0356]]) >>> As = torch.randn(3,2,5) >>> Bs = torch.randn(3,5,4) >>> torch.einsum('bij,bjk->bik', As, Bs) # batch matrix multiplication tensor([[[-1.0564, -1.5904, 3.2023, 3.1271], [-1.6706, -0.8097, -0.8025, -2.1183]], [[ 4.2239, 0.3107, -0.5756, -0.2354], [-1.4558, -0.3460, 1.5087, -0.8530]], [[ 2.8153, 1.8787, -4.3839, -1.2112], [ 0.3728, -2.1131, 0.0921, 0.8305]]]) >>> A = torch.randn(3, 3) >>> torch.einsum('ii->i', A) # diagonal tensor([-0.7825, 0.8291, -0.1936]) >>> A = torch.randn(4, 3, 3) >>> torch.einsum('...ii->...i', A) # batch diagonal tensor([[-1.0864, 0.7292, 0.0569], [-0.9725, -1.0270, 0.6493], [ 0.5832, -1.1716, -1.5084], [ 0.4041, -1.1690, 0.8570]]) >>> A = torch.randn(2, 3, 4, 5) >>> torch.einsum('...ij->...ji', A).shape # batch permute torch.Size([2, 3, 5, 4]) """ if len(operands) == 1 and isinstance(operands[0], (list, tuple)): # the old interface of passing the operands as one list argument operands = operands[0] return torch._C._VariableFunctions.einsum(equation, operands)
[docs]def isfinite(tensor): r"""Returns a new tensor with boolean elements representing if each element is Finite or not. Arguments: tensor (Tensor): A tensor to check Returns: Tensor: A torch.Tensor with dtype torch.bool containing a True at each location of finite elements and False otherwise Example:: >>> torch.isfinite(torch.tensor([1, float('inf'), 2, float('-inf'), float('nan')])) tensor([True, False, True, False, False]) """ if not isinstance(tensor, torch.Tensor): raise TypeError("The argument is not a tensor: {}".format(repr(tensor))) # Support int input, nan and inf are concepts in floating point numbers. # Numpy uses type 'Object' when the int overflows long, but we don't # have a similar concept. It's safe to assume any created LongTensor doesn't # overflow and it's finite. if not tensor.is_floating_point(): return torch.ones_like(tensor, dtype=torch.bool) return (tensor == tensor) & (tensor.abs() != inf)
[docs]def isinf(tensor): r"""Returns a new tensor with boolean elements representing if each element is +/-INF or not. Arguments: tensor (Tensor): A tensor to check Returns: Tensor: A torch.Tensor with dtype torch.bool containing a True at each location of +/-INF elements and False otherwise Example:: >>> torch.isinf(torch.tensor([1, float('inf'), 2, float('-inf'), float('nan')])) tensor([False, True, False, True, False]) """ if not isinstance(tensor, torch.Tensor): raise TypeError("The argument is not a tensor: {}".format(repr(tensor))) if tensor.dtype in [torch.uint8, torch.int8, torch.int16, torch.int32, torch.int64]: return torch.zeros_like(tensor, dtype=torch.bool) return tensor.abs() == inf
[docs]def meshgrid(*tensors, **kwargs): r"""Take :math:N tensors, each of which can be either scalar or 1-dimensional vector, and create :math:N N-dimensional grids, where the :math:i :sup:th grid is defined by expanding the :math:i :sup:th input over dimensions defined by other inputs. Args: tensors (list of Tensor): list of scalars or 1 dimensional tensors. Scalars will be treated as tensors of size :math:(1,) automatically Returns: seq (sequence of Tensors): If the input has :math:k tensors of size :math:(N_1,), (N_2,), \ldots , (N_k,), then the output would also have :math:k tensors, where all tensors are of size :math:(N_1, N_2, \ldots , N_k). Example:: >>> x = torch.tensor([1, 2, 3]) >>> y = torch.tensor([4, 5, 6]) >>> grid_x, grid_y = torch.meshgrid(x, y) >>> grid_x tensor([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) >>> grid_y tensor([[4, 5, 6], [4, 5, 6], [4, 5, 6]]) """ if kwargs: raise TypeError("meshgrid() got an unexpected keyword argument '%s'" % (list(kwargs)[0],)) if len(tensors) == 1 and isinstance(tensors[0], (list, tuple)): # the old interface of passing the operands as one list argument tensors = tensors[0] return torch._C._VariableFunctions.meshgrid(tensors)
[docs]def stft(input, n_fft, hop_length=None, win_length=None, window=None, center=True, pad_mode='reflect', normalized=False, onesided=True): # type: (Tensor, int, Optional[int], Optional[int], Optional[Tensor], bool, str, bool, bool) -> Tensor r"""Short-time Fourier transform (STFT). Ignoring the optional batch dimension, this method computes the following expression: .. math:: X[m, \omega] = \sum_{k = 0}^{\text{win\_length-1}}% \text{window}[k]\ \text{input}[m \times \text{hop\_length} + k]\ % \exp\left(- j \frac{2 \pi \cdot \omega k}{\text{win\_length}}\right), where :math:m is the index of the sliding window, and :math:\omega is the frequency that :math:0 \leq \omega < \text{n\_fft}. When :attr:onesided is the default value True, * :attr:input must be either a 1-D time sequence or a 2-D batch of time sequences. * If :attr:hop_length is None (default), it is treated as equal to floor(n_fft / 4). * If :attr:win_length is None (default), it is treated as equal to :attr:n_fft. * :attr:window can be a 1-D tensor of size :attr:win_length, e.g., from :meth:torch.hann_window. If :attr:window is None (default), it is treated as if having :math:1 everywhere in the window. If :math:\text{win\_length} < \text{n\_fft}, :attr:window will be padded on both sides to length :attr:n_fft before being applied. * If :attr:center is True (default), :attr:input will be padded on both sides so that the :math:t-th frame is centered at time :math:t \times \text{hop\_length}. Otherwise, the :math:t-th frame begins at time :math:t \times \text{hop\_length}. * :attr:pad_mode determines the padding method used on :attr:input when :attr:center is True. See :meth:torch.nn.functional.pad for all available options. Default is "reflect". * If :attr:onesided is True (default), only values for :math:\omega in :math:\left[0, 1, 2, \dots, \left\lfloor \frac{\text{n\_fft}}{2} \right\rfloor + 1\right] are returned because the real-to-complex Fourier transform satisfies the conjugate symmetry, i.e., :math:X[m, \omega] = X[m, \text{n\_fft} - \omega]^*. * If :attr:normalized is True (default is False), the function returns the normalized STFT results, i.e., multiplied by :math:(\text{frame\_length})^{-0.5}. Returns the real and the imaginary parts together as one tensor of size :math:(* \times N \times T \times 2), where :math:* is the optional batch size of :attr:input, :math:N is the number of frequencies where STFT is applied, :math:T is the total number of frames used, and each pair in the last dimension represents a complex number as the real part and the imaginary part. .. warning:: This function changed signature at version 0.4.1. Calling with the previous signature may cause error or return incorrect result. Arguments: input (Tensor): the input tensor n_fft (int): size of Fourier transform hop_length (int, optional): the distance between neighboring sliding window frames. Default: None (treated as equal to floor(n_fft / 4)) win_length (int, optional): the size of window frame and STFT filter. Default: None (treated as equal to :attr:n_fft) window (Tensor, optional): the optional window function. Default: None (treated as window of all :math:1 s) center (bool, optional): whether to pad :attr:input on both sides so that the :math:t-th frame is centered at time :math:t \times \text{hop\_length}. Default: True pad_mode (string, optional): controls the padding method used when :attr:center is True. Default: "reflect" normalized (bool, optional): controls whether to return the normalized STFT results Default: False onesided (bool, optional): controls whether to return half of results to avoid redundancy Default: True Returns: Tensor: A tensor containing the STFT result with shape described above """ # TODO: after having proper ways to map Python strings to ATen Enum, move # this and F.pad to ATen. if center: signal_dim = input.dim() extended_shape = [1] * (3 - signal_dim) + list(input.size()) pad = int(n_fft // 2) input = F.pad(input.view(extended_shape), (pad, pad), pad_mode) input = input.view(input.shape[-signal_dim:]) return torch._C._VariableFunctions.stft(input, n_fft, hop_length, win_length, window, normalized, onesided)
del torch.unique_dim
[docs]def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=None): r"""Returns the unique elements of the input tensor. Arguments: input (Tensor): the input tensor sorted (bool): Whether to sort the unique elements in ascending order before returning as output. return_inverse (bool): Whether to also return the indices for where elements in the original input ended up in the returned unique list. return_counts (bool): Whether to also return the counts for each unique element. dim (int): the dimension to apply unique. If None, the unique of the flattened input is returned. default: None Returns: (Tensor, Tensor (optional), Tensor (optional)): A tensor or a tuple of tensors containing - **output** (*Tensor*): the output list of unique scalar elements. - **inverse_indices** (*Tensor*): (optional) if :attr:return_inverse is True, there will be an additional returned tensor (same shape as input) representing the indices for where elements in the original input map to in the output; otherwise, this function will only return a single tensor. - **counts** (*Tensor*): (optional) if :attr:return_counts is True, there will be an additional returned tensor (same shape as output or output.size(dim), if dim was specified) representing the number of occurrences for each unique value or tensor. Example:: >>> output = torch.unique(torch.tensor([1, 3, 2, 3], dtype=torch.long)) >>> output tensor([ 2, 3, 1]) >>> output, inverse_indices = torch.unique( torch.tensor([1, 3, 2, 3], dtype=torch.long), sorted=True, return_inverse=True) >>> output tensor([ 1, 2, 3]) >>> inverse_indices tensor([ 0, 2, 1, 2]) >>> output, inverse_indices = torch.unique( torch.tensor([[1, 3], [2, 3]], dtype=torch.long), sorted=True, return_inverse=True) >>> output tensor([ 1, 2, 3]) >>> inverse_indices tensor([[ 0, 2], [ 1, 2]]) """ if dim is not None: output, inverse_indices, counts = torch._C._VariableFunctions.unique_dim( input, dim, sorted=sorted, return_inverse=return_inverse, return_counts=return_counts, ) else: output, inverse_indices, counts = torch._unique2( input, sorted=sorted, return_inverse=return_inverse, return_counts=return_counts, ) if return_inverse and return_counts: return output, inverse_indices, counts elif return_inverse: return output, inverse_indices elif return_counts: return output, counts else: return output
[docs]def unique_consecutive(input, return_inverse=False, return_counts=False, dim=None): r"""Eliminates all but the first element from every consecutive group of equivalent elements. .. note:: This function is different from :func:torch.unique in the sense that this function only eliminates consecutive duplicate values. This semantics is similar to std::unique in C++. Arguments: input (Tensor): the input tensor return_inverse (bool): Whether to also return the indices for where elements in the original input ended up in the returned unique list. return_counts (bool): Whether to also return the counts for each unique element. dim (int): the dimension to apply unique. If None, the unique of the flattened input is returned. default: None Returns: (Tensor, Tensor (optional), Tensor (optional)): A tensor or a tuple of tensors containing - **output** (*Tensor*): the output list of unique scalar elements. - **inverse_indices** (*Tensor*): (optional) if :attr:return_inverse is True, there will be an additional returned tensor (same shape as input) representing the indices for where elements in the original input map to in the output; otherwise, this function will only return a single tensor. - **counts** (*Tensor*): (optional) if :attr:return_counts is True, there will be an additional returned tensor (same shape as output or output.size(dim), if dim was specified) representing the number of occurrences for each unique value or tensor. Example:: >>> x = torch.tensor([1, 1, 2, 2, 3, 1, 1, 2]) >>> output = torch.unique_consecutive(x) >>> output tensor([1, 2, 3, 1, 2]) >>> output, inverse_indices = torch.unique_consecutive(x, return_inverse=True) >>> output tensor([1, 2, 3, 1, 2]) >>> inverse_indices tensor([0, 0, 1, 1, 2, 3, 3, 4]) >>> output, counts = torch.unique_consecutive(x, return_counts=True) >>> output tensor([1, 2, 3, 1, 2]) >>> counts tensor([2, 2, 1, 2, 1]) """ output, inverse_indices, counts = torch._C._VariableFunctions.unique_consecutive( input, return_inverse=return_inverse, return_counts=return_counts, dim=dim) if return_inverse and return_counts: return output, inverse_indices, counts if return_inverse: return output, inverse_indices if return_counts: return output, counts return output
[docs]def tensordot(a, b, dims=2): r"""Returns a contraction of a and b over multiple dimensions. :attr:tensordot implements a generalized matrix product. Args: a (Tensor): Left tensor to contract b (Tensor): Right tensor to contract dims (int or tuple of two lists of integers): number of dimensions to contract or explicit lists of dimensions for :attr:a and :attr:b respectively When called with an integer argument :attr:dims = :math:d, and the number of dimensions of :attr:a and :attr:b is :math:m and :math:n, respectively, it computes .. math:: r_{i_0,...,i_{m-d}, i_d,...,i_n} = \sum_{k_0,...,k_{d-1}} a_{i_0,...,i_{m-d},k_0,...,k_{d-1}} \times b_{k_0,...,k_{d-1}, i_d,...,i_n}. When called with :attr:dims of the list form, the given dimensions will be contracted in place of the last :math:d of :attr:a and the first :math:d of :math:b. The sizes in these dimensions must match, but :attr:tensordot will deal with broadcasted dimensions. Examples:: >>> a = torch.arange(60.).reshape(3, 4, 5) >>> b = torch.arange(24.).reshape(4, 3, 2) >>> torch.tensordot(a, b, dims=([1, 0], [0, 1])) tensor([[4400., 4730.], [4532., 4874.], [4664., 5018.], [4796., 5162.], [4928., 5306.]]) >>> a = torch.randn(3, 4, 5, device='cuda') >>> b = torch.randn(4, 5, 6, device='cuda') >>> c = torch.tensordot(a, b, dims=2).cpu() tensor([[ 8.3504, -2.5436, 6.2922, 2.7556, -1.0732, 3.2741], [ 3.3161, 0.0704, 5.0187, -0.4079, -4.3126, 4.8744], [ 0.8223, 3.9445, 3.2168, -0.2400, 3.4117, 1.7780]]) """ if isinstance(dims, (list, tuple)) or \ (isinstance(dims, torch.Tensor) and dims.numel() > 1): dims_a, dims_b = dims else: if isinstance(dims, torch.Tensor): dims = dims.item() dims_a = list(range(-dims, 0)) dims_b = list(range(dims)) return torch._C._VariableFunctions.tensordot(a, b, dims_a, dims_b)
[docs]def cartesian_prod(*tensors): """Do cartesian product of the given sequence of tensors. The behavior is similar to python's itertools.product. Arguments: *tensors: any number of 1 dimensional tensors. Returns: Tensor: A tensor equivalent to converting all the input tensors into lists, do itertools.product on these lists, and finally convert the resulting list into tensor. Example:: >>> a = [1, 2, 3] >>> b = [4, 5] >>> list(itertools.product(a, b)) [(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)] >>> tensor_a = torch.tensor(a) >>> tensor_b = torch.tensor(b) >>> torch.cartesian_prod(tensor_a, tensor_b) tensor([[1, 4], [1, 5], [2, 4], [2, 5], [3, 4], [3, 5]]) """ return torch._C._VariableFunctions.cartesian_prod(tensors)
[docs]def norm(input, p="fro", dim=None, keepdim=False, out=None, dtype=None): r"""Returns the matrix norm or vector norm of a given tensor. Args: input (Tensor): the input tensor p (int, float, inf, -inf, 'fro', 'nuc', optional): the order of norm. Default: 'fro' The following norms can be calculated: ===== ============================ ========================== ord matrix norm vector norm ===== ============================ ========================== None Frobenius norm 2-norm 'fro' Frobenius norm -- 'nuc' nuclear norm -- Other as vec norm when dim is None sum(abs(x)**ord)**(1./ord) ===== ============================ ========================== dim (int, 2-tuple of ints, 2-list of ints, optional): If it is an int, vector norm will be calculated, if it is 2-tuple of ints, matrix norm will be calculated. If the value is None, matrix norm will be calculated when the input tensor only has two dimensions, vector norm will be calculated when the input tensor only has one dimension. If the input tensor has more than two dimensions, the vector norm will be applied to last dimension. keepdim (bool, optional): whether the output tensors have :attr:dim retained or not. Ignored if :attr:dim = None and :attr:out = None. Default: False out (Tensor, optional): the output tensor. Ignored if :attr:dim = None and :attr:out = None. dtype (:class:torch.dtype, optional): the desired data type of returned tensor. If specified, the input tensor is casted to :attr:'dtype' while performing the operation. Default: None. Example:: >>> import torch >>> a = torch.arange(9, dtype= torch.float) - 4 >>> b = a.reshape((3, 3)) >>> torch.norm(a) tensor(7.7460) >>> torch.norm(b) tensor(7.7460) >>> torch.norm(a, float('inf')) tensor(4.) >>> torch.norm(b, float('inf')) tensor(4.) >>> c = torch.tensor([[ 1, 2, 3],[-1, 1, 4]] , dtype= torch.float) >>> torch.norm(c, dim=0) tensor([1.4142, 2.2361, 5.0000]) >>> torch.norm(c, dim=1) tensor([3.7417, 4.2426]) >>> torch.norm(c, p=1, dim=1) tensor([6., 6.]) >>> d = torch.arange(8, dtype= torch.float).reshape(2,2,2) >>> torch.norm(d, dim=(1,2)) tensor([ 3.7417, 11.2250]) >>> torch.norm(d[0, :, :]), torch.norm(d[1, :, :]) (tensor(3.7417), tensor(11.2250)) """ ndim = input.dim() # catch default case if dim is None and out is None and dtype is None: if p == "fro": return torch._C._VariableFunctions.frobenius_norm(input) elif p != "nuc": return torch._C._VariableFunctions.norm(input, p) if p == "fro": if dtype is not None: raise ValueError("dtype argument is not supported in frobenius norm") if dim is None: dim = tuple(range(ndim)) if out is None: return torch._C._VariableFunctions.frobenius_norm(input, dim, keepdim=keepdim) return torch._C._VariableFunctions.frobenius_norm(input, dim, keepdim=keepdim, out=out) elif p == "nuc": if dtype is not None: raise ValueError("dtype argument is not supported in nuclear norm") if dim is None: if out is None: return torch._C._VariableFunctions.nuclear_norm(input, keepdim=keepdim) return torch._C._VariableFunctions.nuclear_norm(input, keepdim=keepdim, out=out) return torch._C._VariableFunctions.nuclear_norm(input, dim, keepdim=keepdim, out=out) else: if dim is None: dim = tuple(range(ndim)) if out is None and dtype is None: return torch._C._VariableFunctions.norm(input, p, dim, keepdim=keepdim) elif out is None: return torch._C._VariableFunctions.norm(input, p, dim, keepdim=keepdim, dtype=dtype) elif dtype is None: return torch._C._VariableFunctions.norm(input, p, dim, keepdim=keepdim, out=out) return torch._C._VariableFunctions.norm(input, p, dim, keepdim=keepdim, dtype=dtype, out=out)
[docs]def chain_matmul(*matrices): r"""Returns the matrix product of the :math:N 2-D tensors. This product is efficiently computed using the matrix chain order algorithm which selects the order in which incurs the lowest cost in terms of arithmetic operations ([CLRS]_). Note that since this is a function to compute the product, :math:N needs to be greater than or equal to 2; if equal to 2 then a trivial matrix-matrix product is returned. If :math:N is 1, then this is a no-op - the original matrix is returned as is. Args: matrices (Tensors...): a sequence of 2 or more 2-D tensors whose product is to be determined. Returns: Tensor: if the :math:i^{th} tensor was of dimensions :math:p_{i} \times p_{i + 1}, then the product would be of dimensions :math:p_{1} \times p_{N + 1}. Example:: >>> a = torch.randn(3, 4) >>> b = torch.randn(4, 5) >>> c = torch.randn(5, 6) >>> d = torch.randn(6, 7) >>> torch.chain_matmul(a, b, c, d) tensor([[ -2.3375, -3.9790, -4.1119, -6.6577, 9.5609, -11.5095, -3.2614], [ 21.4038, 3.3378, -8.4982, -5.2457, -10.2561, -2.4684, 2.7163], [ -0.9647, -5.8917, -2.3213, -5.2284, 12.8615, -12.2816, -2.5095]]) .. _[CLRS]: https://mitpress.mit.edu/books/introduction-algorithms-third-edition """ return torch._C._VariableFunctions.chain_matmul(matrices)
[docs]def lu(A, pivot=True, get_infos=False, out=None): r"""Computes the LU factorization of a square matrix or batches of square matrices :attr:A. Returns a tuple containing the LU factorization and pivots of :attr:A. Pivoting is done if :attr:pivot is set to True. .. note:: The pivots returned by the function are 1-indexed. If :attr:pivot is False, then the returned pivots is a tensor filled with zeros of the appropriate size. .. note:: LU factorization with :attr:pivot = False is not available for CPU, and attempting to do so will throw an error. However, LU factorization with :attr:pivot = False is available for CUDA. .. note:: This function does not check if the factorization was successful or not if :attr:get_infos is True since the status of the factorization is present in the third element of the return tuple. Arguments: A (Tensor): the tensor to factor of size :math:(*, m, m) pivot (bool, optional): controls whether pivoting is done. Default: True get_infos (bool, optional): if set to True, returns an info IntTensor. Default: False out (tuple, optional): optional output tuple. If :attr:get_infos is True, then the elements in the tuple are Tensor, IntTensor, and IntTensor. If :attr:get_infos is False, then the elements in the tuple are Tensor, IntTensor. Default: None Returns: (Tensor, IntTensor, IntTensor (optional)): A tuple of tensors containing - **factorization** (*Tensor*): the factorization of size :math:(*, m, m) - **pivots** (*IntTensor*): the pivots of size :math:(*, m) - **infos** (*IntTensor*, *optional*): if :attr:get_infos is True, this is a tensor of size :math:(*) where non-zero values indicate whether factorization for the matrix or each minibatch has succeeded or failed Example:: >>> A = torch.randn(2, 3, 3) >>> A_LU, pivots = torch.lu(A) >>> A_LU tensor([[[ 1.3506, 2.5558, -0.0816], [ 0.1684, 1.1551, 0.1940], [ 0.1193, 0.6189, -0.5497]], [[ 0.4526, 1.2526, -0.3285], [-0.7988, 0.7175, -0.9701], [ 0.2634, -0.9255, -0.3459]]]) >>> pivots tensor([[ 3, 3, 3], [ 3, 3, 3]], dtype=torch.int32) >>> A_LU, pivots, info = torch.lu(A, get_infos=True) >>> if info.nonzero().size(0) == 0: ... print('LU factorization succeeded for all samples!') LU factorization succeeded for all samples! """ # If get_infos is True, then we don't need to check for errors and vice versa result = torch._lu_with_info(A, pivot=pivot, check_errors=(not get_infos)) if out is not None: if not isinstance(out, (tuple, list)): raise TypeError("argument 'out' must be tuple of Tensors, not {}" .format(type(out).__name__)) if len(out) - int(get_infos) != 2: raise TypeError("expected tuple of {} elements but got {}" .format(2 + int(get_infos), len(out))) return (out[i].resize_as_(result[i]).copy_(result[i]) for i in range(len(out))) if get_infos: return result # A_LU, pivots, infos else: return result[0], result[1] # A_LU, pivots
[docs]def gels(input, A, out=None): r"""Computes the solution to the least squares and least norm problems for a full rank matrix :math:A of size :math:(m \times n) and a matrix :math:B of size :math:(m \times k). For more information regarding :func:torch.gels, please check :func:torch.lstsq. .. warning:: :func:torch.gels is deprecated in favour of :func:torch.lstsq and will be removed in the next release. Please use :func:torch.lstsq instead. """ warnings.warn("torch.gels is deprecated in favour of torch.lstsq and will be removed in " "the next release. Please use torch.lstsq instead.", stacklevel=2) return torch.lstsq(input, A, out=out)