y = abs(x)

y = argmax(x, out_max_val, topk)

y = (x - mean) / sqrt(var + eps) * slope + bias

y = x + bias

C = binaryop(A, B)

y = log(1 + e^(-x)) , x > 0
y = log(1 + e^x),     x < 0

y = cast(x)

if x < 0    y = (exp(x / alpha) - 1.f) * alpha
else        y = x

y = clamp(x, min, max)

y = concat(x0, x1, x2, ...) by axis

x2 = pad(x, pads, pad_value)
x3 = conv(x2, weight, kernel, stride, dilation) + bias
y = activation(x3, act_type, act_params)

x2 = pad(x, pads, pad_value)
x3 = conv1d(x2, weight, kernel, stride, dilation) + bias
y = activation(x3, act_type, act_params)

x2 = pad(x, pads, pad_value)
x3 = conv3d(x2, weight, kernel, stride, dilation) + bias
y = activation(x3, act_type, act_params)

x2 = pad(x, pads, pad_value)
x3 = conv(x2, weight, kernel, stride, dilation, group) + bias
y = activation(x3, act_type, act_params)

x2 = pad(x, pads, pad_value)
x3 = conv1d(x2, weight, kernel, stride, dilation, group) + bias
y = activation(x3, act_type, act_params)

x2 = pad(x, pads, pad_value)
x3 = conv3d(x2, weight, kernel, stride, dilation, group) + bias
y = activation(x3, act_type, act_params)

self[offset] = src

y = crop(x)

x2 = deconv(x, weight, kernel, stride, dilation) + bias
x3 = depad(x2, pads, pad_value)
y = activation(x3, act_type, act_params)

x2 = deconv1d(x, weight, kernel, stride, dilation) + bias
x3 = depad(x2, pads, pad_value)
y = activation(x3, act_type, act_params)

x2 = deconv3d(x, weight, kernel, stride, dilation) + bias
x3 = depad(x2, pads, pad_value)
y = activation(x3, act_type, act_params)

x2 = deconv(x, weight, kernel, stride, dilation, group) + bias
x3 = depad(x2, pads, pad_value)
y = activation(x3, act_type, act_params)

x2 = deconv1d(x, weight, kernel, stride, dilation, group) + bias
x3 = depad(x2, pads, pad_value)
y = activation(x3, act_type, act_params)

x2 = deconv3d(x, weight, kernel, stride, dilation, group) + bias
x3 = depad(x2, pads, pad_value)
y = activation(x3, act_type, act_params)

x2 = deformableconv2d(x, offset, mask, weight, kernel, stride, dilation) + bias
y = activation(x2, act_type, act_params)

y = x * scale + bias

y = diag(x, diagonal)

y = x * scale

y = elementwise_op(x0, x1, ...)

if x < 0    y = (exp(x) - 1) * alpha
else        y = x

y = embedding(x)

if base == -1   y = exp(shift + x * scale)
else            y = pow(base, (shift + x * scale))

y = fold(x)

if fast_gelu == 1   y = 0.5 * x * (1 + tanh(0.79788452 * (x + 0.044715 * x * x * x)));
else                y = 0.5 * x * erfc(-0.70710678 * x)

a = transA ? transpose(x0) : x0
b = transb ? transpose(x1) : x1
c = x2
y = (gemm(a, b) + c * beta) * alpha

Given an input and a flow-field grid, computes the output using input values and pixel locations from grid.

For each output location output[:, h2, w2], the size-2 vector grid[h2, w2, 2] specifies input pixel[:, h1, w1] locations x and y, 
which are used to interpolate the output value output[:, h2, w2]

This function is often used in conjunction with affine_grid() to build Spatial Transformer Networks .

split x along channel axis into group x0, x1 ...
l2 normalize for each group x0, x1 ...
y = x * gamma + beta

y = gru(x)
y0, hidden y1 = gru(x0, hidden x1)

y = clamp(x * alpha + beta, 0, 1)

y = x * clamp(x * alpha + beta, 0, 1)

x2 = innerproduct(x, weight) + bias
y = activation(x2, act_type, act_params)

y = input

split x along channel axis into instance x0, x1 ...
l2 normalize for each channel instance x0, x1 ...
y = x * gamma + beta

if dynamic_target_size == 0     y = resize(x) by fixed size or scale
else                            y = resize(x0, size(x1))

x1 = x as complex
x1 = x1 * sqrt(norm) if normalized
y = istft(x1)
y1 = unpad(y) if center

if returns == 0 return y1 as complex
if returns == 1 return y1 real
if returns == 2 return y1 imag

split x along outmost axis into part x0, x1 ...
l2 normalize for each part x0, x1 ...
y = x * gamma + beta by elementwise

if base == -1   y = log(shift + x * scale)
else            y = log(shift + x * scale) / log(base)

if region_type == ACROSS_CHANNELS   square_sum = sum of channel window of local_size
if region_type == WITHIN_CHANNEL    square_sum = sum of spatial window of local_size
y = x * pow(bias + alpha * square_sum / (local_size * local_size), -beta)

y = lstm(x)
y0, hidden y1, cell y2 = lstm(x0, hidden x1, cell x2)

y = data

y = x * tanh(log(exp(x) + 1))

q_affine = affine(q) / (embed_dim / num_head)
k_affine = affine(k) or reuse kv_cache part
v_affine = affine(v) or reuse kv_cache part
split q k v into num_head part q0, k0, v0, q1, k1, v1 ...
for each num_head part
    qk = q * k
    qk = qk + attn_mask if attn_mask exists
    softmax(qk)
    qkv = qk * v
    merge qkv to out
y = affine(out)

if normalize_variance == 1 && across_channels == 1      y = (x - mean) / (sqrt(var) + eps) of whole blob
if normalize_variance == 1 && across_channels == 0      y = (x - mean) / (sqrt(var) + eps) of each channel
if normalize_variance == 0 && across_channels == 1      y = x - mean of whole blob
if normalize_variance == 0 && across_channels == 0      y = x - mean of each channel

y = x

if across_spatial == 1 && across_channel == 1      x2 = normalize(x) of whole blob
if across_spatial == 1 && across_channel == 0      x2 = normalize(x) of each channel
if across_spatial == 0 && across_channel == 1      x2 = normalize(x) of each position
y = x2 * scale

y = wrap_packing(x)

y = pad(x, pads)

y = reorder(x)

if mode == 0    y = depth_to_space(x) where x channel order is sw-sh-outc
if mode == 1    y = depth_to_space(x) where x channel order is outc-sw-sh

x2 = pad(x, pads)
x3 = pooling(x2, kernel, stride)

x2 = pad(x, pads)
x3 = pooling1d(x2, kernel, stride)

x2 = pad(x, pads)
x3 = pooling3d(x2, kernel, stride)

y = pow((shift + x * scale), power)

if x < 0    y = x * slope
else        y = x

y = float2int8(x * scale)

y = reduce_op(x * coeff)

if x < 0    y = x * slope
else        y = x

if mode == 0    y = space_to_depth(x) where x channel order is sw-sh-outc
if mode == 1    y = space_to_depth(x) where x channel order is outc-sw-sh

x2 = x * scale_in + bias
x3 = activation(x2)
y = float2int8(x3 * scale_out)

y = reshape(x)

split x along outmost axis into part x0, x1 ...
root mean square normalize for each part x0, x1 ...
y = x * gamma by elementwise

y = rnn(x)
y0, hidden y1 = rnn(x0, hidden x1)

y1 = x1 * cos - x2 * sin
y2 = x1 * sin + x2 * cos

if scale_data_size == -233  y = x0 * x1
else                        y = x * scale + bias

scaled dot product attention
for each num_head part
    qk = q * k
    qk = qk + attn_mask if attn_mask exists
    softmax(qk)
    qkv = qk * v

if x < 0    y = (exp(x) - 1.f) * alpha * lambda
else        y = x * lambda

if x < -lambd y = x + bias
if x >  lambd y = x - bias
else          y = x

if reverse == 0     y = shufflechannel(x) by group
if reverse == 1     y = shufflechannel(x) by channel / group

y = 1 / (1 + exp(-x))

split x along axis into slices, each part slice size is based on slices array

softmax(x, axis)

y = log(exp(x) + 1)

x1 = pad(x) if center
y = stft(x1)
y = y / sqrt(norm) if normalized

if power == 0 return y as real
if power == 1 return magnitude
if power == 2 return square of magnitude

y0, y1 ... = x

y = x / (1 + exp(-x))

y = tanh(x)

if x > threshold    y = 1
else                y = 0

y = repeat tiles along axis for x

y = unaryop(x)

y = unfold(x)