---
title: "clika_runtime.nn.functional functions"
sidebar_label: "Functions"
description: "Module-level functions of clika_runtime.nn.functional."
---

<!-- Generated by tools/api_reference/generate_api_docs.py. Do not edit. -->

## `adaptive_avg_pool`

```python
adaptive_avg_pooladaptive_avg_pool(input: clika_runtime._core.Tensor, output_size: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor
```

adaptive_avg_pool(input: clika_runtime._core.Tensor, output_size: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor

adaptive_avg_pool(input, output_size) -> Tensor

The `adaptive_avg_pool` operator.

## `adaptive_avg_pool1d`

```python
adaptive_avg_pool1d(input: 'Tensor', output_size: 'int | Sequence[int]') -> 'Tensor'
```

adaptive_avg_pool1d(input, output_size) -> Tensor

Average pooling to a fixed output length over channels-last
``[batch, length, channels]``.

## `adaptive_avg_pool2d`

```python
adaptive_avg_pool2d(input: 'Tensor', output_size: 'int | Sequence[int]') -> 'Tensor'
```

adaptive_avg_pool2d(input, output_size) -> Tensor

Average pooling to a fixed ``[height, width]`` over channels-last input;
an int means a square output.

## `adaptive_avg_pool3d`

```python
adaptive_avg_pool3d(input: 'Tensor', output_size: 'int | Sequence[int]') -> 'Tensor'
```

adaptive_avg_pool3d(input, output_size) -> Tensor

Average pooling to a fixed ``[depth, height, width]`` over
channels-last input; an int means a cubic output.

## `adaptive_max_pool`

```python
adaptive_max_pooladaptive_max_pool(input: clika_runtime._core.Tensor, output_size: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor
```

adaptive_max_pool(input: clika_runtime._core.Tensor, output_size: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor

adaptive_max_pool(input, output_size) -> Tensor

The `adaptive_max_pool` operator.

## `adaptive_max_pool1d`

```python
adaptive_max_pool1d(input: 'Tensor', output_size: 'int | Sequence[int]') -> 'Tensor'
```

adaptive_max_pool1d(input, output_size) -> Tensor

Max pooling to a fixed output length over channels-last input.

## `adaptive_max_pool2d`

```python
adaptive_max_pool2d(input: 'Tensor', output_size: 'int | Sequence[int]') -> 'Tensor'
```

adaptive_max_pool2d(input, output_size) -> Tensor

Max pooling to a fixed ``[height, width]`` over channels-last input; an
int means a square output.

## `adaptive_max_pool3d`

```python
adaptive_max_pool3d(input: 'Tensor', output_size: 'int | Sequence[int]') -> 'Tensor'
```

adaptive_max_pool3d(input, output_size) -> Tensor

Max pooling to a fixed ``[depth, height, width]`` over channels-last
input; an int means a cubic output.

## `add_layer_norm`

```python
add_layer_normadd_layer_norm(input: clika_runtime._core.Tensor, residual: clika_runtime._core.Tensor | None = None, post_residual: clika_runtime._core.Tensor | None = None, normalized_shape: collections.abc.Sequence[int] = [], skip_bias: clika_runtime._core.Tensor | None = None, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

add_layer_norm(input: clika_runtime._core.Tensor, residual: clika_runtime._core.Tensor | None = None, post_residual: clika_runtime._core.Tensor | None = None, normalized_shape: collections.abc.Sequence[int] = [], skip_bias: clika_runtime._core.Tensor | None = None, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

add_layer_norm(input, residual=None, post_residual=None, normalized_shape=[], skip_bias=None, weight=None, bias=None, eps=None, *, activation=None) -> tuple[Tensor, Tensor]

The `add_layer_norm` operator.

## `add_rms_norm`

```python
add_rms_normadd_rms_norm(input: clika_runtime._core.Tensor, residual: clika_runtime._core.Tensor | None = None, residual2: clika_runtime._core.Tensor | None = None, post_residual: clika_runtime._core.Tensor | None = None, normalized_shape: collections.abc.Sequence[int] = [], skip_bias: clika_runtime._core.Tensor | None = None, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

add_rms_norm(input: clika_runtime._core.Tensor, residual: clika_runtime._core.Tensor | None = None, residual2: clika_runtime._core.Tensor | None = None, post_residual: clika_runtime._core.Tensor | None = None, normalized_shape: collections.abc.Sequence[int] = [], skip_bias: clika_runtime._core.Tensor | None = None, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

add_rms_norm(input, residual=None, residual2=None, post_residual=None, normalized_shape=[], skip_bias=None, weight=None, bias=None, eps=None, *, activation=None) -> tuple[Tensor, Tensor]

The `add_rms_norm` operator.

## `affine_grid`

```python
affine_grid(theta: 'Tensor', size: 'Sequence[int]', align_corners: 'bool | None' = None) -> 'Tensor'
```

affine_grid(theta, size, align_corners=None) -> Tensor

The sampling grid ``grid_sample`` reads for the affine maps ``theta``
(``[N, 2, 3]`` for a 2-d output, ``[N, 3, 4]`` for a 3-d one), over an
output of ``size = (N, C, H, W)`` or ``(N, C, D, H, W)``: normalized
coordinates in ``[-1, 1]`` per output position, shaped
``[N, H, W, 2]`` or ``[N, D, H, W, 3]``.

## `alpha_dropout`

```python
alpha_dropout(input: 'Tensor', p: 'float' = 0.5, training: 'bool' = False, inplace: 'bool' = False) -> 'Tensor'
```

alpha_dropout(input, p=0.5, training=False, inplace=False) -> Tensor

The self-normalizing dropout that keeps the mean and variance of a SELU
activation: a dropped element takes the saturation value and the result
is rescaled and shifted, while ``training`` is True; otherwise the
identity.

## `avg_pool`

```python
avg_poolavg_pool(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], ceil_mode: bool, count_include_pad: bool, divisor_override: int | None) -> clika_runtime._core.Tensor
```

avg_pool(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], ceil_mode: bool, count_include_pad: bool, divisor_override: int | None) -> clika_runtime._core.Tensor

avg_pool(input, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override) -> Tensor

The `avg_pool` operator.

## `avg_pool1d`

```python
avg_pool1d(input: 'Tensor', kernel_size: 'int | Sequence[int]', stride: 'int | Sequence[int] | None' = None, padding: 'int | Sequence[int]' = 0, ceil_mode: 'bool' = False, count_include_pad: 'bool' = True) -> 'Tensor'
```

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

1-d average pooling over channels-last ``[batch, length, channels]``;
``stride=None`` means the kernel size.

## `avg_pool2d`

```python
avg_pool2d(input: 'Tensor', kernel_size: 'int | Sequence[int]', stride: 'int | Sequence[int] | None' = None, padding: 'int | Sequence[int]' = 0, ceil_mode: 'bool' = False, count_include_pad: 'bool' = True, divisor_override: 'int | None' = None) -> 'Tensor'
```

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

2-d average pooling over channels-last ``[batch, height, width,
channels]``; ``stride=None`` means the kernel size;
``divisor_override`` replaces the window count as the divisor.

## `avg_pool3d`

```python
avg_pool3d(input: 'Tensor', kernel_size: 'int | Sequence[int]', stride: 'int | Sequence[int] | None' = None, padding: 'int | Sequence[int]' = 0, ceil_mode: 'bool' = False, count_include_pad: 'bool' = True, divisor_override: 'int | None' = None) -> 'Tensor'
```

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

3-d average pooling over channels-last ``[batch, depth, height, width,
channels]``; ``stride=None`` means the kernel size.

## `batch_norm`

```python
batch_norm(input: 'Tensor', running_mean: 'Tensor | None', running_var: 'Tensor | None', weight: 'Tensor | None' = None, bias: 'Tensor | None' = None, training: 'bool' = False, momentum: 'float' = 0.1, eps: 'float' = 1e-05, *, activation: 'ActivationLike' = None) -> 'Tensor'
```

batch_norm(input, running_mean, running_var, weight=None, bias=None, training=False, momentum=0.1, eps=1e-05, *, activation=None) -> Tensor

Normalize each channel of channels-last ``[batch, *spatial, channels]``
input, then scale and shift it by ``weight`` and ``bias``. With
``training=False`` the running statistics are the statistics. With
``training=True`` the batch's own mean and variance over every axis but
the channel axis normalize it, and the running statistics that are given
move toward the batch's in place: ``running = (1 - momentum) * running +
momentum * batch``, with the unbiased variance. ``activation`` (a name
such as ``"relu"``) applies to the result in the same operator.

## `bilinear`

```python
bilinear(input1: 'Tensor', input2: 'Tensor', weight: 'Tensor', bias: 'Tensor | None' = None) -> 'Tensor'
```

bilinear(input1, input2, weight, bias=None) -> Tensor

``y = x1^T W x2 + b`` with ``weight`` ``[out, in1, in2]``: every
leading dimension of the inputs is a batch dimension.

## `binary_cross_entropy`

```python
binary_cross_entropybinary_cross_entropy(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, reduction: object = 'mean') -> clika_runtime._core.Tensor
```

binary_cross_entropy(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, reduction: object = 'mean') -> clika_runtime._core.Tensor

binary_cross_entropy(input, target, weight=None, reduction='mean') -> Tensor

The `binary_cross_entropy` operator.

## `binary_cross_entropy_with_logits`

```python
binary_cross_entropy_with_logitsbinary_cross_entropy_with_logits(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, reduction: object = 'mean', pos_weight: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

binary_cross_entropy_with_logits(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, reduction: object = 'mean', pos_weight: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

binary_cross_entropy_with_logits(input, target, weight=None, reduction='mean', pos_weight=None) -> Tensor

The `binary_cross_entropy_with_logits` operator.

## `celu`

```python
celu(input: clika_runtime._core.Tensor, alpha: float = 1.0, inplace: bool = False) -> clika_runtime._core.Tensor
```

celu(input, alpha=1.0, inplace=False) -> Tensor

Continuously differentiable exponential linear unit: max(0, input) + min(0,
alpha * (exp(input / alpha) - 1)). ``inplace=True`` writes the result into
``input`` and returns ``input`` itself.

## `celu_`

```python
celu_celu_(self: clika_runtime._core.Tensor, alpha: float = 1.0) -> clika_runtime._core.Tensor
```

celu_(self: clika_runtime._core.Tensor, alpha: float = 1.0) -> clika_runtime._core.Tensor

celu_(self, alpha=1.0) -> Tensor

The `celu_` operator.

## `channel_shuffle`

```python
channel_shuffle(input: 'Tensor', groups: 'int') -> 'Tensor'
```

channel_shuffle(input, groups) -> Tensor

Interleave the channels of ``groups`` groups: channel ``g * (C //
groups) + i`` moves to ``i * groups + g`` (the channel axis is the last
one).

## `circular_pad`

```python
circular_padcircular_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor
```

circular_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor

circular_pad(input, pad) -> Tensor

The `circular_pad` operator.

## `constant_pad`

```python
constant_padconstant_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], value: clika_runtime._core.ops.ScalarOrTensor | None = None) -> clika_runtime._core.Tensor
```

constant_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], value: clika_runtime._core.ops.ScalarOrTensor | None = None) -> clika_runtime._core.Tensor

constant_pad(input, pad, value=None) -> Tensor

The `constant_pad` operator.

## `conv`

```python
convconv(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

conv(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

conv(input, weight, bias, stride, padding, dilation, groups, mode='constant', value=None, *, activation='identity') -> Tensor

The `conv` operator.

## `conv1d`

```python
conv1dconv1d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

conv1d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

conv1d(input, weight, bias=None, stride=[1], padding=[0], dilation=[1], groups=1, *, activation='identity') -> Tensor

The `conv1d` operator.

## `conv2d`

```python
conv2dconv2d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

conv2d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

conv2d(input, weight, bias=None, stride=[1, 1], padding=[0, 0], dilation=[1, 1], groups=1, *, activation='identity') -> Tensor

The `conv2d` operator.

## `conv3d`

```python
conv3dconv3d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

conv3d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

conv3d(input, weight, bias=None, stride=[1, 1, 1], padding=[0, 0, 0], dilation=[1, 1, 1], groups=1, *, activation='identity') -> Tensor

The `conv3d` operator.

## `conv_transpose`

```python
conv_transposeconv_transpose(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], groups: int, dilation: collections.abc.Sequence[int], *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

conv_transpose(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], groups: int, dilation: collections.abc.Sequence[int], *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

conv_transpose(input, weight, bias, stride, padding, output_padding, groups, dilation, *, activation='identity') -> Tensor

The `conv_transpose` operator.

## `conv_transpose1d`

```python
conv_transpose1dconv_transpose1d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0, 0], output_padding: collections.abc.Sequence[int] = [0], groups: int = 1, dilation: collections.abc.Sequence[int] = [1], *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

conv_transpose1d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0, 0], output_padding: collections.abc.Sequence[int] = [0], groups: int = 1, dilation: collections.abc.Sequence[int] = [1], *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

conv_transpose1d(input, weight, bias=None, stride=[1], padding=[0, 0], output_padding=[0], groups=1, dilation=[1], *, activation='identity') -> Tensor

The `conv_transpose1d` operator.

## `conv_transpose2d`

```python
conv_transpose2dconv_transpose2d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0], groups: int = 1, dilation: collections.abc.Sequence[int] = [1, 1], *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

conv_transpose2d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0], groups: int = 1, dilation: collections.abc.Sequence[int] = [1, 1], *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

conv_transpose2d(input, weight, bias=None, stride=[1, 1], padding=[0, 0, 0, 0], output_padding=[0, 0], groups=1, dilation=[1, 1], *, activation='identity') -> Tensor

The `conv_transpose2d` operator.

## `conv_transpose3d`

```python
conv_transpose3dconv_transpose3d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0, 0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0, 0], groups: int = 1, dilation: collections.abc.Sequence[int] = [1, 1, 1], *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

conv_transpose3d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0, 0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0, 0], groups: int = 1, dilation: collections.abc.Sequence[int] = [1, 1, 1], *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

conv_transpose3d(input, weight, bias=None, stride=[1, 1, 1], padding=[0, 0, 0, 0, 0, 0], output_padding=[0, 0, 0], groups=1, dilation=[1, 1, 1], *, activation='identity') -> Tensor

The `conv_transpose3d` operator.

## `cosine_embedding_loss`

```python
cosine_embedding_loss(input1: 'Tensor', input2: 'Tensor', target: 'Tensor', margin: 'float' = 0.0, reduction: 'Reduction' = 'mean') -> 'Tensor'
```

cosine_embedding_loss(input1, input2, target, margin=0.0, reduction="mean") -> Tensor

``1 - cos(x1, x2)`` where ``target == 1``, ``max(0, cos(x1, x2) -
margin)`` where ``target == -1``; then the reduction.

## `cosine_similarity`

```python
cosine_similarity(x1: 'Tensor', x2: 'Tensor', dim: 'int' = 1, eps: 'float' = 1e-08) -> 'Tensor'
```

cosine_similarity(x1, x2, dim=1, eps=1e-8) -> Tensor

``x1 . x2 / max(||x1|| ||x2||, eps)`` along ``dim``.

## `cross_entropy`

```python
cross_entropycross_entropy(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, ignore_index: int | None = None, reduction: object = 'mean') -> clika_runtime._core.Tensor
```

cross_entropy(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, ignore_index: int | None = None, reduction: object = 'mean') -> clika_runtime._core.Tensor

cross_entropy(input, target, weight=None, ignore_index=None, reduction='mean') -> Tensor

The `cross_entropy` operator.

## `dropout`

```python
dropout(input: 'Tensor', p: 'float' = 0.5, training: 'bool' = True, inplace: 'bool' = False) -> 'Tensor'
```

dropout(input, p=0.5, training=True, inplace=False) -> Tensor

Zero each element with probability ``p`` and scale the rest by
``1 / (1 - p)`` while ``training`` is True; otherwise the input passes
through unchanged. ``inplace=True`` writes the result into ``input``.

## `dropout1d`

```python
dropout1d(input: 'Tensor', p: 'float' = 0.5, training: 'bool' = True, inplace: 'bool' = False) -> 'Tensor'
```

dropout1d(input, p=0.5, training=True, inplace=False) -> Tensor

Channel-wise dropout for 1-d signals laid out channels-last, ``(N, L, C)``
or ``(L, C)``: whole channels are zeroed with probability ``p`` and the
rest scaled by ``1 / (1 - p)`` while ``training`` is True; otherwise the
identity.

## `dropout2d`

```python
dropout2d(input: 'Tensor', p: 'float' = 0.5, training: 'bool' = True, inplace: 'bool' = False) -> 'Tensor'
```

dropout2d(input, p=0.5, training=True, inplace=False) -> Tensor

Channel-wise dropout for 2-d feature maps laid out channels-last,
``(N, H, W, C)`` or ``(H, W, C)``: whole channels are zeroed with
probability ``p`` and the rest scaled by ``1 / (1 - p)`` while
``training`` is True; otherwise the identity.

## `dropout3d`

```python
dropout3d(input: 'Tensor', p: 'float' = 0.5, training: 'bool' = True, inplace: 'bool' = False) -> 'Tensor'
```

dropout3d(input, p=0.5, training=True, inplace=False) -> Tensor

Channel-wise dropout for 3-d feature maps laid out channels-last,
``(N, D, H, W, C)`` or ``(D, H, W, C)``: whole channels are zeroed with
probability ``p`` and the rest scaled by ``1 / (1 - p)`` while
``training`` is True; otherwise the identity.

## `elu`

```python
elu(input: clika_runtime._core.Tensor, alpha: float = 1.0, inplace: bool = False, *, scale: float = 1.0, input_scale: float = 1.0) -> clika_runtime._core.Tensor
```

elu(input, alpha=1.0, inplace=False, *, scale=1.0, input_scale=1.0) -> Tensor

Exponential linear unit: scale * input for input > 0, scale * alpha *
(exp(input_scale * input) - 1) otherwise. ``inplace=True`` writes the
result into ``input`` and returns ``input`` itself.

## `elu_`

```python
elu_elu_(self: clika_runtime._core.Tensor, alpha: float = 1.0, scale: float = 1.0, input_scale: float = 1.0) -> clika_runtime._core.Tensor
```

elu_(self: clika_runtime._core.Tensor, alpha: float = 1.0, scale: float = 1.0, input_scale: float = 1.0) -> clika_runtime._core.Tensor

elu_(self, alpha=1.0, scale=1.0, input_scale=1.0) -> Tensor

The `elu_` operator.

## `embedding`

```python
embeddingembedding(indices: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor
```

embedding(indices: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor

embedding(indices, weight, bias=None, *, activation=None) -> Tensor

The `embedding` operator.

## `fast_gelu`

```python
fast_gelufast_gelu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

fast_gelu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

fast_gelu(input) -> Tensor

The `fast_gelu` operator.

## `feature_alpha_dropout`

```python
feature_alpha_dropout(input: 'Tensor', p: 'float' = 0.5, training: 'bool' = False, inplace: 'bool' = False) -> 'Tensor'
```

feature_alpha_dropout(input, p=0.5, training=False, inplace=False) -> Tensor

Channel-wise alpha dropout over a channels-last input (the channel is the
last dim; every dim between the leading batch dim and it is spatial):
whole channels take the saturation value with probability ``p`` and the
result is rescaled and shifted, while ``training`` is True; otherwise
the identity.

## `fold`

```python
foldfold(input: clika_runtime._core.Tensor, output_size: collections.abc.Sequence[int], kernel_size: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], stride: collections.abc.Sequence[int] = [], mode: object = 'constant', value: float | None = None) -> clika_runtime._core.Tensor
```

fold(input: clika_runtime._core.Tensor, output_size: collections.abc.Sequence[int], kernel_size: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], stride: collections.abc.Sequence[int] = [], mode: object = 'constant', value: float | None = None) -> clika_runtime._core.Tensor

fold(input, output_size, kernel_size, dilation=[], padding=[], stride=[], mode='constant', value=None) -> Tensor

The `fold` operator.

## `gated_rms_norm`

```python
gated_rms_normgated_rms_norm(input: clika_runtime._core.Tensor, gate: clika_runtime._core.Tensor, normalized_shape: collections.abc.Sequence[int], weight: clika_runtime._core.Tensor | None = None, eps: float | None = None) -> clika_runtime._core.Tensor
```

gated_rms_norm(input: clika_runtime._core.Tensor, gate: clika_runtime._core.Tensor, normalized_shape: collections.abc.Sequence[int], weight: clika_runtime._core.Tensor | None = None, eps: float | None = None) -> clika_runtime._core.Tensor

gated_rms_norm(input, gate, normalized_shape, weight=None, eps=None) -> Tensor

The `gated_rms_norm` operator.

## `gaussian_nll_loss`

```python
gaussian_nll_loss(input: 'Tensor', target: 'Tensor', var: 'Tensor', full: 'bool' = False, eps: 'float' = 1e-06, reduction: 'Reduction' = 'mean') -> 'Tensor'
```

gaussian_nll_loss(input, target, var, full=False, eps=1e-6, reduction="mean") -> Tensor

``0.5 * (log(max(var, eps)) + (input - target)^2 / max(var, eps))``,
plus ``0.5 * log(2 pi)`` with ``full=True``; then the reduction.

## `geglu`

```python
geglugeglu(input: clika_runtime._core.Tensor, approximate: object | None = 'none') -> clika_runtime._core.Tensor
```

geglu(input: clika_runtime._core.Tensor, approximate: object | None = 'none') -> clika_runtime._core.Tensor

geglu(input, approximate='none') -> Tensor

The `geglu` operator.

## `gelu`

```python
gelugelu(input: clika_runtime._core.Tensor, approximate: object | None = 'none') -> clika_runtime._core.Tensor
```

gelu(input: clika_runtime._core.Tensor, approximate: object | None = 'none') -> clika_runtime._core.Tensor

gelu(input, approximate='none') -> Tensor

The `gelu` operator.

## `gelu_`

```python
gelu_gelu_(self: clika_runtime._core.Tensor, approximate: object | None = 'none') -> clika_runtime._core.Tensor
```

gelu_(self: clika_runtime._core.Tensor, approximate: object | None = 'none') -> clika_runtime._core.Tensor

gelu_(self, approximate='none') -> Tensor

The `gelu_` operator.

## `glu`

```python
gluglu(input: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor
```

glu(input: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor

glu(input, dim=-1) -> Tensor

The `glu` operator.

## `grid_sample`

```python
grid_samplegrid_sample(input: clika_runtime._core.Tensor, grid: clika_runtime._core.Tensor, mode: object = 'bilinear', padding_mode: object = 'zeros', align_corners: bool = False) -> clika_runtime._core.Tensor
```

grid_sample(input: clika_runtime._core.Tensor, grid: clika_runtime._core.Tensor, mode: object = 'bilinear', padding_mode: object = 'zeros', align_corners: bool = False) -> clika_runtime._core.Tensor

grid_sample(input, grid, mode='bilinear', padding_mode='zeros', align_corners=False) -> Tensor

The `grid_sample` operator.

## `group_norm`

```python
group_norm(input: 'Tensor', num_groups: 'int', weight: 'Tensor | None' = None, bias: 'Tensor | None' = None, eps: 'float' = 1e-05) -> 'Tensor'
```

group_norm(input, num_groups, weight=None, bias=None, eps=1e-05) -> Tensor

Normalize channels-last ``[batch, *spatial, channels]`` input per sample
over each of ``num_groups`` groups of consecutive channels and the
spatial dimensions, then scale and shift each channel by ``weight`` and
``bias``.

## `gumbel_softmax`

```python
gumbel_softmax(logits: 'Tensor', tau: 'float' = 1.0, hard: 'bool' = False, eps: 'float' = 1e-10, dim: 'int' = -1) -> 'Tensor'
```

gumbel_softmax(logits, tau=1.0, hard=False, eps=1e-10, dim=-1) -> Tensor

A sample from the Gumbel-softmax distribution: ``softmax((logits +
g) / tau)`` with ``g`` standard Gumbel noise. ``hard=True`` returns the
one-hot argmax of that sample instead.

## `hardshrink`

```python
hardshrinkhardshrink(input: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor
```

hardshrink(input: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor

hardshrink(input, lambd=0.5) -> Tensor

The `hardshrink` operator.

## `hardshrink_`

```python
hardshrink_hardshrink_(self: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor
```

hardshrink_(self: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor

hardshrink_(self, lambd=0.5) -> Tensor

The `hardshrink_` operator.

## `hardsigmoid`

```python
hardsigmoid(input: clika_runtime._core.Tensor, inplace: bool = False) -> clika_runtime._core.Tensor
```

hardsigmoid(input, inplace=False) -> Tensor

Piecewise-linear sigmoid approximation: clamp(input / 6 + 1 / 2, 0, 1).
``inplace=True`` writes the result into ``input`` and returns ``input``
itself.

## `hardsigmoid_`

```python
hardsigmoid_hardsigmoid_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

hardsigmoid_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

hardsigmoid_(self) -> Tensor

The `hardsigmoid_` operator.

## `hardswish`

```python
hardswish(input: clika_runtime._core.Tensor, inplace: bool = False) -> clika_runtime._core.Tensor
```

hardswish(input, inplace=False) -> Tensor

Piecewise-linear swish approximation: input * clamp(input / 6 + 1 / 2, 0,
1). ``inplace=True`` writes the result into ``input`` and returns ``input``
itself.

## `hardswish_`

```python
hardswish_hardswish_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

hardswish_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

hardswish_(self) -> Tensor

The `hardswish_` operator.

## `hardtanh`

```python
hardtanh(input: clika_runtime._core.Tensor, min_val: float = -1.0, max_val: float = 1.0, inplace: bool = False) -> clika_runtime._core.Tensor
```

hardtanh(input, min_val=-1.0, max_val=1.0, inplace=False) -> Tensor

Clamps every element to [min_val, max_val]. ``inplace=True`` writes the
result into ``input`` and returns ``input`` itself.

## `hardtanh_`

```python
hardtanh_hardtanh_(self: clika_runtime._core.Tensor, min_val: float = -1.0, max_val: float = 1.0) -> clika_runtime._core.Tensor
```

hardtanh_(self: clika_runtime._core.Tensor, min_val: float = -1.0, max_val: float = 1.0) -> clika_runtime._core.Tensor

hardtanh_(self, min_val=-1.0, max_val=1.0) -> Tensor

The `hardtanh_` operator.

## `hinge_embedding_loss`

```python
hinge_embedding_loss(input: 'Tensor', target: 'Tensor', margin: 'float' = 1.0, reduction: 'Reduction' = 'mean') -> 'Tensor'
```

hinge_embedding_loss(input, target, margin=1.0, reduction="mean") -> Tensor

``input`` where ``target == 1``, ``max(0, margin - input)`` where
``target == -1``; then the reduction.

## `huber_loss`

```python
huber_losshuber_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean', delta: float = 1.0) -> clika_runtime._core.Tensor
```

huber_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean', delta: float = 1.0) -> clika_runtime._core.Tensor

huber_loss(input, target, reduction='mean', delta=1.0) -> Tensor

The `huber_loss` operator.

## `instance_norm`

```python
instance_norm(input: 'Tensor', running_mean: 'Tensor | None' = None, running_var: 'Tensor | None' = None, weight: 'Tensor | None' = None, bias: 'Tensor | None' = None, use_input_stats: 'bool' = True, momentum: 'float' = 0.1, eps: 'float' = 1e-05, *, activation: 'ActivationLike' = None) -> 'Tensor'
```

instance_norm(input, running_mean=None, running_var=None, weight=None, bias=None, use_input_stats=True, momentum=0.1, eps=1e-05, *, activation=None) -> Tensor

Normalize each channel of each sample of channels-last ``[batch,
*spatial, channels]`` input over its spatial dimensions, then scale and
shift it by ``weight`` and ``bias``. With ``use_input_stats=False`` the
running statistics are the statistics. With ``use_input_stats=True``
each instance's own mean and variance normalize it, and the running
statistics that are given move toward the batch average of those in
place: ``running = (1 - momentum) * running + momentum * average``, with
the unbiased variance. ``activation`` (a name such as ``"relu"``)
applies to the result in the same operator.

## `interpolate`

```python
interpolate(input: 'Tensor', size: 'int | Sequence[int] | None' = None, scale_factor: 'float | Sequence[float] | None' = None, mode: 'InterpolationMode' = 'nearest', align_corners: 'bool | None' = None, recompute_scale_factor: 'bool | None' = None, antialias: 'bool' = False) -> 'Tensor'
```

interpolate(input, size=None, scale_factor=None, mode="nearest", align_corners=None, recompute_scale_factor=None, antialias=False) -> Tensor

Resample the spatial dimensions of channels-last ``[batch, *spatial,
channels]`` input to ``size`` OR by ``scale_factor`` (exactly one). The
rank picks the variant, so ``"linear"``, ``"bilinear"`` and
``"trilinear"`` name the same interpolation; ``"nearest"``,
``"nearest-exact"``, ``"bicubic"`` and ``"area"`` are the others.

## `kl_div`

```python
kl_divkl_div(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean', log_target: bool = False) -> clika_runtime._core.Tensor
```

kl_div(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean', log_target: bool = False) -> clika_runtime._core.Tensor

kl_div(input, target, reduction='mean', log_target=False) -> Tensor

The `kl_div` operator.

## `l1_loss`

```python
l1_lossl1_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean') -> clika_runtime._core.Tensor
```

l1_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean') -> clika_runtime._core.Tensor

l1_loss(input, target, reduction='mean') -> Tensor

The `l1_loss` operator.

## `layer_norm`

```python
layer_normlayer_norm(input: clika_runtime._core.Tensor, normalized_shape: collections.abc.Sequence[int], weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor
```

layer_norm(input: clika_runtime._core.Tensor, normalized_shape: collections.abc.Sequence[int], weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor

layer_norm(input, normalized_shape, weight=None, bias=None, eps=None, *, activation=None) -> Tensor

The `layer_norm` operator.

## `leaky_relu`

```python
leaky_relu(input: clika_runtime._core.Tensor, negative_slope: float = 0.01, inplace: bool = False) -> clika_runtime._core.Tensor
```

leaky_relu(input, negative_slope=0.01, inplace=False) -> Tensor

ReLU with a small slope on the negative side: input for input > 0,
negative_slope * input otherwise. ``inplace=True`` writes the result into
``input`` and returns ``input`` itself.

## `leaky_relu_`

```python
leaky_relu_leaky_relu_(self: clika_runtime._core.Tensor, negative_slope: float = 0.01) -> clika_runtime._core.Tensor
```

leaky_relu_(self: clika_runtime._core.Tensor, negative_slope: float = 0.01) -> clika_runtime._core.Tensor

leaky_relu_(self, negative_slope=0.01) -> Tensor

The `leaky_relu_` operator.

## `linear`

```python
linearlinear(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, situ_beta: float = 0.0, situ_linear_beta: float = 0.0) -> clika_runtime._core.Tensor
```

linear(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, situ_beta: float = 0.0, situ_linear_beta: float = 0.0) -> clika_runtime._core.Tensor

linear(input, weight, bias=None, *, activation=None, situ_beta=0.0, situ_linear_beta=0.0) -> Tensor

The `linear` operator.

## `local_response_norm`

```python
local_response_norm(input: 'Tensor', size: 'int', alpha: 'float' = 0.0001, beta: 'float' = 0.75, k: 'float' = 1.0) -> 'Tensor'
```

local_response_norm(input, size, alpha=1e-4, beta=0.75, k=1.0) -> Tensor

``x / (k + alpha * sum_{neighbors} x^2) ** beta`` with the sum over a
window of ``size`` channels centered on each channel (the channel axis
is the last one).

## `log_sigmoid`

```python
log_sigmoidlog_sigmoid(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

log_sigmoid(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

log_sigmoid(input) -> Tensor

The `log_sigmoid` operator.

## `log_sigmoid_`

```python
log_sigmoid_log_sigmoid_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

log_sigmoid_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

log_sigmoid_(self) -> Tensor

The `log_sigmoid_` operator.

## `log_softmax`

```python
log_softmaxlog_softmax(input: clika_runtime._core.Tensor, dim: int = -1, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor
```

log_softmax(input: clika_runtime._core.Tensor, dim: int = -1, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

log_softmax(input, dim=-1, *, dtype=Undefined) -> Tensor

The `log_softmax` operator.

## `log_softmax_`

```python
log_softmax_log_softmax_(self: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor
```

log_softmax_(self: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor

log_softmax_(self, dim=-1) -> Tensor

The `log_softmax_` operator.

## `logit`

```python
logitlogit(input: clika_runtime._core.Tensor, eps: float | None = None) -> clika_runtime._core.Tensor
```

logit(input: clika_runtime._core.Tensor, eps: float | None = None) -> clika_runtime._core.Tensor

logit(input, eps=None) -> Tensor

The `logit` operator.

## `logit_`

```python
logit_logit_(self: clika_runtime._core.Tensor, eps: float | None = None) -> clika_runtime._core.Tensor
```

logit_(self: clika_runtime._core.Tensor, eps: float | None = None) -> clika_runtime._core.Tensor

logit_(self, eps=None) -> Tensor

The `logit_` operator.

## `logsigmoid`

```python
logsigmoid(input: 'Tensor') -> 'Tensor'
```

logsigmoid(input) -> Tensor

``log(1 / (1 + exp(-x)))``, element-wise (the ``log_sigmoid``
operator under its other spelling).

## `lp_pool1d`

```python
lp_pool1d(input: 'Tensor', norm_type: 'float', kernel_size: 'int | Sequence[int]', stride: 'int | Sequence[int] | None' = None, ceil_mode: 'bool' = False) -> 'Tensor'
```

lp_pool1d(input, norm_type, kernel_size, stride=None, ceil_mode=False) -> Tensor

Power-average pooling: the p-norm of each window
(``sum(x ** p) ** (1 / p)``) over channels-last ``[batch, length,
channels]``.

## `lp_pool2d`

```python
lp_pool2d(input: 'Tensor', norm_type: 'float', kernel_size: 'int | Sequence[int]', stride: 'int | Sequence[int] | None' = None, ceil_mode: 'bool' = False) -> 'Tensor'
```

lp_pool2d(input, norm_type, kernel_size, stride=None, ceil_mode=False) -> Tensor

Power-average pooling over channels-last ``[batch, height, width,
channels]``.

## `lp_pool3d`

```python
lp_pool3d(input: 'Tensor', norm_type: 'float', kernel_size: 'int | Sequence[int]', stride: 'int | Sequence[int] | None' = None, ceil_mode: 'bool' = False) -> 'Tensor'
```

lp_pool3d(input, norm_type, kernel_size, stride=None, ceil_mode=False) -> Tensor

Power-average pooling over channels-last ``[batch, depth, height,
width, channels]``.

## `margin_ranking_loss`

```python
margin_ranking_loss(input1: 'Tensor', input2: 'Tensor', target: 'Tensor', margin: 'float' = 0.0, reduction: 'Reduction' = 'mean') -> 'Tensor'
```

margin_ranking_loss(input1, input2, target, margin=0.0, reduction="mean") -> Tensor

``max(0, -target * (input1 - input2) + margin)``; then the reduction.

## `max_pool`

```python
max_poolmax_pool(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], ceil_mode: bool) -> clika_runtime._core.Tensor
```

max_pool(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], ceil_mode: bool) -> clika_runtime._core.Tensor

max_pool(input, kernel_size, stride, padding, dilation, ceil_mode) -> Tensor

The `max_pool` operator.

## `max_pool1d`

```python
max_pool1d(input: 'Tensor', kernel_size: 'int | Sequence[int]', stride: 'int | Sequence[int] | None' = None, padding: 'int | Sequence[int]' = 0, dilation: 'int | Sequence[int]' = 1, ceil_mode: 'bool' = False, return_indices: 'bool' = False) -> 'Tensor | tuple[Tensor, Tensor]'
```

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

1-d max pooling over channels-last ``[batch, length, channels]``;
``stride=None`` means the kernel size. ``return_indices=True`` also
returns the flat window-argmax indices.

## `max_pool1d_with_indices`

```python
max_pool1d_with_indicesmax_pool1d_with_indices(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], ceil_mode: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

max_pool1d_with_indices(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], ceil_mode: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

max_pool1d_with_indices(input, kernel_size, stride=[], padding=[0], dilation=[1], ceil_mode=False) -> tuple[Tensor, Tensor]

The `max_pool1d_with_indices` operator.

## `max_pool2d`

```python
max_pool2d(input: 'Tensor', kernel_size: 'int | Sequence[int]', stride: 'int | Sequence[int] | None' = None, padding: 'int | Sequence[int]' = 0, dilation: 'int | Sequence[int]' = 1, ceil_mode: 'bool' = False, return_indices: 'bool' = False) -> 'Tensor | tuple[Tensor, Tensor]'
```

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

2-d max pooling over channels-last ``[batch, height, width,
channels]``; ``stride=None`` means the kernel size.
``return_indices=True`` also returns the flat window-argmax indices.

## `max_pool2d_with_indices`

```python
max_pool2d_with_indicesmax_pool2d_with_indices(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], ceil_mode: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

max_pool2d_with_indices(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], ceil_mode: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

max_pool2d_with_indices(input, kernel_size, stride=[], padding=[0, 0], dilation=[1, 1], ceil_mode=False) -> tuple[Tensor, Tensor]

The `max_pool2d_with_indices` operator.

## `max_pool3d`

```python
max_pool3d(input: 'Tensor', kernel_size: 'int | Sequence[int]', stride: 'int | Sequence[int] | None' = None, padding: 'int | Sequence[int]' = 0, dilation: 'int | Sequence[int]' = 1, ceil_mode: 'bool' = False, return_indices: 'bool' = False) -> 'Tensor | tuple[Tensor, Tensor]'
```

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

3-d max pooling over channels-last ``[batch, depth, height, width,
channels]``; ``stride=None`` means the kernel size.
``return_indices=True`` also returns the flat window-argmax indices.

## `max_pool3d_with_indices`

```python
max_pool3d_with_indicesmax_pool3d_with_indices(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], ceil_mode: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

max_pool3d_with_indices(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], ceil_mode: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

max_pool3d_with_indices(input, kernel_size, stride=[], padding=[0, 0, 0], dilation=[1, 1, 1], ceil_mode=False) -> tuple[Tensor, Tensor]

The `max_pool3d_with_indices` operator.

## `max_pool_with_indices`

```python
max_pool_with_indicesmax_pool_with_indices(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], ceil_mode: bool) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

max_pool_with_indices(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], ceil_mode: bool) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

max_pool_with_indices(input, kernel_size, stride, padding, dilation, ceil_mode) -> tuple[Tensor, Tensor]

The `max_pool_with_indices` operator.

## `mish`

```python
mish(input: clika_runtime._core.Tensor, inplace: bool = False) -> clika_runtime._core.Tensor
```

mish(input, inplace=False) -> Tensor

Mish activation: input * tanh(softplus(input)). ``inplace=True`` writes the
result into ``input`` and returns ``input`` itself.

## `mish_`

```python
mish_mish_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

mish_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

mish_(self) -> Tensor

The `mish_` operator.

## `mse_loss`

```python
mse_lossmse_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean') -> clika_runtime._core.Tensor
```

mse_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean') -> clika_runtime._core.Tensor

mse_loss(input, target, reduction='mean') -> Tensor

The `mse_loss` operator.

## `multilabel_soft_margin_loss`

```python
multilabel_soft_margin_loss(input: 'Tensor', target: 'Tensor', weight: 'Tensor | None' = None, reduction: 'Reduction' = 'mean') -> 'Tensor'
```

multilabel_soft_margin_loss(input, target, weight=None, reduction="mean") -> Tensor

``-(target * logsigmoid(input) + (1 - target) * logsigmoid(-input))``
averaged over the class axis (the last one); then the reduction.

## `nll_loss`

```python
nll_lossnll_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, ignore_index: int | None = None, reduction: object = 'mean') -> clika_runtime._core.Tensor
```

nll_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, ignore_index: int | None = None, reduction: object = 'mean') -> clika_runtime._core.Tensor

nll_loss(input, target, weight=None, ignore_index=None, reduction='mean') -> Tensor

The `nll_loss` operator.

## `normalize`

```python
normalize(input: 'Tensor', p: 'float' = 2.0, dim: 'int' = 1, eps: 'float' = 1e-12) -> 'Tensor'
```

normalize(input, p=2.0, dim=1, eps=1e-12) -> Tensor

``x / max(||x||_p, eps)`` along ``dim``.

## `normalize_`

```python
normalize_normalize_(self: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...), dim: int = 1, eps: float | None = None) -> clika_runtime._core.Tensor
```

normalize_(self: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...), dim: int = 1, eps: float | None = None) -> clika_runtime._core.Tensor

normalize_(self, p=2.0, dim=1, eps=None) -> Tensor

The `normalize_` operator.

## `one_hot`

```python
one_hot(tensor: 'Tensor', num_classes: 'int' = -1) -> 'Tensor'
```

one_hot(tensor, num_classes=-1) -> Tensor

The one-hot encoding of integer ``tensor`` as a trailing axis of
``num_classes``; ``-1`` reads the class count off the largest index
(a value read that waits for the tensor).

## `pad`

```python
pad(input: 'Tensor', pad: 'Sequence[int]', mode: "Literal['constant', 'reflect', 'replicate', 'circular']" = 'constant', value: 'float | None' = None) -> 'Tensor'
```

pad(input, pad, mode="constant", value=None) -> Tensor

Pad ``input`` by ``pad``, read the way the reference framework reads
it: ``(left, right)`` pairs from the LAST dimension backwards, so
``pad=(1, 1)`` pads the last dimension, ``pad=(1, 1, 2, 2)`` the last
two, and a leading dimension the list does not reach stays as it is.
The pairs are converted to the runtime's leading-axis-first order
before the operator runs. ``mode`` is ``"constant"`` (filled with
``value``, ``None`` meaning 0), ``"reflect"``, ``"replicate"``, or
``"circular"``; a negative width crops that side.

## `pairwise_distance`

```python
pairwise_distance(x1: 'Tensor', x2: 'Tensor', p: 'float' = 2.0, eps: 'float' = 1e-06, keepdim: 'bool' = False) -> 'Tensor'
```

pairwise_distance(x1, x2, p=2.0, eps=1e-6, keepdim=False) -> Tensor

``||x1 - x2 + eps||_p`` along the last dimension.

## `pdist`

```python
pdistpdist(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...)) -> clika_runtime._core.Tensor
```

pdist(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...)) -> clika_runtime._core.Tensor

pdist(input, p=2.0) -> Tensor

The `pdist` operator.

## `pixel_shuffle`

```python
pixel_shufflepixel_shuffle(input: clika_runtime._core.Tensor, upscale_factor: int, mode: object = 'crd') -> clika_runtime._core.Tensor
```

pixel_shuffle(input: clika_runtime._core.Tensor, upscale_factor: int, mode: object = 'crd') -> clika_runtime._core.Tensor

pixel_shuffle(input, upscale_factor, mode='crd') -> Tensor

The `pixel_shuffle` operator.

## `pixel_unshuffle`

```python
pixel_unshufflepixel_unshuffle(input: clika_runtime._core.Tensor, downscale_factor: int, mode: object = 'crd') -> clika_runtime._core.Tensor
```

pixel_unshuffle(input: clika_runtime._core.Tensor, downscale_factor: int, mode: object = 'crd') -> clika_runtime._core.Tensor

pixel_unshuffle(input, downscale_factor, mode='crd') -> Tensor

The `pixel_unshuffle` operator.

## `poisson_nll_loss`

```python
poisson_nll_loss(input: 'Tensor', target: 'Tensor', log_input: 'bool' = True, full: 'bool' = False, size_average: 'bool | None' = None, eps: 'float' = 1e-08, reduce: 'bool | None' = None, reduction: 'Reduction' = 'mean') -> 'Tensor'
```

poisson_nll_loss(input, target, log_input=True, full=False, eps=1e-8, reduction="mean") -> Tensor

``exp(input) - target * input`` (``log_input=True``) or
``input - target * log(input + eps)``; ``full=True`` adds the Stirling
term where ``target > 1``; then the reduction.

## `prelu`

```python
preluprelu(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

prelu(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

prelu(input, weight=None) -> Tensor

The `prelu` operator.

## `prelu_`

```python
prelu_prelu_(self: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

prelu_(self: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

prelu_(self, weight=None) -> Tensor

The `prelu_` operator.

## `reflect_pad`

```python
reflect_padreflect_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor
```

reflect_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor

reflect_pad(input, pad) -> Tensor

The `reflect_pad` operator.

## `reglu`

```python
reglureglu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

reglu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

reglu(input) -> Tensor

The `reglu` operator.

## `relu`

```python
relu(input: clika_runtime._core.Tensor, inplace: bool = False) -> clika_runtime._core.Tensor
```

relu(input, inplace=False) -> Tensor

Rectified linear unit: max(0, input). ``inplace=True`` writes the result
into ``input`` and returns ``input`` itself.

## `relu6`

```python
relu6(input: clika_runtime._core.Tensor, inplace: bool = False) -> clika_runtime._core.Tensor
```

relu6(input, inplace=False) -> Tensor

ReLU capped at 6: clamp(input, 0, 6). ``inplace=True`` writes the result
into ``input`` and returns ``input`` itself.

## `relu6_`

```python
relu6_relu6_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

relu6_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

relu6_(self) -> Tensor

The `relu6_` operator.

## `relu_`

```python
relu_relu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

relu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

relu_(self) -> Tensor

The `relu_` operator.

## `replicate_pad`

```python
replicate_padreplicate_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor
```

replicate_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor

replicate_pad(input, pad) -> Tensor

The `replicate_pad` operator.

## `rms_norm`

```python
rms_normrms_norm(input: clika_runtime._core.Tensor, normalized_shape: collections.abc.Sequence[int], weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor
```

rms_norm(input: clika_runtime._core.Tensor, normalized_shape: collections.abc.Sequence[int], weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor

rms_norm(input, normalized_shape, weight=None, bias=None, eps=None, *, activation=None) -> Tensor

The `rms_norm` operator.

## `rrelu`

```python
rrelu(input: 'Tensor', lower: 'float' = 0.125, upper: 'float' = 0.3333333333333333, training: 'bool' = False, inplace: 'bool' = False) -> 'Tensor'
```

rrelu(input, lower=1/8, upper=1/3, training=False, inplace=False) -> Tensor

Randomized leaky ReLU: a negative element is multiplied by a slope drawn
uniformly from ``[lower, upper]`` for each element while ``training`` is
True, and by the fixed ``(lower + upper) / 2`` otherwise; the other
elements pass through. ``inplace=True`` writes the result into
``input`` and returns ``input`` itself.

## `scaled_dot_product_attention`

```python
scaled_dot_product_attention(query: 'Tensor', key: 'Tensor', value: 'Tensor', attn_mask: 'Tensor | None' = None, dropout_p: 'float' = 0.0, is_causal: 'bool' = False, scale: 'float | None' = None, enable_gqa: 'bool' = False) -> 'Tensor'
```

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

``softmax(scale * q k^T + mask) v`` over head-major ``[batch, heads,
seq, head_dim]`` tensors; ``scale=None`` means ``1 / sqrt(head_dim)``;
a boolean ``attn_mask`` keeps ``True`` positions, a floating one adds
to the logits. Grouped key / value heads broadcast to their query
group whichever way ``enable_gqa`` is set. ``dropout_p > 0`` raises
RuntimeError (this runtime serves inference).

## `scaled_dot_product_attention_varlen`

```python
scaled_dot_product_attention_varlenscaled_dot_product_attention_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool = False, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...)) -> clika_runtime._core.Tensor
```

scaled_dot_product_attention_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool = False, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...)) -> clika_runtime._core.Tensor

scaled_dot_product_attention_varlen(query, key, value, cu_seqlens_q, cu_seqlens_k, max_seqlen_q=None, max_seqlen_k=None, attn_mask=None, is_causal=False, q_scale=None, k_scale=None, v_scale=None) -> Tensor

The `scaled_dot_product_attention_varlen` operator.

## `selu`

```python
selu(input: clika_runtime._core.Tensor, inplace: bool = False) -> clika_runtime._core.Tensor
```

selu(input, inplace=False) -> Tensor

Scaled exponential linear unit: ELU with the fixed self-normalizing
constants (alpha about 1.6733, scale about 1.0507). ``inplace=True`` writes
the result into ``input`` and returns ``input`` itself.

## `selu_`

```python
selu_selu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

selu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

selu_(self) -> Tensor

The `selu_` operator.

## `sigmoid`

```python
sigmoidsigmoid(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sigmoid(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sigmoid(input) -> Tensor

The `sigmoid` operator.

## `sigmoid_`

```python
sigmoid_sigmoid_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sigmoid_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sigmoid_(self) -> Tensor

The `sigmoid_` operator.

## `silu`

```python
silu(input: clika_runtime._core.Tensor, inplace: bool = False) -> clika_runtime._core.Tensor
```

silu(input, inplace=False) -> Tensor

Sigmoid linear unit (swish): input * sigmoid(input). ``inplace=True``
writes the result into ``input`` and returns ``input`` itself.

## `silu_`

```python
silu_silu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

silu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

silu_(self) -> Tensor

The `silu_` operator.

## `smooth_l1_loss`

```python
smooth_l1_losssmooth_l1_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean', beta: float = 1.0) -> clika_runtime._core.Tensor
```

smooth_l1_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean', beta: float = 1.0) -> clika_runtime._core.Tensor

smooth_l1_loss(input, target, reduction='mean', beta=1.0) -> Tensor

The `smooth_l1_loss` operator.

## `soft_margin_loss`

```python
soft_margin_loss(input: 'Tensor', target: 'Tensor', reduction: 'Reduction' = 'mean') -> 'Tensor'
```

soft_margin_loss(input, target, reduction="mean") -> Tensor

``log(1 + exp(-target * input))``; then the reduction.

## `softmax`

```python
softmaxsoftmax(input: clika_runtime._core.Tensor, dim: int = -1, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor
```

softmax(input: clika_runtime._core.Tensor, dim: int = -1, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

softmax(input, dim=-1, *, dtype=Undefined) -> Tensor

The `softmax` operator.

## `softmax_`

```python
softmax_softmax_(self: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor
```

softmax_(self: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor

softmax_(self, dim=-1) -> Tensor

The `softmax_` operator.

## `softmin`

```python
softminsoftmin(input: clika_runtime._core.Tensor, dim: int = -1, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor
```

softmin(input: clika_runtime._core.Tensor, dim: int = -1, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

softmin(input, dim=-1, *, dtype=Undefined) -> Tensor

The `softmin` operator.

## `softmin_`

```python
softmin_softmin_(self: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor
```

softmin_(self: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor

softmin_(self, dim=-1) -> Tensor

The `softmin_` operator.

## `softplus`

```python
softplussoftplus(input: clika_runtime._core.Tensor, beta: float = 1.0, threshold: float = 20.0) -> clika_runtime._core.Tensor
```

softplus(input: clika_runtime._core.Tensor, beta: float = 1.0, threshold: float = 20.0) -> clika_runtime._core.Tensor

softplus(input, beta=1.0, threshold=20.0) -> Tensor

The `softplus` operator.

## `softplus_`

```python
softplus_softplus_(self: clika_runtime._core.Tensor, beta: float = 1.0, threshold: float = 20.0) -> clika_runtime._core.Tensor
```

softplus_(self: clika_runtime._core.Tensor, beta: float = 1.0, threshold: float = 20.0) -> clika_runtime._core.Tensor

softplus_(self, beta=1.0, threshold=20.0) -> Tensor

The `softplus_` operator.

## `softshrink`

```python
softshrinksoftshrink(input: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor
```

softshrink(input: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor

softshrink(input, lambd=0.5) -> Tensor

The `softshrink` operator.

## `softshrink_`

```python
softshrink_softshrink_(self: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor
```

softshrink_(self: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor

softshrink_(self, lambd=0.5) -> Tensor

The `softshrink_` operator.

## `softsign`

```python
softsignsoftsign(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

softsign(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

softsign(input) -> Tensor

The `softsign` operator.

## `softsign_`

```python
softsign_softsign_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

softsign_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

softsign_(self) -> Tensor

The `softsign_` operator.

## `swiglu`

```python
swigluswiglu(input: clika_runtime._core.Tensor, alpha: float = 1.0, beta: float = 0.0, limit: float = inf) -> clika_runtime._core.Tensor
```

swiglu(input: clika_runtime._core.Tensor, alpha: float = 1.0, beta: float = 0.0, limit: float = inf) -> clika_runtime._core.Tensor

swiglu(input, alpha=1.0, beta=0.0, limit=None) -> Tensor

The `swiglu` operator.

## `tanh`

```python
tanhtanh(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

tanh(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

tanh(input) -> Tensor

The `tanh` operator.

## `tanh_`

```python
tanh_tanh_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

tanh_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

tanh_(self) -> Tensor

The `tanh_` operator.

## `tanhshrink`

```python
tanhshrink(input: 'Tensor') -> 'Tensor'
```

tanhshrink(input) -> Tensor

``x - tanh(x)``, element-wise.

## `threshold`

```python
threshold(input: clika_runtime._core.Tensor, threshold: float, value: float, inplace: bool = False) -> clika_runtime._core.Tensor
```

threshold(input, threshold, value, inplace=False) -> Tensor

Keeps every element above threshold and replaces the rest with value.
``inplace=True`` writes the result into ``input`` and returns ``input``
itself.

## `threshold_`

```python
threshold_threshold_(self: clika_runtime._core.Tensor, threshold: float, value: float) -> clika_runtime._core.Tensor
```

threshold_(self: clika_runtime._core.Tensor, threshold: float, value: float) -> clika_runtime._core.Tensor

threshold_(self, threshold, value) -> Tensor

The `threshold_` operator.

## `triplet_margin_loss`

```python
triplet_margin_loss(anchor: 'Tensor', positive: 'Tensor', negative: 'Tensor', margin: 'float' = 1.0, p: 'float' = 2.0, eps: 'float' = 1e-06, swap: 'bool' = False, reduction: 'Reduction' = 'mean') -> 'Tensor'
```

triplet_margin_loss(anchor, positive, negative, margin=1.0, p=2.0, eps=1e-6, swap=False, reduction="mean") -> Tensor

``max(0, d(a, p) - d(a, n) + margin)`` with ``d`` the p-norm distance;
``swap=True`` uses the smaller of ``d(a, n)`` and ``d(p, n)``; then the
reduction.

## `unfold`

```python
unfoldunfold(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], stride: collections.abc.Sequence[int] = [], mode: object = 'constant', value: float | None = None) -> clika_runtime._core.Tensor
```

unfold(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], stride: collections.abc.Sequence[int] = [], mode: object = 'constant', value: float | None = None) -> clika_runtime._core.Tensor

unfold(input, kernel_size, dilation=[], padding=[], stride=[], mode='constant', value=None) -> Tensor

The `unfold` operator.

## `upsample`

```python
upsample(input: 'Tensor', size: 'int | Sequence[int] | None' = None, scale_factor: 'float | Sequence[float] | None' = None, mode: 'InterpolationMode' = 'nearest', align_corners: 'bool | None' = None) -> 'Tensor'
```

upsample(input, size=None, scale_factor=None, mode="nearest", align_corners=None) -> Tensor

The same resampling as :func:`interpolate`.

## `upsample_bicubic2d`

```python
upsample_bicubic2dupsample_bicubic2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor
```

upsample_bicubic2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor

upsample_bicubic2d(input, sizes=[], scale_factors=[], align_corners=False) -> Tensor

The `upsample_bicubic2d` operator.

## `upsample_bilinear`

```python
upsample_bilinear(input: 'Tensor', size: 'int | Sequence[int] | None' = None, scale_factor: 'float | Sequence[float] | None' = None) -> 'Tensor'
```

upsample_bilinear(input, size=None, scale_factor=None) -> Tensor

Bilinear resampling of the spatial dimensions with aligned corners.

## `upsample_bilinear2d`

```python
upsample_bilinear2dupsample_bilinear2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor
```

upsample_bilinear2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor

upsample_bilinear2d(input, sizes=[], scale_factors=[], align_corners=False) -> Tensor

The `upsample_bilinear2d` operator.

## `upsample_linear1d`

```python
upsample_linear1dupsample_linear1d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor
```

upsample_linear1d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor

upsample_linear1d(input, sizes=[], scale_factors=[], align_corners=False) -> Tensor

The `upsample_linear1d` operator.

## `upsample_nearest`

```python
upsample_nearest(input: 'Tensor', size: 'int | Sequence[int] | None' = None, scale_factor: 'float | Sequence[float] | None' = None) -> 'Tensor'
```

upsample_nearest(input, size=None, scale_factor=None) -> Tensor

Nearest-neighbor resampling of the spatial dimensions.

## `upsample_nearest1d`

```python
upsample_nearest1dupsample_nearest1d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor
```

upsample_nearest1d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor

upsample_nearest1d(input, sizes=[], scale_factors=[]) -> Tensor

The `upsample_nearest1d` operator.

## `upsample_nearest2d`

```python
upsample_nearest2dupsample_nearest2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor
```

upsample_nearest2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor

upsample_nearest2d(input, sizes=[], scale_factors=[]) -> Tensor

The `upsample_nearest2d` operator.

## `upsample_nearest3d`

```python
upsample_nearest3dupsample_nearest3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor
```

upsample_nearest3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor

upsample_nearest3d(input, sizes=[], scale_factors=[]) -> Tensor

The `upsample_nearest3d` operator.

## `upsample_trilinear3d`

```python
upsample_trilinear3dupsample_trilinear3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor
```

upsample_trilinear3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor

upsample_trilinear3d(input, sizes=[], scale_factors=[], align_corners=False) -> Tensor

The `upsample_trilinear3d` operator.