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

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

## `abs`

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

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

abs(input) -> Tensor

The `abs` operator.

## `abs_`

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

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

abs_(self) -> Tensor

The `abs_` operator.

## `acos`

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

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

acos(input) -> Tensor

The `acos` operator.

## `acos_`

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

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

acos_(self) -> Tensor

The `acos_` operator.

## `acosh`

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

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

acosh(input) -> Tensor

The `acosh` operator.

## `acosh_`

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

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

acosh_(self) -> Tensor

The `acosh_` operator.

## `adaptive_avg_pool`

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

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

adaptive_avg_pool(input, output_size) -> Tensor

The `adaptive_avg_pool` operator.

## `adaptive_avg_pool1d`

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

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

adaptive_avg_pool1d(input, output_size) -> Tensor

The `adaptive_avg_pool1d` operator.

## `adaptive_avg_pool2d`

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

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

adaptive_avg_pool2d(input, output_size) -> Tensor

The `adaptive_avg_pool2d` operator.

## `adaptive_avg_pool3d`

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

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

adaptive_avg_pool3d(input, output_size) -> Tensor

The `adaptive_avg_pool3d` operator.

## `adaptive_max_pool`

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

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

adaptive_max_pool(input, output_size) -> Tensor

The `adaptive_max_pool` operator.

## `adaptive_max_pool1d`

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

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

adaptive_max_pool1d(input, output_size) -> Tensor

The `adaptive_max_pool1d` operator.

## `adaptive_max_pool2d`

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

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

adaptive_max_pool2d(input, output_size) -> Tensor

The `adaptive_max_pool2d` operator.

## `adaptive_max_pool3d`

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

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

adaptive_max_pool3d(input, output_size) -> Tensor

The `adaptive_max_pool3d` operator.

## `add`

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

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

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

The `add` operator.

## `add_`

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

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

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

The `add_` operator.

## `add_layer_norm`

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

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

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

The `add_layer_norm` operator.

## `add_rms_norm`

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

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

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

The `add_rms_norm` operator.

## `all`

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

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

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

The `all` operator.

## `allclose`

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

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

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

The `allclose` operator.

## `amax`

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

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

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

The `amax` operator.

## `amin`

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

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

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

The `amin` operator.

## `aminmax`

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

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

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

The `aminmax` operator.

## `any`

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

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

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

The `any` operator.

## `arange`

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

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

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

## `argmax`

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

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

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

The `argmax` operator.

## `argmin`

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

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

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

The `argmin` operator.

## `argsort`

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

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

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

The `argsort` operator.

## `as_tensor`

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

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

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

## `asin`

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

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

asin(input) -> Tensor

The `asin` operator.

## `asin_`

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

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

asin_(self) -> Tensor

The `asin_` operator.

## `asinh`

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

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

asinh(input) -> Tensor

The `asinh` operator.

## `asinh_`

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

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

asinh_(self) -> Tensor

The `asinh_` operator.

## `async_eval`

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

async_eval(*trees) -> None

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

## `atan`

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

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

atan(input) -> Tensor

The `atan` operator.

## `atan2`

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

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

atan2(input, other) -> Tensor

The `atan2` operator.

## `atan2_`

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

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

atan2_(self, other) -> Tensor

The `atan2_` operator.

## `atan_`

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

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

atan_(self) -> Tensor

The `atan_` operator.

## `atanh`

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

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

atanh(input) -> Tensor

The `atanh` operator.

## `atanh_`

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

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

atanh_(self) -> Tensor

The `atanh_` operator.

## `atleast_1d`

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

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

atleast_1d(input) -> Tensor

The `atleast_1d` operator.

## `atleast_2d`

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

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

atleast_2d(input) -> Tensor

The `atleast_2d` operator.

## `atleast_3d`

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

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

atleast_3d(input) -> Tensor

The `atleast_3d` operator.

## `attention`

```python
attentionattention(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, attn_mask: clika_runtime._core.Tensor | None = None, head_sink: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), kept_prefix: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

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

attention(query, key, value, attn_mask=None, head_sink=None, is_causal=None, q_scale=None, softcap=None, sliding_window=None, smooth_softmax=None, k_scale=None, v_scale=None, kept_prefix=None) -> Tensor

The `attention` operator.

## `attention_over_cache`

```python
attention_over_cacheattention_over_cache(query: clika_runtime._core.Tensor, cache_key: clika_runtime._core.Tensor, cache_value: clika_runtime._core.Tensor, kvcache_start: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), rope_cos: clika_runtime._core.Tensor | None = None, rope_sin: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: object | None = None, num_heads: int | None = None, kv_num_heads: int | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), head_sink: clika_runtime._core.Tensor | None = None, q_norm_gain: clika_runtime._core.Tensor | None = None, k_norm_gain: clika_runtime._core.Tensor | None = None, qk_norm_eps: float | None = None, slot_ids: clika_runtime._core.Tensor | None = None, kept_prefix: clika_runtime._core.Tensor | None = None, kv_position_offset: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

attention_over_cache(query: clika_runtime._core.Tensor, cache_key: clika_runtime._core.Tensor, cache_value: clika_runtime._core.Tensor, kvcache_start: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), rope_cos: clika_runtime._core.Tensor | None = None, rope_sin: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: object | None = None, num_heads: int | None = None, kv_num_heads: int | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), head_sink: clika_runtime._core.Tensor | None = None, q_norm_gain: clika_runtime._core.Tensor | None = None, k_norm_gain: clika_runtime._core.Tensor | None = None, qk_norm_eps: float | None = None, slot_ids: clika_runtime._core.Tensor | None = None, kept_prefix: clika_runtime._core.Tensor | None = None, kv_position_offset: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

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

The `attention_over_cache` operator.

## `attention_varlen`

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

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

attention_varlen(query, key, value, cu_seqlens_q, cu_seqlens_k, max_seqlen_q=None, max_seqlen_k=None, attn_mask=None, head_sink=None, is_causal=None, q_scale=None, softcap=None, sliding_window=None, smooth_softmax=None, k_scale=None, v_scale=None, kept_prefix=None, kv_position_offset=None) -> Tensor

The `attention_varlen` operator.

## `avg_pool`

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

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

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

The `avg_pool` operator.

## `avg_pool1d`

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

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

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

The `avg_pool1d` operator.

## `avg_pool2d`

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

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

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

The `avg_pool2d` operator.

## `avg_pool3d`

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

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

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

The `avg_pool3d` operator.

## `batch_norm`

```python
batch_normbatch_norm(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, running_mean: clika_runtime._core.Tensor | None = None, running_var: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor
```

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

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

The `batch_norm` operator.

## `bernoulli`

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

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

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

The `bernoulli` operator.

## `bernoulli_`

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

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

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

The `bernoulli_` operator.

## `binary_cross_entropy`

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

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

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

The `binary_cross_entropy` operator.

## `binary_cross_entropy_with_logits`

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

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

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

The `binary_cross_entropy_with_logits` operator.

## `bincount`

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

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

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

The `bincount` operator.

## `bitwise_and`

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

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

bitwise_and(input, other) -> Tensor

The `bitwise_and` operator.

## `bitwise_and_`

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

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

bitwise_and_(self, other) -> Tensor

The `bitwise_and_` operator.

## `bitwise_left_shift`

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

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

bitwise_left_shift(input, other) -> Tensor

The `bitwise_left_shift` operator.

## `bitwise_left_shift_`

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

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

bitwise_left_shift_(self, other) -> Tensor

The `bitwise_left_shift_` operator.

## `bitwise_not`

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

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

bitwise_not(input) -> Tensor

The `bitwise_not` operator.

## `bitwise_not_`

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

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

bitwise_not_(self) -> Tensor

The `bitwise_not_` operator.

## `bitwise_or`

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

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

bitwise_or(input, other) -> Tensor

The `bitwise_or` operator.

## `bitwise_or_`

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

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

bitwise_or_(self, other) -> Tensor

The `bitwise_or_` operator.

## `bitwise_right_shift`

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

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

bitwise_right_shift(input, other) -> Tensor

The `bitwise_right_shift` operator.

## `bitwise_right_shift_`

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

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

bitwise_right_shift_(self, other) -> Tensor

The `bitwise_right_shift_` operator.

## `bitwise_xor`

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

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

bitwise_xor(input, other) -> Tensor

The `bitwise_xor` operator.

## `bitwise_xor_`

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

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

bitwise_xor_(self, other) -> Tensor

The `bitwise_xor_` operator.

## `bmm`

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

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

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

The `bmm` operator.

## `broadcast_tensors`

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

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

broadcast_tensors(tensors) -> list[Tensor]

The `broadcast_tensors` operator.

## `broadcast_to`

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

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

broadcast_to(input, shape) -> Tensor

The `broadcast_to` operator.

## `bucketize`

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

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

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

The `bucketize` operator.

## `cast`

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

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

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

The `cast` operator.

## `cast_like`

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

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

cast_like(input, reference) -> Tensor

The `cast_like` operator.

## `causal_conv_update`

```python
causal_conv_updatecausal_conv_update(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None, state: clika_runtime._core.Tensor, seq_lens: clika_runtime._core.Tensor | None = None, slot_ids: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor
```

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

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

The `causal_conv_update` operator.

## `cdist`

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

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

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

The `cdist` operator.

## `ceil`

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

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

ceil(input) -> Tensor

The `ceil` operator.

## `ceil_`

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

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

ceil_(self) -> Tensor

The `ceil_` operator.

## `celu`

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

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

celu(input, alpha=1.0) -> Tensor

The `celu` operator.

## `celu_`

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

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

celu_(self, alpha=1.0) -> Tensor

The `celu_` operator.

## `chunk`

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

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

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

The `chunk` operator.

## `circular_pad`

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

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

circular_pad(input, pad) -> Tensor

The `circular_pad` operator.

## `clamp`

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

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

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

The `clamp` operator.

## `clamp_`

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

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

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

The `clamp_` operator.

## `clamp_max`

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

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

clamp_max(input, max) -> Tensor

The `clamp_max` operator.

## `clamp_max_`

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

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

clamp_max_(self, max) -> Tensor

The `clamp_max_` operator.

## `clamp_min`

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

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

clamp_min(input, min) -> Tensor

The `clamp_min` operator.

## `clamp_min_`

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

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

clamp_min_(self, min) -> Tensor

The `clamp_min_` operator.

## `clone`

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

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

clone(src) -> Tensor

The `clone` operator.

## `compile`

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

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

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

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

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

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

## `concat`

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

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

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

The `concat` operator.

## `constant_pad`

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

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

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

The `constant_pad` operator.

## `contiguous`

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

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

contiguous(input, force_copy=False) -> Tensor

The `contiguous` operator.

## `conv`

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

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

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

The `conv` operator.

## `conv1d`

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

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

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

The `conv1d` operator.

## `conv2d`

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

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

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

The `conv2d` operator.

## `conv3d`

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

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

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

The `conv3d` operator.

## `conv_transpose`

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

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

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

The `conv_transpose` operator.

## `conv_transpose1d`

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

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

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

The `conv_transpose1d` operator.

## `conv_transpose2d`

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

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

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

The `conv_transpose2d` operator.

## `conv_transpose3d`

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

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

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

The `conv_transpose3d` operator.

## `copy`

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

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

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

The `copy` operator.

## `copy_`

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

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

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

The `copy_` operator.

## `copy_into`

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

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

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

The `copy_into` operator.

## `copy_to_cpu`

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

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

copy_to_cpu(src) -> Tensor

The `copy_to_cpu` operator.

## `copysign`

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

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

copysign(input, other) -> Tensor

The `copysign` operator.

## `copysign_`

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

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

copysign_(self, other) -> Tensor

The `copysign_` operator.

## `cos`

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

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

cos(input) -> Tensor

The `cos` operator.

## `cos_`

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

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

cos_(self) -> Tensor

The `cos_` operator.

## `cosh`

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

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

cosh(input) -> Tensor

The `cosh` operator.

## `cosh_`

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

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

cosh_(self) -> Tensor

The `cosh_` operator.

## `cosine_similarity`

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

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

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

The `cosine_similarity` operator.

## `count_nonzero`

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

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

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

The `count_nonzero` operator.

## `cross`

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

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

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

The `cross` operator.

## `cross_entropy`

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

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

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

The `cross_entropy` operator.

## `cummax`

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

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

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

The `cummax` operator.

## `cummin`

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

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

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

The `cummin` operator.

## `cumprod`

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

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

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

The `cumprod` operator.

## `cumprod_`

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

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

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

The `cumprod_` operator.

## `cumsum`

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

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

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

The `cumsum` operator.

## `cumsum_`

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

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

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

The `cumsum_` operator.

## `deform_conv`

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

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

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

The `deform_conv` operator.

## `deg2rad`

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

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

deg2rad(input) -> Tensor

The `deg2rad` operator.

## `deg2rad_`

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

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

deg2rad_(self) -> Tensor

The `deg2rad_` operator.

## `dequantize`

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

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

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

The `dequantize` operator.

## `dequantize_`

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

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

dequantize_(input, out) -> Tensor

The `dequantize_` operator.

## `device`

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

device(target) -> a placement region

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

## `device_count`

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

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

Overloaded function.

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

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

2. ``device_count(kind: object) -> int``

device_count(kind) -> int

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

## `diag`

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

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

diag(input, diagonal=0) -> Tensor

The `diag` operator.

## `diag_embed`

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

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

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

The `diag_embed` operator.

## `diagonal`

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

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

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

The `diagonal` operator.

## `diff`

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

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

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

The `diff` operator.

## `div`

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

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

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

The `div` operator.

## `div_`

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

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

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

The `div_` operator.

## `dot`

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

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

dot(input, other) -> Tensor

The `dot` operator.

## `dynamic_quantize`

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

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

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

The `dynamic_quantize` operator.

## `eager`

```python
eager() -> '_EagerScope'
```

eager() -> an execution-mode region

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

## `einsum`

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

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

einsum(equation, operands) -> Tensor

The `einsum` operator.

## `elu`

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

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

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

The `elu` operator.

## `elu_`

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

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

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

The `elu_` operator.

## `embedding`

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

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

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

The `embedding` operator.

## `empty`

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

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

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

## `empty_cache`

```python
empty_cacheempty_cache(device: object) -> None
```

empty_cache(device: object) -> None

empty_cache(device) -> None

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

## `empty_like`

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

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

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

## `empty_strided`

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

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

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

The `empty_strided` operator.

## `eq`

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

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

eq(input, other) -> Tensor

The `eq` operator.

## `eq_`

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

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

eq_(self, other) -> Tensor

The `eq_` operator.

## `erf`

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

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

erf(input) -> Tensor

The `erf` operator.

## `erf_`

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

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

erf_(self) -> Tensor

The `erf_` operator.

## `erfc`

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

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

erfc(input) -> Tensor

The `erfc` operator.

## `erfc_`

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

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

erfc_(self) -> Tensor

The `erfc_` operator.

## `erfinv`

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

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

erfinv(input) -> Tensor

The `erfinv` operator.

## `erfinv_`

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

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

erfinv_(self) -> Tensor

The `erfinv_` operator.

## `eval`

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

eval(*trees) -> None

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

## `exp`

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

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

exp(input) -> Tensor

The `exp` operator.

## `exp_`

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

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

exp_(self) -> Tensor

The `exp_` operator.

## `expand`

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

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

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

The `expand` operator.

## `expand_as`

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

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

expand_as(input, other) -> Tensor

The `expand_as` operator.

## `exponential_`

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

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

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

The `exponential_` operator.

## `eye`

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

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

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

## `fast_gelu`

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

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

fast_gelu(input) -> Tensor

The `fast_gelu` operator.

## `fill`

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

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

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

The `fill` operator.

## `fill_`

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

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

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

The `fill_` operator.

## `fill_diagonal`

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

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

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

The `fill_diagonal` operator.

## `fill_diagonal_`

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

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

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

The `fill_diagonal_` operator.

## `flatten`

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

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

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

The `flatten` operator.

## `flip`

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

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

flip(input, dims) -> Tensor

The `flip` operator.

## `fliplr`

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

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

fliplr(input) -> Tensor

The `fliplr` operator.

## `flipud`

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

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

flipud(input) -> Tensor

The `flipud` operator.

## `floor`

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

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

floor(input) -> Tensor

The `floor` operator.

## `floor_`

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

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

floor_(self) -> Tensor

The `floor_` operator.

## `floor_divide`

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

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

floor_divide(input, other) -> Tensor

The `floor_divide` operator.

## `floor_divide_`

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

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

floor_divide_(self, other) -> Tensor

The `floor_divide_` operator.

## `fmax`

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

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

fmax(input, other) -> Tensor

The `fmax` operator.

## `fmin`

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

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

fmin(input, other) -> Tensor

The `fmin` operator.

## `fmod`

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

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

fmod(input, other) -> Tensor

The `fmod` operator.

## `fmod_`

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

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

fmod_(self, other) -> Tensor

The `fmod_` operator.

## `fold`

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

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

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

The `fold` operator.

## `frac`

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

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

frac(input) -> Tensor

The `frac` operator.

## `frac_`

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

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

frac_(self) -> Tensor

The `frac_` operator.

## `frexp`

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

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

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

The `frexp` operator.

## `from_dlpack`

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

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

from_dlpack(array) -> Tensor

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

## `from_numpy`

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

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

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

## `full`

```python
full(size: 'Sequence[int] | int', fill_value: 'Number', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

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

A tensor filled with ``fill_value``. Without ``dtype`` the fill value
picks the type: a bool fills a ``bool`` tensor, an int an ``int64`` one,
a float one of the default dtype.

## `full_like`

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

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

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

## `gated_delta_update`

```python
gated_delta_updategated_delta_update(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, beta: clika_runtime._core.Tensor, gate: clika_runtime._core.Tensor, state: clika_runtime._core.Tensor, seq_lens: clika_runtime._core.Tensor | None = None, slot_ids: clika_runtime._core.Tensor | None = None, scale: float | None = None, gate_bias: clika_runtime._core.Tensor | None = None, gate_scale: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

gated_delta_update(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, beta: clika_runtime._core.Tensor, gate: clika_runtime._core.Tensor, state: clika_runtime._core.Tensor, seq_lens: clika_runtime._core.Tensor | None = None, slot_ids: clika_runtime._core.Tensor | None = None, scale: float | None = None, gate_bias: clika_runtime._core.Tensor | None = None, gate_scale: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

gated_delta_update(query, key, value, beta, gate, state, seq_lens=None, slot_ids=None, scale=None, gate_bias=None, gate_scale=None) -> Tensor

The `gated_delta_update` operator.

## `gated_rms_norm`

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

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

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

The `gated_rms_norm` operator.

## `gather`

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

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

gather(input, dim, index) -> Tensor

The `gather` operator.

## `ge`

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

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

ge(input, other) -> Tensor

The `ge` operator.

## `ge_`

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

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

ge_(self, other) -> Tensor

The `ge_` operator.

## `geglu`

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

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

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

The `geglu` operator.

## `gelu`

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

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

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

The `gelu` operator.

## `gelu_`

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

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

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

The `gelu_` operator.

## `generate_rotary_cache`

```python
generate_rotary_cachegenerate_rotary_cache(rotary_dim: int, max_positions: int, theta: float | None = None, scaling: object | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...), yarn_truncate: bool | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

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

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

The `generate_rotary_cache` operator.

## `get_default_dtype`

```python
get_default_dtype() -> 'Dtype'
```

get_default_dtype() -> dtype

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

## `get_device_properties`

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

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

Overloaded function.

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

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

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

get_device_properties(device) -> DeviceProperties

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

## `get_printoptions`

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

get_printoptions() -> dict

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

## `glu`

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

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

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

The `glu` operator.

## `grid_sample`

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

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

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

The `grid_sample` operator.

## `group_norm`

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

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

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

The `group_norm` operator.

## `group_query_attention`

```python
group_query_attentiongroup_query_attention(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, past_key: clika_runtime._core.Tensor | None = None, past_value: clika_runtime._core.Tensor | None = None, kvcache_start: clika_runtime._core.Tensor | None = None, rope_cos: clika_runtime._core.Tensor | None = None, rope_sin: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: object | None = None, num_heads: int | None = None, kv_num_heads: int | None = None, out_present_key: clika_runtime._core.Tensor | None = None, out_present_value: clika_runtime._core.Tensor | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), head_sink: clika_runtime._core.Tensor | None = None, q_norm_gain: clika_runtime._core.Tensor | None = None, k_norm_gain: clika_runtime._core.Tensor | None = None, qk_norm_eps: float | None = None, slot_ids: clika_runtime._core.Tensor | None = None, kept_prefix: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

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

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

The `group_query_attention` operator.

## `group_query_attention_varlen`

```python
group_query_attention_varlengroup_query_attention_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), past_key: clika_runtime._core.Tensor | None = None, past_value: clika_runtime._core.Tensor | None = None, kvcache_start: clika_runtime._core.Tensor | None = None, rope_cos: clika_runtime._core.Tensor | None = None, rope_sin: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, attn_mask: clika_runtime._core.Tensor | None = None, head_sink: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: object | None = None, num_heads: int | None = None, kv_num_heads: int | None = None, out_present_key: clika_runtime._core.Tensor | None = None, out_present_value: clika_runtime._core.Tensor | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), q_norm_gain: clika_runtime._core.Tensor | None = None, k_norm_gain: clika_runtime._core.Tensor | None = None, qk_norm_eps: float | None = None, slot_ids: clika_runtime._core.Tensor | None = None, kept_prefix: clika_runtime._core.Tensor | None = None, kv_position_offset: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

group_query_attention_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), past_key: clika_runtime._core.Tensor | None = None, past_value: clika_runtime._core.Tensor | None = None, kvcache_start: clika_runtime._core.Tensor | None = None, rope_cos: clika_runtime._core.Tensor | None = None, rope_sin: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, attn_mask: clika_runtime._core.Tensor | None = None, head_sink: clika_runtime._core.Tensor | None = None, is_causal: bool | None = None, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), softcap: float | None = None, sliding_window: int | None = None, smooth_softmax: bool | None = None, rotary_mode: object | None = None, num_heads: int | None = None, kv_num_heads: int | None = None, out_present_key: clika_runtime._core.Tensor | None = None, out_present_value: clika_runtime._core.Tensor | None = None, k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), q_norm_gain: clika_runtime._core.Tensor | None = None, k_norm_gain: clika_runtime._core.Tensor | None = None, qk_norm_eps: float | None = None, slot_ids: clika_runtime._core.Tensor | None = None, kept_prefix: clika_runtime._core.Tensor | None = None, kv_position_offset: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

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

The `group_query_attention_varlen` operator.

## `gt`

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

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

gt(input, other) -> Tensor

The `gt` operator.

## `gt_`

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

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

gt_(self, other) -> Tensor

The `gt_` operator.

## `hardshrink`

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

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

hardshrink(input, lambd=0.5) -> Tensor

The `hardshrink` operator.

## `hardshrink_`

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

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

hardshrink_(self, lambd=0.5) -> Tensor

The `hardshrink_` operator.

## `hardsigmoid`

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

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

hardsigmoid(input) -> Tensor

The `hardsigmoid` operator.

## `hardsigmoid_`

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

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

hardsigmoid_(self) -> Tensor

The `hardsigmoid_` operator.

## `hardswish`

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

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

hardswish(input) -> Tensor

The `hardswish` operator.

## `hardswish_`

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

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

hardswish_(self) -> Tensor

The `hardswish_` operator.

## `hardtanh`

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

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

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

The `hardtanh` operator.

## `hardtanh_`

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

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

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

The `hardtanh_` operator.

## `hash_128`

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

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

hash_128(input, seed=0) -> Tensor

The `hash_128` operator.

## `hash_256`

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

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

hash_256(input, seed=0) -> Tensor

The `hash_256` operator.

## `hash_64`

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

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

hash_64(input, seed=0) -> Tensor

The `hash_64` operator.

## `hash_chain`

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

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

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

The `hash_chain` operator.

## `hash_lanes`

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

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

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

The `hash_lanes` operator.

## `hash_tensor`

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

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

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

The `hash_tensor` operator.

## `histogram`

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

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

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

The `histogram` operator.

## `huber_loss`

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

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

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

The `huber_loss` operator.

## `hypot`

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

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

hypot(input, other) -> Tensor

The `hypot` operator.

## `hypot_`

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

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

hypot_(self, other) -> Tensor

The `hypot_` operator.

## `index`

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

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

index(input, indices) -> Tensor

The `index` operator.

## `index_add`

```python
index_addindex_add(input: clika_runtime._core.Tensor, dim: int, indices: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

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

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

The `index_add` operator.

## `index_add_`

```python
index_add_index_add_(self: clika_runtime._core.Tensor, dim: int, indices: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

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

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

The `index_add_` operator.

## `index_copy`

```python
index_copyindex_copy(input: clika_runtime._core.Tensor, dim: int, indices: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

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

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

The `index_copy` operator.

## `index_copy_`

```python
index_copy_index_copy_(self: clika_runtime._core.Tensor, dim: int, indices: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

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

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

The `index_copy_` operator.

## `index_fill`

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

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

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

The `index_fill` operator.

## `index_fill_`

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

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

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

The `index_fill_` operator.

## `index_put`

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

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

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

The `index_put` operator.

## `index_put_`

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

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

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

The `index_put_` operator.

## `index_select`

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

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

index_select(input, dim, index) -> Tensor

The `index_select` operator.

## `inner`

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

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

inner(input, other) -> Tensor

The `inner` operator.

## `instance_norm`

```python
instance_norminstance_norm(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, running_mean: clika_runtime._core.Tensor | None = None, running_var: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor
```

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

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

The `instance_norm` operator.

## `interpolate`

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

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

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

The `interpolate` operator.

## `is_available`

```python
is_availableis_available(kind: object) -> bool
```

is_available(kind: object) -> bool

is_available(kind) -> bool

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

## `is_meta_init`

```python
is_meta_init() -> 'bool'
```

is_meta_init() -> bool

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

## `isclose`

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

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

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

The `isclose` operator.

## `isfinite`

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

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

isfinite(input) -> Tensor

The `isfinite` operator.

## `isinf`

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

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

isinf(input) -> Tensor

The `isinf` operator.

## `isnan`

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

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

isnan(input) -> Tensor

The `isnan` operator.

## `isneginf`

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

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

isneginf(input) -> Tensor

The `isneginf` operator.

## `isposinf`

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

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

isposinf(input) -> Tensor

The `isposinf` operator.

## `kl_div`

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

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

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

The `kl_div` operator.

## `kron`

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

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

kron(input, other) -> Tensor

The `kron` operator.

## `kthvalue`

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

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

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

The `kthvalue` operator.

## `l1_loss`

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

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

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

The `l1_loss` operator.

## `layer_norm`

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

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

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

The `layer_norm` operator.

## `le`

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

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

le(input, other) -> Tensor

The `le` operator.

## `le_`

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

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

le_(self, other) -> Tensor

The `le_` operator.

## `leaky_relu`

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

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

leaky_relu(input, negative_slope=0.01) -> Tensor

The `leaky_relu` operator.

## `leaky_relu_`

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

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

leaky_relu_(self, negative_slope=0.01) -> Tensor

The `leaky_relu_` operator.

## `linear`

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

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

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

The `linear` operator.

## `linspace`

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

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

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

## `load`

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

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

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

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

## `load_with_metadata`

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

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

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

## `log`

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

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

log(input) -> Tensor

The `log` operator.

## `log10`

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

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

log10(input) -> Tensor

The `log10` operator.

## `log10_`

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

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

log10_(self) -> Tensor

The `log10_` operator.

## `log1p`

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

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

log1p(input) -> Tensor

The `log1p` operator.

## `log1p_`

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

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

log1p_(self) -> Tensor

The `log1p_` operator.

## `log2`

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

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

log2(input) -> Tensor

The `log2` operator.

## `log2_`

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

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

log2_(self) -> Tensor

The `log2_` operator.

## `log_`

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

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

log_(self) -> Tensor

The `log_` operator.

## `log_sigmoid`

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

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

log_sigmoid(input) -> Tensor

The `log_sigmoid` operator.

## `log_sigmoid_`

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

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

log_sigmoid_(self) -> Tensor

The `log_sigmoid_` operator.

## `log_softmax`

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

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

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

The `log_softmax` operator.

## `log_softmax_`

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

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

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

The `log_softmax_` operator.

## `logaddexp`

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

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

logaddexp(input, other) -> Tensor

The `logaddexp` operator.

## `logaddexp2`

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

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

logaddexp2(input, other) -> Tensor

The `logaddexp2` operator.

## `logical_and`

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

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

logical_and(input, other) -> Tensor

The `logical_and` operator.

## `logical_and_`

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

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

logical_and_(self, other) -> Tensor

The `logical_and_` operator.

## `logical_not`

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

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

logical_not(input) -> Tensor

The `logical_not` operator.

## `logical_not_`

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

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

logical_not_(self) -> Tensor

The `logical_not_` operator.

## `logical_or`

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

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

logical_or(input, other) -> Tensor

The `logical_or` operator.

## `logical_or_`

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

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

logical_or_(self, other) -> Tensor

The `logical_or_` operator.

## `logical_xor`

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

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

logical_xor(input, other) -> Tensor

The `logical_xor` operator.

## `logical_xor_`

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

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

logical_xor_(self, other) -> Tensor

The `logical_xor_` operator.

## `logit`

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

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

logit(input, eps=None) -> Tensor

The `logit` operator.

## `logit_`

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

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

logit_(self, eps=None) -> Tensor

The `logit_` operator.

## `logsumexp`

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

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

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

The `logsumexp` operator.

## `lt`

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

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

lt(input, other) -> Tensor

The `lt` operator.

## `lt_`

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

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

lt_(self, other) -> Tensor

The `lt_` operator.

## `make_quantized`

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

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

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

## `make_quantized_affine`

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

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

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

## `manual_seed`

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

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

manual_seed(seed, device=None) -> None

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

## `masked_fill`

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

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

masked_fill(input, mask, value) -> Tensor

The `masked_fill` operator.

## `masked_fill_`

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

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

masked_fill_(self, mask, value) -> Tensor

The `masked_fill_` operator.

## `masked_scatter`

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

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

masked_scatter(input, mask, source) -> Tensor

The `masked_scatter` operator.

## `masked_scatter_`

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

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

masked_scatter_(self, mask, source) -> Tensor

The `masked_scatter_` operator.

## `masked_select`

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

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

masked_select(input, mask) -> Tensor

The `masked_select` operator.

## `matmul`

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

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

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

The `matmul` operator.

## `max`

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

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

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

The `max` operator.

## `max_pool`

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

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

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

The `max_pool` operator.

## `max_pool1d`

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

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

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

The `max_pool1d` operator.

## `max_pool1d_with_indices`

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

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

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

The `max_pool1d_with_indices` operator.

## `max_pool2d`

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

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

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

The `max_pool2d` operator.

## `max_pool2d_with_indices`

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

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

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

The `max_pool2d_with_indices` operator.

## `max_pool3d`

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

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

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

The `max_pool3d` operator.

## `max_pool3d_with_indices`

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

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

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

The `max_pool3d_with_indices` operator.

## `max_pool_with_indices`

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

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

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

The `max_pool_with_indices` operator.

## `maximum`

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

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

maximum(input, other) -> Tensor

The `maximum` operator.

## `maximum_`

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

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

maximum_(self, other) -> Tensor

The `maximum_` operator.

## `mean`

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

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

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

The `mean` operator.

## `median`

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

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

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

The `median` operator.

## `memory_stats`

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

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

memory_stats(device) -> MemoryStats

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

## `meshgrid`

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

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

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

The `meshgrid` operator.

## `meta_init`

```python
meta_init() -> '_MetaInitScope'
```

meta_init() -> a construction region

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

## `min`

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

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

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

The `min` operator.

## `minimum`

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

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

minimum(input, other) -> Tensor

The `minimum` operator.

## `minimum_`

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

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

minimum_(self, other) -> Tensor

The `minimum_` operator.

## `mish`

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

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

mish(input) -> Tensor

The `mish` operator.

## `mish_`

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

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

mish_(self) -> Tensor

The `mish_` operator.

## `mla_attention`

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

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

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

The `mla_attention` operator.

## `mm`

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

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

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

The `mm` operator.

## `mod`

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

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

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

The `mod` operator.

## `mod_`

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

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

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

The `mod_` operator.

## `moe`

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

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

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

The `moe` operator.

## `mrope_rotary_embedding`

```python
mrope_rotary_embeddingmrope_rotary_embedding(input: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor, mrope_sections: collections.abc.Sequence[int], interleaved_sections: bool | None = None, theta: float | None = None, scaling: object | None = None, mode: object | None = None, rotary_dim: int | None = None, scale: float | None = None) -> clika_runtime._core.Tensor
```

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

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

The `mrope_rotary_embedding` operator.

## `mrope_rotary_embedding_qk_varlen`

```python
mrope_rotary_embedding_qk_varlenmrope_rotary_embedding_qk_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor, mrope_sections: collections.abc.Sequence[int], interleaved_sections: bool | None = None, theta: float | None = None, scaling: object | None = None, mode: object | None = None, rotary_dim: int | None = None, scale: float | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

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

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

The `mrope_rotary_embedding_qk_varlen` operator.

## `mrope_rotary_embedding_varlen`

```python
mrope_rotary_embedding_varlenmrope_rotary_embedding_varlen(input: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor, mrope_sections: collections.abc.Sequence[int], interleaved_sections: bool | None = None, theta: float | None = None, scaling: object | None = None, mode: object | None = None, rotary_dim: int | None = None, scale: float | None = None) -> clika_runtime._core.Tensor
```

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

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

The `mrope_rotary_embedding_varlen` operator.

## `ms_deform_attention`

```python
ms_deform_attentionms_deform_attention(value: clika_runtime._core.Tensor, spatial_shapes: clika_runtime._core.Tensor, level_start_index: clika_runtime._core.Tensor, sampling_locations: clika_runtime._core.Tensor, attention_weights: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

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

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

The `ms_deform_attention` operator.

## `mse_loss`

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

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

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

The `mse_loss` operator.

## `mul`

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

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

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

The `mul` operator.

## `mul_`

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

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

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

The `mul_` operator.

## `multinomial`

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

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

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

The `multinomial` operator.

## `mv`

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

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

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

The `mv` operator.

## `nan_to_num`

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

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

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

The `nan_to_num` operator.

## `nan_to_num_`

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

nan_to_num_(self: clika_runtime._core.Tensor, nan: float | None = None, posinf: float | None = None, neginf: float | None = None) -> clika_runtime._core.Tensor

nan_to_num_(self, nan=None, posinf=None, neginf=None) -> Tensor

The `nan_to_num_` operator.

## `nanmean`

```python
nanmeannanmean(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor
```

nanmean(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor

nanmean(input, dims=[], keepdim=False) -> Tensor

The `nanmean` operator.

## `nanmedian`

```python
nanmediannanmedian(input: clika_runtime._core.Tensor, dim: int | None = None, keepdim: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

nanmedian(input: clika_runtime._core.Tensor, dim: int | None = None, keepdim: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

nanmedian(input, dim=None, keepdim=False) -> tuple[Tensor, Tensor]

The `nanmedian` operator.

## `nanquantile`

```python
nanquantilenanquantile(input: clika_runtime._core.Tensor, q: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, keepdim: bool = False, interpolation: object = 'linear') -> clika_runtime._core.Tensor
```

nanquantile(input: clika_runtime._core.Tensor, q: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, keepdim: bool = False, interpolation: object = 'linear') -> clika_runtime._core.Tensor

nanquantile(input, q, dim=None, keepdim=False, interpolation='linear') -> Tensor

The `nanquantile` operator.

## `nansum`

```python
nansumnansum(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor
```

nansum(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor

nansum(input, dims=[], keepdim=False) -> Tensor

The `nansum` operator.

## `narrow`

```python
narrownarrow(input: clika_runtime._core.Tensor, dim: int, start: clika_runtime._core.ops.IndexBound, length: clika_runtime._core.ops.IndexBound) -> clika_runtime._core.Tensor
```

narrow(input: clika_runtime._core.Tensor, dim: int, start: clika_runtime._core.ops.IndexBound, length: clika_runtime._core.ops.IndexBound) -> clika_runtime._core.Tensor

narrow(input, dim, start, length) -> Tensor

The `narrow` operator.

## `ndim`

```python
ndimndim(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

ndim(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

ndim(input) -> Tensor

The `ndim` operator.

## `ndim_host`

```python
ndim_hostndim_host(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

ndim_host(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

ndim_host(input) -> Tensor

The `ndim_host` operator.

## `ne`

```python
nene(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

ne(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

ne(input, other) -> Tensor

The `ne` operator.

## `ne_`

```python
ne_ne_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

ne_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

ne_(self, other) -> Tensor

The `ne_` operator.

## `neg`

```python
negneg(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

neg(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

neg(input) -> Tensor

The `neg` operator.

## `neg_`

```python
neg_neg_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

neg_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

neg_(self) -> Tensor

The `neg_` operator.

## `nll_loss`

```python
nll_lossnll_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, ignore_index: int | None = None, reduction: object = 'mean') -> clika_runtime._core.Tensor
```

nll_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None, ignore_index: int | None = None, reduction: object = 'mean') -> clika_runtime._core.Tensor

nll_loss(input, target, weight=None, ignore_index=None, reduction='mean') -> Tensor

The `nll_loss` operator.

## `nms`

```python
nmsnms(boxes: clika_runtime._core.Tensor, scores: clika_runtime._core.Tensor, max_output_boxes_per_class: clika_runtime._core.ops.ScalarOrTensor | None = None, iou_threshold: clika_runtime._core.ops.ScalarOrTensor | None = None, score_threshold: clika_runtime._core.ops.ScalarOrTensor | None = None, center_point_box: bool = False) -> clika_runtime._core.Tensor
```

nms(boxes: clika_runtime._core.Tensor, scores: clika_runtime._core.Tensor, max_output_boxes_per_class: clika_runtime._core.ops.ScalarOrTensor | None = None, iou_threshold: clika_runtime._core.ops.ScalarOrTensor | None = None, score_threshold: clika_runtime._core.ops.ScalarOrTensor | None = None, center_point_box: bool = False) -> clika_runtime._core.Tensor

nms(boxes, scores, max_output_boxes_per_class=None, iou_threshold=None, score_threshold=None, center_point_box=False) -> Tensor

The `nms` operator.

## `nonzero`

```python
nonzerononzero(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

nonzero(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

nonzero(input) -> Tensor

The `nonzero` operator.

## `norm`

```python
normnorm(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...), dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor
```

norm(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...), dims: collections.abc.Sequence[int] = [], keepdim: bool = False) -> clika_runtime._core.Tensor

norm(input, p=2.0, dims=[], keepdim=False) -> Tensor

The `norm` operator.

## `normal`

```python
normalnormal(mean: clika_runtime._core.ops.ScalarOrTensor, stddev: clika_runtime._core.ops.ScalarOrTensor, shape: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor
```

normal(mean: clika_runtime._core.ops.ScalarOrTensor, stddev: clika_runtime._core.ops.ScalarOrTensor, shape: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

normal(mean, stddev, shape, *, device=None) -> Tensor

The `normal` operator.

## `normal_`

```python
normal_normal_(self: clika_runtime._core.Tensor, mean: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), stddev: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor
```

normal_(self: clika_runtime._core.Tensor, mean: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), stddev: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

normal_(self, mean=0, stddev=1, *, device=None) -> Tensor

The `normal_` operator.

## `normalize`

```python
normalizenormalize(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...), dim: int = 1, eps: float | None = None) -> clika_runtime._core.Tensor
```

normalize(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...), dim: int = 1, eps: float | None = None) -> clika_runtime._core.Tensor

normalize(input, p=2.0, dim=1, eps=None) -> Tensor

The `normalize` operator.

## `normalize_`

```python
normalize_normalize_(self: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...), dim: int = 1, eps: float | None = None) -> clika_runtime._core.Tensor
```

normalize_(self: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...), dim: int = 1, eps: float | None = None) -> clika_runtime._core.Tensor

normalize_(self, p=2.0, dim=1, eps=None) -> Tensor

The `normalize_` operator.

## `numel`

```python
numelnumel(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

numel(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

numel(input) -> Tensor

The `numel` operator.

## `numel_host`

```python
numel_hostnumel_host(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

numel_host(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

numel_host(input) -> Tensor

The `numel_host` operator.

## `one_hot`

```python
one_hotone_hot(indices: clika_runtime._core.Tensor, num_classes: int) -> clika_runtime._core.Tensor
```

one_hot(indices: clika_runtime._core.Tensor, num_classes: int) -> clika_runtime._core.Tensor

one_hot(indices, num_classes) -> Tensor

The `one_hot` operator.

## `ones`

```python
ones(*size: 'ShapeDim', dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

ones(*size, dtype=None, device=None) -> Tensor

A one-filled tensor; the default dtype unless ``dtype`` says otherwise.

## `ones_like`

```python
ones_like(input: 'Tensor', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

ones_like(input, *, dtype=None, device=None) -> Tensor

A one-filled tensor of ``input``'s shape, dtype and device, each
overridable by keyword.

## `outer`

```python
outerouter(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

outer(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

outer(input, other) -> Tensor

The `outer` operator.

## `pad`

```python
padpad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], mode: object = 'constant', value: clika_runtime._core.ops.ScalarOrTensor | None = None) -> clika_runtime._core.Tensor
```

pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], mode: object = 'constant', value: clika_runtime._core.ops.ScalarOrTensor | None = None) -> clika_runtime._core.Tensor

pad(input, pad, mode='constant', value=None) -> Tensor

The `pad` operator.

## `pairwise_distance`

```python
pairwise_distancepairwise_distance(x1: clika_runtime._core.Tensor, x2: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...), eps: float | None = None, keepdim: bool = False) -> clika_runtime._core.Tensor
```

pairwise_distance(x1: clika_runtime._core.Tensor, x2: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...), eps: float | None = None, keepdim: bool = False) -> clika_runtime._core.Tensor

pairwise_distance(x1, x2, p=2.0, eps=None, keepdim=False) -> Tensor

The `pairwise_distance` operator.

## `pdist`

```python
pdistpdist(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...)) -> clika_runtime._core.Tensor
```

pdist(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar = Scalar(...)) -> clika_runtime._core.Tensor

pdist(input, p=2.0) -> Tensor

The `pdist` operator.

## `permute`

```python
permutepermute(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor
```

permute(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor

permute(input, dims) -> Tensor

The `permute` operator.

## `pixel_shuffle`

```python
pixel_shufflepixel_shuffle(input: clika_runtime._core.Tensor, upscale_factor: int, mode: object = 'crd') -> clika_runtime._core.Tensor
```

pixel_shuffle(input: clika_runtime._core.Tensor, upscale_factor: int, mode: object = 'crd') -> clika_runtime._core.Tensor

pixel_shuffle(input, upscale_factor, mode='crd') -> Tensor

The `pixel_shuffle` operator.

## `pixel_unshuffle`

```python
pixel_unshufflepixel_unshuffle(input: clika_runtime._core.Tensor, downscale_factor: int, mode: object = 'crd') -> clika_runtime._core.Tensor
```

pixel_unshuffle(input: clika_runtime._core.Tensor, downscale_factor: int, mode: object = 'crd') -> clika_runtime._core.Tensor

pixel_unshuffle(input, downscale_factor, mode='crd') -> Tensor

The `pixel_unshuffle` operator.

## `poisson`

```python
poissonpoisson(rates: clika_runtime._core.Tensor, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor
```

poisson(rates: clika_runtime._core.Tensor, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

poisson(rates, *, device=None) -> Tensor

The `poisson` operator.

## `pow`

```python
powpow(input: clika_runtime._core.Tensor, exponent: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

pow(input: clika_runtime._core.Tensor, exponent: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

pow(input, exponent) -> Tensor

The `pow` operator.

## `pow_`

```python
pow_pow_(self: clika_runtime._core.Tensor, exponent: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

pow_(self: clika_runtime._core.Tensor, exponent: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

pow_(self, exponent) -> Tensor

The `pow_` operator.

## `prelu`

```python
preluprelu(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

prelu(input: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

prelu(input, weight=None) -> Tensor

The `prelu` operator.

## `prelu_`

```python
prelu_prelu_(self: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

prelu_(self: clika_runtime._core.Tensor, weight: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

prelu_(self, weight=None) -> Tensor

The `prelu_` operator.

## `prod`

```python
prodprod(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor
```

prod(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

prod(input, dims=[], keepdim=False, *, dtype=Undefined) -> Tensor

The `prod` operator.

## `put`

```python
putput(input: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor, source: clika_runtime._core.Tensor, accumulate: bool = False) -> clika_runtime._core.Tensor
```

put(input: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor, source: clika_runtime._core.Tensor, accumulate: bool = False) -> clika_runtime._core.Tensor

put(input, index, source, accumulate=False) -> Tensor

The `put` operator.

## `put_`

```python
put_put_(self: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor, source: clika_runtime._core.Tensor, accumulate: bool = False) -> clika_runtime._core.Tensor
```

put_(self: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor, source: clika_runtime._core.Tensor, accumulate: bool = False) -> clika_runtime._core.Tensor

put_(self, index, source, accumulate=False) -> Tensor

The `put_` operator.

## `q_embedding`

```python
q_embeddingq_embedding(indices: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor
```

q_embedding(indices: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

q_embedding(indices, weight, bias=None, *, activation=None, out_dtype=Undefined) -> Tensor

The `q_embedding` operator.

## `qadd`

```python
qaddqadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: object | None = 'identity') -> clika_runtime._core.QTensor

Overloaded function.

1. ``qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qadd(input, other, *, activation='identity') -> Tensor

The `qadd` operator.

2. ``qadd(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qadd(input, other, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined, activation='identity') -> QTensor

The `qadd` operator.

## `qadd_`

```python
qadd_qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
```

qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

Overloaded function.

1. ``qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qadd_(input, other, out, *, activation='identity') -> QTensor

The `qadd_` operator.

2. ``qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qadd_(input, other, out, *, activation='identity') -> Tensor

The `qadd_` operator.

3. ``qadd_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qadd_(input, other, out, out_scale, out_zero_point=None, out_quant_axis=-1, *, activation='identity') -> Tensor

The `qadd_` operator.

## `qconcat`

```python
qconcatqconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int = 0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int = 0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: object | None = 'identity') -> clika_runtime._core.QTensor

Overloaded function.

1. ``qconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int = 0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconcat(tensors, dim=0, *, activation='identity') -> Tensor

The `qconcat` operator.

2. ``qconcat(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qconcat(tensors, dim, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined, activation='identity') -> QTensor

The `qconcat` operator.

## `qconcat_`

```python
qconcat_qconcat_(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
```

qconcat_(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
qconcat_(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

Overloaded function.

1. ``qconcat_(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qconcat_(tensors, dim, out, *, activation='identity') -> QTensor

The `qconcat_` operator.

2. ``qconcat_(tensors: collections.abc.Sequence[clika_runtime._core.QTensor], dim: int, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconcat_(tensors, dim, out, out_scale, out_zero_point=None, out_quant_axis=-1, *, activation='identity') -> Tensor

The `qconcat_` operator.

## `qconv`

```python
qconvqconv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qconv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, mode: object, value: float | None, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qconv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv(input, weight, bias=None, stride=[], padding=[], dilation=[], groups=1, mode='constant', value=None, *, activation='identity') -> Tensor

The `qconv` operator.

2. ``qconv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, mode: object, value: float | None, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qconv(input, weight, bias, stride, padding, dilation, groups, mode, value, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qconv` operator.

## `qconv1d`

```python
qconv1dqconv1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qconv1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qconv1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv1d(input, weight, bias=None, stride=[1], padding=[0], dilation=[1], groups=1, *, activation='identity') -> Tensor

The `qconv1d` operator.

2. ``qconv1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qconv1d(input, weight, bias, stride, padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qconv1d` operator.

## `qconv1d_woq`

```python
qconv1d_woqqconv1d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv1d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qconv1d_woq(input, weight, bias=None, stride=[1], padding=[0], dilation=[1], groups=1, *, activation='identity') -> Tensor

The `qconv1d_woq` operator.

## `qconv2d`

```python
qconv2dqconv2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qconv2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qconv2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv2d(input, weight, bias=None, stride=[1, 1], padding=[0, 0], dilation=[1, 1], groups=1, *, activation='identity') -> Tensor

The `qconv2d` operator.

2. ``qconv2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qconv2d(input, weight, bias, stride, padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qconv2d` operator.

## `qconv2d_woq`

```python
qconv2d_woqqconv2d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv2d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qconv2d_woq(input, weight, bias=None, stride=[1, 1], padding=[0, 0], dilation=[1, 1], groups=1, *, activation='identity') -> Tensor

The `qconv2d_woq` operator.

## `qconv3d`

```python
qconv3dqconv3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qconv3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qconv3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv3d(input, weight, bias=None, stride=[1, 1, 1], padding=[0, 0, 0], dilation=[1, 1, 1], groups=1, *, activation='identity') -> Tensor

The `qconv3d` operator.

2. ``qconv3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qconv3d(input, weight, bias, stride, padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qconv3d` operator.

## `qconv3d_woq`

```python
qconv3d_woqqconv3d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv3d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qconv3d_woq(input, weight, bias=None, stride=[1, 1, 1], padding=[0, 0, 0], dilation=[1, 1, 1], groups=1, *, activation='identity') -> Tensor

The `qconv3d_woq` operator.

## `qconv_`

```python
qconv_qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
```

qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

Overloaded function.

1. ``qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qconv_(input, weight, out, bias=None, stride=[], padding=[], dilation=[], groups=1, mode='constant', value=None, *, activation='identity') -> QTensor

The `qconv_` operator.

2. ``qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv_(input, weight, out, bias=None, stride=[], padding=[], dilation=[], groups=1, mode='constant', value=None, *, activation='identity') -> Tensor

The `qconv_` operator.

3. ``qconv_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv_(input, weight, out, out_scale, out_zero_point, out_quant_axis=-1, bias=None, stride=[], padding=[], dilation=[], groups=1, mode='constant', value=None, *, activation='identity') -> Tensor

The `qconv_` operator.

## `qconv_transpose`

```python
qconv_transposeqconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv_transpose(input, weight, bias=None, stride=[], padding=[], output_padding=[], dilation=[], groups=1, *, activation='identity') -> Tensor

The `qconv_transpose` operator.

2. ``qconv_transpose(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qconv_transpose(input, weight, bias, stride, padding, output_padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qconv_transpose` operator.

## `qconv_transpose1d`

```python
qconv_transpose1dqconv_transpose1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], output_padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv_transpose1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], output_padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qconv_transpose1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qconv_transpose1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], output_padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv_transpose1d(input, weight, bias=None, stride=[1], padding=[0], output_padding=[0], dilation=[1], groups=1, *, activation='identity') -> Tensor

The `qconv_transpose1d` operator.

2. ``qconv_transpose1d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qconv_transpose1d(input, weight, bias, stride, padding, output_padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qconv_transpose1d` operator.

## `qconv_transpose1d_woq`

```python
qconv_transpose1d_woqqconv_transpose1d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], output_padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv_transpose1d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1], padding: collections.abc.Sequence[int] = [0], output_padding: collections.abc.Sequence[int] = [0], dilation: collections.abc.Sequence[int] = [1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qconv_transpose1d_woq(input, weight, bias=None, stride=[1], padding=[0], output_padding=[0], dilation=[1], groups=1, *, activation='identity') -> Tensor

The `qconv_transpose1d_woq` operator.

## `qconv_transpose2d`

```python
qconv_transpose2dqconv_transpose2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], output_padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv_transpose2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], output_padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qconv_transpose2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qconv_transpose2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], output_padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv_transpose2d(input, weight, bias=None, stride=[1, 1], padding=[0, 0], output_padding=[0, 0], dilation=[1, 1], groups=1, *, activation='identity') -> Tensor

The `qconv_transpose2d` operator.

2. ``qconv_transpose2d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qconv_transpose2d(input, weight, bias, stride, padding, output_padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qconv_transpose2d` operator.

## `qconv_transpose2d_woq`

```python
qconv_transpose2d_woqqconv_transpose2d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], output_padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv_transpose2d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1], padding: collections.abc.Sequence[int] = [0, 0], output_padding: collections.abc.Sequence[int] = [0, 0], dilation: collections.abc.Sequence[int] = [1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qconv_transpose2d_woq(input, weight, bias=None, stride=[1, 1], padding=[0, 0], output_padding=[0, 0], dilation=[1, 1], groups=1, *, activation='identity') -> Tensor

The `qconv_transpose2d_woq` operator.

## `qconv_transpose3d`

```python
qconv_transpose3dqconv_transpose3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv_transpose3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qconv_transpose3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qconv_transpose3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv_transpose3d(input, weight, bias=None, stride=[1, 1, 1], padding=[0, 0, 0], output_padding=[0, 0, 0], dilation=[1, 1, 1], groups=1, *, activation='identity') -> Tensor

The `qconv_transpose3d` operator.

2. ``qconv_transpose3d(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], output_padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qconv_transpose3d(input, weight, bias, stride, padding, output_padding, dilation, groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qconv_transpose3d` operator.

## `qconv_transpose3d_woq`

```python
qconv_transpose3d_woqqconv_transpose3d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qconv_transpose3d_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [1, 1, 1], padding: collections.abc.Sequence[int] = [0, 0, 0], output_padding: collections.abc.Sequence[int] = [0, 0, 0], dilation: collections.abc.Sequence[int] = [1, 1, 1], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

qconv_transpose3d_woq(input, weight, bias=None, stride=[1, 1, 1], padding=[0, 0, 0], output_padding=[0, 0, 0], dilation=[1, 1, 1], groups=1, *, activation='identity') -> Tensor

The `qconv_transpose3d_woq` operator.

## `qconv_transpose_`

```python
qconv_transpose_qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
```

qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

Overloaded function.

1. ``qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qconv_transpose_(input, weight, out, bias=None, stride=[], padding=[], output_padding=[], dilation=[], groups=1, *, activation='identity') -> QTensor

The `qconv_transpose_` operator.

2. ``qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv_transpose_(input, weight, out, bias=None, stride=[], padding=[], output_padding=[], dilation=[], groups=1, *, activation='identity') -> Tensor

The `qconv_transpose_` operator.

3. ``qconv_transpose_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qconv_transpose_(input, weight, out, out_scale, out_zero_point, out_quant_axis=-1, bias=None, stride=[], padding=[], output_padding=[], dilation=[], groups=1, *, activation='identity') -> Tensor

The `qconv_transpose_` operator.

## `qconv_transpose_woq`

```python
qconv_transpose_woqqconv_transpose_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity', compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor
```

qconv_transpose_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], output_padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, *, activation: object | None = 'identity', compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qconv_transpose_woq(input, weight, bias=None, stride=[], padding=[], output_padding=[], dilation=[], groups=1, *, activation='identity', compute_mode='exact_fp') -> Tensor

The `qconv_transpose_woq` operator.

## `qconv_woq`

```python
qconv_woqqconv_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity', compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor
```

qconv_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, mode: object = 'constant', value: float | None = None, *, activation: object | None = 'identity', compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qconv_woq(input, weight, bias=None, stride=[], padding=[], dilation=[], groups=1, mode='constant', value=None, *, activation='identity', compute_mode='exact_fp') -> Tensor

The `qconv_woq` operator.

## `qdeform_conv`

```python
qdeform_convqdeform_conv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, offset_groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qdeform_conv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, offset_groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qdeform_conv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, offset_groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qdeform_conv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, offset_groups: int = 1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qdeform_conv(input, weight, offset, mask=None, bias=None, stride=[], padding=[], dilation=[], groups=1, offset_groups=1, *, activation='identity') -> Tensor

The `qdeform_conv` operator.

2. ``qdeform_conv(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None, bias: clika_runtime._core.Tensor | None, stride: collections.abc.Sequence[int], padding: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int], groups: int, offset_groups: int, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qdeform_conv(input, weight, offset, mask, bias, stride, padding, dilation, groups, offset_groups, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qdeform_conv` operator.

## `qdeform_conv_woq`

```python
qdeform_conv_woqqdeform_conv_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, offset_groups: int = 1, *, activation: object | None = 'identity', compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor
```

qdeform_conv_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, offset: clika_runtime._core.Tensor, mask: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, stride: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], dilation: collections.abc.Sequence[int] = [], groups: int = 1, offset_groups: int = 1, *, activation: object | None = 'identity', compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qdeform_conv_woq(input, weight, offset, mask=None, bias=None, stride=[], padding=[], dilation=[], groups=1, offset_groups=1, *, activation='identity', compute_mode='exact_fp') -> Tensor

The `qdeform_conv_woq` operator.

## `qdiv`

```python
qdivqdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: object | None = 'identity') -> clika_runtime._core.QTensor

Overloaded function.

1. ``qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qdiv(input, other, *, activation='identity') -> Tensor

The `qdiv` operator.

2. ``qdiv(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qdiv(input, other, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined, activation='identity') -> QTensor

The `qdiv` operator.

## `qdiv_`

```python
qdiv_qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
```

qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

Overloaded function.

1. ``qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qdiv_(input, other, out, *, activation='identity') -> QTensor

The `qdiv_` operator.

2. ``qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qdiv_(input, other, out, *, activation='identity') -> Tensor

The `qdiv_` operator.

3. ``qdiv_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qdiv_(input, other, out, out_scale, out_zero_point=None, out_quant_axis=-1, *, activation='identity') -> Tensor

The `qdiv_` operator.

## `qfast_gelu`

```python
qfast_geluqfast_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
```

qfast_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
qfast_gelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qfast_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor``

qfast_gelu(input) -> Tensor

The `qfast_gelu` operator.

2. ``qfast_gelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qfast_gelu(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qfast_gelu` operator.

## `qfast_gelu_`

```python
qfast_gelu_qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

qfast_gelu_(input, out) -> QTensor

The `qfast_gelu_` operator.

2. ``qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

qfast_gelu_(input, out) -> Tensor

The `qfast_gelu_` operator.

3. ``qfast_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

qfast_gelu_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `qfast_gelu_` operator.

## `qgelu`

```python
qgeluqgelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
```

qgelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
qgelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qgelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor``

qgelu(input) -> Tensor

The `qgelu` operator.

2. ``qgelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qgelu(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qgelu` operator.

## `qgelu_`

```python
qgelu_qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

qgelu_(input, out) -> QTensor

The `qgelu_` operator.

2. ``qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

qgelu_(input, out) -> Tensor

The `qgelu_` operator.

3. ``qgelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

qgelu_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `qgelu_` operator.

## `qhardsigmoid`

```python
qhardsigmoidqhardsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
```

qhardsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
qhardsigmoid(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qhardsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor``

qhardsigmoid(input) -> Tensor

The `qhardsigmoid` operator.

2. ``qhardsigmoid(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qhardsigmoid(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qhardsigmoid` operator.

## `qhardsigmoid_`

```python
qhardsigmoid_qhardsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

qhardsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
qhardsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
qhardsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qhardsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

qhardsigmoid_(input, out) -> QTensor

The `qhardsigmoid_` operator.

2. ``qhardsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

qhardsigmoid_(input, out) -> Tensor

The `qhardsigmoid_` operator.

3. ``qhardsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

qhardsigmoid_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `qhardsigmoid_` operator.

## `qhardswish`

```python
qhardswishqhardswish(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
```

qhardswish(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
qhardswish(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qhardswish(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor``

qhardswish(input) -> Tensor

The `qhardswish` operator.

2. ``qhardswish(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qhardswish(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qhardswish` operator.

## `qhardswish_`

```python
qhardswish_qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

qhardswish_(input, out) -> QTensor

The `qhardswish_` operator.

2. ``qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

qhardswish_(input, out) -> Tensor

The `qhardswish_` operator.

3. ``qhardswish_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

qhardswish_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `qhardswish_` operator.

## `qk_layer_norm`

```python
qk_layer_normqk_layer_norm(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, query_bias: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, key_bias: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

qk_layer_norm(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, query_bias: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, key_bias: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

qk_layer_norm(query, key=None, value=None, query_weight=None, query_bias=None, key_weight=None, key_bias=None, head_dim=0, eps=None) -> tuple[Tensor, Tensor, Tensor]

The `qk_layer_norm` operator.

## `qk_layer_norm_`

```python
qk_layer_norm_qk_layer_norm_(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, query_bias: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, key_bias: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> clika_runtime._core.Tensor
```

qk_layer_norm_(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, query_bias: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, key_bias: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> clika_runtime._core.Tensor

qk_layer_norm_(query, key=None, value=None, query_weight=None, query_bias=None, key_weight=None, key_bias=None, head_dim=0, eps=None) -> Tensor

The `qk_layer_norm_` operator.

## `qk_rms_norm`

```python
qk_rms_normqk_rms_norm(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

qk_rms_norm(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

qk_rms_norm(query, key=None, value=None, query_weight=None, key_weight=None, head_dim=0, eps=None) -> tuple[Tensor, Tensor, Tensor]

The `qk_rms_norm` operator.

## `qk_rms_norm_`

```python
qk_rms_norm_qk_rms_norm_(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> clika_runtime._core.Tensor
```

qk_rms_norm_(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor | None = None, value: clika_runtime._core.Tensor | None = None, query_weight: clika_runtime._core.Tensor | None = None, key_weight: clika_runtime._core.Tensor | None = None, head_dim: int = 0, eps: float | None = None) -> clika_runtime._core.Tensor

qk_rms_norm_(query, key=None, value=None, query_weight=None, key_weight=None, head_dim=0, eps=None) -> Tensor

The `qk_rms_norm_` operator.

## `qleaky_relu`

```python
qleaky_reluqleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float = 0.01) -> clika_runtime._core.Tensor
```

qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float = 0.01) -> clika_runtime._core.Tensor
qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float = 0.01) -> clika_runtime._core.Tensor``

qleaky_relu(input, negative_slope=0.01) -> Tensor

The `qleaky_relu` operator.

2. ``qleaky_relu(input: clika_runtime._core.QTensor, negative_slope: float, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qleaky_relu(input, negative_slope, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qleaky_relu` operator.

## `qleaky_relu_`

```python
qleaky_relu_qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

qleaky_relu_(input, negative_slope, out) -> QTensor

The `qleaky_relu_` operator.

2. ``qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

qleaky_relu_(input, negative_slope, out) -> Tensor

The `qleaky_relu_` operator.

3. ``qleaky_relu_(input: clika_runtime._core.QTensor, negative_slope: float, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

qleaky_relu_(input, negative_slope, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `qleaky_relu_` operator.

## `qlinear`

```python
qlinearqlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor
```

qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor
qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor``

qlinear(input, weight, bias=None, *, activation=None) -> Tensor

The `qlinear` operator.

2. ``qlinear(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, activation: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qlinear(input, weight, bias, activation, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qlinear` operator.

## `qlinear_`

```python
qlinear_qlinear_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.QTensor
```

qlinear_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.QTensor
qlinear_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qlinear_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.QTensor``

qlinear_(input, weight, out, bias=None, *, activation=None) -> QTensor

The `qlinear_` operator.

2. ``qlinear_(input: clika_runtime._core.QTensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor``

qlinear_(input, weight, out, bias=None, *, activation=None) -> Tensor

The `qlinear_` operator.

## `qlinear_woq`

```python
qlinear_woqqlinear_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor
```

qlinear_woq(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qlinear_woq(input, weight, bias=None, *, activation=None, compute_mode='exact_fp') -> Tensor

The `qlinear_woq` operator.

## `qlinear_woq_`

```python
qlinear_woq_qlinear_woq_(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor
```

qlinear_woq_(input: clika_runtime._core.Tensor, weight: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qlinear_woq_(input, weight, out, bias=None, *, activation=None, compute_mode='exact_fp') -> Tensor

The `qlinear_woq_` operator.

## `qmatmul`

```python
qmatmulqmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor
```

qmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor
qmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, activation: object, transpose_a: bool, transpose_b: bool, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor``

qmatmul(input, other, bias=None, *, activation=None, transpose_a=False, transpose_b=False) -> Tensor

The `qmatmul` operator.

2. ``qmatmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None, activation: object, transpose_a: bool, transpose_b: bool, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qmatmul(input, other, bias, activation, transpose_a, transpose_b, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qmatmul` operator.

## `qmatmul_`

```python
qmatmul_qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.QTensor
```

qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.QTensor
qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor
qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.QTensor``

qmatmul_(input, other, out, bias=None, *, activation=None, transpose_a=False, transpose_b=False) -> QTensor

The `qmatmul_` operator.

2. ``qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor``

qmatmul_(input, other, out, bias=None, *, activation=None, transpose_a=False, transpose_b=False) -> Tensor

The `qmatmul_` operator.

3. ``qmatmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False) -> clika_runtime._core.Tensor``

qmatmul_(input, other, out, out_scale, out_zero_point, out_quant_axis=-1, bias=None, *, activation=None, transpose_a=False, transpose_b=False) -> Tensor

The `qmatmul_` operator.

## `qmatmul_woq`

```python
qmatmul_woqqmatmul_woq(input: clika_runtime._core.Tensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor
```

qmatmul_woq(input: clika_runtime._core.Tensor, other: clika_runtime._core.QTensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qmatmul_woq(input, other, bias=None, *, activation=None, transpose_a=False, transpose_b=False, compute_mode='exact_fp') -> Tensor

The `qmatmul_woq` operator.

## `qmatmul_woq_`

```python
qmatmul_woq_qmatmul_woq_(input: clika_runtime._core.Tensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor
```

qmatmul_woq_(input: clika_runtime._core.Tensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, bias: clika_runtime._core.Tensor | None = None, *, activation: object | None = None, transpose_a: bool = False, transpose_b: bool = False, compute_mode: object = 'exact_fp') -> clika_runtime._core.Tensor

qmatmul_woq_(input, other, out, bias=None, *, activation=None, transpose_a=False, transpose_b=False, compute_mode='exact_fp') -> Tensor

The `qmatmul_woq_` operator.

## `qmoe`

```python
qmoeqmoe(input: clika_runtime._core.QTensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.QTensor = QTensor(, []), fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: object | None = None, renormalize: bool | None = None, n_group: int | None = None, topk_group: int | None = None, routed_scaling_factor: float | None = None, sparse_mixer_eps: float | None = None, apply_router_weight_on_input: bool | None = None, *, activation: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | None = None, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

qmoe(input: clika_runtime._core.QTensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.QTensor = QTensor(, []), fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: object | None = None, renormalize: bool | None = None, n_group: int | None = None, topk_group: int | None = None, routed_scaling_factor: float | None = None, sparse_mixer_eps: float | None = None, apply_router_weight_on_input: bool | None = None, *, activation: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | None = None, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
qmoe(input: clika_runtime._core.QTensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None, fc2_bias: clika_runtime._core.Tensor | None, fc3_experts: clika_runtime._core.QTensor, fc3_bias: clika_runtime._core.Tensor | None, e_score_correction_bias: clika_runtime._core.Tensor | None, router_weights: clika_runtime._core.Tensor | None, routing_mode: object, renormalize: bool | None, n_group: int | None, topk_group: int | None, routed_scaling_factor: float | None, sparse_mixer_eps: float | None, apply_router_weight_on_input: bool | None, activation: object, swiglu_fusion: object, swiglu_alpha: float | None, swiglu_beta: float | None, swiglu_limit: float | None, gelu_mode: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qmoe(input: clika_runtime._core.QTensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.QTensor = QTensor(, []), fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: object | None = None, renormalize: bool | None = None, n_group: int | None = None, topk_group: int | None = None, routed_scaling_factor: float | None = None, sparse_mixer_eps: float | None = None, apply_router_weight_on_input: bool | None = None, *, activation: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | None = None, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor``

qmoe(input, router_logits, fc1_experts, fc2_experts, top_k, fc1_bias=None, fc2_bias=None, fc3_experts=None, fc3_bias=None, e_score_correction_bias=None, router_weights=None, routing_mode=None, renormalize=None, n_group=None, topk_group=None, routed_scaling_factor=None, sparse_mixer_eps=None, apply_router_weight_on_input=None, *, activation=None, swiglu_fusion=None, swiglu_alpha=None, swiglu_beta=None, swiglu_limit=None, gelu_mode=None, shared_output=None) -> Tensor

The `qmoe` operator.

2. ``qmoe(input: clika_runtime._core.QTensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None, fc2_bias: clika_runtime._core.Tensor | None, fc3_experts: clika_runtime._core.QTensor, fc3_bias: clika_runtime._core.Tensor | None, e_score_correction_bias: clika_runtime._core.Tensor | None, router_weights: clika_runtime._core.Tensor | None, routing_mode: object, renormalize: bool | None, n_group: int | None, topk_group: int | None, routed_scaling_factor: float | None, sparse_mixer_eps: float | None, apply_router_weight_on_input: bool | None, activation: object, swiglu_fusion: object, swiglu_alpha: float | None, swiglu_beta: float | None, swiglu_limit: float | None, gelu_mode: object, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.QTensor``

qmoe(input, router_logits, fc1_experts, fc2_experts, top_k, fc1_bias, fc2_bias, fc3_experts, fc3_bias, e_score_correction_bias, router_weights, routing_mode, renormalize, n_group, topk_group, routed_scaling_factor, sparse_mixer_eps, apply_router_weight_on_input, activation, swiglu_fusion, swiglu_alpha, swiglu_beta, swiglu_limit, gelu_mode, out_scale, out_zero_point, out_quant_axis=-1, *, out_dtype=Undefined, shared_output=None) -> QTensor

The `qmoe` operator.

## `qmoe_woq`

```python
qmoe_woqqmoe_woq(input: clika_runtime._core.Tensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.QTensor = QTensor(, []), fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: object | None = None, renormalize: bool | None = None, n_group: int | None = None, topk_group: int | None = None, routed_scaling_factor: float | None = None, sparse_mixer_eps: float | None = None, apply_router_weight_on_input: bool | None = None, *, activation: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | None = None, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

qmoe_woq(input: clika_runtime._core.Tensor, router_logits: clika_runtime._core.Tensor, fc1_experts: clika_runtime._core.QTensor, fc2_experts: clika_runtime._core.QTensor, top_k: int, fc1_bias: clika_runtime._core.Tensor | None = None, fc2_bias: clika_runtime._core.Tensor | None = None, fc3_experts: clika_runtime._core.QTensor = QTensor(, []), fc3_bias: clika_runtime._core.Tensor | None = None, e_score_correction_bias: clika_runtime._core.Tensor | None = None, router_weights: clika_runtime._core.Tensor | None = None, routing_mode: object | None = None, renormalize: bool | None = None, n_group: int | None = None, topk_group: int | None = None, routed_scaling_factor: float | None = None, sparse_mixer_eps: float | None = None, apply_router_weight_on_input: bool | None = None, *, activation: object | None = None, swiglu_fusion: object | None = None, swiglu_alpha: float | None = None, swiglu_beta: float | None = None, swiglu_limit: float | None = None, gelu_mode: object | None = None, shared_output: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

qmoe_woq(input, router_logits, fc1_experts, fc2_experts, top_k, fc1_bias=None, fc2_bias=None, fc3_experts=None, fc3_bias=None, e_score_correction_bias=None, router_weights=None, routing_mode=None, renormalize=None, n_group=None, topk_group=None, routed_scaling_factor=None, sparse_mixer_eps=None, apply_router_weight_on_input=None, *, activation=None, swiglu_fusion=None, swiglu_alpha=None, swiglu_beta=None, swiglu_limit=None, gelu_mode=None, shared_output=None) -> Tensor

The `qmoe_woq` operator.

## `qmul`

```python
qmulqmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: object | None = 'identity') -> clika_runtime._core.QTensor

Overloaded function.

1. ``qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qmul(input, other, *, activation='identity') -> Tensor

The `qmul` operator.

2. ``qmul(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qmul(input, other, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined, activation='identity') -> QTensor

The `qmul` operator.

## `qmul_`

```python
qmul_qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
```

qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

Overloaded function.

1. ``qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qmul_(input, other, out, *, activation='identity') -> QTensor

The `qmul_` operator.

2. ``qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qmul_(input, other, out, *, activation='identity') -> Tensor

The `qmul_` operator.

3. ``qmul_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qmul_(input, other, out, out_scale, out_zero_point=None, out_quant_axis=-1, *, activation='identity') -> Tensor

The `qmul_` operator.

## `qneg`

```python
qnegqneg(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
```

qneg(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
qneg(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qneg(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor``

qneg(input) -> Tensor

The `qneg` operator.

2. ``qneg(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qneg(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qneg` operator.

## `qneg_`

```python
qneg_qneg_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

qneg_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
qneg_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
qneg_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qneg_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

qneg_(input, out) -> QTensor

The `qneg_` operator.

2. ``qneg_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

qneg_(input, out) -> Tensor

The `qneg_` operator.

3. ``qneg_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

qneg_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `qneg_` operator.

## `qquick_gelu`

```python
qquick_geluqquick_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
```

qquick_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
qquick_gelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qquick_gelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor``

qquick_gelu(input) -> Tensor

The `qquick_gelu` operator.

2. ``qquick_gelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qquick_gelu(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qquick_gelu` operator.

## `qquick_gelu_`

```python
qquick_gelu_qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

qquick_gelu_(input, out) -> QTensor

The `qquick_gelu_` operator.

2. ``qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

qquick_gelu_(input, out) -> Tensor

The `qquick_gelu_` operator.

3. ``qquick_gelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

qquick_gelu_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `qquick_gelu_` operator.

## `qrelu`

```python
qreluqrelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
```

qrelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
qrelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qrelu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor``

qrelu(input) -> Tensor

The `qrelu` operator.

2. ``qrelu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qrelu(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qrelu` operator.

## `qrelu_`

```python
qrelu_qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

qrelu_(input, out) -> QTensor

The `qrelu_` operator.

2. ``qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

qrelu_(input, out) -> Tensor

The `qrelu_` operator.

3. ``qrelu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

qrelu_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `qrelu_` operator.

## `qsigmoid`

```python
qsigmoidqsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
```

qsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
qsigmoid(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qsigmoid(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor``

qsigmoid(input) -> Tensor

The `qsigmoid` operator.

2. ``qsigmoid(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qsigmoid(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qsigmoid` operator.

## `qsigmoid_`

```python
qsigmoid_qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

qsigmoid_(input, out) -> QTensor

The `qsigmoid_` operator.

2. ``qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

qsigmoid_(input, out) -> Tensor

The `qsigmoid_` operator.

3. ``qsigmoid_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

qsigmoid_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `qsigmoid_` operator.

## `qsilu`

```python
qsiluqsilu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
```

qsilu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
qsilu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qsilu(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor``

qsilu(input) -> Tensor

The `qsilu` operator.

2. ``qsilu(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qsilu(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qsilu` operator.

## `qsilu_`

```python
qsilu_qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

qsilu_(input, out) -> QTensor

The `qsilu_` operator.

2. ``qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

qsilu_(input, out) -> Tensor

The `qsilu_` operator.

3. ``qsilu_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

qsilu_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `qsilu_` operator.

## `qsub`

```python
qsubqsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: object | None = 'identity') -> clika_runtime._core.QTensor

Overloaded function.

1. ``qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qsub(input, other, *, activation='identity') -> Tensor

The `qsub` operator.

2. ``qsub(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qsub(input, other, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined, activation='identity') -> QTensor

The `qsub` operator.

## `qsub_`

```python
qsub_qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
```

qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor
qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

Overloaded function.

1. ``qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor, *, activation: object | None = 'identity') -> clika_runtime._core.QTensor``

qsub_(input, other, out, *, activation='identity') -> QTensor

The `qsub_` operator.

2. ``qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qsub_(input, other, out, *, activation='identity') -> Tensor

The `qsub_` operator.

3. ``qsub_(input: clika_runtime._core.QTensor, other: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor``

qsub_(input, other, out, out_scale, out_zero_point=None, out_quant_axis=-1, *, activation='identity') -> Tensor

The `qsub_` operator.

## `qtanh`

```python
qtanhqtanh(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
```

qtanh(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor
qtanh(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

Overloaded function.

1. ``qtanh(input: clika_runtime._core.QTensor) -> clika_runtime._core.Tensor``

qtanh(input) -> Tensor

The `qtanh` operator.

2. ``qtanh(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor``

qtanh(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `qtanh` operator.

## `qtanh_`

```python
qtanh_qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

qtanh_(input, out) -> QTensor

The `qtanh_` operator.

2. ``qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

qtanh_(input, out) -> Tensor

The `qtanh_` operator.

3. ``qtanh_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

qtanh_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `qtanh_` operator.

## `quantile`

```python
quantilequantile(input: clika_runtime._core.Tensor, q: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, keepdim: bool = False, interpolation: object = 'linear') -> clika_runtime._core.Tensor
```

quantile(input: clika_runtime._core.Tensor, q: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, keepdim: bool = False, interpolation: object = 'linear') -> clika_runtime._core.Tensor

quantile(input, q, dim=None, keepdim=False, interpolation='linear') -> Tensor

The `quantile` operator.

## `quantize`

```python
quantize(input: 'Tensor', scale: 'ScaleLike', zero_point: 'ZeroPointLike' = None, quant_axis: 'int' = -1, *, out_dtype: 'DtypeLike' = None, block_size: 'int' = 0) -> 'QTensor'
```

quantize(input, scale, zero_point=None, quant_axis=-1, *, out_dtype=None, block_size=0) -> QTensor

Quantize ``input`` at ``scale``, a number or a tensor.
``quantize(x, 0.02, out_dtype=clika_runtime.int8)`` quantizes per tensor
at a single scale; tensor scales carry per-channel and blocked schemes
exactly as :func:`clika_runtime.ops.quantize` takes them.

## `quantize_`

```python
quantize_quantize_(input: clika_runtime._core.Tensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

quantize_(input: clika_runtime._core.Tensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
quantize_(input: clika_runtime._core.Tensor, out: clika_runtime._core.Tensor, scale: clika_runtime._core.Tensor, zero_point: clika_runtime._core.Tensor | None = None, quant_axis: int = -1, block_size: int = 0) -> clika_runtime._core.Tensor

Overloaded function.

1. ``quantize_(input: clika_runtime._core.Tensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

quantize_(input, out) -> QTensor

The `quantize_` operator.

2. ``quantize_(input: clika_runtime._core.Tensor, out: clika_runtime._core.Tensor, scale: clika_runtime._core.Tensor, zero_point: clika_runtime._core.Tensor | None = None, quant_axis: int = -1, block_size: int = 0) -> clika_runtime._core.Tensor``

quantize_(input, out, scale, zero_point=None, quant_axis=-1, block_size=0) -> Tensor

The `quantize_` operator.

## `quantize_dequantize`

```python
quantize_dequantize(input: 'Tensor', scale: 'ScaleLike', zero_point: 'ZeroPointLike' = None, quant_axis: 'int' = -1, *, code_dtype: 'DtypeLike' = None, out_dtype: 'DtypeLike' = None, block_size: 'int' = 0) -> 'Tensor'
```

quantize_dequantize(input, scale, zero_point=None, quant_axis=-1, *, code_dtype=None, out_dtype=None, block_size=0) -> Tensor

Quantize then dequantize in one call, at a number or tensor scale. The
round trip reports what the quantized representation keeps; the
standard fake-quantization step.

## `quantize_to_scheme`

```python
quantize_to_schemequantize_to_scheme(input: clika_runtime._core.Tensor, scheme: str, scale: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.QTensor
```

quantize_to_scheme(input: clika_runtime._core.Tensor, scheme: str, scale: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.QTensor

quantize_to_scheme(input, scheme, scale=None) -> QTensor

The `quantize_to_scheme` operator.

## `quantized_view`

```python
quantized_viewquantized_view(tensor: clika_runtime._core.Tensor) -> clika_runtime._core.QTensor
```

quantized_view(tensor: clika_runtime._core.Tensor) -> clika_runtime._core.QTensor

The typed quantized view of a tensor that carries a quantization scheme (Tensor.is_quantized); raises RuntimeError on a plain tensor.

## `quick_gelu`

```python
quick_geluquick_gelu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

quick_gelu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

quick_gelu(input) -> Tensor

The `quick_gelu` operator.

## `rad2deg`

```python
rad2degrad2deg(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

rad2deg(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

rad2deg(input) -> Tensor

The `rad2deg` operator.

## `rad2deg_`

```python
rad2deg_rad2deg_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

rad2deg_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

rad2deg_(self) -> Tensor

The `rad2deg_` operator.

## `rand`

```python
rand(*size: 'ShapeDim', dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

rand(*size, dtype=None, device=None) -> Tensor

Uniform samples in ``[0, 1)``; the default dtype unless ``dtype`` says
otherwise.

## `rand_like`

```python
rand_like(input: 'Tensor', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

rand_like(input, *, dtype=None, device=None) -> Tensor

Uniform samples in ``[0, 1)`` of ``input``'s shape, dtype and device,
each overridable by keyword.

## `randint`

```python
randint(*args: 'int | Sequence[int]', size: 'Sequence[int] | None' = None, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

randint(low=0, high, size, *, dtype=None, device=None) -> Tensor

Uniform integers in ``[low, high)`` of the given shape:
``randint(high, size)`` or ``randint(low, high, size)``; ``size`` may
also be given by keyword. ``int64`` unless ``dtype`` says otherwise.

## `randint_like`

```python
randint_like(input: 'Tensor', low: 'int', high: 'int | None' = None, *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

randint_like(input, low=0, high, *, dtype=None, device=None) -> Tensor

Uniform integers in ``[low, high)`` of ``input``'s shape, dtype and
device (``randint_like(input, high)`` counts from zero); dtype and
device overridable by keyword.

## `randn`

```python
randn(*size: 'ShapeDim', dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

randn(*size, dtype=None, device=None) -> Tensor

Standard-normal samples; the default dtype unless ``dtype`` says otherwise.

## `randn_like`

```python
randn_like(input: 'Tensor', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

randn_like(input, *, dtype=None, device=None) -> Tensor

Standard-normal samples of ``input``'s shape, dtype and device, each
overridable by keyword.

## `random_`

```python
random_random_(self: clika_runtime._core.Tensor, low: int | None = None, high: int | None = None, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor
```

random_(self: clika_runtime._core.Tensor, low: int | None = None, high: int | None = None, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

random_(self, low=None, high=None, *, device=None) -> Tensor

The `random_` operator.

## `randperm`

```python
randpermrandperm(n: clika_runtime._core.ops.ScalarOrTensor, *, dtype: clika_runtime._core.DataType = DataType.Int64, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor
```

randperm(n: clika_runtime._core.ops.ScalarOrTensor, *, dtype: clika_runtime._core.DataType = DataType.Int64, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

randperm(n, *, dtype=Int64, device=None) -> Tensor

The `randperm` operator.

## `reciprocal`

```python
reciprocalreciprocal(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

reciprocal(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

reciprocal(input) -> Tensor

The `reciprocal` operator.

## `reciprocal_`

```python
reciprocal_reciprocal_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

reciprocal_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

reciprocal_(self) -> Tensor

The `reciprocal_` operator.

## `reflect_pad`

```python
reflect_padreflect_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor
```

reflect_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor

reflect_pad(input, pad) -> Tensor

The `reflect_pad` operator.

## `reglu`

```python
reglureglu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

reglu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

reglu(input) -> Tensor

The `reglu` operator.

## `relu`

```python
relurelu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

relu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

relu(input) -> Tensor

The `relu` operator.

## `relu6`

```python
relu6relu6(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

relu6(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

relu6(input) -> Tensor

The `relu6` operator.

## `relu6_`

```python
relu6_relu6_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

relu6_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

relu6_(self) -> Tensor

The `relu6_` operator.

## `relu_`

```python
relu_relu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

relu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

relu_(self) -> Tensor

The `relu_` operator.

## `remainder`

```python
remainderremainder(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

remainder(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

remainder(input, other) -> Tensor

The `remainder` operator.

## `remainder_`

```python
remainder_remainder_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

remainder_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

remainder_(self, other) -> Tensor

The `remainder_` operator.

## `renorm`

```python
renormrenorm(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar, dim: int, maxnorm: clika_runtime._core.ops.Scalar, eps: float | None = None) -> clika_runtime._core.Tensor
```

renorm(input: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar, dim: int, maxnorm: clika_runtime._core.ops.Scalar, eps: float | None = None) -> clika_runtime._core.Tensor

renorm(input, p, dim, maxnorm, eps=None) -> Tensor

The `renorm` operator.

## `renorm_`

```python
renorm_renorm_(self: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar, dim: int, maxnorm: clika_runtime._core.ops.Scalar, eps: float | None = None) -> clika_runtime._core.Tensor
```

renorm_(self: clika_runtime._core.Tensor, p: clika_runtime._core.ops.Scalar, dim: int, maxnorm: clika_runtime._core.ops.Scalar, eps: float | None = None) -> clika_runtime._core.Tensor

renorm_(self, p, dim, maxnorm, eps=None) -> Tensor

The `renorm_` operator.

## `repeat`

```python
repeatrepeat(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor
```

repeat(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor

repeat(input, sizes) -> Tensor

The `repeat` operator.

## `repeat_interleave`

```python
repeat_interleaverepeat_interleave(input: clika_runtime._core.Tensor, repeats: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, output_size: int | None = None) -> clika_runtime._core.Tensor
```

repeat_interleave(input: clika_runtime._core.Tensor, repeats: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, output_size: int | None = None) -> clika_runtime._core.Tensor

repeat_interleave(input, repeats, dim=None, output_size=None) -> Tensor

The `repeat_interleave` operator.

## `replicate_pad`

```python
replicate_padreplicate_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor
```

replicate_pad(input: clika_runtime._core.Tensor, pad: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor

replicate_pad(input, pad) -> Tensor

The `replicate_pad` operator.

## `requantize`

```python
requantizerequantize(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor
```

requantize(input: clika_runtime._core.QTensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1, *, out_dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.QTensor

requantize(input, out_scale, out_zero_point=None, out_quant_axis=-1, *, out_dtype=Undefined) -> QTensor

The `requantize` operator.

## `requantize_`

```python
requantize_requantize_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

requantize_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
requantize_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor

Overloaded function.

1. ``requantize_(input: clika_runtime._core.QTensor, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

requantize_(input, out) -> QTensor

The `requantize_` operator.

2. ``requantize_(input: clika_runtime._core.QTensor, out: clika_runtime._core.Tensor, out_scale: clika_runtime._core.Tensor, out_zero_point: clika_runtime._core.Tensor | None = None, out_quant_axis: int = -1) -> clika_runtime._core.Tensor``

requantize_(input, out, out_scale, out_zero_point=None, out_quant_axis=-1) -> Tensor

The `requantize_` operator.

## `resample`

```python
resampleresample(input: clika_runtime._core.Tensor, orig_freq: int, new_freq: int, lowpass_filter_width: int = 16, rolloff: float = 0.945, beta: float | None = None) -> clika_runtime._core.Tensor
```

resample(input: clika_runtime._core.Tensor, orig_freq: int, new_freq: int, lowpass_filter_width: int = 16, rolloff: float = 0.945, beta: float | None = None) -> clika_runtime._core.Tensor

resample(input, orig_freq, new_freq, lowpass_filter_width=16, rolloff=0.945, beta=None) -> Tensor

The `resample` operator.

## `reset_peak_memory_stats`

```python
reset_peak_memory_statsreset_peak_memory_stats(device: object) -> None
```

reset_peak_memory_stats(device: object) -> None

reset_peak_memory_stats(device) -> None

Restart the device's peak memory marks (peak_active_bytes, peak_requested_bytes, peak_reserved_bytes) from the present figures; nothing is allocated, freed or waited on. The measuring idiom: reset, run one step, read memory_stats(device).peak_active_bytes, or peak_requested_bytes for the bytes the step asked for.

## `reshape`

```python
reshapereshape(input: clika_runtime._core.Tensor, shape: collections.abc.Sequence[clika_runtime._core.ops.IndexBound]) -> clika_runtime._core.Tensor
```

reshape(input: clika_runtime._core.Tensor, shape: collections.abc.Sequence[clika_runtime._core.ops.IndexBound]) -> clika_runtime._core.Tensor

reshape(input, shape) -> Tensor

The `reshape` operator.

## `reshape_as`

```python
reshape_asreshape_as(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

reshape_as(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

reshape_as(input, other) -> Tensor

The `reshape_as` operator.

## `rfft`

```python
rfftrfft(input: clika_runtime._core.Tensor, n_fft: int | None = None, normalized: bool = False) -> clika_runtime._core.Tensor
```

rfft(input: clika_runtime._core.Tensor, n_fft: int | None = None, normalized: bool = False) -> clika_runtime._core.Tensor

rfft(input, n_fft=None, normalized=False) -> Tensor

The `rfft` operator.

## `rms_norm`

```python
rms_normrms_norm(input: clika_runtime._core.Tensor, normalized_shape: collections.abc.Sequence[int], weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor
```

rms_norm(input: clika_runtime._core.Tensor, normalized_shape: collections.abc.Sequence[int], weight: clika_runtime._core.Tensor | None = None, bias: clika_runtime._core.Tensor | None = None, eps: float | None = None, *, activation: object | None = None) -> clika_runtime._core.Tensor

rms_norm(input, normalized_shape, weight=None, bias=None, eps=None, *, activation=None) -> Tensor

The `rms_norm` operator.

## `roll`

```python
rollroll(input: clika_runtime._core.Tensor, shifts: collections.abc.Sequence[int], dims: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor
```

roll(input: clika_runtime._core.Tensor, shifts: collections.abc.Sequence[int], dims: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor

roll(input, shifts, dims=[]) -> Tensor

The `roll` operator.

## `rot90`

```python
rot90rot90(input: clika_runtime._core.Tensor, k: int = 1, dims: collections.abc.Sequence[int] = [0, 1]) -> clika_runtime._core.Tensor
```

rot90(input: clika_runtime._core.Tensor, k: int = 1, dims: collections.abc.Sequence[int] = [0, 1]) -> clika_runtime._core.Tensor

rot90(input, k=1, dims=[0, 1]) -> Tensor

The `rot90` operator.

## `rotary_embedding`

```python
rotary_embeddingrotary_embedding(input: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

rotary_embedding(input: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

rotary_embedding(input, position_ids=None, cos=None, sin=None, mode=None, rotary_dim=None, theta=None, scaling=None, scale=None, low_freq_factor=None, high_freq_factor=None, original_max_pos=None, beta_fast=None, beta_slow=None, freq_factors=None) -> Tensor

The `rotary_embedding` operator.

## `rotary_embedding_qk`

```python
rotary_embedding_qkrotary_embedding_qk(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

rotary_embedding_qk(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

rotary_embedding_qk(query, key, position_ids=None, cos=None, sin=None, mode=None, rotary_dim=None, theta=None, scaling=None, scale=None, low_freq_factor=None, high_freq_factor=None, original_max_pos=None, beta_fast=None, beta_slow=None, freq_factors=None) -> tuple[Tensor, Tensor]

The `rotary_embedding_qk` operator.

## `rotary_embedding_qk_varlen`

```python
rotary_embedding_qk_varlenrotary_embedding_qk_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, cu_seqlens: clika_runtime._core.Tensor, seqlens: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

rotary_embedding_qk_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, cu_seqlens: clika_runtime._core.Tensor, seqlens: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

rotary_embedding_qk_varlen(query, key, cu_seqlens, seqlens=None, position_ids=None, cos=None, sin=None, mode=None, rotary_dim=None, theta=None, scaling=None, scale=None, low_freq_factor=None, high_freq_factor=None, original_max_pos=None, beta_fast=None, beta_slow=None, freq_factors=None) -> tuple[Tensor, Tensor]

The `rotary_embedding_qk_varlen` operator.

## `rotary_embedding_varlen`

```python
rotary_embedding_varlenrotary_embedding_varlen(input: clika_runtime._core.Tensor, cu_seqlens: clika_runtime._core.Tensor, seqlens: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

rotary_embedding_varlen(input: clika_runtime._core.Tensor, cu_seqlens: clika_runtime._core.Tensor, seqlens: clika_runtime._core.Tensor | None = None, position_ids: clika_runtime._core.Tensor | None = None, cos: clika_runtime._core.Tensor | None = None, sin: clika_runtime._core.Tensor | None = None, mode: object | None = None, rotary_dim: int | None = None, theta: float | None = None, scaling: object | None = None, scale: float | None = None, low_freq_factor: float | None = None, high_freq_factor: float | None = None, original_max_pos: int | None = None, beta_fast: float | None = None, beta_slow: float | None = None, freq_factors: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

rotary_embedding_varlen(input, cu_seqlens, seqlens=None, position_ids=None, cos=None, sin=None, mode=None, rotary_dim=None, theta=None, scaling=None, scale=None, low_freq_factor=None, high_freq_factor=None, original_max_pos=None, beta_fast=None, beta_slow=None, freq_factors=None) -> Tensor

The `rotary_embedding_varlen` operator.

## `round`

```python
roundround(input: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor
```

round(input: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor

round(input, decimals=0) -> Tensor

The `round` operator.

## `round_`

```python
round_round_(self: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor
```

round_(self: clika_runtime._core.Tensor, decimals: int = 0) -> clika_runtime._core.Tensor

round_(self, decimals=0) -> Tensor

The `round_` operator.

## `rsqrt`

```python
rsqrtrsqrt(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

rsqrt(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

rsqrt(input) -> Tensor

The `rsqrt` operator.

## `rsqrt_`

```python
rsqrt_rsqrt_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

rsqrt_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

rsqrt_(self) -> Tensor

The `rsqrt_` operator.

## `save`

```python
save(obj: 'Tensor | Mapping[str, Tensor] | Any', path: 'PathLike', *, metadata: 'Metadata | None' = None) -> 'None'
```

save(obj, path, *, metadata=None) -> None

Write ``obj`` to a safetensors file at ``path``: a
:class:`~clika_runtime.Tensor`, a ``dict`` of tensors (a
``state_dict``, kept in its own order), or any pytree of tensors,
flattened by key path with its structure in the file's header
metadata. ``metadata`` adds ``str -> str`` pairs to the header (a dict,
or ``(key, value)`` pairs), written in the given order after the
structure entries. Pending work on every tensor settles first.

Raises:
    TypeError: when a leaf is not a tensor, a dict key is not a str, or
        a metadata pair is not two strings.
    ValueError: when a dict uses the reserved key ``.tensor``, or a
        metadata key starts with ``clika.``.

## `scaled_dot_product_attention`

```python
scaled_dot_product_attentionscaled_dot_product_attention(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool = False, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...)) -> clika_runtime._core.Tensor
```

scaled_dot_product_attention(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool = False, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...)) -> clika_runtime._core.Tensor

scaled_dot_product_attention(query, key, value, attn_mask=None, is_causal=False, q_scale=None, k_scale=None, v_scale=None) -> Tensor

The `scaled_dot_product_attention` operator.

## `scaled_dot_product_attention_varlen`

```python
scaled_dot_product_attention_varlenscaled_dot_product_attention_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool = False, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...)) -> clika_runtime._core.Tensor
```

scaled_dot_product_attention_varlen(query: clika_runtime._core.Tensor, key: clika_runtime._core.Tensor, value: clika_runtime._core.Tensor, cu_seqlens_q: clika_runtime._core.Tensor, cu_seqlens_k: clika_runtime._core.Tensor, max_seqlen_q: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), max_seqlen_k: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), attn_mask: clika_runtime._core.Tensor | None = None, is_causal: bool = False, q_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), k_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...), v_scale: clika_runtime._core.ops.ScalarOrTensor = ScalarOrTensor(...)) -> clika_runtime._core.Tensor

scaled_dot_product_attention_varlen(query, key, value, cu_seqlens_q, cu_seqlens_k, max_seqlen_q=None, max_seqlen_k=None, attn_mask=None, is_causal=False, q_scale=None, k_scale=None, v_scale=None) -> Tensor

The `scaled_dot_product_attention_varlen` operator.

## `scatter`

```python
scatterscatter(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

scatter(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

scatter(input, dim, index, src) -> Tensor

The `scatter` operator.

## `scatter_`

```python
scatter_scatter_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

scatter_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

scatter_(self, dim, index, src) -> Tensor

The `scatter_` operator.

## `scatter_add`

```python
scatter_addscatter_add(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, deterministic: bool = False) -> clika_runtime._core.Tensor
```

scatter_add(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_add(input, dim, index, src, deterministic=False) -> Tensor

The `scatter_add` operator.

## `scatter_add_`

```python
scatter_add_scatter_add_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, deterministic: bool = False) -> clika_runtime._core.Tensor
```

scatter_add_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_add_(self, dim, index, src, deterministic=False) -> Tensor

The `scatter_add_` operator.

## `scatter_reduce`

```python
scatter_reducescatter_reduce(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: object, include_self: bool = True, deterministic: bool = False) -> clika_runtime._core.Tensor
```

scatter_reduce(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: object, include_self: bool = True, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_reduce(input, dim, index, src, reduce, include_self=True, deterministic=False) -> Tensor

The `scatter_reduce` operator.

## `scatter_reduce_`

```python
scatter_reduce_scatter_reduce_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: object, include_self: bool = True, deterministic: bool = False) -> clika_runtime._core.Tensor
```

scatter_reduce_(self: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: object, include_self: bool = True, deterministic: bool = False) -> clika_runtime._core.Tensor

scatter_reduce_(self, dim, index, src, reduce, include_self=True, deterministic=False) -> Tensor

The `scatter_reduce_` operator.

## `searchsorted`

```python
searchsortedsearchsorted(sorted_sequence: clika_runtime._core.Tensor, values: clika_runtime._core.Tensor, out_int32: bool = False, right: bool = False, side: bool | None = None, sorter: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

searchsorted(sorted_sequence: clika_runtime._core.Tensor, values: clika_runtime._core.Tensor, out_int32: bool = False, right: bool = False, side: bool | None = None, sorter: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor

searchsorted(sorted_sequence, values, out_int32=False, right=False, side=None, sorter=None) -> Tensor

The `searchsorted` operator.

## `select`

```python
selectselect(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.ops.IndexBound) -> clika_runtime._core.Tensor
```

select(input: clika_runtime._core.Tensor, dim: int, index: clika_runtime._core.ops.IndexBound) -> clika_runtime._core.Tensor

select(input, dim, index) -> Tensor

The `select` operator.

## `selu`

```python
seluselu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

selu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

selu(input) -> Tensor

The `selu` operator.

## `selu_`

```python
selu_selu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

selu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

selu_(self) -> Tensor

The `selu_` operator.

## `set_default_dtype`

```python
set_default_dtype(dtype: 'DtypeLike') -> 'None'
```

set_default_dtype(dtype) -> None

Set the default floating-point dtype (``clika_runtime.float32``,
``"bfloat16"``, ...). Only a floating-point dtype is accepted.

## `set_printoptions`

```python
set_printoptions(precision: 'int | None' = None, threshold: 'int | None' = None, edgeitems: 'int | None' = None, linewidth: 'int | None' = None, sci_mode: 'bool | None' = None) -> 'None'
```

set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, sci_mode=None) -> None

Set how tensors print. ``precision`` digits after the point (4 at
start), ``threshold`` the element count past which the printout
abbreviates with ``...`` (1000), ``edgeitems`` the entries kept at each
end of an abbreviated dim (3), ``linewidth`` the characters per line
(80), ``sci_mode`` forces (True) or forbids (False) scientific notation;
None lets the values decide. An argument left None keeps its value.

## `sgn`

```python
sgnsgn(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sgn(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sgn(input) -> Tensor

The `sgn` operator.

## `sgn_`

```python
sgn_sgn_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sgn_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sgn_(self) -> Tensor

The `sgn_` operator.

## `shape`

```python
shapeshape(input: clika_runtime._core.Tensor, dim: int | None = None) -> clika_runtime._core.Tensor
```

shape(input: clika_runtime._core.Tensor, dim: int | None = None) -> clika_runtime._core.Tensor
shape(input: clika_runtime._core.Tensor, start: int | None, end: int | None) -> clika_runtime._core.Tensor

Overloaded function.

1. ``shape(input: clika_runtime._core.Tensor, dim: int | None = None) -> clika_runtime._core.Tensor``

shape(input, dim=None) -> Tensor

The `shape` operator.

2. ``shape(input: clika_runtime._core.Tensor, start: int | None, end: int | None) -> clika_runtime._core.Tensor``

shape(input, start, end) -> Tensor

The `shape` operator.

## `shape_host`

```python
shape_hostshape_host(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

shape_host(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
shape_host(input: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor
shape_host(input: clika_runtime._core.Tensor, start: int | None, end: int | None) -> clika_runtime._core.Tensor

Overloaded function.

1. ``shape_host(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

shape_host(input) -> Tensor

The `shape_host` operator.

2. ``shape_host(input: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor``

shape_host(input, dim) -> Tensor

The `shape_host` operator.

3. ``shape_host(input: clika_runtime._core.Tensor, start: int | None, end: int | None) -> clika_runtime._core.Tensor``

shape_host(input, start, end) -> Tensor

The `shape_host` operator.

## `sigmoid`

```python
sigmoidsigmoid(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sigmoid(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sigmoid(input) -> Tensor

The `sigmoid` operator.

## `sigmoid_`

```python
sigmoid_sigmoid_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sigmoid_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sigmoid_(self) -> Tensor

The `sigmoid_` operator.

## `sign`

```python
signsign(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sign(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sign(input) -> Tensor

The `sign` operator.

## `sign_`

```python
sign_sign_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sign_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sign_(self) -> Tensor

The `sign_` operator.

## `silu`

```python
silusilu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

silu(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

silu(input) -> Tensor

The `silu` operator.

## `silu_`

```python
silu_silu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

silu_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

silu_(self) -> Tensor

The `silu_` operator.

## `sin`

```python
sinsin(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sin(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sin(input) -> Tensor

The `sin` operator.

## `sin_`

```python
sin_sin_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sin_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sin_(self) -> Tensor

The `sin_` operator.

## `sinc`

```python
sincsinc(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sinc(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sinc(input) -> Tensor

The `sinc` operator.

## `sinc_`

```python
sinc_sinc_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sinc_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sinc_(self) -> Tensor

The `sinc_` operator.

## `sinh`

```python
sinhsinh(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sinh(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sinh(input) -> Tensor

The `sinh` operator.

## `sinh_`

```python
sinh_sinh_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sinh_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sinh_(self) -> Tensor

The `sinh_` operator.

## `slice`

```python
sliceslice(input: clika_runtime._core.Tensor, dim: int, start: clika_runtime._core.ops.IndexBound = IndexBound(...), end: clika_runtime._core.ops.IndexBound = IndexBound(...), step: clika_runtime._core.ops.IndexBound = IndexBound(...)) -> clika_runtime._core.Tensor
```

slice(input: clika_runtime._core.Tensor, dim: int, start: clika_runtime._core.ops.IndexBound = IndexBound(...), end: clika_runtime._core.ops.IndexBound = IndexBound(...), step: clika_runtime._core.ops.IndexBound = IndexBound(...)) -> clika_runtime._core.Tensor
slice(input: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int], start: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = [], end: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = [], step: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = []) -> clika_runtime._core.Tensor

Overloaded function.

1. ``slice(input: clika_runtime._core.Tensor, dim: int, start: clika_runtime._core.ops.IndexBound = IndexBound(...), end: clika_runtime._core.ops.IndexBound = IndexBound(...), step: clika_runtime._core.ops.IndexBound = IndexBound(...)) -> clika_runtime._core.Tensor``

slice(input, dim, start=None, end=None, step=1) -> Tensor

The `slice` operator.

2. ``slice(input: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int], start: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = [], end: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = [], step: collections.abc.Sequence[clika_runtime._core.ops.IndexBound] = []) -> clika_runtime._core.Tensor``

slice(input, dim, start=[], end=[], step=[]) -> Tensor

The `slice` operator.

## `smooth_l1_loss`

```python
smooth_l1_losssmooth_l1_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean', beta: float = 1.0) -> clika_runtime._core.Tensor
```

smooth_l1_loss(input: clika_runtime._core.Tensor, target: clika_runtime._core.Tensor, reduction: object = 'mean', beta: float = 1.0) -> clika_runtime._core.Tensor

smooth_l1_loss(input, target, reduction='mean', beta=1.0) -> Tensor

The `smooth_l1_loss` operator.

## `snake`

```python
snakesnake(input: clika_runtime._core.Tensor, alpha: clika_runtime._core.Tensor | None = None, beta: clika_runtime._core.Tensor | None = None, eps: float = 1e-09) -> clika_runtime._core.Tensor
```

snake(input: clika_runtime._core.Tensor, alpha: clika_runtime._core.Tensor | None = None, beta: clika_runtime._core.Tensor | None = None, eps: float = 1e-09) -> clika_runtime._core.Tensor

snake(input, alpha=None, beta=None, eps=1e-9) -> Tensor

The `snake` operator.

## `snake_`

```python
snake_snake_(self: clika_runtime._core.Tensor, alpha: clika_runtime._core.Tensor | None = None, beta: clika_runtime._core.Tensor | None = None, eps: float = 1e-09) -> clika_runtime._core.Tensor
```

snake_(self: clika_runtime._core.Tensor, alpha: clika_runtime._core.Tensor | None = None, beta: clika_runtime._core.Tensor | None = None, eps: float = 1e-09) -> clika_runtime._core.Tensor

snake_(self, alpha=None, beta=None, eps=1e-9) -> Tensor

The `snake_` operator.

## `softcap_logits`

```python
softcap_logitssoftcap_logits(input: clika_runtime._core.Tensor, cap: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

softcap_logits(input: clika_runtime._core.Tensor, cap: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

softcap_logits(input, cap) -> Tensor

The `softcap_logits` operator.

## `softcap_logits_`

```python
softcap_logits_softcap_logits_(self: clika_runtime._core.Tensor, cap: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

softcap_logits_(self: clika_runtime._core.Tensor, cap: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

softcap_logits_(self, cap) -> Tensor

The `softcap_logits_` operator.

## `softmax`

```python
softmaxsoftmax(input: clika_runtime._core.Tensor, dim: int = -1, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor
```

softmax(input: clika_runtime._core.Tensor, dim: int = -1, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

softmax(input, dim=-1, *, dtype=Undefined) -> Tensor

The `softmax` operator.

## `softmax_`

```python
softmax_softmax_(self: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor
```

softmax_(self: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor

softmax_(self, dim=-1) -> Tensor

The `softmax_` operator.

## `softmin`

```python
softminsoftmin(input: clika_runtime._core.Tensor, dim: int = -1, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor
```

softmin(input: clika_runtime._core.Tensor, dim: int = -1, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

softmin(input, dim=-1, *, dtype=Undefined) -> Tensor

The `softmin` operator.

## `softmin_`

```python
softmin_softmin_(self: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor
```

softmin_(self: clika_runtime._core.Tensor, dim: int = -1) -> clika_runtime._core.Tensor

softmin_(self, dim=-1) -> Tensor

The `softmin_` operator.

## `softplus`

```python
softplussoftplus(input: clika_runtime._core.Tensor, beta: float = 1.0, threshold: float = 20.0) -> clika_runtime._core.Tensor
```

softplus(input: clika_runtime._core.Tensor, beta: float = 1.0, threshold: float = 20.0) -> clika_runtime._core.Tensor

softplus(input, beta=1.0, threshold=20.0) -> Tensor

The `softplus` operator.

## `softplus_`

```python
softplus_softplus_(self: clika_runtime._core.Tensor, beta: float = 1.0, threshold: float = 20.0) -> clika_runtime._core.Tensor
```

softplus_(self: clika_runtime._core.Tensor, beta: float = 1.0, threshold: float = 20.0) -> clika_runtime._core.Tensor

softplus_(self, beta=1.0, threshold=20.0) -> Tensor

The `softplus_` operator.

## `softshrink`

```python
softshrinksoftshrink(input: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor
```

softshrink(input: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor

softshrink(input, lambd=0.5) -> Tensor

The `softshrink` operator.

## `softshrink_`

```python
softshrink_softshrink_(self: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor
```

softshrink_(self: clika_runtime._core.Tensor, lambd: float = 0.5) -> clika_runtime._core.Tensor

softshrink_(self, lambd=0.5) -> Tensor

The `softshrink_` operator.

## `softsign`

```python
softsignsoftsign(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

softsign(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

softsign(input) -> Tensor

The `softsign` operator.

## `softsign_`

```python
softsign_softsign_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

softsign_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

softsign_(self) -> Tensor

The `softsign_` operator.

## `sort`

```python
sortsort(input: clika_runtime._core.Tensor, dim: int = -1, descending: bool = False, stable: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

sort(input: clika_runtime._core.Tensor, dim: int = -1, descending: bool = False, stable: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

sort(input, dim=-1, descending=False, stable=False) -> tuple[Tensor, Tensor]

The `sort` operator.

## `split_by_size`

```python
split_by_sizesplit_by_size(input: clika_runtime._core.Tensor, chunk_size: int, dim: int = 0) -> list[clika_runtime._core.Tensor]
```

split_by_size(input: clika_runtime._core.Tensor, chunk_size: int, dim: int = 0) -> list[clika_runtime._core.Tensor]

split_by_size(input, chunk_size, dim=0) -> list[Tensor]

The `split_by_size` operator.

## `split_with_sizes`

```python
split_with_sizessplit_with_sizes(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], dim: int = 0) -> list[clika_runtime._core.Tensor]
```

split_with_sizes(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], dim: int = 0) -> list[clika_runtime._core.Tensor]

split_with_sizes(input, sizes, dim=0) -> list[Tensor]

The `split_with_sizes` operator.

## `sqrt`

```python
sqrtsqrt(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sqrt(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sqrt(input) -> Tensor

The `sqrt` operator.

## `sqrt_`

```python
sqrt_sqrt_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

sqrt_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

sqrt_(self) -> Tensor

The `sqrt_` operator.

## `square`

```python
squaresquare(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

square(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

square(input) -> Tensor

The `square` operator.

## `square_`

```python
square_square_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

square_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

square_(self) -> Tensor

The `square_` operator.

## `squeeze`

```python
squeezesqueeze(input: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor
```

squeeze(input: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor

squeeze(input, dim=[]) -> Tensor

The `squeeze` operator.

## `squeeze_`

```python
squeeze_squeeze_(self: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor
```

squeeze_(self: clika_runtime._core.Tensor, dim: collections.abc.Sequence[int] = []) -> clika_runtime._core.Tensor

squeeze_(self, dim=[]) -> Tensor

The `squeeze_` operator.

## `ssd_update`

```python
ssd_updatessd_update(input: clika_runtime._core.Tensor, dt: clika_runtime._core.Tensor, a_rate: clika_runtime._core.Tensor, b_mat: clika_runtime._core.Tensor, c_mat: clika_runtime._core.Tensor, d_skip: clika_runtime._core.Tensor | None, dt_bias: clika_runtime._core.Tensor | None, gate: clika_runtime._core.Tensor | None, state: clika_runtime._core.Tensor, seq_lens: clika_runtime._core.Tensor | None = None, slot_ids: clika_runtime._core.Tensor | None = None, dt_softplus: bool = False) -> clika_runtime._core.Tensor
```

ssd_update(input: clika_runtime._core.Tensor, dt: clika_runtime._core.Tensor, a_rate: clika_runtime._core.Tensor, b_mat: clika_runtime._core.Tensor, c_mat: clika_runtime._core.Tensor, d_skip: clika_runtime._core.Tensor | None, dt_bias: clika_runtime._core.Tensor | None, gate: clika_runtime._core.Tensor | None, state: clika_runtime._core.Tensor, seq_lens: clika_runtime._core.Tensor | None = None, slot_ids: clika_runtime._core.Tensor | None = None, dt_softplus: bool = False) -> clika_runtime._core.Tensor

ssd_update(input, dt, a_rate, b_mat, c_mat, d_skip, dt_bias, gate, state, seq_lens=None, slot_ids=None, dt_softplus=False) -> Tensor

The `ssd_update` operator.

## `stack`

```python
stackstack(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], dim: int = 0) -> clika_runtime._core.Tensor
```

stack(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], dim: int = 0) -> clika_runtime._core.Tensor

stack(tensors, dim=0) -> Tensor

The `stack` operator.

## `std`

```python
stdstd(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], correction: int = 1, keepdim: bool = False) -> clika_runtime._core.Tensor
```

std(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], correction: int = 1, keepdim: bool = False) -> clika_runtime._core.Tensor

std(input, dims=[], correction=1, keepdim=False) -> Tensor

The `std` operator.

## `stft`

```python
stftstft(input: clika_runtime._core.Tensor, n_fft: int, hop_length: int | None = None, win_length: int | None = None, window: clika_runtime._core.Tensor | None = None, center: bool = True, pad_mode: object = 'reflect', normalized: bool = False, onesided: bool = True) -> clika_runtime._core.Tensor
```

stft(input: clika_runtime._core.Tensor, n_fft: int, hop_length: int | None = None, win_length: int | None = None, window: clika_runtime._core.Tensor | None = None, center: bool = True, pad_mode: object = 'reflect', normalized: bool = False, onesided: bool = True) -> clika_runtime._core.Tensor

stft(input, n_fft, hop_length=None, win_length=None, window=None, center=True, pad_mode='reflect', normalized=False, onesided=True) -> Tensor

The `stft` operator.

## `stream`

```python
stream(stream_or_device: 'Stream | Device | str') -> '_PlacementContext'
```

stream(stream_or_device) -> a placement region

Run the region on a stream: operations inside issue onto it in order
and land their outputs there. A :class:`Device` (or a device string)
stands for that device's default stream at each operation.

## `sub`

```python
subsub(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

sub(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
sub(input: clika_runtime._core.ops.Scalar, other: clika_runtime._core.Tensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

sub(input, other, alpha=1.0, *, activation='identity') -> Tensor

The `sub` operator.

## `sub_`

```python
sub_sub_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor
```

sub_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor, alpha: float = 1.0, *, activation: object | None = 'identity') -> clika_runtime._core.Tensor

sub_(self, other, alpha=1.0, *, activation='identity') -> Tensor

The `sub_` operator.

## `sum`

```python
sumsum(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor
```

sum(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], keepdim: bool = False, *, dtype: clika_runtime._core.DataType = DataType.Undefined) -> clika_runtime._core.Tensor

sum(input, dims=[], keepdim=False, *, dtype=Undefined) -> Tensor

The `sum` operator.

## `swiglu`

```python
swigluswiglu(input: clika_runtime._core.Tensor, alpha: float = 1.0, beta: float = 0.0, limit: float = inf) -> clika_runtime._core.Tensor
```

swiglu(input: clika_runtime._core.Tensor, alpha: float = 1.0, beta: float = 0.0, limit: float = inf) -> clika_runtime._core.Tensor

swiglu(input, alpha=1.0, beta=0.0, limit=None) -> Tensor

The `swiglu` operator.

## `synchronize`

```python
synchronize(target: 'Stream | Device | str | None' = None) -> 'None'
```

synchronize(target=None) -> None

Block until the targeted work has completed.

``None`` (the default) synchronizes the stream the calling thread's
ambient placement resolves to: a set stream as is, a set device's
current lane for this thread, and, with nothing set, the calling
thread's current lane on the cpu. A :class:`Device` (or device string)
drains that device: every lane of that device is waited on, so the
device's queued work is complete on return, and no other device's lane
is waited on. A :class:`Stream` synchronizes itself. Prefer this
targeted form over ``ops.synchronize_all`` (which stalls every stream
in the process).

## `synchronize_all`

```python
synchronize_allsynchronize_all() -> None
```

synchronize_all() -> None

synchronize_all() -> None

The `synchronize_all` operator.

## `synchronous`

```python
synchronous() -> '_SynchronousScope'
```

synchronous() -> an execution-mode region

Every operation inside completes before it returns: the calling
thread's lane is settled on enter, then the region runs one operation
at a time (deterministic stepping and debugging; pipelining is
given up). Nests inside :func:`device` / :func:`stream` regions.

## `take`

```python
taketake(self: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

take(self: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

take(self, index) -> Tensor

The `take` operator.

## `take_along_dim`

```python
take_along_dimtake_along_dim(input: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor, dim: int | None = None) -> clika_runtime._core.Tensor
```

take_along_dim(input: clika_runtime._core.Tensor, index: clika_runtime._core.Tensor, dim: int | None = None) -> clika_runtime._core.Tensor

take_along_dim(input, index, dim=None) -> Tensor

The `take_along_dim` operator.

## `tan`

```python
tantan(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

tan(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

tan(input) -> Tensor

The `tan` operator.

## `tan_`

```python
tan_tan_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

tan_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

tan_(self) -> Tensor

The `tan_` operator.

## `tanh`

```python
tanhtanh(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

tanh(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

tanh(input) -> Tensor

The `tanh` operator.

## `tanh_`

```python
tanh_tanh_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

tanh_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

tanh_(self) -> Tensor

The `tanh_` operator.

## `tensor`

```python
tensor(data: 'object', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

tensor(data, *, dtype=None, device=None) -> Tensor

A tensor from an array, a nested Python list, a number, or a tensor.

Arrays and lists copy in on the CPU and move to ``device`` when asked.
Lists of Python floats enter at the default dtype (:func:`get_default_dtype`);
ints at ``int64``; bools at ``bool``. Python data packs its own payload,
so no array library is needed; an array enters through the buffer
protocol or DLPack at its own dtype. When ``dtype`` names a type a
payload cannot spell directly (``bfloat16``, the ``float8`` family,
sub-byte codes), the data enters at a carrier type and converts through
the runtime; pass raw payloads to :meth:`Tensor.from_bytes` to skip the
conversion entirely. A ``Tensor`` argument passes through, converted
when ``dtype`` or ``device`` ask for a change (the result may share
its storage). Inside a meta-init region the result is storage-free.

## `tensordot`

```python
tensordottensordot(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, dims_a: collections.abc.Sequence[int], dims_b: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor
```

tensordot(input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor, dims_a: collections.abc.Sequence[int], dims_b: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor

tensordot(input, other, dims_a, dims_b) -> Tensor

The `tensordot` operator.

## `threshold`

```python
thresholdthreshold(input: clika_runtime._core.Tensor, threshold: float, value: float) -> clika_runtime._core.Tensor
```

threshold(input: clika_runtime._core.Tensor, threshold: float, value: float) -> clika_runtime._core.Tensor

threshold(input, threshold, value) -> Tensor

The `threshold` operator.

## `threshold_`

```python
threshold_threshold_(self: clika_runtime._core.Tensor, threshold: float, value: float) -> clika_runtime._core.Tensor
```

threshold_(self: clika_runtime._core.Tensor, threshold: float, value: float) -> clika_runtime._core.Tensor

threshold_(self, threshold, value) -> Tensor

The `threshold_` operator.

## `tile`

```python
tiletile(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor
```

tile(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor

tile(input, dims) -> Tensor

The `tile` operator.

## `to`

```python
toto(src: clika_runtime._core.Tensor, *, target: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor
```

to(src: clika_runtime._core.Tensor, *, target: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor
to(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], *, target: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> list[clika_runtime._core.Tensor]
to(src: clika_runtime._core.Tensor, device_str: str) -> clika_runtime._core.Tensor

Overloaded function.

1. ``to(src: clika_runtime._core.Tensor, *, target: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor``

to(src, *, target=None) -> Tensor

The `to` operator.

2. ``to(tensors: collections.abc.Sequence[clika_runtime._core.Tensor], *, target: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> list[clika_runtime._core.Tensor]``

to(tensors, *, target=None) -> list[Tensor]

The `to` operator.

3. ``to(src: clika_runtime._core.Tensor, device_str: str) -> clika_runtime._core.Tensor``

to(src, device_str) -> Tensor

The `to` operator.

## `topk`

```python
topktopk(input: clika_runtime._core.Tensor, k: int, dim: int = -1, largest: bool = True, sorted: bool = True) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

topk(input: clika_runtime._core.Tensor, k: int, dim: int = -1, largest: bool = True, sorted: bool = True) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]

topk(input, k, dim=-1, largest=True, sorted=True) -> tuple[Tensor, Tensor]

The `topk` operator.

## `trace`

```python
trace(fn: 'Callable[..., object]', inputs: 'object' = None, *, example_inputs: 'object' = None, signature: 'Sequence[TensorSpec] | None' = None, input_names: 'Sequence[str]' = (), output_names: 'Sequence[str]' = (), graph_name: 'str' = 'traced_model') -> 'TracedGraph'
```

trace(fn, example_inputs, *, input_names=(), output_names=(), graph_name="traced_model") -> TracedGraph

Record ``fn`` once into a graph. Two roads name the inputs:
``trace(fn, example_inputs=...)`` derives the graph inputs from example
tensors (their shapes and dtypes matter, their values are never read),
and ``trace(fn, signature)`` declares them as :class:`TensorSpec` values
(a -1 dim is dynamic). The second positional argument is read as a
signature when it is a sequence of ``TensorSpec`` values and as the
example inputs otherwise.

A module is called as ``module(*example_inputs)``; a plain callable is
called with ``example_inputs`` as its one argument (a list of tensors
for a list-in/list-out function, or any pytree). Tensor leaves feed the
graph in flattening order, static leaves are baked in, and the result's
tensor leaves are the graph outputs. Reading a tensor's value inside
``fn`` during the recording raises. ``input_names`` and
``output_names`` name the flattened tensors in order (defaults:
``input_<i>`` and ``output_<i>``; a dict key names its tensor).

The result carries the graph as ``.graph`` and answers the graph's own
methods directly (``run``, ``input_names``, ``output_names``,
``nodes``). The graph comes back as recorded: ``optimize()`` it when
wanted, ``to()`` a device, device string or stream to choose where it
runs, then ``finalize()`` it, and it runs.

## `tracing`

```python
tracing() -> '_TracingScope'
```

tracing() -> an execution-mode region

Operations inside record into a lazy graph and return unevaluated
handles;
nothing runs until a value is read through ``clika_runtime.eval`` (a
plain read of a traced value raises). :func:`eager` re-enables
immediate execution for a nested region.

## `transpose`

```python
transposetranspose(input: clika_runtime._core.Tensor, dim0: int, dim1: int) -> clika_runtime._core.Tensor
```

transpose(input: clika_runtime._core.Tensor, dim0: int, dim1: int) -> clika_runtime._core.Tensor

transpose(input, dim0, dim1) -> Tensor

The `transpose` operator.

## `tril`

```python
triltril(input: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor
```

tril(input: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

tril(input, diagonal=0) -> Tensor

The `tril` operator.

## `tril_`

```python
tril_tril_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor
```

tril_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

tril_(self, diagonal=0) -> Tensor

The `tril_` operator.

## `triu`

```python
triutriu(input: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor
```

triu(input: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

triu(input, diagonal=0) -> Tensor

The `triu` operator.

## `triu_`

```python
triu_triu_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor
```

triu_(self: clika_runtime._core.Tensor, diagonal: int = 0) -> clika_runtime._core.Tensor

triu_(self, diagonal=0) -> Tensor

The `triu_` operator.

## `trunc`

```python
trunctrunc(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

trunc(input: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

trunc(input) -> Tensor

The `trunc` operator.

## `trunc_`

```python
trunc_trunc_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

trunc_(self: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

trunc_(self) -> Tensor

The `trunc_` operator.

## `unflatten`

```python
unflattenunflatten(input: clika_runtime._core.Tensor, dim: int, sizes: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor
```

unflatten(input: clika_runtime._core.Tensor, dim: int, sizes: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor

unflatten(input, dim, sizes) -> Tensor

The `unflatten` operator.

## `unfold`

```python
unfoldunfold(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], stride: collections.abc.Sequence[int] = [], mode: object = 'constant', value: float | None = None) -> clika_runtime._core.Tensor
```

unfold(input: clika_runtime._core.Tensor, kernel_size: collections.abc.Sequence[int], dilation: collections.abc.Sequence[int] = [], padding: collections.abc.Sequence[int] = [], stride: collections.abc.Sequence[int] = [], mode: object = 'constant', value: float | None = None) -> clika_runtime._core.Tensor

unfold(input, kernel_size, dilation=[], padding=[], stride=[], mode='constant', value=None) -> Tensor

The `unfold` operator.

## `uniform_`

```python
uniform_uniform_(self: clika_runtime._core.Tensor, low: float = 0.0, high: float = 1.0, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor
```

uniform_(self: clika_runtime._core.Tensor, low: float = 0.0, high: float = 1.0, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

uniform_(self, low=0.0, high=1.0, *, device=None) -> Tensor

The `uniform_` operator.

## `unique`

```python
uniqueunique(input: clika_runtime._core.Tensor, sorted: bool = True, return_inverse: bool = False, return_counts: bool = False, dim: int | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

unique(input: clika_runtime._core.Tensor, sorted: bool = True, return_inverse: bool = False, return_counts: bool = False, dim: int | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

unique(input, sorted=True, return_inverse=False, return_counts=False, dim=None) -> tuple[Tensor, Tensor, Tensor]

The `unique` operator.

## `unique_consecutive`

```python
unique_consecutiveunique_consecutive(input: clika_runtime._core.Tensor, return_inverse: bool = False, return_counts: bool = False, dim: int | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

unique_consecutive(input: clika_runtime._core.Tensor, return_inverse: bool = False, return_counts: bool = False, dim: int | None = None) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor, clika_runtime._core.Tensor]

unique_consecutive(input, return_inverse=False, return_counts=False, dim=None) -> tuple[Tensor, Tensor, Tensor]

The `unique_consecutive` operator.

## `unsqueeze`

```python
unsqueezeunsqueeze(input: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor
```

unsqueeze(input: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor

unsqueeze(input, dim) -> Tensor

The `unsqueeze` operator.

## `unsqueeze_`

```python
unsqueeze_unsqueeze_(self: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor
```

unsqueeze_(self: clika_runtime._core.Tensor, dim: int) -> clika_runtime._core.Tensor

unsqueeze_(self, dim) -> Tensor

The `unsqueeze_` operator.

## `upsample_bicubic2d`

```python
upsample_bicubic2dupsample_bicubic2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor
```

upsample_bicubic2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor

upsample_bicubic2d(input, sizes=[], scale_factors=[], align_corners=False) -> Tensor

The `upsample_bicubic2d` operator.

## `upsample_bilinear2d`

```python
upsample_bilinear2dupsample_bilinear2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor
```

upsample_bilinear2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor

upsample_bilinear2d(input, sizes=[], scale_factors=[], align_corners=False) -> Tensor

The `upsample_bilinear2d` operator.

## `upsample_linear1d`

```python
upsample_linear1dupsample_linear1d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor
```

upsample_linear1d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor

upsample_linear1d(input, sizes=[], scale_factors=[], align_corners=False) -> Tensor

The `upsample_linear1d` operator.

## `upsample_nearest1d`

```python
upsample_nearest1dupsample_nearest1d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor
```

upsample_nearest1d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor

upsample_nearest1d(input, sizes=[], scale_factors=[]) -> Tensor

The `upsample_nearest1d` operator.

## `upsample_nearest2d`

```python
upsample_nearest2dupsample_nearest2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor
```

upsample_nearest2d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor

upsample_nearest2d(input, sizes=[], scale_factors=[]) -> Tensor

The `upsample_nearest2d` operator.

## `upsample_nearest3d`

```python
upsample_nearest3dupsample_nearest3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor
```

upsample_nearest3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = []) -> clika_runtime._core.Tensor

upsample_nearest3d(input, sizes=[], scale_factors=[]) -> Tensor

The `upsample_nearest3d` operator.

## `upsample_trilinear3d`

```python
upsample_trilinear3dupsample_trilinear3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor
```

upsample_trilinear3d(input: clika_runtime._core.Tensor, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], scale_factors: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor] = [], align_corners: bool = False) -> clika_runtime._core.Tensor

upsample_trilinear3d(input, sizes=[], scale_factors=[], align_corners=False) -> Tensor

The `upsample_trilinear3d` operator.

## `validate_rotary_dim`

```python
validate_rotary_dimvalidate_rotary_dim(rotary_dim: int, head_dim: int = -1) -> None
```

validate_rotary_dim(rotary_dim: int, head_dim: int = -1) -> None

validate_rotary_dim(rotary_dim, head_dim=-1) -> None

The `validate_rotary_dim` operator.

## `var`

```python
varvar(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], correction: int = 1, keepdim: bool = False) -> clika_runtime._core.Tensor
```

var(input: clika_runtime._core.Tensor, dims: collections.abc.Sequence[int] = [], correction: int = 1, keepdim: bool = False) -> clika_runtime._core.Tensor

var(input, dims=[], correction=1, keepdim=False) -> Tensor

The `var` operator.

## `version`

```python
versionversion() -> str
```

version() -> str

The ClikaRT runtime version string (e.g. "0.1.0").

## `where`

```python
wherewhere(condition: clika_runtime._core.Tensor, input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

where(condition: clika_runtime._core.Tensor, input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
where(condition: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor

Overloaded function.

1. ``where(condition: clika_runtime._core.Tensor, input: clika_runtime._core.Tensor, other: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

where(condition, input, other) -> Tensor

The `where` operator.

2. ``where(condition: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor``

where(condition) -> Tensor

The `where` operator.

## `xlog1py`

```python
xlog1pyxlog1py(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

xlog1py(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

xlog1py(input, other) -> Tensor

The `xlog1py` operator.

## `xlogy`

```python
xlogyxlogy(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

xlogy(input: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

xlogy(input, other) -> Tensor

The `xlogy` operator.

## `xlogy_`

```python
xlogy_xlogy_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

xlogy_(self: clika_runtime._core.Tensor, other: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

xlogy_(self, other) -> Tensor

The `xlogy_` operator.

## `zero_`

```python
zero_zero_(self: clika_runtime._core.Tensor, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor
```

zero_(self: clika_runtime._core.Tensor, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

zero_(self, *, device=None) -> Tensor

The `zero_` operator.

## `zeros`

```python
zeros(*size: 'ShapeDim', dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

zeros(*size, dtype=None, device=None) -> Tensor

A zero-filled tensor; the default dtype unless ``dtype`` says otherwise.

## `zeros_like`

```python
zeros_like(input: 'Tensor', *, dtype: 'DtypeLike' = None, device: 'DeviceLike' = None) -> 'Tensor'
```

zeros_like(input, *, dtype=None, device=None) -> Tensor

A zero-filled tensor of ``input``'s shape, dtype and device, each
overridable by keyword.