clika_runtime functions

abs

abs(*args, **kwargs)

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

abs(input) -> Tensor

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

abs_

abs_(*args, **kwargs)

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

abs_(self) -> Tensor

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

acos

acos(*args, **kwargs)

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

acos(input) -> Tensor

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

acos_

acos_(*args, **kwargs)

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

acos_(self) -> Tensor

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

acosh

acosh(*args, **kwargs)

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

acosh(input) -> Tensor

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

acosh_

acosh_(*args, **kwargs)

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

acosh_(self) -> Tensor

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

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

add(*args, **kwargs)

add(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, alpha: float = 1.0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor add(a: clika_runtime.Scalar, input: clika_runtime._core.Tensor, alpha: float = 1.0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

Overloaded function.

1. add(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, alpha: float = 1.0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

add(input, other, alpha=1.0, *, activation=Identity) -> Tensor

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

2. add(a: clika_runtime.Scalar, input: clika_runtime._core.Tensor, alpha: float = 1.0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

add(a, input, alpha=1.0, *, activation=Identity) -> Tensor

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

add_

add_(*args, **kwargs)

add_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, alpha: float = 1.0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

add_(self, other, alpha=1.0, *, activation=Identity) -> Tensor

The add_ operator; its contract is ClikaRT::ops::add_ 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.

all

all(*args, **kwargs)

all(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor

all(input, dims=[], keepdim=False) -> Tensor

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

allclose

allclose(*args, **kwargs)

allclose(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, rtol: float = 1e-05, atol: float = 1e-08, equal_nan: bool = False) -> clika_runtime._core.Tensor

allclose(input, other, rtol=1e-5, atol=1e-8, equal_nan=False) -> Tensor

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

amax

amax(*args, **kwargs)

amax(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor

amax(input, dims=[], keepdim=False) -> Tensor

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

amin

amin(*args, **kwargs)

amin(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor

amin(input, dims=[], keepdim=False) -> Tensor

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

aminmax

aminmax(*args, **kwargs)

aminmax(input: clika_runtime._core.Tensor, dim: int | None = None, keepdim: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

aminmax(input, dim=None, keepdim=False) -> tuple[Tensor, Tensor]

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

any

any(*args, **kwargs)

any(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor

any(input, dims=[], keepdim=False) -> Tensor

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

arange

arange(start: 'int | float', end: 'int | float | None' = None, step: 'int | float' = 1, *, dtype: 'DataType | None' = None, device: 'DeviceLike' = None) -> 'Tensor'

Evenly spaced values in [start, end).

arange(n) counts from zero. All-integer arguments produce an int64 tensor, any float argument a float32 one; dtype overrides either.

argmax

argmax(*args, **kwargs)

argmax(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False, *, index_dtype: clika_runtime._core.DataType = DataType.Int64) -> clika_runtime._core.Tensor

argmax(input, dims=[], keepdim=False, *, index_dtype=Int64) -> Tensor

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

argmin

argmin(*args, **kwargs)

argmin(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False, *, index_dtype: clika_runtime._core.DataType = DataType.Int64) -> clika_runtime._core.Tensor

argmin(input, dims=[], keepdim=False, *, index_dtype=Int64) -> Tensor

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

argsort

argsort(*args, **kwargs)

argsort(input: clika_runtime._core.Tensor, dim: int = -1, descending: bool = False, stable: bool = False) -> clika_runtime._core.Tensor

argsort(input, dim=-1, descending=False, stable=False) -> Tensor

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

asin

asin(*args, **kwargs)

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

asin(input) -> Tensor

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

asin_

asin_(*args, **kwargs)

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

asin_(self) -> Tensor

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

asinh

asinh(*args, **kwargs)

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

asinh(input) -> Tensor

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

asinh_

asinh_(*args, **kwargs)

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

asinh_(self) -> Tensor

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

atan

atan(*args, **kwargs)

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

atan(input) -> Tensor

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

atan2

atan2(*args, **kwargs)

atan2(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

atan2(input, other) -> Tensor

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

atan2_

atan2_(*args, **kwargs)

atan2_(self: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

atan2_(self, other) -> Tensor

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

atan_

atan_(*args, **kwargs)

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

atan_(self) -> Tensor

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

atanh

atanh(*args, **kwargs)

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

atanh(input) -> Tensor

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

atanh_

atanh_(*args, **kwargs)

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

atanh_(self) -> Tensor

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

atleast_1d

atleast_1d(*args, **kwargs)

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

atleast_1d(input) -> Tensor

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

atleast_2d

atleast_2d(*args, **kwargs)

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

atleast_2d(input) -> Tensor

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

atleast_3d

atleast_3d(*args, **kwargs)

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

atleast_3d(input) -> Tensor

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

attention

attention(*args, **kwargs)

attention(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, v: clika_runtime._core.Tensor, attn_mask: clika_runtime._core.Tensor | None = None, head_sink: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, k_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...)) -> clika_runtime._core.Tensor

attention(input, other, v, attn_mask=None, head_sink=None, is_causal=None, q_scale=None, softcap=None, sliding_window=None, smooth_softmax=None, k_scale=None, v_scale=None) -> Tensor

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

attention_over_cache

attention_over_cache(*args, **kwargs)

attention_over_cache(input: clika_runtime._core.Tensor, cache_key: clika_runtime._core.Tensor, cache_value: clika_runtime._core.Tensor, kvcache_start: 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(...), rope_cos: clika_runtime._core.Tensor | None = None, rope_sin: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: clika_runtime.RotaryMode | None = None, num_heads: int | None = None, kv_num_heads: int | None = None, k_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), head_sink: clika_runtime._core.Tensor | None = None, q_norm_gain: clika_runtime._core.Tensor | None = None, k_norm_gain: clika_runtime._core.Tensor | None = None, qk_norm_eps: float | None = None, slot_ids: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

attention_over_cache(input, cache_key, cache_value, kvcache_start, cu_seqlens_q, cu_seqlens_k, max_seqlen_q=None, max_seqlen_k=None, rope_cos=None, rope_sin=None, position_ids=None, attn_mask=None, is_causal=None, q_scale=None, softcap=None, sliding_window=None, smooth_softmax=None, rotary_mode=None, num_heads=None, kv_num_heads=None, k_scale=None, v_scale=None, head_sink=None, q_norm_gain=None, k_norm_gain=None, qk_norm_eps=None, slot_ids=None) -> Tensor

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

attention_varlen

attention_varlen(*args, **kwargs)

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, head_sink: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, k_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...)) -> clika_runtime._core.Tensor

attention_varlen(input, other, v, cu_seqlens_q, cu_seqlens_k, max_seqlen_q=None, max_seqlen_k=None, attn_mask=None, head_sink=None, is_causal=None, q_scale=None, softcap=None, sliding_window=None, smooth_softmax=None, k_scale=None, v_scale=None) -> Tensor

The attention_varlen operator; its contract is ClikaRT::ops::attention_varlen 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.

bernoulli

bernoulli(*args, **kwargs)

bernoulli(probabilities: clika_runtime._core.Tensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

bernoulli(probabilities, *, device=None) -> Tensor

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

bernoulli_

bernoulli_(*args, **kwargs)

bernoulli_(self: clika_runtime._core.Tensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> None

bernoulli_(self, *, device=None) -> None

The bernoulli_ operator; its contract is ClikaRT::ops::bernoulli_ 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.

bincount

bincount(*args, **kwargs)

bincount(input: clika_runtime._core.Tensor, weights: clika_runtime._core.Tensor | None = None, minlength: int = 0) -> clika_runtime._core.Tensor

bincount(input, weights=None, minlength=0) -> Tensor

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

bitwise_and

bitwise_and(*args, **kwargs)

bitwise_and(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

bitwise_and(input, other) -> Tensor

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

bitwise_and_

bitwise_and_(*args, **kwargs)

bitwise_and_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

bitwise_and_(self, other) -> Tensor

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

bitwise_left_shift

bitwise_left_shift(*args, **kwargs)

bitwise_left_shift(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

bitwise_left_shift(input, other) -> Tensor

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

bitwise_left_shift_

bitwise_left_shift_(*args, **kwargs)

bitwise_left_shift_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

bitwise_left_shift_(self, other) -> Tensor

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

bitwise_not

bitwise_not(*args, **kwargs)

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

bitwise_not(input) -> Tensor

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

bitwise_not_

bitwise_not_(*args, **kwargs)

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

bitwise_not_(self) -> Tensor

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

bitwise_or

bitwise_or(*args, **kwargs)

bitwise_or(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

bitwise_or(input, other) -> Tensor

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

bitwise_or_

bitwise_or_(*args, **kwargs)

bitwise_or_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

bitwise_or_(self, other) -> Tensor

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

bitwise_right_shift

bitwise_right_shift(*args, **kwargs)

bitwise_right_shift(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

bitwise_right_shift(input, other) -> Tensor

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

bitwise_right_shift_

bitwise_right_shift_(*args, **kwargs)

bitwise_right_shift_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

bitwise_right_shift_(self, other) -> Tensor

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

bitwise_xor

bitwise_xor(*args, **kwargs)

bitwise_xor(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

bitwise_xor(input, other) -> Tensor

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

bitwise_xor_

bitwise_xor_(*args, **kwargs)

bitwise_xor_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

bitwise_xor_(self, other) -> Tensor

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

bmm

bmm(*args, **kwargs)

bmm(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

bmm(input, other, bias=None, *, activation=None) -> Tensor

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

broadcast_tensors

broadcast_tensors(*args, **kwargs)

broadcast_tensors(tensors: collections.abc.Sequence[clika_runtime._core.Tensor]) -> list[clika_runtime._core.Tensor]

broadcast_tensors(tensors) -> list[Tensor]

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

broadcast_to

broadcast_to(*args, **kwargs)

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

broadcast_to(input, shape) -> Tensor

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

bucketize

bucketize(*args, **kwargs)

bucketize(input: clika_runtime._core.Tensor, boundaries: clika_runtime._core.Tensor, out_int32: bool = False, right: bool = False) -> clika_runtime._core.Tensor

bucketize(input, boundaries, out_int32=False, right=False) -> Tensor

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

cast

cast(*args, **kwargs)

cast(input: clika_runtime._core.Tensor, target: clika_runtime._core.DataType, force_copy: bool = False) -> clika_runtime._core.Tensor

cast(input, target, force_copy=False) -> Tensor

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

cast_like

cast_like(*args, **kwargs)

cast_like(input: clika_runtime._core.Tensor, reference: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

cast_like(input, reference) -> Tensor

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

causal_conv_update

causal_conv_update(*args, **kwargs)

causal_conv_update(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None, state: clika_runtime._core.Tensor, seq_lens: clika_runtime._core.Tensor | None = None, slot_ids: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

causal_conv_update(input, weight, bias, state, seq_lens=None, slot_ids=None, *, activation=None) -> Tensor

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

cdist

cdist(*args, **kwargs)

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

cdist(input, other, p=2.0) -> Tensor

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

ceil

ceil(*args, **kwargs)

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

ceil(input) -> Tensor

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

ceil_

ceil_(*args, **kwargs)

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

ceil_(self) -> Tensor

The ceil_ operator; its contract is ClikaRT::ops::ceil_ 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.

chunk

chunk(*args, **kwargs)

chunk(input: clika_runtime._core.Tensor, num_chunks: int, dim: int = 0) -> list[clika_runtime._core.Tensor]

chunk(input, num_chunks, dim=0) -> list[Tensor]

The chunk operator; its contract is ClikaRT::ops::chunk 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.

clamp

clamp(*args, **kwargs)

clamp(input: clika_runtime._core.Tensor, min: clika_runtime.ScalarOrTensor | None = None, max: clika_runtime.ScalarOrTensor | None = None) -> clika_runtime._core.Tensor

clamp(input, min=None, max=None) -> Tensor

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

clamp_

clamp_(*args, **kwargs)

clamp_(self: clika_runtime._core.Tensor, min: clika_runtime.ScalarOrTensor | None = None, max: clika_runtime.ScalarOrTensor | None = None) -> clika_runtime._core.Tensor

clamp_(self, min=None, max=None) -> Tensor

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

clamp_max

clamp_max(*args, **kwargs)

clamp_max(input: clika_runtime._core.Tensor, max: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

clamp_max(input, max) -> Tensor

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

clamp_max_

clamp_max_(*args, **kwargs)

clamp_max_(self: clika_runtime._core.Tensor, max: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

clamp_max_(self, max) -> Tensor

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

clamp_min

clamp_min(*args, **kwargs)

clamp_min(input: clika_runtime._core.Tensor, min: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

clamp_min(input, min) -> Tensor

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

clamp_min_

clamp_min_(*args, **kwargs)

clamp_min_(self: clika_runtime._core.Tensor, min: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

clamp_min_(self, min) -> Tensor

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

clone

clone(*args, **kwargs)

clone(src: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

clone(src) -> Tensor

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

compile

compile(*args, **kwargs)

compile(fn: collections.abc.Callable, signature: collections.abc.Sequence[clika_runtime._core.TensorSpec] = [], *, optimize: bool = True, specialize: bool = False, dynamic_dims: collections.abc.Sequence[str] = [], dynamic_axes: collections.abc.Sequence[clika_runtime._core.DynamicAxis] = [], output_names: collections.abc.Sequence[str] = [], graph_name: str = 'compiled_model') -> clika_runtime._core.CompiledFunction

Wrap fn in a CompiledFunction. An empty signature derives one spec per input from the first call's tensors; dynamic_dims names signature dims to keep dynamic, dynamic_axes declares them by coordinate when the signature is derived.

concat

concat(*args, **kwargs)

concat(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], dim: int = 0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

concat(tensors, dim=0, *, activation=Identity) -> Tensor

The concat operator; its contract is ClikaRT::ops::concat 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.

contiguous

contiguous(*args, **kwargs)

contiguous(input: clika_runtime._core.Tensor, force_copy: bool = False) -> clika_runtime._core.Tensor

contiguous(input, force_copy=False) -> Tensor

The contiguous operator; its contract is ClikaRT::ops::contiguous 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.

copy

copy(*args, **kwargs)

copy(src: clika_runtime._core.Tensor, *, target: clika_runtime.StreamOrDevice = StreamOrDevice(...), force_copy: bool = True) -> clika_runtime._core.Tensor

copy(src, *, target=None, force_copy=True) -> Tensor

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

copy_

copy_(*args, **kwargs)

copy_(self: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, *, target: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

copy_(self, src, *, target=None) -> Tensor

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

copy_into

copy_into(*args, **kwargs)

copy_into(out: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, *, target: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

copy_into(out, src, *, target=None) -> Tensor

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

copy_to_cpu

copy_to_cpu(*args, **kwargs)

copy_to_cpu(src: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

copy_to_cpu(src) -> Tensor

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

copysign

copysign(*args, **kwargs)

copysign(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

copysign(input, other) -> Tensor

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

copysign_

copysign_(*args, **kwargs)

copysign_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

copysign_(self, other) -> Tensor

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

cos

cos(*args, **kwargs)

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

cos(input) -> Tensor

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

cos_

cos_(*args, **kwargs)

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

cos_(self) -> Tensor

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

cosh

cosh(*args, **kwargs)

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

cosh(input) -> Tensor

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

cosh_

cosh_(*args, **kwargs)

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

cosh_(self) -> Tensor

The cosh_ operator; its contract is ClikaRT::ops::cosh_ 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.

count_nonzero

count_nonzero(*args, **kwargs)

count_nonzero(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor

count_nonzero(input, dims=[]) -> Tensor

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

cross

cross(*args, **kwargs)

cross(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, dim: int | None = None) -> clika_runtime._core.Tensor

cross(input, other, dim=None) -> Tensor

The cross operator; its contract is ClikaRT::ops::cross 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.

cummax

cummax(*args, **kwargs)

cummax(input: clika_runtime._core.Tensor, dim: int) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

cummax(input, dim) -> tuple[Tensor, Tensor]

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

cummin

cummin(*args, **kwargs)

cummin(input: clika_runtime._core.Tensor, dim: int) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

cummin(input, dim) -> tuple[Tensor, Tensor]

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

cumprod

cumprod(*args, **kwargs)

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

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

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

cumprod_

cumprod_(*args, **kwargs)

cumprod_(self: clika_runtime._core.Tensor, dim: int, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

cumprod_(self, dim, *, dtype=Undefined) -> Tensor

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

cumsum

cumsum(*args, **kwargs)

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

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

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

cumsum_

cumsum_(*args, **kwargs)

cumsum_(self: clika_runtime._core.Tensor, dim: int, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

cumsum_(self, dim, *, dtype=Undefined) -> Tensor

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

deform_conv

deform_conv(*args, **kwargs)

deform_conv(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, offset_groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

deform_conv(input, weight, offset, mask=None, bias=None, stride=[], padding=[], dilation=[], groups=1, offset_groups=1, *, activation=Identity) -> Tensor

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

deg2rad

deg2rad(*args, **kwargs)

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

deg2rad(input) -> Tensor

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

deg2rad_

deg2rad_(*args, **kwargs)

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

deg2rad_(self) -> Tensor

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

dequantize

dequantize(*args, **kwargs)

dequantize(input: clika_runtime._core.QTensor, *, target_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

dequantize(input, *, target_dtype=Undefined) -> Tensor

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

dequantize_

dequantize_(*args, **kwargs)

dequantize_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

dequantize_(input, out) -> Tensor

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

device

device(target: 'Device | str') -> '_PlacementContext'

A placement region from a device: operations inside run on that device's default stream. Accepts a :class:Device or a device string; for a specific stream use :func:crt.stream.

diag

diag(*args, **kwargs)

diag(input: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

diag(input, diagonal=0) -> Tensor

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

diag_embed

diag_embed(*args, **kwargs)

diag_embed(input: clika_runtime._core.Tensor, offset: int = 0, dim1: int = -2, dim2: int = -1) -> clika_runtime._core.Tensor

diag_embed(input, offset=0, dim1=-2, dim2=-1) -> Tensor

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

diagonal

diagonal(*args, **kwargs)

diagonal(input: clika_runtime._core.Tensor, offset: int = 0, dim1: int = 0, dim2: int = 1) -> clika_runtime._core.Tensor

diagonal(input, offset=0, dim1=0, dim2=1) -> Tensor

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

diff

diff(*args, **kwargs)

diff(input: clika_runtime._core.Tensor, n: int = 1, dim: int = -1, prepend: clika_runtime._core.Tensor | None = None, append: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

diff(input, n=1, dim=-1, prepend=None, append=None) -> Tensor

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

div

div(*args, **kwargs)

div(input: clika_runtime.core.Tensor, other: clika_runtime.ScalarOrTensor, rounding_mode: clika_runtime.RoundingMode = RoundingMode.None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor div(a: clika_runtime.Scalar, input: clika_runtime.core.Tensor, rounding_mode: clika_runtime.RoundingMode = RoundingMode.None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

Overloaded function.

1. div(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, rounding_mode: clika_runtime.RoundingMode = RoundingMode.None_, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

div(input, other, rounding_mode=None, *, activation=Identity) -> Tensor

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

2. div(a: clika_runtime.Scalar, input: clika_runtime._core.Tensor, rounding_mode: clika_runtime.RoundingMode = RoundingMode.None_, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

div(a, input, rounding_mode=None, *, activation=Identity) -> Tensor

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

div_

div_(*args, **kwargs)

div_(self: clika_runtime.core.Tensor, other: clika_runtime.ScalarOrTensor, rounding_mode: clika_runtime.RoundingMode = RoundingMode.None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

div_(self, other, rounding_mode=None, *, activation=Identity) -> Tensor

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

dot

dot(*args, **kwargs)

dot(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

dot(input, other) -> Tensor

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

dynamic_quantize

dynamic_quantize(*args, **kwargs)

dynamic_quantize(input: clika_runtime._core.Tensor) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

dynamic_quantize(input) -> tuple[Tensor, Tensor, Tensor]

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

einsum

einsum(*args, **kwargs)

einsum(equation: str, operands: collections.abc.Sequence[clika_runtime._core.Tensor]) -> clika_runtime._core.Tensor

einsum(equation, operands) -> Tensor

The einsum operator; its contract is ClikaRT::ops::einsum 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.

empty

empty(*args, **kwargs)

empty(shape: collections.abc.Sequence[clika_runtime.ScalarOrTensor], dtype: clika_runtime._core.DataType, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...), pinned_for: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

empty(shape, dtype, *, device=None, pinned_for=None) -> Tensor

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

empty_like

empty_like(*args, **kwargs)

empty_like(reference: clika_runtime._core.Tensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

empty_like(reference, *, device=None) -> Tensor

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

empty_strided

empty_strided(*args, **kwargs)

empty_strided(size: collections.abc.Sequence[int], stride: collections.abc.Sequence[int], dtype: clika_runtime._core.DataType, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

empty_strided(size, stride, dtype, *, device=None) -> Tensor

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

eq

eq(*args, **kwargs)

eq(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

eq(input, other) -> Tensor

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

eq_

eq_(*args, **kwargs)

eq_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

eq_(self, other) -> Tensor

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

erf

erf(*args, **kwargs)

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

erf(input) -> Tensor

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

erf_

erf_(*args, **kwargs)

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

erf_(self) -> Tensor

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

erfc

erfc(*args, **kwargs)

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

erfc(input) -> Tensor

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

erfc_

erfc_(*args, **kwargs)

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

erfc_(self) -> Tensor

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

erfinv

erfinv(*args, **kwargs)

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

erfinv(input) -> Tensor

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

erfinv_

erfinv_(*args, **kwargs)

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

erfinv_(self) -> Tensor

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

exp

exp(*args, **kwargs)

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

exp(input) -> Tensor

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

exp_

exp_(*args, **kwargs)

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

exp_(self) -> Tensor

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

expand

expand(*args, **kwargs)

expand(input: clika_runtime._core.Tensor, shape: collections.abc.Sequence[clika_runtime.ScalarOrTensor], bidirectional: bool = False) -> clika_runtime._core.Tensor

expand(input, shape, bidirectional=False) -> Tensor

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

expand_as

expand_as(*args, **kwargs)

expand_as(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

expand_as(input, other) -> Tensor

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

exponential_

exponential_(*args, **kwargs)

exponential_(self: clika_runtime._core.Tensor, lambd: float = 1.0, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

exponential_(self, lambd=1.0, *, device=None) -> Tensor

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

eye

eye(*args, **kwargs)

eye(n: clika_runtime.ScalarOrTensor, m: clika_runtime.ScalarOrTensor | None = None, *, dtype: clika_runtime._core.DataType = DataType.Float32, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

eye(n, m=None, *, dtype=Float32, device=None) -> Tensor

The eye operator; its contract is ClikaRT::ops::eye 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.

fill

fill(*args, **kwargs)

fill(input: clika_runtime._core.Tensor, value: clika_runtime.ScalarOrTensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

fill(input, value, *, device=None) -> Tensor

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

fill_

fill_(*args, **kwargs)

fill_(self: clika_runtime._core.Tensor, value: clika_runtime.ScalarOrTensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

fill_(self, value, *, device=None) -> Tensor

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

fill_diagonal

fill_diagonal(*args, **kwargs)

fill_diagonal(input: clika_runtime._core.Tensor, fill_value: clika_runtime.Scalar, wrap: bool = False, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

fill_diagonal(input, fill_value, wrap=False, *, device=None) -> Tensor

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

fill_diagonal_

fill_diagonal_(*args, **kwargs)

fill_diagonal_(self: clika_runtime._core.Tensor, fill_value: clika_runtime.Scalar, wrap: bool = False, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

fill_diagonal_(self, fill_value, wrap=False, *, device=None) -> Tensor

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

flatten

flatten(*args, **kwargs)

flatten(input: clika_runtime._core.Tensor, start_dim: int = 0, end_dim: int = -1) -> clika_runtime._core.Tensor

flatten(input, start_dim=0, end_dim=-1) -> Tensor

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

flip

flip(*args, **kwargs)

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

flip(input, dims) -> Tensor

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

fliplr

fliplr(*args, **kwargs)

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

fliplr(input) -> Tensor

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

flipud

flipud(*args, **kwargs)

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

flipud(input) -> Tensor

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

floor

floor(*args, **kwargs)

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

floor(input) -> Tensor

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

floor_

floor_(*args, **kwargs)

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

floor_(self) -> Tensor

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

floor_divide

floor_divide(*args, **kwargs)

floor_divide(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

floor_divide(input, other) -> Tensor

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

floor_divide_

floor_divide_(*args, **kwargs)

floor_divide_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

floor_divide_(self, other) -> Tensor

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

fmax

fmax(*args, **kwargs)

fmax(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

fmax(input, other) -> Tensor

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

fmin

fmin(*args, **kwargs)

fmin(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

fmin(input, other) -> Tensor

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

fmod

fmod(*args, **kwargs)

fmod(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

fmod(input, other) -> Tensor

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

fmod_

fmod_(*args, **kwargs)

fmod_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

fmod_(self, other) -> Tensor

The fmod_ operator; its contract is ClikaRT::ops::fmod_ 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.

frac

frac(*args, **kwargs)

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

frac(input) -> Tensor

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

frac_

frac_(*args, **kwargs)

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

frac_(self) -> Tensor

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

frexp

frexp(*args, **kwargs)

frexp(input: clika_runtime._core.Tensor) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

frexp(input) -> tuple[Tensor, Tensor]

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

from_numpy

from_numpy(*args, **kwargs)

from_numpy(array: object) -> clika_runtime._core.Tensor

A ZERO-COPY tensor BORROWING the array's memory (C-contiguous, writable, cpu): mutations alias both ways, and the tensor keeps the array alive for its whole lifetime. An op on the tensor runs asynchronously on the calling thread's placement, so a raw read of the array after an in-place op sees the write once that placement is synchronized: crt.synchronize() for the calling thread's lane, crt.synchronize(stream) when the op ran under an explicit stream; reads through numpy() settle on their own. Use tensor(...) for the copying entry; densify a strided array with np.ascontiguousarray(a) first.

full

full(shape: 'Sequence[int]', fill_value: 'int | float | bool', *, dtype: 'DataType | None' = None, device: 'DeviceLike' = None) -> 'Tensor'

A tensor filled with fill_value.

Without dtype the fill value picks the type: a bool fills a bool tensor, an int an int64 one, a float a float32 one.

full_like

full_like(*args, **kwargs)

full_like(reference: clika_runtime._core.Tensor, fill_value: clika_runtime.ScalarOrTensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

full_like(reference, fill_value, *, device=None) -> Tensor

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

gated_delta_update

gated_delta_update(*args, **kwargs)

gated_delta_update(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, v: clika_runtime._core.Tensor, beta: clika_runtime._core.Tensor, g: clika_runtime._core.Tensor, state: clika_runtime._core.Tensor, seq_lens: clika_runtime._core.Tensor | None = None, slot_ids: clika_runtime._core.Tensor | None = None, scale: float | None = None, gate_bias: clika_runtime._core.Tensor | None = None, gate_scale: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

gated_delta_update(input, other, v, beta, g, state, seq_lens=None, slot_ids=None, scale=None, gate_bias=None, gate_scale=None) -> Tensor

The gated_delta_update operator; its contract is ClikaRT::ops::gated_delta_update 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.

gather

gather(*args, **kwargs)

gather(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

gather(input, dim, index) -> Tensor

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

ge

ge(*args, **kwargs)

ge(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

ge(input, other) -> Tensor

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

ge_

ge_(*args, **kwargs)

ge_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

ge_(self, other) -> Tensor

The ge_ operator; its contract is ClikaRT::ops::ge_ 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.

generate_rotary_cache

generate_rotary_cache(*args, **kwargs)

generate_rotary_cache(rotary_dim: int, max_positions: int, theta: float | None = None, scaling: clika_runtime.RopeScaling | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

generate_rotary_cache(rotary_dim, max_positions, theta=None, scaling=None, scale=None, low_freq_factor=None, high_freq_factor=None, original_max_pos=None, beta_fast=None, beta_slow=None, freq_factors=None, *, device=None) -> tuple[Tensor, Tensor]

The generate_rotary_cache operator; its contract is ClikaRT::ops::generate_rotary_cache 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.

group_query_attention

group_query_attention(*args, **kwargs)

group_query_attention(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, v: clika_runtime._core.Tensor, past_key: clika_runtime._core.Tensor | None = None, past_value: clika_runtime._core.Tensor | None = None, kvcache_start: clika_runtime._core.Tensor | None = None, rope_cos: clika_runtime._core.Tensor | None = None, rope_sin: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: clika_runtime.RotaryMode | None = None, num_heads: int | None = None, kv_num_heads: int | None = None, out_present_key: clika_runtime._core.Tensor | None = None, out_present_value: clika_runtime._core.Tensor | None = None, k_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), head_sink: clika_runtime._core.Tensor | None = None, q_norm_gain: clika_runtime._core.Tensor | None = None, k_norm_gain: clika_runtime._core.Tensor | None = None, qk_norm_eps: float | None = None, slot_ids: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

group_query_attention(input, other, v, past_key=None, past_value=None, kvcache_start=None, rope_cos=None, rope_sin=None, position_ids=None, attn_mask=None, is_causal=None, q_scale=None, softcap=None, sliding_window=None, smooth_softmax=None, rotary_mode=None, num_heads=None, kv_num_heads=None, out_present_key=None, out_present_value=None, k_scale=None, v_scale=None, head_sink=None, q_norm_gain=None, k_norm_gain=None, qk_norm_eps=None, slot_ids=None) -> tuple[Tensor, Tensor, Tensor]

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

group_query_attention_varlen

group_query_attention_varlen(*args, **kwargs)

group_query_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(...), past_key: clika_runtime._core.Tensor | None = None, past_value: clika_runtime._core.Tensor | None = None, kvcache_start: clika_runtime._core.Tensor | None = None, rope_cos: clika_runtime._core.Tensor | None = None, rope_sin: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, attn_mask: clika_runtime._core.Tensor | None = None, head_sink: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: clika_runtime.RotaryMode | None = None, num_heads: int | None = None, kv_num_heads: int | None = None, out_present_key: clika_runtime._core.Tensor | None = None, out_present_value: clika_runtime._core.Tensor | None = None, k_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), q_norm_gain: clika_runtime._core.Tensor | None = None, k_norm_gain: clika_runtime._core.Tensor | None = None, qk_norm_eps: float | None = None, slot_ids: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

group_query_attention_varlen(input, other, v, cu_seqlens_q, cu_seqlens_k, max_seqlen_q=None, max_seqlen_k=None, past_key=None, past_value=None, kvcache_start=None, rope_cos=None, rope_sin=None, position_ids=None, attn_mask=None, head_sink=None, is_causal=None, q_scale=None, softcap=None, sliding_window=None, smooth_softmax=None, rotary_mode=None, num_heads=None, kv_num_heads=None, out_present_key=None, out_present_value=None, k_scale=None, v_scale=None, q_norm_gain=None, k_norm_gain=None, qk_norm_eps=None, slot_ids=None) -> tuple[Tensor, Tensor, Tensor]

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

gt

gt(*args, **kwargs)

gt(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

gt(input, other) -> Tensor

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

gt_

gt_(*args, **kwargs)

gt_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

gt_(self, other) -> Tensor

The gt_ operator; its contract is ClikaRT::ops::gt_ 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.

hash_128

hash_128(*args, **kwargs)

hash_128(input: clika_runtime._core.Tensor, seed: int = 0) -> clika_runtime._core.Tensor

hash_128(input, seed=0) -> Tensor

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

hash_256

hash_256(*args, **kwargs)

hash_256(input: clika_runtime._core.Tensor, seed: int = 0) -> clika_runtime._core.Tensor

hash_256(input, seed=0) -> Tensor

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

hash_64

hash_64(*args, **kwargs)

hash_64(input: clika_runtime._core.Tensor, seed: int = 0) -> clika_runtime._core.Tensor

hash_64(input, seed=0) -> Tensor

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

hash_chain

hash_chain(*args, **kwargs)

hash_chain(rows: clika_runtime._core.Tensor, parent: clika_runtime._core.Tensor, seed: int = 0) -> clika_runtime._core.Tensor

hash_chain(rows, parent, seed=0) -> Tensor

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

hash_tensor

hash_tensor(*args, **kwargs)

hash_tensor(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False, mode: clika_runtime.HashTensorMode = HashTensorMode.XorSum) -> clika_runtime._core.Tensor

hash_tensor(input, dims=[], keepdim=False, mode=XorSum) -> Tensor

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

histogram

histogram(*args, **kwargs)

histogram(input: clika_runtime._core.Tensor, bins: int = 100, range: clika_runtime._core.Tensor | None = None, weight: clika_runtime._core.Tensor | None = None, density: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

histogram(input, bins=100, range=None, weight=None, density=False) -> tuple[Tensor, Tensor]

The histogram operator; its contract is ClikaRT::ops::histogram 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.

hypot

hypot(*args, **kwargs)

hypot(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

hypot(input, other) -> Tensor

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

hypot_

hypot_(*args, **kwargs)

hypot_(self: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

hypot_(self, other) -> Tensor

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

index

index(*args, **kwargs)

index(input: clika_runtime._core.Tensor, indices: collections.abc.Sequence[clika_runtime.IndexEntry]) -> clika_runtime._core.Tensor

index(input, indices) -> Tensor

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

index_add

index_add(*args, **kwargs)

index_add(input: clika_runtime._core.Tensor, dim: int, indices: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

index_add(input, dim, indices, src) -> Tensor

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

index_add_

index_add_(*args, **kwargs)

index_add_(self: clika_runtime._core.Tensor, dim: int, indices: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

index_add_(self, dim, indices, src) -> Tensor

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

index_copy

index_copy(*args, **kwargs)

index_copy(input: clika_runtime._core.Tensor, dim: int, indices: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

index_copy(input, dim, indices, src) -> Tensor

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

index_copy_

index_copy_(*args, **kwargs)

index_copy_(self: clika_runtime._core.Tensor, dim: int, indices: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

index_copy_(self, dim, indices, src) -> Tensor

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

index_fill

index_fill(*args, **kwargs)

index_fill(input: clika_runtime._core.Tensor, dim: int, indices: clika_runtime._core.Tensor, value: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

index_fill(input, dim, indices, value) -> Tensor

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

index_fill_

index_fill_(*args, **kwargs)

index_fill_(self: clika_runtime._core.Tensor, dim: int, indices: clika_runtime._core.Tensor, value: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

index_fill_(self, dim, indices, value) -> Tensor

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

index_put

index_put(*args, **kwargs)

index_put(input: clika_runtime._core.Tensor, indices: collections.abc.Sequence[clika_runtime.IndexEntry], value: clika_runtime.ScalarOrTensor, accumulate: bool = False) -> clika_runtime._core.Tensor

index_put(input, indices, value, accumulate=False) -> Tensor

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

index_put_

index_put_(*args, **kwargs)

index_put_(self: clika_runtime._core.Tensor, indices: collections.abc.Sequence[clika_runtime.IndexEntry], value: clika_runtime.ScalarOrTensor, accumulate: bool = False) -> clika_runtime._core.Tensor

index_put_(self, indices, value, accumulate=False) -> Tensor

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

index_select

index_select(*args, **kwargs)

index_select(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

index_select(input, dim, index) -> Tensor

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

inner

inner(*args, **kwargs)

inner(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

inner(input, other) -> Tensor

The inner operator; its contract is ClikaRT::ops::inner 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.

isclose

isclose(*args, **kwargs)

isclose(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, rtol: float = 1e-05, atol: float = 1e-08, equal_nan: bool = False) -> clika_runtime._core.Tensor

isclose(input, other, rtol=1e-5, atol=1e-8, equal_nan=False) -> Tensor

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

isfinite

isfinite(*args, **kwargs)

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

isfinite(input) -> Tensor

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

isinf

isinf(*args, **kwargs)

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

isinf(input) -> Tensor

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

isnan

isnan(*args, **kwargs)

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

isnan(input) -> Tensor

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

isneginf

isneginf(*args, **kwargs)

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

isneginf(input) -> Tensor

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

isposinf

isposinf(*args, **kwargs)

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

isposinf(input) -> Tensor

The isposinf operator; its contract is ClikaRT::ops::isposinf 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.

kron

kron(*args, **kwargs)

kron(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

kron(input, other) -> Tensor

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

kthvalue

kthvalue(*args, **kwargs)

kthvalue(input: clika_runtime._core.Tensor, k: int, dim: int = -1, keepdim: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

kthvalue(input, k, dim=-1, keepdim=False) -> tuple[Tensor, Tensor]

The kthvalue operator; its contract is ClikaRT::ops::kthvalue 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.

le

le(*args, **kwargs)

le(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

le(input, other) -> Tensor

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

le_

le_(*args, **kwargs)

le_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

le_(self, other) -> Tensor

The le_ operator; its contract is ClikaRT::ops::le_ 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.

linspace

linspace(*args, **kwargs)

linspace(start: clika_runtime.ScalarOrTensor, end: clika_runtime.ScalarOrTensor, steps: clika_runtime.ScalarOrTensor, *, dtype: clika_runtime._core.DataType = DataType.Float32, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

linspace(start, end, steps, *, dtype=Float32, device=None) -> Tensor

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

log

log(*args, **kwargs)

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

log(input) -> Tensor

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

log10

log10(*args, **kwargs)

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

log10(input) -> Tensor

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

log10_

log10_(*args, **kwargs)

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

log10_(self) -> Tensor

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

log1p

log1p(*args, **kwargs)

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

log1p(input) -> Tensor

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

log1p_

log1p_(*args, **kwargs)

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

log1p_(self) -> Tensor

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

log2

log2(*args, **kwargs)

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

log2(input) -> Tensor

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

log2_

log2_(*args, **kwargs)

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

log2_(self) -> Tensor

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

log_

log_(*args, **kwargs)

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

log_(self) -> Tensor

The log_ operator; its contract is ClikaRT::ops::log_ 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.

logaddexp

logaddexp(*args, **kwargs)

logaddexp(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

logaddexp(input, other) -> Tensor

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

logaddexp2

logaddexp2(*args, **kwargs)

logaddexp2(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

logaddexp2(input, other) -> Tensor

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

logical_and

logical_and(*args, **kwargs)

logical_and(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

logical_and(input, other) -> Tensor

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

logical_and_

logical_and_(*args, **kwargs)

logical_and_(self: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

logical_and_(self, other) -> Tensor

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

logical_not

logical_not(*args, **kwargs)

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

logical_not(input) -> Tensor

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

logical_not_

logical_not_(*args, **kwargs)

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

logical_not_(self) -> Tensor

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

logical_or

logical_or(*args, **kwargs)

logical_or(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

logical_or(input, other) -> Tensor

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

logical_or_

logical_or_(*args, **kwargs)

logical_or_(self: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

logical_or_(self, other) -> Tensor

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

logical_xor

logical_xor(*args, **kwargs)

logical_xor(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

logical_xor(input, other) -> Tensor

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

logical_xor_

logical_xor_(*args, **kwargs)

logical_xor_(self: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

logical_xor_(self, other) -> Tensor

The logical_xor_ operator; its contract is ClikaRT::ops::logical_xor_ 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.

logsumexp

logsumexp(*args, **kwargs)

logsumexp(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int], keepdim: bool = False) -> clika_runtime._core.Tensor

logsumexp(input, dims, keepdim=False) -> Tensor

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

lt

lt(*args, **kwargs)

lt(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

lt(input, other) -> Tensor

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

lt_

lt_(*args, **kwargs)

lt_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

lt_(self, other) -> Tensor

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

make_quantized

make_quantized(*args, **kwargs)

make_quantized(payload: clika_runtime._core.Tensor, scheme: str, logical_shape: collections.abc.Sequence[int], global_scale: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.QTensor

Construct a quantized weight from a raw packed payload (UInt8 block rows) under a named block scheme; logical_shape is the element shape it encodes, row-contiguous dimension first.

make_quantized_affine

make_quantized_affine(*args, **kwargs)

make_quantized_affine(codes: clika_runtime._core.Tensor, scales: clika_runtime._core.Tensor, biases: clika_runtime._core.Tensor, group_size: int, bits: int, logical_shape: collections.abc.Sequence[int]) -> clika_runtime._core.QTensor

Construct a float-bias affine weight from its planes: value = scale * code + bias per group. logical_shape is [out_features, in_features].

masked_fill

masked_fill(*args, **kwargs)

masked_fill(input: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor, value: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

masked_fill(input, mask, value) -> Tensor

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

masked_fill_

masked_fill_(*args, **kwargs)

masked_fill_(self: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor, value: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

masked_fill_(self, mask, value) -> Tensor

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

masked_scatter

masked_scatter(*args, **kwargs)

masked_scatter(input: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor, source: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

masked_scatter(input, mask, source) -> Tensor

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

masked_scatter_

masked_scatter_(*args, **kwargs)

masked_scatter_(self: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor, source: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

masked_scatter_(self, mask, source) -> Tensor

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

masked_select

masked_select(*args, **kwargs)

masked_select(input: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

masked_select(input, mask) -> Tensor

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

matmul

matmul(*args, **kwargs)

matmul(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, transpose_a: bool = False, transpose_b: bool = False, situ_beta: float = 0.0, situ_linear_beta: float = 0.0) -> clika_runtime._core.Tensor

matmul(input, other, bias=None, *, activation=None, transpose_a=False, transpose_b=False, situ_beta=0.0, situ_linear_beta=0.0) -> Tensor

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

max

max(*args, **kwargs)

max(input: clika_runtime._core.Tensor, dim: int, keepdim: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

max(input, dim, keepdim=False) -> tuple[Tensor, Tensor]

The max operator; its contract is ClikaRT::ops::max 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.

maximum

maximum(*args, **kwargs)

maximum(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

maximum(input, other) -> Tensor

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

maximum_

maximum_(*args, **kwargs)

maximum_(self: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

maximum_(self, other) -> Tensor

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

mean

mean(*args, **kwargs)

mean(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

mean(input, dims=[], keepdim=False, *, dtype=Undefined) -> Tensor

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

median

median(*args, **kwargs)

median(input: clika_runtime._core.Tensor, dim: int | None = None, keepdim: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

median(input, dim=None, keepdim=False) -> tuple[Tensor, Tensor]

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

meshgrid

meshgrid(*args, **kwargs)

meshgrid(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], indexing: clika_runtime.MeshgridIndexing = MeshgridIndexing.IJ) -> list[clika_runtime._core.Tensor]

meshgrid(tensors, indexing=IJ) -> list[Tensor]

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

min

min(*args, **kwargs)

min(input: clika_runtime._core.Tensor, dim: int, keepdim: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

min(input, dim, keepdim=False) -> tuple[Tensor, Tensor]

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

minimum

minimum(*args, **kwargs)

minimum(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

minimum(input, other) -> Tensor

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

minimum_

minimum_(*args, **kwargs)

minimum_(self: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

minimum_(self, other) -> Tensor

The minimum_ operator; its contract is ClikaRT::ops::minimum_ 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.

mla_attention

mla_attention(*args, **kwargs)

mla_attention(q_nope: clika_runtime._core.Tensor, q_pe: clika_runtime._core.Tensor, new_ckv: clika_runtime._core.Tensor, new_kpe: clika_runtime._core.Tensor, ckv_cache: clika_runtime._core.Tensor, kpe_cache: clika_runtime._core.Tensor, kvcache_start: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, scale: float, slot_ids: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

mla_attention(q_nope, q_pe, new_ckv, new_kpe, ckv_cache, kpe_cache, kvcache_start, cu_seqlens_q, scale, slot_ids=None) -> Tensor

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

mm

mm(*args, **kwargs)

mm(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

mm(input, other, bias=None, *, activation=None) -> Tensor

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

mod

mod(*args, **kwargs)

mod(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, mode: clika_runtime.ModMode = ModMode.Python) -> clika_runtime._core.Tensor

mod(input, other, mode=Python) -> Tensor

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

mod_

mod_(*args, **kwargs)

mod_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, mode: clika_runtime.ModMode = ModMode.Python) -> clika_runtime._core.Tensor

mod_(self, other, mode=Python) -> Tensor

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

moe

moe(*args, **kwargs)

moe(input: clika_runtime._core.Tensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.Tensor, fc2_experts: clika_runtime._core.Tensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.Tensor | None = None, fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: clika_runtime.MoeRouting | None = None, renormalize: bool | None = None, n_group: int | None = None, topk_group: int | None = None, routed_scaling_factor: float | None = None, sparse_mixer_eps: float | None = None, apply_router_weight_on_input: bool | None = None, *, activation: clika_runtime._core.Activation | None = None, swiglu_fusion: clika_runtime.SwigluFusion | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: clika_runtime.GeluMode | None = None, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

moe(input, router_logits, fc1_experts, fc2_experts, top_k, fc1_bias=None, fc2_bias=None, fc3_experts=None, fc3_bias=None, e_score_correction_bias=None, router_weights=None, routing_mode=None, renormalize=None, n_group=None, topk_group=None, routed_scaling_factor=None, sparse_mixer_eps=None, apply_router_weight_on_input=None, *, activation=None, swiglu_fusion=None, swiglu_alpha=None, swiglu_beta=None, swiglu_limit=None, gelu_mode=None, shared_output=None) -> Tensor

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

mrope_rotary_embedding

mrope_rotary_embedding(*args, **kwargs)

mrope_rotary_embedding(x0: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor, mrope_sections: collections.abc.Sequence[int], interleaved_sections: bool | None = None, theta: float | None = None, scaling: clika_runtime.RopeScaling | None = None, mode: clika_runtime.RotaryMode | None = None, rotary_dim: int | None = None, scale: float | None = None) -> clika_runtime._core.Tensor

mrope_rotary_embedding(x0, position_ids, mrope_sections, interleaved_sections=None, theta=None, scaling=None, mode=None, rotary_dim=None, scale=None) -> Tensor

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

mrope_rotary_embedding_qk_varlen

mrope_rotary_embedding_qk_varlen(*args, **kwargs)

mrope_rotary_embedding_qk_varlen(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor, mrope_sections: collections.abc.Sequence[int], interleaved_sections: bool | None = None, theta: float | None = None, scaling: clika_runtime.RopeScaling | None = None, mode: clika_runtime.RotaryMode | None = None, rotary_dim: int | None = None, scale: float | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

mrope_rotary_embedding_qk_varlen(input, other, position_ids, mrope_sections, interleaved_sections=None, theta=None, scaling=None, mode=None, rotary_dim=None, scale=None) -> tuple[Tensor, Tensor]

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

mrope_rotary_embedding_varlen

mrope_rotary_embedding_varlen(*args, **kwargs)

mrope_rotary_embedding_varlen(x0: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor, mrope_sections: collections.abc.Sequence[int], interleaved_sections: bool | None = None, theta: float | None = None, scaling: clika_runtime.RopeScaling | None = None, mode: clika_runtime.RotaryMode | None = None, rotary_dim: int | None = None, scale: float | None = None) -> clika_runtime._core.Tensor

mrope_rotary_embedding_varlen(x0, position_ids, mrope_sections, interleaved_sections=None, theta=None, scaling=None, mode=None, rotary_dim=None, scale=None) -> Tensor

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

ms_deform_attention

ms_deform_attention(*args, **kwargs)

ms_deform_attention(value: clika_runtime._core.Tensor, spatial_shapes: clika_runtime._core.Tensor, level_start_index: clika_runtime._core.Tensor, sampling_locations: clika_runtime._core.Tensor, attention_weights: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

ms_deform_attention(value, spatial_shapes, level_start_index, sampling_locations, attention_weights) -> Tensor

The ms_deform_attention operator; its contract is ClikaRT::ops::ms_deform_attention 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.

mul

mul(*args, **kwargs)

mul(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor mul(a: clika_runtime.Scalar, input: clika_runtime._core.Tensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

Overloaded function.

1. mul(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

mul(input, other, *, activation=Identity) -> Tensor

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

2. mul(a: clika_runtime.Scalar, input: clika_runtime._core.Tensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

mul(a, input, *, activation=Identity) -> Tensor

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

mul_

mul_(*args, **kwargs)

mul_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

mul_(self, other, *, activation=Identity) -> Tensor

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

multinomial

multinomial(*args, **kwargs)

multinomial(probabilities: clika_runtime._core.Tensor, num_samples: int, replacement: bool = False, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

multinomial(probabilities, num_samples, replacement=False, *, device=None) -> Tensor

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

mv

mv(*args, **kwargs)

mv(input: clika_runtime._core.Tensor, vec: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

mv(input, vec, bias=None, *, activation=None) -> Tensor

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

nan_to_num

nan_to_num(*args, **kwargs)

nan_to_num(input: clika_runtime._core.Tensor, nan: float | None = None, posinf: float | None = None, neginf: float | None = None) -> clika_runtime._core.Tensor

nan_to_num(input, nan=None, posinf=None, neginf=None) -> Tensor

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

nan_to_num_

nan_to_num_(*args, **kwargs)

nan_to_num_(self: clika_runtime._core.Tensor, nan: float | None = None, posinf: float | None = None, neginf: float | None = None) -> clika_runtime._core.Tensor

nan_to_num_(self, nan=None, posinf=None, neginf=None) -> Tensor

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

nanmean

nanmean(*args, **kwargs)

nanmean(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor

nanmean(input, dims=[], keepdim=False) -> Tensor

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

nanmedian

nanmedian(*args, **kwargs)

nanmedian(input: clika_runtime._core.Tensor, dim: int | None = None, keepdim: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

nanmedian(input, dim=None, keepdim=False) -> tuple[Tensor, Tensor]

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

nanquantile

nanquantile(*args, **kwargs)

nanquantile(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, dim: int | None = None, keepdim: bool = False, interpolation: clika_runtime.QuantileInterp = QuantileInterp.Linear) -> clika_runtime._core.Tensor

nanquantile(input, other, dim=None, keepdim=False, interpolation=Linear) -> Tensor

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

nansum

nansum(*args, **kwargs)

nansum(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor

nansum(input, dims=[], keepdim=False) -> Tensor

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

narrow

narrow(*args, **kwargs)

narrow(input: clika_runtime._core.Tensor, dim: int, start: clika_runtime.IndexBound, length: clika_runtime.IndexBound) -> clika_runtime._core.Tensor

narrow(input, dim, start, length) -> Tensor

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

ndim

ndim(*args, **kwargs)

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

ndim(input) -> Tensor

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

ndim_host

ndim_host(*args, **kwargs)

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

ndim_host(input) -> Tensor

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

ne

ne(*args, **kwargs)

ne(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

ne(input, other) -> Tensor

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

ne_

ne_(*args, **kwargs)

ne_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

ne_(self, other) -> Tensor

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

neg

neg(*args, **kwargs)

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

neg(input) -> Tensor

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

neg_

neg_(*args, **kwargs)

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

neg_(self) -> Tensor

The neg_ operator; its contract is ClikaRT::ops::neg_ 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.

nms

nms(*args, **kwargs)

nms(boxes: clika_runtime._core.Tensor, scores: clika_runtime._core.Tensor, max_output_boxes_per_class: clika_runtime.ScalarOrTensor | None = None, iou_threshold: clika_runtime.ScalarOrTensor | None = None, score_threshold: clika_runtime.ScalarOrTensor | None = None, center_point_box: bool = False) -> clika_runtime._core.Tensor

nms(boxes, scores, max_output_boxes_per_class=None, iou_threshold=None, score_threshold=None, center_point_box=False) -> Tensor

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

nonzero

nonzero(*args, **kwargs)

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

nonzero(input) -> Tensor

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

norm

norm(*args, **kwargs)

norm(input: clika_runtime._core.Tensor, other: clika_runtime.Scalar = Scalar(...), dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor

norm(input, other=2.0, dims=[], keepdim=False) -> Tensor

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

normal

normal(*args, **kwargs)

normal(mean: clika_runtime.ScalarOrTensor, stddev: clika_runtime.ScalarOrTensor, shape: collections.abc.Sequence[clika_runtime.ScalarOrTensor], *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

normal(mean, stddev, shape, *, device=None) -> Tensor

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

normal_

normal_(*args, **kwargs)

normal_(self: clika_runtime._core.Tensor, mean: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), stddev: clika_runtime.ScalarOrTensor = ScalarOrTensor(...), *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

normal_(self, mean=0, stddev=1, *, device=None) -> Tensor

The normal_ operator; its contract is ClikaRT::ops::normal_ 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.

numel

numel(*args, **kwargs)

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

numel(input) -> Tensor

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

numel_host

numel_host(*args, **kwargs)

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

numel_host(input) -> Tensor

The numel_host operator; its contract is ClikaRT::ops::numel_host 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.

ones

ones(*shape: 'ShapeDim', dtype: 'DataType | None' = None, device: 'DeviceLike' = None) -> 'Tensor'

A one-filled tensor; float32 unless dtype says otherwise.

ones_like

ones_like(*args, **kwargs)

ones_like(reference: clika_runtime._core.Tensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

ones_like(reference, *, device=None) -> Tensor

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

outer

outer(*args, **kwargs)

outer(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

outer(input, other) -> Tensor

The outer operator; its contract is ClikaRT::ops::outer 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.

permute

permute(*args, **kwargs)

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

permute(input, dims) -> Tensor

The permute operator; its contract is ClikaRT::ops::permute 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.

poisson

poisson(*args, **kwargs)

poisson(rates: clika_runtime._core.Tensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

poisson(rates, *, device=None) -> Tensor

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

pow

pow(*args, **kwargs)

pow(input: clika_runtime._core.Tensor, exponent: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

pow(input, exponent) -> Tensor

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

pow_

pow_(*args, **kwargs)

pow_(self: clika_runtime._core.Tensor, exponent: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

pow_(self, exponent) -> Tensor

The pow_ operator; its contract is ClikaRT::ops::pow_ 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.

prod

prod(*args, **kwargs)

prod(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

prod(input, dims=[], keepdim=False, *, dtype=Undefined) -> Tensor

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

put

put(*args, **kwargs)

put(input: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor, source: clika_runtime._core.Tensor, accumulate: bool = False) -> clika_runtime._core.Tensor

put(input, index, source, accumulate=False) -> Tensor

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

put_

put_(*args, **kwargs)

put_(self: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor, source: clika_runtime._core.Tensor, accumulate: bool = False) -> clika_runtime._core.Tensor

put_(self, index, source, accumulate=False) -> Tensor

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

q_embedding

q_embedding(*args, **kwargs)

q_embedding(indices: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

q_embedding(indices, weight, bias=None, *, activation=None, out_dtype=Undefined) -> Tensor

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

qadd

qadd(*args, **kwargs)

qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

Overloaded function.

1. qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qadd(input, other, *, activation=Identity) -> Tensor

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

2. qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qadd(input, other, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined, activation=Identity) -> QTensor

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

qadd_

qadd_(*args, **kwargs)

qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.QTensor qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.Tensor qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

Overloaded function.

1. qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qadd_(input, other, out, *, activation=Identity) -> QTensor

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

2. qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qadd_(input, other, out, *, activation=Identity) -> Tensor

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

3. qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qadd_(input, other, out, out_scale, out_zero_point=None, out_quant_axis=-1, *, activation=Identity) -> Tensor

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

qconcat

qconcat(*args, **kwargs)

qconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int = 0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor qconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

Overloaded function.

1. qconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int = 0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qconcat(tensors, dim=0, *, activation=Identity) -> Tensor

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

2. qconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qconcat(tensors, dim, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined, activation=Identity) -> QTensor

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

qconcat_

qconcat_(*args, **kwargs)

qconcat_(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.QTensor qconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

Overloaded function.

1. qconcat_(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qconcat_(tensors, dim, out, *, activation=Identity) -> QTensor

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

2. qconcat_(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qconcat_(tensors, dim, out, out_scale, out_zero_point=None, out_quant_axis=-1, *, activation=Identity) -> Tensor

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

qconv

qconv(*args, **kwargs)

qconv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: clika_runtime._core.PadMode = PadMode.Constant, value: float | None = None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor qconv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, 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, value: float | None, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qconv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: clika_runtime._core.PadMode = PadMode.Constant, value: float | None = None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

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

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

2. qconv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, 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, value: float | None, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qconv(input, weight, bias, stride, padding, dilation, groups, mode, value, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qconv1d

qconv1d(*args, **kwargs)

qconv1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, 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 qconv1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qconv1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, 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

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

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

2. qconv1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qconv1d(input, weight, bias, stride, padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qconv1d_woq

qconv1d_woq(*args, **kwargs)

qconv1d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, 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

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

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

qconv2d

qconv2d(*args, **kwargs)

qconv2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, 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 qconv2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qconv2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, 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

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

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

2. qconv2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qconv2d(input, weight, bias, stride, padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qconv2d_woq

qconv2d_woq(*args, **kwargs)

qconv2d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, 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

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

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

qconv3d

qconv3d(*args, **kwargs)

qconv3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, 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 qconv3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qconv3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, 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

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

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

2. qconv3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qconv3d(input, weight, bias, stride, padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qconv3d_woq

qconv3d_woq(*args, **kwargs)

qconv3d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, 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

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

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

qconv_

qconv_(*args, **kwargs)

qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: clika_runtime._core.PadMode = PadMode.Constant, value: float | None = None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.QTensor qconv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: clika_runtime._core.PadMode = PadMode.Constant, value: float | None = None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.Tensor qconv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: clika_runtime._core.PadMode = PadMode.Constant, value: float | None = None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

Overloaded function.

1. qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: clika_runtime._core.PadMode = PadMode.Constant, value: float | None = None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qconv_(input, weight, out, bias=None, stride=[], padding=[], dilation=[], groups=1, mode=Constant, value=None, *, activation=Identity) -> QTensor

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

2. qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: clika_runtime._core.PadMode = PadMode.Constant, value: float | None = None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qconv_(input, weight, out, bias=None, stride=[], padding=[], dilation=[], groups=1, mode=Constant, value=None, *, activation=Identity) -> Tensor

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

3. qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: clika_runtime._core.PadMode = PadMode.Constant, value: float | None = None, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qconv_(input, weight, out, out_scale, out_zero_point, out_quant_axis=-1, bias=None, stride=[], padding=[], dilation=[], groups=1, mode=Constant, value=None, *, activation=Identity) -> Tensor

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

qconv_transpose

qconv_transpose(*args, **kwargs)

qconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor qconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

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

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

2. qconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qconv_transpose(input, weight, bias, stride, padding, output_padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qconv_transpose1d

qconv_transpose1d(*args, **kwargs)

qconv_transpose1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], output_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 qconv_transpose1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qconv_transpose1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], output_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

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

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

2. qconv_transpose1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qconv_transpose1d(input, weight, bias, stride, padding, output_padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qconv_transpose1d_woq

qconv_transpose1d_woq(*args, **kwargs)

qconv_transpose1d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], output_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

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

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

qconv_transpose2d

qconv_transpose2d(*args, **kwargs)

qconv_transpose2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], output_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 qconv_transpose2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qconv_transpose2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], output_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

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

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

2. qconv_transpose2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qconv_transpose2d(input, weight, bias, stride, padding, output_padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qconv_transpose2d_woq

qconv_transpose2d_woq(*args, **kwargs)

qconv_transpose2d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], output_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

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

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

qconv_transpose3d

qconv_transpose3d(*args, **kwargs)

qconv_transpose3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], output_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 qconv_transpose3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qconv_transpose3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], output_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

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

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

2. qconv_transpose3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qconv_transpose3d(input, weight, bias, stride, padding, output_padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qconv_transpose3d_woq

qconv_transpose3d_woq(*args, **kwargs)

qconv_transpose3d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], output_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

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

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

qconv_transpose_

qconv_transpose_(*args, **kwargs)

qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.QTensor qconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.Tensor qconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

Overloaded function.

1. qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qconv_transpose_(input, weight, out, bias=None, stride=[], padding=[], output_padding=[], dilation=[], groups=1, *, activation=Identity) -> QTensor

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

2. qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

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

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

3. qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qconv_transpose_(input, weight, out, out_scale, out_zero_point, out_quant_axis=-1, bias=None, stride=[], padding=[], output_padding=[], dilation=[], groups=1, *, activation=Identity) -> Tensor

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

qconv_transpose_woq

qconv_transpose_woq(*args, **kwargs)

qconv_transpose_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity, compute_mode: clika_runtime.QComputeMode = QComputeMode.ExactFP) -> clika_runtime._core.Tensor

qconv_transpose_woq(input, weight, bias=None, stride=[], padding=[], output_padding=[], dilation=[], groups=1, *, activation=Identity, compute_mode=ExactFP) -> Tensor

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

qconv_woq

qconv_woq(*args, **kwargs)

qconv_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: clika_runtime._core.PadMode = PadMode.Constant, value: float | None = None, *, activation: clika_runtime._core.Activation = Activation.Identity, compute_mode: clika_runtime.QComputeMode = QComputeMode.ExactFP) -> clika_runtime._core.Tensor

qconv_woq(input, weight, bias=None, stride=[], padding=[], dilation=[], groups=1, mode=Constant, value=None, *, activation=Identity, compute_mode=ExactFP) -> Tensor

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

qdeform_conv

qdeform_conv(*args, **kwargs)

qdeform_conv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, offset_groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor qdeform_conv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, offset_groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qdeform_conv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, offset_groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qdeform_conv(input, weight, offset, mask=None, bias=None, stride=[], padding=[], dilation=[], groups=1, offset_groups=1, *, activation=Identity) -> Tensor

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

2. qdeform_conv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, offset_groups: int, activation: clika_runtime._core.Activation, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qdeform_conv(input, weight, offset, mask, bias, stride, padding, dilation, groups, offset_groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qdeform_conv_woq

qdeform_conv_woq(*args, **kwargs)

qdeform_conv_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, offset_groups: int = 1, *, activation: clika_runtime._core.Activation = Activation.Identity, compute_mode: clika_runtime.QComputeMode = QComputeMode.ExactFP) -> clika_runtime._core.Tensor

qdeform_conv_woq(input, weight, offset, mask=None, bias=None, stride=[], padding=[], dilation=[], groups=1, offset_groups=1, *, activation=Identity, compute_mode=ExactFP) -> Tensor

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

qdiv

qdiv(*args, **kwargs)

qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

Overloaded function.

1. qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qdiv(input, other, *, activation=Identity) -> Tensor

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

2. qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qdiv(input, other, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined, activation=Identity) -> QTensor

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

qdiv_

qdiv_(*args, **kwargs)

qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.QTensor qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.Tensor qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

Overloaded function.

1. qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qdiv_(input, other, out, *, activation=Identity) -> QTensor

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

2. qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qdiv_(input, other, out, *, activation=Identity) -> Tensor

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

3. qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qdiv_(input, other, out, out_scale, out_zero_point=None, out_quant_axis=-1, *, activation=Identity) -> Tensor

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

qfast_gelu

qfast_gelu(*args, **kwargs)

qfast_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor qfast_gelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qfast_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qfast_gelu(input) -> Tensor

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

2. qfast_gelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qfast_gelu(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qfast_gelu_

qfast_gelu_(*args, **kwargs)

qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qfast_gelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qfast_gelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qfast_gelu_(input, out) -> QTensor

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

2. qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

qfast_gelu_(input, out) -> Tensor

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

3. qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

qfast_gelu_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

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

qgelu

qgelu(*args, **kwargs)

qgelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor qgelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qgelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qgelu(input) -> Tensor

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

2. qgelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qgelu(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qgelu_

qgelu_(*args, **kwargs)

qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qgelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qgelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qgelu_(input, out) -> QTensor

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

2. qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

qgelu_(input, out) -> Tensor

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

3. qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

qgelu_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

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

qhardswish

qhardswish(*args, **kwargs)

qhardswish(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor qhardswish(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qhardswish(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qhardswish(input) -> Tensor

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

2. qhardswish(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qhardswish(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qhardswish_

qhardswish_(*args, **kwargs)

qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qhardswish(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qhardswish(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qhardswish_(input, out) -> QTensor

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

2. qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

qhardswish_(input, out) -> Tensor

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

3. qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

qhardswish_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

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

qk_layer_norm

qk_layer_norm(*args, **kwargs)

qk_layer_norm(input: clika_runtime._core.Tensor, k: clika_runtime._core.Tensor | None = None, v: clika_runtime._core.Tensor | None = None, w_q: clika_runtime._core.Tensor | None = None, b_q: clika_runtime._core.Tensor | None = None, w_k: clika_runtime._core.Tensor | None = None, b_k: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

qk_layer_norm(input, k=None, v=None, w_q=None, b_q=None, w_k=None, b_k=None, head_dim=0, eps=None) -> tuple[Tensor, Tensor, Tensor]

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

qk_layer_norm_

qk_layer_norm_(*args, **kwargs)

qk_layer_norm_(input: clika_runtime._core.Tensor, k: clika_runtime._core.Tensor | None = None, v: clika_runtime._core.Tensor | None = None, w_q: clika_runtime._core.Tensor | None = None, b_q: clika_runtime._core.Tensor | None = None, w_k: clika_runtime._core.Tensor | None = None, b_k: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> clika_runtime._core.Tensor

qk_layer_norm_(input, k=None, v=None, w_q=None, b_q=None, w_k=None, b_k=None, head_dim=0, eps=None) -> Tensor

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

qk_rms_norm

qk_rms_norm(*args, **kwargs)

qk_rms_norm(input: clika_runtime._core.Tensor, k: clika_runtime._core.Tensor | None = None, v: clika_runtime._core.Tensor | None = None, w_q: clika_runtime._core.Tensor | None = None, w_k: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

qk_rms_norm(input, k=None, v=None, w_q=None, w_k=None, head_dim=0, eps=None) -> tuple[Tensor, Tensor, Tensor]

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

qk_rms_norm_

qk_rms_norm_(*args, **kwargs)

qk_rms_norm_(input: clika_runtime._core.Tensor, k: clika_runtime._core.Tensor | None = None, v: clika_runtime._core.Tensor | None = None, w_q: clika_runtime._core.Tensor | None = None, w_k: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> clika_runtime._core.Tensor

qk_rms_norm_(input, k=None, v=None, w_q=None, w_k=None, head_dim=0, eps=None) -> Tensor

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

qleaky_relu

qleaky_relu(*args, **kwargs)

qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float = 0.01) -> clika_runtime._core.Tensor qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float = 0.01) -> clika_runtime._core.Tensor

qleaky_relu(input, negative_slope=0.01) -> Tensor

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

2. qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qleaky_relu(input, negative_slope, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qleaky_relu_

qleaky_relu_(*args, **kwargs)

qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qleaky_relu_(input, negative_slope, out) -> QTensor

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

2. qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

qleaky_relu_(input, negative_slope, out) -> Tensor

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

3. qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

qleaky_relu_(input, negative_slope, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

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

qlinear

qlinear(*args, **kwargs)

qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, activation: clika_runtime._core.Activation | None, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

qlinear(input, weight, bias=None, *, activation=None) -> Tensor

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

2. qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, activation: clika_runtime._core.Activation | None, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qlinear(input, weight, bias, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qlinear_

qlinear_(*args, **kwargs)

qlinear_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime.core.QTensor qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

Overloaded function.

1. qlinear_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.QTensor

qlinear_(input, weight, out, bias=None, *, activation=None) -> QTensor

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

2. qlinear_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None) -> clika_runtime._core.Tensor

qlinear_(input, weight, out, bias=None, *, activation=None) -> Tensor

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

qlinear_woq

qlinear_woq(*args, **kwargs)

qlinear_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, compute_mode: clika_runtime.QComputeMode = QComputeMode.ExactFP) -> clika_runtime._core.Tensor

qlinear_woq(input, weight, bias=None, *, activation=None, compute_mode=ExactFP) -> Tensor

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

qlinear_woq_

qlinear_woq_(*args, **kwargs)

qlinear_woq_(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, compute_mode: clika_runtime.QComputeMode = QComputeMode.ExactFP) -> clika_runtime._core.Tensor

qlinear_woq_(input, weight, out, bias=None, *, activation=None, compute_mode=ExactFP) -> Tensor

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

qmatmul

qmatmul(*args, **kwargs)

qmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor qmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, activation: clika_runtime._core.Activation | None, transpose_a: bool, transpose_b: bool, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor

qmatmul(input, other, bias=None, *, activation=None, transpose_a=False, transpose_b=False) -> Tensor

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

2. qmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, activation: clika_runtime._core.Activation | None, transpose_a: bool, transpose_b: bool, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qmatmul(input, other, bias, activation, transpose_a, transpose_b, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qmatmul_

qmatmul_(*args, **kwargs)

qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime.core.QTensor qmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime.core.Tensor qmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor

Overloaded function.

1. qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.QTensor

qmatmul_(input, other, out, bias=None, *, activation=None, transpose_a=False, transpose_b=False) -> QTensor

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

2. qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor

qmatmul_(input, other, out, bias=None, *, activation=None, transpose_a=False, transpose_b=False) -> Tensor

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

3. qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor

qmatmul_(input, other, out, out_scale, out_zero_point, out_quant_axis=-1, bias=None, *, activation=None, transpose_a=False, transpose_b=False) -> Tensor

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

qmatmul_woq

qmatmul_woq(*args, **kwargs)

qmatmul_woq(input: clika_runtime._core.Tensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, transpose_a: bool = False, transpose_b: bool = False, compute_mode: clika_runtime.QComputeMode = QComputeMode.ExactFP) -> clika_runtime._core.Tensor

qmatmul_woq(input, other, bias=None, *, activation=None, transpose_a=False, transpose_b=False, compute_mode=ExactFP) -> Tensor

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

qmatmul_woq_

qmatmul_woq_(*args, **kwargs)

qmatmul_woq_(input: clika_runtime._core.Tensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: clika_runtime._core.Activation | None = None, transpose_a: bool = False, transpose_b: bool = False, compute_mode: clika_runtime.QComputeMode = QComputeMode.ExactFP) -> clika_runtime._core.Tensor

qmatmul_woq_(input, other, out, bias=None, *, activation=None, transpose_a=False, transpose_b=False, compute_mode=ExactFP) -> Tensor

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

qmoe

qmoe(*args, **kwargs)

qmoe(input: clika_runtime._core.QTensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.QTensor = QTensor(, []), fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: clika_runtime.MoeRouting | None = None, renormalize: bool | None = None, n_group: int | None = None, topk_group: int | None = None, routed_scaling_factor: float | None = None, sparse_mixer_eps: float | None = None, apply_router_weight_on_input: bool | None = None, *, activation: clika_runtime._core.Activation | None = None, swiglu_fusion: clika_runtime.SwigluFusion | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: clika_runtime.GeluMode | None = None, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor qmoe(input: clika_runtime._core.QTensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None, fc2_bias: clika_runtime._core.Tensor | None, fc3_experts: clika_runtime._core.QTensor, fc3_bias: clika_runtime._core.Tensor | None, e_score_correction_bias: clika_runtime._core.Tensor | None, router_weights: clika_runtime._core.Tensor | None, routing_mode: clika_runtime.MoeRouting | None, renormalize: bool | None, n_group: int | None, topk_group: int | None, routed_scaling_factor: float | None, sparse_mixer_eps: float | None, apply_router_weight_on_input: bool | None, activation: clika_runtime._core.Activation | None, swiglu_fusion: clika_runtime.SwigluFusion | None, swiglu_alpha: float | None, swiglu_beta: float | None, swiglu_limit: float | None, gelu_mode: clika_runtime.GeluMode | None, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.QTensor

Overloaded function.

1. qmoe(input: clika_runtime._core.QTensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.QTensor = QTensor(, []), fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: clika_runtime.MoeRouting | None = None, renormalize: bool | None = None, n_group: int | None = None, topk_group: int | None = None, routed_scaling_factor: float | None = None, sparse_mixer_eps: float | None = None, apply_router_weight_on_input: bool | None = None, *, activation: clika_runtime._core.Activation | None = None, swiglu_fusion: clika_runtime.SwigluFusion | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: clika_runtime.GeluMode | None = None, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

qmoe(input, router_logits, fc1_experts, fc2_experts, top_k, fc1_bias=None, fc2_bias=None, fc3_experts=None, fc3_bias=None, e_score_correction_bias=None, router_weights=None, routing_mode=None, renormalize=None, n_group=None, topk_group=None, routed_scaling_factor=None, sparse_mixer_eps=None, apply_router_weight_on_input=None, *, activation=None, swiglu_fusion=None, swiglu_alpha=None, swiglu_beta=None, swiglu_limit=None, gelu_mode=None, shared_output=None) -> Tensor

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

2. qmoe(input: clika_runtime._core.QTensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None, fc2_bias: clika_runtime._core.Tensor | None, fc3_experts: clika_runtime._core.QTensor, fc3_bias: clika_runtime._core.Tensor | None, e_score_correction_bias: clika_runtime._core.Tensor | None, router_weights: clika_runtime._core.Tensor | None, routing_mode: clika_runtime.MoeRouting | None, renormalize: bool | None, n_group: int | None, topk_group: int | None, routed_scaling_factor: float | None, sparse_mixer_eps: float | None, apply_router_weight_on_input: bool | None, activation: clika_runtime._core.Activation | None, swiglu_fusion: clika_runtime.SwigluFusion | None, swiglu_alpha: float | None, swiglu_beta: float | None, swiglu_limit: float | None, gelu_mode: clika_runtime.GeluMode | None, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.QTensor

qmoe(input, router_logits, fc1_experts, fc2_experts, top_k, fc1_bias, fc2_bias, fc3_experts, fc3_bias, e_score_correction_bias, router_weights, routing_mode, renormalize, n_group, topk_group, routed_scaling_factor, sparse_mixer_eps, apply_router_weight_on_input, activation, swiglu_fusion, swiglu_alpha, swiglu_beta, swiglu_limit, gelu_mode, out_scale, out_zero_point, out_quant_axis=-1, *, out_dtype=Undefined, shared_output=None) -> QTensor

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

qmoe_woq

qmoe_woq(*args, **kwargs)

qmoe_woq(input: clika_runtime._core.Tensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.QTensor = QTensor(, []), fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: clika_runtime.MoeRouting | None = None, renormalize: bool | None = None, n_group: int | None = None, topk_group: int | None = None, routed_scaling_factor: float | None = None, sparse_mixer_eps: float | None = None, apply_router_weight_on_input: bool | None = None, *, activation: clika_runtime._core.Activation | None = None, swiglu_fusion: clika_runtime.SwigluFusion | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: clika_runtime.GeluMode | None = None, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

qmoe_woq(input, router_logits, fc1_experts, fc2_experts, top_k, fc1_bias=None, fc2_bias=None, fc3_experts=None, fc3_bias=None, e_score_correction_bias=None, router_weights=None, routing_mode=None, renormalize=None, n_group=None, topk_group=None, routed_scaling_factor=None, sparse_mixer_eps=None, apply_router_weight_on_input=None, *, activation=None, swiglu_fusion=None, swiglu_alpha=None, swiglu_beta=None, swiglu_limit=None, gelu_mode=None, shared_output=None) -> Tensor

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

qmul

qmul(*args, **kwargs)

qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

Overloaded function.

1. qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qmul(input, other, *, activation=Identity) -> Tensor

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

2. qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qmul(input, other, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined, activation=Identity) -> QTensor

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

qmul_

qmul_(*args, **kwargs)

qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.QTensor qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.Tensor qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

Overloaded function.

1. qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qmul_(input, other, out, *, activation=Identity) -> QTensor

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

2. qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qmul_(input, other, out, *, activation=Identity) -> Tensor

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

3. qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qmul_(input, other, out, out_scale, out_zero_point=None, out_quant_axis=-1, *, activation=Identity) -> Tensor

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

qquick_gelu

qquick_gelu(*args, **kwargs)

qquick_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor qquick_gelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qquick_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qquick_gelu(input) -> Tensor

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

2. qquick_gelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qquick_gelu(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qquick_gelu_

qquick_gelu_(*args, **kwargs)

qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qquick_gelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qquick_gelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qquick_gelu_(input, out) -> QTensor

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

2. qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

qquick_gelu_(input, out) -> Tensor

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

3. qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

qquick_gelu_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

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

qrelu

qrelu(*args, **kwargs)

qrelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor qrelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qrelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qrelu(input) -> Tensor

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

2. qrelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qrelu(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qrelu_

qrelu_(*args, **kwargs)

qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qrelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qrelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qrelu_(input, out) -> QTensor

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

2. qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

qrelu_(input, out) -> Tensor

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

3. qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

qrelu_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

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

qsigmoid

qsigmoid(*args, **kwargs)

qsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor qsigmoid(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qsigmoid(input) -> Tensor

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

2. qsigmoid(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qsigmoid(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qsigmoid_

qsigmoid_(*args, **kwargs)

qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qsigmoid(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qsigmoid(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qsigmoid_(input, out) -> QTensor

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

2. qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

qsigmoid_(input, out) -> Tensor

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

3. qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

qsigmoid_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

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

qsilu

qsilu(*args, **kwargs)

qsilu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor qsilu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qsilu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qsilu(input) -> Tensor

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

2. qsilu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qsilu(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qsilu_

qsilu_(*args, **kwargs)

qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qsilu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qsilu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qsilu_(input, out) -> QTensor

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

2. qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

qsilu_(input, out) -> Tensor

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

3. qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

qsilu_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

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

qsub

qsub(*args, **kwargs)

qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

Overloaded function.

1. qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qsub(input, other, *, activation=Identity) -> Tensor

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

2. qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qsub(input, other, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined, activation=Identity) -> QTensor

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

qsub_

qsub_(*args, **kwargs)

qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.QTensor qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime.core.Tensor qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

Overloaded function.

1. qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.QTensor

qsub_(input, other, out, *, activation=Identity) -> QTensor

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

2. qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qsub_(input, other, out, *, activation=Identity) -> Tensor

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

3. qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

qsub_(input, other, out, out_scale, out_zero_point=None, out_quant_axis=-1, *, activation=Identity) -> Tensor

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

qtanh

qtanh(*args, **kwargs)

qtanh(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor qtanh(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qtanh(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qtanh(input) -> Tensor

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

2. qtanh(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

qtanh(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

qtanh_

qtanh_(*args, **kwargs)

qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qtanh(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qtanh(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qtanh_(input, out) -> QTensor

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

2. qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

qtanh_(input, out) -> Tensor

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

3. qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

qtanh_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

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

quantile

quantile(*args, **kwargs)

quantile(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, dim: int | None = None, keepdim: bool = False, interpolation: clika_runtime.QuantileInterp = QuantileInterp.Linear) -> clika_runtime._core.Tensor

quantile(input, other, dim=None, keepdim=False, interpolation=Linear) -> Tensor

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

quantize

quantize(input: 'Tensor', scale: 'ScaleLike', zero_point: 'ZeroPointLike' = None, quant_axis: 'int' = -1, *, out_dtype: 'DataType' = DataType.Undefined, block_size: 'int' = 0) -> 'QTensor'

Quantize input at scale, a number or a tensor.

quantize(x, 0.02, out_dtype=int8) quantizes per tensor at a single scale; tensor scales carry per-channel and blocked schemes exactly as :func:clika_runtime.ops.quantize takes them.

quantize_

quantize_(*args, **kwargs)

quantize_(input: clika_runtime._core.Tensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor quantize(input: clika_runtime._core.Tensor, out: clika_runtime._core.Tensor, scale: clika_runtime._core.Tensor, zero_point: clika_runtime._core.Tensor | None = None, quant_axis: int = -1, block_size: int = 0) -> clika_runtime._core.Tensor

Overloaded function.

1. quantize_(input: clika_runtime._core.Tensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

quantize_(input, out) -> QTensor

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

2. quantize_(input: clika_runtime._core.Tensor, out: clika_runtime._core.Tensor, scale: clika_runtime._core.Tensor, zero_point: clika_runtime._core.Tensor | None = None, quant_axis: int = -1, block_size: int = 0) -> clika_runtime._core.Tensor

quantize_(input, out, scale, zero_point=None, quant_axis=-1, block_size=0) -> Tensor

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

quantize_dequantize

quantize_dequantize(input: 'Tensor', scale: 'ScaleLike', zero_point: 'ZeroPointLike' = None, quant_axis: 'int' = -1, *, code_dtype: 'DataType' = DataType.Undefined, out_dtype: 'DataType' = DataType.Undefined, block_size: 'int' = 0) -> 'Tensor'

Quantize then dequantize in one call, at a number or tensor scale.

The round trip reports what the quantized representation keeps; the standard fake-quantization step.

quantize_to_scheme

quantize_to_scheme(*args, **kwargs)

quantize_to_scheme(input: clika_runtime._core.Tensor, scheme: str, scale: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.QTensor

quantize_to_scheme(input, scheme, scale=None) -> QTensor

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

quantized_view

quantized_view(*args, **kwargs)

quantized_view(tensor: clika_runtime._core.Tensor) -> clika_runtime._core.QTensor

The typed quantized view of a tensor that carries a quantization scheme (Tensor.is_quantized); raises RuntimeError on a plain tensor.

quick_gelu

quick_gelu(*args, **kwargs)

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

quick_gelu(input) -> Tensor

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

rad2deg

rad2deg(*args, **kwargs)

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

rad2deg(input) -> Tensor

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

rad2deg_

rad2deg_(*args, **kwargs)

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

rad2deg_(self) -> Tensor

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

rand

rand(*shape: 'ShapeDim', dtype: 'DataType | None' = None, device: 'DeviceLike' = None) -> 'Tensor'

Uniform samples in [0, 1); float32 unless dtype says otherwise.

rand_like

rand_like(*args, **kwargs)

rand_like(reference: clika_runtime._core.Tensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

rand_like(reference, *, device=None) -> Tensor

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

randint

randint(*args, **kwargs)

randint(low: int, high: int, shape: collections.abc.Sequence[clika_runtime.ScalarOrTensor], *, dtype: clika_runtime._core.DataType = DataType.Int64, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

randint(low, high, shape, *, dtype=Int64, device=None) -> Tensor

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

randint_like

randint_like(*args, **kwargs)

randint_like(reference: clika_runtime._core.Tensor, low: int, high: int, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

randint_like(reference, low, high, *, device=None) -> Tensor

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

randn

randn(*shape: 'ShapeDim', dtype: 'DataType | None' = None, device: 'DeviceLike' = None) -> 'Tensor'

Standard-normal samples; float32 unless dtype says otherwise.

randn_like

randn_like(*args, **kwargs)

randn_like(reference: clika_runtime._core.Tensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

randn_like(reference, *, device=None) -> Tensor

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

random_

random_(*args, **kwargs)

random_(self: clika_runtime._core.Tensor, low: int | None = None, high: int | None = None, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

random_(self, low=None, high=None, *, device=None) -> Tensor

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

randperm

randperm(*args, **kwargs)

randperm(n: clika_runtime.ScalarOrTensor, *, dtype: clika_runtime._core.DataType = DataType.Int64, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

randperm(n, *, dtype=Int64, device=None) -> Tensor

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

reciprocal

reciprocal(*args, **kwargs)

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

reciprocal(input) -> Tensor

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

reciprocal_

reciprocal_(*args, **kwargs)

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

reciprocal_(self) -> Tensor

The reciprocal_ operator; its contract is ClikaRT::ops::reciprocal_ 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.

remainder

remainder(*args, **kwargs)

remainder(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

remainder(input, other) -> Tensor

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

remainder_

remainder_(*args, **kwargs)

remainder_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

remainder_(self, other) -> Tensor

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

renorm

renorm(*args, **kwargs)

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

renorm(input, other, dim, maxnorm, eps=None) -> Tensor

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

renorm_

renorm_(*args, **kwargs)

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

renorm_(self, p, dim, maxnorm, eps=None) -> Tensor

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

repeat

repeat(*args, **kwargs)

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

repeat(input, sizes) -> Tensor

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

repeat_interleave

repeat_interleave(*args, **kwargs)

repeat_interleave(input: clika_runtime._core.Tensor, repeats: clika_runtime.ScalarOrTensor, dim: int | None = None, output_size: int | None = None) -> clika_runtime._core.Tensor

repeat_interleave(input, repeats, dim=None, output_size=None) -> Tensor

The repeat_interleave operator; its contract is ClikaRT::ops::repeat_interleave 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.

requantize

requantize(*args, **kwargs)

requantize(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

requantize(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

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

requantize_

requantize_(*args, **kwargs)

requantize_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor requantize(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. requantize_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

requantize_(input, out) -> QTensor

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

2. requantize_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

requantize_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

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

resample

resample(*args, **kwargs)

resample(input: clika_runtime._core.Tensor, orig_freq: int, new_freq: int, lowpass_filter_width: int = 16, rolloff: float = 0.945, beta: float | None = None) -> clika_runtime._core.Tensor

resample(input, orig_freq, new_freq, lowpass_filter_width=16, rolloff=0.945, beta=None) -> Tensor

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

reshape

reshape(*args, **kwargs)

reshape(input: clika_runtime._core.Tensor, shape: collections.abc.Sequence[clika_runtime.IndexBound]) -> clika_runtime._core.Tensor

reshape(input, shape) -> Tensor

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

reshape_as

reshape_as(*args, **kwargs)

reshape_as(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

reshape_as(input, other) -> Tensor

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

rfft

rfft(*args, **kwargs)

rfft(input: clika_runtime._core.Tensor, n_fft: int | None = None, normalized: bool = False) -> clika_runtime._core.Tensor

rfft(input, n_fft=None, normalized=False) -> Tensor

The rfft operator; its contract is ClikaRT::ops::rfft 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.

roll

roll(*args, **kwargs)

roll(input: clika_runtime._core.Tensor, shifts: collections.abc.Sequence[int], dims: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor

roll(input, shifts, dims=[]) -> Tensor

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

rot90

rot90(*args, **kwargs)

rot90(input: clika_runtime._core.Tensor, k: int = 1, dims: collections.abc.Sequence[int] = [0, 1]) -> clika_runtime._core.Tensor

rot90(input, k=1, dims=[0, 1]) -> Tensor

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

rotary_embedding

rotary_embedding(*args, **kwargs)

rotary_embedding(x0: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: clika_runtime.RotaryMode | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: clika_runtime.RopeScaling | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

rotary_embedding(x0, position_ids=None, cos=None, sin=None, mode=None, rotary_dim=None, theta=None, scaling=None, scale=None, low_freq_factor=None, high_freq_factor=None, original_max_pos=None, beta_fast=None, beta_slow=None, freq_factors=None) -> Tensor

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

rotary_embedding_qk

rotary_embedding_qk(*args, **kwargs)

rotary_embedding_qk(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: clika_runtime.RotaryMode | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: clika_runtime.RopeScaling | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

rotary_embedding_qk(input, other, position_ids=None, cos=None, sin=None, mode=None, rotary_dim=None, theta=None, scaling=None, scale=None, low_freq_factor=None, high_freq_factor=None, original_max_pos=None, beta_fast=None, beta_slow=None, freq_factors=None) -> tuple[Tensor, Tensor]

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

rotary_embedding_qk_varlen

rotary_embedding_qk_varlen(*args, **kwargs)

rotary_embedding_qk_varlen(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, cu_seqlens: clika_runtime._core.Tensor, seqlens: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: clika_runtime.RotaryMode | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: clika_runtime.RopeScaling | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

rotary_embedding_qk_varlen(input, other, cu_seqlens, seqlens=None, position_ids=None, cos=None, sin=None, mode=None, rotary_dim=None, theta=None, scaling=None, scale=None, low_freq_factor=None, high_freq_factor=None, original_max_pos=None, beta_fast=None, beta_slow=None, freq_factors=None) -> tuple[Tensor, Tensor]

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

rotary_embedding_varlen

rotary_embedding_varlen(*args, **kwargs)

rotary_embedding_varlen(x0: clika_runtime._core.Tensor, cu_seqlens: clika_runtime._core.Tensor, seqlens: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: clika_runtime.RotaryMode | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: clika_runtime.RopeScaling | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

rotary_embedding_varlen(x0, cu_seqlens, seqlens=None, position_ids=None, cos=None, sin=None, mode=None, rotary_dim=None, theta=None, scaling=None, scale=None, low_freq_factor=None, high_freq_factor=None, original_max_pos=None, beta_fast=None, beta_slow=None, freq_factors=None) -> Tensor

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

round

round(*args, **kwargs)

round(input: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor

round(input, decimals=0) -> Tensor

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

round_

round_(*args, **kwargs)

round_(self: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor

round_(self, decimals=0) -> Tensor

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

rsqrt

rsqrt(*args, **kwargs)

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

rsqrt(input) -> Tensor

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

rsqrt_

rsqrt_(*args, **kwargs)

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

rsqrt_(self) -> Tensor

The rsqrt_ operator; its contract is ClikaRT::ops::rsqrt_ 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.

scatter

scatter(*args, **kwargs)

scatter(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

scatter(input, dim, index, src) -> Tensor

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

scatter_

scatter_(*args, **kwargs)

scatter_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

scatter_(self, dim, index, src) -> Tensor

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

scatter_add

scatter_add(*args, **kwargs)

scatter_add(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_add(input, dim, index, src, deterministic=False) -> Tensor

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

scatter_add_

scatter_add_(*args, **kwargs)

scatter_add_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_add_(self, dim, index, src, deterministic=False) -> Tensor

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

scatter_reduce

scatter_reduce(*args, **kwargs)

scatter_reduce(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: clika_runtime.ScatterReduceMode, include_self: bool = True, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_reduce(input, dim, index, src, reduce, include_self=True, deterministic=False) -> Tensor

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

scatter_reduce_

scatter_reduce_(*args, **kwargs)

scatter_reduce_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: clika_runtime.ScatterReduceMode, include_self: bool = True, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_reduce_(self, dim, index, src, reduce, include_self=True, deterministic=False) -> Tensor

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

searchsorted

searchsorted(*args, **kwargs)

searchsorted(sorted_sequence: clika_runtime._core.Tensor, values: clika_runtime._core.Tensor, out_int32: bool = False, right: bool = False, side: bool | None = None, sorter: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

searchsorted(sorted_sequence, values, out_int32=False, right=False, side=None, sorter=None) -> Tensor

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

select

select(*args, **kwargs)

select(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime.IndexBound) -> clika_runtime._core.Tensor

select(input, dim, index) -> Tensor

The select operator; its contract is ClikaRT::ops::select 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.

sgn

sgn(*args, **kwargs)

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

sgn(input) -> Tensor

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

sgn_

sgn_(*args, **kwargs)

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

sgn_(self) -> Tensor

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

shape

shape(*args, **kwargs)

shape(input: clika_runtime._core.Tensor, dim: int | None = None) -> clika_runtime._core.Tensor shape(input: clika_runtime._core.Tensor, start: int | None, end: int | None) -> clika_runtime._core.Tensor

Overloaded function.

1. shape(input: clika_runtime._core.Tensor, dim: int | None = None) -> clika_runtime._core.Tensor

shape(input, dim=None) -> Tensor

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

2. shape(input: clika_runtime._core.Tensor, start: int | None, end: int | None) -> clika_runtime._core.Tensor

shape(input, start, end) -> Tensor

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

shape_host

shape_host(*args, **kwargs)

shape_host(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor shape_host(input: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor shape_host(input: clika_runtime._core.Tensor, start: int | None, end: int | None) -> clika_runtime._core.Tensor

Overloaded function.

1. shape_host(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

shape_host(input) -> Tensor

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

2. shape_host(input: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor

shape_host(input, dim) -> Tensor

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

3. shape_host(input: clika_runtime._core.Tensor, start: int | None, end: int | None) -> clika_runtime._core.Tensor

shape_host(input, start, end) -> Tensor

The shape_host operator; its contract is ClikaRT::ops::shape_host 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.

sign

sign(*args, **kwargs)

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

sign(input) -> Tensor

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

sign_

sign_(*args, **kwargs)

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

sign_(self) -> Tensor

The sign_ operator; its contract is ClikaRT::ops::sign_ 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.

sin

sin(*args, **kwargs)

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

sin(input) -> Tensor

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

sin_

sin_(*args, **kwargs)

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

sin_(self) -> Tensor

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

sinc

sinc(*args, **kwargs)

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

sinc(input) -> Tensor

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

sinc_

sinc_(*args, **kwargs)

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

sinc_(self) -> Tensor

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

sinh

sinh(*args, **kwargs)

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

sinh(input) -> Tensor

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

sinh_

sinh_(*args, **kwargs)

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

sinh_(self) -> Tensor

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

slice

slice(*args, **kwargs)

slice(input: clika_runtime._core.Tensor, dim: int, start: clika_runtime.IndexBound = IndexBound(...), end: clika_runtime.IndexBound = IndexBound(...), step: clika_runtime.IndexBound = IndexBound(...)) -> clika_runtime._core.Tensor slice(input: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int], start: collections.abc.Sequence[clika_runtime.IndexBound] = [], end: collections.abc.Sequence[clika_runtime.IndexBound] = [], step: collections.abc.Sequence[clika_runtime.IndexBound] = []) -> clika_runtime._core.Tensor

Overloaded function.

1. slice(input: clika_runtime._core.Tensor, dim: int, start: clika_runtime.IndexBound = IndexBound(...), end: clika_runtime.IndexBound = IndexBound(...), step: clika_runtime.IndexBound = IndexBound(...)) -> clika_runtime._core.Tensor

slice(input, dim, start=None, end=None, step=1) -> Tensor

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

2. slice(input: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int], start: collections.abc.Sequence[clika_runtime.IndexBound] = [], end: collections.abc.Sequence[clika_runtime.IndexBound] = [], step: collections.abc.Sequence[clika_runtime.IndexBound] = []) -> clika_runtime._core.Tensor

slice(input, dim, start=[], end=[], step=[]) -> Tensor

The slice operator; its contract is ClikaRT::ops::slice 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.

snake

snake(*args, **kwargs)

snake(input: clika_runtime._core.Tensor, alpha: clika_runtime._core.Tensor | None = None, beta: clika_runtime._core.Tensor | None = None, eps: float = 1e-09) -> clika_runtime._core.Tensor

snake(input, alpha=None, beta=None, eps=1e-9) -> Tensor

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

snake_

snake_(*args, **kwargs)

snake_(self: clika_runtime._core.Tensor, alpha: clika_runtime._core.Tensor | None = None, beta: clika_runtime._core.Tensor | None = None, eps: float = 1e-09) -> clika_runtime._core.Tensor

snake_(self, alpha=None, beta=None, eps=1e-9) -> Tensor

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

softcap_logits

softcap_logits(*args, **kwargs)

softcap_logits(input: clika_runtime._core.Tensor, cap: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

softcap_logits(input, cap) -> Tensor

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

softcap_logits_

softcap_logits_(*args, **kwargs)

softcap_logits_(self: clika_runtime._core.Tensor, cap: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

softcap_logits_(self, cap) -> Tensor

The softcap_logits_ operator; its contract is ClikaRT::ops::softcap_logits_ 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.

sort

sort(*args, **kwargs)

sort(input: clika_runtime._core.Tensor, dim: int = -1, descending: bool = False, stable: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

sort(input, dim=-1, descending=False, stable=False) -> tuple[Tensor, Tensor]

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

split_by_size

split_by_size(*args, **kwargs)

split_by_size(input: clika_runtime._core.Tensor, chunk_size: int, dim: int = 0) -> list[clika_runtime._core.Tensor]

split_by_size(input, chunk_size, dim=0) -> list[Tensor]

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

split_with_sizes

split_with_sizes(*args, **kwargs)

split_with_sizes(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime.ScalarOrTensor], dim: int = 0) -> list[clika_runtime._core.Tensor]

split_with_sizes(input, sizes, dim=0) -> list[Tensor]

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

sqrt

sqrt(*args, **kwargs)

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

sqrt(input) -> Tensor

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

sqrt_

sqrt_(*args, **kwargs)

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

sqrt_(self) -> Tensor

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

square

square(*args, **kwargs)

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

square(input) -> Tensor

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

square_

square_(*args, **kwargs)

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

square_(self) -> Tensor

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

squeeze

squeeze(*args, **kwargs)

squeeze(input: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor

squeeze(input, dim=[]) -> Tensor

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

squeeze_

squeeze_(*args, **kwargs)

squeeze_(self: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor

squeeze_(self, dim=[]) -> Tensor

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

ssd_update

ssd_update(*args, **kwargs)

ssd_update(input: clika_runtime._core.Tensor, dt: clika_runtime._core.Tensor, a_rate: clika_runtime._core.Tensor, b_mat: clika_runtime._core.Tensor, c_mat: clika_runtime._core.Tensor, d_skip: clika_runtime._core.Tensor | None, dt_bias: clika_runtime._core.Tensor | None, z: clika_runtime._core.Tensor | None, state: clika_runtime._core.Tensor, seq_lens: clika_runtime._core.Tensor | None = None, slot_ids: clika_runtime._core.Tensor | None = None, dt_softplus: bool = False) -> clika_runtime._core.Tensor

ssd_update(input, dt, a_rate, b_mat, c_mat, d_skip, dt_bias, z, state, seq_lens=None, slot_ids=None, dt_softplus=False) -> Tensor

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

stack

stack(*args, **kwargs)

stack(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], dim: int = 0) -> clika_runtime._core.Tensor

stack(tensors, dim=0) -> Tensor

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

std

std(*args, **kwargs)

std(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], correction: int = 1, keepdim: bool = False) -> clika_runtime._core.Tensor

std(input, dims=[], correction=1, keepdim=False) -> Tensor

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

stft

stft(*args, **kwargs)

stft(input: clika_runtime._core.Tensor, n_fft: int, hop_length: int | None = None, win_length: int | None = None, window: clika_runtime._core.Tensor | None = None, center: bool = True, pad_mode: clika_runtime._core.PadMode = PadMode.Reflect, normalized: bool = False, onesided: bool = True) -> clika_runtime._core.Tensor

stft(input, n_fft, hop_length=None, win_length=None, window=None, center=True, pad_mode=Reflect, normalized=False, onesided=True) -> Tensor

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

stream

stream(stream_or_device: 'Stream | Device | str') -> '_PlacementContext'

A placement region from a stream (or a device, resolved to its default stream at each operation). Accepts a :class:Stream, a :class:Device, or a device string like "cuda:0".

sub

sub(*args, **kwargs)

sub(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, alpha: float = 1.0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor sub(a: clika_runtime.Scalar, input: clika_runtime._core.Tensor, alpha: float = 1.0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

Overloaded function.

1. sub(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, alpha: float = 1.0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

sub(input, other, alpha=1.0, *, activation=Identity) -> Tensor

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

2. sub(a: clika_runtime.Scalar, input: clika_runtime._core.Tensor, alpha: float = 1.0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

sub(a, input, alpha=1.0, *, activation=Identity) -> Tensor

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

sub_

sub_(*args, **kwargs)

sub_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor, alpha: float = 1.0, *, activation: clika_runtime._core.Activation = Activation.Identity) -> clika_runtime._core.Tensor

sub_(self, other, alpha=1.0, *, activation=Identity) -> Tensor

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

sum

sum(*args, **kwargs)

sum(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

sum(input, dims=[], keepdim=False, *, dtype=Undefined) -> Tensor

The sum operator; its contract is ClikaRT::ops::sum 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.

synchronize

synchronize(target: 'Stream | Device | str | None' = None) -> 'None'

Block until the targeted stream's submitted work has completed.

None (the default) synchronizes the stream the calling thread's ambient placement resolves to: a set stream as-is, a set device's current lane for this thread, and, with nothing set, the calling thread's current lane on cpu (never a default stream unless one was set); a :class:Device (or device string) synchronizes that device's default stream; a :class:Stream synchronizes itself. Prefer this targeted form over synchronize_all (which stalls every stream in the process).

synchronize_all

synchronize_all(*args, **kwargs)

synchronize_all() -> None

synchronize_all() -> None

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

take

take(*args, **kwargs)

take(self: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

take(self, index) -> Tensor

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

take_along_dim

take_along_dim(*args, **kwargs)

take_along_dim(input: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor, dim: int | None = None) -> clika_runtime._core.Tensor

take_along_dim(input, index, dim=None) -> Tensor

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

tan

tan(*args, **kwargs)

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

tan(input) -> Tensor

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

tan_

tan_(*args, **kwargs)

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

tan_(self) -> Tensor

The tan_ operator; its contract is ClikaRT::ops::tan_ 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.

tensor

tensor(data: 'object', *, dtype: 'DataType | None' = None, device: 'DeviceLike' = None) -> 'Tensor'

A tensor from an array, a nested Python list, a number, or a tensor.

Arrays and lists copy in on the CPU and move to device when asked. Lists of Python floats enter at float32; ints at int64; bools at bool. When dtype names a type the array bridge cannot hold (bfloat16, the float8 family, sub-byte codes), the data enters at a carrier type and converts through the runtime; pass raw payloads to :meth:Tensor.from_bytes to skip the conversion entirely.

A Tensor argument passes through, converted when dtype or device ask for a change (the result may share its storage).

tensordot

tensordot(*args, **kwargs)

tensordot(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, dims_a: collections.abc.Sequence[int], dims_b: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor

tensordot(input, other, dims_a, dims_b) -> Tensor

The tensordot operator; its contract is ClikaRT::ops::tensordot 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.

tile

tile(*args, **kwargs)

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

tile(input, dims) -> Tensor

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

to

to(*args, **kwargs)

to(src: clika_runtime._core.Tensor, *, target: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor to(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], *, target: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> list[clika_runtime._core.Tensor] to(src: clika_runtime._core.Tensor, device_str: str) -> clika_runtime._core.Tensor

Overloaded function.

1. to(src: clika_runtime._core.Tensor, *, target: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

to(src, *, target=None) -> Tensor

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

2. to(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], *, target: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> list[clika_runtime._core.Tensor]

to(tensors, *, target=None) -> list[Tensor]

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

3. to(src: clika_runtime._core.Tensor, device_str: str) -> clika_runtime._core.Tensor

to(src, device_str) -> Tensor

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

topk

topk(*args, **kwargs)

topk(input: clika_runtime._core.Tensor, k: int, dim: int = -1, largest: bool = True, sorted: bool = True) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

topk(input, k, dim=-1, largest=True, sorted=True) -> tuple[Tensor, Tensor]

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

trace

trace(fn: 'Traceable', *args: 'object', **kwargs: 'object') -> 'object'

Record fn's tensor operations into a runnable graph.

Two calling shapes: trace(fn, signature, ...) declares the inputs as :class:~clika_runtime.TensorSpec values (-1 dims are dynamic), and trace(fn, example_inputs=[...], ...) derives the signature from example tensors; their shapes and dtypes matter, their values are never read.

fn is a callable taking and returning lists of tensors, or an :class:~clika_runtime.nn.Module (called as module(*inputs); a bare tensor result becomes a one-element list). Tracing runs fn once on data-free stand-ins, so reading a tensor's value inside it (item(), numpy()) raises. Returns an :class:~clika_runtime.io.ModelGraph; run it with graph.run([...]).

transpose

transpose(*args, **kwargs)

transpose(input: clika_runtime._core.Tensor, dim0: int, dim1: int) -> clika_runtime._core.Tensor

transpose(input, dim0, dim1) -> Tensor

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

tril

tril(*args, **kwargs)

tril(input: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

tril(input, diagonal=0) -> Tensor

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

tril_

tril_(*args, **kwargs)

tril_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

tril_(self, diagonal=0) -> Tensor

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

triu

triu(*args, **kwargs)

triu(input: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

triu(input, diagonal=0) -> Tensor

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

triu_

triu_(*args, **kwargs)

triu_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

triu_(self, diagonal=0) -> Tensor

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

trunc

trunc(*args, **kwargs)

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

trunc(input) -> Tensor

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

trunc_

trunc_(*args, **kwargs)

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

trunc_(self) -> Tensor

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

unflatten

unflatten(*args, **kwargs)

unflatten(input: clika_runtime._core.Tensor, dim: int, sizes: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor

unflatten(input, dim, sizes) -> Tensor

The unflatten operator; its contract is ClikaRT::ops::unflatten 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.

uniform_

uniform_(*args, **kwargs)

uniform_(self: clika_runtime._core.Tensor, low: float = 0.0, high: float = 1.0, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

uniform_(self, low=0.0, high=1.0, *, device=None) -> Tensor

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

unique

unique(*args, **kwargs)

unique(input: clika_runtime._core.Tensor, sorted: bool = True, return_inverse: bool = False, return_counts: bool = False, dim: int | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

unique(input, sorted=True, return_inverse=False, return_counts=False, dim=None) -> tuple[Tensor, Tensor, Tensor]

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

unique_consecutive

unique_consecutive(*args, **kwargs)

unique_consecutive(input: clika_runtime._core.Tensor, return_inverse: bool = False, return_counts: bool = False, dim: int | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

unique_consecutive(input, return_inverse=False, return_counts=False, dim=None) -> tuple[Tensor, Tensor, Tensor]

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

unsqueeze

unsqueeze(*args, **kwargs)

unsqueeze(input: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor

unsqueeze(input, dim) -> Tensor

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

unsqueeze_

unsqueeze_(*args, **kwargs)

unsqueeze_(self: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor

unsqueeze_(self, dim) -> Tensor

The unsqueeze_ operator; its contract is ClikaRT::ops::unsqueeze_ 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.

validate_rotary_dim

validate_rotary_dim(*args, **kwargs)

validate_rotary_dim(rotary_dim: int, head_dim: int = -1) -> None

validate_rotary_dim(rotary_dim, head_dim=-1) -> None

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

var

var(*args, **kwargs)

var(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], correction: int = 1, keepdim: bool = False) -> clika_runtime._core.Tensor

var(input, dims=[], correction=1, keepdim=False) -> Tensor

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

version

version(*args, **kwargs)

version() -> str

The ClikaRT runtime version string (e.g. "0.1.0").

where

where(*args, **kwargs)

where(condition: clika_runtime._core.Tensor, input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor where(condition: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

Overloaded function.

1. where(condition: clika_runtime._core.Tensor, input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

where(condition, input, other) -> Tensor

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

2. where(condition: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

where(condition) -> Tensor

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

xlog1py

xlog1py(*args, **kwargs)

xlog1py(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

xlog1py(input, other) -> Tensor

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

xlogy

xlogy(*args, **kwargs)

xlogy(input: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

xlogy(input, other) -> Tensor

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

xlogy_

xlogy_(*args, **kwargs)

xlogy_(self: clika_runtime._core.Tensor, other: clika_runtime.ScalarOrTensor) -> clika_runtime._core.Tensor

xlogy_(self, other) -> Tensor

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

zero_

zero_(*args, **kwargs)

zero_(self: clika_runtime._core.Tensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

zero_(self, *, device=None) -> Tensor

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

zeros

zeros(*shape: 'ShapeDim', dtype: 'DataType | None' = None, device: 'DeviceLike' = None) -> 'Tensor'

A zero-filled tensor; float32 unless dtype says otherwise.

zeros_like

zeros_like(*args, **kwargs)

zeros_like(reference: clika_runtime._core.Tensor, *, device: clika_runtime.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

zeros_like(reference, *, device=None) -> Tensor

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