Returns the mean value of all elements in the input tensor.

Returns the standard deviation of all elements in the input tensor.

Returns the variance of all elements in the input tensor.

Returns the sum of all elements in the input tensor.

Computes the element-wise absolute value of the given input tensor.

Computes the fractional portion of each element in input. out_i = input_i - (floor . abs) input_i * (sign input_i)

Returns the indices of the maximum value of all elements in the input tensor.

Each element of the tensor other added to each element of the tensor input. The resulting tensor is returned.

Multiplies each element of the tensor other to each element of the input tensor and returns a new resulting tensor.

Element wise subtraction of other tensor from input tensor and returns a new resulting tensor

Element wise division of input tensor by other tensor and returns a new resulting tensor

ceil

floor

min

max

median

Adds each element of the input input with the scalar and returns a new resulting tensor.

Subtracts each element of the input input with the scalar and returns a new resulting tensor.

Multiplies each element of the input input with the scalar and returns a new resulting tensor.

Divides each element of the input input with the scalar and returns a new resulting tensor.

Matrix product of two tensors.

The behavior depends on the dimensionality of the tensors as follows:

If both tensors are 1-dimensional, the dot product (scalar) is returned. If both arguments are 2-dimensional, the matrix-matrix product is returned. If the first argument is 1-dimensional and the second argument is 2-dimensional, a 1 is prepended to its dimension for the purpose of the matrix multiply. After the matrix multiply, the prepended dimension is removed. If the first argument is 2-dimensional and the second argument is 1-dimensional, the matrix-vector product is returned. If both arguments are at least 1-dimensional and at least one argument is N-dimensional (where N > 2), then a batched matrix multiply is returned. If the first argument is 1-dimensional, a 1 is prepended to its dimension for the purpose of the batched matrix multiply and removed after. If the second argument is 1-dimensional, a 1 is appended to its dimension for the purpose of the batched matrix multiple and removed after. The non-matrix (i.e. batch) dimensions are broadcasted (and thus must be broadcastable). For example, if input is a (j times 1 times n times m)(j×1×n×m) tensor and other is a (k times m times p)(k×m×p) tensor, out will be an (j times k times n times p)(j×k×n×p) tensor.

A simple lookup table that looks up embeddings in a fixed dictionary and size. This module is often used to retrieve word embeddings using indices. The input to the module is a list of indices, and the embedding matrix, and the output is the corresponding word embeddings.

A one hot encoding of the given input. The encoding is based on the given number of classes.

Computes the error function of each element

Computes the complementary error function of each element of input

Computes the inverse error function of each element of input. The inverse error function is defined in the range (-1, 1)(−1,1) as: erfinv(erf(x)) = x

Computes the logarithm of the gamma function on input.

Computes the logarithmic derivative of the gamma function on input.

Computes the nth derivative of the digamma function on input. n geq 0n≥0 is called the order of the polygamma function.

Computes the multivariate log-gamma function with dimension pp element-wise. All elements must be greater than (p-1)/2, otherwise an error would be thrown.

Returns a new tensor with the exponential of the elements of the input tensor input.

Returns a new tensor with the natural logarithm of (1 + input).

Returns a new tensor with the logarithm to the base 2 of the elements of input.

Returns a new tensor with the natural logarithm of the elements of input.

Returns a new tensor with the logarithm to the base 10 of the elements of input.

Takes the power of each element in input with exponent and returns a tensor with the result.

Takes the power of each element in input with exponent and returns a tensor with the result. Exponent is a tensor with the same number of elements as input.

Applies the rectified linear unit function element-wise.

Applies Exponential linear unit function element-wise, with alpha input, \(\text{ELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x) - 1))\)

Applies exponential linear unit function element wise with default alpha value = 1

Applies element-wise, \(\text{SELU}(x) = scale * (\max(0,x) + \min(0, \alpha * (\exp(x) - 1))\) , with α=1.6732632423543772848170429916717 and scale=1.0507009873554804934193349852946.

Applies element-wise, \(\text{CELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x/\alpha) - 1))\).

Applies the element-wise function sigmoid.

Applies a softmax function. It is applied to all slices along dim, and will re-scale them so that the elements lie in the range [0, 1] and sum to 1.

Applies a softmax followed by a logarithm. While mathematically equivalent to log(softmax(x)), doing these two operations separately is slower, and numerically unstable. This function uses an alternative formulation to compute the output and gradient correctly.

Thresholds each element of the input Tensor.

Returns a new tensor with the sine of the elements of input.

Returns a new tensor with the cos of the elements of input.

Returns a new tensor with the tangent of the elements of input.

Returns a new tensor with the hyperbolic sine of the elements of input.

Returns a new tensor with the hyperbolic cosine of the elements of input.

Returns a new tensor with the hyperbolic tangent of the elements of input.

Returns a new tensor with the square-root of the elements of input.

Computes input > other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument.

Computes input < other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument.

Computes input >= other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument.

Computes input <= other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument.

Computes input == other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument.

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.

Returns a new 1-D tensor which indexes the input tensor according to the boolean mask mask which is a BoolTensor. The shapes of the mask tensor and the input tensor don’t need to match, but they must be broadcastable.

Returns a tuple of 1-D tensors, one for each dimension in input, each containing the indices (in that dimension) of all non-zero elements of input .

Computes input /= other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument.

Casting to given Dtype, where Dtype is an object that represents the data type of a tensor in hasktorch.

squeezeAll

squeezeDim

Returns a tuple (values, indices) where values is the cumulative maximum of elements of input in the dimension dim. And indices is the index location of each maximum value found in the dimension dim.

Returns a tuple (values, indices) where values is the cumulative minimum of elements of input in the dimension dim. And indices is the index location of each maximum value found in the dimension dim.

Returns the cumulative product of elements of input in the dimension dim. For example, if input is a vector of size N, the result will also be a vector of size N, with elements.

Returns the cumulative sum of elements of input in the dimension dim. For example, if input is a vector of size N, the result will also be a vector of size N, with elements.

Function that measures the Binary Cross Entropy between the target and the output.

Binary Cross Entropy with weights defaulted to 1.0 & reduction defaulted to ReduceMean

This loss combines a Sigmoid layer and the BCELoss in one single class. This version is more numerically stable than using a plain Sigmoid followed by a BCELoss as, by combining the operations into one layer, we take advantage of the log-sum-exp trick for numerical stability.

Creates a criterion that measures the mean squared error (squared L2 norm) between each element in the input and target.

The negative log likelihood loss.

Returns cosine similarity between x1 and x2, computed along dim.

Returns cosine similarity with defaulted options.

The Connectionist Temporal Classification loss. Calculates loss between a continuous (unsegmented) time series and a target sequence. CTCLoss sums over the probability of possible alignments of input to target, producing a loss value which is differentiable with respect to each input node. The alignment of input to target is assumed to be “many-to-one”, which limits the length of the target sequence such that it must be leq≤ the input length.

Returns CTC loss with defaulted options.

Returns the p-norm of (input - other) The shapes of input and other must be broadcastable.

Measures the loss given an input tensor xx and a labels tensor yy (containing 1 or -1). This is usually used for measuring whether two inputs are similar or dissimilar, e.g. using the L1 pairwise distance as xx, and is typically used for learning nonlinear embeddings or semi-supervised learning.

The 2D negative log likelihood loss

Creates a criterion that optimizes a multi-class classification hinge loss (margin-based loss) between input \(x\) (a 2D mini-batch Tensor) and output \(y\) (which is a 1D tensor of target class indices)

Creates a criterion that optimizes a multi-label one-versus-all loss based on max-entropy, between input \(x\) and target \(y\) of size \((N,C)\) .

The Kullback-Leibler divergence Loss KL divergence is a useful distance measure for continuous distributions and is often useful when performing direct regression over the space of (discretely sampled) continuous output distributions. As with NLLLoss, the input given is expected to contain log-probabilities and is not restricted to a 2D Tensor. The targets are interpreted as probabilities by default, but could be considered as log-probabilities with log_target set to True. This criterion expects a target Tensor of the same size as the input Tensor.

Creates a criterion that uses a squared term if the absolute element-wise error falls below 1 and an L1 term otherwise. It is less sensitive to outliers than the MSELoss and in some cases prevents exploding gradients (e.g. see Fast R-CNN paper by Ross Girshick). Also known as the Huber loss.

Creates a criterion that optimizes a two-class classification logistic loss between input tensor \(x\) and target tensor \(y\) (containing 1 or -1).

Applies a 1D adaptive max pooling over an input signal composed of several input planes.

Applies a 2D adaptive max pooling over an input signal composed of several input planes.

Applies a 3D adaptive max pooling over an input signal composed of several input planes

maxPool1dWithIndices

Applies a 1D max pooling over an input signal composed of several input planes.

Applies a 2D max pooling over an input signal composed of several input planes.

Applies a 3D max pooling over an input signal composed of several input planes.

Calculates resulting dimensions from a 2d maxpool operation see https://pytorch.org/docs/master/generated/torch.nn.MaxPool2d.html#torch.nn.MaxPool2d

Applies a 1D average pooling over an input signal composed of several input planes.

Applies a 1D adaptive average pooling over an input signal composed of several input planes.

Applies a 2D adaptive average pooling over an input signal composed of several input planes.

Applies a 3D adaptive average pooling over an input signal composed of several input planes.

Takes the inverse of the square matrix input. input can be batches of 2D square tensors, in which case this function would return a tensor composed of individual inverses.

Solves a system of equations with a triangular coefficient matrix AA and multiple right-hand sides bb

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).

Computes the eigenvalues and eigenvectors of a real square matrix

This function returns a namedtuple (U, S, V) which is the singular value decomposition of a input real matrix or batches of real matrices input such that input = U * diag(S) * V^T

Computes the Cholesky decomposition of a symmetric positive-definite matrix AA or for batches of symmetric positive-definite matrices.

Solves a linear system of equations with a positive semidefinite matrix to be inverted given its Cholesky factor matrix uu .

This function returns the solution to the system of linear equations represented by AX = BAX=B and the LU factorization of A, in order as a namedtuple solution, LU. LU contains L and U factors for LU factorization of A

Solves a linear system of equations with a positive semidefinite matrix to be inverted given its Cholesky factor matrix uu .

This is a low-level function for calling LAPACK directly. This function returns a namedtuple (a, tau) as defined in LAPACK documentation for geqrf.

Computes the orthogonal matrix Q of a QR factorization, from the (input, input2) tuple returned by geqrf function. This directly calls the underlying LAPACK function ?orgqr. See LAPACK documentation for orgqr for further details.

Multiplies mat (given by input3) by the orthogonal Q matrix of the QR factorization formed by torch.geqrf() that is represented by (a, tau) (given by (input, input2)). This directly calls the underlying LAPACK function ?ormqr. See LAPACK documentation for ormqr for further details.

Returns the LU solve of the linear system Ax = bAx=b using the partially pivoted LU factorization of A from torch.lu().

During training, randomly zeroes some of the elements of the input tensor with probability p using samples from a Bernoulli distribution.

Applies alpha dropout to the input.

Computes the bitwise NOT of the given input tensor. The input tensor must be of integral or Boolean types. For bool tensors, it computes the logical NOT.

Computes the element-wise logical NOT of the given input tensor. If not specified, the output tensor will have the bool dtype. If the input tensor is not a bool tensor, zeros are treated as False and non-zeros are treated as True.

Concatenates the given sequence of seq tensors in the given dimension. All tensors must either have the same shape (except in the concatenating dimension) or be empty.

Puts values from the tensor value into the input tensor (out-of-place) using the indices specified in indices (which is a tuple of Tensors). The expression tensor.index_put_(indices, value) is equivalent to tensor[indices] = value. If accumulate is True, the elements in value are added to self. If accumulate is False, the behavior is undefined if indices contain duplicate elements.

Splits a tensor into a specific number of chunks. Last chunk will be smaller if the tensor size along the given dimension dim is not divisible by chunks.

Clamp all elements in input into the range [ min, max ] and return a resulting tensor.

Clamps all elements in input to be smaller or equal max.

Clamps all elements in input to be larger or equal min.

Pads the input tensor boundaries with a constant value.

Applies a 1D convolution over an input signal composed of several input planes.

Applies a 2D convolution over an input signal composed of several input planes.

Applies a 3D convolution over an input signal composed of several input planes.

Applies a 1D transposed convolution over an input signal composed of several input planes

Applies a 2D transposed convolution over an input signal composed of several input planes

Applies a 3D transposed convolution over an input signal composed of several input planes

Returns a new tensor with the signs of the elements of input

Returns a tensor that is a transposed version of input. The given dimensions dim0 and dim1 are swapped.

transpose special case for a 2D tensor

Returns a tensor with the elements of input as the diagonal. The second argument controls which diagonal to consider: If Int = 0, it is the main diagonal. If Int > 0, it is above the main diagonal. If Int < 0, it is below the main diagonal.

If input is a vector (1-D tensor), then returns a 2-D square tensor with the elements of input as the diagonal. If input is a tensor with more than one dimension, then returns a 2-D tensor with diagonal elements equal to a flattened input. The argument offset controls which diagonal to consider: If offset = 0, it is the main diagonal. If offset > 0, it is above the main diagonal. If offset < 0, it is below the main diagonal.

Returns a partial view of input with the its diagonal elements with respect to dim1 and dim2 appended as a dimension at the end of the shape. Applying diagEmbed to the output of this function with the same arguments yields a diagonal matrix with the diagonal entries of the input. However, diagEmbed has different default dimensions, so those need to be explicitly specified.

Returns True if all elements in the tensor are True, False otherwise.

Returns True if any elements in the tensor are True, False otherwise.

Returns True if all elements in each row of the tensor in the given dimension dim are True, False otherwise. If keepdim is True, the output tensor is of the same size as input except in the dimension dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 fewer dimension than input.

Returns True if any elements in each row of the tensor in the given dimension dim are True, False otherwise. If keepdim is True, the output tensor is of the same size as input except in the dimension dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 fewer dimension than input.

Permute the dimensions of this tensor.

expand TODO: figure out what the implicit boolean value does

flatten

flattenAll

A long short-term memory (LSTM) cell.

A gated recurrent unit (GRU) cell

An Elman RNN cell with tanh non-linearity

An Elman RNN cell with ReLU non-linearity

A quantized long short-term memory (LSTM) cell.

A quantized long gated recurrent unit (GRU) cell.