clika_runtime.nn.functional functions

adaptive_avg_pool

adaptive_avg_pool(*args, **kwargs)

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; its contract is ClikaRT::ops::adaptive_avg_pool in the C++ API reference.

adaptive_avg_pool1d

adaptive_avg_pool1d(*args, **kwargs)

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

adaptive_avg_pool1d(input, output_size) -> Tensor

The adaptive_avg_pool1d operator; its contract is ClikaRT::ops::adaptive_avg_pool1d in the C++ API reference.

adaptive_avg_pool2d

adaptive_avg_pool2d(*args, **kwargs)

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

adaptive_avg_pool2d(input, output_size) -> Tensor

The adaptive_avg_pool2d operator; its contract is ClikaRT::ops::adaptive_avg_pool2d in the C++ API reference.

adaptive_avg_pool3d

adaptive_avg_pool3d(*args, **kwargs)

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

adaptive_avg_pool3d(input, output_size) -> Tensor

The adaptive_avg_pool3d operator; its contract is ClikaRT::ops::adaptive_avg_pool3d in the C++ API reference.

adaptive_max_pool

adaptive_max_pool(*args, **kwargs)

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; its contract is ClikaRT::ops::adaptive_max_pool in the C++ API reference.

adaptive_max_pool1d

adaptive_max_pool1d(*args, **kwargs)

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

adaptive_max_pool1d(input, output_size) -> Tensor

The adaptive_max_pool1d operator; its contract is ClikaRT::ops::adaptive_max_pool1d in the C++ API reference.

adaptive_max_pool2d

adaptive_max_pool2d(*args, **kwargs)

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

adaptive_max_pool2d(input, output_size) -> Tensor

The adaptive_max_pool2d operator; its contract is ClikaRT::ops::adaptive_max_pool2d in the C++ API reference.

adaptive_max_pool3d

adaptive_max_pool3d(*args, **kwargs)

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

adaptive_max_pool3d(input, output_size) -> Tensor

The adaptive_max_pool3d operator; its contract is ClikaRT::ops::adaptive_max_pool3d in the C++ API reference.

add_layer_norm

add_layer_norm(*args, **kwargs)

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: clika_runtime._core.Activation | 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; its contract is ClikaRT::ops::add_layer_norm in the C++ API reference.

add_rms_norm

add_rms_norm(*args, **kwargs)

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: clika_runtime._core.Activation | 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; its contract is ClikaRT::ops::add_rms_norm in the C++ API reference.

avg_pool

avg_pool(*args, **kwargs)

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; its contract is ClikaRT::ops::avg_pool in the C++ API reference.

avg_pool1d

avg_pool1d(*args, **kwargs)

avg_pool1d(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [0], ceil_mode: bool = False, count_include_pad: bool = True) -> clika_runtime._core.Tensor

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

The avg_pool1d operator; its contract is ClikaRT::ops::avg_pool1d in the C++ API reference.

avg_pool2d

avg_pool2d(*args, **kwargs)

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

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

The avg_pool2d operator; its contract is ClikaRT::ops::avg_pool2d in the C++ API reference.

avg_pool3d

avg_pool3d(*args, **kwargs)

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

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

The avg_pool3d operator; its contract is ClikaRT::ops::avg_pool3d in the C++ API reference.

batch_norm

batch_norm(*args, **kwargs)

batch_norm(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, running_mean: clika_runtime._core.Tensor | None = None, running_var: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

batch_norm(input, weight=None, bias=None, running_mean=None, running_var=None, eps=None, *, activation=None) -> Tensor

The batch_norm operator; its contract is ClikaRT::ops::batch_norm in the C++ API reference.

binary_cross_entropy

binary_cross_entropy(*args, **kwargs)

binary_cross_entropy(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, reduction: clika_runtime.Reduction = Reduction.Mean) -> clika_runtime._core.Tensor

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

The binary_cross_entropy operator; its contract is ClikaRT::ops::binary_cross_entropy in the C++ API reference.

binary_cross_entropy_with_logits

binary_cross_entropy_with_logits(*args, **kwargs)

binary_cross_entropy_with_logits(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, reduction: clika_runtime.Reduction = Reduction.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; its contract is ClikaRT::ops::binary_cross_entropy_with_logits in the C++ API reference.

celu

celu(*args, **kwargs)

celu(input: clika_runtime._core.Tensor, alpha: float = 1.0) -> clika_runtime._core.Tensor

celu(input, alpha=1.0) -> Tensor

The celu operator; its contract is ClikaRT::ops::celu in the C++ API reference.

celu_

celu_(*args, **kwargs)

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

celu_(self, alpha=1.0) -> Tensor

The celu_ operator; its contract is ClikaRT::ops::celu_ in the C++ API reference.

circular_pad

circular_pad(*args, **kwargs)

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

circular_pad(input, pad) -> Tensor

The circular_pad operator; its contract is ClikaRT::ops::circular_pad in the C++ API reference.

constant_pad

constant_pad(*args, **kwargs)

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

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

The constant_pad operator; its contract is ClikaRT::ops::constant_pad in the C++ API reference.

conv

conv(*args, **kwargs)

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: clika_runtime._core.PadMode = PadMode.Constant, value: float | None = None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

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

The conv operator; its contract is ClikaRT::ops::conv in the C++ API reference.

conv1d

conv1d(*args, **kwargs)

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: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

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

The conv1d operator; its contract is ClikaRT::ops::conv1d in the C++ API reference.

conv2d

conv2d(*args, **kwargs)

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: clika_runtime._core.Activation = Activation.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; its contract is ClikaRT::ops::conv2d in the C++ API reference.

conv3d

conv3d(*args, **kwargs)

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: clika_runtime._core.Activation = Activation.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; its contract is ClikaRT::ops::conv3d in the C++ API reference.

conv_transpose

conv_transpose(*args, **kwargs)

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: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

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

The conv_transpose operator; its contract is ClikaRT::ops::conv_transpose in the C++ API reference.

conv_transpose1d

conv_transpose1d(*args, **kwargs)

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: clika_runtime._core.Activation = Activation.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; its contract is ClikaRT::ops::conv_transpose1d in the C++ API reference.

conv_transpose2d

conv_transpose2d(*args, **kwargs)

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: clika_runtime._core.Activation = Activation.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; its contract is ClikaRT::ops::conv_transpose2d in the C++ API reference.

conv_transpose3d

conv_transpose3d(*args, **kwargs)

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: clika_runtime._core.Activation = Activation.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; its contract is ClikaRT::ops::conv_transpose3d in the C++ API reference.

cosine_similarity

cosine_similarity(*args, **kwargs)

cosine_similarity(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, dim: int = 1, eps: float | None = None) -> clika_runtime._core.Tensor

cosine_similarity(input, other, dim=1, eps=None) -> Tensor

The cosine_similarity operator; its contract is ClikaRT::ops::cosine_similarity in the C++ API reference.

cross_entropy

cross_entropy(*args, **kwargs)

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: clika_runtime.Reduction = Reduction.Mean) -> clika_runtime._core.Tensor

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

The cross_entropy operator; its contract is ClikaRT::ops::cross_entropy in the C++ API reference.

elu

elu(*args, **kwargs)

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

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

The elu operator; its contract is ClikaRT::ops::elu in the C++ API reference.

elu_

elu_(*args, **kwargs)

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; its contract is ClikaRT::ops::elu_ in the C++ API reference.

embedding

embedding(*args, **kwargs)

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

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

The embedding operator; its contract is ClikaRT::ops::embedding in the C++ API reference.

fast_gelu

fast_gelu(*args, **kwargs)

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

fast_gelu(input) -> Tensor

The fast_gelu operator; its contract is ClikaRT::ops::fast_gelu in the C++ API reference.

fold

fold(*args, **kwargs)

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: clika_runtime._core.PadMode = PadMode.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; its contract is ClikaRT::ops::fold in the C++ API reference.

gated_rms_norm

gated_rms_norm(*args, **kwargs)

gated_rms_norm(input: clika_runtime._core.Tensor, other: 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, other, normalized_shape, weight=None, eps=None) -> Tensor

The gated_rms_norm operator; its contract is ClikaRT::ops::gated_rms_norm in the C++ API reference.

geglu

geglu(*args, **kwargs)

geglu(input: clika_runtime.core.Tensor, approximate: clika_runtime.GeluMode = GeluMode.None) -> clika_runtime._core.Tensor

geglu(input, approximate=None) -> Tensor

The geglu operator; its contract is ClikaRT::ops::geglu in the C++ API reference.

gelu

gelu(*args, **kwargs)

gelu(input: clika_runtime.core.Tensor, approximate: clika_runtime.GeluMode = GeluMode.None) -> clika_runtime._core.Tensor

gelu(input, approximate=None) -> Tensor

The gelu operator; its contract is ClikaRT::ops::gelu in the C++ API reference.

gelu_

gelu_(*args, **kwargs)

gelu_(self: clika_runtime.core.Tensor, approximate: clika_runtime.GeluMode = GeluMode.None) -> clika_runtime._core.Tensor

gelu_(self, approximate=None) -> Tensor

The gelu_ operator; its contract is ClikaRT::ops::gelu_ in the C++ API reference.

glu

glu(*args, **kwargs)

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

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

The glu operator; its contract is ClikaRT::ops::glu in the C++ API reference.

grid_sample

grid_sample(*args, **kwargs)

grid_sample(input: clika_runtime._core.Tensor, grid: clika_runtime._core.Tensor, mode: clika_runtime.GridSampleMode = GridSampleMode.Bilinear, padding_mode: clika_runtime.GridSamplePaddingMode = GridSamplePaddingMode.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; its contract is ClikaRT::ops::grid_sample in the C++ API reference.

group_norm

group_norm(*args, **kwargs)

group_norm(input: clika_runtime._core.Tensor, num_groups: int, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, running_mean: clika_runtime._core.Tensor | None = None, running_var: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

group_norm(input, num_groups, weight=None, bias=None, running_mean=None, running_var=None, eps=None, *, activation=None) -> Tensor

The group_norm operator; its contract is ClikaRT::ops::group_norm in the C++ API reference.

hardshrink

hardshrink(*args, **kwargs)

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

hardshrink(input, lambd=0.5) -> Tensor

The hardshrink operator; its contract is ClikaRT::ops::hardshrink in the C++ API reference.

hardshrink_

hardshrink_(*args, **kwargs)

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

hardshrink_(self, lambd=0.5) -> Tensor

The hardshrink_ operator; its contract is ClikaRT::ops::hardshrink_ in the C++ API reference.

hardsigmoid

hardsigmoid(*args, **kwargs)

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

hardsigmoid(input) -> Tensor

The hardsigmoid operator; its contract is ClikaRT::ops::hardsigmoid in the C++ API reference.

hardsigmoid_

hardsigmoid_(*args, **kwargs)

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

hardsigmoid_(self) -> Tensor

The hardsigmoid_ operator; its contract is ClikaRT::ops::hardsigmoid_ in the C++ API reference.

hardswish

hardswish(*args, **kwargs)

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

hardswish(input) -> Tensor

The hardswish operator; its contract is ClikaRT::ops::hardswish in the C++ API reference.

hardswish_

hardswish_(*args, **kwargs)

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

hardswish_(self) -> Tensor

The hardswish_ operator; its contract is ClikaRT::ops::hardswish_ in the C++ API reference.

hardtanh

hardtanh(*args, **kwargs)

hardtanh(input: clika_runtime._core.Tensor, min_val: float = -1.0, max_val: float = 1.0) -> clika_runtime._core.Tensor

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

The hardtanh operator; its contract is ClikaRT::ops::hardtanh in the C++ API reference.

hardtanh_

hardtanh_(*args, **kwargs)

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; its contract is ClikaRT::ops::hardtanh_ in the C++ API reference.

huber_loss

huber_loss(*args, **kwargs)

huber_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: clika_runtime.Reduction = Reduction.Mean, delta: float = 1.0) -> clika_runtime._core.Tensor

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

The huber_loss operator; its contract is ClikaRT::ops::huber_loss in the C++ API reference.

instance_norm

instance_norm(*args, **kwargs)

instance_norm(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, running_mean: clika_runtime._core.Tensor | None = None, running_var: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

instance_norm(input, weight=None, bias=None, running_mean=None, running_var=None, eps=None, *, activation=None) -> Tensor

The instance_norm operator; its contract is ClikaRT::ops::instance_norm in the C++ API reference.

interpolate

interpolate(*args, **kwargs)

interpolate(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime.ScalarOrTensor] = [], mode: clika_runtime.InterpMode = InterpMode.Nearest, align_corners: bool | None = None, recompute_scale_factor: bool = False, antialias: bool = False) -> clika_runtime._core.Tensor

interpolate(input, sizes=[], scale_factors=[], mode=Nearest, align_corners=None, recompute_scale_factor=False, antialias=False) -> Tensor

The interpolate operator; its contract is ClikaRT::ops::interpolate in the C++ API reference.

kl_div

kl_div(*args, **kwargs)

kl_div(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: clika_runtime.Reduction = Reduction.Mean, log_target: bool = False) -> clika_runtime._core.Tensor

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

The kl_div operator; its contract is ClikaRT::ops::kl_div in the C++ API reference.

l1_loss

l1_loss(*args, **kwargs)

l1_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: clika_runtime.Reduction = Reduction.Mean) -> clika_runtime._core.Tensor

l1_loss(input, target, reduction=Mean) -> Tensor

The l1_loss operator; its contract is ClikaRT::ops::l1_loss in the C++ API reference.

layer_norm

layer_norm(*args, **kwargs)

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: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

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

The layer_norm operator; its contract is ClikaRT::ops::layer_norm in the C++ API reference.

leaky_relu

leaky_relu(*args, **kwargs)

leaky_relu(input: clika_runtime._core.Tensor, negative_slope: float = 0.01) -> clika_runtime._core.Tensor

leaky_relu(input, negative_slope=0.01) -> Tensor

The leaky_relu operator; its contract is ClikaRT::ops::leaky_relu in the C++ API reference.

leaky_relu_

leaky_relu_(*args, **kwargs)

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; its contract is ClikaRT::ops::leaky_relu_ in the C++ API reference.

linear

linear(*args, **kwargs)

linear(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | 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; its contract is ClikaRT::ops::linear in the C++ API reference.

log_sigmoid

log_sigmoid(*args, **kwargs)

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

log_sigmoid(input) -> Tensor

The log_sigmoid operator; its contract is ClikaRT::ops::log_sigmoid in the C++ API reference.

log_sigmoid_

log_sigmoid_(*args, **kwargs)

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

log_sigmoid_(self) -> Tensor

The log_sigmoid_ operator; its contract is ClikaRT::ops::log_sigmoid_ in the C++ API reference.

log_softmax

log_softmax(*args, **kwargs)

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; its contract is ClikaRT::ops::log_softmax in the C++ API reference.

log_softmax_

log_softmax_(*args, **kwargs)

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

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

The log_softmax_ operator; its contract is ClikaRT::ops::log_softmax_ in the C++ API reference.

logit

logit(*args, **kwargs)

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

logit(input, eps=None) -> Tensor

The logit operator; its contract is ClikaRT::ops::logit in the C++ API reference.

logit_

logit_(*args, **kwargs)

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

logit_(self, eps=None) -> Tensor

The logit_ operator; its contract is ClikaRT::ops::logit_ in the C++ API reference.

max_pool

max_pool(*args, **kwargs)

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; its contract is ClikaRT::ops::max_pool in the C++ API reference.

max_pool1d

max_pool1d(*args, **kwargs)

max_pool1d(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) -> clika_runtime._core.Tensor

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

The max_pool1d operator; its contract is ClikaRT::ops::max_pool1d in the C++ API reference.

max_pool1d_with_indices

max_pool1d_with_indices(*args, **kwargs)

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; its contract is ClikaRT::ops::max_pool1d_with_indices in the C++ API reference.

max_pool2d

max_pool2d(*args, **kwargs)

max_pool2d(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) -> clika_runtime._core.Tensor

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

The max_pool2d operator; its contract is ClikaRT::ops::max_pool2d in the C++ API reference.

max_pool2d_with_indices

max_pool2d_with_indices(*args, **kwargs)

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; its contract is ClikaRT::ops::max_pool2d_with_indices in the C++ API reference.

max_pool3d

max_pool3d(*args, **kwargs)

max_pool3d(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) -> clika_runtime._core.Tensor

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

The max_pool3d operator; its contract is ClikaRT::ops::max_pool3d in the C++ API reference.

max_pool3d_with_indices

max_pool3d_with_indices(*args, **kwargs)

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; its contract is ClikaRT::ops::max_pool3d_with_indices in the C++ API reference.

max_pool_with_indices

max_pool_with_indices(*args, **kwargs)

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; its contract is ClikaRT::ops::max_pool_with_indices in the C++ API reference.

mish

mish(*args, **kwargs)

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

mish(input) -> Tensor

The mish operator; its contract is ClikaRT::ops::mish in the C++ API reference.

mish_

mish_(*args, **kwargs)

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

mish_(self) -> Tensor

The mish_ operator; its contract is ClikaRT::ops::mish_ in the C++ API reference.

mse_loss

mse_loss(*args, **kwargs)

mse_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: clika_runtime.Reduction = Reduction.Mean) -> clika_runtime._core.Tensor

mse_loss(input, target, reduction=Mean) -> Tensor

The mse_loss operator; its contract is ClikaRT::ops::mse_loss in the C++ API reference.

nll_loss

nll_loss(*args, **kwargs)

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: clika_runtime.Reduction = Reduction.Mean) -> clika_runtime._core.Tensor

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

The nll_loss operator; its contract is ClikaRT::ops::nll_loss in the C++ API reference.

normalize

normalize(*args, **kwargs)

normalize(input: clika_runtime._core.Tensor, other: clika_runtime.Scalar = Scalar(...), dim: int = 1, eps: float | None = None) -> clika_runtime._core.Tensor

normalize(input, other=2.0, dim=1, eps=None) -> Tensor

The normalize operator; its contract is ClikaRT::ops::normalize in the C++ API reference.

normalize_

normalize_(*args, **kwargs)

normalize_(self: clika_runtime._core.Tensor, p: clika_runtime.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; its contract is ClikaRT::ops::normalize_ in the C++ API reference.

one_hot

one_hot(*args, **kwargs)

one_hot(indices: clika_runtime._core.Tensor, num_classes: int) -> clika_runtime._core.Tensor

one_hot(indices, num_classes) -> Tensor

The one_hot operator; its contract is ClikaRT::ops::one_hot in the C++ API reference.

pad

pad(*args, **kwargs)

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

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

The pad operator; its contract is ClikaRT::ops::pad in the C++ API reference.

pairwise_distance

pairwise_distance(*args, **kwargs)

pairwise_distance(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, p: clika_runtime.Scalar = Scalar(...), eps: float | None = None, keepdim: bool = False) -> clika_runtime._core.Tensor

pairwise_distance(input, other, p=2.0, eps=None, keepdim=False) -> Tensor

The pairwise_distance operator; its contract is ClikaRT::ops::pairwise_distance in the C++ API reference.

pdist

pdist(*args, **kwargs)

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

pdist(input, other=2.0) -> Tensor

The pdist operator; its contract is ClikaRT::ops::pdist in the C++ API reference.

pixel_shuffle

pixel_shuffle(*args, **kwargs)

pixel_shuffle(input: clika_runtime._core.Tensor, upscale_factor: int, mode: clika_runtime.PixelShuffleMode = PixelShuffleMode.CRD) -> clika_runtime._core.Tensor

pixel_shuffle(input, upscale_factor, mode=CRD) -> Tensor

The pixel_shuffle operator; its contract is ClikaRT::ops::pixel_shuffle in the C++ API reference.

pixel_unshuffle

pixel_unshuffle(*args, **kwargs)

pixel_unshuffle(input: clika_runtime._core.Tensor, downscale_factor: int, mode: clika_runtime.PixelShuffleMode = PixelShuffleMode.CRD) -> clika_runtime._core.Tensor

pixel_unshuffle(input, downscale_factor, mode=CRD) -> Tensor

The pixel_unshuffle operator; its contract is ClikaRT::ops::pixel_unshuffle in the C++ API reference.

prelu

prelu(*args, **kwargs)

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; its contract is ClikaRT::ops::prelu in the C++ API reference.

prelu_

prelu_(*args, **kwargs)

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; its contract is ClikaRT::ops::prelu_ in the C++ API reference.

reflect_pad

reflect_pad(*args, **kwargs)

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

reflect_pad(input, pad) -> Tensor

The reflect_pad operator; its contract is ClikaRT::ops::reflect_pad in the C++ API reference.

reglu

reglu(*args, **kwargs)

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

reglu(input) -> Tensor

The reglu operator; its contract is ClikaRT::ops::reglu in the C++ API reference.

relu

relu(*args, **kwargs)

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

relu(input) -> Tensor

The relu operator; its contract is ClikaRT::ops::relu in the C++ API reference.

relu6

relu6(*args, **kwargs)

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

relu6(input) -> Tensor

The relu6 operator; its contract is ClikaRT::ops::relu6 in the C++ API reference.

relu6_

relu6_(*args, **kwargs)

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

relu6_(self) -> Tensor

The relu6_ operator; its contract is ClikaRT::ops::relu6_ in the C++ API reference.

relu_

relu_(*args, **kwargs)

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

relu_(self) -> Tensor

The relu_ operator; its contract is ClikaRT::ops::relu_ in the C++ API reference.

replicate_pad

replicate_pad(*args, **kwargs)

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

replicate_pad(input, pad) -> Tensor

The replicate_pad operator; its contract is ClikaRT::ops::replicate_pad in the C++ API reference.

rms_norm

rms_norm(*args, **kwargs)

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: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

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

The rms_norm operator; its contract is ClikaRT::ops::rms_norm in the C++ API reference.

scaled_dot_product_attention

scaled_dot_product_attention(*args, **kwargs)

scaled_dot_product_attention(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, v: clika_runtime._core.Tensor, attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool = False, q_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), k_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...)) -> clika_runtime._core.Tensor

scaled_dot_product_attention(input, other, v, attn_mask=None, is_causal=False, q_scale=None, k_scale=None, v_scale=None) -> Tensor

The scaled_dot_product_attention operator; its contract is ClikaRT::ops::scaled_dot_product_attention in the C++ API reference.

scaled_dot_product_attention_varlen

scaled_dot_product_attention_varlen(*args, **kwargs)

scaled_dot_product_attention_varlen(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, v: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool = False, q_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), k_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...)) -> clika_runtime._core.Tensor

scaled_dot_product_attention_varlen(input, other, v, 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; its contract is ClikaRT::ops::scaled_dot_product_attention_varlen in the C++ API reference.

selu

selu(*args, **kwargs)

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

selu(input) -> Tensor

The selu operator; its contract is ClikaRT::ops::selu in the C++ API reference.

selu_

selu_(*args, **kwargs)

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

selu_(self) -> Tensor

The selu_ operator; its contract is ClikaRT::ops::selu_ in the C++ API reference.

sigmoid

sigmoid(*args, **kwargs)

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

sigmoid(input) -> Tensor

The sigmoid operator; its contract is ClikaRT::ops::sigmoid in the C++ API reference.

sigmoid_

sigmoid_(*args, **kwargs)

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

sigmoid_(self) -> Tensor

The sigmoid_ operator; its contract is ClikaRT::ops::sigmoid_ in the C++ API reference.

silu

silu(*args, **kwargs)

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

silu(input) -> Tensor

The silu operator; its contract is ClikaRT::ops::silu in the C++ API reference.

silu_

silu_(*args, **kwargs)

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

silu_(self) -> Tensor

The silu_ operator; its contract is ClikaRT::ops::silu_ in the C++ API reference.

smooth_l1_loss

smooth_l1_loss(*args, **kwargs)

smooth_l1_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: clika_runtime.Reduction = Reduction.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; its contract is ClikaRT::ops::smooth_l1_loss in the C++ API reference.

softmax

softmax(*args, **kwargs)

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; its contract is ClikaRT::ops::softmax in the C++ API reference.

softmax_

softmax_(*args, **kwargs)

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

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

The softmax_ operator; its contract is ClikaRT::ops::softmax_ in the C++ API reference.

softmin

softmin(*args, **kwargs)

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; its contract is ClikaRT::ops::softmin in the C++ API reference.

softmin_

softmin_(*args, **kwargs)

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

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

The softmin_ operator; its contract is ClikaRT::ops::softmin_ in the C++ API reference.

softplus

softplus(*args, **kwargs)

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; its contract is ClikaRT::ops::softplus in the C++ API reference.

softplus_

softplus_(*args, **kwargs)

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; its contract is ClikaRT::ops::softplus_ in the C++ API reference.

softshrink

softshrink(*args, **kwargs)

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

softshrink(input, lambd=0.5) -> Tensor

The softshrink operator; its contract is ClikaRT::ops::softshrink in the C++ API reference.

softshrink_

softshrink_(*args, **kwargs)

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

softshrink_(self, lambd=0.5) -> Tensor

The softshrink_ operator; its contract is ClikaRT::ops::softshrink_ in the C++ API reference.

softsign

softsign(*args, **kwargs)

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

softsign(input) -> Tensor

The softsign operator; its contract is ClikaRT::ops::softsign in the C++ API reference.

softsign_

softsign_(*args, **kwargs)

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

softsign_(self) -> Tensor

The softsign_ operator; its contract is ClikaRT::ops::softsign_ in the C++ API reference.

swiglu

swiglu(*args, **kwargs)

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; its contract is ClikaRT::ops::swiglu in the C++ API reference.

tanh

tanh(*args, **kwargs)

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

tanh(input) -> Tensor

The tanh operator; its contract is ClikaRT::ops::tanh in the C++ API reference.

tanh_

tanh_(*args, **kwargs)

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

tanh_(self) -> Tensor

The tanh_ operator; its contract is ClikaRT::ops::tanh_ in the C++ API reference.

threshold

threshold(*args, **kwargs)

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

threshold(input, threshold, value) -> Tensor

The threshold operator; its contract is ClikaRT::ops::threshold in the C++ API reference.

threshold_

threshold_(*args, **kwargs)

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

threshold_(self, threshold, value) -> Tensor

The threshold_ operator; its contract is ClikaRT::ops::threshold_ in the C++ API reference.

unfold

unfold(*args, **kwargs)

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: clika_runtime._core.PadMode = PadMode.Constant, value: float | None = None) -> clika_runtime._core.Tensor

unfold(input, kernel_size, dilation, padding, stride, mode=Constant, value=None) -> Tensor

The unfold operator; its contract is ClikaRT::ops::unfold in the C++ API reference.

upsample_bicubic2d

upsample_bicubic2d(*args, **kwargs)

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

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

The upsample_bicubic2d operator; its contract is ClikaRT::ops::upsample_bicubic2d in the C++ API reference.

upsample_bilinear2d

upsample_bilinear2d(*args, **kwargs)

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

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

The upsample_bilinear2d operator; its contract is ClikaRT::ops::upsample_bilinear2d in the C++ API reference.

upsample_linear1d

upsample_linear1d(*args, **kwargs)

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

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

The upsample_linear1d operator; its contract is ClikaRT::ops::upsample_linear1d in the C++ API reference.

upsample_nearest1d

upsample_nearest1d(*args, **kwargs)

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

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

The upsample_nearest1d operator; its contract is ClikaRT::ops::upsample_nearest1d in the C++ API reference.

upsample_nearest2d

upsample_nearest2d(*args, **kwargs)

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

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

The upsample_nearest2d operator; its contract is ClikaRT::ops::upsample_nearest2d in the C++ API reference.

upsample_nearest3d

upsample_nearest3d(*args, **kwargs)

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

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

The upsample_nearest3d operator; its contract is ClikaRT::ops::upsample_nearest3d in the C++ API reference.

upsample_trilinear3d

upsample_trilinear3d(*args, **kwargs)

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

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

The upsample_trilinear3d operator; its contract is ClikaRT::ops::upsample_trilinear3d in the C++ API reference.