clika_runtime functions

abs

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

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

abs(input) -> Tensor

The abs operator.

abs_

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

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

abs_(self) -> Tensor

The abs_ operator.

acos

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

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

acos(input) -> Tensor

The acos operator.

acos_

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

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

acos_(self) -> Tensor

The acos_ operator.

acosh

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

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

acosh(input) -> Tensor

The acosh operator.

acosh_

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

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

acosh_(self) -> Tensor

The acosh_ operator.

adaptive_avg_pool

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

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

adaptive_avg_pool(input, output_size) -> Tensor

The adaptive_avg_pool operator.

adaptive_avg_pool1d

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

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.

adaptive_avg_pool2d

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

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.

adaptive_avg_pool3d

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

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.

adaptive_max_pool

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

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

adaptive_max_pool(input, output_size) -> Tensor

The adaptive_max_pool operator.

adaptive_max_pool1d

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

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.

adaptive_max_pool2d

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

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.

adaptive_max_pool3d

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

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.

add

addadd(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

add(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor add(input: clika_runtime._core.ops.Scalar, other: clika_runtime._core.Tensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

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

The add operator.

add_

add_add_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

add_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

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

The add_ operator.

add_layer_norm

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

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

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

The add_layer_norm operator.

add_rms_norm

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

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

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

The add_rms_norm operator.

all

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

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.

allclose

allcloseallclose(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: 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.

amax

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

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.

amin

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

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.

aminmax

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

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.

any

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

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.

arange

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

arange(start, end=None, step=1, *, dtype=None, device=None) -> Tensor

Evenly spaced values in [start, end); arange(n) counts from zero. All-integer arguments produce an int64 tensor, any float argument one of the default dtype; dtype overrides either. A zero-dimensional tensor bound counts as an integer when its dtype is not a floating-point type.

argmax

argmaxargmax(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: 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.

argmin

argminargmin(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: 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.

argsort

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

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.

as_tensor

as_tensor(data: 'object', dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

as_tensor(data, dtype=None, device=None) -> Tensor

A tensor over data without a copy when none is needed: a Tensor passes through, a c-contiguous writable numpy array on the CPU is borrowed (the tensor shares the array's memory, as :func:~clika_runtime.from_numpy does), and anything else enters through :func:tensor. A requested dtype or device that differs from the data's converts, which copies.

asin

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

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

asin(input) -> Tensor

The asin operator.

asin_

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

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

asin_(self) -> Tensor

The asin_ operator.

asinh

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

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

asinh(input) -> Tensor

The asinh operator.

asinh_

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

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

asinh_(self) -> Tensor

The asinh_ operator.

async_eval

async_eval(*trees: 'Any') -> 'None'

async_eval(*trees) -> None

Submit the deferred work behind every tensor in the trees (work recorded under a tracing scope) on its stream and return without waiting; a later read, or :func:eval, settles the values. A tensor with no deferred work is left as it is.

atan

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

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

atan(input) -> Tensor

The atan operator.

atan2

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

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

atan2(input, other) -> Tensor

The atan2 operator.

atan2_

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

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

atan2_(self, other) -> Tensor

The atan2_ operator.

atan_

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

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

atan_(self) -> Tensor

The atan_ operator.

atanh

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

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

atanh(input) -> Tensor

The atanh operator.

atanh_

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

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

atanh_(self) -> Tensor

The atanh_ operator.

atleast_1d

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

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

atleast_1d(input) -> Tensor

The atleast_1d operator.

atleast_2d

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

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

atleast_2d(input) -> Tensor

The atleast_2d operator.

atleast_3d

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

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

atleast_3d(input) -> Tensor

The atleast_3d operator.

attention

attentionattention(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), kept_prefix: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

attention(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), kept_prefix: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

attention(query, key, value, 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, kept_prefix=None) -> Tensor

The attention operator.

attention_over_cache

attention_over_cacheattention_over_cache(query: 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.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._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: object | None = None, num_heads: int | None = None, kv_num_heads: int | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.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, kept_prefix: clika_runtime._core.Tensor | None = None, kv_position_offset: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

attention_over_cache(query: 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.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._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: object | None = None, num_heads: int | None = None, kv_num_heads: int | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.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, kept_prefix: clika_runtime._core.Tensor | None = None, kv_position_offset: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

attention_over_cache(query, 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, kept_prefix=None, kv_position_offset=None) -> Tensor

The attention_over_cache operator.

attention_varlen

attention_varlenattention_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), attn_mask: clika_runtime._core.Tensor | None = None, head_sink: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), kept_prefix: clika_runtime._core.Tensor | None = None, kv_position_offset: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

attention_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), attn_mask: clika_runtime._core.Tensor | None = None, head_sink: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), kept_prefix: clika_runtime._core.Tensor | None = None, kv_position_offset: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

attention_varlen(query, key, value, 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, kept_prefix=None, kv_position_offset=None) -> Tensor

The attention_varlen operator.

avg_pool

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

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

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

The avg_pool operator.

avg_pool1d

avg_pool1davg_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: 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.

avg_pool2d

avg_pool2davg_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: 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.

avg_pool3d

avg_pool3davg_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: 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.

batch_norm

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

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: object | 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.

bernoulli

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

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

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

The bernoulli operator.

bernoulli_

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

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

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

The bernoulli_ operator.

binary_cross_entropy

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

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

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

The binary_cross_entropy operator.

binary_cross_entropy_with_logits

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

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

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

The binary_cross_entropy_with_logits operator.

bincount

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

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.

bitwise_and

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

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

bitwise_and(input, other) -> Tensor

The bitwise_and operator.

bitwise_and_

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

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

bitwise_and_(self, other) -> Tensor

The bitwise_and_ operator.

bitwise_left_shift

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

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

bitwise_left_shift(input, other) -> Tensor

The bitwise_left_shift operator.

bitwise_left_shift_

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

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

bitwise_left_shift_(self, other) -> Tensor

The bitwise_left_shift_ operator.

bitwise_not

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

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

bitwise_not(input) -> Tensor

The bitwise_not operator.

bitwise_not_

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

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

bitwise_not_(self) -> Tensor

The bitwise_not_ operator.

bitwise_or

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

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

bitwise_or(input, other) -> Tensor

The bitwise_or operator.

bitwise_or_

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

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

bitwise_or_(self, other) -> Tensor

The bitwise_or_ operator.

bitwise_right_shift

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

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

bitwise_right_shift(input, other) -> Tensor

The bitwise_right_shift operator.

bitwise_right_shift_

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

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

bitwise_right_shift_(self, other) -> Tensor

The bitwise_right_shift_ operator.

bitwise_xor

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

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

bitwise_xor(input, other) -> Tensor

The bitwise_xor operator.

bitwise_xor_

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

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

bitwise_xor_(self, other) -> Tensor

The bitwise_xor_ operator.

bmm

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

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

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

The bmm operator.

broadcast_tensors

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

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

broadcast_tensors(tensors) -> list[Tensor]

The broadcast_tensors operator.

broadcast_to

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

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

broadcast_to(input, shape) -> Tensor

The broadcast_to operator.

bucketize

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

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.

cast

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

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.

cast_like

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

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.

causal_conv_update

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

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: object | 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.

cdist

cdistcdist(x1: clika_runtime._core.Tensor, x2: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...)) -> clika_runtime._core.Tensor

cdist(x1: clika_runtime._core.Tensor, x2: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...)) -> clika_runtime._core.Tensor

cdist(x1, x2, p=2.0) -> Tensor

The cdist operator.

ceil

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

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

ceil(input) -> Tensor

The ceil operator.

ceil_

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

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

ceil_(self) -> Tensor

The ceil_ operator.

celu

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

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

celu(input, alpha=1.0) -> Tensor

The celu operator.

celu_

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

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

celu_(self, alpha=1.0) -> Tensor

The celu_ operator.

chunk

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

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.

circular_pad

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

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

circular_pad(input, pad) -> Tensor

The circular_pad operator.

clamp

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

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

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

The clamp operator.

clamp_

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

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

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

The clamp_ operator.

clamp_max

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

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

clamp_max(input, max) -> Tensor

The clamp_max operator.

clamp_max_

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

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

clamp_max_(self, max) -> Tensor

The clamp_max_ operator.

clamp_min

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

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

clamp_min(input, min) -> Tensor

The clamp_min operator.

clamp_min_

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

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

clamp_min_(self, min) -> Tensor

The clamp_min_ operator.

clone

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

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

clone(src) -> Tensor

The clone operator.

compile

compile(fn: 'Callable[..., Any]', signature: 'Sequence[TensorSpec]' = (), *, dynamic: 'bool | None' = None, fullgraph: 'bool' = False, optimize: 'bool | None' = None, specialize: 'bool | None' = None, place: 'PlaceLike' = None, dynamic_axes: 'DynamicAxes | None' = None, output_names: 'Sequence[str] | None' = None, graph_name: 'str | None' = None) -> 'CompiledFunction[Any, Any]'

compile(fn, signature=(), *, dynamic=None, fullgraph=False, optimize=None, specialize=None, place=None, dynamic_axes=None, output_names=None, graph_name=None) -> CompiledFunction

Wrap a callable or a module: the first call serves the eager result and records the graph; later calls with the same input structure and matching shapes run the graph and never call Python. A module returns a :class:CompiledModule. The call takes and returns pytrees: tensor leaves are the graph inputs and outputs, every other leaf is a static value baked into the capture.

Guards. A call re-captures when its input structure or a static leaf's value differs from the capture, and when a plain-data value the callable closes over or reads from its module globals by name has changed since the capture (numbers, strings, None and tuples, dicts, frozensets of them up to a small size; a list or a set is read as an accumulator the function may grow and is not tracked, and neither is a tensor, a module, or any other object, so a mutated closure tensor keeps serving the captured behavior until :meth:CompiledFunction.reset). Shapes are the graph's own guard: a drifted shape serves eagerly and re-captures with the drifted axes dynamic; past CompiledFunction.kMaxRecaptures the function serves eagerly until reset().

signature declares the inputs as :class:TensorSpec values (a -1 dim is dynamic) for the flattened tensor inputs, in order. Without one, the first call derives a static signature. dynamic=True marks every axis of every input dynamic at the first call, so one graph serves every shape; dynamic_axes marks axes by input name, {"x": {0: "batch"}} or {"x": [0]}. A call binds through the callable's signature, so a tensor is named by its parameter (fn(x, m) and fn(x, mask=m) are one structure named x and mask, absent optional parameters take their defaults, **kwargs entries read by their keys); a call whose one parameter holds a container names the tensors by the container's own keys (fn(batch) reads input_ids), a container beside other parameters joins the key to the parameter's name with ., a positional-only or *args tensor is input_<i>, and a nested position joins its path entries with . (batch.tokens).

fullgraph=True raises :class:~clika_runtime.ClikaRTError when the function cannot be recorded as one graph (a Python branch on a tensor value, a data read during the recording); the default keeps serving such a function eagerly. optimize and specialize select the capture's graph optimization; place (a device, device string, or stream) homes the captured graph and its weights, and without it each capture is homed on the device its tensor inputs sit on (a call on another device captures again there); output_names names the tensor outputs in flattening order and graph_name names the graph.

concat

concatconcat(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], dim: int = 0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

concat(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], dim: int = 0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

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

The concat operator.

constant_pad

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

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

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

The constant_pad operator.

contiguous

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

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

contiguous(input, force_copy=False) -> Tensor

The contiguous operator.

conv

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

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

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

The conv operator.

conv1d

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

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

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

The conv1d operator.

conv2d

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

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

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

The conv2d operator.

conv3d

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

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

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

The conv3d operator.

conv_transpose

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

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

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

The conv_transpose operator.

conv_transpose1d

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

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

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

The conv_transpose1d operator.

conv_transpose2d

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

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

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

The conv_transpose2d operator.

conv_transpose3d

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

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

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

The conv_transpose3d operator.

copy

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

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

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

The copy operator.

copy_

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

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

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

The copy_ operator.

copy_into

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

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

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

The copy_into operator.

copy_to_cpu

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

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

copy_to_cpu(src) -> Tensor

The copy_to_cpu operator.

copysign

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

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

copysign(input, other) -> Tensor

The copysign operator.

copysign_

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

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

copysign_(self, other) -> Tensor

The copysign_ operator.

cos

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

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

cos(input) -> Tensor

The cos operator.

cos_

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

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

cos_(self) -> Tensor

The cos_ operator.

cosh

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

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

cosh(input) -> Tensor

The cosh operator.

cosh_

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

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

cosh_(self) -> Tensor

The cosh_ operator.

cosine_similarity

cosine_similaritycosine_similarity(x1: clika_runtime._core.Tensor, x2: clika_runtime._core.Tensor, dim: int = 1, eps: float | None = None) -> clika_runtime._core.Tensor

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

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

The cosine_similarity operator.

count_nonzero

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

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.

cross

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

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.

cross_entropy

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

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

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

The cross_entropy operator.

cummax

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

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.

cummin

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

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.

cumprod

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

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.

cumprod_

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

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.

cumsum

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

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.

cumsum_

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

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.

deform_conv

deform_convdeform_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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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.

deg2rad

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

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

deg2rad(input) -> Tensor

The deg2rad operator.

deg2rad_

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

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

deg2rad_(self) -> Tensor

The deg2rad_ operator.

dequantize

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

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.

dequantize_

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

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

dequantize_(input, out) -> Tensor

The dequantize_ operator.

device

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

device(target) -> a placement region

Run the region on a device: operations inside run on the calling thread's lane for it, and factories called inside place their tensors there. Accepts a :class:Device or a device string ("cpu", "cuda:0"); "meta" enters :func:meta_init instead, where every tensor built is storage-free (Tensor.is_fake) and reports the placement it will materialize on. For a specific stream use :func:stream.

device_count

device_countdevice_count(api: clika_runtime._core.Device) -> int

device_count(api: clika_runtime._core.Device) -> int device_count(kind: object) -> int

Overloaded function.

1. device_count(api: clika_runtime._core.Device) -> int

How many devices the backend exposes here (0 when it is unavailable). Brings the backend up on the first call.

2. device_count(kind: object) -> int

device_count(kind) -> int

How many devices the backend exposes (0 when it is unavailable).

diag

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

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

diag(input, diagonal=0) -> Tensor

The diag operator.

diag_embed

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

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.

diagonal

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

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.

diff

diffdiff(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: 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.

div

divdiv(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, rounding_mode: object | None = 'none', *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

div(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, rounding_mode: object | None = 'none', *, activation: object | None = 'identity') -> clika_runtime._core.Tensor div(input: clika_runtime._core.ops.Scalar, other: clika_runtime._core.Tensor, rounding_mode: object | None = 'none', *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

div(input, other, rounding_mode='none', *, activation='identity') -> Tensor

The div operator.

div_

div_div_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, rounding_mode: object | None = 'none', *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

div_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, rounding_mode: object | None = 'none', *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

div_(self, other, rounding_mode='none', *, activation='identity') -> Tensor

The div_ operator.

dot

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

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

dot(input, other) -> Tensor

The dot operator.

dynamic_quantize

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

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.

eager

eager() -> '_EagerScope'

eager() -> an execution-mode region

Force immediate execution inside a :func:tracing region, for a value the host must see (a metric, a control-flow decision). Outside tracing execution is already eager, so the region changes nothing there.

einsum

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

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

einsum(equation, operands) -> Tensor

The einsum operator.

elu

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

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.

elu_

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

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

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

The elu_ operator.

embedding

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

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

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

The embedding operator.

empty

empty(*size: 'ShapeDim', dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

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

An uninitialized tensor of the given shape; the default dtype unless dtype says otherwise.

empty_cache

empty_cacheempty_cache(device: object) -> None

empty_cache(device: object) -> None

empty_cache(device) -> None

Return the runtime pool's idle memory on the device to the driver (or the OS); memory in use is never touched. A closed model's bytes stay in the pool until this call or memory pressure, so close one model, call this, then load the next.

empty_like

empty_like(input: 'Tensor', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

empty_like(input, *, dtype=None, device=None) -> Tensor

An uninitialized tensor of input's shape, dtype and device, each overridable by keyword.

empty_strided

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

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

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

The empty_strided operator.

eq

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

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

eq(input, other) -> Tensor

The eq operator.

eq_

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

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

eq_(self, other) -> Tensor

The eq_ operator.

erf

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

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

erf(input) -> Tensor

The erf operator.

erf_

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

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

erf_(self) -> Tensor

The erf_ operator.

erfc

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

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

erfc(input) -> Tensor

The erfc operator.

erfc_

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

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

erfc_(self) -> Tensor

The erfc_ operator.

erfinv

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

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

erfinv(input) -> Tensor

The erfinv operator.

erfinv_

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

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

erfinv_(self) -> Tensor

The erfinv_ operator.

eval

eval(*trees: 'Any') -> 'None'

eval(*trees) -> None

Wait until every tensor in the trees has its value. A tree is any nesting of dicts, lists, tuples, dataclasses and registered containers; leaves that are not tensors are skipped. Returns once every tensor's pending work (including work recorded under a tracing scope) has run, the point where an asynchronous failure surfaces.

exp

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

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

exp(input) -> Tensor

The exp operator.

exp_

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

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

exp_(self) -> Tensor

The exp_ operator.

expand

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

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

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

The expand operator.

expand_as

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

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.

exponential_

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

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

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

The exponential_ operator.

eye

eye(n: 'int', m: 'int | None' = None, *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

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

An n by m (n by n when m is None) matrix with ones on the diagonal; the default dtype unless dtype says otherwise.

fast_gelu

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

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

fast_gelu(input) -> Tensor

The fast_gelu operator.

fill

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

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

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

The fill operator.

fill_

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

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

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

The fill_ operator.

fill_diagonal

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

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

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

The fill_diagonal operator.

fill_diagonal_

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

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

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

The fill_diagonal_ operator.

flatten

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

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.

flip

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

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

flip(input, dims) -> Tensor

The flip operator.

fliplr

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

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

fliplr(input) -> Tensor

The fliplr operator.

flipud

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

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

flipud(input) -> Tensor

The flipud operator.

floor

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

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

floor(input) -> Tensor

The floor operator.

floor_

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

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

floor_(self) -> Tensor

The floor_ operator.

floor_divide

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

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

floor_divide(input, other) -> Tensor

The floor_divide operator.

floor_divide_

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

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

floor_divide_(self, other) -> Tensor

The floor_divide_ operator.

fmax

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

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

fmax(input, other) -> Tensor

The fmax operator.

fmin

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

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

fmin(input, other) -> Tensor

The fmin operator.

fmod

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

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

fmod(input, other) -> Tensor

The fmod operator.

fmod_

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

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

fmod_(self, other) -> Tensor

The fmod_ operator.

fold

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

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

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

The fold operator.

frac

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

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

frac(input) -> Tensor

The frac operator.

frac_

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

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

frac_(self) -> Tensor

The frac_ operator.

frexp

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

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

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

The frexp operator.

from_dlpack

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

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

from_dlpack(array) -> Tensor

A tensor SHARING the memory of any DLPack producer (a numpy array, a torch tensor, another framework's array): no copy, mutations alias both ways, and the producer's buffer stays alive for the tensor's lifetime. The dtype and the device follow the producer (cpu, cuda, vulkan and metal devices). A CUDA producer that takes the DLPack stream argument is handed the calling thread's current stream on its device, so the work it still has queued on the buffer finishes before any runtime operation reads it. On the thread's own stream nothing waits on the host; inside synchronous(), or on a device's default stream, the call waits for that work before it returns. A producer without the stream argument is read as it stands.

from_numpy

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

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(size: 'Sequence[int] | int', fill_value: 'Number', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

full(size, fill_value, *, dtype=None, device=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 one of the default dtype.

full_like

full_like(input: 'Tensor', fill_value: 'Number', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

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

A tensor of input's shape, dtype and device filled with fill_value; dtype and device overridable by keyword.

gated_delta_update

gated_delta_updategated_delta_update(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, beta: clika_runtime._core.Tensor, gate: 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(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, beta: clika_runtime._core.Tensor, gate: 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(query, key, value, beta, gate, state, seq_lens=None, slot_ids=None, scale=None, gate_bias=None, gate_scale=None) -> Tensor

The gated_delta_update operator.

gated_rms_norm

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

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

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

The gated_rms_norm operator.

gather

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

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.

ge

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

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

ge(input, other) -> Tensor

The ge operator.

ge_

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

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

ge_(self, other) -> Tensor

The ge_ operator.

geglu

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

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

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

The geglu operator.

gelu

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

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

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

The gelu operator.

gelu_

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

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

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

The gelu_ operator.

generate_rotary_cache

generate_rotary_cachegenerate_rotary_cache(rotary_dim: int, max_positions: int, theta: float | None = None, scaling: object | 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._core.ops.StreamOrDevice = StreamOrDevice(...), yarn_truncate: bool | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

generate_rotary_cache(rotary_dim: int, max_positions: int, theta: float | None = None, scaling: object | 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._core.ops.StreamOrDevice = StreamOrDevice(...), yarn_truncate: bool | None = None) -> 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, yarn_truncate=None) -> tuple[Tensor, Tensor]

The generate_rotary_cache operator.

get_default_dtype

get_default_dtype() -> 'Dtype'

get_default_dtype() -> dtype

The floating-point dtype a factory uses when dtype is not given, and the dtype of a tensor built from Python floats; float32 until :func:set_default_dtype changes it.

get_device_properties

get_device_propertiesget_device_properties(device: clika_runtime._core.Device) -> clika_runtime._core.DeviceProperties

get_device_properties(device: clika_runtime._core.Device) -> clika_runtime._core.DeviceProperties get_device_properties(device: object) -> clika_runtime._core.DeviceProperties

Overloaded function.

1. get_device_properties(device: clika_runtime._core.Device) -> clika_runtime._core.DeviceProperties

The static capabilities of one device; raises RuntimeError when the device does not exist or its backend is not loaded.

2. get_device_properties(device: object) -> clika_runtime._core.DeviceProperties

get_device_properties(device) -> DeviceProperties

The static capabilities of a device (a Device or a device string).

get_printoptions

get_printoptions() -> 'dict[str, Any]'

get_printoptions() -> dict

The current print options (a copy): precision, threshold, edgeitems, linewidth, sci_mode.

glu

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

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

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

The glu operator.

grid_sample

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

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

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

The grid_sample operator.

group_norm

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

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: object | 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.

group_query_attention

group_query_attentiongroup_query_attention(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: object | 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.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, kept_prefix: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

group_query_attention(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: object | 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.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, kept_prefix: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

group_query_attention(query, key, value, 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, kept_prefix=None) -> tuple[Tensor, Tensor, Tensor]

The group_query_attention operator.

group_query_attention_varlen

group_query_attention_varlengroup_query_attention_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: object | 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.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, kept_prefix: clika_runtime._core.Tensor | None = None, kv_position_offset: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

group_query_attention_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: object | 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._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.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, kept_prefix: clika_runtime._core.Tensor | None = None, kv_position_offset: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

group_query_attention_varlen(query, key, value, 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, kept_prefix=None, kv_position_offset=None) -> tuple[Tensor, Tensor, Tensor]

The group_query_attention_varlen operator.

gt

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

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

gt(input, other) -> Tensor

The gt operator.

gt_

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

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

gt_(self, other) -> Tensor

The gt_ operator.

hardshrink

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

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

hardshrink(input, lambd=0.5) -> Tensor

The hardshrink operator.

hardshrink_

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

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

hardshrink_(self, lambd=0.5) -> Tensor

The hardshrink_ operator.

hardsigmoid

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

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

hardsigmoid(input) -> Tensor

The hardsigmoid operator.

hardsigmoid_

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

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

hardsigmoid_(self) -> Tensor

The hardsigmoid_ operator.

hardswish

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

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

hardswish(input) -> Tensor

The hardswish operator.

hardswish_

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

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

hardswish_(self) -> Tensor

The hardswish_ operator.

hardtanh

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

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.

hardtanh_

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

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

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

The hardtanh_ operator.

hash_128

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

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

hash_128(input, seed=0) -> Tensor

The hash_128 operator.

hash_256

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

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

hash_256(input, seed=0) -> Tensor

The hash_256 operator.

hash_64

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

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

hash_64(input, seed=0) -> Tensor

The hash_64 operator.

hash_chain

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

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.

hash_lanes

hash_laneshash_lanes(input: clika_runtime._core.Tensor, key: int = 0, algo: object = 'auto', mask_bits: int = 0) -> clika_runtime._core.Tensor

hash_lanes(input: clika_runtime._core.Tensor, key: int = 0, algo: object = 'auto', mask_bits: int = 0) -> clika_runtime._core.Tensor

hash_lanes(input, key=0, algo='auto', mask_bits=0) -> Tensor

The hash_lanes operator.

hash_tensor

hash_tensorhash_tensor(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False, mode: object = 'xor_sum') -> clika_runtime._core.Tensor

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

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

The hash_tensor operator.

histogram

histogramhistogram(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: 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.

huber_loss

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

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

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

The huber_loss operator.

hypot

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

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

hypot(input, other) -> Tensor

The hypot operator.

hypot_

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

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

hypot_(self, other) -> Tensor

The hypot_ operator.

index

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

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

index(input, indices) -> Tensor

The index operator.

index_add

index_addindex_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: 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.

index_add_

index_add_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: 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.

index_copy

index_copyindex_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: 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.

index_copy_

index_copy_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: 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.

index_fill

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

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

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

The index_fill operator.

index_fill_

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

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

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

The index_fill_ operator.

index_put

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

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

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

The index_put operator.

index_put_

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

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

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

The index_put_ operator.

index_select

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

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.

inner

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

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

inner(input, other) -> Tensor

The inner operator.

instance_norm

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

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: object | 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.

interpolate

interpolateinterpolate(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], mode: object = 'nearest', align_corners: bool | None = None, recompute_scale_factor: bool = False, antialias: bool = False) -> clika_runtime._core.Tensor

interpolate(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], mode: object = '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.

is_available

is_availableis_available(kind: object) -> bool

is_available(kind: object) -> bool

is_available(kind) -> bool

Whether the backend ("cuda", "vulkan", "metal", "cpu", ... or a Device) loads and initializes on this machine; the first call brings it up.

is_meta_init

is_meta_init() -> 'bool'

is_meta_init() -> bool

Whether the calling thread is inside a :func:meta_init (or device("meta")) region.

isclose

iscloseisclose(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: 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.

isfinite

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

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

isfinite(input) -> Tensor

The isfinite operator.

isinf

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

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

isinf(input) -> Tensor

The isinf operator.

isnan

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

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

isnan(input) -> Tensor

The isnan operator.

isneginf

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

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

isneginf(input) -> Tensor

The isneginf operator.

isposinf

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

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

isposinf(input) -> Tensor

The isposinf operator.

kl_div

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

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

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

The kl_div operator.

kron

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

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

kron(input, other) -> Tensor

The kron operator.

kthvalue

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

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.

l1_loss

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

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

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

The l1_loss operator.

layer_norm

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

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

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

The layer_norm operator.

le

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

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

le(input, other) -> Tensor

The le operator.

le_

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

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

le_(self, other) -> Tensor

The le_ operator.

leaky_relu

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

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.

leaky_relu_

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

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

leaky_relu_(self, negative_slope=0.01) -> Tensor

The leaky_relu_ operator.

linear

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

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

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

The linear operator.

linspace

linspace(start: 'Number', end: 'Number', steps: 'int', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

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

steps values evenly spaced from start to end inclusive; the default dtype unless dtype says otherwise.

load

load(path: 'PathLike', *, device: 'Device | str | None' = None, mmap: 'bool | None' = None) -> 'Tensor | dict[str, Tensor] | Any'

load(path, *, device=None, mmap=None) -> Tensor | dict[str, Tensor] | pytree

Read a safetensors file written by :func:save (or by another tool) onto device (None means the cpu). A file holding one tensor under the reserved key loads as a :class:~clika_runtime.Tensor; a file whose header metadata carries a pytree structure loads as that pytree; anything else loads as a dict[str, Tensor] in header order.

mmap selects memory-mapped, on-demand loading; only the eager form is served here, so mmap=True raises NotImplementedError.

load_with_metadata

load_with_metadata(path: 'PathLike', *, device: 'Device | str | None' = None, mmap: 'bool | None' = None) -> 'tuple[Tensor | dict[str, Tensor] | Any, dict[str, str]]'

load_with_metadata(path, *, device=None, mmap=None) -> (obj, dict[str, str])

:func:load plus the file's header metadata as a dict in header order: the pairs save(..., metadata=) wrote, or whatever another tool put there (a non-string value arrives as its JSON text). The structure entries :func:load consumes (clika.format, clika.treespec) are not part of the returned dict.

log

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

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

log(input) -> Tensor

The log operator.

log10

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

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

log10(input) -> Tensor

The log10 operator.

log10_

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

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

log10_(self) -> Tensor

The log10_ operator.

log1p

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

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

log1p(input) -> Tensor

The log1p operator.

log1p_

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

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

log1p_(self) -> Tensor

The log1p_ operator.

log2

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

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

log2(input) -> Tensor

The log2 operator.

log2_

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

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

log2_(self) -> Tensor

The log2_ operator.

log_

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

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

log_(self) -> Tensor

The log_ operator.

log_sigmoid

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

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

log_sigmoid(input) -> Tensor

The log_sigmoid operator.

log_sigmoid_

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

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

log_sigmoid_(self) -> Tensor

The log_sigmoid_ operator.

log_softmax

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

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

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

The log_softmax operator.

log_softmax_

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

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

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

The log_softmax_ operator.

logaddexp

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

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

logaddexp(input, other) -> Tensor

The logaddexp operator.

logaddexp2

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

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

logaddexp2(input, other) -> Tensor

The logaddexp2 operator.

logical_and

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

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.

logical_and_

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

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.

logical_not

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

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

logical_not(input) -> Tensor

The logical_not operator.

logical_not_

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

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

logical_not_(self) -> Tensor

The logical_not_ operator.

logical_or

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

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.

logical_or_

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

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.

logical_xor

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

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.

logical_xor_

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

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.

logit

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

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

logit(input, eps=None) -> Tensor

The logit operator.

logit_

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

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

logit_(self, eps=None) -> Tensor

The logit_ operator.

logsumexp

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

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.

lt

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

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

lt(input, other) -> Tensor

The lt operator.

lt_

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

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

lt_(self, other) -> Tensor

The lt_ operator.

make_quantized

make_quantizedmake_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

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_affinemake_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

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

manual_seed

manual_seedmanual_seed(seed: int, device: object | None = None) -> None

manual_seed(seed: int, device: object | None = None) -> None

manual_seed(seed, device=None) -> None

Seed a device's random-number generator so its random ops replay; None seeds the calling thread's ambient device.

masked_fill

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

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

masked_fill(input, mask, value) -> Tensor

The masked_fill operator.

masked_fill_

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

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

masked_fill_(self, mask, value) -> Tensor

The masked_fill_ operator.

masked_scatter

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

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.

masked_scatter_

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

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.

masked_select

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

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.

matmul

matmulmatmul(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | 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: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | 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.

max

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

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.

max_pool

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

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

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

The max_pool operator.

max_pool1d

max_pool1dmax_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: 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.

max_pool1d_with_indices

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

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

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

The max_pool1d_with_indices operator.

max_pool2d

max_pool2dmax_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: 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.

max_pool2d_with_indices

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

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

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

The max_pool2d_with_indices operator.

max_pool3d

max_pool3dmax_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: 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.

max_pool3d_with_indices

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

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

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

The max_pool3d_with_indices operator.

max_pool_with_indices

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

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

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

The max_pool_with_indices operator.

maximum

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

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

maximum(input, other) -> Tensor

The maximum operator.

maximum_

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

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

maximum_(self, other) -> Tensor

The maximum_ operator.

mean

meanmean(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: 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.

median

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

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.

memory_stats

memory_statsmemory_stats(device: object) -> clika_runtime._core.MemoryStats

memory_stats(device: object) -> clika_runtime._core.MemoryStats

memory_stats(device) -> MemoryStats

A snapshot of the device's memory: physical free/total and the runtime pool's counters.

meshgrid

meshgridmeshgrid(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], indexing: object = 'ij') -> list[clika_runtime._core.Tensor]

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

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

The meshgrid operator.

meta_init

meta_init() -> '_MetaInitScope'

meta_init() -> a construction region

Mark the region as shape-only construction: a factory called inside (zeros, empty, a layer's declared slots) is meant to mint a storage-free tensor carrying shape, dtype, and placement only, so a large model builds at zero bytes and materializes later through Module.to_empty(device=...) or load_state_dict(..., assign=True). device("meta") is the same region. The region sets the calling thread's meta-init flag (:func:is_meta_init), which the tensor factories read: a tensor built inside is storage-free (Tensor.is_fake) and reports the placement it will materialize on (the requested device, or the ambient one); there is no separate meta device.

min

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

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.

minimum

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

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

minimum(input, other) -> Tensor

The minimum operator.

minimum_

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

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

minimum_(self, other) -> Tensor

The minimum_ operator.

mish

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

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

mish(input) -> Tensor

The mish operator.

mish_

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

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

mish_(self) -> Tensor

The mish_ operator.

mla_attention

mla_attentionmla_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: 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.

mm

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

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

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

The mm operator.

mod

modmod(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, mode: object = 'python') -> clika_runtime._core.Tensor

mod(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, mode: object = 'python') -> clika_runtime._core.Tensor

mod(input, other, mode='python') -> Tensor

The mod operator.

mod_

mod_mod_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, mode: object = 'python') -> clika_runtime._core.Tensor

mod_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, mode: object = 'python') -> clika_runtime._core.Tensor

mod_(self, other, mode='python') -> Tensor

The mod_ operator.

moe

moemoe(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: object | 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: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | None = None, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

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: object | 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: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | 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.

mrope_rotary_embedding

mrope_rotary_embeddingmrope_rotary_embedding(input: 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: object | None = None, mode: object | None = None, rotary_dim: int | None = None, scale: float | None = None) -> clika_runtime._core.Tensor

mrope_rotary_embedding(input: 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: object | None = None, mode: object | None = None, rotary_dim: int | None = None, scale: float | None = None) -> clika_runtime._core.Tensor

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

The mrope_rotary_embedding operator.

mrope_rotary_embedding_qk_varlen

mrope_rotary_embedding_qk_varlenmrope_rotary_embedding_qk_varlen(query: clika_runtime._core.Tensor, key: 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: object | None = None, mode: object | 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(query: clika_runtime._core.Tensor, key: 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: object | None = None, mode: object | 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(query, key, 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.

mrope_rotary_embedding_varlen

mrope_rotary_embedding_varlenmrope_rotary_embedding_varlen(input: 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: object | None = None, mode: object | None = None, rotary_dim: int | None = None, scale: float | None = None) -> clika_runtime._core.Tensor

mrope_rotary_embedding_varlen(input: 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: object | None = None, mode: object | None = None, rotary_dim: int | None = None, scale: float | None = None) -> clika_runtime._core.Tensor

mrope_rotary_embedding_varlen(input, 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.

ms_deform_attention

ms_deform_attentionms_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: 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.

mse_loss

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

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

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

The mse_loss operator.

mul

mulmul(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

mul(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor mul(input: clika_runtime._core.ops.Scalar, other: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

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

The mul operator.

mul_

mul_mul_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

mul_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

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

The mul_ operator.

multinomial

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

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

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

The multinomial operator.

mv

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

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

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

The mv operator.

nan_to_num

nan_to_numnan_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: 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.

nan_to_num_

nan_to_num_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: 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.

nanmean

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

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.

nanmedian

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

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.

nanquantile

nanquantilenanquantile(input: clika_runtime._core.Tensor, q: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, keepdim: bool = False, interpolation: object = 'linear') -> clika_runtime._core.Tensor

nanquantile(input: clika_runtime._core.Tensor, q: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, keepdim: bool = False, interpolation: object = 'linear') -> clika_runtime._core.Tensor

nanquantile(input, q, dim=None, keepdim=False, interpolation='linear') -> Tensor

The nanquantile operator.

nansum

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

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.

narrow

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

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

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

The narrow operator.

ndim

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

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

ndim(input) -> Tensor

The ndim operator.

ndim_host

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

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

ndim_host(input) -> Tensor

The ndim_host operator.

ne

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

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

ne(input, other) -> Tensor

The ne operator.

ne_

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

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

ne_(self, other) -> Tensor

The ne_ operator.

neg

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

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

neg(input) -> Tensor

The neg operator.

neg_

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

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

neg_(self) -> Tensor

The neg_ operator.

nll_loss

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

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

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

The nll_loss operator.

nms

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

nms(boxes: clika_runtime._core.Tensor, scores: clika_runtime._core.Tensor, max_output_boxes_per_class: clika_runtime._core.ops.ScalarOrTensor | None = None, iou_threshold: clika_runtime._core.ops.ScalarOrTensor | None = None, score_threshold: clika_runtime._core.ops.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.

nonzero

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

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

nonzero(input) -> Tensor

The nonzero operator.

norm

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

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

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

The norm operator.

normal

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

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

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

The normal operator.

normal_

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

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

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

The normal_ operator.

normalize

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

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

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

The normalize operator.

normalize_

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

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

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

The normalize_ operator.

numel

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

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

numel(input) -> Tensor

The numel operator.

numel_host

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

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

numel_host(input) -> Tensor

The numel_host operator.

one_hot

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

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

one_hot(indices, num_classes) -> Tensor

The one_hot operator.

ones

ones(*size: 'ShapeDim', dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

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

A one-filled tensor; the default dtype unless dtype says otherwise.

ones_like

ones_like(input: 'Tensor', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

ones_like(input, *, dtype=None, device=None) -> Tensor

A one-filled tensor of input's shape, dtype and device, each overridable by keyword.

outer

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

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

outer(input, other) -> Tensor

The outer operator.

pad

padpad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], mode: object = 'constant', value: clika_runtime._core.ops.ScalarOrTensor | None = None) -> clika_runtime._core.Tensor

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

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

The pad operator.

pairwise_distance

pairwise_distancepairwise_distance(x1: clika_runtime._core.Tensor, x2: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...), eps: float | None = None, keepdim: bool = False) -> clika_runtime._core.Tensor

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

pairwise_distance(x1, x2, p=2.0, eps=None, keepdim=False) -> Tensor

The pairwise_distance operator.

pdist

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

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

pdist(input, p=2.0) -> Tensor

The pdist operator.

permute

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

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

permute(input, dims) -> Tensor

The permute operator.

pixel_shuffle

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

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

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

The pixel_shuffle operator.

pixel_unshuffle

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

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

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

The pixel_unshuffle operator.

poisson

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

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

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

The poisson operator.

pow

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

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

pow(input, exponent) -> Tensor

The pow operator.

pow_

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

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

pow_(self, exponent) -> Tensor

The pow_ operator.

prelu

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

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

prelu(input, weight=None) -> Tensor

The prelu operator.

prelu_

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

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

prelu_(self, weight=None) -> Tensor

The prelu_ operator.

prod

prodprod(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: 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.

put

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

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.

put_

put_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: 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.

q_embedding

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

q_embedding(indices: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | 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.

qadd

qaddqadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = '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: object | None = 'identity') -> clika_runtime._core.QTensor

Overloaded function.

1. qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

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

The qadd operator.

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: object | None = '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.

qadd_

qadd_qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor

qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime.core.QTensor qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = '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: object | None = '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: object | None = 'identity') -> clika_runtime._core.QTensor

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

The qadd_ operator.

2. qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

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

The qadd_ operator.

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: object | None = '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.

qconcat

qconcatqconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int = 0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int = 0, *, activation: object | None = '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: object | None = 'identity') -> clika_runtime._core.QTensor

Overloaded function.

1. qconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int = 0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

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

The qconcat operator.

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: object | None = '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.

qconcat_

qconcat_qconcat_(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor

qconcat_(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out: clika_runtime._core.QTensor, *, activation: object | None = '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: object | None = '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: object | None = 'identity') -> clika_runtime._core.QTensor

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

The qconcat_ operator.

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: object | None = '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.

qconv

qconvqconv(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: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

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: object = 'constant', value: float | None = None, *, activation: object | None = '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: object, value: float | None, activation: object, 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: object = 'constant', value: float | None = None, *, activation: object | None = '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.

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: object, value: float | None, activation: object, 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.

qconv1d

qconv1dqconv1d(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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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: object, 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: object | None = 'identity') -> clika_runtime._core.Tensor

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

The qconv1d operator.

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: object, 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.

qconv1d_woq

qconv1d_woqqconv1d_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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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.

qconv2d

qconv2dqconv2d(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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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: object, 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: object | None = '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.

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: object, 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.

qconv2d_woq

qconv2d_woqqconv2d_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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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.

qconv3d

qconv3dqconv3d(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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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: object, 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: object | None = '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.

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: object, 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.

qconv3d_woq

qconv3d_woqqconv3d_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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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.

qconv_

qconv_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: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor

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: object = 'constant', value: float | None = None, *, activation: object | None = '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: object = 'constant', value: float | None = None, *, activation: object | None = '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: object = 'constant', value: float | None = None, *, activation: object | None = '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: object = 'constant', value: float | None = None, *, activation: object | None = '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.

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: object = 'constant', value: float | None = None, *, activation: object | None = '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.

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: object = 'constant', value: float | None = None, *, activation: object | None = '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.

qconv_transpose

qconv_transposeqconv_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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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: object, 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: object | None = '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.

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: object, 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.

qconv_transpose1d

qconv_transpose1dqconv_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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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: object, 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: object | None = '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.

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: object, 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.

qconv_transpose1d_woq

qconv_transpose1d_woqqconv_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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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.

qconv_transpose2d

qconv_transpose2dqconv_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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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: object, 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: object | None = '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.

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: object, 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.

qconv_transpose2d_woq

qconv_transpose2d_woqqconv_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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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.

qconv_transpose3d

qconv_transpose3dqconv_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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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: object, 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: object | None = '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.

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: object, 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.

qconv_transpose3d_woq

qconv_transpose3d_woqqconv_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: object | None = 'identity') -> clika_runtime._core.Tensor

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: object | None = '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.

qconv_transpose_

qconv_transpose_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: object | None = 'identity') -> clika_runtime._core.QTensor

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: object | None = '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: object | None = '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: object | None = '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: object | None = '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.

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: object | None = '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.

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: object | None = '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.

qconv_transpose_woq

qconv_transpose_woqqconv_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: object | None = 'identity', compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

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: object | None = 'identity', compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

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

The qconv_transpose_woq operator.

qconv_woq

qconv_woqqconv_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: object = 'constant', value: float | None = None, *, activation: object | None = 'identity', compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

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: object = 'constant', value: float | None = None, *, activation: object | None = 'identity', compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qconv_woq(input, weight, bias=None, stride=[], padding=[], dilation=[], groups=1, mode='constant', value=None, *, activation='identity', compute_mode='exact_fp') -> Tensor

The qconv_woq operator.

qdeform_conv

qdeform_convqdeform_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: object | None = '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 = 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: object | None = '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: object, 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: object | None = '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.

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: object, 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.

qdeform_conv_woq

qdeform_conv_woqqdeform_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: object | None = 'identity', compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

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: object | None = 'identity', compute_mode: object = 'exact_fp') -> 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='exact_fp') -> Tensor

The qdeform_conv_woq operator.

qdiv

qdivqdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = '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: object | None = 'identity') -> clika_runtime._core.QTensor

Overloaded function.

1. qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

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

The qdiv operator.

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: object | None = '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.

qdiv_

qdiv_qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor

qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime.core.QTensor qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = '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: object | None = '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: object | None = 'identity') -> clika_runtime._core.QTensor

qdiv_(input, other, out, *, activation='identity') -> QTensor

The qdiv_ operator.

2. qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qdiv_(input, other, out, *, activation='identity') -> Tensor

The qdiv_ operator.

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: object | None = '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.

qfast_gelu

qfast_geluqfast_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

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.

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.

qfast_gelu_

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

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.

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.

qgelu

qgeluqgelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

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.

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.

qgelu_

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

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

qgelu_(input, out) -> Tensor

The qgelu_ operator.

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.

qhardsigmoid

qhardsigmoidqhardsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qhardsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor qhardsigmoid(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. qhardsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qhardsigmoid(input) -> Tensor

The qhardsigmoid operator.

2. qhardsigmoid(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

qhardsigmoid(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The qhardsigmoid operator.

qhardsigmoid_

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

qhardsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qhardsigmoid(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qhardsigmoid(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. qhardsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qhardsigmoid_(input, out) -> QTensor

The qhardsigmoid_ operator.

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

qhardsigmoid_(input, out) -> Tensor

The qhardsigmoid_ operator.

3. qhardsigmoid_(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

qhardsigmoid_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The qhardsigmoid_ operator.

qhardswish

qhardswishqhardswish(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

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.

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.

qhardswish_

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

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

qhardswish_(input, out) -> Tensor

The qhardswish_ operator.

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.

qk_layer_norm

qk_layer_normqk_layer_norm(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, query_bias: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, key_bias: 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(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, query_bias: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, key_bias: 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(query, key=None, value=None, query_weight=None, query_bias=None, key_weight=None, key_bias=None, head_dim=0, eps=None) -> tuple[Tensor, Tensor, Tensor]

The qk_layer_norm operator.

qk_layer_norm_

qk_layer_norm_qk_layer_norm_(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, query_bias: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, key_bias: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> clika_runtime._core.Tensor

qk_layer_norm_(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, query_bias: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, key_bias: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> clika_runtime._core.Tensor

qk_layer_norm_(query, key=None, value=None, query_weight=None, query_bias=None, key_weight=None, key_bias=None, head_dim=0, eps=None) -> Tensor

The qk_layer_norm_ operator.

qk_rms_norm

qk_rms_normqk_rms_norm(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, key_weight: 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(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, key_weight: 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(query, key=None, value=None, query_weight=None, key_weight=None, head_dim=0, eps=None) -> tuple[Tensor, Tensor, Tensor]

The qk_rms_norm operator.

qk_rms_norm_

qk_rms_norm_qk_rms_norm_(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> clika_runtime._core.Tensor

qk_rms_norm_(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> clika_runtime._core.Tensor

qk_rms_norm_(query, key=None, value=None, query_weight=None, key_weight=None, head_dim=0, eps=None) -> Tensor

The qk_rms_norm_ operator.

qleaky_relu

qleaky_reluqleaky_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 = 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.

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.

qleaky_relu_

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

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.

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.

qlinear

qlinearqlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor

qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, activation: object, 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: object | None = None) -> clika_runtime._core.Tensor

qlinear(input, weight, bias=None, *, activation=None) -> Tensor

The qlinear operator.

2. qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, activation: object, 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.

qlinear_

qlinear_qlinear_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.QTensor

qlinear_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | 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: object | 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: object | None = None) -> clika_runtime._core.QTensor

qlinear_(input, weight, out, bias=None, *, activation=None) -> QTensor

The qlinear_ operator.

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

qlinear_(input, weight, out, bias=None, *, activation=None) -> Tensor

The qlinear_ operator.

qlinear_woq

qlinear_woqqlinear_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qlinear_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qlinear_woq(input, weight, bias=None, *, activation=None, compute_mode='exact_fp') -> Tensor

The qlinear_woq operator.

qlinear_woq_

qlinear_woq_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: object | None = None, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

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: object | None = None, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qlinear_woq_(input, weight, out, bias=None, *, activation=None, compute_mode='exact_fp') -> Tensor

The qlinear_woq_ operator.

qmatmul

qmatmulqmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | 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 = None, *, activation: object | 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: object, 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: object | 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.

2. qmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, activation: object, 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.

qmatmul_

qmatmul_qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | 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.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | 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: object | 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: object | 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: object | 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.

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: object | 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.

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: object | 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.

qmatmul_woq

qmatmul_woqqmatmul_woq(input: clika_runtime._core.Tensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qmatmul_woq(input: clika_runtime._core.Tensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qmatmul_woq(input, other, bias=None, *, activation=None, transpose_a=False, transpose_b=False, compute_mode='exact_fp') -> Tensor

The qmatmul_woq operator.

qmatmul_woq_

qmatmul_woq_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: object | None = None, transpose_a: bool = False, transpose_b: bool = False, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

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: object | None = None, transpose_a: bool = False, transpose_b: bool = False, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qmatmul_woq_(input, other, out, bias=None, *, activation=None, transpose_a=False, transpose_b=False, compute_mode='exact_fp') -> Tensor

The qmatmul_woq_ operator.

qmoe

qmoeqmoe(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: object | 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: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | 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 = 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: object | 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: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | 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: object, 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: object, swiglu_fusion: object, swiglu_alpha: float | None, swiglu_beta: float | None, swiglu_limit: float | None, gelu_mode: object, 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: object | 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: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | 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.

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: object, 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: object, swiglu_fusion: object, swiglu_alpha: float | None, swiglu_beta: float | None, swiglu_limit: float | None, gelu_mode: object, 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.

qmoe_woq

qmoe_woqqmoe_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: object | 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: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | None = None, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

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: object | 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: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | 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.

qmul

qmulqmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = '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: object | None = 'identity') -> clika_runtime._core.QTensor

Overloaded function.

1. qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qmul(input, other, *, activation='identity') -> Tensor

The qmul operator.

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: object | None = '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.

qmul_

qmul_qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor

qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime.core.QTensor qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = '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: object | None = '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: object | None = 'identity') -> clika_runtime._core.QTensor

qmul_(input, other, out, *, activation='identity') -> QTensor

The qmul_ operator.

2. qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qmul_(input, other, out, *, activation='identity') -> Tensor

The qmul_ operator.

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: object | None = '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.

qneg

qnegqneg(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qneg(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor qneg(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. qneg(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qneg(input) -> Tensor

The qneg operator.

2. qneg(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

qneg(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The qneg operator.

qneg_

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

qneg_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qneg(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qneg(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. qneg_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qneg_(input, out) -> QTensor

The qneg_ operator.

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

qneg_(input, out) -> Tensor

The qneg_ operator.

3. qneg_(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

qneg_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The qneg_ operator.

qquick_gelu

qquick_geluqquick_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

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.

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.

qquick_gelu_

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

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.

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.

qrelu

qreluqrelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

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.

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.

qrelu_

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

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

qrelu_(input, out) -> Tensor

The qrelu_ operator.

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.

qsigmoid

qsigmoidqsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

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.

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.

qsigmoid_

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

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

qsigmoid_(input, out) -> Tensor

The qsigmoid_ operator.

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.

qsilu

qsiluqsilu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

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.

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.

qsilu_

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

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

qsilu_(input, out) -> Tensor

The qsilu_ operator.

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.

qsub

qsubqsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = '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: object | None = 'identity') -> clika_runtime._core.QTensor

Overloaded function.

1. qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qsub(input, other, *, activation='identity') -> Tensor

The qsub operator.

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: object | None = '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.

qsub_

qsub_qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor

qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime.core.QTensor qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = '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: object | None = '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: object | None = 'identity') -> clika_runtime._core.QTensor

qsub_(input, other, out, *, activation='identity') -> QTensor

The qsub_ operator.

2. qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qsub_(input, other, out, *, activation='identity') -> Tensor

The qsub_ operator.

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: object | None = '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.

qtanh

qtanhqtanh(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

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.

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.

qtanh_

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

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

qtanh_(input, out) -> Tensor

The qtanh_ operator.

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.

quantile

quantilequantile(input: clika_runtime._core.Tensor, q: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, keepdim: bool = False, interpolation: object = 'linear') -> clika_runtime._core.Tensor

quantile(input: clika_runtime._core.Tensor, q: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, keepdim: bool = False, interpolation: object = 'linear') -> clika_runtime._core.Tensor

quantile(input, q, dim=None, keepdim=False, interpolation='linear') -> Tensor

The quantile operator.

quantize

quantize(input: 'Tensor', scale: 'ScaleLike', zero_point: 'ZeroPointLike' = None, quant_axis: 'int' = -1, *, out_dtype: 'DtypeLike' = None, block_size: 'int' = 0) -> 'QTensor'

quantize(input, scale, zero_point=None, quant_axis=-1, *, out_dtype=None, block_size=0) -> QTensor

Quantize input at scale, a number or a tensor. quantize(x, 0.02, out_dtype=clika_runtime.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_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.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.

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.

quantize_dequantize

quantize_dequantize(input: 'Tensor', scale: 'ScaleLike', zero_point: 'ZeroPointLike' = None, quant_axis: 'int' = -1, *, code_dtype: 'DtypeLike' = None, out_dtype: 'DtypeLike' = None, block_size: 'int' = 0) -> 'Tensor'

quantize_dequantize(input, scale, zero_point=None, quant_axis=-1, *, code_dtype=None, out_dtype=None, block_size=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_schemequantize_to_scheme(input: clika_runtime._core.Tensor, scheme: str, scale: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.QTensor

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.

quantized_view

quantized_viewquantized_view(tensor: clika_runtime._core.Tensor) -> clika_runtime._core.QTensor

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_geluquick_gelu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

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

quick_gelu(input) -> Tensor

The quick_gelu operator.

rad2deg

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

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

rad2deg(input) -> Tensor

The rad2deg operator.

rad2deg_

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

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

rad2deg_(self) -> Tensor

The rad2deg_ operator.

rand

rand(*size: 'ShapeDim', dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

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

Uniform samples in [0, 1); the default dtype unless dtype says otherwise.

rand_like

rand_like(input: 'Tensor', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

rand_like(input, *, dtype=None, device=None) -> Tensor

Uniform samples in [0, 1) of input's shape, dtype and device, each overridable by keyword.

randint

randint(*args: 'int | Sequence[int]', size: 'Sequence[int] | None' = None, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

randint(low=0, high, size, *, dtype=None, device=None) -> Tensor

Uniform integers in [low, high) of the given shape: randint(high, size) or randint(low, high, size); size may also be given by keyword. int64 unless dtype says otherwise.

randint_like

randint_like(input: 'Tensor', low: 'int', high: 'int | None' = None, *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

randint_like(input, low=0, high, *, dtype=None, device=None) -> Tensor

Uniform integers in [low, high) of input's shape, dtype and device (randint_like(input, high) counts from zero); dtype and device overridable by keyword.

randn

randn(*size: 'ShapeDim', dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

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

Standard-normal samples; the default dtype unless dtype says otherwise.

randn_like

randn_like(input: 'Tensor', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

randn_like(input, *, dtype=None, device=None) -> Tensor

Standard-normal samples of input's shape, dtype and device, each overridable by keyword.

random_

random_random_(self: clika_runtime._core.Tensor, low: int | None = None, high: int | None = None, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

random_(self: clika_runtime._core.Tensor, low: int | None = None, high: int | None = None, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

random_(self, low=None, high=None, *, device=None) -> Tensor

The random_ operator.

randperm

randpermrandperm(n: clika_runtime._core.ops.ScalarOrTensor, *, dtype: clika_runtime._core.DataType = DataType.Int64, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

randperm(n: clika_runtime._core.ops.ScalarOrTensor, *, dtype: clika_runtime._core.DataType = DataType.Int64, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

randperm(n, *, dtype=Int64, device=None) -> Tensor

The randperm operator.

reciprocal

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

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

reciprocal(input) -> Tensor

The reciprocal operator.

reciprocal_

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

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

reciprocal_(self) -> Tensor

The reciprocal_ operator.

reflect_pad

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

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

reflect_pad(input, pad) -> Tensor

The reflect_pad operator.

reglu

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

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

reglu(input) -> Tensor

The reglu operator.

relu

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

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

relu(input) -> Tensor

The relu operator.

relu6

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

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

relu6(input) -> Tensor

The relu6 operator.

relu6_

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

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

relu6_(self) -> Tensor

The relu6_ operator.

relu_

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

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

relu_(self) -> Tensor

The relu_ operator.

remainder

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

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

remainder(input, other) -> Tensor

The remainder operator.

remainder_

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

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

remainder_(self, other) -> Tensor

The remainder_ operator.

renorm

renormrenorm(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar, dim: int, maxnorm: clika_runtime._core.ops.Scalar, eps: float | None = None) -> clika_runtime._core.Tensor

renorm(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar, dim: int, maxnorm: clika_runtime._core.ops.Scalar, eps: float | None = None) -> clika_runtime._core.Tensor

renorm(input, p, dim, maxnorm, eps=None) -> Tensor

The renorm operator.

renorm_

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

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

renorm_(self, p, dim, maxnorm, eps=None) -> Tensor

The renorm_ operator.

repeat

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

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

repeat(input, sizes) -> Tensor

The repeat operator.

repeat_interleave

repeat_interleaverepeat_interleave(input: clika_runtime._core.Tensor, repeats: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, output_size: int | None = None) -> clika_runtime._core.Tensor

repeat_interleave(input: clika_runtime._core.Tensor, repeats: clika_runtime._core.ops.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.

replicate_pad

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

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

replicate_pad(input, pad) -> Tensor

The replicate_pad operator.

requantize

requantizerequantize(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: 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.

requantize_

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

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.

resample

resampleresample(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: 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.

reset_peak_memory_stats

reset_peak_memory_statsreset_peak_memory_stats(device: object) -> None

reset_peak_memory_stats(device: object) -> None

reset_peak_memory_stats(device) -> None

Restart the device's peak memory marks (peak_active_bytes, peak_requested_bytes, peak_reserved_bytes) from the present figures; nothing is allocated, freed or waited on. The measuring idiom: reset, run one step, read memory_stats(device).peak_active_bytes, or peak_requested_bytes for the bytes the step asked for.

reshape

reshapereshape(input: clika_runtime._core.Tensor, shape: collections.abc.Sequence[clika_runtime._core.ops.IndexBound]) -> clika_runtime._core.Tensor

reshape(input: clika_runtime._core.Tensor, shape: collections.abc.Sequence[clika_runtime._core.ops.IndexBound]) -> clika_runtime._core.Tensor

reshape(input, shape) -> Tensor

The reshape operator.

reshape_as

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

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.

rfft

rfftrfft(input: clika_runtime._core.Tensor, n_fft: int | None = None, normalized: bool = False) -> clika_runtime._core.Tensor

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.

rms_norm

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

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

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

The rms_norm operator.

roll

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

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.

rot90

rot90rot90(input: clika_runtime._core.Tensor, k: int = 1, dims: collections.abc.Sequence[int] = [0, 1]) -> clika_runtime._core.Tensor

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.

rotary_embedding

rotary_embeddingrotary_embedding(input: 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: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | 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(input: 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: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | 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(input, 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.

rotary_embedding_qk

rotary_embedding_qkrotary_embedding_qk(query: clika_runtime._core.Tensor, key: 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: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | 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(query: clika_runtime._core.Tensor, key: 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: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | 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(query, key, 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.

rotary_embedding_qk_varlen

rotary_embedding_qk_varlenrotary_embedding_qk_varlen(query: clika_runtime._core.Tensor, key: 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: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | 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(query: clika_runtime._core.Tensor, key: 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: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | 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(query, key, 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.

rotary_embedding_varlen

rotary_embedding_varlenrotary_embedding_varlen(input: 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: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | 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(input: 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: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | 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(input, 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.

round

roundround(input: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor

round(input: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor

round(input, decimals=0) -> Tensor

The round operator.

round_

round_round_(self: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor

round_(self: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor

round_(self, decimals=0) -> Tensor

The round_ operator.

rsqrt

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

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

rsqrt(input) -> Tensor

The rsqrt operator.

rsqrt_

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

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

rsqrt_(self) -> Tensor

The rsqrt_ operator.

save

save(obj: 'Tensor | Mapping[str, Tensor] | Any', path: 'PathLike', *, metadata: 'Metadata | None' = None) -> 'None'

save(obj, path, *, metadata=None) -> None

Write obj to a safetensors file at path: a :class:~clika_runtime.Tensor, a dict of tensors (a state_dict, kept in its own order), or any pytree of tensors, flattened by key path with its structure in the file's header metadata. metadata adds str -> str pairs to the header (a dict, or (key, value) pairs), written in the given order after the structure entries. Pending work on every tensor settles first.

Raises: TypeError: when a leaf is not a tensor, a dict key is not a str, or a metadata pair is not two strings. ValueError: when a dict uses the reserved key .tensor, or a metadata key starts with clika..

scaled_dot_product_attention

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

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

scaled_dot_product_attention(query, key, value, attn_mask=None, is_causal=False, q_scale=None, k_scale=None, v_scale=None) -> Tensor

The scaled_dot_product_attention operator.

scaled_dot_product_attention_varlen

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

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

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

The scaled_dot_product_attention_varlen operator.

scatter

scatterscatter(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

scatter(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

scatter(input, dim, index, src) -> Tensor

The scatter operator.

scatter_

scatter_scatter_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

scatter_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

scatter_(self, dim, index, src) -> Tensor

The scatter_ operator.

scatter_add

scatter_addscatter_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: 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.

scatter_add_

scatter_add_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: 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.

scatter_reduce

scatter_reducescatter_reduce(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: object, include_self: bool = True, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_reduce(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: object, 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.

scatter_reduce_

scatter_reduce_scatter_reduce_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: object, include_self: bool = True, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_reduce_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: object, 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.

searchsorted

searchsortedsearchsorted(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: 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.

select

selectselect(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.ops.IndexBound) -> clika_runtime._core.Tensor

select(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.ops.IndexBound) -> clika_runtime._core.Tensor

select(input, dim, index) -> Tensor

The select operator.

selu

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

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

selu(input) -> Tensor

The selu operator.

selu_

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

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

selu_(self) -> Tensor

The selu_ operator.

set_default_dtype

set_default_dtype(dtype: 'DtypeLike') -> 'None'

set_default_dtype(dtype) -> None

Set the default floating-point dtype (clika_runtime.float32, "bfloat16", ...). Only a floating-point dtype is accepted.

set_printoptions

set_printoptions(precision: 'int | None' = None, threshold: 'int | None' = None, edgeitems: 'int | None' = None, linewidth: 'int | None' = None, sci_mode: 'bool | None' = None) -> 'None'

set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, sci_mode=None) -> None

Set how tensors print. precision digits after the point (4 at start), threshold the element count past which the printout abbreviates with ... (1000), edgeitems the entries kept at each end of an abbreviated dim (3), linewidth the characters per line (80), sci_mode forces (True) or forbids (False) scientific notation; None lets the values decide. An argument left None keeps its value.

sgn

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

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

sgn(input) -> Tensor

The sgn operator.

sgn_

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

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

sgn_(self) -> Tensor

The sgn_ operator.

shape

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

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.

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.

shape_host

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

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.

2. shape_host(input: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor

shape_host(input, dim) -> Tensor

The shape_host operator.

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.

sigmoid

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

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

sigmoid(input) -> Tensor

The sigmoid operator.

sigmoid_

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

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

sigmoid_(self) -> Tensor

The sigmoid_ operator.

sign

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

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

sign(input) -> Tensor

The sign operator.

sign_

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

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

sign_(self) -> Tensor

The sign_ operator.

silu

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

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

silu(input) -> Tensor

The silu operator.

silu_

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

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

silu_(self) -> Tensor

The silu_ operator.

sin

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

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

sin(input) -> Tensor

The sin operator.

sin_

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

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

sin_(self) -> Tensor

The sin_ operator.

sinc

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

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

sinc(input) -> Tensor

The sinc operator.

sinc_

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

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

sinc_(self) -> Tensor

The sinc_ operator.

sinh

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

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

sinh(input) -> Tensor

The sinh operator.

sinh_

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

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

sinh_(self) -> Tensor

The sinh_ operator.

slice

sliceslice(input: clika_runtime._core.Tensor, dim: int, start: clika_runtime._core.ops.IndexBound = IndexBound(...), end: clika_runtime._core.ops.IndexBound = IndexBound(...), step: clika_runtime._core.ops.IndexBound = IndexBound(...)) -> clika_runtime._core.Tensor

slice(input: clika_runtime._core.Tensor, dim: int, start: clika_runtime._core.ops.IndexBound = IndexBound(...), end: clika_runtime._core.ops.IndexBound = IndexBound(...), step: clika_runtime._core.ops.IndexBound = IndexBound(...)) -> clika_runtime._core.Tensor slice(input: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int], start: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = [], end: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = [], step: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = []) -> clika_runtime._core.Tensor

Overloaded function.

1. slice(input: clika_runtime._core.Tensor, dim: int, start: clika_runtime._core.ops.IndexBound = IndexBound(...), end: clika_runtime._core.ops.IndexBound = IndexBound(...), step: clika_runtime._core.ops.IndexBound = IndexBound(...)) -> clika_runtime._core.Tensor

slice(input, dim, start=None, end=None, step=1) -> Tensor

The slice operator.

2. slice(input: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int], start: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = [], end: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = [], step: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = []) -> clika_runtime._core.Tensor

slice(input, dim, start=[], end=[], step=[]) -> Tensor

The slice operator.

smooth_l1_loss

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

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

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

The smooth_l1_loss operator.

snake

snakesnake(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: 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.

snake_

snake_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: 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.

softcap_logits

softcap_logitssoftcap_logits(input: clika_runtime._core.Tensor, cap: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

softcap_logits(input: clika_runtime._core.Tensor, cap: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

softcap_logits(input, cap) -> Tensor

The softcap_logits operator.

softcap_logits_

softcap_logits_softcap_logits_(self: clika_runtime._core.Tensor, cap: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

softcap_logits_(self: clika_runtime._core.Tensor, cap: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

softcap_logits_(self, cap) -> Tensor

The softcap_logits_ operator.

softmax

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

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

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

The softmax operator.

softmax_

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

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

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

The softmax_ operator.

softmin

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

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

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

The softmin operator.

softmin_

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

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

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

The softmin_ operator.

softplus

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

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

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

The softplus operator.

softplus_

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

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

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

The softplus_ operator.

softshrink

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

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

softshrink(input, lambd=0.5) -> Tensor

The softshrink operator.

softshrink_

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

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

softshrink_(self, lambd=0.5) -> Tensor

The softshrink_ operator.

softsign

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

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

softsign(input) -> Tensor

The softsign operator.

softsign_

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

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

softsign_(self) -> Tensor

The softsign_ operator.

sort

sortsort(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: 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.

split_by_size

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

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.

split_with_sizes

split_with_sizessplit_with_sizes(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], dim: int = 0) -> list[clika_runtime._core.Tensor]

split_with_sizes(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], dim: int = 0) -> list[clika_runtime._core.Tensor]

split_with_sizes(input, sizes, dim=0) -> list[Tensor]

The split_with_sizes operator.

sqrt

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

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

sqrt(input) -> Tensor

The sqrt operator.

sqrt_

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

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

sqrt_(self) -> Tensor

The sqrt_ operator.

square

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

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

square(input) -> Tensor

The square operator.

square_

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

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

square_(self) -> Tensor

The square_ operator.

squeeze

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

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

squeeze(input, dim=[]) -> Tensor

The squeeze operator.

squeeze_

squeeze_squeeze_(self: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor

squeeze_(self: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor

squeeze_(self, dim=[]) -> Tensor

The squeeze_ operator.

ssd_update

ssd_updatessd_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, gate: 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: 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, gate: 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, gate, state, seq_lens=None, slot_ids=None, dt_softplus=False) -> Tensor

The ssd_update operator.

stack

stackstack(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], dim: int = 0) -> clika_runtime._core.Tensor

stack(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], dim: int = 0) -> clika_runtime._core.Tensor

stack(tensors, dim=0) -> Tensor

The stack operator.

std

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

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.

stft

stftstft(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: object = 'reflect', normalized: bool = False, onesided: bool = True) -> clika_runtime._core.Tensor

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: object = '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.

stream

stream(stream_or_device: 'Stream | Device | str') -> '_PlacementContext'

stream(stream_or_device) -> a placement region

Run the region on a stream: operations inside issue onto it in order and land their outputs there. A :class:Device (or a device string) stands for that device's default stream at each operation.

sub

subsub(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

sub(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor sub(input: clika_runtime._core.ops.Scalar, other: clika_runtime._core.Tensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

sub(input, other, alpha=1.0, *, activation='identity') -> Tensor

The sub operator.

sub_

sub_sub_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

sub_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

sub_(self, other, alpha=1.0, *, activation='identity') -> Tensor

The sub_ operator.

sum

sumsum(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: 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.

swiglu

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

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

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

The swiglu operator.

synchronize

synchronize(target: 'Stream | Device | str | None' = None) -> 'None'

synchronize(target=None) -> None

Block until the targeted 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 the cpu. A :class:Device (or device string) drains that device: every lane of that device is waited on, so the device's queued work is complete on return, and no other device's lane is waited on. A :class:Stream synchronizes itself. Prefer this targeted form over ops.synchronize_all (which stalls every stream in the process).

synchronize_all

synchronize_allsynchronize_all() -> None

synchronize_all() -> None

synchronize_all() -> None

The synchronize_all operator.

synchronous

synchronous() -> '_SynchronousScope'

synchronous() -> an execution-mode region

Every operation inside completes before it returns: the calling thread's lane is settled on enter, then the region runs one operation at a time (deterministic stepping and debugging; pipelining is given up). Nests inside :func:device / :func:stream regions.

take

taketake(self: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

take(self: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

take(self, index) -> Tensor

The take operator.

take_along_dim

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

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.

tan

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

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

tan(input) -> Tensor

The tan operator.

tan_

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

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

tan_(self) -> Tensor

The tan_ operator.

tanh

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

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

tanh(input) -> Tensor

The tanh operator.

tanh_

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

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

tanh_(self) -> Tensor

The tanh_ operator.

tensor

tensor(data: 'object', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

tensor(data, *, dtype=None, device=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 the default dtype (:func:get_default_dtype); ints at int64; bools at bool. Python data packs its own payload, so no array library is needed; an array enters through the buffer protocol or DLPack at its own dtype. When dtype names a type a payload cannot spell directly (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). Inside a meta-init region the result is storage-free.

tensordot

tensordottensordot(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: 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.

threshold

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

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

threshold(input, threshold, value) -> Tensor

The threshold operator.

threshold_

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

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

threshold_(self, threshold, value) -> Tensor

The threshold_ operator.

tile

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

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

tile(input, dims) -> Tensor

The tile operator.

to

toto(src: clika_runtime._core.Tensor, *, target: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

to(src: clika_runtime._core.Tensor, *, target: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor to(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], *, target: clika_runtime._core.ops.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._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

to(src, *, target=None) -> Tensor

The to operator.

2. to(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], *, target: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> list[clika_runtime._core.Tensor]

to(tensors, *, target=None) -> list[Tensor]

The to operator.

3. to(src: clika_runtime._core.Tensor, device_str: str) -> clika_runtime._core.Tensor

to(src, device_str) -> Tensor

The to operator.

topk

topktopk(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: 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.

trace

trace(fn: 'Callable[..., object]', inputs: 'object' = None, *, example_inputs: 'object' = None, signature: 'Sequence[TensorSpec] | None' = None, input_names: 'Sequence[str]' = (), output_names: 'Sequence[str]' = (), graph_name: 'str' = 'traced_model') -> 'TracedGraph'

trace(fn, example_inputs, *, input_names=(), output_names=(), graph_name="traced_model") -> TracedGraph

Record fn once into a graph. Two roads name the inputs: trace(fn, example_inputs=...) derives the graph inputs from example tensors (their shapes and dtypes matter, their values are never read), and trace(fn, signature) declares them as :class:TensorSpec values (a -1 dim is dynamic). The second positional argument is read as a signature when it is a sequence of TensorSpec values and as the example inputs otherwise.

A module is called as module(*example_inputs); a plain callable is called with example_inputs as its one argument (a list of tensors for a list-in/list-out function, or any pytree). Tensor leaves feed the graph in flattening order, static leaves are baked in, and the result's tensor leaves are the graph outputs. Reading a tensor's value inside fn during the recording raises. input_names and output_names name the flattened tensors in order (defaults: input_<i> and output_<i>; a dict key names its tensor).

The result carries the graph as .graph and answers the graph's own methods directly (run, input_names, output_names, nodes). The graph comes back as recorded: optimize() it when wanted, to() a device, device string or stream to choose where it runs, then finalize() it, and it runs.

tracing

tracing() -> '_TracingScope'

tracing() -> an execution-mode region

Operations inside record into a lazy graph and return unevaluated handles; nothing runs until a value is read through clika_runtime.eval (a plain read of a traced value raises). :func:eager re-enables immediate execution for a nested region.

transpose

transposetranspose(input: clika_runtime._core.Tensor, dim0: int, dim1: int) -> clika_runtime._core.Tensor

transpose(input: clika_runtime._core.Tensor, dim0: int, dim1: int) -> clika_runtime._core.Tensor

transpose(input, dim0, dim1) -> Tensor

The transpose operator.

tril

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

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

tril(input, diagonal=0) -> Tensor

The tril operator.

tril_

tril_tril_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

tril_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

tril_(self, diagonal=0) -> Tensor

The tril_ operator.

triu

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

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

triu(input, diagonal=0) -> Tensor

The triu operator.

triu_

triu_triu_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

triu_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

triu_(self, diagonal=0) -> Tensor

The triu_ operator.

trunc

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

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

trunc(input) -> Tensor

The trunc operator.

trunc_

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

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

trunc_(self) -> Tensor

The trunc_ operator.

unflatten

unflattenunflatten(input: clika_runtime._core.Tensor, dim: int, sizes: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor

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.

unfold

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

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

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

The unfold operator.

uniform_

uniform_uniform_(self: clika_runtime._core.Tensor, low: float = 0.0, high: float = 1.0, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

uniform_(self: clika_runtime._core.Tensor, low: float = 0.0, high: float = 1.0, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

uniform_(self, low=0.0, high=1.0, *, device=None) -> Tensor

The uniform_ operator.

unique

uniqueunique(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: 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.

unique_consecutive

unique_consecutiveunique_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: 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.

unsqueeze

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

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

unsqueeze(input, dim) -> Tensor

The unsqueeze operator.

unsqueeze_

unsqueeze_unsqueeze_(self: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor

unsqueeze_(self: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor

unsqueeze_(self, dim) -> Tensor

The unsqueeze_ operator.

upsample_bicubic2d

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

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

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

The upsample_bicubic2d operator.

upsample_bilinear2d

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

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

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

The upsample_bilinear2d operator.

upsample_linear1d

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

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

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

The upsample_linear1d operator.

upsample_nearest1d

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

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

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

The upsample_nearest1d operator.

upsample_nearest2d

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

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

upsample_nearest2d(input, sizes=[], scale_factors=[]) -> Tensor

The upsample_nearest2d operator.

upsample_nearest3d

upsample_nearest3dupsample_nearest3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor

upsample_nearest3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor

upsample_nearest3d(input, sizes=[], scale_factors=[]) -> Tensor

The upsample_nearest3d operator.

upsample_trilinear3d

upsample_trilinear3dupsample_trilinear3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor

upsample_trilinear3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor

upsample_trilinear3d(input, sizes=[], scale_factors=[], align_corners=False) -> Tensor

The upsample_trilinear3d operator.

validate_rotary_dim

validate_rotary_dimvalidate_rotary_dim(rotary_dim: int, head_dim: int = -1) -> None

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.

var

varvar(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], correction: int = 1, keepdim: bool = False) -> clika_runtime._core.Tensor

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.

version

versionversion() -> str

version() -> str

The ClikaRT runtime version string (e.g. "0.1.0").

where

wherewhere(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, 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.

2. where(condition: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

where(condition) -> Tensor

The where operator.

xlog1py

xlog1pyxlog1py(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

xlog1py(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

xlog1py(input, other) -> Tensor

The xlog1py operator.

xlogy

xlogyxlogy(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

xlogy(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

xlogy(input, other) -> Tensor

The xlogy operator.

xlogy_

xlogy_xlogy_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

xlogy_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

xlogy_(self, other) -> Tensor

The xlogy_ operator.

zero_

zero_zero_(self: clika_runtime._core.Tensor, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

zero_(self: clika_runtime._core.Tensor, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

zero_(self, *, device=None) -> Tensor

The zero_ operator.

zeros

zeros(*size: 'ShapeDim', dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

zeros(*size, dtype=None, device=None) -> Tensor

A zero-filled tensor; the default dtype unless dtype says otherwise.

zeros_like

zeros_like(input: 'Tensor', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'

zeros_like(input, *, dtype=None, device=None) -> Tensor

A zero-filled tensor of input's shape, dtype and device, each overridable by keyword.