clika_runtime.ops functions

abs

abs(*args, **kwargs)

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

abs(input) -> Tensor

The abs operator.

abs_

abs_(*args, **kwargs)

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

abs_(self) -> Tensor

The abs_ operator.

acos

acos(*args, **kwargs)

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

acos(input) -> Tensor

The acos operator.

acos_

acos_(*args, **kwargs)

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

acos_(self) -> Tensor

The acos_ operator.

acosh

acosh(*args, **kwargs)

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

acosh(input) -> Tensor

The acosh operator.

acosh_

acosh_(*args, **kwargs)

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

acosh_(self) -> Tensor

The acosh_ operator.

adaptive_avg_pool

adaptive_avg_pool(*args, **kwargs)

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

adaptive_avg_pool(input, output_size) -> Tensor

The adaptive_avg_pool operator.

adaptive_avg_pool1d

adaptive_avg_pool1d(*args, **kwargs)

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

adaptive_avg_pool1d(input, output_size) -> Tensor

The adaptive_avg_pool1d operator.

adaptive_avg_pool2d

adaptive_avg_pool2d(*args, **kwargs)

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

adaptive_avg_pool2d(input, output_size) -> Tensor

The adaptive_avg_pool2d operator.

adaptive_avg_pool3d

adaptive_avg_pool3d(*args, **kwargs)

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

adaptive_avg_pool3d(input, output_size) -> Tensor

The adaptive_avg_pool3d operator.

adaptive_max_pool

adaptive_max_pool(*args, **kwargs)

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

adaptive_max_pool(input, output_size) -> Tensor

The adaptive_max_pool operator.

adaptive_max_pool1d

adaptive_max_pool1d(*args, **kwargs)

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

adaptive_max_pool1d(input, output_size) -> Tensor

The adaptive_max_pool1d operator.

adaptive_max_pool2d

adaptive_max_pool2d(*args, **kwargs)

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

adaptive_max_pool2d(input, output_size) -> Tensor

The adaptive_max_pool2d operator.

adaptive_max_pool3d

adaptive_max_pool3d(*args, **kwargs)

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

adaptive_max_pool3d(input, output_size) -> Tensor

The adaptive_max_pool3d operator.

add

add(*args, **kwargs)

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_(*args, **kwargs)

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_norm(*args, **kwargs)

add_layer_norm(input: clika_runtime._core.Tensor, residual: clika_runtime._core.Tensor | None = None, post_residual: clika_runtime._core.Tensor | None = None, normalized_shape: collections.abc.Sequence[int] = [], skip_bias: clika_runtime._core.Tensor | None = None, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: 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_norm(*args, **kwargs)

add_rms_norm(input: clika_runtime._core.Tensor, residual: clika_runtime._core.Tensor | None = None, residual2: clika_runtime._core.Tensor | None = None, post_residual: clika_runtime._core.Tensor | None = None, normalized_shape: collections.abc.Sequence[int] = [], skip_bias: clika_runtime._core.Tensor | None = None, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: 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

all(*args, **kwargs)

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

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

The all operator.

allclose

allclose(*args, **kwargs)

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

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

The allclose operator.

amax

amax(*args, **kwargs)

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

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

The amax operator.

amin

amin(*args, **kwargs)

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

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

The amin operator.

aminmax

aminmax(*args, **kwargs)

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

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

The aminmax operator.

any

any(*args, **kwargs)

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

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

The any operator.

arange

arange(*args, **kwargs)

arange(start: clika_runtime._core.ops.ScalarOrTensor, end: clika_runtime._core.ops.ScalarOrTensor, step: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), *, dtype: clika_runtime._core.DataType = DataType.Int64, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

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

The arange operator.

argmax

argmax(*args, **kwargs)

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

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

The argmax operator.

argmin

argmin(*args, **kwargs)

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

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

The argmin operator.

argsort

argsort(*args, **kwargs)

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

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

The argsort operator.

asin

asin(*args, **kwargs)

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

asin(input) -> Tensor

The asin operator.

asin_

asin_(*args, **kwargs)

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

asin_(self) -> Tensor

The asin_ operator.

asinh

asinh(*args, **kwargs)

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

asinh(input) -> Tensor

The asinh operator.

asinh_

asinh_(*args, **kwargs)

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

asinh_(self) -> Tensor

The asinh_ operator.

atan

atan(*args, **kwargs)

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

atan(input) -> Tensor

The atan operator.

atan2

atan2(*args, **kwargs)

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

atan2(input, other) -> Tensor

The atan2 operator.

atan2_

atan2_(*args, **kwargs)

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

atan2_(self, other) -> Tensor

The atan2_ operator.

atan_

atan_(*args, **kwargs)

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

atan_(self) -> Tensor

The atan_ operator.

atanh

atanh(*args, **kwargs)

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

atanh(input) -> Tensor

The atanh operator.

atanh_

atanh_(*args, **kwargs)

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

atanh_(self) -> Tensor

The atanh_ operator.

atleast_1d

atleast_1d(*args, **kwargs)

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

atleast_1d(input) -> Tensor

The atleast_1d operator.

atleast_2d

atleast_2d(*args, **kwargs)

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

atleast_2d(input) -> Tensor

The atleast_2d operator.

atleast_3d

atleast_3d(*args, **kwargs)

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

atleast_3d(input) -> Tensor

The atleast_3d operator.

attention

attention(*args, **kwargs)

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

The attention operator.

attention_over_cache

attention_over_cache(*args, **kwargs)

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

The attention_over_cache operator.

attention_varlen

attention_varlen(*args, **kwargs)

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

The attention_varlen operator.

avg_pool

avg_pool(*args, **kwargs)

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

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

The avg_pool operator.

avg_pool1d

avg_pool1d(*args, **kwargs)

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

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

The avg_pool1d operator.

avg_pool2d

avg_pool2d(*args, **kwargs)

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

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

The avg_pool2d operator.

avg_pool3d

avg_pool3d(*args, **kwargs)

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

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

The avg_pool3d operator.

batch_norm

batch_norm(*args, **kwargs)

batch_norm(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, running_mean: clika_runtime._core.Tensor | None = None, running_var: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: 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

bernoulli(*args, **kwargs)

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_(*args, **kwargs)

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_entropy(*args, **kwargs)

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_logits(*args, **kwargs)

binary_cross_entropy_with_logits(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, reduction: 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

bincount(*args, **kwargs)

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

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

The bincount operator.

bitwise_and

bitwise_and(*args, **kwargs)

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_(*args, **kwargs)

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_shift(*args, **kwargs)

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_(*args, **kwargs)

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_not(*args, **kwargs)

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

bitwise_not(input) -> Tensor

The bitwise_not operator.

bitwise_not_

bitwise_not_(*args, **kwargs)

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

bitwise_not_(self) -> Tensor

The bitwise_not_ operator.

bitwise_or

bitwise_or(*args, **kwargs)

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_(*args, **kwargs)

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_shift(*args, **kwargs)

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_(*args, **kwargs)

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_xor(*args, **kwargs)

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_(*args, **kwargs)

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

bmm(*args, **kwargs)

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_tensors(*args, **kwargs)

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

broadcast_tensors(tensors) -> list[Tensor]

The broadcast_tensors operator.

broadcast_to

broadcast_to(*args, **kwargs)

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

bucketize(*args, **kwargs)

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

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

The bucketize operator.

cast

cast(*args, **kwargs)

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

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

The cast operator.

cast_like

cast_like(*args, **kwargs)

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

cast_like(input, reference) -> Tensor

The cast_like operator.

causal_conv_update

causal_conv_update(*args, **kwargs)

causal_conv_update(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None, state: clika_runtime._core.Tensor, seq_lens: clika_runtime._core.Tensor | None = None, slot_ids: clika_runtime._core.Tensor | None = None, *, activation: 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

cdist(*args, **kwargs)

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

ceil(*args, **kwargs)

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

ceil(input) -> Tensor

The ceil operator.

ceil_

ceil_(*args, **kwargs)

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

ceil_(self) -> Tensor

The ceil_ operator.

celu

celu(*args, **kwargs)

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

celu(input, alpha=1.0) -> Tensor

The celu operator.

celu_

celu_(*args, **kwargs)

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

celu_(self, alpha=1.0) -> Tensor

The celu_ operator.

chunk

chunk(*args, **kwargs)

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

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

The chunk operator.

circular_pad

circular_pad(*args, **kwargs)

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

clamp(*args, **kwargs)

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_(*args, **kwargs)

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_max(*args, **kwargs)

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_(*args, **kwargs)

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_min(*args, **kwargs)

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_(*args, **kwargs)

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

clone(*args, **kwargs)

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

clone(src) -> Tensor

The clone operator.

concat

concat(*args, **kwargs)

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_pad(*args, **kwargs)

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

contiguous(*args, **kwargs)

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

contiguous(input, force_copy=False) -> Tensor

The contiguous operator.

conv

conv(*args, **kwargs)

conv(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, mode: 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

conv1d(*args, **kwargs)

conv1d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: 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

conv2d(*args, **kwargs)

conv2d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: 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

conv3d(*args, **kwargs)

conv3d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: 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_transpose(*args, **kwargs)

conv_transpose(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], groups: int, dilation: collections.abc.Sequence[int], *, activation: 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_transpose1d(*args, **kwargs)

conv_transpose1d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0, 0], output_padding: collections.abc.Sequence[int] = [0], groups: int = 1, dilation: collections.abc.Sequence[int] = [1], *, activation: 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_transpose2d(*args, **kwargs)

conv_transpose2d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0], groups: int = 1, dilation: collections.abc.Sequence[int] = [1, 1], *, activation: 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_transpose3d(*args, **kwargs)

conv_transpose3d(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0, 0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0, 0], groups: int = 1, dilation: collections.abc.Sequence[int] = [1, 1, 1], *, activation: 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

copy(*args, **kwargs)

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_(*args, **kwargs)

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_into(*args, **kwargs)

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_cpu(*args, **kwargs)

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

copy_to_cpu(src) -> Tensor

The copy_to_cpu operator.

copysign

copysign(*args, **kwargs)

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_(*args, **kwargs)

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

copysign_(self, other) -> Tensor

The copysign_ operator.

cos

cos(*args, **kwargs)

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

cos(input) -> Tensor

The cos operator.

cos_

cos_(*args, **kwargs)

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

cos_(self) -> Tensor

The cos_ operator.

cosh

cosh(*args, **kwargs)

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

cosh(input) -> Tensor

The cosh operator.

cosh_

cosh_(*args, **kwargs)

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

cosh_(self) -> Tensor

The cosh_ operator.

cosine_similarity

cosine_similarity(*args, **kwargs)

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_nonzero(*args, **kwargs)

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

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

The count_nonzero operator.

cross

cross(*args, **kwargs)

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

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

The cross operator.

cross_entropy

cross_entropy(*args, **kwargs)

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

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

The cross_entropy operator.

cummax

cummax(*args, **kwargs)

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

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

The cummax operator.

cummin

cummin(*args, **kwargs)

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

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

The cummin operator.

cumprod

cumprod(*args, **kwargs)

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

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

The cumprod operator.

cumprod_

cumprod_(*args, **kwargs)

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

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

The cumprod_ operator.

cumsum

cumsum(*args, **kwargs)

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

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

The cumsum operator.

cumsum_

cumsum_(*args, **kwargs)

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

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

The cumsum_ operator.

deform_conv

deform_conv(*args, **kwargs)

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

deg2rad(*args, **kwargs)

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

deg2rad(input) -> Tensor

The deg2rad operator.

deg2rad_

deg2rad_(*args, **kwargs)

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

deg2rad_(self) -> Tensor

The deg2rad_ operator.

dequantize

dequantize(*args, **kwargs)

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

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

The dequantize operator.

dequantize_

dequantize_(*args, **kwargs)

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

dequantize_(input, out) -> Tensor

The dequantize_ operator.

diag

diag(*args, **kwargs)

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

diag(input, diagonal=0) -> Tensor

The diag operator.

diag_embed

diag_embed(*args, **kwargs)

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

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

The diag_embed operator.

diagonal

diagonal(*args, **kwargs)

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

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

The diagonal operator.

diff

diff(*args, **kwargs)

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

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

The diff operator.

div

div(*args, **kwargs)

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_(*args, **kwargs)

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

dot(*args, **kwargs)

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

dot(input, other) -> Tensor

The dot operator.

dynamic_quantize

dynamic_quantize(*args, **kwargs)

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

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

The dynamic_quantize operator.

einsum

einsum(*args, **kwargs)

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

einsum(equation, operands) -> Tensor

The einsum operator.

elu

elu(*args, **kwargs)

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

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

The elu operator.

elu_

elu_(*args, **kwargs)

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

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

The elu_ operator.

embedding

embedding(*args, **kwargs)

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(*args, **kwargs)

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

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

The empty operator.

empty_like

empty_like(*args, **kwargs)

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

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

The empty_like operator.

empty_strided

empty_strided(*args, **kwargs)

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

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

The empty_strided operator.

eq

eq(*args, **kwargs)

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_(*args, **kwargs)

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

eq_(self, other) -> Tensor

The eq_ operator.

erf

erf(*args, **kwargs)

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

erf(input) -> Tensor

The erf operator.

erf_

erf_(*args, **kwargs)

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

erf_(self) -> Tensor

The erf_ operator.

erfc

erfc(*args, **kwargs)

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

erfc(input) -> Tensor

The erfc operator.

erfc_

erfc_(*args, **kwargs)

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

erfc_(self) -> Tensor

The erfc_ operator.

erfinv

erfinv(*args, **kwargs)

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

erfinv(input) -> Tensor

The erfinv operator.

erfinv_

erfinv_(*args, **kwargs)

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

erfinv_(self) -> Tensor

The erfinv_ operator.

exp

exp(*args, **kwargs)

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

exp(input) -> Tensor

The exp operator.

exp_

exp_(*args, **kwargs)

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

exp_(self) -> Tensor

The exp_ operator.

expand

expand(*args, **kwargs)

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_as(*args, **kwargs)

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

expand_as(input, other) -> Tensor

The expand_as operator.

exponential_

exponential_(*args, **kwargs)

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(*args, **kwargs)

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

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

The eye operator.

fast_gelu

fast_gelu(*args, **kwargs)

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

fast_gelu(input) -> Tensor

The fast_gelu operator.

fill

fill(*args, **kwargs)

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_(*args, **kwargs)

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_diagonal(*args, **kwargs)

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_(*args, **kwargs)

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

flatten(*args, **kwargs)

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

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

The flatten operator.

flip

flip(*args, **kwargs)

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

flip(input, dims) -> Tensor

The flip operator.

fliplr

fliplr(*args, **kwargs)

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

fliplr(input) -> Tensor

The fliplr operator.

flipud

flipud(*args, **kwargs)

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

flipud(input) -> Tensor

The flipud operator.

floor

floor(*args, **kwargs)

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

floor(input) -> Tensor

The floor operator.

floor_

floor_(*args, **kwargs)

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

floor_(self) -> Tensor

The floor_ operator.

floor_divide

floor_divide(*args, **kwargs)

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_(*args, **kwargs)

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

fmax(*args, **kwargs)

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

fmax(input, other) -> Tensor

The fmax operator.

fmin

fmin(*args, **kwargs)

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

fmin(input, other) -> Tensor

The fmin operator.

fmod

fmod(*args, **kwargs)

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_(*args, **kwargs)

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

fmod_(self, other) -> Tensor

The fmod_ operator.

fold

fold(*args, **kwargs)

fold(input: clika_runtime._core.Tensor, output_size: collections.abc.Sequence[int], kernel_size: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], stride: collections.abc.Sequence[int] = [], mode: 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

frac(*args, **kwargs)

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

frac(input) -> Tensor

The frac operator.

frac_

frac_(*args, **kwargs)

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

frac_(self) -> Tensor

The frac_ operator.

frexp

frexp(*args, **kwargs)

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

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

The frexp operator.

full

full(*args, **kwargs)

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

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

The full operator.

full_like

full_like(*args, **kwargs)

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

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

The full_like operator.

gated_delta_update

gated_delta_update(*args, **kwargs)

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_norm(*args, **kwargs)

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

gather(*args, **kwargs)

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

gather(input, dim, index) -> Tensor

The gather operator.

ge

ge(*args, **kwargs)

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_(*args, **kwargs)

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

ge_(self, other) -> Tensor

The ge_ operator.

geglu

geglu(*args, **kwargs)

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

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

The geglu operator.

gelu

gelu(*args, **kwargs)

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

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

The gelu operator.

gelu_

gelu_(*args, **kwargs)

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_cache(*args, **kwargs)

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(...)) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

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

The generate_rotary_cache operator.

glu

glu(*args, **kwargs)

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

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

The glu operator.

grid_sample

grid_sample(*args, **kwargs)

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_norm(*args, **kwargs)

group_norm(input: clika_runtime._core.Tensor, num_groups: int, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, running_mean: clika_runtime._core.Tensor | None = None, running_var: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: 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_attention(*args, **kwargs)

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) -> 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) -> tuple[Tensor, Tensor, Tensor]

The group_query_attention operator.

group_query_attention_varlen

group_query_attention_varlen(*args, **kwargs)

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) -> 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) -> tuple[Tensor, Tensor, Tensor]

The group_query_attention_varlen operator.

gt

gt(*args, **kwargs)

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_(*args, **kwargs)

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

gt_(self, other) -> Tensor

The gt_ operator.

hardshrink

hardshrink(*args, **kwargs)

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

hardshrink(input, lambd=0.5) -> Tensor

The hardshrink operator.

hardshrink_

hardshrink_(*args, **kwargs)

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

hardshrink_(self, lambd=0.5) -> Tensor

The hardshrink_ operator.

hardsigmoid

hardsigmoid(*args, **kwargs)

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

hardsigmoid(input) -> Tensor

The hardsigmoid operator.

hardsigmoid_

hardsigmoid_(*args, **kwargs)

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

hardsigmoid_(self) -> Tensor

The hardsigmoid_ operator.

hardswish

hardswish(*args, **kwargs)

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

hardswish(input) -> Tensor

The hardswish operator.

hardswish_

hardswish_(*args, **kwargs)

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

hardswish_(self) -> Tensor

The hardswish_ operator.

hardtanh

hardtanh(*args, **kwargs)

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

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

The hardtanh operator.

hardtanh_

hardtanh_(*args, **kwargs)

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

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

The hardtanh_ operator.

hash_128

hash_128(*args, **kwargs)

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

hash_128(input, seed=0) -> Tensor

The hash_128 operator.

hash_256

hash_256(*args, **kwargs)

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

hash_256(input, seed=0) -> Tensor

The hash_256 operator.

hash_64

hash_64(*args, **kwargs)

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

hash_64(input, seed=0) -> Tensor

The hash_64 operator.

hash_chain

hash_chain(*args, **kwargs)

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

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

The hash_chain operator.

hash_tensor

hash_tensor(*args, **kwargs)

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

histogram(*args, **kwargs)

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

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

The histogram operator.

huber_loss

huber_loss(*args, **kwargs)

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

hypot(*args, **kwargs)

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

hypot(input, other) -> Tensor

The hypot operator.

hypot_

hypot_(*args, **kwargs)

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

hypot_(self, other) -> Tensor

The hypot_ operator.

index

index(*args, **kwargs)

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_add(*args, **kwargs)

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

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

The index_add operator.

index_add_

index_add_(*args, **kwargs)

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

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

The index_add_ operator.

index_copy

index_copy(*args, **kwargs)

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

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

The index_copy operator.

index_copy_

index_copy_(*args, **kwargs)

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

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

The index_copy_ operator.

index_fill

index_fill(*args, **kwargs)

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_(*args, **kwargs)

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_put(*args, **kwargs)

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_(*args, **kwargs)

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_select(*args, **kwargs)

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

index_select(input, dim, index) -> Tensor

The index_select operator.

inner

inner(*args, **kwargs)

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

inner(input, other) -> Tensor

The inner operator.

instance_norm

instance_norm(*args, **kwargs)

instance_norm(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, running_mean: clika_runtime._core.Tensor | None = None, running_var: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: 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

interpolate(*args, **kwargs)

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.

isclose

isclose(*args, **kwargs)

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

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

The isclose operator.

isfinite

isfinite(*args, **kwargs)

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

isfinite(input) -> Tensor

The isfinite operator.

isinf

isinf(*args, **kwargs)

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

isinf(input) -> Tensor

The isinf operator.

isnan

isnan(*args, **kwargs)

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

isnan(input) -> Tensor

The isnan operator.

isneginf

isneginf(*args, **kwargs)

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

isneginf(input) -> Tensor

The isneginf operator.

isposinf

isposinf(*args, **kwargs)

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

isposinf(input) -> Tensor

The isposinf operator.

kl_div

kl_div(*args, **kwargs)

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

kron(*args, **kwargs)

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

kron(input, other) -> Tensor

The kron operator.

kthvalue

kthvalue(*args, **kwargs)

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

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

The kthvalue operator.

l1_loss

l1_loss(*args, **kwargs)

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_norm(*args, **kwargs)

layer_norm(input: clika_runtime._core.Tensor, normalized_shape: collections.abc.Sequence[int], weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: 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

le(*args, **kwargs)

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_(*args, **kwargs)

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_relu(*args, **kwargs)

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

leaky_relu(input, negative_slope=0.01) -> Tensor

The leaky_relu operator.

leaky_relu_

leaky_relu_(*args, **kwargs)

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

leaky_relu_(self, negative_slope=0.01) -> Tensor

The leaky_relu_ operator.

linear

linear(*args, **kwargs)

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(*args, **kwargs)

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

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

The linspace operator.

log

log(*args, **kwargs)

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

log(input) -> Tensor

The log operator.

log10

log10(*args, **kwargs)

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

log10(input) -> Tensor

The log10 operator.

log10_

log10_(*args, **kwargs)

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

log10_(self) -> Tensor

The log10_ operator.

log1p

log1p(*args, **kwargs)

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

log1p(input) -> Tensor

The log1p operator.

log1p_

log1p_(*args, **kwargs)

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

log1p_(self) -> Tensor

The log1p_ operator.

log2

log2(*args, **kwargs)

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

log2(input) -> Tensor

The log2 operator.

log2_

log2_(*args, **kwargs)

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

log2_(self) -> Tensor

The log2_ operator.

log_

log_(*args, **kwargs)

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

log_(self) -> Tensor

The log_ operator.

log_sigmoid

log_sigmoid(*args, **kwargs)

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

log_sigmoid(input) -> Tensor

The log_sigmoid operator.

log_sigmoid_

log_sigmoid_(*args, **kwargs)

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

log_sigmoid_(self) -> Tensor

The log_sigmoid_ operator.

log_softmax

log_softmax(*args, **kwargs)

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

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

The log_softmax operator.

log_softmax_

log_softmax_(*args, **kwargs)

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

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

The log_softmax_ operator.

logaddexp

logaddexp(*args, **kwargs)

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

logaddexp(input, other) -> Tensor

The logaddexp operator.

logaddexp2

logaddexp2(*args, **kwargs)

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

logaddexp2(input, other) -> Tensor

The logaddexp2 operator.

logical_and

logical_and(*args, **kwargs)

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

logical_and(input, other) -> Tensor

The logical_and operator.

logical_and_

logical_and_(*args, **kwargs)

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

logical_and_(self, other) -> Tensor

The logical_and_ operator.

logical_not

logical_not(*args, **kwargs)

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

logical_not(input) -> Tensor

The logical_not operator.

logical_not_

logical_not_(*args, **kwargs)

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

logical_not_(self) -> Tensor

The logical_not_ operator.

logical_or

logical_or(*args, **kwargs)

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

logical_or(input, other) -> Tensor

The logical_or operator.

logical_or_

logical_or_(*args, **kwargs)

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

logical_or_(self, other) -> Tensor

The logical_or_ operator.

logical_xor

logical_xor(*args, **kwargs)

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

logical_xor(input, other) -> Tensor

The logical_xor operator.

logical_xor_

logical_xor_(*args, **kwargs)

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

logical_xor_(self, other) -> Tensor

The logical_xor_ operator.

logit

logit(*args, **kwargs)

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

logit(input, eps=None) -> Tensor

The logit operator.

logit_

logit_(*args, **kwargs)

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

logit_(self, eps=None) -> Tensor

The logit_ operator.

logsumexp

logsumexp(*args, **kwargs)

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

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

The logsumexp operator.

lt

lt(*args, **kwargs)

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_(*args, **kwargs)

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

lt_(self, other) -> Tensor

The lt_ operator.

masked_fill

masked_fill(*args, **kwargs)

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_(*args, **kwargs)

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_scatter(*args, **kwargs)

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

masked_scatter(input, mask, source) -> Tensor

The masked_scatter operator.

masked_scatter_

masked_scatter_(*args, **kwargs)

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

masked_scatter_(self, mask, source) -> Tensor

The masked_scatter_ operator.

masked_select

masked_select(*args, **kwargs)

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

masked_select(input, mask) -> Tensor

The masked_select operator.

matmul

matmul(*args, **kwargs)

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

max(*args, **kwargs)

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

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

The max operator.

max_pool

max_pool(*args, **kwargs)

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

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

The max_pool operator.

max_pool1d

max_pool1d(*args, **kwargs)

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

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

The max_pool1d operator.

max_pool1d_with_indices

max_pool1d_with_indices(*args, **kwargs)

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

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

The max_pool1d_with_indices operator.

max_pool2d

max_pool2d(*args, **kwargs)

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

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

The max_pool2d operator.

max_pool2d_with_indices

max_pool2d_with_indices(*args, **kwargs)

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

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

The max_pool2d_with_indices operator.

max_pool3d

max_pool3d(*args, **kwargs)

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

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

The max_pool3d operator.

max_pool3d_with_indices

max_pool3d_with_indices(*args, **kwargs)

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

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

The max_pool3d_with_indices operator.

max_pool_with_indices

max_pool_with_indices(*args, **kwargs)

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

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

The max_pool_with_indices operator.

maximum

maximum(*args, **kwargs)

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

maximum(input, other) -> Tensor

The maximum operator.

maximum_

maximum_(*args, **kwargs)

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

maximum_(self, other) -> Tensor

The maximum_ operator.

mean

mean(*args, **kwargs)

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

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

The mean operator.

median

median(*args, **kwargs)

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

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

The median operator.

meshgrid

meshgrid(*args, **kwargs)

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.

min

min(*args, **kwargs)

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

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

The min operator.

minimum

minimum(*args, **kwargs)

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

minimum(input, other) -> Tensor

The minimum operator.

minimum_

minimum_(*args, **kwargs)

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

minimum_(self, other) -> Tensor

The minimum_ operator.

mish

mish(*args, **kwargs)

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

mish(input) -> Tensor

The mish operator.

mish_

mish_(*args, **kwargs)

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

mish_(self) -> Tensor

The mish_ operator.

mla_attention

mla_attention(*args, **kwargs)

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

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

The mla_attention operator.

mm

mm(*args, **kwargs)

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

mod(*args, **kwargs)

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_(*args, **kwargs)

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

moe(*args, **kwargs)

moe(input: clika_runtime._core.Tensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.Tensor, fc2_experts: clika_runtime._core.Tensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.Tensor | None = None, fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: 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_embedding(*args, **kwargs)

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_varlen(*args, **kwargs)

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_varlen(*args, **kwargs)

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_attention(*args, **kwargs)

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

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

The ms_deform_attention operator.

mse_loss

mse_loss(*args, **kwargs)

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

mul(*args, **kwargs)

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_(*args, **kwargs)

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

multinomial(*args, **kwargs)

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

mv(*args, **kwargs)

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_num(*args, **kwargs)

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

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

The nan_to_num operator.

nan_to_num_

nan_to_num_(*args, **kwargs)

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

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

The nan_to_num_ operator.

nanmean

nanmean(*args, **kwargs)

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

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

The nanmean operator.

nanmedian

nanmedian(*args, **kwargs)

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

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

The nanmedian operator.

nanquantile

nanquantile(*args, **kwargs)

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

nansum(*args, **kwargs)

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

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

The nansum operator.

narrow

narrow(*args, **kwargs)

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

ndim(*args, **kwargs)

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

ndim(input) -> Tensor

The ndim operator.

ndim_host

ndim_host(*args, **kwargs)

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

ndim_host(input) -> Tensor

The ndim_host operator.

ne

ne(*args, **kwargs)

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_(*args, **kwargs)

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

ne_(self, other) -> Tensor

The ne_ operator.

neg

neg(*args, **kwargs)

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

neg(input) -> Tensor

The neg operator.

neg_

neg_(*args, **kwargs)

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

neg_(self) -> Tensor

The neg_ operator.

nll_loss

nll_loss(*args, **kwargs)

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

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

The nll_loss operator.

nms

nms(*args, **kwargs)

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

nonzero(*args, **kwargs)

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

nonzero(input) -> Tensor

The nonzero operator.

norm

norm(*args, **kwargs)

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

normal(*args, **kwargs)

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_(*args, **kwargs)

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

normalize(*args, **kwargs)

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_(*args, **kwargs)

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

numel(*args, **kwargs)

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

numel(input) -> Tensor

The numel operator.

numel_host

numel_host(*args, **kwargs)

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

numel_host(input) -> Tensor

The numel_host operator.

one_hot

one_hot(*args, **kwargs)

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

one_hot(indices, num_classes) -> Tensor

The one_hot operator.

ones

ones(*args, **kwargs)

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

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

The ones operator.

ones_like

ones_like(*args, **kwargs)

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

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

The ones_like operator.

outer

outer(*args, **kwargs)

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

outer(input, other) -> Tensor

The outer operator.

pad

pad(*args, **kwargs)

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_distance(*args, **kwargs)

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

pdist(*args, **kwargs)

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

permute(*args, **kwargs)

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

permute(input, dims) -> Tensor

The permute operator.

pixel_shuffle

pixel_shuffle(*args, **kwargs)

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_unshuffle(*args, **kwargs)

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

poisson(*args, **kwargs)

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

pow(*args, **kwargs)

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_(*args, **kwargs)

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

pow_(self, exponent) -> Tensor

The pow_ operator.

prelu

prelu(*args, **kwargs)

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

prelu(input, weight=None) -> Tensor

The prelu operator.

prelu_

prelu_(*args, **kwargs)

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

prelu_(self, weight=None) -> Tensor

The prelu_ operator.

prod

prod(*args, **kwargs)

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

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

The prod operator.

put

put(*args, **kwargs)

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

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

The put operator.

put_

put_(*args, **kwargs)

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

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

The put_ operator.

q_embedding

q_embedding(*args, **kwargs)

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

qadd(*args, **kwargs)

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_(*args, **kwargs)

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

qconcat(*args, **kwargs)

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_(*args, **kwargs)

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

qconv(*args, **kwargs)

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

qconv1d(*args, **kwargs)

qconv1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: 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_woq(*args, **kwargs)

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

qconv2d(*args, **kwargs)

qconv2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: 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_woq(*args, **kwargs)

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

qconv3d(*args, **kwargs)

qconv3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: 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_woq(*args, **kwargs)

qconv3d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: 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_(*args, **kwargs)

qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: 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_transpose(*args, **kwargs)

qconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: 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_transpose1d(*args, **kwargs)

qconv_transpose1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], output_padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: 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_woq(*args, **kwargs)

qconv_transpose1d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], output_padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: 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_transpose2d(*args, **kwargs)

qconv_transpose2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], output_padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: 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_woq(*args, **kwargs)

qconv_transpose2d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], output_padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: 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_transpose3d(*args, **kwargs)

qconv_transpose3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: 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_woq(*args, **kwargs)

qconv_transpose3d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: 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_(*args, **kwargs)

qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: 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_woq(*args, **kwargs)

qconv_transpose_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: 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_woq(*args, **kwargs)

qconv_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: 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_conv(*args, **kwargs)

qdeform_conv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, offset_groups: int = 1, *, activation: 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_woq(*args, **kwargs)

qdeform_conv_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, offset_groups: int = 1, *, activation: 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

qdiv(*args, **kwargs)

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_(*args, **kwargs)

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_gelu(*args, **kwargs)

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

Overloaded function.

1. qfast_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qfast_gelu(input) -> Tensor

The qfast_gelu operator.

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_(*args, **kwargs)

qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qfast_gelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qfast_gelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qfast_gelu_(input, out) -> QTensor

The qfast_gelu_ operator.

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

qgelu(*args, **kwargs)

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

Overloaded function.

1. qgelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qgelu(input) -> Tensor

The qgelu operator.

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_(*args, **kwargs)

qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qgelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qgelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qgelu_(input, out) -> QTensor

The qgelu_ operator.

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.

qhardswish

qhardswish(*args, **kwargs)

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

Overloaded function.

1. qhardswish(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qhardswish(input) -> Tensor

The qhardswish operator.

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_(*args, **kwargs)

qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qhardswish(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qhardswish(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qhardswish_(input, out) -> QTensor

The qhardswish_ operator.

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_norm(*args, **kwargs)

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_(*args, **kwargs)

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_norm(*args, **kwargs)

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_(*args, **kwargs)

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_relu(*args, **kwargs)

qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float = 0.01) -> clika_runtime._core.Tensor qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float = 0.01) -> clika_runtime._core.Tensor

qleaky_relu(input, negative_slope=0.01) -> Tensor

The qleaky_relu operator.

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_(*args, **kwargs)

qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qleaky_relu_(input, negative_slope, out) -> QTensor

The qleaky_relu_ operator.

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

qlinear(*args, **kwargs)

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_(*args, **kwargs)

qlinear_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: 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_woq(*args, **kwargs)

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_(*args, **kwargs)

qlinear_woq_(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: 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

qmatmul(*args, **kwargs)

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_(*args, **kwargs)

qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: 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_woq(*args, **kwargs)

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_(*args, **kwargs)

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

qmoe(*args, **kwargs)

qmoe(input: clika_runtime._core.QTensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.QTensor = QTensor(, []), fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: 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_woq(*args, **kwargs)

qmoe_woq(input: clika_runtime._core.Tensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.QTensor = QTensor(, []), fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: 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

qmul(*args, **kwargs)

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_(*args, **kwargs)

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.

qquick_gelu

qquick_gelu(*args, **kwargs)

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

Overloaded function.

1. qquick_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qquick_gelu(input) -> Tensor

The qquick_gelu operator.

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_(*args, **kwargs)

qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qquick_gelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qquick_gelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qquick_gelu_(input, out) -> QTensor

The qquick_gelu_ operator.

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

qrelu(*args, **kwargs)

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

Overloaded function.

1. qrelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qrelu(input) -> Tensor

The qrelu operator.

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_(*args, **kwargs)

qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qrelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qrelu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qrelu_(input, out) -> QTensor

The qrelu_ operator.

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

qsigmoid(*args, **kwargs)

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

Overloaded function.

1. qsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qsigmoid(input) -> Tensor

The qsigmoid operator.

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_(*args, **kwargs)

qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qsigmoid(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qsigmoid(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qsigmoid_(input, out) -> QTensor

The qsigmoid_ operator.

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

qsilu(*args, **kwargs)

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

Overloaded function.

1. qsilu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qsilu(input) -> Tensor

The qsilu operator.

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_(*args, **kwargs)

qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qsilu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qsilu(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qsilu_(input, out) -> QTensor

The qsilu_ operator.

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

qsub(*args, **kwargs)

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_(*args, **kwargs)

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

qtanh(*args, **kwargs)

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

Overloaded function.

1. qtanh(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor

qtanh(input) -> Tensor

The qtanh operator.

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_(*args, **kwargs)

qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor qtanh(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime.core.Tensor qtanh(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

qtanh_(input, out) -> QTensor

The qtanh_ operator.

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

quantile(*args, **kwargs)

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(*args, **kwargs)

quantize(input: clika_runtime._core.Tensor, scale: clika_runtime._core.Tensor, zero_point: clika_runtime._core.Tensor | None = None, quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, block_size: int = 0) -> clika_runtime._core.QTensor

quantize(input, scale, zero_point=None, quant_axis=-1, *, out_dtype=Undefined, block_size=0) -> QTensor

The quantize operator.

quantize_

quantize_(*args, **kwargs)

quantize_(input: clika_runtime._core.Tensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor quantize(input: clika_runtime._core.Tensor, out: clika_runtime._core.Tensor, scale: clika_runtime._core.Tensor, zero_point: clika_runtime._core.Tensor | None = None, quant_axis: int = -1, block_size: int = 0) -> clika_runtime._core.Tensor

Overloaded function.

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

quantize_(input, out) -> QTensor

The quantize_ operator.

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(*args, **kwargs)

quantize_dequantize(input: clika_runtime._core.Tensor, scale: clika_runtime._core.Tensor, zero_point: clika_runtime._core.Tensor | None = None, quant_axis: int = -1, *, code_dtype: clika_runtime._core.DataType = DataType.Undefined, out_dtype: clika_runtime._core.DataType = DataType.Undefined, block_size: int = 0) -> clika_runtime._core.Tensor

quantize_dequantize(input, scale, zero_point=None, quant_axis=-1, *, code_dtype=Undefined, out_dtype=Undefined, block_size=0) -> Tensor

The quantize_dequantize operator.

quantize_to_scheme

quantize_to_scheme(*args, **kwargs)

quantize_to_scheme(input: clika_runtime._core.Tensor, scheme: str, scale: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.QTensor

quantize_to_scheme(input, scheme, scale=None) -> QTensor

The quantize_to_scheme operator.

quick_gelu

quick_gelu(*args, **kwargs)

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

quick_gelu(input) -> Tensor

The quick_gelu operator.

rad2deg

rad2deg(*args, **kwargs)

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

rad2deg(input) -> Tensor

The rad2deg operator.

rad2deg_

rad2deg_(*args, **kwargs)

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

rad2deg_(self) -> Tensor

The rad2deg_ operator.

rand

rand(*args, **kwargs)

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

rand(shape, *, dtype=Float32, device=None) -> Tensor

The rand operator.

rand_like

rand_like(*args, **kwargs)

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

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

The rand_like operator.

randint

randint(*args, **kwargs)

randint(low: int, high: int, shape: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], *, dtype: clika_runtime._core.DataType = DataType.Int64, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

randint(low, high, shape, *, dtype=Int64, device=None) -> Tensor

The randint operator.

randint_like

randint_like(*args, **kwargs)

randint_like(reference: clika_runtime._core.Tensor, low: int, high: int, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

randint_like(reference, low, high, *, device=None) -> Tensor

The randint_like operator.

randn

randn(*args, **kwargs)

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

randn(shape, *, dtype=Float32, device=None) -> Tensor

The randn operator.

randn_like

randn_like(*args, **kwargs)

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

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

The randn_like operator.

random_

random_(*args, **kwargs)

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

randperm(*args, **kwargs)

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

reciprocal(*args, **kwargs)

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

reciprocal(input) -> Tensor

The reciprocal operator.

reciprocal_

reciprocal_(*args, **kwargs)

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

reciprocal_(self) -> Tensor

The reciprocal_ operator.

reflect_pad

reflect_pad(*args, **kwargs)

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

reglu(*args, **kwargs)

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

reglu(input) -> Tensor

The reglu operator.

relu

relu(*args, **kwargs)

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

relu(input) -> Tensor

The relu operator.

relu6

relu6(*args, **kwargs)

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

relu6(input) -> Tensor

The relu6 operator.

relu6_

relu6_(*args, **kwargs)

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

relu6_(self) -> Tensor

The relu6_ operator.

relu_

relu_(*args, **kwargs)

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

relu_(self) -> Tensor

The relu_ operator.

remainder

remainder(*args, **kwargs)

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_(*args, **kwargs)

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

remainder_(self, other) -> Tensor

The remainder_ operator.

renorm

renorm(*args, **kwargs)

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_(*args, **kwargs)

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

repeat(*args, **kwargs)

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_interleave(*args, **kwargs)

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_pad(*args, **kwargs)

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

requantize(*args, **kwargs)

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

requantize(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The requantize operator.

requantize_

requantize_(*args, **kwargs)

requantize_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime.core.QTensor requantize(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. requantize_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor

requantize_(input, out) -> QTensor

The requantize_ operator.

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

resample(*args, **kwargs)

resample(input: clika_runtime._core.Tensor, orig_freq: int, new_freq: int, lowpass_filter_width: int = 16, rolloff: float = 0.945, beta: float | None = None) -> clika_runtime._core.Tensor

resample(input, orig_freq, new_freq, lowpass_filter_width=16, rolloff=0.945, beta=None) -> Tensor

The resample operator.

reshape

reshape(*args, **kwargs)

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_as(*args, **kwargs)

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

reshape_as(input, other) -> Tensor

The reshape_as operator.

rfft

rfft(*args, **kwargs)

rfft(input: clika_runtime._core.Tensor, n_fft: int | None = None, normalized: bool = False) -> clika_runtime._core.Tensor

rfft(input, n_fft=None, normalized=False) -> Tensor

The rfft operator.

rms_norm

rms_norm(*args, **kwargs)

rms_norm(input: clika_runtime._core.Tensor, normalized_shape: collections.abc.Sequence[int], weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: 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

roll(*args, **kwargs)

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

roll(input, shifts, dims=[]) -> Tensor

The roll operator.

rot90

rot90(*args, **kwargs)

rot90(input: clika_runtime._core.Tensor, k: int = 1, dims: collections.abc.Sequence[int] = [0, 1]) -> clika_runtime._core.Tensor

rot90(input, k=1, dims=[0, 1]) -> Tensor

The rot90 operator.

rotary_embedding

rotary_embedding(*args, **kwargs)

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_qk(*args, **kwargs)

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_varlen(*args, **kwargs)

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_varlen(*args, **kwargs)

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

round(*args, **kwargs)

round(input: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor

round(input, decimals=0) -> Tensor

The round operator.

round_

round_(*args, **kwargs)

round_(self: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor

round_(self, decimals=0) -> Tensor

The round_ operator.

rsqrt

rsqrt(*args, **kwargs)

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

rsqrt(input) -> Tensor

The rsqrt operator.

rsqrt_

rsqrt_(*args, **kwargs)

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

rsqrt_(self) -> Tensor

The rsqrt_ operator.

scaled_dot_product_attention

scaled_dot_product_attention(*args, **kwargs)

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_varlen(*args, **kwargs)

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

scatter(*args, **kwargs)

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_(*args, **kwargs)

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_add(*args, **kwargs)

scatter_add(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_add(input, dim, index, src, deterministic=False) -> Tensor

The scatter_add operator.

scatter_add_

scatter_add_(*args, **kwargs)

scatter_add_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_add_(self, dim, index, src, deterministic=False) -> Tensor

The scatter_add_ operator.

scatter_reduce

scatter_reduce(*args, **kwargs)

scatter_reduce(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: 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_(*args, **kwargs)

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

searchsorted(*args, **kwargs)

searchsorted(sorted_sequence: clika_runtime._core.Tensor, values: clika_runtime._core.Tensor, out_int32: bool = False, right: bool = False, side: bool | None = None, sorter: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

searchsorted(sorted_sequence, values, out_int32=False, right=False, side=None, sorter=None) -> Tensor

The searchsorted operator.

select

select(*args, **kwargs)

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

selu(*args, **kwargs)

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

selu(input) -> Tensor

The selu operator.

selu_

selu_(*args, **kwargs)

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

selu_(self) -> Tensor

The selu_ operator.

sgn

sgn(*args, **kwargs)

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

sgn(input) -> Tensor

The sgn operator.

sgn_

sgn_(*args, **kwargs)

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

sgn_(self) -> Tensor

The sgn_ operator.

shape

shape(*args, **kwargs)

shape(input: clika_runtime._core.Tensor, dim: int | None = None) -> clika_runtime._core.Tensor shape(input: clika_runtime._core.Tensor, start: int | None, end: int | None) -> clika_runtime._core.Tensor

Overloaded function.

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

shape(input, dim=None) -> Tensor

The shape operator.

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_host(*args, **kwargs)

shape_host(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor shape_host(input: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor shape_host(input: clika_runtime._core.Tensor, start: int | None, end: int | None) -> clika_runtime._core.Tensor

Overloaded function.

1. shape_host(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

shape_host(input) -> Tensor

The shape_host operator.

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

sigmoid(*args, **kwargs)

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

sigmoid(input) -> Tensor

The sigmoid operator.

sigmoid_

sigmoid_(*args, **kwargs)

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

sigmoid_(self) -> Tensor

The sigmoid_ operator.

sign

sign(*args, **kwargs)

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

sign(input) -> Tensor

The sign operator.

sign_

sign_(*args, **kwargs)

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

sign_(self) -> Tensor

The sign_ operator.

silu

silu(*args, **kwargs)

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

silu(input) -> Tensor

The silu operator.

silu_

silu_(*args, **kwargs)

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

silu_(self) -> Tensor

The silu_ operator.

sin

sin(*args, **kwargs)

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

sin(input) -> Tensor

The sin operator.

sin_

sin_(*args, **kwargs)

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

sin_(self) -> Tensor

The sin_ operator.

sinc

sinc(*args, **kwargs)

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

sinc(input) -> Tensor

The sinc operator.

sinc_

sinc_(*args, **kwargs)

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

sinc_(self) -> Tensor

The sinc_ operator.

sinh

sinh(*args, **kwargs)

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

sinh(input) -> Tensor

The sinh operator.

sinh_

sinh_(*args, **kwargs)

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

sinh_(self) -> Tensor

The sinh_ operator.

slice

slice(*args, **kwargs)

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_loss(*args, **kwargs)

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

snake(*args, **kwargs)

snake(input: clika_runtime._core.Tensor, alpha: clika_runtime._core.Tensor | None = None, beta: clika_runtime._core.Tensor | None = None, eps: float = 1e-09) -> clika_runtime._core.Tensor

snake(input, alpha=None, beta=None, eps=1e-9) -> Tensor

The snake operator.

snake_

snake_(*args, **kwargs)

snake_(self: clika_runtime._core.Tensor, alpha: clika_runtime._core.Tensor | None = None, beta: clika_runtime._core.Tensor | None = None, eps: float = 1e-09) -> clika_runtime._core.Tensor

snake_(self, alpha=None, beta=None, eps=1e-9) -> Tensor

The snake_ operator.

softcap_logits

softcap_logits(*args, **kwargs)

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_(*args, **kwargs)

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

softmax(*args, **kwargs)

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

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

The softmax operator.

softmax_

softmax_(*args, **kwargs)

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

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

The softmax_ operator.

softmin

softmin(*args, **kwargs)

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

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

The softmin operator.

softmin_

softmin_(*args, **kwargs)

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

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

The softmin_ operator.

softplus

softplus(*args, **kwargs)

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

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

The softplus operator.

softplus_

softplus_(*args, **kwargs)

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

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

The softplus_ operator.

softshrink

softshrink(*args, **kwargs)

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

softshrink(input, lambd=0.5) -> Tensor

The softshrink operator.

softshrink_

softshrink_(*args, **kwargs)

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

softshrink_(self, lambd=0.5) -> Tensor

The softshrink_ operator.

softsign

softsign(*args, **kwargs)

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

softsign(input) -> Tensor

The softsign operator.

softsign_

softsign_(*args, **kwargs)

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

softsign_(self) -> Tensor

The softsign_ operator.

sort

sort(*args, **kwargs)

sort(input: clika_runtime._core.Tensor, dim: int = -1, descending: bool = False, stable: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

sort(input, dim=-1, descending=False, stable=False) -> tuple[Tensor, Tensor]

The sort operator.

split_by_size

split_by_size(*args, **kwargs)

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

split_by_size(input, chunk_size, dim=0) -> list[Tensor]

The split_by_size operator.

split_with_sizes

split_with_sizes(*args, **kwargs)

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

sqrt(*args, **kwargs)

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

sqrt(input) -> Tensor

The sqrt operator.

sqrt_

sqrt_(*args, **kwargs)

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

sqrt_(self) -> Tensor

The sqrt_ operator.

square

square(*args, **kwargs)

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

square(input) -> Tensor

The square operator.

square_

square_(*args, **kwargs)

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

square_(self) -> Tensor

The square_ operator.

squeeze

squeeze(*args, **kwargs)

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

squeeze(input, dim=[]) -> Tensor

The squeeze operator.

squeeze_

squeeze_(*args, **kwargs)

squeeze_(self: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor

squeeze_(self, dim=[]) -> Tensor

The squeeze_ operator.

ssd_update

ssd_update(*args, **kwargs)

ssd_update(input: clika_runtime._core.Tensor, dt: clika_runtime._core.Tensor, a_rate: clika_runtime._core.Tensor, b_mat: clika_runtime._core.Tensor, c_mat: clika_runtime._core.Tensor, d_skip: clika_runtime._core.Tensor | None, dt_bias: clika_runtime._core.Tensor | None, 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

stack(*args, **kwargs)

stack(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], dim: int = 0) -> clika_runtime._core.Tensor

stack(tensors, dim=0) -> Tensor

The stack operator.

std

std(*args, **kwargs)

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

std(input, dims=[], correction=1, keepdim=False) -> Tensor

The std operator.

stft

stft(*args, **kwargs)

stft(input: clika_runtime._core.Tensor, n_fft: int, hop_length: int | None = None, win_length: int | None = None, window: clika_runtime._core.Tensor | None = None, center: bool = True, pad_mode: 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.

sub

sub(*args, **kwargs)

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_(*args, **kwargs)

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

sum(*args, **kwargs)

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

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

The sum operator.

swiglu

swiglu(*args, **kwargs)

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

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

The swiglu operator.

synchronize_all

synchronize_all(*args, **kwargs)

synchronize_all() -> None

synchronize_all() -> None

The synchronize_all operator.

take

take(*args, **kwargs)

take(self: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

take(self, index) -> Tensor

The take operator.

take_along_dim

take_along_dim(*args, **kwargs)

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

take_along_dim(input, index, dim=None) -> Tensor

The take_along_dim operator.

tan

tan(*args, **kwargs)

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

tan(input) -> Tensor

The tan operator.

tan_

tan_(*args, **kwargs)

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

tan_(self) -> Tensor

The tan_ operator.

tanh

tanh(*args, **kwargs)

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

tanh(input) -> Tensor

The tanh operator.

tanh_

tanh_(*args, **kwargs)

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

tanh_(self) -> Tensor

The tanh_ operator.

tensordot

tensordot(*args, **kwargs)

tensordot(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, dims_a: collections.abc.Sequence[int], dims_b: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor

tensordot(input, other, dims_a, dims_b) -> Tensor

The tensordot operator.

threshold

threshold(*args, **kwargs)

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

threshold(input, threshold, value) -> Tensor

The threshold operator.

threshold_

threshold_(*args, **kwargs)

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

threshold_(self, threshold, value) -> Tensor

The threshold_ operator.

tile

tile(*args, **kwargs)

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

to(*args, **kwargs)

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

topk(*args, **kwargs)

topk(input: clika_runtime._core.Tensor, k: int, dim: int = -1, largest: bool = True, sorted: bool = True) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

topk(input, k, dim=-1, largest=True, sorted=True) -> tuple[Tensor, Tensor]

The topk operator.

trace

trace(*args, **kwargs)

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

trace(input) -> Tensor

The trace operator.

transpose

transpose(*args, **kwargs)

transpose(input: clika_runtime._core.Tensor, dim0: int, dim1: int) -> clika_runtime._core.Tensor

transpose(input, dim0, dim1) -> Tensor

The transpose operator.

tril

tril(*args, **kwargs)

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

tril(input, diagonal=0) -> Tensor

The tril operator.

tril_

tril_(*args, **kwargs)

tril_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

tril_(self, diagonal=0) -> Tensor

The tril_ operator.

triu

triu(*args, **kwargs)

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

triu(input, diagonal=0) -> Tensor

The triu operator.

triu_

triu_(*args, **kwargs)

triu_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

triu_(self, diagonal=0) -> Tensor

The triu_ operator.

trunc

trunc(*args, **kwargs)

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

trunc(input) -> Tensor

The trunc operator.

trunc_

trunc_(*args, **kwargs)

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

trunc_(self) -> Tensor

The trunc_ operator.

unflatten

unflatten(*args, **kwargs)

unflatten(input: clika_runtime._core.Tensor, dim: int, sizes: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor

unflatten(input, dim, sizes) -> Tensor

The unflatten operator.

unfold

unfold(*args, **kwargs)

unfold(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], stride: collections.abc.Sequence[int] = [], mode: 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_(*args, **kwargs)

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

unique(*args, **kwargs)

unique(input: clika_runtime._core.Tensor, sorted: bool = True, return_inverse: bool = False, return_counts: bool = False, dim: int | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

unique(input, sorted=True, return_inverse=False, return_counts=False, dim=None) -> tuple[Tensor, Tensor, Tensor]

The unique operator.

unique_consecutive

unique_consecutive(*args, **kwargs)

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

unique_consecutive(input, return_inverse=False, return_counts=False, dim=None) -> tuple[Tensor, Tensor, Tensor]

The unique_consecutive operator.

unsqueeze

unsqueeze(*args, **kwargs)

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

unsqueeze(input, dim) -> Tensor

The unsqueeze operator.

unsqueeze_

unsqueeze_(*args, **kwargs)

unsqueeze_(self: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor

unsqueeze_(self, dim) -> Tensor

The unsqueeze_ operator.

upsample_bicubic2d

upsample_bicubic2d(*args, **kwargs)

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_bilinear2d(*args, **kwargs)

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_linear1d(*args, **kwargs)

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_nearest1d(*args, **kwargs)

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_nearest2d(*args, **kwargs)

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_nearest3d(*args, **kwargs)

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_trilinear3d(*args, **kwargs)

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_dim(*args, **kwargs)

validate_rotary_dim(rotary_dim: int, head_dim: int = -1) -> None

validate_rotary_dim(rotary_dim, head_dim=-1) -> None

The validate_rotary_dim operator.

var

var(*args, **kwargs)

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

var(input, dims=[], correction=1, keepdim=False) -> Tensor

The var operator.

where

where(*args, **kwargs)

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

Overloaded function.

1. where(condition: clika_runtime._core.Tensor, input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

where(condition, input, other) -> Tensor

The where operator.

2. where(condition: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

where(condition) -> Tensor

The where operator.

xlog1py

xlog1py(*args, **kwargs)

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

xlog1py(input, other) -> Tensor

The xlog1py operator.

xlogy

xlogy(*args, **kwargs)

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_(*args, **kwargs)

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_(*args, **kwargs)

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(*args, **kwargs)

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

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

The zeros operator.

zeros_like

zeros_like(*args, **kwargs)

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

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

The zeros_like operator.