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

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

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

Applies a 1D transposed convolution operator over an input signal composed of several input planes, sometimes also called "deconvolution".

Applies a 2D transposed convolution operator over an input image composed of several input planes, sometimes also called "deconvolution".

Applies a 3D transposed convolution operator over an input image composed of several input planes, sometimes also called "deconvolution"

Extract sliding local blocks from a batched input tensor.

Combine an array of sliding local blocks into a large containing tensor.

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

Applies 2D average-pooling operation in $kH \times kW$ regions by step size $sH \times sW$ steps.

Applies 3D average-pooling operation in $kT \times kH \times kW$ regions by step size $sT \times sH \times sW$ steps.

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.

Compute a partial inverse of MaxPool1d.

Compute a partial inverse of MaxPool2d.

Compute a partial inverse of MaxPool3d.

Apply a 1D power-average pooling over an input signal composed of several input planes.

Apply a 2D power-average pooling over an input signal composed of several input planes.

Apply a 3D power-average pooling over an input signal composed of several input planes.

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.

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

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

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

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

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

scaled_dot_product_attention(query, key, value, attn_mask=None, dropout_p=0.0,

Apply a threshold to each element of the input Tensor.

In-place version of threshold().

Applies the rectified linear unit function element-wise.

In-place version of relu().

Applies the HardTanh function element-wise.

In-place version of hardtanh().

Apply hardswish function, element-wise.

Applies the element-wise function $\text{ReLU6}(x) = \min(\max(0,x), 6)$.

Apply the Exponential Linear Unit (ELU) function element-wise.

In-place version of elu().

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

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

Applies element-wise, $\text{LeakyReLU}(x) = \max(0, x) + \text{negative\_slope} * \min(0, x)$

In-place version of leaky_relu().

Applies element-wise the function $\text{PReLU}(x) = \max(0,x) + \text{weight} * \min(0,x)$ where weight is a learnable parameter.

Randomized leaky ReLU.

In-place version of rrelu().

The gated linear unit.

When the approximate argument is 'none', it applies element-wise the function $\text{GELU}(x) = x * \Phi(x)$

Applies element-wise $\text{LogSigmoid}(x_i) = \log \left(\frac{1}{1 + \exp(-x_i)}\right)$

Applies the hard shrinkage function element-wise

Applies element-wise, $\text{Tanhshrink}(x) = x - \text{Tanh}(x)$

Applies element-wise, the function $\text{SoftSign}(x) = \frac{x}{1 + |x|}$

Applies element-wise, the function $\text{Softplus}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x))$.

Apply a softmin function.

Apply a softmax function.

Applies the soft shrinkage function elementwise

Sample from the Gumbel-Softmax distribution (Link 1 Link 2) and optionally discretize.

Apply a softmax followed by a logarithm.

Applies element-wise, $\text{Tanh}(x) = \tanh(x) = \frac{\exp(x) - \exp(-x)}{\exp(x) + \exp(-x)}$

Applies the element-wise function $\text{Sigmoid}(x) = \frac{1}{1 + \exp(-x)}$

Apply the Hardsigmoid function element-wise.

Apply the Sigmoid Linear Unit (SiLU) function, element-wise.

Apply the Mish function, element-wise.

Apply Batch Normalization for each channel across a batch of data.

Apply Group Normalization for last certain number of dimensions.

Apply Instance Normalization independently for each channel in every data sample within a batch.

Apply Layer Normalization for last certain number of dimensions.

Apply local response normalization over an input signal.

Apply Root Mean Square Layer Normalization.

Perform $L_p$ normalization of inputs over specified dimension.

Applies a linear transformation to the incoming data: $y = xA^T + b$.

Applies a bilinear transformation to the incoming data: $y = x_1^T A x_2 + b$

During training, randomly zeroes some elements of the input tensor with probability p.

Apply alpha dropout to the input.

Randomly masks out entire channels (a channel is a feature map).

Randomly zero out entire channels (a channel is a 1D feature map).

Randomly zero out entire channels (a channel is a 2D feature map).

Randomly zero out entire channels (a channel is a 3D feature map).

Generate a simple lookup table that looks up embeddings in a fixed dictionary and size.

Compute sums, means or maxes of bags of embeddings.

Takes LongTensor with index values of shape (*) and returns a tensor of shape (*, num_classes) that have zeros everywhere except where the index of last dimension matches the corresponding value of the input tensor, in which case it will be 1.

See torch.nn.PairwiseDistance for details

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

Computes the p-norm distance between every pair of row vectors in the input.

Compute Binary Cross Entropy between the target and input probabilities.

Compute Binary Cross Entropy between target and input logits.

Compute the Poisson negative log likelihood loss.

Compute the cosine embedding loss.

Compute the cross entropy loss between input logits and target.

Compute the Connectionist Temporal Classification loss.

Compute the Gaussian negative log likelihood loss.

Compute the hinge embedding loss.

Compute the KL Divergence loss.

Compute the L1 loss, with optional weighting.

Compute the element-wise mean squared error, with optional weighting.

Compute the margin ranking loss.

Compute the multilabel margin loss.

Compute the multilabel soft margin loss.

Compute the multi margin loss, with optional weighting.

Compute the negative log likelihood loss.

Compute the Huber loss, with optional weighting.

Compute the Smooth L1 loss.

Compute the soft margin loss.

Compute the triplet loss between given input tensors and a margin greater than 0.

Compute the triplet margin loss for input tensors using a custom distance function.

Rearranges elements in a tensor of shape $(*, C \times r^2, H, W)$ to a tensor of shape $(*, C, H \times r, W \times r)$, where r is the upscale_factor.

Reverses the PixelShuffle operation by rearranging elements in a tensor of shape $(*, C, H \times r, W \times r)$ to a tensor of shape $(*, C \times r^2, H, W)$, where r is the downscale_factor.

Pads tensor.

Down/up samples the input.

Upsample input.

Upsamples the input, using nearest neighbours' pixel values.

Upsamples the input, using bilinear upsampling.

Compute grid sample.

Generate 2D or 3D flow field (sampling grid), given a batch of affine matrices theta.

torch.nn.parallel.data_parallel

Evaluate module(input) in parallel across the GPUs given in device_ids.