Tensor

device (property)

(self) -> clika_runtime._core.Device

dtype (property)

(self) -> clika_runtime._core.DataType

is_quantized (property)

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

nbytes (property)

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

numel (property)

Element count.

shape (property)

(self) -> tuple

__init__

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

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

abs

abs(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

abs() -> Tensor

Method form of clika_runtime.ops.abs.

abs_

abs_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

abs_() -> Tensor

Method form of clika_runtime.ops.abs_.

Mutates and returns self.

acos

acos(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

acos() -> Tensor

Method form of clika_runtime.ops.acos.

acos_

acos_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

acos_() -> Tensor

Method form of clika_runtime.ops.acos_.

Mutates and returns self.

acosh

acosh(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

acosh() -> Tensor

Method form of clika_runtime.ops.acosh.

acosh_

acosh_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

acosh_() -> Tensor

Method form of clika_runtime.ops.acosh_.

Mutates and returns self.

adaptive_avg_pool

adaptive_avg_pool(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

adaptive_avg_pool(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_avg_pool.

adaptive_avg_pool1d

adaptive_avg_pool1d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

adaptive_avg_pool1d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_avg_pool1d.

adaptive_avg_pool2d

adaptive_avg_pool2d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

adaptive_avg_pool2d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_avg_pool2d.

adaptive_avg_pool3d

adaptive_avg_pool3d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

adaptive_avg_pool3d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_avg_pool3d.

adaptive_max_pool

adaptive_max_pool(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

adaptive_max_pool(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_max_pool.

adaptive_max_pool1d

adaptive_max_pool1d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

adaptive_max_pool1d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_max_pool1d.

adaptive_max_pool2d

adaptive_max_pool2d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

adaptive_max_pool2d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_max_pool2d.

adaptive_max_pool3d

adaptive_max_pool3d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

adaptive_max_pool3d(output_size) -> Tensor

Method form of clika_runtime.ops.adaptive_max_pool3d.

add

add(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.add.

add_

add_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.add_.

Mutates and returns self.

add_layer_norm

add_layer_norm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

add_rms_norm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

all(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.all.

allclose

allclose(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.allclose.

amax

amax(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.amax.

amin

amin(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.amin.

aminmax

aminmax(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.aminmax.

any

any(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.any.

argmax

argmax(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.argmax.

argmin

argmin(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.argmin.

argsort

argsort(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.argsort.

asin

asin(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

asin() -> Tensor

Method form of clika_runtime.ops.asin.

asin_

asin_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

asin_() -> Tensor

Method form of clika_runtime.ops.asin_.

Mutates and returns self.

asinh

asinh(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

asinh() -> Tensor

Method form of clika_runtime.ops.asinh.

asinh_

asinh_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

asinh_() -> Tensor

Method form of clika_runtime.ops.asinh_.

Mutates and returns self.

atan

atan(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

atan() -> Tensor

Method form of clika_runtime.ops.atan.

atan2

atan2(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

atan2(other) -> Tensor

Method form of clika_runtime.ops.atan2.

atan2_

atan2_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

atan2_(other) -> Tensor

Method form of clika_runtime.ops.atan2_.

Mutates and returns self.

atan_

atan_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

atan_() -> Tensor

Method form of clika_runtime.ops.atan_.

Mutates and returns self.

atanh

atanh(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

atanh() -> Tensor

Method form of clika_runtime.ops.atanh.

atanh_

atanh_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

atanh_() -> Tensor

Method form of clika_runtime.ops.atanh_.

Mutates and returns self.

atleast_1d

atleast_1d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

atleast_1d() -> Tensor

Method form of clika_runtime.ops.atleast_1d.

atleast_2d

atleast_2d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

atleast_2d() -> Tensor

Method form of clika_runtime.ops.atleast_2d.

atleast_3d

atleast_3d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

atleast_3d() -> Tensor

Method form of clika_runtime.ops.atleast_3d.

attention

attention(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.attention.

attention_over_cache

attention_over_cache(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.attention_over_cache.

attention_varlen

attention_varlen(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.attention_varlen.

avg_pool

avg_pool(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.avg_pool.

avg_pool1d

avg_pool1d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

avg_pool2d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

avg_pool3d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

batch_norm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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_

bernoulli_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

bernoulli_(*, device=None) -> Tensor

Method form of clika_runtime.ops.bernoulli_.

Mutates and returns self.

binary_cross_entropy

binary_cross_entropy(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.binary_cross_entropy.

binary_cross_entropy_with_logits

binary_cross_entropy_with_logits(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

bincount(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.bincount.

bitwise_and

bitwise_and(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

bitwise_and(other) -> Tensor

Method form of clika_runtime.ops.bitwise_and.

bitwise_and_

bitwise_and_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

bitwise_and_(other) -> Tensor

Method form of clika_runtime.ops.bitwise_and_.

Mutates and returns self.

bitwise_left_shift

bitwise_left_shift(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

bitwise_left_shift(other) -> Tensor

Method form of clika_runtime.ops.bitwise_left_shift.

bitwise_left_shift_

bitwise_left_shift_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

bitwise_left_shift_(other) -> Tensor

Method form of clika_runtime.ops.bitwise_left_shift_.

Mutates and returns self.

bitwise_not

bitwise_not(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

bitwise_not() -> Tensor

Method form of clika_runtime.ops.bitwise_not.

bitwise_not_

bitwise_not_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

bitwise_not_() -> Tensor

Method form of clika_runtime.ops.bitwise_not_.

Mutates and returns self.

bitwise_or

bitwise_or(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

bitwise_or(other) -> Tensor

Method form of clika_runtime.ops.bitwise_or.

bitwise_or_

bitwise_or_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

bitwise_or_(other) -> Tensor

Method form of clika_runtime.ops.bitwise_or_.

Mutates and returns self.

bitwise_right_shift

bitwise_right_shift(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

bitwise_right_shift(other) -> Tensor

Method form of clika_runtime.ops.bitwise_right_shift.

bitwise_right_shift_

bitwise_right_shift_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

bitwise_right_shift_(other) -> Tensor

Method form of clika_runtime.ops.bitwise_right_shift_.

Mutates and returns self.

bitwise_xor

bitwise_xor(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

bitwise_xor(other) -> Tensor

Method form of clika_runtime.ops.bitwise_xor.

bitwise_xor_

bitwise_xor_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

bitwise_xor_(other) -> Tensor

Method form of clika_runtime.ops.bitwise_xor_.

Mutates and returns self.

bmm

bmm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.bmm.

broadcast_to

broadcast_to(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

broadcast_to(shape) -> Tensor

Method form of clika_runtime.ops.broadcast_to.

bucketize

bucketize(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.bucketize.

bytes

bytesbytes(self) -> bytes

bytes(self) -> bytes

The host-contiguous payload at the tensor's OWN dtype; lossless for every dtype, bfloat16/float8/sub-byte included.

cast

cast(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

cast(target, force_copy=False) -> Tensor

Method form of clika_runtime.ops.cast.

cast_like

cast_like(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

cast_like(reference) -> Tensor

Method form of clika_runtime.ops.cast_like.

causal_conv_update

causal_conv_update(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.causal_conv_update.

cdist

cdist(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

cdist(other, p=2.0) -> Tensor

Method form of clika_runtime.ops.cdist.

ceil

ceil(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

ceil() -> Tensor

Method form of clika_runtime.ops.ceil.

ceil_

ceil_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

ceil_() -> Tensor

Method form of clika_runtime.ops.ceil_.

Mutates and returns self.

celu

celu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

celu(alpha=1.0) -> Tensor

Method form of clika_runtime.ops.celu.

celu_

celu_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

celu_(alpha=1.0) -> Tensor

Method form of clika_runtime.ops.celu_.

Mutates and returns self.

chunk

chunk(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.chunk.

circular_pad

circular_pad(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

circular_pad(pad) -> Tensor

Method form of clika_runtime.ops.circular_pad.

clamp

clamp(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.clamp.

clamp_

clamp_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.clamp_.

Mutates and returns self.

clamp_max

clamp_max(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

clamp_max(max) -> Tensor

Method form of clika_runtime.ops.clamp_max.

clamp_max_

clamp_max_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

clamp_max_(max) -> Tensor

Method form of clika_runtime.ops.clamp_max_.

Mutates and returns self.

clamp_min

clamp_min(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

clamp_min(min) -> Tensor

Method form of clika_runtime.ops.clamp_min.

clamp_min_

clamp_min_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

clamp_min_(min) -> Tensor

Method form of clika_runtime.ops.clamp_min_.

Mutates and returns self.

constant_pad

constant_pad(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

constant_pad(pad, value=None) -> Tensor

Method form of clika_runtime.ops.constant_pad.

contiguous

contiguous(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

contiguous(force_copy=False) -> Tensor

Method form of clika_runtime.ops.contiguous.

conv

conv(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

conv(weight, bias, stride, padding, dilation, groups, mode=Constant, value=None, *, activation=Identity) -> Tensor

Method form of clika_runtime.ops.conv.

conv1d

conv1d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.conv1d.

conv2d

conv2d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

conv3d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

conv_transpose(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.conv_transpose.

conv_transpose1d

conv_transpose1d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

conv_transpose2d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

conv_transpose3d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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_

copy_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.copy_.

Mutates and returns self.

copysign

copysign(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

copysign(other) -> Tensor

Method form of clika_runtime.ops.copysign.

copysign_

copysign_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

copysign_(other) -> Tensor

Method form of clika_runtime.ops.copysign_.

Mutates and returns self.

cos

cos(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

cos() -> Tensor

Method form of clika_runtime.ops.cos.

cos_

cos_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

cos_() -> Tensor

Method form of clika_runtime.ops.cos_.

Mutates and returns self.

cosh

cosh(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

cosh() -> Tensor

Method form of clika_runtime.ops.cosh.

cosh_

cosh_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

cosh_() -> Tensor

Method form of clika_runtime.ops.cosh_.

Mutates and returns self.

cosine_similarity

cosine_similarity(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.cosine_similarity.

count_nonzero

count_nonzero(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

count_nonzero(dims=[]) -> Tensor

Method form of clika_runtime.ops.count_nonzero.

cross

cross(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

cross(other, dim=None) -> Tensor

Method form of clika_runtime.ops.cross.

cross_entropy

cross_entropy(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

cross_entropy(target, weight=None, ignore_index=None, reduction=Mean) -> Tensor

Method form of clika_runtime.ops.cross_entropy.

cummax

cummax(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.cummax.

cummin

cummin(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.cummin.

cumprod

cumprod(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.cumprod.

cumprod_

cumprod_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.cumprod_.

Mutates and returns self.

cumsum

cumsum(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.cumsum.

cumsum_

cumsum_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.cumsum_.

Mutates and returns self.

deform_conv

deform_conv(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

deg2rad(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

deg2rad() -> Tensor

Method form of clika_runtime.ops.deg2rad.

deg2rad_

deg2rad_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

deg2rad_() -> Tensor

Method form of clika_runtime.ops.deg2rad_.

Mutates and returns self.

diag

diag(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

diag(diagonal=0) -> Tensor

Method form of clika_runtime.ops.diag.

diag_embed

diag_embed(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.diag_embed.

diagonal

diagonal(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.diagonal.

diff

diff(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.diff.

div

div(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.div.

div_

div_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.div_.

Mutates and returns self.

dot

dot(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

dot(other) -> Tensor

Method form of clika_runtime.ops.dot.

dynamic_quantize

dynamic_quantize(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.dynamic_quantize.

elu

elu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.elu.

elu_

elu_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.elu_.

Mutates and returns self.

eq

eq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

eq(other) -> Tensor

Method form of clika_runtime.ops.eq.

eq_

eq_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

eq_(other) -> Tensor

Method form of clika_runtime.ops.eq_.

Mutates and returns self.

erf

erf(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

erf() -> Tensor

Method form of clika_runtime.ops.erf.

erf_

erf_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

erf_() -> Tensor

Method form of clika_runtime.ops.erf_.

Mutates and returns self.

erfc

erfc(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

erfc() -> Tensor

Method form of clika_runtime.ops.erfc.

erfc_

erfc_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

erfc_() -> Tensor

Method form of clika_runtime.ops.erfc_.

Mutates and returns self.

erfinv

erfinv(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

erfinv() -> Tensor

Method form of clika_runtime.ops.erfinv.

erfinv_

erfinv_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

erfinv_() -> Tensor

Method form of clika_runtime.ops.erfinv_.

Mutates and returns self.

exp

exp(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

exp() -> Tensor

Method form of clika_runtime.ops.exp.

exp_

exp_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

exp_() -> Tensor

Method form of clika_runtime.ops.exp_.

Mutates and returns self.

expand

expand(self: 'Tensor', *dims: 'object', **kwargs: 'object') -> 'Tensor'

ops.expand(self, dims): dims as separate arguments (x.expand(2, 3)) or as one sequence (x.expand([2, 3])).

expand_as

expand_as(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

expand_as(other) -> Tensor

Method form of clika_runtime.ops.expand_as.

exponential_

exponential_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.exponential_.

Mutates and returns self.

fast_gelu

fast_gelu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

fast_gelu() -> Tensor

Method form of clika_runtime.ops.fast_gelu.

fill

fill(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.fill.

fill_

fill_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.fill_.

Mutates and returns self.

fill_diagonal

fill_diagonal(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.fill_diagonal.

fill_diagonal_

fill_diagonal_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.fill_diagonal_.

Mutates and returns self.

flatten

flatten(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.flatten.

flip

flip(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

flip(dims) -> Tensor

Method form of clika_runtime.ops.flip.

fliplr

fliplr(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

fliplr() -> Tensor

Method form of clika_runtime.ops.fliplr.

flipud

flipud(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

flipud() -> Tensor

Method form of clika_runtime.ops.flipud.

floor

floor(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

floor() -> Tensor

Method form of clika_runtime.ops.floor.

floor_

floor_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

floor_() -> Tensor

Method form of clika_runtime.ops.floor_.

Mutates and returns self.

floor_divide

floor_divide(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

floor_divide(other) -> Tensor

Method form of clika_runtime.ops.floor_divide.

floor_divide_

floor_divide_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

floor_divide_(other) -> Tensor

Method form of clika_runtime.ops.floor_divide_.

Mutates and returns self.

fmax

fmax(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

fmax(other) -> Tensor

Method form of clika_runtime.ops.fmax.

fmin

fmin(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

fmin(other) -> Tensor

Method form of clika_runtime.ops.fmin.

fmod

fmod(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

fmod(other) -> Tensor

Method form of clika_runtime.ops.fmod.

fmod_

fmod_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

fmod_(other) -> Tensor

Method form of clika_runtime.ops.fmod_.

Mutates and returns self.

fold

fold(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

fold(output_size, kernel_size, dilation, padding, stride, mode=Constant, value=None) -> Tensor

Method form of clika_runtime.ops.fold.

frac

frac(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

frac() -> Tensor

Method form of clika_runtime.ops.frac.

frac_

frac_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

frac_() -> Tensor

Method form of clika_runtime.ops.frac_.

Mutates and returns self.

frexp

frexp(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

frexp() -> tuple[Tensor, Tensor]

Method form of clika_runtime.ops.frexp.

from_bytes

from_bytes(*args, **kwargs)

from_bytes(data: bytes, shape: collections.abc.Sequence[int], dtype: clika_runtime._core.DataType, device: clika_runtime.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

from_data(*args, **kwargs)

from_data(array: ndarray[order='C', device='cpu', writable=False], device: clika_runtime.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_delta_update

gated_delta_update(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.gated_delta_update.

gated_rms_norm

gated_rms_norm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.gated_rms_norm.

gather

gather(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

gather(dim, index) -> Tensor

Method form of clika_runtime.ops.gather.

ge

ge(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

ge(other) -> Tensor

Method form of clika_runtime.ops.ge.

ge_

ge_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

ge_(other) -> Tensor

Method form of clika_runtime.ops.ge_.

Mutates and returns self.

geglu

geglu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

geglu(approximate=None) -> Tensor

Method form of clika_runtime.ops.geglu.

gelu

gelu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

gelu(approximate=None) -> Tensor

Method form of clika_runtime.ops.gelu.

gelu_

gelu_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

gelu_(approximate=None) -> Tensor

Method form of clika_runtime.ops.gelu_.

Mutates and returns self.

glu

glu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

glu(dim=-1) -> Tensor

Method form of clika_runtime.ops.glu.

grid_sample

grid_sample(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

grid_sample(grid, mode=Bilinear, padding_mode=Zeros, align_corners=False) -> Tensor

Method form of clika_runtime.ops.grid_sample.

group_norm

group_norm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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.

group_query_attention

group_query_attention(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.group_query_attention.

group_query_attention_varlen

group_query_attention_varlen(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.group_query_attention_varlen.

gt

gt(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

gt(other) -> Tensor

Method form of clika_runtime.ops.gt.

gt_

gt_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

gt_(other) -> Tensor

Method form of clika_runtime.ops.gt_.

Mutates and returns self.

hardshrink

hardshrink(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

hardshrink(lambd=0.5) -> Tensor

Method form of clika_runtime.ops.hardshrink.

hardshrink_

hardshrink_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

hardshrink_(lambd=0.5) -> Tensor

Method form of clika_runtime.ops.hardshrink_.

Mutates and returns self.

hardsigmoid

hardsigmoid(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

hardsigmoid() -> Tensor

Method form of clika_runtime.ops.hardsigmoid.

hardsigmoid_

hardsigmoid_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

hardsigmoid_() -> Tensor

Method form of clika_runtime.ops.hardsigmoid_.

Mutates and returns self.

hardswish

hardswish(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

hardswish() -> Tensor

Method form of clika_runtime.ops.hardswish.

hardswish_

hardswish_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

hardswish_() -> Tensor

Method form of clika_runtime.ops.hardswish_.

Mutates and returns self.

hardtanh

hardtanh(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.hardtanh.

hardtanh_

hardtanh_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.hardtanh_.

Mutates and returns self.

hash_128

hash_128(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

hash_128(seed=0) -> Tensor

Method form of clika_runtime.ops.hash_128.

hash_256

hash_256(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

hash_256(seed=0) -> Tensor

Method form of clika_runtime.ops.hash_256.

hash_64

hash_64(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

hash_64(seed=0) -> Tensor

Method form of clika_runtime.ops.hash_64.

hash_tensor

hash_tensor(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.hash_tensor.

histogram

histogram(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.histogram.

huber_loss

huber_loss(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.huber_loss.

hypot

hypot(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

hypot(other) -> Tensor

Method form of clika_runtime.ops.hypot.

hypot_

hypot_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

hypot_(other) -> Tensor

Method form of clika_runtime.ops.hypot_.

Mutates and returns self.

index

index(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

index(indices) -> Tensor

Method form of clika_runtime.ops.index.

index_add

index_add(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

index_add(dim, indices, src) -> Tensor

Method form of clika_runtime.ops.index_add.

index_add_

index_add_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

index_add_(dim, indices, src) -> Tensor

Method form of clika_runtime.ops.index_add_.

Mutates and returns self.

index_copy

index_copy(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

index_copy(dim, indices, src) -> Tensor

Method form of clika_runtime.ops.index_copy.

index_copy_

index_copy_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

index_copy_(dim, indices, src) -> Tensor

Method form of clika_runtime.ops.index_copy_.

Mutates and returns self.

index_fill

index_fill(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

index_fill(dim, indices, value) -> Tensor

Method form of clika_runtime.ops.index_fill.

index_fill_

index_fill_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

index_fill_(dim, indices, value) -> Tensor

Method form of clika_runtime.ops.index_fill_.

Mutates and returns self.

index_put

index_put(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.index_put.

index_put_

index_put_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.index_put_.

Mutates and returns self.

index_select

index_select(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

index_select(dim, index) -> Tensor

Method form of clika_runtime.ops.index_select.

inner

inner(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

inner(other) -> Tensor

Method form of clika_runtime.ops.inner.

instance_norm

instance_norm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

interpolate(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.interpolate.

isclose

isclose(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.isclose.

isfinite

isfinite(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

isfinite() -> Tensor

Method form of clika_runtime.ops.isfinite.

isinf

isinf(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

isinf() -> Tensor

Method form of clika_runtime.ops.isinf.

isnan

isnan(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

isnan() -> Tensor

Method form of clika_runtime.ops.isnan.

isneginf

isneginf(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

isneginf() -> Tensor

Method form of clika_runtime.ops.isneginf.

isposinf

isposinf(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

isposinf() -> Tensor

Method form of clika_runtime.ops.isposinf.

item

item(self: 'Tensor') -> 'bool | int | float'

The value of a one-element tensor as a Python number.

kl_div

kl_div(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.kl_div.

kron

kron(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

kron(other) -> Tensor

Method form of clika_runtime.ops.kron.

kthvalue

kthvalue(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.kthvalue.

l1_loss

l1_loss(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

l1_loss(target, reduction=Mean) -> Tensor

Method form of clika_runtime.ops.l1_loss.

layer_norm

layer_norm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.layer_norm.

le

le(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

le(other) -> Tensor

Method form of clika_runtime.ops.le.

le_

le_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

le_(other) -> Tensor

Method form of clika_runtime.ops.le_.

Mutates and returns self.

leaky_relu

leaky_relu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

leaky_relu(negative_slope=0.01) -> Tensor

Method form of clika_runtime.ops.leaky_relu.

leaky_relu_

leaky_relu_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

leaky_relu_(negative_slope=0.01) -> Tensor

Method form of clika_runtime.ops.leaky_relu_.

Mutates and returns self.

linear

linear(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.linear.

log

log(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

log() -> Tensor

Method form of clika_runtime.ops.log.

log10

log10(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

log10() -> Tensor

Method form of clika_runtime.ops.log10.

log10_

log10_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

log10_() -> Tensor

Method form of clika_runtime.ops.log10_.

Mutates and returns self.

log1p

log1p(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

log1p() -> Tensor

Method form of clika_runtime.ops.log1p.

log1p_

log1p_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

log1p_() -> Tensor

Method form of clika_runtime.ops.log1p_.

Mutates and returns self.

log2

log2(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

log2() -> Tensor

Method form of clika_runtime.ops.log2.

log2_

log2_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

log2_() -> Tensor

Method form of clika_runtime.ops.log2_.

Mutates and returns self.

log_

log_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

log_() -> Tensor

Method form of clika_runtime.ops.log_.

Mutates and returns self.

log_sigmoid

log_sigmoid(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

log_sigmoid() -> Tensor

Method form of clika_runtime.ops.log_sigmoid.

log_sigmoid_

log_sigmoid_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

log_sigmoid_() -> Tensor

Method form of clika_runtime.ops.log_sigmoid_.

Mutates and returns self.

log_softmax

log_softmax(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.log_softmax.

log_softmax_

log_softmax_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

log_softmax_(dim=-1) -> Tensor

Method form of clika_runtime.ops.log_softmax_.

Mutates and returns self.

logaddexp

logaddexp(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

logaddexp(other) -> Tensor

Method form of clika_runtime.ops.logaddexp.

logaddexp2

logaddexp2(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

logaddexp2(other) -> Tensor

Method form of clika_runtime.ops.logaddexp2.

logical_and

logical_and(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

logical_and(other) -> Tensor

Method form of clika_runtime.ops.logical_and.

logical_and_

logical_and_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

logical_and_(other) -> Tensor

Method form of clika_runtime.ops.logical_and_.

Mutates and returns self.

logical_not

logical_not(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

logical_not() -> Tensor

Method form of clika_runtime.ops.logical_not.

logical_not_

logical_not_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

logical_not_() -> Tensor

Method form of clika_runtime.ops.logical_not_.

Mutates and returns self.

logical_or

logical_or(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

logical_or(other) -> Tensor

Method form of clika_runtime.ops.logical_or.

logical_or_

logical_or_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

logical_or_(other) -> Tensor

Method form of clika_runtime.ops.logical_or_.

Mutates and returns self.

logical_xor

logical_xor(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

logical_xor(other) -> Tensor

Method form of clika_runtime.ops.logical_xor.

logical_xor_

logical_xor_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

logical_xor_(other) -> Tensor

Method form of clika_runtime.ops.logical_xor_.

Mutates and returns self.

logit

logit(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

logit(eps=None) -> Tensor

Method form of clika_runtime.ops.logit.

logit_

logit_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

logit_(eps=None) -> Tensor

Method form of clika_runtime.ops.logit_.

Mutates and returns self.

logsumexp

logsumexp(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

logsumexp(dims, keepdim=False) -> Tensor

Method form of clika_runtime.ops.logsumexp.

lt

lt(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

lt(other) -> Tensor

Method form of clika_runtime.ops.lt.

lt_

lt_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

lt_(other) -> Tensor

Method form of clika_runtime.ops.lt_.

Mutates and returns self.

masked_fill

masked_fill(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

masked_fill(mask, value) -> Tensor

Method form of clika_runtime.ops.masked_fill.

masked_fill_

masked_fill_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

masked_fill_(mask, value) -> Tensor

Method form of clika_runtime.ops.masked_fill_.

Mutates and returns self.

masked_scatter

masked_scatter(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

masked_scatter(mask, source) -> Tensor

Method form of clika_runtime.ops.masked_scatter.

masked_scatter_

masked_scatter_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

masked_scatter_(mask, source) -> Tensor

Method form of clika_runtime.ops.masked_scatter_.

Mutates and returns self.

masked_select

masked_select(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

masked_select(mask) -> Tensor

Method form of clika_runtime.ops.masked_select.

matmul

matmul(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

max(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.max.

max_pool

max_pool(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.max_pool.

max_pool1d

max_pool1d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

max_pool1d_with_indices(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

max_pool2d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

max_pool2d_with_indices(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

max_pool3d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

max_pool3d_with_indices(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

max_pool_with_indices(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

maximum(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

maximum(other) -> Tensor

Method form of clika_runtime.ops.maximum.

maximum_

maximum_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

maximum_(other) -> Tensor

Method form of clika_runtime.ops.maximum_.

Mutates and returns self.

mean

mean(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.mean.

median

median(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.median.

min

min(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.min.

minimum

minimum(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

minimum(other) -> Tensor

Method form of clika_runtime.ops.minimum.

minimum_

minimum_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

minimum_(other) -> Tensor

Method form of clika_runtime.ops.minimum_.

Mutates and returns self.

mish

mish(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

mish() -> Tensor

Method form of clika_runtime.ops.mish.

mish_

mish_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

mish_() -> Tensor

Method form of clika_runtime.ops.mish_.

Mutates and returns self.

mm

mm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.mm.

mod

mod(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

mod(other, mode=Python) -> Tensor

Method form of clika_runtime.ops.mod.

mod_

mod_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

mod_(other, mode=Python) -> Tensor

Method form of clika_runtime.ops.mod_.

Mutates and returns self.

moe

moe(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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_qk_varlen

mrope_rotary_embedding_qk_varlen(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.mrope_rotary_embedding_qk_varlen.

mse_loss

mse_loss(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

mse_loss(target, reduction=Mean) -> Tensor

Method form of clika_runtime.ops.mse_loss.

mul

mul(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.mul.

mul_

mul_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.mul_.

Mutates and returns self.

mv

mv(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.mv.

nan_to_num

nan_to_num(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.nan_to_num.

nan_to_num_

nan_to_num_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.nan_to_num_.

Mutates and returns self.

nanmean

nanmean(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.nanmean.

nanmedian

nanmedian(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.nanmedian.

nanquantile

nanquantile(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.nanquantile.

nansum

nansum(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.nansum.

narrow

narrow(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

narrow(dim, start, length) -> Tensor

Method form of clika_runtime.ops.narrow.

ndim

ndim(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

ndim() -> Tensor

Method form of clika_runtime.ops.ndim.

ndim_host

ndim_host(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

ndim_host() -> Tensor

Method form of clika_runtime.ops.ndim_host.

ne

ne(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

ne(other) -> Tensor

Method form of clika_runtime.ops.ne.

ne_

ne_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

ne_(other) -> Tensor

Method form of clika_runtime.ops.ne_.

Mutates and returns self.

neg

neg(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

neg() -> Tensor

Method form of clika_runtime.ops.neg.

neg_

neg_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

neg_() -> Tensor

Method form of clika_runtime.ops.neg_.

Mutates and returns self.

nll_loss

nll_loss(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

nll_loss(target, weight=None, ignore_index=None, reduction=Mean) -> Tensor

Method form of clika_runtime.ops.nll_loss.

nonzero

nonzero(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

nonzero() -> Tensor

Method form of clika_runtime.ops.nonzero.

norm

norm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.norm.

normal_

normal_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.normal_.

Mutates and returns self.

normalize

normalize(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.normalize.

normalize_

normalize_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.normalize_.

Mutates and returns self.

numel_host

numel_host(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

numel_host() -> Tensor

Method form of clika_runtime.ops.numel_host.

numpy

numpynumpy(self) -> numpy.ndarray[]

numpy(self) -> 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().

outer

outer(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

outer(other) -> Tensor

Method form of clika_runtime.ops.outer.

pad

pad(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

pad(pad, mode=Constant, value=None) -> Tensor

Method form of clika_runtime.ops.pad.

pairwise_distance

pairwise_distance(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.pairwise_distance.

pdist

pdist(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

pdist(other=2.0) -> Tensor

Method form of clika_runtime.ops.pdist.

permute

permute(self: 'Tensor', *dims: 'object', **kwargs: 'object') -> 'Tensor'

ops.permute(self, dims): dims as separate arguments (x.permute(2, 3)) or as one sequence (x.permute([2, 3])).

pixel_shuffle

pixel_shuffle(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

pixel_shuffle(upscale_factor, mode=CRD) -> Tensor

Method form of clika_runtime.ops.pixel_shuffle.

pixel_unshuffle

pixel_unshuffle(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

pixel_unshuffle(downscale_factor, mode=CRD) -> Tensor

Method form of clika_runtime.ops.pixel_unshuffle.

pow

pow(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

pow(exponent) -> Tensor

Method form of clika_runtime.ops.pow.

pow_

pow_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

pow_(exponent) -> Tensor

Method form of clika_runtime.ops.pow_.

Mutates and returns self.

prelu

prelu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

prelu(weight=None) -> Tensor

Method form of clika_runtime.ops.prelu.

prelu_

prelu_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

prelu_(weight=None) -> Tensor

Method form of clika_runtime.ops.prelu_.

Mutates and returns self.

prod

prod(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.prod.

put

put(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.put.

put_

put_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.put_.

Mutates and returns self.

qconv1d_woq

qconv1d_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

qconv2d_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

qconv3d_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

qconv_transpose1d_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

qconv_transpose2d_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

qconv_transpose3d_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

qconv_transpose_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.qconv_transpose_woq.

qconv_woq

qconv_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.qconv_woq.

qdeform_conv_woq

qdeform_conv_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.qdeform_conv_woq.

qk_layer_norm

qk_layer_norm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

qk_layer_norm(k=None, v=None, w_q=None, b_q=None, w_k=None, b_k=None, head_dim=0, eps=None) -> tuple[Tensor, Tensor, Tensor]

Method form of clika_runtime.ops.qk_layer_norm.

qk_layer_norm_

qk_layer_norm_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

qk_layer_norm_(k=None, v=None, w_q=None, b_q=None, w_k=None, b_k=None, head_dim=0, eps=None) -> Tensor

Method form of clika_runtime.ops.qk_layer_norm_.

Mutates and returns self.

qk_rms_norm

qk_rms_norm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

qk_rms_norm(k=None, v=None, w_q=None, w_k=None, head_dim=0, eps=None) -> tuple[Tensor, Tensor, Tensor]

Method form of clika_runtime.ops.qk_rms_norm.

qk_rms_norm_

qk_rms_norm_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

qk_rms_norm_(k=None, v=None, w_q=None, w_k=None, head_dim=0, eps=None) -> Tensor

Method form of clika_runtime.ops.qk_rms_norm_.

Mutates and returns self.

qlinear_woq

qlinear_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

qlinear_woq(weight, bias=None, *, activation=None, compute_mode=ExactFP) -> Tensor

Method form of clika_runtime.ops.qlinear_woq.

qlinear_woq_

qlinear_woq_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

qlinear_woq_(weight, out, bias=None, *, activation=None, compute_mode=ExactFP) -> Tensor

Method form of clika_runtime.ops.qlinear_woq_.

qmatmul_woq

qmatmul_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

qmatmul_woq(other, bias=None, *, activation=None, transpose_a=False, transpose_b=False, compute_mode=ExactFP) -> Tensor

Method form of clika_runtime.ops.qmatmul_woq.

qmatmul_woq_

qmatmul_woq_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

qmatmul_woq_(other, out, bias=None, *, activation=None, transpose_a=False, transpose_b=False, compute_mode=ExactFP) -> Tensor

Method form of clika_runtime.ops.qmatmul_woq_.

qmoe_woq

qmoe_woq(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

quantile(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.quantile.

quantize

quantize(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.quantize.

quantize_

quantize_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

quantize_(out) -> QTensor

Method form of clika_runtime.ops.quantize_.

quantize_dequantize

quantize_dequantize(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

quantize_to_scheme(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

quantize_to_scheme(scheme, scale=None) -> QTensor

Method form of clika_runtime.ops.quantize_to_scheme.

quick_gelu

quick_gelu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

quick_gelu() -> Tensor

Method form of clika_runtime.ops.quick_gelu.

rad2deg

rad2deg(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

rad2deg() -> Tensor

Method form of clika_runtime.ops.rad2deg.

rad2deg_

rad2deg_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

rad2deg_() -> Tensor

Method form of clika_runtime.ops.rad2deg_.

Mutates and returns self.

random_

random_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.random_.

Mutates and returns self.

reciprocal

reciprocal(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

reciprocal() -> Tensor

Method form of clika_runtime.ops.reciprocal.

reciprocal_

reciprocal_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

reciprocal_() -> Tensor

Method form of clika_runtime.ops.reciprocal_.

Mutates and returns self.

reflect_pad

reflect_pad(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

reflect_pad(pad) -> Tensor

Method form of clika_runtime.ops.reflect_pad.

reglu

reglu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

reglu() -> Tensor

Method form of clika_runtime.ops.reglu.

relu

relu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

relu() -> Tensor

Method form of clika_runtime.ops.relu.

relu6

relu6(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

relu6() -> Tensor

Method form of clika_runtime.ops.relu6.

relu6_

relu6_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

relu6_() -> Tensor

Method form of clika_runtime.ops.relu6_.

Mutates and returns self.

relu_

relu_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

relu_() -> Tensor

Method form of clika_runtime.ops.relu_.

Mutates and returns self.

remainder

remainder(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

remainder(other) -> Tensor

Method form of clika_runtime.ops.remainder.

remainder_

remainder_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

remainder_(other) -> Tensor

Method form of clika_runtime.ops.remainder_.

Mutates and returns self.

renorm

renorm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.renorm.

renorm_

renorm_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.renorm_.

Mutates and returns self.

repeat

repeat(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

repeat(sizes) -> Tensor

Method form of clika_runtime.ops.repeat.

repeat_interleave

repeat_interleave(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.repeat_interleave.

replicate_pad

replicate_pad(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

replicate_pad(pad) -> Tensor

Method form of clika_runtime.ops.replicate_pad.

resample

resample(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.resample.

reshape

reshape(self: 'Tensor', *dims: 'object', **kwargs: 'object') -> 'Tensor'

ops.reshape(self, dims): dims as separate arguments (x.reshape(2, 3)) or as one sequence (x.reshape([2, 3])).

reshape_as

reshape_as(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

reshape_as(other) -> Tensor

Method form of clika_runtime.ops.reshape_as.

rfft

rfft(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.rfft.

rms_norm

rms_norm(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.rms_norm.

roll

roll(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.roll.

rot90

rot90(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.rot90.

rotary_embedding_qk

rotary_embedding_qk(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

rotary_embedding_qk(other, position_ids=None, cos=None, sin=None, mode=None, rotary_dim=None, theta=None, scaling=None, scale=None, low_freq_factor=None, high_freq_factor=None, original_max_pos=None, beta_fast=None, beta_slow=None, freq_factors=None) -> tuple[Tensor, Tensor]

Method form of clika_runtime.ops.rotary_embedding_qk.

rotary_embedding_qk_varlen

rotary_embedding_qk_varlen(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

rotary_embedding_qk_varlen(other, cu_seqlens, seqlens=None, position_ids=None, cos=None, sin=None, mode=None, rotary_dim=None, theta=None, scaling=None, scale=None, low_freq_factor=None, high_freq_factor=None, original_max_pos=None, beta_fast=None, beta_slow=None, freq_factors=None) -> tuple[Tensor, Tensor]

Method form of clika_runtime.ops.rotary_embedding_qk_varlen.

round

round(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

round(decimals=0) -> Tensor

Method form of clika_runtime.ops.round.

round_

round_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

round_(decimals=0) -> Tensor

Method form of clika_runtime.ops.round_.

Mutates and returns self.

rsqrt

rsqrt(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

rsqrt() -> Tensor

Method form of clika_runtime.ops.rsqrt.

rsqrt_

rsqrt_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

rsqrt_() -> Tensor

Method form of clika_runtime.ops.rsqrt_.

Mutates and returns self.

scaled_dot_product_attention

scaled_dot_product_attention(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

scaled_dot_product_attention(other, v, attn_mask=None, is_causal=False, q_scale=None, k_scale=None, v_scale=None) -> Tensor

Method form of clika_runtime.ops.scaled_dot_product_attention.

scaled_dot_product_attention_varlen

scaled_dot_product_attention_varlen(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

scaled_dot_product_attention_varlen(other, v, cu_seqlens_q, cu_seqlens_k, max_seqlen_q=None, max_seqlen_k=None, attn_mask=None, is_causal=False, q_scale=None, k_scale=None, v_scale=None) -> Tensor

Method form of clika_runtime.ops.scaled_dot_product_attention_varlen.

scatter

scatter(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

scatter(dim, index, src) -> Tensor

Method form of clika_runtime.ops.scatter.

scatter_

scatter_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

scatter_(dim, index, src) -> Tensor

Method form of clika_runtime.ops.scatter_.

Mutates and returns self.

scatter_add

scatter_add(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.scatter_add.

scatter_add_

scatter_add_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.scatter_add_.

Mutates and returns self.

scatter_reduce

scatter_reduce(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.scatter_reduce.

scatter_reduce_

scatter_reduce_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.scatter_reduce_.

Mutates and returns self.

select

select(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

select(dim, index) -> Tensor

Method form of clika_runtime.ops.select.

selu

selu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

selu() -> Tensor

Method form of clika_runtime.ops.selu.

selu_

selu_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

selu_() -> Tensor

Method form of clika_runtime.ops.selu_.

Mutates and returns self.

sgn

sgn(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

sgn() -> Tensor

Method form of clika_runtime.ops.sgn.

sgn_

sgn_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

sgn_() -> Tensor

Method form of clika_runtime.ops.sgn_.

Mutates and returns self.

shape_host

shape_host(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

shape_host() -> Tensor

Method form of clika_runtime.ops.shape_host.

sigmoid

sigmoid(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

sigmoid() -> Tensor

Method form of clika_runtime.ops.sigmoid.

sigmoid_

sigmoid_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

sigmoid_() -> Tensor

Method form of clika_runtime.ops.sigmoid_.

Mutates and returns self.

sign

sign(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

sign() -> Tensor

Method form of clika_runtime.ops.sign.

sign_

sign_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

sign_() -> Tensor

Method form of clika_runtime.ops.sign_.

Mutates and returns self.

silu

silu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

silu() -> Tensor

Method form of clika_runtime.ops.silu.

silu_

silu_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

silu_() -> Tensor

Method form of clika_runtime.ops.silu_.

Mutates and returns self.

sin

sin(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

sin() -> Tensor

Method form of clika_runtime.ops.sin.

sin_

sin_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

sin_() -> Tensor

Method form of clika_runtime.ops.sin_.

Mutates and returns self.

sinc

sinc(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

sinc() -> Tensor

Method form of clika_runtime.ops.sinc.

sinc_

sinc_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

sinc_() -> Tensor

Method form of clika_runtime.ops.sinc_.

Mutates and returns self.

sinh

sinh(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

sinh() -> Tensor

Method form of clika_runtime.ops.sinh.

sinh_

sinh_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

sinh_() -> Tensor

Method form of clika_runtime.ops.sinh_.

Mutates and returns self.

slice

slice(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

slice(dim, start=None, end=None, step=1) -> Tensor

Method form of clika_runtime.ops.slice.

smooth_l1_loss

smooth_l1_loss(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

smooth_l1_loss(target, reduction=Mean, beta=1.0) -> Tensor

Method form of clika_runtime.ops.smooth_l1_loss.

snake

snake(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.snake.

snake_

snake_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.snake_.

Mutates and returns self.

softcap_logits

softcap_logits(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

softcap_logits(cap) -> Tensor

Method form of clika_runtime.ops.softcap_logits.

softcap_logits_

softcap_logits_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

softcap_logits_(cap) -> Tensor

Method form of clika_runtime.ops.softcap_logits_.

Mutates and returns self.

softmax

softmax(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.softmax.

softmax_

softmax_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

softmax_(dim=-1) -> Tensor

Method form of clika_runtime.ops.softmax_.

Mutates and returns self.

softmin

softmin(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.softmin.

softmin_

softmin_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

softmin_(dim=-1) -> Tensor

Method form of clika_runtime.ops.softmin_.

Mutates and returns self.

softplus

softplus(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.softplus.

softplus_

softplus_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.softplus_.

Mutates and returns self.

softshrink

softshrink(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

softshrink(lambd=0.5) -> Tensor

Method form of clika_runtime.ops.softshrink.

softshrink_

softshrink_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

softshrink_(lambd=0.5) -> Tensor

Method form of clika_runtime.ops.softshrink_.

Mutates and returns self.

softsign

softsign(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

softsign() -> Tensor

Method form of clika_runtime.ops.softsign.

softsign_

softsign_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

softsign_() -> Tensor

Method form of clika_runtime.ops.softsign_.

Mutates and returns self.

sort

sort(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.sort.

split_by_size

split_by_size(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.split_by_size.

split_with_sizes

split_with_sizes(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

split_with_sizes(sizes, dim=0) -> list[Tensor]

Method form of clika_runtime.ops.split_with_sizes.

sqrt

sqrt(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

sqrt() -> Tensor

Method form of clika_runtime.ops.sqrt.

sqrt_

sqrt_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

sqrt_() -> Tensor

Method form of clika_runtime.ops.sqrt_.

Mutates and returns self.

square

square(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

square() -> Tensor

Method form of clika_runtime.ops.square.

square_

square_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

square_() -> Tensor

Method form of clika_runtime.ops.square_.

Mutates and returns self.

squeeze

squeeze(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

squeeze(dim=[]) -> Tensor

Method form of clika_runtime.ops.squeeze.

squeeze_

squeeze_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

squeeze_(dim=[]) -> Tensor

Method form of clika_runtime.ops.squeeze_.

Mutates and returns self.

ssd_update

ssd_update(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

ssd_update(dt, a_rate, b_mat, c_mat, d_skip, dt_bias, z, state, seq_lens=None, slot_ids=None, dt_softplus=False) -> Tensor

Method form of clika_runtime.ops.ssd_update.

std

std(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.std.

stft

stft(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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.

sub

sub(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.sub.

sub_

sub_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

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

Method form of clika_runtime.ops.sub_.

Mutates and returns self.

sum

sum(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.sum.

swiglu

swiglu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.swiglu.

take

take(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

take(index) -> Tensor

Method form of clika_runtime.ops.take.

take_along_dim

take_along_dim(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

take_along_dim(index, dim=None) -> Tensor

Method form of clika_runtime.ops.take_along_dim.

tan

tan(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

tan() -> Tensor

Method form of clika_runtime.ops.tan.

tan_

tan_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

tan_() -> Tensor

Method form of clika_runtime.ops.tan_.

Mutates and returns self.

tanh

tanh(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

tanh() -> Tensor

Method form of clika_runtime.ops.tanh.

tanh_

tanh_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

tanh_() -> Tensor

Method form of clika_runtime.ops.tanh_.

Mutates and returns self.

tensordot

tensordot(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

tensordot(other, dims_a, dims_b) -> Tensor

Method form of clika_runtime.ops.tensordot.

threshold

threshold(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

threshold(threshold, value) -> Tensor

Method form of clika_runtime.ops.threshold.

threshold_

threshold_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

threshold_(threshold, value) -> Tensor

Method form of clika_runtime.ops.threshold_.

Mutates and returns self.

tile

tile(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

tile(dims) -> Tensor

Method form of clika_runtime.ops.tile.

to

to(self: 'Tensor', target: '_core.DataType | _core.Device | str') -> 'Tensor'

Convert to a dtype, or move to a device.

x.to(clika_runtime.float32) converts through the runtime cast; x.to("cpu") and x.to(Device.gpu()) move the tensor.

topk

topk(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.topk.

trace

trace(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

trace() -> Tensor

Method form of clika_runtime.ops.trace.

transpose

transpose(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

transpose(dim0, dim1) -> Tensor

Method form of clika_runtime.ops.transpose.

tril

tril(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

tril(diagonal=0) -> Tensor

Method form of clika_runtime.ops.tril.

tril_

tril_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

tril_(diagonal=0) -> Tensor

Method form of clika_runtime.ops.tril_.

Mutates and returns self.

triu

triu(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

triu(diagonal=0) -> Tensor

Method form of clika_runtime.ops.triu.

triu_

triu_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

triu_(diagonal=0) -> Tensor

Method form of clika_runtime.ops.triu_.

Mutates and returns self.

trunc

trunc(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

trunc() -> Tensor

Method form of clika_runtime.ops.trunc.

trunc_

trunc_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

trunc_() -> Tensor

Method form of clika_runtime.ops.trunc_.

Mutates and returns self.

unflatten

unflatten(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

unflatten(dim, sizes) -> Tensor

Method form of clika_runtime.ops.unflatten.

unfold

unfold(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

unfold(kernel_size, dilation, padding, stride, mode=Constant, value=None) -> Tensor

Method form of clika_runtime.ops.unfold.

uniform_

uniform_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

uniform_(low=0.0, high=1.0, *, device=None) -> Tensor

Method form of clika_runtime.ops.uniform_.

Mutates and returns self.

unique

unique(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.unique.

unique_consecutive

unique_consecutive(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.unique_consecutive.

unsqueeze

unsqueeze(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

unsqueeze(dim) -> Tensor

Method form of clika_runtime.ops.unsqueeze.

unsqueeze_

unsqueeze_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

unsqueeze_(dim) -> Tensor

Method form of clika_runtime.ops.unsqueeze_.

Mutates and returns self.

upsample_bicubic2d

upsample_bicubic2d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

upsample_bicubic2d(sizes=[], scale_factors=[], align_corners=False) -> Tensor

Method form of clika_runtime.ops.upsample_bicubic2d.

upsample_bilinear2d

upsample_bilinear2d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

upsample_bilinear2d(sizes=[], scale_factors=[], align_corners=False) -> Tensor

Method form of clika_runtime.ops.upsample_bilinear2d.

upsample_linear1d

upsample_linear1d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

upsample_linear1d(sizes=[], scale_factors=[], align_corners=False) -> Tensor

Method form of clika_runtime.ops.upsample_linear1d.

upsample_nearest1d

upsample_nearest1d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

upsample_nearest1d(sizes=[], scale_factors=[]) -> Tensor

Method form of clika_runtime.ops.upsample_nearest1d.

upsample_nearest2d

upsample_nearest2d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

upsample_nearest2d(sizes=[], scale_factors=[]) -> Tensor

Method form of clika_runtime.ops.upsample_nearest2d.

upsample_nearest3d

upsample_nearest3d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

upsample_nearest3d(sizes=[], scale_factors=[]) -> Tensor

Method form of clika_runtime.ops.upsample_nearest3d.

upsample_trilinear3d

upsample_trilinear3d(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

upsample_trilinear3d(sizes=[], scale_factors=[], align_corners=False) -> Tensor

Method form of clika_runtime.ops.upsample_trilinear3d.

var

var(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

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

Method form of clika_runtime.ops.var.

xlog1py

xlog1py(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

xlog1py(other) -> Tensor

Method form of clika_runtime.ops.xlog1py.

xlogy

xlogy(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> 'Any'

xlogy(other) -> Tensor

Method form of clika_runtime.ops.xlogy.

xlogy_

xlogy_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

xlogy_(other) -> Tensor

Method form of clika_runtime.ops.xlogy_.

Mutates and returns self.

zero_

zero_(self: '_core.Tensor', *args: 'Any', **kwargs: 'Any') -> '_core.Tensor'

zero_(*, device=None) -> Tensor

Method form of clika_runtime.ops.zero_.

Mutates and returns self.