tensorplay@1.0.0.dev20260909

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

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

See AdaptiveMaxPool1d for details.

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

See AdaptiveMaxPool2d for details.

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

See AdaptiveMaxPool3d for details.

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.

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

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

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

Compute Binary Cross Entropy between target and input logits.

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

Compute Binary Cross Entropy between the target and input probabilities.

See BCELoss for details.

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.

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

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 or a one-element tuple (padW,). 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)

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 or a tuple (padH, padW). 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)

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 or a tuple (padD, padH, padW). 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)

Compute the cosine embedding loss.

See CosineEmbeddingLoss for details.

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

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.

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

In-place version of dropout().

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

See Dropout1d for details.

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.

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

See FeatureAlphaDropout for details.

In-place version of feature_dropout().

Randomly zeroes entire channels (dim 1).

Combine an array of sliding local blocks into a tensor containing

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.

Applies 2D fractional max pooling over an input signal.

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

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

Applies 3D fractional max pooling over an input signal.

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

Compute the Gaussian negative log likelihood loss.

See GaussianNLLLoss for details.

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

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

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) – 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) – 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) – 'bilinear' | 'nearest' | 'bicubic'. Default: 'bilinear'

• padding_mode (str) – 'zeros' | 'border' | 'reflection'. Default: 'zeros'

• align_corners (bool, optional) – extrema treatment, default False.

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

One time step of a gated recurrent unit cell.

Sample from the Gumbel-Softmax distribution and optionally discretize.

straight-through when hard=True).

Applies the hard shrinkage function element-wise.

See Hardshrink for more details.

Compute the hinge embedding loss.

See HingeEmbeddingLoss for details.

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.

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

Routes to the native upsample_* ops exactly like

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

Compute the L1 loss, with optional weighting.

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

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

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.

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.

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

See LogSigmoid for more details.

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

See LPPool1d for details.

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.

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

See LPPool3d for details.

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

Compute the margin ranking loss.

See MarginRankingLoss for details.

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

See MaxPool1d for details.

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

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

See MaxPool2d for details.

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

See MaxPool3d for details.

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

Compute a partial inverse of MaxPool1d.

See MaxUnpool1d for details.

Compute a partial inverse of MaxPool2d.

See MaxUnpool2d for details.

Compute a partial inverse of MaxPool3d.

See MaxUnpool3d for details.

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.

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.

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.

Compute the multilabel soft margin loss.

See MultiLabelSoftMarginLoss for details.

The negative log likelihood loss.

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

See NLLLoss for details.

Performs $L_p$ normalization over the specified dimension —

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

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

Computes the pairwise distance between input vectors.

dimension.

Computes the pairwise distance between rows of input.

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

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]``.

Reverses the pixel_shuffle() transformation: (*, C, H x r, W x r) -> (*, C x r^2, H, W).

Compute the Poisson negative log likelihood loss.

See PoissonNLLLoss for details.