---
title: "Tensor"
sidebar_label: "Tensor"
description: "The clika_runtime Tensor class."
---

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

An n-dimensional array on a device. Operators run asynchronously and return at once; a read (numpy(), item(), tolist(), print) waits for the value. Build one with clika_runtime.tensor(...), the factories (zeros, ones, randn, ...), from_numpy or from_dlpack.

## `T` (property)

The tensor with every dimension reversed (a view).

## `device` (property)

(self) -> clika_runtime._core.Device

## `dtype` (property)

The element dtype object (clika_runtime.float32, ...).

## `is_fake` (property)

True for a declared, storage-free tensor (a parameter slot before load_state_dict binds it): its metadata reads, its data does not.

## `is_quantized` (property)

True when a quantization scheme rides the tensor (quantized_view() names it).

## `mT` (property)

The tensor with its last two dimensions swapped (a view).

## `nbytes` (property)

Payload size in bytes at the tensor's own dtype.

## `ndim` (property)

The number of dimensions.

## `shape` (property)

The dimensions as a Size (a tuple with numel()).

## `__init__`

```python
__init__(self, /, *args, **kwargs)
```

Initialize self.  See help(type(self)) for accurate signature.

## `abs`

```python
absabs(self) -> clika_runtime._core.Tensor
```

abs(self) -> clika_runtime._core.Tensor

abs() -> Tensor

Method form of clika_runtime.ops.abs.

## `abs_`

```python
abs_abs_(self) -> object
```

abs_(self) -> object

abs_() -> Tensor

Method form of clika_runtime.ops.abs_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `acos`

```python
acosacos(self) -> clika_runtime._core.Tensor
```

acos(self) -> clika_runtime._core.Tensor

acos() -> Tensor

Method form of clika_runtime.ops.acos.

## `acos_`

```python
acos_acos_(self) -> object
```

acos_(self) -> object

acos_() -> Tensor

Method form of clika_runtime.ops.acos_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `acosh`

```python
acoshacosh(self) -> clika_runtime._core.Tensor
```

acosh(self) -> clika_runtime._core.Tensor

acosh() -> Tensor

Method form of clika_runtime.ops.acosh.

## `acosh_`

```python
acosh_acosh_(self) -> object
```

acosh_(self) -> object

acosh_() -> Tensor

Method form of clika_runtime.ops.acosh_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `adaptive_avg_pool`

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

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

adaptive_avg_pool(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_avg_pool.

## `adaptive_avg_pool1d`

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

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

adaptive_avg_pool1d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_avg_pool1d.

## `adaptive_avg_pool2d`

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

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

adaptive_avg_pool2d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_avg_pool2d.

## `adaptive_avg_pool3d`

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

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

adaptive_avg_pool3d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_avg_pool3d.

## `adaptive_max_pool`

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

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

adaptive_max_pool(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_max_pool.

## `adaptive_max_pool1d`

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

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

adaptive_max_pool1d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_max_pool1d.

## `adaptive_max_pool2d`

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

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

adaptive_max_pool2d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_max_pool2d.

## `adaptive_max_pool3d`

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

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

adaptive_max_pool3d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_max_pool3d.

## `add`

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

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

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

Method form of clika_runtime.ops.add.

## `add_`

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

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

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

Method form of clika_runtime.ops.add_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `add_layer_norm`

```python
add_layer_normadd_layer_norm(self, 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(self, 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(residual=None, post_residual=None, normalized_shape=[], skip_bias=None, weight=None, bias=None, eps=None, *, activation=None) -> tuple[Tensor, Tensor]

Method form of clika_runtime.ops.add_layer_norm.

## `add_rms_norm`

```python
add_rms_normadd_rms_norm(self, 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(self, 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(residual=None, residual2=None, post_residual=None, normalized_shape=[], skip_bias=None, weight=None, bias=None, eps=None, *, activation=None) -> tuple[Tensor, Tensor]

Method form of clika_runtime.ops.add_rms_norm.

## `all`

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

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

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

Method form of clika_runtime.ops.all.

## `allclose`

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

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

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

Method form of clika_runtime.ops.allclose.

## `amax`

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

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

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

Method form of clika_runtime.ops.amax.

## `amin`

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

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

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

Method form of clika_runtime.ops.amin.

## `aminmax`

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

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

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

Method form of clika_runtime.ops.aminmax.

## `any`

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

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

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

Method form of clika_runtime.ops.any.

## `argmax`

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

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

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

Method form of clika_runtime.ops.argmax.

## `argmin`

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

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

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

Method form of clika_runtime.ops.argmin.

## `argsort`

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

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

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

Method form of clika_runtime.ops.argsort.

## `asin`

```python
asinasin(self) -> clika_runtime._core.Tensor
```

asin(self) -> clika_runtime._core.Tensor

asin() -> Tensor

Method form of clika_runtime.ops.asin.

## `asin_`

```python
asin_asin_(self) -> object
```

asin_(self) -> object

asin_() -> Tensor

Method form of clika_runtime.ops.asin_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `asinh`

```python
asinhasinh(self) -> clika_runtime._core.Tensor
```

asinh(self) -> clika_runtime._core.Tensor

asinh() -> Tensor

Method form of clika_runtime.ops.asinh.

## `asinh_`

```python
asinh_asinh_(self) -> object
```

asinh_(self) -> object

asinh_() -> Tensor

Method form of clika_runtime.ops.asinh_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `atan`

```python
atanatan(self) -> clika_runtime._core.Tensor
```

atan(self) -> clika_runtime._core.Tensor

atan() -> Tensor

Method form of clika_runtime.ops.atan.

## `atan2`

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

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

atan2(other) -> Tensor

Method form of clika_runtime.ops.atan2.

## `atan2_`

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

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

atan2_(other) -> Tensor

Method form of clika_runtime.ops.atan2_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `atan_`

```python
atan_atan_(self) -> object
```

atan_(self) -> object

atan_() -> Tensor

Method form of clika_runtime.ops.atan_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `atanh`

```python
atanhatanh(self) -> clika_runtime._core.Tensor
```

atanh(self) -> clika_runtime._core.Tensor

atanh() -> Tensor

Method form of clika_runtime.ops.atanh.

## `atanh_`

```python
atanh_atanh_(self) -> object
```

atanh_(self) -> object

atanh_() -> Tensor

Method form of clika_runtime.ops.atanh_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `atleast_1d`

```python
atleast_1datleast_1d(self) -> clika_runtime._core.Tensor
```

atleast_1d(self) -> clika_runtime._core.Tensor

atleast_1d() -> Tensor

Method form of clika_runtime.ops.atleast_1d.

## `atleast_2d`

```python
atleast_2datleast_2d(self) -> clika_runtime._core.Tensor
```

atleast_2d(self) -> clika_runtime._core.Tensor

atleast_2d() -> Tensor

Method form of clika_runtime.ops.atleast_2d.

## `atleast_3d`

```python
atleast_3datleast_3d(self) -> clika_runtime._core.Tensor
```

atleast_3d(self) -> clika_runtime._core.Tensor

atleast_3d() -> Tensor

Method form of clika_runtime.ops.atleast_3d.

## `avg_pool`

```python
avg_poolavg_pool(self, 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(self, 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(kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override) -> Tensor

Method form of clika_runtime.ops.avg_pool.

## `avg_pool1d`

```python
avg_pool1davg_pool1d(self, 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(self, 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(kernel_size, stride=[], padding=[0], ceil_mode=False, count_include_pad=True) -> Tensor

Method form of clika_runtime.ops.avg_pool1d.

## `avg_pool2d`

```python
avg_pool2davg_pool2d(self, 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(self, 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(kernel_size, stride=[], padding=[0, 0], ceil_mode=False, count_include_pad=True, divisor_override=None) -> Tensor

Method form of clika_runtime.ops.avg_pool2d.

## `avg_pool3d`

```python
avg_pool3davg_pool3d(self, 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(self, 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(kernel_size, stride=[], padding=[0, 0, 0], ceil_mode=False, count_include_pad=True, divisor_override=None) -> Tensor

Method form of clika_runtime.ops.avg_pool3d.

## `batch_norm`

```python
batch_normbatch_norm(self, 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(self, 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(weight=None, bias=None, running_mean=None, running_var=None, eps=None, *, activation=None) -> Tensor

Method form of clika_runtime.ops.batch_norm.

## `bernoulli_`

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

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

bernoulli_(*, device=None) -> Tensor

Method form of clika_runtime.ops.bernoulli_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `binary_cross_entropy`

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

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

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

Method form of clika_runtime.ops.binary_cross_entropy.

## `binary_cross_entropy_with_logits`

```python
binary_cross_entropy_with_logitsbinary_cross_entropy_with_logits(self, 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(self, 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(target, weight=None, reduction='mean', pos_weight=None) -> Tensor

Method form of clika_runtime.ops.binary_cross_entropy_with_logits.

## `bincount`

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

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

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

Method form of clika_runtime.ops.bincount.

## `bitwise_and`

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

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

bitwise_and(other) -> Tensor

Method form of clika_runtime.ops.bitwise_and.

## `bitwise_and_`

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

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

bitwise_and_(other) -> Tensor

Method form of clika_runtime.ops.bitwise_and_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `bitwise_left_shift`

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

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

bitwise_left_shift(other) -> Tensor

Method form of clika_runtime.ops.bitwise_left_shift.

## `bitwise_left_shift_`

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

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

bitwise_left_shift_(other) -> Tensor

Method form of clika_runtime.ops.bitwise_left_shift_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `bitwise_not`

```python
bitwise_notbitwise_not(self) -> clika_runtime._core.Tensor
```

bitwise_not(self) -> clika_runtime._core.Tensor

bitwise_not() -> Tensor

Method form of clika_runtime.ops.bitwise_not.

## `bitwise_not_`

```python
bitwise_not_bitwise_not_(self) -> object
```

bitwise_not_(self) -> object

bitwise_not_() -> Tensor

Method form of clika_runtime.ops.bitwise_not_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `bitwise_or`

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

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

bitwise_or(other) -> Tensor

Method form of clika_runtime.ops.bitwise_or.

## `bitwise_or_`

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

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

bitwise_or_(other) -> Tensor

Method form of clika_runtime.ops.bitwise_or_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `bitwise_right_shift`

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

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

bitwise_right_shift(other) -> Tensor

Method form of clika_runtime.ops.bitwise_right_shift.

## `bitwise_right_shift_`

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

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

bitwise_right_shift_(other) -> Tensor

Method form of clika_runtime.ops.bitwise_right_shift_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `bitwise_xor`

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

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

bitwise_xor(other) -> Tensor

Method form of clika_runtime.ops.bitwise_xor.

## `bitwise_xor_`

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

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

bitwise_xor_(other) -> Tensor

Method form of clika_runtime.ops.bitwise_xor_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `bmm`

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

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

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

Method form of clika_runtime.ops.bmm.

## `broadcast_to`

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

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

broadcast_to(shape) -> Tensor

Method form of clika_runtime.ops.broadcast_to.

## `bucketize`

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

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

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

Method form of clika_runtime.ops.bucketize.

## `bytes`

```python
bytesbytes(self) -> bytes
```

bytes(self) -> bytes

bytes() -> bytes

The host-contiguous payload at the tensor's OWN dtype; lossless for every dtype, bfloat16/float8/sub-byte included. Inside a tracing scope the value is not computed yet and this raises.

## `cast`

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

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

cast(target, force_copy=False) -> Tensor

Method form of clika_runtime.ops.cast.

## `cast_like`

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

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

cast_like(reference) -> Tensor

Method form of clika_runtime.ops.cast_like.

## `causal_conv_update`

```python
causal_conv_updatecausal_conv_update(self, 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(self, 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(weight, bias, state, seq_lens=None, slot_ids=None, *, activation=None) -> Tensor

Method form of clika_runtime.ops.causal_conv_update.

## `ceil`

```python
ceilceil(self) -> clika_runtime._core.Tensor
```

ceil(self) -> clika_runtime._core.Tensor

ceil() -> Tensor

Method form of clika_runtime.ops.ceil.

## `ceil_`

```python
ceil_ceil_(self) -> object
```

ceil_(self) -> object

ceil_() -> Tensor

Method form of clika_runtime.ops.ceil_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `celu`

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

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

celu(alpha=1.0) -> Tensor

Method form of clika_runtime.ops.celu.

## `celu_`

```python
celu_celu_(self, alpha: float = 1.0) -> object
```

celu_(self, alpha: float = 1.0) -> object

celu_(alpha=1.0) -> Tensor

Method form of clika_runtime.ops.celu_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `chunk`

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

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

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

Method form of clika_runtime.ops.chunk.

## `circular_pad`

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

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

circular_pad(pad) -> Tensor

Method form of clika_runtime.ops.circular_pad.

## `clamp`

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

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

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

Method form of clika_runtime.ops.clamp.

## `clamp_`

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

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

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

Method form of clika_runtime.ops.clamp_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `clamp_max`

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

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

clamp_max(max) -> Tensor

Method form of clika_runtime.ops.clamp_max.

## `clamp_max_`

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

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

clamp_max_(max) -> Tensor

Method form of clika_runtime.ops.clamp_max_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `clamp_min`

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

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

clamp_min(min) -> Tensor

Method form of clika_runtime.ops.clamp_min.

## `clamp_min_`

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

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

clamp_min_(min) -> Tensor

Method form of clika_runtime.ops.clamp_min_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `constant_pad`

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

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

constant_pad(pad, value=None) -> Tensor

Method form of clika_runtime.ops.constant_pad.

## `contiguous`

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

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

contiguous(force_copy=False) -> Tensor

Method form of clika_runtime.ops.contiguous.

## `conv`

```python
convconv(self, 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(self, 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(weight, bias, stride, padding, dilation, groups, mode='constant', value=None, *, activation='identity') -> Tensor

Method form of clika_runtime.ops.conv.

## `conv1d`

```python
conv1dconv1d(self, 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(self, 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(weight, bias=None, stride=[1], padding=[0], dilation=[1], groups=1, *, activation='identity') -> Tensor

Method form of clika_runtime.ops.conv1d.

## `conv2d`

```python
conv2dconv2d(self, 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(self, 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(weight, bias=None, stride=[1, 1], padding=[0, 0], dilation=[1, 1], groups=1, *, activation='identity') -> Tensor

Method form of clika_runtime.ops.conv2d.

## `conv3d`

```python
conv3dconv3d(self, 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(self, 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(weight, bias=None, stride=[1, 1, 1], padding=[0, 0, 0], dilation=[1, 1, 1], groups=1, *, activation='identity') -> Tensor

Method form of clika_runtime.ops.conv3d.

## `conv_transpose`

```python
conv_transposeconv_transpose(self, 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(self, 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(weight, bias, stride, padding, output_padding, groups, dilation, *, activation='identity') -> Tensor

Method form of clika_runtime.ops.conv_transpose.

## `conv_transpose1d`

```python
conv_transpose1dconv_transpose1d(self, 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(self, 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(weight, bias=None, stride=[1], padding=[0, 0], output_padding=[0], groups=1, dilation=[1], *, activation='identity') -> Tensor

Method form of clika_runtime.ops.conv_transpose1d.

## `conv_transpose2d`

```python
conv_transpose2dconv_transpose2d(self, 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(self, 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(weight, bias=None, stride=[1, 1], padding=[0, 0, 0, 0], output_padding=[0, 0], groups=1, dilation=[1, 1], *, activation='identity') -> Tensor

Method form of clika_runtime.ops.conv_transpose2d.

## `conv_transpose3d`

```python
conv_transpose3dconv_transpose3d(self, 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(self, 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(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

Method form of clika_runtime.ops.conv_transpose3d.

## `copy_`

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

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

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

Method form of clika_runtime.ops.copy_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `copysign`

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

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

copysign(other) -> Tensor

Method form of clika_runtime.ops.copysign.

## `copysign_`

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

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

copysign_(other) -> Tensor

Method form of clika_runtime.ops.copysign_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `cos`

```python
coscos(self) -> clika_runtime._core.Tensor
```

cos(self) -> clika_runtime._core.Tensor

cos() -> Tensor

Method form of clika_runtime.ops.cos.

## `cos_`

```python
cos_cos_(self) -> object
```

cos_(self) -> object

cos_() -> Tensor

Method form of clika_runtime.ops.cos_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `cosh`

```python
coshcosh(self) -> clika_runtime._core.Tensor
```

cosh(self) -> clika_runtime._core.Tensor

cosh() -> Tensor

Method form of clika_runtime.ops.cosh.

## `cosh_`

```python
cosh_cosh_(self) -> object
```

cosh_(self) -> object

cosh_() -> Tensor

Method form of clika_runtime.ops.cosh_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `count_nonzero`

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

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

count_nonzero(dims=[]) -> Tensor

Method form of clika_runtime.ops.count_nonzero.

## `cross`

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

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

cross(other, dim=None) -> Tensor

Method form of clika_runtime.ops.cross.

## `cross_entropy`

```python
cross_entropycross_entropy(self, 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(self, 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(target, weight=None, ignore_index=None, reduction='mean') -> Tensor

Method form of clika_runtime.ops.cross_entropy.

## `cummax`

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

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

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

Method form of clika_runtime.ops.cummax.

## `cummin`

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

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

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

Method form of clika_runtime.ops.cummin.

## `cumprod`

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

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

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

Method form of clika_runtime.ops.cumprod.

## `cumprod_`

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

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

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

Method form of clika_runtime.ops.cumprod_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `cumsum`

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

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

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

Method form of clika_runtime.ops.cumsum.

## `cumsum_`

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

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

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

Method form of clika_runtime.ops.cumsum_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `deform_conv`

```python
deform_convdeform_conv(self, 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(self, 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(weight, offset, mask=None, bias=None, stride=[], padding=[], dilation=[], groups=1, offset_groups=1, *, activation='identity') -> Tensor

Method form of clika_runtime.ops.deform_conv.

## `deg2rad`

```python
deg2raddeg2rad(self) -> clika_runtime._core.Tensor
```

deg2rad(self) -> clika_runtime._core.Tensor

deg2rad() -> Tensor

Method form of clika_runtime.ops.deg2rad.

## `deg2rad_`

```python
deg2rad_deg2rad_(self) -> object
```

deg2rad_(self) -> object

deg2rad_() -> Tensor

Method form of clika_runtime.ops.deg2rad_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `diag`

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

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

diag(diagonal=0) -> Tensor

Method form of clika_runtime.ops.diag.

## `diag_embed`

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

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

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

Method form of clika_runtime.ops.diag_embed.

## `diagonal`

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

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

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

Method form of clika_runtime.ops.diagonal.

## `diff`

```python
diffdiff(self, 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(self, 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(n=1, dim=-1, prepend=None, append=None) -> Tensor

Method form of clika_runtime.ops.diff.

## `dim`

```python
dimdim(self) -> int
```

dim(self) -> int

dim() -> int

The number of dimensions.

## `div`

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

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

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

Method form of clika_runtime.ops.div.

## `div_`

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

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

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

Method form of clika_runtime.ops.div_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `dot`

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

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

dot(other) -> Tensor

Method form of clika_runtime.ops.dot.

## `dynamic_quantize`

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

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

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

Method form of clika_runtime.ops.dynamic_quantize.

## `element_size`

```python
element_sizeelement_size(self) -> int
```

element_size(self) -> int

element_size() -> int

Bytes per element (1 for the sub-byte dtypes).

## `elu`

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

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

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

Method form of clika_runtime.ops.elu.

## `elu_`

```python
elu_elu_(self, alpha: float = 1.0, scale: float = 1.0, input_scale: float = 1.0) -> object
```

elu_(self, alpha: float = 1.0, scale: float = 1.0, input_scale: float = 1.0) -> object

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

Method form of clika_runtime.ops.elu_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `eq`

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

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

eq(other) -> Tensor

Method form of clika_runtime.ops.eq.

## `eq_`

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

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

eq_(other) -> Tensor

Method form of clika_runtime.ops.eq_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `erf`

```python
erferf(self) -> clika_runtime._core.Tensor
```

erf(self) -> clika_runtime._core.Tensor

erf() -> Tensor

Method form of clika_runtime.ops.erf.

## `erf_`

```python
erf_erf_(self) -> object
```

erf_(self) -> object

erf_() -> Tensor

Method form of clika_runtime.ops.erf_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `erfc`

```python
erfcerfc(self) -> clika_runtime._core.Tensor
```

erfc(self) -> clika_runtime._core.Tensor

erfc() -> Tensor

Method form of clika_runtime.ops.erfc.

## `erfc_`

```python
erfc_erfc_(self) -> object
```

erfc_(self) -> object

erfc_() -> Tensor

Method form of clika_runtime.ops.erfc_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `erfinv`

```python
erfinverfinv(self) -> clika_runtime._core.Tensor
```

erfinv(self) -> clika_runtime._core.Tensor

erfinv() -> Tensor

Method form of clika_runtime.ops.erfinv.

## `erfinv_`

```python
erfinv_erfinv_(self) -> object
```

erfinv_(self) -> object

erfinv_() -> Tensor

Method form of clika_runtime.ops.erfinv_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `exp`

```python
expexp(self) -> clika_runtime._core.Tensor
```

exp(self) -> clika_runtime._core.Tensor

exp() -> Tensor

Method form of clika_runtime.ops.exp.

## `exp_`

```python
exp_exp_(self) -> object
```

exp_(self) -> object

exp_() -> Tensor

Method form of clika_runtime.ops.exp_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `expand`

```python
expandexpand(self, *args) -> clika_runtime._core.Tensor
```

expand(self, *args) -> clika_runtime._core.Tensor

expand(*sizes) -> Tensor

A broadcast view to the given sizes (-1 keeps a dimension); dims as separate arguments or one sequence.

## `expand_as`

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

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

expand_as(other) -> Tensor

Method form of clika_runtime.ops.expand_as.

## `exponential_`

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

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

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

Method form of clika_runtime.ops.exponential_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `fake`

```python
fakefake(spec: clika_runtime._core.FakeTensor) -> clika_runtime._core.Tensor
```

fake(spec: clika_runtime._core.FakeTensor) -> clika_runtime._core.Tensor

fake(spec) -> Tensor

A tensor with the shape, dtype and placement of a FakeTensor and no storage: a declared slot a checkpoint binds later. Its metadata reads; a data read raises until it is bound.

## `fast_gelu`

```python
fast_gelufast_gelu(self) -> clika_runtime._core.Tensor
```

fast_gelu(self) -> clika_runtime._core.Tensor

fast_gelu() -> Tensor

Method form of clika_runtime.ops.fast_gelu.

## `fill`

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

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

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

Method form of clika_runtime.ops.fill.

## `fill_`

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

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

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

Method form of clika_runtime.ops.fill_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `fill_diagonal`

```python
fill_diagonalfill_diagonal(self, 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: clika_runtime._core.ops.Scalar, wrap: bool = False, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> clika_runtime._core.Tensor

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

Method form of clika_runtime.ops.fill_diagonal.

## `fill_diagonal_`

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

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

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

Method form of clika_runtime.ops.fill_diagonal_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `flatten`

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

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

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

Method form of clika_runtime.ops.flatten.

## `flip`

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

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

flip(dims) -> Tensor

Method form of clika_runtime.ops.flip.

## `fliplr`

```python
fliplrfliplr(self) -> clika_runtime._core.Tensor
```

fliplr(self) -> clika_runtime._core.Tensor

fliplr() -> Tensor

Method form of clika_runtime.ops.fliplr.

## `flipud`

```python
flipudflipud(self) -> clika_runtime._core.Tensor
```

flipud(self) -> clika_runtime._core.Tensor

flipud() -> Tensor

Method form of clika_runtime.ops.flipud.

## `floor`

```python
floorfloor(self) -> clika_runtime._core.Tensor
```

floor(self) -> clika_runtime._core.Tensor

floor() -> Tensor

Method form of clika_runtime.ops.floor.

## `floor_`

```python
floor_floor_(self) -> object
```

floor_(self) -> object

floor_() -> Tensor

Method form of clika_runtime.ops.floor_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `floor_divide`

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

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

floor_divide(other) -> Tensor

Method form of clika_runtime.ops.floor_divide.

## `floor_divide_`

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

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

floor_divide_(other) -> Tensor

Method form of clika_runtime.ops.floor_divide_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `fmax`

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

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

fmax(other) -> Tensor

Method form of clika_runtime.ops.fmax.

## `fmin`

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

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

fmin(other) -> Tensor

Method form of clika_runtime.ops.fmin.

## `fmod`

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

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

fmod(other) -> Tensor

Method form of clika_runtime.ops.fmod.

## `fmod_`

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

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

fmod_(other) -> Tensor

Method form of clika_runtime.ops.fmod_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `fold`

```python
foldfold(self, 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(self, 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(output_size, kernel_size, dilation=[], padding=[], stride=[], mode='constant', value=None) -> Tensor

Method form of clika_runtime.ops.fold.

## `frac`

```python
fracfrac(self) -> clika_runtime._core.Tensor
```

frac(self) -> clika_runtime._core.Tensor

frac() -> Tensor

Method form of clika_runtime.ops.frac.

## `frac_`

```python
frac_frac_(self) -> object
```

frac_(self) -> object

frac_() -> Tensor

Method form of clika_runtime.ops.frac_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `frexp`

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

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

frexp() -> tuple[Tensor, Tensor]

Method form of clika_runtime.ops.frexp.

## `from_bytes`

```python
from_bytesfrom_bytes(data: bytes, shape: collections.abc.Sequence[int], dtype: clika_runtime._core.DataType, device: clika_runtime._core.ops.StreamOrDevice | None = None) -> clika_runtime._core.Tensor
```

from_bytes(data: bytes, shape: collections.abc.Sequence[int], dtype: clika_runtime._core.DataType, device: clika_runtime._core.ops.StreamOrDevice | None = None) -> clika_runtime._core.Tensor

Store a raw payload AS `dtype`: the entry for dtypes numpy cannot spell (bfloat16, float8, sub-byte codes). len(data) must equal the shape's packed byte size.

## `from_data`

```python
from_datafrom_data(array: ndarray[order='C', device='cpu', writable=False], device: clika_runtime._core.ops.StreamOrDevice | None = None) -> clika_runtime._core.Tensor
```

from_data(array: ndarray[order='C', device='cpu', writable=False], device: clika_runtime._core.ops.StreamOrDevice | None = None) -> clika_runtime._core.Tensor

Copy a C-contiguous numpy array (any numpy-native dtype) into a new tensor on `device`; unspecified consults the calling thread's ambient placement and falls back to the cpu.

## `gated_rms_norm`

```python
gated_rms_normgated_rms_norm(self, 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(self, 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(gate, normalized_shape, weight=None, eps=None) -> Tensor

Method form of clika_runtime.ops.gated_rms_norm.

## `gather`

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

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

gather(dim, index) -> Tensor

Method form of clika_runtime.ops.gather.

## `ge`

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

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

ge(other) -> Tensor

Method form of clika_runtime.ops.ge.

## `ge_`

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

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

ge_(other) -> Tensor

Method form of clika_runtime.ops.ge_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `geglu`

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

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

geglu(approximate='none') -> Tensor

Method form of clika_runtime.ops.geglu.

## `gelu`

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

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

gelu(approximate='none') -> Tensor

Method form of clika_runtime.ops.gelu.

## `gelu_`

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

gelu_(self, approximate: object | None = 'none') -> object

gelu_(approximate='none') -> Tensor

Method form of clika_runtime.ops.gelu_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `glu`

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

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

glu(dim=-1) -> Tensor

Method form of clika_runtime.ops.glu.

## `grid_sample`

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

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

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

Method form of clika_runtime.ops.grid_sample.

## `group_norm`

```python
group_normgroup_norm(self, 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(self, 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(num_groups, weight=None, bias=None, running_mean=None, running_var=None, eps=None, *, activation=None) -> Tensor

Method form of clika_runtime.ops.group_norm.

## `gt`

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

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

gt(other) -> Tensor

Method form of clika_runtime.ops.gt.

## `gt_`

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

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

gt_(other) -> Tensor

Method form of clika_runtime.ops.gt_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `hardshrink`

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

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

hardshrink(lambd=0.5) -> Tensor

Method form of clika_runtime.ops.hardshrink.

## `hardshrink_`

```python
hardshrink_hardshrink_(self, lambd: float = 0.5) -> object
```

hardshrink_(self, lambd: float = 0.5) -> object

hardshrink_(lambd=0.5) -> Tensor

Method form of clika_runtime.ops.hardshrink_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `hardsigmoid`

```python
hardsigmoidhardsigmoid(self) -> clika_runtime._core.Tensor
```

hardsigmoid(self) -> clika_runtime._core.Tensor

hardsigmoid() -> Tensor

Method form of clika_runtime.ops.hardsigmoid.

## `hardsigmoid_`

```python
hardsigmoid_hardsigmoid_(self) -> object
```

hardsigmoid_(self) -> object

hardsigmoid_() -> Tensor

Method form of clika_runtime.ops.hardsigmoid_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `hardswish`

```python
hardswishhardswish(self) -> clika_runtime._core.Tensor
```

hardswish(self) -> clika_runtime._core.Tensor

hardswish() -> Tensor

Method form of clika_runtime.ops.hardswish.

## `hardswish_`

```python
hardswish_hardswish_(self) -> object
```

hardswish_(self) -> object

hardswish_() -> Tensor

Method form of clika_runtime.ops.hardswish_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `hardtanh`

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

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

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

Method form of clika_runtime.ops.hardtanh.

## `hardtanh_`

```python
hardtanh_hardtanh_(self, min_val: float = -1.0, max_val: float = 1.0) -> object
```

hardtanh_(self, min_val: float = -1.0, max_val: float = 1.0) -> object

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

Method form of clika_runtime.ops.hardtanh_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `hash_128`

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

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

hash_128(seed=0) -> Tensor

Method form of clika_runtime.ops.hash_128.

## `hash_256`

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

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

hash_256(seed=0) -> Tensor

Method form of clika_runtime.ops.hash_256.

## `hash_64`

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

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

hash_64(seed=0) -> Tensor

Method form of clika_runtime.ops.hash_64.

## `hash_lanes`

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

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

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

Method form of clika_runtime.ops.hash_lanes.

## `hash_tensor`

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

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

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

Method form of clika_runtime.ops.hash_tensor.

## `histogram`

```python
histogramhistogram(self, 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(self, 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(bins=100, range=None, weight=None, density=False) -> tuple[Tensor, Tensor]

Method form of clika_runtime.ops.histogram.

## `huber_loss`

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

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

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

Method form of clika_runtime.ops.huber_loss.

## `hypot`

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

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

hypot(other) -> Tensor

Method form of clika_runtime.ops.hypot.

## `hypot_`

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

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

hypot_(other) -> Tensor

Method form of clika_runtime.ops.hypot_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `index`

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

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

index(indices) -> Tensor

Method form of clika_runtime.ops.index.

## `index_add`

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

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

index_add(dim, indices, src) -> Tensor

Method form of clika_runtime.ops.index_add.

## `index_add_`

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

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

index_add_(dim, indices, src) -> Tensor

Method form of clika_runtime.ops.index_add_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `index_copy`

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

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

index_copy(dim, indices, src) -> Tensor

Method form of clika_runtime.ops.index_copy.

## `index_copy_`

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

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

index_copy_(dim, indices, src) -> Tensor

Method form of clika_runtime.ops.index_copy_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `index_fill`

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

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

index_fill(dim, indices, value) -> Tensor

Method form of clika_runtime.ops.index_fill.

## `index_fill_`

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

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

index_fill_(dim, indices, value) -> Tensor

Method form of clika_runtime.ops.index_fill_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `index_put`

```python
index_putindex_put(self, 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: collections.abc.Sequence[clika_runtime._core.ops.IndexEntry], value: clika_runtime._core.ops.ScalarOrTensor, accumulate: bool = False) -> clika_runtime._core.Tensor

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

Method form of clika_runtime.ops.index_put.

## `index_put_`

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

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

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

Method form of clika_runtime.ops.index_put_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `index_select`

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

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

index_select(dim, index) -> Tensor

Method form of clika_runtime.ops.index_select.

## `inner`

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

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

inner(other) -> Tensor

Method form of clika_runtime.ops.inner.

## `instance_norm`

```python
instance_norminstance_norm(self, 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(self, 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(weight=None, bias=None, running_mean=None, running_var=None, eps=None, *, activation=None) -> Tensor

Method form of clika_runtime.ops.instance_norm.

## `interpolate`

```python
interpolateinterpolate(self, 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(self, 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(sizes=[], scale_factors=[], mode='nearest', align_corners=None, recompute_scale_factor=False, antialias=False) -> Tensor

Method form of clika_runtime.ops.interpolate.

## `is_contiguous`

```python
is_contiguousis_contiguous(self) -> bool
```

is_contiguous(self) -> bool

is_contiguous() -> bool

True when the elements are laid out densely in row-major order.

## `isclose`

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

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

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

Method form of clika_runtime.ops.isclose.

## `isfinite`

```python
isfiniteisfinite(self) -> clika_runtime._core.Tensor
```

isfinite(self) -> clika_runtime._core.Tensor

isfinite() -> Tensor

Method form of clika_runtime.ops.isfinite.

## `isinf`

```python
isinfisinf(self) -> clika_runtime._core.Tensor
```

isinf(self) -> clika_runtime._core.Tensor

isinf() -> Tensor

Method form of clika_runtime.ops.isinf.

## `isnan`

```python
isnanisnan(self) -> clika_runtime._core.Tensor
```

isnan(self) -> clika_runtime._core.Tensor

isnan() -> Tensor

Method form of clika_runtime.ops.isnan.

## `isneginf`

```python
isneginfisneginf(self) -> clika_runtime._core.Tensor
```

isneginf(self) -> clika_runtime._core.Tensor

isneginf() -> Tensor

Method form of clika_runtime.ops.isneginf.

## `isposinf`

```python
isposinfisposinf(self) -> clika_runtime._core.Tensor
```

isposinf(self) -> clika_runtime._core.Tensor

isposinf() -> Tensor

Method form of clika_runtime.ops.isposinf.

## `item`

```python
itemitem(self) -> object
```

item(self) -> object

item() -> bool | int | float

The value of a one-element tensor as a Python number (waits for the value). Inside a tracing scope the value is not computed yet and this raises; clika_runtime.eval(tensor) computes it.

## `kl_div`

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

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

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

Method form of clika_runtime.ops.kl_div.

## `kron`

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

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

kron(other) -> Tensor

Method form of clika_runtime.ops.kron.

## `kthvalue`

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

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

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

Method form of clika_runtime.ops.kthvalue.

## `l1_loss`

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

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

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

Method form of clika_runtime.ops.l1_loss.

## `layer_norm`

```python
layer_normlayer_norm(self, 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(self, 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(normalized_shape, weight=None, bias=None, eps=None, *, activation=None) -> Tensor

Method form of clika_runtime.ops.layer_norm.

## `le`

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

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

le(other) -> Tensor

Method form of clika_runtime.ops.le.

## `le_`

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

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

le_(other) -> Tensor

Method form of clika_runtime.ops.le_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `leaky_relu`

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

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

leaky_relu(negative_slope=0.01) -> Tensor

Method form of clika_runtime.ops.leaky_relu.

## `leaky_relu_`

```python
leaky_relu_leaky_relu_(self, negative_slope: float = 0.01) -> object
```

leaky_relu_(self, negative_slope: float = 0.01) -> object

leaky_relu_(negative_slope=0.01) -> Tensor

Method form of clika_runtime.ops.leaky_relu_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `linear`

```python
linearlinear(self, 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(self, 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(weight, bias=None, *, activation=None, situ_beta=0.0, situ_linear_beta=0.0) -> Tensor

Method form of clika_runtime.ops.linear.

## `log`

```python
loglog(self) -> clika_runtime._core.Tensor
```

log(self) -> clika_runtime._core.Tensor

log() -> Tensor

Method form of clika_runtime.ops.log.

## `log10`

```python
log10log10(self) -> clika_runtime._core.Tensor
```

log10(self) -> clika_runtime._core.Tensor

log10() -> Tensor

Method form of clika_runtime.ops.log10.

## `log10_`

```python
log10_log10_(self) -> object
```

log10_(self) -> object

log10_() -> Tensor

Method form of clika_runtime.ops.log10_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `log1p`

```python
log1plog1p(self) -> clika_runtime._core.Tensor
```

log1p(self) -> clika_runtime._core.Tensor

log1p() -> Tensor

Method form of clika_runtime.ops.log1p.

## `log1p_`

```python
log1p_log1p_(self) -> object
```

log1p_(self) -> object

log1p_() -> Tensor

Method form of clika_runtime.ops.log1p_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `log2`

```python
log2log2(self) -> clika_runtime._core.Tensor
```

log2(self) -> clika_runtime._core.Tensor

log2() -> Tensor

Method form of clika_runtime.ops.log2.

## `log2_`

```python
log2_log2_(self) -> object
```

log2_(self) -> object

log2_() -> Tensor

Method form of clika_runtime.ops.log2_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `log_`

```python
log_log_(self) -> object
```

log_(self) -> object

log_() -> Tensor

Method form of clika_runtime.ops.log_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `log_sigmoid`

```python
log_sigmoidlog_sigmoid(self) -> clika_runtime._core.Tensor
```

log_sigmoid(self) -> clika_runtime._core.Tensor

log_sigmoid() -> Tensor

Method form of clika_runtime.ops.log_sigmoid.

## `log_sigmoid_`

```python
log_sigmoid_log_sigmoid_(self) -> object
```

log_sigmoid_(self) -> object

log_sigmoid_() -> Tensor

Method form of clika_runtime.ops.log_sigmoid_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `log_softmax`

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

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

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

Method form of clika_runtime.ops.log_softmax.

## `log_softmax_`

```python
log_softmax_log_softmax_(self, dim: int = -1) -> object
```

log_softmax_(self, dim: int = -1) -> object

log_softmax_(dim=-1) -> Tensor

Method form of clika_runtime.ops.log_softmax_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `logaddexp`

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

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

logaddexp(other) -> Tensor

Method form of clika_runtime.ops.logaddexp.

## `logaddexp2`

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

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

logaddexp2(other) -> Tensor

Method form of clika_runtime.ops.logaddexp2.

## `logical_and`

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

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

logical_and(other) -> Tensor

Method form of clika_runtime.ops.logical_and.

## `logical_and_`

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

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

logical_and_(other) -> Tensor

Method form of clika_runtime.ops.logical_and_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `logical_not`

```python
logical_notlogical_not(self) -> clika_runtime._core.Tensor
```

logical_not(self) -> clika_runtime._core.Tensor

logical_not() -> Tensor

Method form of clika_runtime.ops.logical_not.

## `logical_not_`

```python
logical_not_logical_not_(self) -> object
```

logical_not_(self) -> object

logical_not_() -> Tensor

Method form of clika_runtime.ops.logical_not_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `logical_or`

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

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

logical_or(other) -> Tensor

Method form of clika_runtime.ops.logical_or.

## `logical_or_`

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

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

logical_or_(other) -> Tensor

Method form of clika_runtime.ops.logical_or_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `logical_xor`

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

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

logical_xor(other) -> Tensor

Method form of clika_runtime.ops.logical_xor.

## `logical_xor_`

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

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

logical_xor_(other) -> Tensor

Method form of clika_runtime.ops.logical_xor_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `logit`

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

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

logit(eps=None) -> Tensor

Method form of clika_runtime.ops.logit.

## `logit_`

```python
logit_logit_(self, eps: float | None = None) -> object
```

logit_(self, eps: float | None = None) -> object

logit_(eps=None) -> Tensor

Method form of clika_runtime.ops.logit_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `logsumexp`

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

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

logsumexp(dims, keepdim=False) -> Tensor

Method form of clika_runtime.ops.logsumexp.

## `lt`

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

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

lt(other) -> Tensor

Method form of clika_runtime.ops.lt.

## `lt_`

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

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

lt_(other) -> Tensor

Method form of clika_runtime.ops.lt_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `masked_fill`

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

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

masked_fill(mask, value) -> Tensor

Method form of clika_runtime.ops.masked_fill.

## `masked_fill_`

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

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

masked_fill_(mask, value) -> Tensor

Method form of clika_runtime.ops.masked_fill_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `masked_scatter`

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

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

masked_scatter(mask, source) -> Tensor

Method form of clika_runtime.ops.masked_scatter.

## `masked_scatter_`

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

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

masked_scatter_(mask, source) -> Tensor

Method form of clika_runtime.ops.masked_scatter_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `masked_select`

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

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

masked_select(mask) -> Tensor

Method form of clika_runtime.ops.masked_select.

## `matmul`

```python
matmulmatmul(self, 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(self, 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(other, bias=None, *, activation=None, transpose_a=False, transpose_b=False, situ_beta=0.0, situ_linear_beta=0.0) -> Tensor

Method form of clika_runtime.ops.matmul.

## `max`

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

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

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

Method form of clika_runtime.ops.max.

## `max_pool`

```python
max_poolmax_pool(self, 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(self, 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(kernel_size, stride, padding, dilation, ceil_mode) -> Tensor

Method form of clika_runtime.ops.max_pool.

## `max_pool1d`

```python
max_pool1dmax_pool1d(self, 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(self, 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(kernel_size, stride=[], padding=[0], dilation=[1], ceil_mode=False) -> Tensor

Method form of clika_runtime.ops.max_pool1d.

## `max_pool1d_with_indices`

```python
max_pool1d_with_indicesmax_pool1d_with_indices(self, 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(self, 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(kernel_size, stride=[], padding=[0], dilation=[1], ceil_mode=False) -> tuple[Tensor, Tensor]

Method form of clika_runtime.ops.max_pool1d_with_indices.

## `max_pool2d`

```python
max_pool2dmax_pool2d(self, 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(self, 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(kernel_size, stride=[], padding=[0, 0], dilation=[1, 1], ceil_mode=False) -> Tensor

Method form of clika_runtime.ops.max_pool2d.

## `max_pool2d_with_indices`

```python
max_pool2d_with_indicesmax_pool2d_with_indices(self, 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(self, 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(kernel_size, stride=[], padding=[0, 0], dilation=[1, 1], ceil_mode=False) -> tuple[Tensor, Tensor]

Method form of clika_runtime.ops.max_pool2d_with_indices.

## `max_pool3d`

```python
max_pool3dmax_pool3d(self, 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(self, 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(kernel_size, stride=[], padding=[0, 0, 0], dilation=[1, 1, 1], ceil_mode=False) -> Tensor

Method form of clika_runtime.ops.max_pool3d.

## `max_pool3d_with_indices`

```python
max_pool3d_with_indicesmax_pool3d_with_indices(self, 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(self, 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(kernel_size, stride=[], padding=[0, 0, 0], dilation=[1, 1, 1], ceil_mode=False) -> tuple[Tensor, Tensor]

Method form of clika_runtime.ops.max_pool3d_with_indices.

## `max_pool_with_indices`

```python
max_pool_with_indicesmax_pool_with_indices(self, 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(self, 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(kernel_size, stride, padding, dilation, ceil_mode) -> tuple[Tensor, Tensor]

Method form of clika_runtime.ops.max_pool_with_indices.

## `maximum`

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

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

maximum(other) -> Tensor

Method form of clika_runtime.ops.maximum.

## `maximum_`

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

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

maximum_(other) -> Tensor

Method form of clika_runtime.ops.maximum_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `mean`

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

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

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

Method form of clika_runtime.ops.mean.

## `median`

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

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

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

Method form of clika_runtime.ops.median.

## `min`

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

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

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

Method form of clika_runtime.ops.min.

## `minimum`

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

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

minimum(other) -> Tensor

Method form of clika_runtime.ops.minimum.

## `minimum_`

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

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

minimum_(other) -> Tensor

Method form of clika_runtime.ops.minimum_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `mish`

```python
mishmish(self) -> clika_runtime._core.Tensor
```

mish(self) -> clika_runtime._core.Tensor

mish() -> Tensor

Method form of clika_runtime.ops.mish.

## `mish_`

```python
mish_mish_(self) -> object
```

mish_(self) -> object

mish_() -> Tensor

Method form of clika_runtime.ops.mish_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `mm`

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

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

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

Method form of clika_runtime.ops.mm.

## `mod`

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

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

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

Method form of clika_runtime.ops.mod.

## `mod_`

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

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

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

Method form of clika_runtime.ops.mod_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `moe`

```python
moemoe(self, 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(self, 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(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

Method form of clika_runtime.ops.moe.

## `mrope_rotary_embedding`

```python
mrope_rotary_embeddingmrope_rotary_embedding(self, 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(self, 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(position_ids, mrope_sections, interleaved_sections=None, theta=None, scaling=None, mode=None, rotary_dim=None, scale=None) -> Tensor

Method form of clika_runtime.ops.mrope_rotary_embedding.

## `mrope_rotary_embedding_varlen`

```python
mrope_rotary_embedding_varlenmrope_rotary_embedding_varlen(self, 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(self, 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(position_ids, mrope_sections, interleaved_sections=None, theta=None, scaling=None, mode=None, rotary_dim=None, scale=None) -> Tensor

Method form of clika_runtime.ops.mrope_rotary_embedding_varlen.

## `mse_loss`

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

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

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

Method form of clika_runtime.ops.mse_loss.

## `mul`

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

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

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

Method form of clika_runtime.ops.mul.

## `mul_`

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

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

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

Method form of clika_runtime.ops.mul_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `mv`

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

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

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

Method form of clika_runtime.ops.mv.

## `nan_to_num`

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

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

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

Method form of clika_runtime.ops.nan_to_num.

## `nan_to_num_`

```python
nan_to_num_nan_to_num_(self, nan: float | None = None, posinf: float | None = None, neginf: float | None = None) -> object
```

nan_to_num_(self, nan: float | None = None, posinf: float | None = None, neginf: float | None = None) -> object

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

Method form of clika_runtime.ops.nan_to_num_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `nanmean`

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

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

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

Method form of clika_runtime.ops.nanmean.

## `nanmedian`

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

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

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

Method form of clika_runtime.ops.nanmedian.

## `nanquantile`

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

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

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

Method form of clika_runtime.ops.nanquantile.

## `nansum`

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

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

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

Method form of clika_runtime.ops.nansum.

## `narrow`

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

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

narrow(dim, start, length) -> Tensor

Method form of clika_runtime.ops.narrow.

## `ndim_host`

```python
ndim_hostndim_host(self) -> clika_runtime._core.Tensor
```

ndim_host(self) -> clika_runtime._core.Tensor

ndim_host() -> Tensor

Method form of clika_runtime.ops.ndim_host.

## `ne`

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

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

ne(other) -> Tensor

Method form of clika_runtime.ops.ne.

## `ne_`

```python
ne_ne_(self, other: clika_runtime._core.ops.ScalarOrTensor) -> object
```

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

ne_(other) -> Tensor

Method form of clika_runtime.ops.ne_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `neg`

```python
negneg(self) -> clika_runtime._core.Tensor
```

neg(self) -> clika_runtime._core.Tensor

neg() -> Tensor

Method form of clika_runtime.ops.neg.

## `neg_`

```python
neg_neg_(self) -> object
```

neg_(self) -> object

neg_() -> Tensor

Method form of clika_runtime.ops.neg_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `nll_loss`

```python
nll_lossnll_loss(self, 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(self, 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(target, weight=None, ignore_index=None, reduction='mean') -> Tensor

Method form of clika_runtime.ops.nll_loss.

## `nonzero`

```python
nonzerononzero(self) -> clika_runtime._core.Tensor
```

nonzero(self) -> clika_runtime._core.Tensor

nonzero() -> Tensor

Method form of clika_runtime.ops.nonzero.

## `norm`

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

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

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

Method form of clika_runtime.ops.norm.

## `normal_`

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

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

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

Method form of clika_runtime.ops.normal_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `normalize`

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

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

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

Method form of clika_runtime.ops.normalize.

## `normalize_`

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

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

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

Method form of clika_runtime.ops.normalize_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `numel`

```python
numelnumel(self) -> int
```

numel(self) -> int

numel() -> int

The element count.

## `numel_host`

```python
numel_hostnumel_host(self) -> clika_runtime._core.Tensor
```

numel_host(self) -> clika_runtime._core.Tensor

numel_host() -> Tensor

Method form of clika_runtime.ops.numel_host.

## `numpy`

```python
numpynumpy(self) -> numpy.ndarray[]
```

numpy(self) -> numpy.ndarray[]

numpy() -> numpy.ndarray

A ZERO-COPY numpy view over the tensor's cpu storage, taken once the tensor's pending work has settled; mutations alias both ways, and the array keeps the storage alive. A later in-place op on the tensor writes asynchronously on the calling thread's placement, so synchronize it (crt.synchronize(), or crt.synchronize(stream) for an explicit stream) or call numpy() again before reading the view. A device tensor raises TypeError (move it first: t.to('cpu').numpy()); a dtype with no numpy twin raises TypeError; use bytes() or cast(). Inside a tracing scope the value is not computed yet and this raises; clika_runtime.eval(tensor) computes it.

## `outer`

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

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

outer(other) -> Tensor

Method form of clika_runtime.ops.outer.

## `pad`

```python
padpad(self, 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(self, 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(pad, mode='constant', value=None) -> Tensor

Method form of clika_runtime.ops.pad.

## `pdist`

```python
pdistpdist(self, p: clika_runtime._core.ops.Scalar = Scalar(...)) -> clika_runtime._core.Tensor
```

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

pdist(p=2.0) -> Tensor

Method form of clika_runtime.ops.pdist.

## `permute`

```python
permutepermute(self, *args) -> clika_runtime._core.Tensor
```

permute(self, *args) -> clika_runtime._core.Tensor

permute(*dims) -> Tensor

A view with the dimensions reordered; dims as separate arguments or one sequence.

## `pixel_shuffle`

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

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

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

Method form of clika_runtime.ops.pixel_shuffle.

## `pixel_unshuffle`

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

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

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

Method form of clika_runtime.ops.pixel_unshuffle.

## `pow`

```python
powpow(self, exponent: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

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

pow(exponent) -> Tensor

Method form of clika_runtime.ops.pow.

## `pow_`

```python
pow_pow_(self, exponent: clika_runtime._core.ops.ScalarOrTensor) -> object
```

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

pow_(exponent) -> Tensor

Method form of clika_runtime.ops.pow_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `prelu`

```python
preluprelu(self, weight: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.Tensor
```

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

prelu(weight=None) -> Tensor

Method form of clika_runtime.ops.prelu.

## `prelu_`

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

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

prelu_(weight=None) -> Tensor

Method form of clika_runtime.ops.prelu_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `prod`

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

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

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

Method form of clika_runtime.ops.prod.

## `put`

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

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

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

Method form of clika_runtime.ops.put.

## `put_`

```python
put_put_(self, index: clika_runtime._core.Tensor, source: clika_runtime._core.Tensor, accumulate: bool = False) -> object
```

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

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

Method form of clika_runtime.ops.put_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `qconv1d_woq`

```python
qconv1d_woqqconv1d_woq(self, 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(self, 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(weight, bias=None, stride=[1], padding=[0], dilation=[1], groups=1, *, activation='identity') -> Tensor

Method form of clika_runtime.ops.qconv1d_woq.

## `qconv2d_woq`

```python
qconv2d_woqqconv2d_woq(self, 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(self, 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(weight, bias=None, stride=[1, 1], padding=[0, 0], dilation=[1, 1], groups=1, *, activation='identity') -> Tensor

Method form of clika_runtime.ops.qconv2d_woq.

## `qconv3d_woq`

```python
qconv3d_woqqconv3d_woq(self, 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(self, 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(weight, bias=None, stride=[1, 1, 1], padding=[0, 0, 0], dilation=[1, 1, 1], groups=1, *, activation='identity') -> Tensor

Method form of clika_runtime.ops.qconv3d_woq.

## `qconv_transpose1d_woq`

```python
qconv_transpose1d_woqqconv_transpose1d_woq(self, 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(self, 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(weight, bias=None, stride=[1], padding=[0], output_padding=[0], dilation=[1], groups=1, *, activation='identity') -> Tensor

Method form of clika_runtime.ops.qconv_transpose1d_woq.

## `qconv_transpose2d_woq`

```python
qconv_transpose2d_woqqconv_transpose2d_woq(self, 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(self, 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(weight, bias=None, stride=[1, 1], padding=[0, 0], output_padding=[0, 0], dilation=[1, 1], groups=1, *, activation='identity') -> Tensor

Method form of clika_runtime.ops.qconv_transpose2d_woq.

## `qconv_transpose3d_woq`

```python
qconv_transpose3d_woqqconv_transpose3d_woq(self, 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(self, 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(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

Method form of clika_runtime.ops.qconv_transpose3d_woq.

## `qconv_transpose_woq`

```python
qconv_transpose_woqqconv_transpose_woq(self, 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(self, 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(weight, bias=None, stride=[], padding=[], output_padding=[], dilation=[], groups=1, *, activation='identity', compute_mode='exact_fp') -> Tensor

Method form of clika_runtime.ops.qconv_transpose_woq.

## `qconv_woq`

```python
qconv_woqqconv_woq(self, 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(self, 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(weight, bias=None, stride=[], padding=[], dilation=[], groups=1, mode='constant', value=None, *, activation='identity', compute_mode='exact_fp') -> Tensor

Method form of clika_runtime.ops.qconv_woq.

## `qdeform_conv_woq`

```python
qdeform_conv_woqqdeform_conv_woq(self, 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(self, 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(weight, offset, mask=None, bias=None, stride=[], padding=[], dilation=[], groups=1, offset_groups=1, *, activation='identity', compute_mode='exact_fp') -> Tensor

Method form of clika_runtime.ops.qdeform_conv_woq.

## `qlinear_woq`

```python
qlinear_woqqlinear_woq(self, 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(self, 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(weight, bias=None, *, activation=None, compute_mode='exact_fp') -> Tensor

Method form of clika_runtime.ops.qlinear_woq.

## `qlinear_woq_`

```python
qlinear_woq_qlinear_woq_(self, 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_(self, 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_(weight, out, bias=None, *, activation=None, compute_mode='exact_fp') -> Tensor

Method form of clika_runtime.ops.qlinear_woq_.

## `qmatmul_woq`

```python
qmatmul_woqqmatmul_woq(self, 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(self, 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(other, bias=None, *, activation=None, transpose_a=False, transpose_b=False, compute_mode='exact_fp') -> Tensor

Method form of clika_runtime.ops.qmatmul_woq.

## `qmatmul_woq_`

```python
qmatmul_woq_qmatmul_woq_(self, 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_(self, 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_(other, out, bias=None, *, activation=None, transpose_a=False, transpose_b=False, compute_mode='exact_fp') -> Tensor

Method form of clika_runtime.ops.qmatmul_woq_.

## `qmoe_woq`

```python
qmoe_woqqmoe_woq(self, 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(self, 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(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

Method form of clika_runtime.ops.qmoe_woq.

## `quantile`

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

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

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

Method form of clika_runtime.ops.quantile.

## `quantize`

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

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

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

Method form of clika_runtime.ops.quantize.

## `quantize_`

```python
quantize_quantize_(self, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
```

quantize_(self, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor
quantize_(self, 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_(self, out: clika_runtime._core.QTensor) -> clika_runtime._core.QTensor``

quantize_(out) -> QTensor

Method form of clika_runtime.ops.quantize_.

2. ``quantize_(self, 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_(out, scale, zero_point=None, quant_axis=-1, block_size=0) -> Tensor

Method form of clika_runtime.ops.quantize_.

## `quantize_dequantize`

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

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

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

Method form of clika_runtime.ops.quantize_dequantize.

## `quantize_to_scheme`

```python
quantize_to_schemequantize_to_scheme(self, scheme: str, scale: clika_runtime._core.Tensor | None = None) -> clika_runtime._core.QTensor
```

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

quantize_to_scheme(scheme, scale=None) -> QTensor

Method form of clika_runtime.ops.quantize_to_scheme.

## `quick_gelu`

```python
quick_geluquick_gelu(self) -> clika_runtime._core.Tensor
```

quick_gelu(self) -> clika_runtime._core.Tensor

quick_gelu() -> Tensor

Method form of clika_runtime.ops.quick_gelu.

## `rad2deg`

```python
rad2degrad2deg(self) -> clika_runtime._core.Tensor
```

rad2deg(self) -> clika_runtime._core.Tensor

rad2deg() -> Tensor

Method form of clika_runtime.ops.rad2deg.

## `rad2deg_`

```python
rad2deg_rad2deg_(self) -> object
```

rad2deg_(self) -> object

rad2deg_() -> Tensor

Method form of clika_runtime.ops.rad2deg_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `random_`

```python
random_random_(self, low: int | None = None, high: int | None = None, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> object
```

random_(self, low: int | None = None, high: int | None = None, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> object

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

Method form of clika_runtime.ops.random_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `reciprocal`

```python
reciprocalreciprocal(self) -> clika_runtime._core.Tensor
```

reciprocal(self) -> clika_runtime._core.Tensor

reciprocal() -> Tensor

Method form of clika_runtime.ops.reciprocal.

## `reciprocal_`

```python
reciprocal_reciprocal_(self) -> object
```

reciprocal_(self) -> object

reciprocal_() -> Tensor

Method form of clika_runtime.ops.reciprocal_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `reflect_pad`

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

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

reflect_pad(pad) -> Tensor

Method form of clika_runtime.ops.reflect_pad.

## `reglu`

```python
reglureglu(self) -> clika_runtime._core.Tensor
```

reglu(self) -> clika_runtime._core.Tensor

reglu() -> Tensor

Method form of clika_runtime.ops.reglu.

## `relu`

```python
relurelu(self) -> clika_runtime._core.Tensor
```

relu(self) -> clika_runtime._core.Tensor

relu() -> Tensor

Method form of clika_runtime.ops.relu.

## `relu6`

```python
relu6relu6(self) -> clika_runtime._core.Tensor
```

relu6(self) -> clika_runtime._core.Tensor

relu6() -> Tensor

Method form of clika_runtime.ops.relu6.

## `relu6_`

```python
relu6_relu6_(self) -> object
```

relu6_(self) -> object

relu6_() -> Tensor

Method form of clika_runtime.ops.relu6_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `relu_`

```python
relu_relu_(self) -> object
```

relu_(self) -> object

relu_() -> Tensor

Method form of clika_runtime.ops.relu_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `remainder`

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

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

remainder(other) -> Tensor

Method form of clika_runtime.ops.remainder.

## `remainder_`

```python
remainder_remainder_(self, other: clika_runtime._core.ops.ScalarOrTensor) -> object
```

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

remainder_(other) -> Tensor

Method form of clika_runtime.ops.remainder_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `renorm`

```python
renormrenorm(self, 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: clika_runtime._core.ops.Scalar, dim: int, maxnorm: clika_runtime._core.ops.Scalar, eps: float | None = None) -> clika_runtime._core.Tensor

renorm(p, dim, maxnorm, eps=None) -> Tensor

Method form of clika_runtime.ops.renorm.

## `renorm_`

```python
renorm_renorm_(self, p: clika_runtime._core.ops.Scalar, dim: int, maxnorm: clika_runtime._core.ops.Scalar, eps: float | None = None) -> object
```

renorm_(self, p: clika_runtime._core.ops.Scalar, dim: int, maxnorm: clika_runtime._core.ops.Scalar, eps: float | None = None) -> object

renorm_(p, dim, maxnorm, eps=None) -> Tensor

Method form of clika_runtime.ops.renorm_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `repeat`

```python
repeatrepeat(self, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor
```

repeat(self, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor

repeat(sizes) -> Tensor

Method form of clika_runtime.ops.repeat.

## `repeat_interleave`

```python
repeat_interleaverepeat_interleave(self, repeats: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, output_size: int | None = None) -> clika_runtime._core.Tensor
```

repeat_interleave(self, repeats: clika_runtime._core.ops.ScalarOrTensor, dim: int | None = None, output_size: int | None = None) -> clika_runtime._core.Tensor

repeat_interleave(repeats, dim=None, output_size=None) -> Tensor

Method form of clika_runtime.ops.repeat_interleave.

## `replicate_pad`

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

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

replicate_pad(pad) -> Tensor

Method form of clika_runtime.ops.replicate_pad.

## `resample`

```python
resampleresample(self, orig_freq: int, new_freq: int, lowpass_filter_width: int = 16, rolloff: float = 0.945, beta: float | None = None) -> clika_runtime._core.Tensor
```

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

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

Method form of clika_runtime.ops.resample.

## `reshape`

```python
reshapereshape(self, *args) -> clika_runtime._core.Tensor
```

reshape(self, *args) -> clika_runtime._core.Tensor

reshape(*shape) -> Tensor

A view with the given dimensions (one may be -1); dims as separate arguments or one sequence. Copies only when the layout cannot express the new shape.

## `reshape_as`

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

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

reshape_as(other) -> Tensor

Method form of clika_runtime.ops.reshape_as.

## `rfft`

```python
rfftrfft(self, n_fft: int | None = None, normalized: bool = False) -> clika_runtime._core.Tensor
```

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

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

Method form of clika_runtime.ops.rfft.

## `rms_norm`

```python
rms_normrms_norm(self, 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(self, 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(normalized_shape, weight=None, bias=None, eps=None, *, activation=None) -> Tensor

Method form of clika_runtime.ops.rms_norm.

## `roll`

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

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

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

Method form of clika_runtime.ops.roll.

## `rot90`

```python
rot90rot90(self, k: int = 1, dims: collections.abc.Sequence[int] = [0, 1]) -> clika_runtime._core.Tensor
```

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

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

Method form of clika_runtime.ops.rot90.

## `rotary_embedding`

```python
rotary_embeddingrotary_embedding(self, 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(self, 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(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

Method form of clika_runtime.ops.rotary_embedding.

## `rotary_embedding_varlen`

```python
rotary_embedding_varlenrotary_embedding_varlen(self, 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(self, 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(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

Method form of clika_runtime.ops.rotary_embedding_varlen.

## `round`

```python
roundround(self, decimals: int = 0) -> clika_runtime._core.Tensor
```

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

round(decimals=0) -> Tensor

Method form of clika_runtime.ops.round.

## `round_`

```python
round_round_(self, decimals: int = 0) -> object
```

round_(self, decimals: int = 0) -> object

round_(decimals=0) -> Tensor

Method form of clika_runtime.ops.round_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `rsqrt`

```python
rsqrtrsqrt(self) -> clika_runtime._core.Tensor
```

rsqrt(self) -> clika_runtime._core.Tensor

rsqrt() -> Tensor

Method form of clika_runtime.ops.rsqrt.

## `rsqrt_`

```python
rsqrt_rsqrt_(self) -> object
```

rsqrt_(self) -> object

rsqrt_() -> Tensor

Method form of clika_runtime.ops.rsqrt_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `scatter`

```python
scatterscatter(self, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

scatter(self, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

scatter(dim, index, src) -> Tensor

Method form of clika_runtime.ops.scatter.

## `scatter_`

```python
scatter_scatter_(self, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> object
```

scatter_(self, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.ops.ScalarOrTensor) -> object

scatter_(dim, index, src) -> Tensor

Method form of clika_runtime.ops.scatter_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `scatter_add`

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

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

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

Method form of clika_runtime.ops.scatter_add.

## `scatter_add_`

```python
scatter_add_scatter_add_(self, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, deterministic: bool = False) -> object
```

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

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

Method form of clika_runtime.ops.scatter_add_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `scatter_reduce`

```python
scatter_reducescatter_reduce(self, 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: 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(dim, index, src, reduce, include_self=True, deterministic=False) -> Tensor

Method form of clika_runtime.ops.scatter_reduce.

## `scatter_reduce_`

```python
scatter_reduce_scatter_reduce_(self, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: object, include_self: bool = True, deterministic: bool = False) -> object
```

scatter_reduce_(self, dim: int, index: clika_runtime._core.Tensor, src: clika_runtime._core.Tensor, reduce: object, include_self: bool = True, deterministic: bool = False) -> object

scatter_reduce_(dim, index, src, reduce, include_self=True, deterministic=False) -> Tensor

Method form of clika_runtime.ops.scatter_reduce_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `schedule`

```python
scheduleschedule(self) -> object
```

schedule(self) -> object

schedule() -> Tensor

Submit this tensor's deferred computation (work recorded under a tracing scope) on its stream without waiting for it; a tensor with no deferred work is left as it is. synchronize() waits either way; returns the same tensor.

## `select`

```python
selectselect(self, dim: int, index: clika_runtime._core.ops.IndexBound) -> clika_runtime._core.Tensor
```

select(self, dim: int, index: clika_runtime._core.ops.IndexBound) -> clika_runtime._core.Tensor

select(dim, index) -> Tensor

Method form of clika_runtime.ops.select.

## `selu`

```python
seluselu(self) -> clika_runtime._core.Tensor
```

selu(self) -> clika_runtime._core.Tensor

selu() -> Tensor

Method form of clika_runtime.ops.selu.

## `selu_`

```python
selu_selu_(self) -> object
```

selu_(self) -> object

selu_() -> Tensor

Method form of clika_runtime.ops.selu_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `sgn`

```python
sgnsgn(self) -> clika_runtime._core.Tensor
```

sgn(self) -> clika_runtime._core.Tensor

sgn() -> Tensor

Method form of clika_runtime.ops.sgn.

## `sgn_`

```python
sgn_sgn_(self) -> object
```

sgn_(self) -> object

sgn_() -> Tensor

Method form of clika_runtime.ops.sgn_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `shape_host`

```python
shape_hostshape_host(self) -> clika_runtime._core.Tensor
```

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

Overloaded function.

1. ``shape_host(self) -> clika_runtime._core.Tensor``

shape_host() -> Tensor

Method form of clika_runtime.ops.shape_host.

2. ``shape_host(self, dim: int) -> clika_runtime._core.Tensor``

shape_host(dim) -> Tensor

Method form of clika_runtime.ops.shape_host.

3. ``shape_host(self, start: int | None, end: int | None) -> clika_runtime._core.Tensor``

shape_host(start, end) -> Tensor

Method form of clika_runtime.ops.shape_host.

## `sigmoid`

```python
sigmoidsigmoid(self) -> clika_runtime._core.Tensor
```

sigmoid(self) -> clika_runtime._core.Tensor

sigmoid() -> Tensor

Method form of clika_runtime.ops.sigmoid.

## `sigmoid_`

```python
sigmoid_sigmoid_(self) -> object
```

sigmoid_(self) -> object

sigmoid_() -> Tensor

Method form of clika_runtime.ops.sigmoid_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `sign`

```python
signsign(self) -> clika_runtime._core.Tensor
```

sign(self) -> clika_runtime._core.Tensor

sign() -> Tensor

Method form of clika_runtime.ops.sign.

## `sign_`

```python
sign_sign_(self) -> object
```

sign_(self) -> object

sign_() -> Tensor

Method form of clika_runtime.ops.sign_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `silu`

```python
silusilu(self) -> clika_runtime._core.Tensor
```

silu(self) -> clika_runtime._core.Tensor

silu() -> Tensor

Method form of clika_runtime.ops.silu.

## `silu_`

```python
silu_silu_(self) -> object
```

silu_(self) -> object

silu_() -> Tensor

Method form of clika_runtime.ops.silu_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `sin`

```python
sinsin(self) -> clika_runtime._core.Tensor
```

sin(self) -> clika_runtime._core.Tensor

sin() -> Tensor

Method form of clika_runtime.ops.sin.

## `sin_`

```python
sin_sin_(self) -> object
```

sin_(self) -> object

sin_() -> Tensor

Method form of clika_runtime.ops.sin_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `sinc`

```python
sincsinc(self) -> clika_runtime._core.Tensor
```

sinc(self) -> clika_runtime._core.Tensor

sinc() -> Tensor

Method form of clika_runtime.ops.sinc.

## `sinc_`

```python
sinc_sinc_(self) -> object
```

sinc_(self) -> object

sinc_() -> Tensor

Method form of clika_runtime.ops.sinc_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `sinh`

```python
sinhsinh(self) -> clika_runtime._core.Tensor
```

sinh(self) -> clika_runtime._core.Tensor

sinh() -> Tensor

Method form of clika_runtime.ops.sinh.

## `sinh_`

```python
sinh_sinh_(self) -> object
```

sinh_(self) -> object

sinh_() -> Tensor

Method form of clika_runtime.ops.sinh_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `size`

```python
sizesize(self, dim: int | None = None) -> object
```

size(self, dim: int | None = None) -> object

size(dim=None) -> Size | int

The shape as a Size, or one dimension's extent.

## `slice`

```python
sliceslice(self, 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(self, 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(self, 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(self, 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(dim, start=None, end=None, step=1) -> Tensor

Method form of clika_runtime.ops.slice.

2. ``slice(self, 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(dim, start=[], end=[], step=[]) -> Tensor

Method form of clika_runtime.ops.slice.

## `smooth_l1_loss`

```python
smooth_l1_losssmooth_l1_loss(self, target: clika_runtime._core.Tensor, reduction: object = 'mean', beta: float = 1.0) -> clika_runtime._core.Tensor
```

smooth_l1_loss(self, target: clika_runtime._core.Tensor, reduction: object = 'mean', beta: float = 1.0) -> clika_runtime._core.Tensor

smooth_l1_loss(target, reduction='mean', beta=1.0) -> Tensor

Method form of clika_runtime.ops.smooth_l1_loss.

## `snake`

```python
snakesnake(self, 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: clika_runtime._core.Tensor | None = None, beta: clika_runtime._core.Tensor | None = None, eps: float = 1e-09) -> clika_runtime._core.Tensor

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

Method form of clika_runtime.ops.snake.

## `snake_`

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

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

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

Method form of clika_runtime.ops.snake_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `softcap_logits`

```python
softcap_logitssoftcap_logits(self, cap: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor
```

softcap_logits(self, cap: clika_runtime._core.ops.ScalarOrTensor) -> clika_runtime._core.Tensor

softcap_logits(cap) -> Tensor

Method form of clika_runtime.ops.softcap_logits.

## `softcap_logits_`

```python
softcap_logits_softcap_logits_(self, cap: clika_runtime._core.ops.ScalarOrTensor) -> object
```

softcap_logits_(self, cap: clika_runtime._core.ops.ScalarOrTensor) -> object

softcap_logits_(cap) -> Tensor

Method form of clika_runtime.ops.softcap_logits_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `softmax`

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

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

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

Method form of clika_runtime.ops.softmax.

## `softmax_`

```python
softmax_softmax_(self, dim: int = -1) -> object
```

softmax_(self, dim: int = -1) -> object

softmax_(dim=-1) -> Tensor

Method form of clika_runtime.ops.softmax_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `softmin`

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

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

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

Method form of clika_runtime.ops.softmin.

## `softmin_`

```python
softmin_softmin_(self, dim: int = -1) -> object
```

softmin_(self, dim: int = -1) -> object

softmin_(dim=-1) -> Tensor

Method form of clika_runtime.ops.softmin_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `softplus`

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

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

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

Method form of clika_runtime.ops.softplus.

## `softplus_`

```python
softplus_softplus_(self, beta: float = 1.0, threshold: float = 20.0) -> object
```

softplus_(self, beta: float = 1.0, threshold: float = 20.0) -> object

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

Method form of clika_runtime.ops.softplus_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `softshrink`

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

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

softshrink(lambd=0.5) -> Tensor

Method form of clika_runtime.ops.softshrink.

## `softshrink_`

```python
softshrink_softshrink_(self, lambd: float = 0.5) -> object
```

softshrink_(self, lambd: float = 0.5) -> object

softshrink_(lambd=0.5) -> Tensor

Method form of clika_runtime.ops.softshrink_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `softsign`

```python
softsignsoftsign(self) -> clika_runtime._core.Tensor
```

softsign(self) -> clika_runtime._core.Tensor

softsign() -> Tensor

Method form of clika_runtime.ops.softsign.

## `softsign_`

```python
softsign_softsign_(self) -> object
```

softsign_(self) -> object

softsign_() -> Tensor

Method form of clika_runtime.ops.softsign_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `sort`

```python
sortsort(self, dim: int = -1, descending: bool = False, stable: bool = False) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

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

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

Method form of clika_runtime.ops.sort.

## `split_by_size`

```python
split_by_sizesplit_by_size(self, chunk_size: int, dim: int = 0) -> list[clika_runtime._core.Tensor]
```

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

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

Method form of clika_runtime.ops.split_by_size.

## `split_with_sizes`

```python
split_with_sizessplit_with_sizes(self, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], dim: int = 0) -> list[clika_runtime._core.Tensor]
```

split_with_sizes(self, sizes: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor], dim: int = 0) -> list[clika_runtime._core.Tensor]

split_with_sizes(sizes, dim=0) -> list[Tensor]

Method form of clika_runtime.ops.split_with_sizes.

## `sqrt`

```python
sqrtsqrt(self) -> clika_runtime._core.Tensor
```

sqrt(self) -> clika_runtime._core.Tensor

sqrt() -> Tensor

Method form of clika_runtime.ops.sqrt.

## `sqrt_`

```python
sqrt_sqrt_(self) -> object
```

sqrt_(self) -> object

sqrt_() -> Tensor

Method form of clika_runtime.ops.sqrt_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `square`

```python
squaresquare(self) -> clika_runtime._core.Tensor
```

square(self) -> clika_runtime._core.Tensor

square() -> Tensor

Method form of clika_runtime.ops.square.

## `square_`

```python
square_square_(self) -> object
```

square_(self) -> object

square_() -> Tensor

Method form of clika_runtime.ops.square_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `squeeze`

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

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

squeeze(dim=[]) -> Tensor

Method form of clika_runtime.ops.squeeze.

## `squeeze_`

```python
squeeze_squeeze_(self, dim: collections.abc.Sequence[int] = []) -> object
```

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

squeeze_(dim=[]) -> Tensor

Method form of clika_runtime.ops.squeeze_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `ssd_update`

```python
ssd_updatessd_update(self, 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(self, 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(dt, a_rate, b_mat, c_mat, d_skip, dt_bias, gate, state, seq_lens=None, slot_ids=None, dt_softplus=False) -> Tensor

Method form of clika_runtime.ops.ssd_update.

## `std`

```python
stdstd(self, dims: collections.abc.Sequence[int] = [], correction: int = 1, keepdim: bool = False) -> clika_runtime._core.Tensor
```

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

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

Method form of clika_runtime.ops.std.

## `stft`

```python
stftstft(self, 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(self, 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(n_fft, hop_length=None, win_length=None, window=None, center=True, pad_mode='reflect', normalized=False, onesided=True) -> Tensor

Method form of clika_runtime.ops.stft.

## `stride`

```python
stridestride(self, dim: int | None = None) -> object
```

stride(self, dim: int | None = None) -> object

stride(dim=None) -> tuple[int, ...] | int

The element strides, or one dimension's stride.

## `sub`

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

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

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

Method form of clika_runtime.ops.sub.

## `sub_`

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

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

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

Method form of clika_runtime.ops.sub_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `sum`

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

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

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

Method form of clika_runtime.ops.sum.

## `swiglu`

```python
swigluswiglu(self, alpha: float = 1.0, beta: float = 0.0, limit: float = inf) -> clika_runtime._core.Tensor
```

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

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

Method form of clika_runtime.ops.swiglu.

## `synchronize`

```python
synchronizesynchronize(self) -> object
```

synchronize(self) -> object

synchronize() -> Tensor

Wait until this tensor's pending work has completed (the point where an asynchronous failure surfaces); returns the same tensor.

## `t`

```python
tt(self) -> clika_runtime._core.Tensor
```

t(self) -> clika_runtime._core.Tensor

t() -> Tensor

The 2-D transpose (a view); a 0-d or 1-d tensor is returned as is.

## `take`

```python
taketake(self, index: clika_runtime._core.Tensor) -> clika_runtime._core.Tensor
```

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

take(index) -> Tensor

Method form of clika_runtime.ops.take.

## `take_along_dim`

```python
take_along_dimtake_along_dim(self, index: clika_runtime._core.Tensor, dim: int | None = None) -> clika_runtime._core.Tensor
```

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

take_along_dim(index, dim=None) -> Tensor

Method form of clika_runtime.ops.take_along_dim.

## `tan`

```python
tantan(self) -> clika_runtime._core.Tensor
```

tan(self) -> clika_runtime._core.Tensor

tan() -> Tensor

Method form of clika_runtime.ops.tan.

## `tan_`

```python
tan_tan_(self) -> object
```

tan_(self) -> object

tan_() -> Tensor

Method form of clika_runtime.ops.tan_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `tanh`

```python
tanhtanh(self) -> clika_runtime._core.Tensor
```

tanh(self) -> clika_runtime._core.Tensor

tanh() -> Tensor

Method form of clika_runtime.ops.tanh.

## `tanh_`

```python
tanh_tanh_(self) -> object
```

tanh_(self) -> object

tanh_() -> Tensor

Method form of clika_runtime.ops.tanh_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `tensordot`

```python
tensordottensordot(self, other: clika_runtime._core.Tensor, dims_a: collections.abc.Sequence[int], dims_b: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor
```

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

tensordot(other, dims_a, dims_b) -> Tensor

Method form of clika_runtime.ops.tensordot.

## `threshold`

```python
thresholdthreshold(self, threshold: float, value: float) -> clika_runtime._core.Tensor
```

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

threshold(threshold, value) -> Tensor

Method form of clika_runtime.ops.threshold.

## `threshold_`

```python
threshold_threshold_(self, threshold: float, value: float) -> object
```

threshold_(self, threshold: float, value: float) -> object

threshold_(threshold, value) -> Tensor

Method form of clika_runtime.ops.threshold_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `tile`

```python
tiletile(self, dims: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor
```

tile(self, dims: collections.abc.Sequence[clika_runtime._core.ops.ScalarOrTensor]) -> clika_runtime._core.Tensor

tile(dims) -> Tensor

Method form of clika_runtime.ops.tile.

## `to`

```python
toto(self, target: object, dtype: object | None = None) -> object
```

to(self, target: object, dtype: object | None = None) -> object

to(dtype) -> Tensor | to(device, dtype=None) -> Tensor

Convert to a dtype, or move to a device (a Device, a device string or a Stream), optionally converting too. A no-op move returns the same storage.

## `tolist`

```python
tolisttolist(self) -> object
```

tolist(self) -> object

tolist() -> list | bool | int | float

The values as nested Python lists (a Python number for a 0-d tensor); waits for the value. Inside a tracing scope the value is not computed yet and this raises; clika_runtime.eval(tensor) computes it.

## `topk`

```python
topktopk(self, k: int, dim: int = -1, largest: bool = True, sorted: bool = True) -> tuple[clika_runtime._core.Tensor, clika_runtime._core.Tensor]
```

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

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

Method form of clika_runtime.ops.topk.

## `trace`

```python
tracetrace(self) -> clika_runtime._core.Tensor
```

trace(self) -> clika_runtime._core.Tensor

trace() -> Tensor

Method form of clika_runtime.ops.trace.

## `transpose`

```python
transposetranspose(self, dim0: int, dim1: int) -> clika_runtime._core.Tensor
```

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

transpose(dim0, dim1) -> Tensor

Method form of clika_runtime.ops.transpose.

## `tril`

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

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

tril(diagonal=0) -> Tensor

Method form of clika_runtime.ops.tril.

## `tril_`

```python
tril_tril_(self, diagonal: int = 0) -> object
```

tril_(self, diagonal: int = 0) -> object

tril_(diagonal=0) -> Tensor

Method form of clika_runtime.ops.tril_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `triu`

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

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

triu(diagonal=0) -> Tensor

Method form of clika_runtime.ops.triu.

## `triu_`

```python
triu_triu_(self, diagonal: int = 0) -> object
```

triu_(self, diagonal: int = 0) -> object

triu_(diagonal=0) -> Tensor

Method form of clika_runtime.ops.triu_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `trunc`

```python
trunctrunc(self) -> clika_runtime._core.Tensor
```

trunc(self) -> clika_runtime._core.Tensor

trunc() -> Tensor

Method form of clika_runtime.ops.trunc.

## `trunc_`

```python
trunc_trunc_(self) -> object
```

trunc_(self) -> object

trunc_() -> Tensor

Method form of clika_runtime.ops.trunc_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `unflatten`

```python
unflattenunflatten(self, dim: int, sizes: collections.abc.Sequence[int]) -> clika_runtime._core.Tensor
```

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

unflatten(dim, sizes) -> Tensor

Method form of clika_runtime.ops.unflatten.

## `unfold`

```python
unfoldunfold(self, 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(self, 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(kernel_size, dilation=[], padding=[], stride=[], mode='constant', value=None) -> Tensor

Method form of clika_runtime.ops.unfold.

## `uniform_`

```python
uniform_uniform_(self, low: float = 0.0, high: float = 1.0, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> object
```

uniform_(self, low: float = 0.0, high: float = 1.0, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> object

uniform_(low=0.0, high=1.0, *, device=None) -> Tensor

Method form of clika_runtime.ops.uniform_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `unique`

```python
uniqueunique(self, 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(self, 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(sorted=True, return_inverse=False, return_counts=False, dim=None) -> tuple[Tensor, Tensor, Tensor]

Method form of clika_runtime.ops.unique.

## `unique_consecutive`

```python
unique_consecutiveunique_consecutive(self, 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(self, 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(return_inverse=False, return_counts=False, dim=None) -> tuple[Tensor, Tensor, Tensor]

Method form of clika_runtime.ops.unique_consecutive.

## `unsqueeze`

```python
unsqueezeunsqueeze(self, dim: int) -> clika_runtime._core.Tensor
```

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

unsqueeze(dim) -> Tensor

Method form of clika_runtime.ops.unsqueeze.

## `unsqueeze_`

```python
unsqueeze_unsqueeze_(self, dim: int) -> object
```

unsqueeze_(self, dim: int) -> object

unsqueeze_(dim) -> Tensor

Method form of clika_runtime.ops.unsqueeze_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `upsample_bicubic2d`

```python
upsample_bicubic2dupsample_bicubic2d(self, 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(self, 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(sizes=[], scale_factors=[], align_corners=False) -> Tensor

Method form of clika_runtime.ops.upsample_bicubic2d.

## `upsample_bilinear2d`

```python
upsample_bilinear2dupsample_bilinear2d(self, 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(self, 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(sizes=[], scale_factors=[], align_corners=False) -> Tensor

Method form of clika_runtime.ops.upsample_bilinear2d.

## `upsample_linear1d`

```python
upsample_linear1dupsample_linear1d(self, 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(self, 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(sizes=[], scale_factors=[], align_corners=False) -> Tensor

Method form of clika_runtime.ops.upsample_linear1d.

## `upsample_nearest1d`

```python
upsample_nearest1dupsample_nearest1d(self, 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(self, 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(sizes=[], scale_factors=[]) -> Tensor

Method form of clika_runtime.ops.upsample_nearest1d.

## `upsample_nearest2d`

```python
upsample_nearest2dupsample_nearest2d(self, 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(self, 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(sizes=[], scale_factors=[]) -> Tensor

Method form of clika_runtime.ops.upsample_nearest2d.

## `upsample_nearest3d`

```python
upsample_nearest3dupsample_nearest3d(self, 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(self, 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(sizes=[], scale_factors=[]) -> Tensor

Method form of clika_runtime.ops.upsample_nearest3d.

## `upsample_trilinear3d`

```python
upsample_trilinear3dupsample_trilinear3d(self, 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(self, 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(sizes=[], scale_factors=[], align_corners=False) -> Tensor

Method form of clika_runtime.ops.upsample_trilinear3d.

## `var`

```python
varvar(self, dims: collections.abc.Sequence[int] = [], correction: int = 1, keepdim: bool = False) -> clika_runtime._core.Tensor
```

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

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

Method form of clika_runtime.ops.var.

## `view`

```python
viewview(self, *args) -> clika_runtime._core.Tensor
```

view(self, *args) -> clika_runtime._core.Tensor

view(*shape) -> Tensor

The same as reshape: a view with the given dimensions, dims as separate arguments or one sequence.

## `xlog1py`

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

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

xlog1py(other) -> Tensor

Method form of clika_runtime.ops.xlog1py.

## `xlogy`

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

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

xlogy(other) -> Tensor

Method form of clika_runtime.ops.xlogy.

## `xlogy_`

```python
xlogy_xlogy_(self, other: clika_runtime._core.ops.ScalarOrTensor) -> object
```

xlogy_(self, other: clika_runtime._core.ops.ScalarOrTensor) -> object

xlogy_(other) -> Tensor

Method form of clika_runtime.ops.xlogy_.

Writes through this tensor's storage and returns this tensor, so calls chain.

## `zero_`

```python
zero_zero_(self, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> object
```

zero_(self, *, device: clika_runtime._core.ops.StreamOrDevice = StreamOrDevice(...)) -> object

zero_(*, device=None) -> Tensor

Method form of clika_runtime.ops.zero_.

Writes through this tensor's storage and returns this tensor, so calls chain.