# tensorplay.nn.functional API

Source: https://www.tensorplay.cn/docs/api/tensorplay.nn.functional.html

## Functions 137

[#](#api-tensorplay.nn.functional.adaptive_avg_pool1d)

### adaptive_avg_pool1d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.adaptive_avg_pool1d.html)

```python
tensorplay.nn.functional.adaptive_avg_pool1d(input, output_size) → Tensor
```

[#](#api-tensorplay.nn.functional.adaptive_avg_pool2d)

### adaptive_avg_pool2d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.adaptive_avg_pool2d.html)

```python
tensorplay.nn.functional.adaptive_avg_pool2d(input, output_size)
```

[#](#api-tensorplay.nn.functional.adaptive_avg_pool3d)

### adaptive_avg_pool3d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.adaptive_avg_pool3d.html)

```python
tensorplay.nn.functional.adaptive_avg_pool3d(input: Tensor, output_size) → Tensor
```

Apply a 3D adaptive average pooling over an input signal.

[#](#api-tensorplay.nn.functional.adaptive_max_pool1d_with_indices)

### adaptive_max_pool1d_with_indices

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.adaptive_max_pool1d_with_indices.html)

```python
tensorplay.nn.functional.adaptive_max_pool1d_with_indices(input: Tensor, output_size, return_indices: bool = True)
```

Applies a 1D adaptive max pooling over an input signal, returning
(output, indices).

See AdaptiveMaxPool1d for details.

[#](#api-tensorplay.nn.functional.adaptive_max_pool1d)

### adaptive_max_pool1d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.adaptive_max_pool1d.html)

```python
tensorplay.nn.functional.adaptive_max_pool1d(input, output_size) → Tensor
```

[#](#api-tensorplay.nn.functional.adaptive_max_pool2d_with_indices)

### adaptive_max_pool2d_with_indices

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.adaptive_max_pool2d_with_indices.html)

```python
tensorplay.nn.functional.adaptive_max_pool2d_with_indices(input: Tensor, output_size, return_indices: bool = True)
```

Applies a 2D adaptive max pooling over an input signal composed of
several input planes, returning (output, indices).

See AdaptiveMaxPool2d for details.

[#](#api-tensorplay.nn.functional.adaptive_max_pool2d)

### adaptive_max_pool2d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.adaptive_max_pool2d.html)

```python
tensorplay.nn.functional.adaptive_max_pool2d(input, output_size)
```

[#](#api-tensorplay.nn.functional.adaptive_max_pool3d_with_indices)

### adaptive_max_pool3d_with_indices

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.adaptive_max_pool3d_with_indices.html)

```python
tensorplay.nn.functional.adaptive_max_pool3d_with_indices(input: Tensor, output_size, return_indices: bool = True)
```

Applies a 3D adaptive max pooling over an input signal, returning
(output, indices).

See AdaptiveMaxPool3d for details.

[#](#api-tensorplay.nn.functional.adaptive_max_pool3d)

### adaptive_max_pool3d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.adaptive_max_pool3d.html)

```python
tensorplay.nn.functional.adaptive_max_pool3d(input, output_size, return_indices=False)
```

Applies a 3D adaptive max pooling over an input signal composed of several
input planes. Input shape (N, C, D, H, W) or unbatched (C, D, H, W).

See AdaptiveMaxPool3d for details.

[#](#api-tensorplay.nn.functional.affine_grid)

### affine_grid

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.affine_grid.html)

```python
tensorplay.nn.functional.affine_grid(theta: Tensor, size, align_corners=None) → Tensor
```

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

[#](#api-tensorplay.nn.functional.alpha_dropout)

### alpha_dropout

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.alpha_dropout.html)

```python
tensorplay.nn.functional.alpha_dropout(input, p=0.5, training=True, inplace=False)
```

[#](#api-tensorplay.nn.functional.avg_pool1d)

### avg_pool1d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.avg_pool1d.html)

```python
tensorplay.nn.functional.avg_pool1d(input: Tensor, kernel_size, stride=None, padding=0, ceil_mode: bool = False, count_include_pad: bool = True, divisor_override=None) → Tensor
```

avg_pool1d(input, kernel_size, stride=None, padding=0, ceil_mode=False,
count_include_pad=True, divisor_override=None) -> Tensor

Applies a 1D average pooling over an input signal composed of several
input planes. Input shape (N, C, L) or unbatched (C, L).

[#](#api-tensorplay.nn.functional.avg_pool2d)

### avg_pool2d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.avg_pool2d.html)

```python
tensorplay.nn.functional.avg_pool2d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None)
```

[#](#api-tensorplay.nn.functional.avg_pool3d)

### avg_pool3d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.avg_pool3d.html)

```python
tensorplay.nn.functional.avg_pool3d(input: Tensor, kernel_size, stride=None, padding=0, ceil_mode: bool = False, count_include_pad: bool = True, divisor_override=None) → Tensor
```

avg_pool3d(input, kernel_size, stride=None, padding=0, ceil_mode=False,
count_include_pad=True, divisor_override=None) -> Tensor

Applies a 3D average pooling over an input signal composed of several
input planes. Input shape (N, C, D, H, W) or unbatched (C, D, H, W).

[#](#api-tensorplay.nn.functional.batch_norm)

### batch_norm

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.batch_norm.html)

```python
tensorplay.nn.functional.batch_norm(input, running_mean=None, running_var=None, weight=None, bias=None, training=False, momentum=0.1, eps=1e-05)
```

[#](#api-tensorplay.nn.functional.bilinear)

### bilinear

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.bilinear.html)

```python
tensorplay.nn.functional.bilinear(input1, input2, weight, bias=None)
```

[#](#api-tensorplay.nn.functional.binary_cross_entropy_with_logits)

### binary_cross_entropy_with_logits

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.binary_cross_entropy_with_logits.html)

```python
tensorplay.nn.functional.binary_cross_entropy_with_logits(input: Tensor, target: Tensor, weight: Tensor | None = None, size_average=None, reduce=None, reduction: str = 'mean', pos_weight: Tensor | None = None) → Tensor
```

Compute Binary Cross Entropy between target and input logits.

optionally rescaled by weight, then reduced.
See BCEWithLogitsLoss for details.

[#](#api-tensorplay.nn.functional.binary_cross_entropy)

### binary_cross_entropy

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.binary_cross_entropy.html)

```python
tensorplay.nn.functional.binary_cross_entropy(input: Tensor, target: Tensor, weight: Tensor | None = None, size_average=None, reduce=None, reduction: str = 'mean') → Tensor
```

Compute Binary Cross Entropy between the target and input probabilities.

See BCELoss for details.

[#](#api-tensorplay.nn.functional.celu_)

### celu_

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.celu_.html)

```python
tensorplay.nn.functional.celu_(input, alpha=1.) → Tensor
```

In-place version of [celu()](/docs/generated/tensorplay.nn.functional.celu.html#tensorplay.nn.functional.celu).

[#](#api-tensorplay.nn.functional.celu)

### celu

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.celu.html)

```python
tensorplay.nn.functional.celu(input, alpha=1, inplace=False) → Tensor
```

[#](#api-tensorplay.nn.functional.channel_shuffle)

### channel_shuffle

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.channel_shuffle.html)

```python
tensorplay.nn.functional.channel_shuffle(input: Tensor, groups: int) → Tensor
```

Divide the channels in a tensor into g groups and rearrange them
as in ShuffleNet: (*, C, H, W) -> (*, C, H, W) with channels
interleaved across groups.

[#](#api-tensorplay.nn.functional.conv_tbc)

### conv_tbc

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.conv_tbc.html)

```python
tensorplay.nn.functional.conv_tbc(input, weight, bias=None, pad=0)
```

Applies a 1D convolution over an input of shape (T, B, C) along the
(kernel_width, in_channels, out_channels); the math is a standard
cross-channel conv1d after permuting to (B, C, T).

[#](#api-tensorplay.nn.functional.conv_transpose1d)

### conv_transpose1d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.conv_transpose1d.html)

```python
tensorplay.nn.functional.conv_transpose1d(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1)
```

[#](#api-tensorplay.nn.functional.conv_transpose2d)

### conv_transpose2d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.conv_transpose2d.html)

```python
tensorplay.nn.functional.conv_transpose2d(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1)
```

[#](#api-tensorplay.nn.functional.conv_transpose3d)

### conv_transpose3d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.conv_transpose3d.html)

```python
tensorplay.nn.functional.conv_transpose3d(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1)
```

[#](#api-tensorplay.nn.functional.conv1d)

### conv1d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.conv1d.html)

```python
tensorplay.nn.functional.conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)
```

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

See Conv1d for details and output shape.

Parameters:

- input – input tensor of shape $(\text{minibatch} , \text{in\_channels} , iW)$

- weight – filters of shape $(\text{out\_channels} , \frac{\text{in\_channels}}{\text{groups}} , kW)$

- bias – optional bias of shape $(\text{out\_channels})$. Default: None

- stride – the stride of the convolving kernel. Can be a single number or a one-element tuple (sW,). Default: 1

- padding – implicit paddings on both sides of the input. Can be a single number, a one-element tuple (padW,), 'valid' for no padding, or 'same' to keep every output position (unit stride only). Default: 0

- dilation – the spacing between kernel elements. Can be a single number or a one-element tuple (dW,). Default: 1

- groups – split input into groups, $\text{in\_channels}$ should be divisible by the number of groups. Default: 1

Examples:

```
>>> inputs = tp.randn(33, 16, 30)
>>> filters = tp.randn(20, 16, 5)
>>> F.conv1d(inputs, filters)
```

[#](#api-tensorplay.nn.functional.conv2d)

### conv2d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.conv2d.html)

```python
tensorplay.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)
```

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

See Conv2d for details and output shape.

Parameters:

- input – input tensor of shape $(\text{minibatch} , \text{in\_channels} , iH , iW)$

- weight – filters of shape $(\text{out\_channels} , \frac{\text{in\_channels}}{\text{groups}} , kH , kW)$

- bias – optional bias tensor of shape $(\text{out\_channels})$. Default: None

- stride – the stride of the convolving kernel. Can be a single number or a tuple (sH, sW). Default: 1

- padding – implicit paddings on both sides of the input. Can be a single number, a tuple (padH, padW), 'valid' for no padding, or 'same' to keep every output position (unit stride only). Default: 0

- dilation – the spacing between kernel elements. Can be a single number or a tuple (dH, dW). Default: 1

- groups – split input into groups, both $\text{in\_channels}$ and $\text{out\_channels}$ should be divisible by the number of groups. Default: 1

Examples:

```
>>> # With square kernels and equal stride
>>> filters = tp.randn(8, 4, 3, 3)
>>> inputs = tp.randn(1, 4, 5, 5)
>>> F.conv2d(inputs, filters, padding=1)
```

[#](#api-tensorplay.nn.functional.conv3d)

### conv3d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.conv3d.html)

```python
tensorplay.nn.functional.conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)
```

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

See Conv3d for details and output shape.

Parameters:

- input – input tensor of shape $(\text{minibatch} , \text{in\_channels} , iD, iH , iW)$

- weight – filters of shape $(\text{out\_channels} , \frac{\text{in\_channels}}{\text{groups}} , kD, kH , kW)$

- bias – optional bias tensor of shape $(\text{out\_channels})$. Default: None

- stride – the stride of the convolving kernel. Can be a single number or a tuple (sD, sH, sW). Default: 1

- padding – implicit paddings on both sides of the input. Can be a single number, a tuple (padD, padH, padW), 'valid' for no padding, or 'same' to keep every output position (unit stride only). Default: 0

- dilation – the spacing between kernel elements. Can be a single number or a tuple (dD, dH, dW). Default: 1

- groups – split input into groups, both $\text{in\_channels}$ and $\text{out\_channels}$ should be divisible by the number of groups. Default: 1

Examples:

```
>>> # With square kernels and equal stride
>>> filters = tp.randn(8, 4, 3, 3, 3)
>>> inputs = tp.randn(1, 4, 5, 5, 5)
>>> F.conv3d(inputs, filters, padding=1)
```

[#](#api-tensorplay.nn.functional.cosine_embedding_loss)

### cosine_embedding_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.cosine_embedding_loss.html)

```python
tensorplay.nn.functional.cosine_embedding_loss(input1: Tensor, input2: Tensor, target: Tensor, margin: float = 0, size_average=None, reduce=None, reduction: str = 'mean') → Tensor
```

Compute the cosine embedding loss.

See CosineEmbeddingLoss for details.

[#](#api-tensorplay.nn.functional.cosine_similarity)

### cosine_similarity

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.cosine_similarity.html)

```python
tensorplay.nn.functional.cosine_similarity(x1: Tensor, x2: Tensor, dim: int = 1, eps: float = 1e-08) → Tensor
```

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

The inputs are normalized before the dot product, and the per-row norms
are accumulated in a wider dtype (float32 for half-precision inputs,
float64 for float32), so that squaring large values cannot overflow the
accumulator and turn the result into NaN.

[#](#api-tensorplay.nn.functional.cross_entropy)

### cross_entropy

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.cross_entropy.html)

```python
tensorplay.nn.functional.cross_entropy(input, target, weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean', label_smoothing=0.0)
```

Compute the cross entropy loss between input logits and target.

the class-probability path, positive label_smoothing blends the NLL
with a smoothed uniform term, and otherwise this is
nll_loss(log_softmax(input), target) with N-d support.

See CrossEntropyLoss for details.

[#](#api-tensorplay.nn.functional.ctc_loss)

### ctc_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.ctc_loss.html)

```python
tensorplay.nn.functional.ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths, target_lengths, blank: int = 0, reduction: str = 'mean', zero_infinity: bool = False) → Tensor
```

Compute the Connectionist Temporal Classification loss.

(alpha recurrence over the blank-extended target sequence); autograd flows
through log_probs via the composed primitives.

Parameters:

- log_probs – $(T, N, C)$ or $(T, C)$ log-softmax outputs.

- targets – $(N, S)$ or concatenated $(\sum S_n,)$.

- target_lengths (input_lengths /) – $(N,)$ or scalars.

- blank – index of the blank label. Default: 0.

- reduction – 'none' | 'mean' | 'sum'.

- zero_infinity – zero out infinite losses (targets too long for T).

[#](#api-tensorplay.nn.functional.dropout_)

### dropout_

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.dropout_.html)

```python
tensorplay.nn.functional.dropout_(input, p=0.5, training=True)
```

In-place version of [dropout()](/docs/generated/tensorplay.nn.functional.dropout.html#tensorplay.nn.functional.dropout).

[#](#api-tensorplay.nn.functional.dropout)

### dropout

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.dropout.html)

```python
tensorplay.nn.functional.dropout(input, p=0.5, training=True, inplace=False)
```

[#](#api-tensorplay.nn.functional.dropout1d)

### dropout1d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.dropout1d.html)

```python
tensorplay.nn.functional.dropout1d(input: Tensor, p: float = 0.5, training: bool = True, inplace: bool = False) → Tensor
```

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

See Dropout1d for details.

[#](#api-tensorplay.nn.functional.dropout2d)

### dropout2d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.dropout2d.html)

```python
tensorplay.nn.functional.dropout2d(input, p=0.5, training=True, inplace=False)
```

[#](#api-tensorplay.nn.functional.dropout3d)

### dropout3d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.dropout3d.html)

```python
tensorplay.nn.functional.dropout3d(input, p=0.5, training=True, inplace=False)
```

[#](#api-tensorplay.nn.functional.elu_)

### elu_

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.elu_.html)

```python
tensorplay.nn.functional.elu_(input, alpha=1.) → Tensor
```

In-place version of [elu()](/docs/generated/tensorplay.nn.functional.elu.html#tensorplay.nn.functional.elu).

[#](#api-tensorplay.nn.functional.elu)

### elu

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.elu.html)

```python
tensorplay.nn.functional.elu(input, alpha=1, inplace=False) → Tensor
```

[#](#api-tensorplay.nn.functional.embedding_bag)

### embedding_bag

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.embedding_bag.html)

```python
tensorplay.nn.functional.embedding_bag(input: Tensor, weight: Tensor, offsets=None, max_norm=None, norm_type: float = 2, scale_grad_by_freq: bool = False, mode: str = 'mean', sparse: bool = False, per_sample_weights=None, include_last_offset: bool = False, padding_idx=None) → Tensor
```

Compute sums, means or maxes of bags of embeddings.

1-D inputs with offsets (incl. include_last_offset), fixed
length 2-D inputs, per_sample_weights (sum mode), padding_idx
exclusion and max_norm renormalization.
See tensorplay.nn.EmbeddingBag for details.

[#](#api-tensorplay.nn.functional.embedding)

### embedding

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.embedding.html)

```python
tensorplay.nn.functional.embedding(input, weight, padding_idx=None, max_norm=None, norm_type=2.0, scale_grad_by_freq=False, sparse=False)
```

[#](#api-tensorplay.nn.functional.feature_alpha_dropout)

### feature_alpha_dropout

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.feature_alpha_dropout.html)

```python
tensorplay.nn.functional.feature_alpha_dropout(input: Tensor, p: float = 0.5, training: bool = False, inplace: bool = False) → Tensor
```

Randomly masks out entire channels, setting activations to the
negative saturation value of the SELU activation function.

See FeatureAlphaDropout for details.

[#](#api-tensorplay.nn.functional.feature_dropout_)

### feature_dropout_

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.feature_dropout_.html)

```python
tensorplay.nn.functional.feature_dropout_(input, p=0.5, training=True)
```

In-place version of [feature_dropout()](/docs/generated/tensorplay.nn.functional.feature_dropout.html#tensorplay.nn.functional.feature_dropout).

[#](#api-tensorplay.nn.functional.feature_dropout)

### feature_dropout

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.feature_dropout.html)

```python
tensorplay.nn.functional.feature_dropout(input, p=0.5, training=False, inplace=False)
```

Randomly zeroes entire channels (dim 1).

[#](#api-tensorplay.nn.functional.flatten)

### flatten

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.flatten.html)

```python
tensorplay.nn.functional.flatten(input, start_dim=0, end_dim=-1)
```

[#](#api-tensorplay.nn.functional.fold)

### fold

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.fold.html)

```python
tensorplay.nn.functional.fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1)
```

Combine an array of sliding local blocks into a tensor containing

[#](#api-tensorplay.nn.functional.fractional_max_pool2d_with_indices)

### fractional_max_pool2d_with_indices

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.fractional_max_pool2d_with_indices.html)

```python
tensorplay.nn.functional.fractional_max_pool2d_with_indices(input: Tensor, kernel_size, output_size=None, output_ratio=None, return_indices: bool = True, _random_samples=None)
```

Applies 2D fractional max pooling over an input signal composed of
several input planes, returning (output, indices).

The max-pooling operation is applied in $kH \times kW$ regions by a
stochastic step size determined by the target output size.
The number of output features is equal to the number of input planes.

Parameters:

- kernel_size – the size of the window, k or (kH, kW)

- output_size – target output size oH x oW

- output_ratio – alternative to output_size, in range (0, 1)

- return_indices – return pooling indices as well

- _random_samples – optional (B, C, 2) random starts override

See FractionalMaxPool2d for details.

[#](#api-tensorplay.nn.functional.fractional_max_pool2d)

### fractional_max_pool2d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.fractional_max_pool2d.html)

```python
tensorplay.nn.functional.fractional_max_pool2d(input: Tensor, kernel_size, output_size=None, output_ratio=None, return_indices: bool = False, _random_samples=None)
```

Applies 2D fractional max pooling over an input signal.

If return_indices is True, returns (output, indices);
otherwise just the output.

[#](#api-tensorplay.nn.functional.fractional_max_pool3d_with_indices)

### fractional_max_pool3d_with_indices

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.fractional_max_pool3d_with_indices.html)

```python
tensorplay.nn.functional.fractional_max_pool3d_with_indices(input: Tensor, kernel_size, output_size=None, output_ratio=None, return_indices: bool = True, _random_samples=None)
```

Applies 3D fractional max pooling over an input signal composed of
several input planes, returning (output, indices).

Each plane consumes three random samples ordered (T, H, W), matching

[#](#api-tensorplay.nn.functional.fractional_max_pool3d)

### fractional_max_pool3d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.fractional_max_pool3d.html)

```python
tensorplay.nn.functional.fractional_max_pool3d(input: Tensor, kernel_size, output_size=None, output_ratio=None, return_indices: bool = False, _random_samples=None)
```

Applies 3D fractional max pooling over an input signal.

If return_indices is True, returns (output, indices);
otherwise just the output.

[#](#api-tensorplay.nn.functional.gaussian_nll_loss)

### gaussian_nll_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.gaussian_nll_loss.html)

```python
tensorplay.nn.functional.gaussian_nll_loss(input: Tensor, target: Tensor, var, full: bool = False, eps: float = 1e-06, reduction: str = 'mean') → Tensor
```

Compute the Gaussian negative log likelihood loss.

See GaussianNLLLoss for details.

[#](#api-tensorplay.nn.functional.gelu)

### gelu

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.gelu.html)

```python
tensorplay.nn.functional.gelu(input, approximate='none') → Tensor
```

When approximate is ‘none’, applies
$\text{GELU}(x) = x * \Phi(x)$; ‘tanh’ uses the tanh estimation.

[#](#api-tensorplay.nn.functional.glu)

### glu

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.glu.html)

```python
tensorplay.nn.functional.glu(input, dim=-1) → Tensor
```

Gated Linear Unit: $a * \sigma(b)$ where the input is split in half
along dim.

[#](#api-tensorplay.nn.functional.grid_sample)

### grid_sample

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.grid_sample.html)

```python
tensorplay.nn.functional.grid_sample(input: Tensor, grid: Tensor, mode: str = 'bilinear', padding_mode: str = 'zeros', align_corners=None) → Tensor
```

Compute grid sample.

Given an input and a flow-field grid, computes the
output using input values and pixel locations from
grid. Currently, only spatial (4-D) and volumetric (5-D)
input are supported.

Parameters:

- input ([Tensor](/docs/generated/tensorplay.Tensor.html#tensorplay.Tensor)) – input of shape $(N, C, H_\text{in}, W_\text{in})$ (4-D case) or $(N, C, D_\text{in}, H_\text{in}, W_\text{in})$ (5-D case)

- grid ([Tensor](/docs/generated/tensorplay.Tensor.html#tensorplay.Tensor)) – flow-field of shape $(N, H_\text{out}, W_\text{out}, 2)$ (4-D case) or $(N, D_\text{out}, H_\text{out}, W_\text{out}, 3)$ (5-D case)

- mode ([str](https://docs.python.org/3/builtins/stdtypes.html#str)) – 'bilinear' | 'nearest' | 'bicubic'. Default: 'bilinear'

- padding_mode ([str](https://docs.python.org/3/builtins/stdtypes.html#str)) – 'zeros' | 'border' | 'reflection'. Default: 'zeros'

- align_corners ([bool](https://docs.python.org/3/builtins/functions.html#bool), optional) – extrema treatment, default False.

Dispatches to the native grid_sampler_2d / grid_sampler_3d kernels
both input and grid.

[#](#api-tensorplay.nn.functional.group_norm)

### group_norm

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.group_norm.html)

```python
tensorplay.nn.functional.group_norm(input, num_groups, weight=None, bias=None, eps=1e-05)
```

[#](#api-tensorplay.nn.functional.grouped_mm)

### grouped_mm

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.grouped_mm.html)

```python
tensorplay.nn.functional.grouped_mm(input, mat2, offs)
```

[#](#api-tensorplay.nn.functional.gru_cell)

### gru_cell

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.gru_cell.html)

```python
tensorplay.nn.functional.gru_cell(input, hx, w_ih, w_hh, b_ih=None, b_hh=None) → Tensor
```

One time step of a gated recurrent unit cell.

[#](#api-tensorplay.nn.functional.gumbel_softmax)

### gumbel_softmax

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.gumbel_softmax.html)

```python
tensorplay.nn.functional.gumbel_softmax(logits: Tensor, tau: float = 1, hard: bool = False, eps: float = 1e-10, dim: int = -1) → Tensor
```

Sample from the Gumbel-Softmax distribution and optionally discretize.

straight-through when hard=True).

[#](#api-tensorplay.nn.functional.hardshrink)

### hardshrink

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.hardshrink.html)

```python
tensorplay.nn.functional.hardshrink(input, lambd=0.5) → Tensor
```

Applies the hard shrinkage function element-wise.

See Hardshrink for more details.

[#](#api-tensorplay.nn.functional.hardsigmoid)

### hardsigmoid

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.hardsigmoid.html)

```python
tensorplay.nn.functional.hardsigmoid(input, inplace=False) → Tensor
```

[#](#api-tensorplay.nn.functional.hardswish)

### hardswish

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.hardswish.html)

```python
tensorplay.nn.functional.hardswish(input, inplace=False) → Tensor
```

[#](#api-tensorplay.nn.functional.hardtanh_)

### hardtanh_

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.hardtanh_.html)

```python
tensorplay.nn.functional.hardtanh_(input, min_val=-1., max_val=1.) → Tensor
```

In-place version of [hardtanh()](/docs/generated/tensorplay.nn.functional.hardtanh.html#tensorplay.nn.functional.hardtanh).

[#](#api-tensorplay.nn.functional.hardtanh)

### hardtanh

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.hardtanh.html)

```python
tensorplay.nn.functional.hardtanh(input, min_val=-1.0, max_val=1.0, inplace=False) → Tensor
```

[#](#api-tensorplay.nn.functional.hinge_embedding_loss)

### hinge_embedding_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.hinge_embedding_loss.html)

```python
tensorplay.nn.functional.hinge_embedding_loss(input: Tensor, target: Tensor, margin: float = 1.0, size_average=None, reduce=None, reduction: str = 'mean') → Tensor
```

Compute the hinge embedding loss.

See HingeEmbeddingLoss for details.

[#](#api-tensorplay.nn.functional.huber_loss)

### huber_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.huber_loss.html)

```python
tensorplay.nn.functional.huber_loss(input: Tensor, target: Tensor, reduction: str = 'mean', delta: float = 1.0, weight: Tensor | None = None) → Tensor
```

Compute the Huber loss, with optional weighting.

Function uses a squared term if the absolute error falls below delta and
a delta-scaled L1 term otherwise.
See HuberLoss for details.

[#](#api-tensorplay.nn.functional.instance_norm)

### instance_norm

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.instance_norm.html)

```python
tensorplay.nn.functional.instance_norm(input, running_mean=None, running_var=None, weight=None, bias=None, use_input_stats=True, momentum=0.1, eps=1e-05)
```

[#](#api-tensorplay.nn.functional.interpolate)

### interpolate

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.interpolate.html)

```python
tensorplay.nn.functional.interpolate(input: Tensor, size=None, scale_factor=None, mode: str = 'nearest', align_corners=None, recompute_scale_factor=None, antialias: bool = False) → Tensor
```

interpolate(input, size=None, scale_factor=None, mode=’nearest’,
align_corners=None) -> Tensor

Routes to the native upsample_* ops exactly like

[#](#api-tensorplay.nn.functional.kl_div)

### kl_div

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.kl_div.html)

```python
tensorplay.nn.functional.kl_div(input: Tensor, target: Tensor, size_average=None, reduce=None, reduction: str = 'mean', log_target: bool = False) → Tensor
```

Compute the KL Divergence loss.

input holds log-probabilities; see KLDivLoss.
Note that reduction='mean' divides by the number of elements and
does not return the true KL divergence value — use 'batchmean'.

[#](#api-tensorplay.nn.functional.l1_loss)

### l1_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.l1_loss.html)

```python
tensorplay.nn.functional.l1_loss(input: Tensor, target: Tensor, size_average=None, reduce=None, reduction: str = 'mean', weight: Tensor | None = None) → Tensor
```

Compute the L1 loss, with optional weighting.

Function that takes the mean element-wise absolute value difference.
See L1Loss for details.

[#](#api-tensorplay.nn.functional.layer_norm)

### layer_norm

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.layer_norm.html)

```python
tensorplay.nn.functional.layer_norm(input, normalized_shape, weight=None, bias=None, eps=1e-05)
```

[#](#api-tensorplay.nn.functional.leaky_relu_)

### leaky_relu_

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.leaky_relu_.html)

```python
tensorplay.nn.functional.leaky_relu_(input, negative_slope=0.01) → Tensor
```

In-place version of [leaky_relu()](/docs/generated/tensorplay.nn.functional.leaky_relu.html#tensorplay.nn.functional.leaky_relu).

[#](#api-tensorplay.nn.functional.leaky_relu)

### leaky_relu

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.leaky_relu.html)

```python
tensorplay.nn.functional.leaky_relu(input, negative_slope=0.01, inplace=False) → Tensor
```

[#](#api-tensorplay.nn.functional.linear_cross_entropy)

### linear_cross_entropy

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.linear_cross_entropy.html)

```python
tensorplay.nn.functional.linear_cross_entropy(input: Tensor, linear_weight: Tensor, target: Tensor, *, linear_bias=None, weight=None, reduction: str = 'mean', ignore_index=None, label_smoothing: float = 0.0, options=None) → Tensor
```

Compute cross entropy between input, transformed linearly, and
target.

Equivalent to cross_entropy(linear(input, linear_weight), target,
**kwargs) (reference path; chunked/fused options are ignored).

[#](#api-tensorplay.nn.functional.linear)

### linear

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.linear.html)

```python
tensorplay.nn.functional.linear(input: Tensor, weight: Tensor, bias: Tensor | None = None) → Tensor
```

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

Shape:

- Input: $(*, H_\text{in})$ where $*$ means any number of dimensions including none and $H_\text{in} = \text{in\_features}$.

- Weight: $(H_\text{out}, H_\text{in})$ where $H_\text{out} = \text{out\_features}$.

- Bias: $(H_\text{out})$

- Output: $(*, H_\text{out})$

See Linear for more details.

[#](#api-tensorplay.nn.functional.local_response_norm)

### local_response_norm

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.local_response_norm.html)

```python
tensorplay.nn.functional.local_response_norm(input: Tensor, size: int, alpha: float = 0.0001, beta: float = 0.75, k: float = 1.0) → Tensor
```

Apply local response normalization over an input signal.

The input signal is composed of several input planes, where channels
occupy the second dimension. Normalization is applied across channels.

See LocalResponseNorm for details.

[#](#api-tensorplay.nn.functional.log_softmax)

### log_softmax

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.log_softmax.html)

```python
tensorplay.nn.functional.log_softmax(input, dim=None, dtype=None)
```

[#](#api-tensorplay.nn.functional.logsigmoid)

### logsigmoid

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.logsigmoid.html)

```python
tensorplay.nn.functional.logsigmoid(input) → Tensor
```

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

See LogSigmoid for more details.

[#](#api-tensorplay.nn.functional.lp_pool1d)

### lp_pool1d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.lp_pool1d.html)

```python
tensorplay.nn.functional.lp_pool1d(input: Tensor, norm_type, kernel_size, stride=None, ceil_mode: bool = False) → Tensor
```

Apply a 1D power-average pooling over an input signal.

See LPPool1d for details.

[#](#api-tensorplay.nn.functional.lp_pool2d)

### lp_pool2d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.lp_pool2d.html)

```python
tensorplay.nn.functional.lp_pool2d(input: Tensor, norm_type, kernel_size, stride=None, ceil_mode: bool = False) → Tensor
```

Apply a 2D power-average pooling over an input signal.

If the sum of all inputs to the power of p is zero, the gradient is set
to zero as well.

See LPPool2d for details.

[#](#api-tensorplay.nn.functional.lp_pool3d)

### lp_pool3d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.lp_pool3d.html)

```python
tensorplay.nn.functional.lp_pool3d(input: Tensor, norm_type, kernel_size, stride=None, ceil_mode: bool = False) → Tensor
```

Apply a 3D power-average pooling over an input signal.

See LPPool3d for details.

[#](#api-tensorplay.nn.functional.lstm_cell)

### lstm_cell

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.lstm_cell.html)

```python
tensorplay.nn.functional.lstm_cell(input, hx, cx, w_ih, w_hh, b_ih=None, b_hh=None)
```

One time step of a long short-term memory cell. Returns the next
hidden state and next cell state.

[#](#api-tensorplay.nn.functional.margin_ranking_loss)

### margin_ranking_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.margin_ranking_loss.html)

```python
tensorplay.nn.functional.margin_ranking_loss(input1: Tensor, input2: Tensor, target: Tensor, margin: float = 0, size_average=None, reduce=None, reduction: str = 'mean') → Tensor
```

Compute the margin ranking loss.

See MarginRankingLoss for details.

[#](#api-tensorplay.nn.functional.max_pool1d_with_indices)

### max_pool1d_with_indices

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.max_pool1d_with_indices.html)

```python
tensorplay.nn.functional.max_pool1d_with_indices(input: Tensor, kernel_size, stride=None, padding=0, dilation=1, ceil_mode: bool = False, return_indices: bool = True)
```

Applies a 1D max pooling over an input signal, returning
(output, indices).

See MaxPool1d for details.

[#](#api-tensorplay.nn.functional.max_pool1d)

### max_pool1d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.max_pool1d.html)

```python
tensorplay.nn.functional.max_pool1d(input: Tensor, kernel_size, stride=None, padding=0, dilation=1, ceil_mode: bool = False, return_indices: bool = False)
```

max_pool1d(input, kernel_size, stride=None, padding=0, dilation=1,
ceil_mode=False, return_indices=False) -> Tensor

Applies a 1D max pooling over an input signal composed of several input
planes. Input shape (N, C, L) or unbatched (C, L).

[#](#api-tensorplay.nn.functional.max_pool2d_with_indices)

### max_pool2d_with_indices

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.max_pool2d_with_indices.html)

```python
tensorplay.nn.functional.max_pool2d_with_indices(input: Tensor, kernel_size, stride=None, padding=0, dilation=1, ceil_mode: bool = False, return_indices: bool = True)
```

Applies a 2D max pooling over an input composed of several input
planes, returning (output, indices).

See MaxPool2d for details.

[#](#api-tensorplay.nn.functional.max_pool2d)

### max_pool2d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.max_pool2d.html)

```python
tensorplay.nn.functional.max_pool2d(input, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=False, return_indices=False)
```

[#](#api-tensorplay.nn.functional.max_pool3d_with_indices)

### max_pool3d_with_indices

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.max_pool3d_with_indices.html)

```python
tensorplay.nn.functional.max_pool3d_with_indices(input: Tensor, kernel_size, stride=None, padding=0, dilation=1, ceil_mode: bool = False, return_indices: bool = True)
```

Applies a 3D max pooling over an input signal, returning
(output, indices).

See MaxPool3d for details.

[#](#api-tensorplay.nn.functional.max_pool3d)

### max_pool3d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.max_pool3d.html)

```python
tensorplay.nn.functional.max_pool3d(input: Tensor, kernel_size, stride=None, padding=0, dilation=1, ceil_mode: bool = False, return_indices: bool = False) → Tensor
```

max_pool3d(input, kernel_size, stride=None, padding=0, dilation=1,
ceil_mode=False, return_indices=False) -> Tensor

Applies a 3D max pooling over an input signal composed of several input
planes. Input shape (N, C, D, H, W) or unbatched (C, D, H, W).

[#](#api-tensorplay.nn.functional.max_unpool1d)

### max_unpool1d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.max_unpool1d.html)

```python
tensorplay.nn.functional.max_unpool1d(input: Tensor, indices: Tensor, kernel_size, stride=None, padding=0, output_size=None) → Tensor
```

Compute a partial inverse of MaxPool1d.

See MaxUnpool1d for details.

[#](#api-tensorplay.nn.functional.max_unpool2d)

### max_unpool2d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.max_unpool2d.html)

```python
tensorplay.nn.functional.max_unpool2d(input: Tensor, indices: Tensor, kernel_size, stride=None, padding=0, output_size=None) → Tensor
```

Compute a partial inverse of MaxPool2d.

See MaxUnpool2d for details.

[#](#api-tensorplay.nn.functional.max_unpool3d)

### max_unpool3d

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.max_unpool3d.html)

```python
tensorplay.nn.functional.max_unpool3d(input: Tensor, indices: Tensor, kernel_size, stride=None, padding=0, output_size=None) → Tensor
```

Compute a partial inverse of MaxPool3d.

See MaxUnpool3d for details.

[#](#api-tensorplay.nn.functional.mish)

### mish

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.mish.html)

```python
tensorplay.nn.functional.mish(input, inplace=False) → Tensor
```

[#](#api-tensorplay.nn.functional.mse_loss)

### mse_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.mse_loss.html)

```python
tensorplay.nn.functional.mse_loss(input, target, reduction='mean')
```

[#](#api-tensorplay.nn.functional.multi_head_attention_forward)

### multi_head_attention_forward

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.multi_head_attention_forward.html)

```python
tensorplay.nn.functional.multi_head_attention_forward(query: Tensor, key: Tensor, value: Tensor, embed_dim_to_check: int, num_heads: int, in_proj_weight: Tensor = None, in_proj_bias: Tensor = None, bias_k=None, bias_v=None, add_zero_attn: bool = False, dropout_p: float = 0.0, out_proj_weight: Tensor = None, out_proj_bias: Tensor = None, training: bool = True, key_padding_mask=None, need_weights: bool = True, attn_mask=None, use_separate_proj_weight: bool = False, q_proj_weight=None, k_proj_weight=None, v_proj_weight=None, static_k=None, static_v=None, average_attn_weights: bool = True, is_causal: bool = False)
```

multi_head_attention_forward(query, key, value, embed_dim_to_check,
num_heads, in_proj_weight, in_proj_bias=None, bias_k=None, bias_v=None,
add_zero_attn=False, dropout_p=0.0, out_proj_weight=None,
out_proj_bias=None, training=True, key_padding_mask=None,
need_weights=True, attn_mask=None, use_separate_proj_weight=False,
q_proj_weight=None, k_proj_weight=None, v_proj_weight=None,
static_k=None, static_v=None, average_attn_weights=True,
is_causal=False) -> (Tensor, Optional[Tensor])

Computes multi-head attention on (L, N, E) inputs (2D unbatched inputs are
promoted internally and the batch dim is squeezed on return). Returns the
projected output of shape (L, N, E) and, when need_weights is true,
the attention weights of shape (N, L, S) — or (num_heads, L, S) with
average_attn_weights=False.

[#](#api-tensorplay.nn.functional.multi_margin_loss)

### multi_margin_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.multi_margin_loss.html)

```python
tensorplay.nn.functional.multi_margin_loss(input: Tensor, target: Tensor, p: int = 1, margin: float = 1.0, weight: Tensor | None = None, size_average=None, reduce=None, reduction: str = 'mean') → Tensor
```

Compute the multi margin loss, with optional weighting.

sum_d max(0, margin - x_y + x_d)^p * w_y / C over non-target classes.
See MultiMarginLoss for details.

[#](#api-tensorplay.nn.functional.multilabel_margin_loss)

### multilabel_margin_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.multilabel_margin_loss.html)

```python
tensorplay.nn.functional.multilabel_margin_loss(input: Tensor, target: Tensor, size_average=None, reduce=None, reduction: str = 'mean') → Tensor
```

Compute the multilabel margin loss.

for each positive label y (targets are active until the first
-1), add max(0, 1 - x[y] + x[d]) over non-target labels d;
divide by C.
See MultiLabelMarginLoss for details.

[#](#api-tensorplay.nn.functional.multilabel_soft_margin_loss)

### multilabel_soft_margin_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.multilabel_soft_margin_loss.html)

```python
tensorplay.nn.functional.multilabel_soft_margin_loss(input: Tensor, target: Tensor, weight: Tensor | None = None, size_average=None, reduce=None, reduction: str = 'mean') → Tensor
```

Compute the multilabel soft margin loss.

See MultiLabelSoftMarginLoss for details.

[#](#api-tensorplay.nn.functional.native_channel_shuffle)

### native_channel_shuffle

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.native_channel_shuffle.html)

```python
tensorplay.nn.functional.native_channel_shuffle(input: Tensor, groups: int) → Tensor
```

[#](#api-tensorplay.nn.functional.nll_loss)

### nll_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.nll_loss.html)

```python
tensorplay.nn.functional.nll_loss(input, target, weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean')
```

The negative log likelihood loss.

input with a scalar target, 2D (N, C), and N-d
target.

See NLLLoss for details.

[#](#api-tensorplay.nn.functional.normalize)

### normalize

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.normalize.html)

```python
tensorplay.nn.functional.normalize(input, p=2, dim=1, eps=1e-12) → Tensor
```

Performs $L_p$ normalization over the specified dimension —

[#](#api-tensorplay.nn.functional.one_hot)

### one_hot

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.one_hot.html)

```python
tensorplay.nn.functional.one_hot(tensor, num_classes=-1) → LongTensor
```

Returns long tensor shaped tensor.shape + (num_classes,) with a 1 at

[#](#api-tensorplay.nn.functional.pad)

### pad

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.pad.html)

```python
tensorplay.nn.functional.pad(input, pad, mode='constant', value=0)
```

Pads tensor.  pad values are described starting from the last
dimension and may cover any suffix of the input dimensions.

[#](#api-tensorplay.nn.functional.pairwise_distance)

### pairwise_distance

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.pairwise_distance.html)

```python
tensorplay.nn.functional.pairwise_distance(x1: Tensor, x2: Tensor, p: float = 2.0, eps: float = 1e-06, keepdim: bool = False) → Tensor
```

Computes the pairwise distance between input vectors.

dimension.

[#](#api-tensorplay.nn.functional.pdist)

### pdist

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.pdist.html)

```python
tensorplay.nn.functional.pdist(input: Tensor, p: float = 2.0) → Tensor
```

Computes the pairwise distance between rows of input.

Returns the flattened upper triangle of the N x N distance matrix —

[#](#api-tensorplay.nn.functional.pixel_shuffle)

### pixel_shuffle

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.pixel_shuffle.html)

```python
tensorplay.nn.functional.pixel_shuffle(input: Tensor, upscale_factor: int) → Tensor
```

Rearranges elements in a tensor of shape (*, C x r^2, H, W) to a
tensor of shape (*, C, H x r, W x r).

input[n, c*r^2 + i*r + j, h, w]``.

[#](#api-tensorplay.nn.functional.pixel_unshuffle)

### pixel_unshuffle

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.pixel_unshuffle.html)

```python
tensorplay.nn.functional.pixel_unshuffle(input: Tensor, downscale_factor: int) → Tensor
```

Reverses the [pixel_shuffle()](/docs/generated/tensorplay.nn.functional.pixel_shuffle.html#tensorplay.nn.functional.pixel_shuffle) transformation: (*, C, H x r,
W x r) -> (*, C x r^2, H, W).

[#](#api-tensorplay.nn.functional.poisson_nll_loss)

### poisson_nll_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.poisson_nll_loss.html)

```python
tensorplay.nn.functional.poisson_nll_loss(input: Tensor, target: Tensor, log_input: bool = True, full: bool = False, size_average=None, eps: float = 1e-08, reduce=None, reduction: str = 'mean') → Tensor
```

Compute the Poisson negative log likelihood loss.

See PoissonNLLLoss for details.

[#](#api-tensorplay.nn.functional.prelu)

### prelu

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.prelu.html)

```python
tensorplay.nn.functional.prelu(input, weight)
```

[#](#api-tensorplay.nn.functional.relu_)

### relu_

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.relu_.html)

```python
tensorplay.nn.functional.relu_(input) → Tensor
```

In-place version of [relu()](/docs/generated/tensorplay.nn.functional.relu.html#tensorplay.nn.functional.relu).

[#](#api-tensorplay.nn.functional.relu)

### relu

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.relu.html)

```python
tensorplay.nn.functional.relu(input, inplace=False)
```

[#](#api-tensorplay.nn.functional.relu6)

### relu6

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.relu6.html)

```python
tensorplay.nn.functional.relu6(input, inplace=False) → Tensor
```

[#](#api-tensorplay.nn.functional.rms_norm)

### rms_norm

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.rms_norm.html)

```python
tensorplay.nn.functional.rms_norm(input: Tensor, normalized_shape, weight: Tensor | None = None, eps: float | None = None) → Tensor
```

Apply Root Mean Square Layer Normalization.

Dispatches to the native fused kernel (single dispatch, CPU vectorized
rows / CUDA block-per-row); falls back to the composite below under
CompositeImplicitAutograd rms_norm.

[#](#api-tensorplay.nn.functional.rnn_relu_cell)

### rnn_relu_cell

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.rnn_relu_cell.html)

```python
tensorplay.nn.functional.rnn_relu_cell(input, hx, w_ih, w_hh, b_ih=None, b_hh=None) → Tensor
```

One time step of an Elman RNN cell with ReLU nonlinearity.

[#](#api-tensorplay.nn.functional.rnn_tanh_cell)

### rnn_tanh_cell

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.rnn_tanh_cell.html)

```python
tensorplay.nn.functional.rnn_tanh_cell(input, hx, w_ih, w_hh, b_ih=None, b_hh=None) → Tensor
```

One time step of an Elman RNN cell with tanh nonlinearity.

[#](#api-tensorplay.nn.functional.rrelu_)

### rrelu_

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.rrelu_.html)

```python
tensorplay.nn.functional.rrelu_(input, lower=0.125, upper=0.3333333333333333, training=False)
```

In-place version of [rrelu()](/docs/generated/tensorplay.nn.functional.rrelu.html#tensorplay.nn.functional.rrelu).

[#](#api-tensorplay.nn.functional.rrelu)

### rrelu

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.rrelu.html)

```python
tensorplay.nn.functional.rrelu(input, lower=1. / 8, upper=1. / 3, training=False, inplace=False) → Tensor
```

Randomized leaky ReLU.

See RReLU for more details.

[#](#api-tensorplay.nn.functional.scaled_dot_product_attention)

### scaled_dot_product_attention

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.scaled_dot_product_attention.html)

```python
tensorplay.nn.functional.scaled_dot_product_attention(query: Tensor, key: Tensor, value: Tensor, attn_mask=None, dropout_p: float = 0.0, is_causal: bool = False, scale=None, enable_gqa: bool = False, backend: str | None = None) → Tensor
```

scaled_dot_product_attention(query, key, value, attn_mask=None,
dropout_p=0.0, is_causal=False, scale=None, enable_gqa=False,
backend=None) -> Tensor

Computes scaled dot product attention on query, key and value. Routes to
reference:

$$\text{Attention}(Q, K, V) = \text{softmax}(\frac{Q K^T}{\sqrt{E}}) V$$

Parameters:

backend ([str](https://docs.python.org/3/builtins/stdtypes.html#str), optional) – 'flash' | 'mem_efficient',
'math', or None to pick automatically. 'flash'
selects the fused flash-attention kernel, 'math' forces the
composed reference path. When None, the routing candidate
order is governed by [tensorplay.nn.attention.sdpa_kernel()](/docs/generated/tensorplay.nn.attention.sdpa_kernel.html#tensorplay.nn.attention.sdpa_kernel).

[#](#api-tensorplay.nn.functional.scaled_grouped_mm)

### scaled_grouped_mm

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.scaled_grouped_mm.html)

```python
tensorplay.nn.functional.scaled_grouped_mm(*args, **kwargs)
```

[#](#api-tensorplay.nn.functional.scaled_mm)

### scaled_mm

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.scaled_mm.html)

```python
tensorplay.nn.functional.scaled_mm(*args, **kwargs)
```

[#](#api-tensorplay.nn.functional.selu_)

### selu_

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.selu_.html)

```python
tensorplay.nn.functional.selu_(input) → Tensor
```

In-place version of [selu()](/docs/generated/tensorplay.nn.functional.selu.html#tensorplay.nn.functional.selu).

[#](#api-tensorplay.nn.functional.selu)

### selu

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.selu.html)

```python
tensorplay.nn.functional.selu(input, inplace=False) → Tensor
```

[#](#api-tensorplay.nn.functional.sigmoid)

### sigmoid

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.sigmoid.html)

```python
tensorplay.nn.functional.sigmoid(input) → Tensor
```

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

[#](#api-tensorplay.nn.functional.silu)

### silu

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.silu.html)

```python
tensorplay.nn.functional.silu(input: Tensor, inplace: bool = False) → Tensor
```

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

The SiLU function is also known as the swish function.

$$\text{silu}(x) = x * \sigma(x), \text{where } \sigma(x) \text{ is the logistic sigmoid.}$$

> **Note**
>
> See Gaussian Error Linear Units (GELUs) where the SiLU (Sigmoid Linear Unit) was originally coined, and see Sigmoid-Weighted Linear Units for Neural Network Function Approximation in Reinforcement Learning and Swish: a Self-Gated Activation Function where the SiLU was experimented with later.

See SiLU for more details.

[#](#api-tensorplay.nn.functional.smooth_l1_loss)

### smooth_l1_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.smooth_l1_loss.html)

```python
tensorplay.nn.functional.smooth_l1_loss(input: Tensor, target: Tensor, size_average=None, reduce=None, reduction: str = 'mean', beta: float = 1.0) → Tensor
```

Compute the Smooth L1 loss.

Function uses a squared term if the absolute element-wise error falls
below beta and an L1 term otherwise.
See SmoothL1Loss for details.

[#](#api-tensorplay.nn.functional.soft_margin_loss)

### soft_margin_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.soft_margin_loss.html)

```python
tensorplay.nn.functional.soft_margin_loss(input: Tensor, target: Tensor, size_average=None, reduce=None, reduction: str = 'mean') → Tensor
```

Compute the soft margin loss.

See SoftMarginLoss for details.

[#](#api-tensorplay.nn.functional.softmax)

### softmax

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.softmax.html)

```python
tensorplay.nn.functional.softmax(input, dim=None, dtype=None)
```

[#](#api-tensorplay.nn.functional.softmin)

### softmin

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.softmin.html)

```python
tensorplay.nn.functional.softmin(input: Tensor, dim: int | None = None, dtype=None) → Tensor
```

Apply a softmin function.

Note that $\text{Softmin}(x) = \text{Softmax}(-x)$.

See Softmin for more details.

[#](#api-tensorplay.nn.functional.softplus)

### softplus

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.softplus.html)

```python
tensorplay.nn.functional.softplus(input, beta=1, threshold=20) → Tensor
```

[#](#api-tensorplay.nn.functional.softshrink)

### softshrink

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.softshrink.html)

```python
tensorplay.nn.functional.softshrink(input, lambd=0.5) → Tensor
```

Applies the soft shrinkage function element-wise.

See Softshrink for more details.

[#](#api-tensorplay.nn.functional.softsign)

### softsign

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.softsign.html)

```python
tensorplay.nn.functional.softsign(input) → Tensor
```

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

See Softsign for more details.

[#](#api-tensorplay.nn.functional.tanh)

### tanh

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.tanh.html)

```python
tensorplay.nn.functional.tanh(input) → Tensor
```

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

[#](#api-tensorplay.nn.functional.tanhshrink)

### tanhshrink

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.tanhshrink.html)

```python
tensorplay.nn.functional.tanhshrink(input) → Tensor
```

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

See Tanhshrink for more details.

[#](#api-tensorplay.nn.functional.threshold_)

### threshold_

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.threshold_.html)

```python
tensorplay.nn.functional.threshold_(input, threshold, value) → Tensor
```

In-place version of [threshold()](/docs/generated/tensorplay.nn.functional.threshold.html#tensorplay.nn.functional.threshold).

[#](#api-tensorplay.nn.functional.threshold)

### threshold

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.threshold.html)

```python
tensorplay.nn.functional.threshold(input: Tensor, threshold: float, value: float, inplace: bool = False) → Tensor
```

Apply a threshold to each element of the input Tensor.

See Threshold for more details.

[#](#api-tensorplay.nn.functional.triplet_margin_loss)

### triplet_margin_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.triplet_margin_loss.html)

```python
tensorplay.nn.functional.triplet_margin_loss(anchor: Tensor, positive: Tensor, negative: Tensor, margin: float = 1.0, p: float = 2, eps: float = 1e-06, swap: bool = False, size_average=None, reduce=None, reduction: str = 'mean') → Tensor
```

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

See TripletMarginLoss for details.

[#](#api-tensorplay.nn.functional.triplet_margin_with_distance_loss)

### triplet_margin_with_distance_loss

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.triplet_margin_with_distance_loss.html)

```python
tensorplay.nn.functional.triplet_margin_with_distance_loss(anchor: Tensor, positive: Tensor, negative: Tensor, *, distance_function=None, margin: float = 1.0, swap: bool = False, reduction: str = 'mean') → Tensor
```

Compute the triplet margin loss using a custom distance function.

See TripletMarginWithDistanceLoss for details.

[#](#api-tensorplay.nn.functional.unfold)

### unfold

function[Full reference ↗](/docs/generated/tensorplay.nn.functional.unfold.html)

```python
tensorplay.nn.functional.unfold(input, kernel_size, dilation=1, padding=0, stride=1)
```