콘텐츠로 이동

Mobilint IR 연산 형식

이 페이지는 Mobilint IR 연산의 동작, 입력·출력 형상과 속성을 설명합니다. 형식 목록에 있다는 사실만으로 NPU 또는 CPU 오프로딩 실행이 보장되지는 않습니다. 실행 범위는 NPU 연산 지원 범위와 CPU 오프로딩을 확인하세요.

연산 정의 읽는 법

  • 4차원 활성화 텐서는 NHWC 순서입니다. N은 배치, H는 높이, W는 너비, C는 채널이며 아래 형상의 배치 크기는 1입니다.
  • 입력과 출력은 위치에 따라 in[0], out[0]처럼 표기합니다.
  • Weight 속성은 텐서 값이 아니라 텐서 인덱스(TensorIndex)를 저장합니다. 이 인덱스는 상수 텐서의 이름, 자료형, 형상, 저장 위치가 기록된 서브그래프 텐서 표를 가리킵니다. -1은 텐서가 없음을 뜻하며, 생략한 선택적 텐서 속성에도 사용합니다.
  • 속성 표에서 필수는 반드시 지정해야 하는 값, 선택은 생략할 수 있는 값입니다.

연산별 상세 정의

Adding

두 활성화 텐서의 원소별 합.

두 활성화 텐서를 원소별로 더합니다.

out[0] = in[0] + in[1]

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.
in[1] in[0]과 broadcast 가능 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] broadcast(in[0], in[1]) 출력 활성화 텐서.

AddingConstant

활성화 텐서에 상수 텐서를 더합니다.

모델에 저장된 상수를 활성화 텐서 하나에 더합니다. 상수는 scalar, 채널별 벡터, 전체 텐서 중 어느 것이든 될 수 있습니다.

out[0] = constant + in[0]   if is_const_first
         in[0] + constant   otherwise

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
constant Weight 필수 상수 피연산자. in[0]에 맞춰 broadcast합니다.
is_const_first bool false 상수가 왼쪽 피연산자이면 true.
shape int32[] [] 저장된 constant를 (예를 들어 채널별 벡터로) 축약하기 전, 상수 피연산자의 shape. 출력 shape은 broadcast(shape(in[0]), shape)입니다. 기본값 []은 텐서의 shape을 따로 적지 않은 경우이며 필수는 아닙니다.

출력

이름 형상 설명
out[0] broadcast(in[0], shape) 출력 활성화 텐서.

Batchnorm

저장된 평균과 분산으로 채널별 정규화한 뒤 scale과 shift를 적용합니다.

추론 형태의 batch normalization입니다. 각 채널을 모델에 저장된 상수 moving_mean, moving_var로 정규화한 뒤 gamma를 곱하고 beta를 더합니다.

out[0][n, h, w, c] = (in[0][n, h, w, c] - moving_mean[c]) / sqrt(moving_var[c] + epsilon)
                     * gamma[c] + beta[c]

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
gamma Weight 필수 채널별 scale.
beta Weight 필수 채널별 shift.
moving_mean Weight 필수 입력에서 빼는 채널별 평균.
moving_var Weight 필수 epsilon을 더하고 제곱근을 취해 입력을 나누는 채널별 분산.
epsilon Weight 필수 수치 안정성을 위해 분산에 더하는 scalar.
channel_last bool true NPU에서는 NHWC 포맷을 사용하기 때문에 true여야 합니다.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Celu

매개변수 alpha를 쓰는 연속 미분 가능 ELU.

양수 입력은 그대로 두고, 음수 입력은 -alpha로 포화하는 지수 함수로 바꿉니다.

out[0] = max(0, in[0]) + min(0, alpha * (exp(in[0] / alpha) - 1))

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
alpha float32 필수 음수 구간의 포화값이자 지수의 나눗수.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Clip

각 원소를 [clip_min_value, clip_max_value] 범위로 제한합니다.

모든 원소를 주어진 경계 안으로 제한합니다. 경계는 하나만 둘 수 있으며, 없는 쪽은 제한하지 않습니다.

out[0] = min(max(in[0], clip_min_value), clip_max_value)
an absent bound is skipped

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
clip_max_value float32 선택 상한. 없으면 상한을 두지 않습니다.
clip_min_value float32 선택 하한. 없으면 하한을 두지 않습니다.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Concatenate

여러 활성화 텐서를 한 축을 따라 이어 붙입니다.

in[0..K-1]을 피연산자 순서대로 axis 축을 따라 이어 붙입니다. 모든 피연산자는 rank가 같고 나머지 축의 크기가 모두 같습니다.

out[0] = concat(in[0], in[1], ..., in[K-1]) along axis
out[0].shape[axis] = in[0].shape[axis] + ... + in[K-1].shape[axis]

입력

이름 형상 설명
in[0..K-1] axis 축 외에는 모두 같음 입력 활성화 텐서.

속성

이름 타입 기본값 설명
original_key str 선택 더 이상 사용하지 않는 속성(deprecated)입니다. 키는 항상 있지만 값은 항상 None입니다.
axis int32 선택 이어 붙일 축. 음수는 마지막 축부터 셉니다. 텐서의 실제 배치 순서를 따르므로 NHWC 활성화 텐서에서는 3이 채널 축입니다.
original_axis int32 선택 더 이상 사용하지 않는 속성(deprecated)입니다. 키는 항상 있지만 값은 항상 None입니다.
original_inputs int32[] 선택 더 이상 사용하지 않는 속성(deprecated)입니다. 키는 항상 있지만 값은 항상 None입니다.
input_index int32[] 선택 항상 [0, 1, ..., K-1]입니다.
input_names str[] 선택 항상 이 연산의 실제 입력 활성화 텐서 이름과 같습니다.

출력

이름 형상 설명
out[0] axis 축 크기를 피연산자에 대해 합한 in[0] shape 출력 활성화 텐서.

Convolution

NHWC 활성화 텐서과 상수 필터의 2-D convolution.

in[0]의 공간 축 위로 weight를 stride, dilation, zero padding에 맞춰 이동하며 곱해 더하고 bias를 더합니다. weight는 출력 채널 우선인 [out_channels, in_channels / group_number, h_kernel, w_kernel]로 저장합니다.

G  = group_number,  Cg = in_channels / G,  Og = out_channels / G   (// : integer division)
xp = zero_pad(in[0], top=north_padding, bottom=south_padding,
                     left=west_padding, right=east_padding)
out[0][n, y, x, o] = bias[o] + sum_{ky, kx, c < Cg}
    weight[o, c, ky, kx]
    * xp[n, y*h_stride + ky*h_dilation, x*w_stride + kx*w_dilation, (o // Og)*Cg + c]

입력

이름 형상 설명
in[0] [1, H, W, in_channels] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
in_channels int32 필수 입력 채널 수.
out_channels int32 필수 출력 채널 수.
h_kernel int32 필수 kernel 높이.
w_kernel int32 필수 kernel 너비.
h_stride int32 필수 H 방향 stride.
w_stride int32 필수 W 방향 stride.
h_dilation int32 필수 H 방향 dilation.
w_dilation int32 필수 W 방향 dilation.
west_padding int32 필수 W 시작(왼쪽)의 zero padding.
east_padding int32 필수 W 끝(오른쪽)의 zero padding.
north_padding int32 필수 H 시작(위쪽)의 zero padding.
south_padding int32 필수 H 끝(아래쪽)의 zero padding.
padding_list int32[] [] 원래 2-D padding [top, left, bottom, right]. 참고용이며 계산에는 네 *_padding 속성을 씁니다.
group_number int32 필수 채널 그룹 수를 의미하여 값은 1이어야 합니다. 1이 아닌 경우 GroupConvolution 또는 DepthwiseConvolution이어야 합니다.
weight Weight 필수 필터, [out_channels, in_channels / group_number, h_kernel, w_kernel].
bias Weight 선택 bias, [out_channels]. 없으면 0.
channel_last bool true NPU에서는 NHWC 포맷을 사용하기 때문에 true여야 합니다.

출력

이름 형상 설명
out[0] [1, H_out, W_out, out_channels] 출력 활성화 텐서.

Cos

원소별 cosine.

out[0] = cos(in[0])

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

DepthwiseConvolution

입력 채널마다 별도 필터를 쓰는 depthwise 2-D convolution.

입력 채널마다 그룹 하나를 두는(group_number = in_channels) Convolution입니다. 각 입력 채널은 자기 전용 필터 M = out_channels / in_channels개와만 convolution하고 다른 채널과 섞이지 않으며, 출력 채널 o는 입력 채널 o / M을 읽습니다. weight는 [out_channels, 1, h_kernel, w_kernel]로 저장합니다.

M  = out_channels / in_channels
xp = zero_pad(in[0], top=north_padding, bottom=south_padding,
                     left=west_padding, right=east_padding)
out[0][n, y, x, o] = bias[o] + sum_{ky, kx}
    weight[o, 0, ky, kx]
    * xp[n, y*h_stride + ky*h_dilation, x*w_stride + kx*w_dilation, o / M]

입력

이름 형상 설명
in[0] [1, H, W, in_channels] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
in_channels int32 필수 입력 채널 수.
out_channels int32 필수 출력 채널 수. in_channels * M입니다.
h_kernel int32 필수 kernel 높이.
w_kernel int32 필수 kernel 너비.
h_stride int32 필수 H 방향 stride.
w_stride int32 필수 W 방향 stride.
h_dilation int32 필수 H 방향 dilation.
w_dilation int32 필수 W 방향 dilation.
west_padding int32 필수 W 시작(왼쪽)의 zero padding.
east_padding int32 필수 W 끝(오른쪽)의 zero padding.
north_padding int32 필수 H 시작(위쪽)의 zero padding.
south_padding int32 필수 H 끝(아래쪽)의 zero padding.
padding_list int32[] [] 원래 2-D padding [top, left, bottom, right]. 참고용이며 계산에는 네 *_padding 속성을 씁니다.
group_number int32 필수 채널 그룹 수. 입력 채널마다 그룹이 하나이므로 in_channels와 같습니다.
weight Weight 필수 필터, [out_channels, 1, h_kernel, w_kernel].
bias Weight 선택 bias, [out_channels]. 없으면 0.
channel_last bool true NPU에서는 NHWC 포맷을 사용하기 때문에 true여야 합니다.

출력

이름 형상 설명
out[0] [1, H_out, W_out, out_channels] 출력 활성화 텐서.

Div

두 활성화 텐서의 원소별 몫.

in[0]을 in[1]로 원소별로 나눕니다(실수 나눗셈).

out[0] = in[0] / in[1]

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.
in[1] in[0]과 broadcast 가능 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] broadcast(in[0], in[1]) 출력 활성화 텐서.

DivConstant

활성화 텐서를 상수로 나누거나 상수를 활성화 텐서로 나눕니다.

피연산자 하나를 모델에 저장된 상수로 하여 나눗셈을 합니다. 상수는 scalar, 채널별 벡터, 전체 텐서 중 어느 것이든 될 수 있습니다. is_const_first가 true이면 constant / in[0], false이면 in[0] / constant를 계산합니다.

out[0] = constant / in[0]   if is_const_first
         in[0] / constant   otherwise

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
constant Weight 필수 상수 피연산자. in[0]에 맞춰 broadcast합니다.
is_const_first bool 필수 상수가 피제수(왼쪽 피연산자)이면 true, 제수이면 false.
shape int32[] [] 저장된 constant를 (예를 들어 채널별 벡터로) 축약하기 전, 상수 피연산자의 shape. 출력 shape은 broadcast(shape(in[0]), shape)입니다. 기본값 []은 텐서의 shape을 따로 적지 않은 경우이며 필수는 아닙니다.

출력

이름 형상 설명
out[0] broadcast(in[0], shape) 출력 활성화 텐서.

Elu

음수 쪽 배율이 leaky_alpha인 exponential linear unit.

양수 입력은 그대로 두고, 나머지는 -leaky_alpha로 포화하는 leaky_alpha * (exp(x) - 1)로 바꿉니다.

out[0] = in[0]                            if in[0] > 0
         leaky_alpha * (exp(in[0]) - 1)   otherwise

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
leaky_alpha float32 필수 ELU의 alpha. 음수 구간의 배율.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Erf

원소별 Gauss 오차 함수(erf).

out[0] = erf(in[0]) = 2 / sqrt(pi) * integral_0^in[0] exp(-t^2) dt

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Exp

원소별 자연 지수 함수.

out[0] = exp(in[0])

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Gelu

Gaussian error linear unit.

GELU를 원소별로 적용합니다. approximate로 erf를 쓰는 방식과 tanh 근사식 중 하나를 고릅니다.

approximate = false:  out[0] = 0.5 * x * (1 + erf(x / sqrt(2)))
approximate = true:   out[0] = 0.5 * x * (1 + tanh(sqrt(2/pi) * (x + 0.044715 * x^3)))
where x = in[0]

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
approximate bool false tanh 근사식이면 true, erf 정확식이면 false.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

GroupConvolution

NHWC 활성화 텐서과 상수 필터의 grouped 2-D convolution.

Convolution과 같은 grouped convolution을 계산합니다. 채널을 group_number개 그룹으로 나누고, 각 그룹의 출력 out_channels / group_number개는 같은 그룹의 입력 in_channels / group_number개만 봅니다.

G  = group_number,  Cg = in_channels / G,  Og = out_channels / G   (// : integer division)
xp = zero_pad(in[0], top=north_padding, bottom=south_padding,
                     left=west_padding, right=east_padding)
out[0][n, y, x, o] = bias[o] + sum_{ky, kx, c < Cg}
    weight[o, c, ky, kx]
    * xp[n, y*h_stride + ky*h_dilation, x*w_stride + kx*w_dilation, (o // Og)*Cg + c]

입력

이름 형상 설명
in[0] [1, H, W, in_channels] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
in_channels int32 필수 입력 채널 수.
out_channels int32 필수 출력 채널 수.
h_kernel int32 필수 kernel 높이.
w_kernel int32 필수 kernel 너비.
h_stride int32 필수 H 방향 stride.
w_stride int32 필수 W 방향 stride.
h_dilation int32 필수 H 방향 dilation.
w_dilation int32 필수 W 방향 dilation.
west_padding int32 필수 W 시작(왼쪽)의 zero padding.
east_padding int32 필수 W 끝(오른쪽)의 zero padding.
north_padding int32 필수 H 시작(위쪽)의 zero padding.
south_padding int32 필수 H 끝(아래쪽)의 zero padding.
padding_list int32[] [] 원래 2-D padding [top, left, bottom, right]. 참고용이며 계산에는 네 *_padding 속성을 씁니다.
group_number int32 필수 채널 그룹 수. in_channels와 out_channels를 모두 나누어떨어지게 합니다.
weight Weight 필수 필터, [out_channels, in_channels / group_number, h_kernel, w_kernel].
bias Weight 선택 bias, [out_channels]. 없으면 0.
channel_last bool true NPU에서는 NHWC 포맷을 사용하기 때문에 true여야 합니다.

출력

이름 형상 설명
out[0] [1, H_out, W_out, out_channels] 출력 활성화 텐서.

GroupNormalization

채널 그룹마다 H, W와 그룹 채널에 대해 정규화한 뒤 scale과 bias를 적용합니다.

C개 채널을 연속된 num_groups개 그룹으로 나누고, 배치 항목마다 각 그룹을 H, W와 그룹 채널에 대해 평균 0, 분산 1로 정규화합니다. 이어서 채널별 scale과 bias를 적용합니다. 분산은 모집단 분산입니다.

G = num_groups,  Cg = C / G,  g(c) = floor(c / Cg)
S(n, g)   = in[0][n, :, :, g*Cg : (g+1)*Cg]
mu[n, g]  = mean(S(n, g))
var[n, g] = mean((S(n, g) - mu[n, g])^2)
out[0][n, h, w, c] = (in[0][n, h, w, c] - mu[n, g(c)]) / sqrt(var[n, g(c)] + epsilon)
                     * scale[c] + bias[c]

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
num_groups int32 필수 채널 그룹 수. C를 나누어떨어지게 하며, 각 그룹은 연속된 C / num_groups개 채널입니다.
scale Weight 필수 채널별 scale(gamma).
bias Weight 선택 채널별 bias(beta). 없으면 0.
epsilon Weight 필수 수치 안정성을 위해 분산에 더하는 scalar.
channel_last bool true NPU에서는 NHWC 포맷을 사용하기 때문에 true여야 합니다.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

HardSigmoid

구간 선형 sigmoid, clamp(alpha * x + beta, 0, 1).

[0, 1]로 제한한 선형 경사입니다. alpha나 beta가 없으면 각각 1/6, 0.5를 씁니다.

out[0] = clamp(alpha * in[0] + beta, 0, 1)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
alpha float32 선택 경사의 기울기. 없으면 1/6.
beta float32 선택 경사의 절편. 없으면 0.5.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

HardSwish

구간별 swish, x * clamp(x + 3, 0, 6) / 6.

out[0] = in[0] * clamp(in[0] + 3, 0, 6) / 6

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

HeaderView

채널 축을 attention head로 나눠 H 축으로 쌓습니다.

[1, H, W, heads*D] projection을 head별 D 채널 행으로 바꾸는 reshape-transpose-reshape를 하나의 연산으로 표현합니다. 모든 head의 행을 H 축으로 쌓습니다.

D = C / num_heads
batch_order = 0 (head-minor rows, row = h*num_heads + head):
  [1, H, W, C] -reshape-> [1, H, W, num_heads, D]
               -transpose(0,1,3,2,4)-> [1, H, num_heads, W, D]
               -reshape-> [1, H*num_heads, W, D]
batch_order = 1 (head-major rows, row = head*H + h):
  [1, H, W, C] -reshape-> [1, H, W, num_heads, D]
               -transpose(0,3,1,2,4)-> [1, num_heads, H, W, D]
               -reshape-> [1, num_heads*H, W, D]

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
view_shape int32[] [] 사용 중단(deprecated)되었으며 무시합니다. num_heads를 씁니다.
num_heads int32 -1 head 수. C를 나누어떨어지게 합니다.
batch_order int32 0 쌓인 head의 행 순서. 0은 H의 각 행 안에서 head를 번갈아 두고, 1은 head마다 H개 행을 연속으로 둡니다.

출력

이름 형상 설명
out[0] [1, H*num_heads, W, C/num_heads] 출력 활성화 텐서.

HeaderViewRevert

H 축에 쌓인 attention head를 풀어 채널 축으로 다시 합칩니다.

H 축으로 쌓인 D 채널짜리 head별 행 [1, num_heads*H, W, D]를 채널 축으로 이어 붙여 [1, H, W, num_heads*D]로 만듭니다. batch_order는 행을 쌓을 때 쓴 값과 같아야 합니다.

in[0] is [1, num_heads*H, W, D]
batch_order = 0 (input row = h*num_heads + head):
  -reshape-> [1, H, num_heads, W, D]
  -transpose(0,1,3,2,4)-> [1, H, W, num_heads, D]
  -reshape-> [1, H, W, num_heads*D]
batch_order = 1 (input row = head*H + h):
  -reshape-> [1, num_heads, H, W, D]
  -transpose(0,2,3,1,4)-> [1, H, W, num_heads, D]
  -reshape-> [1, H, W, num_heads*D]

입력

이름 형상 설명
in[0] [1, num_heads*H, W, D] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
revert_shape int32[] [] 사용 중단(deprecated)되었으며 무시합니다. num_heads를 씁니다.
num_heads int32 -1 head 수. in[0]의 H 크기를 나누어떨어지게 합니다.
batch_order int32 0 in[0]에 쌓인 head의 행 순서. 0은 H의 각 행 안에서 head가 번갈아 있고, 1은 head마다 H개 행이 연속으로 있습니다. HeaderView와 같은 의미입니다.

출력

이름 형상 설명
out[0] [1, H, W, num_heads*D] 출력 활성화 텐서.

Input

활성화 텐서를 그래프 입력으로 지정합니다.

in[0]이 그래프 밖에서 공급됨을 나타냅니다. 피연산자와 결과가 같은 활성화 텐서이므로 계산은 없으며, 그 활성화 텐서를 그래프 입력으로 지정할 뿐입니다.

out[0] = in[0]      (the same activation)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
orig_name str "" 원본 모델에서 이 입력의 사용자용 이름. 컴파일된 모델이 같은 입력 이름을 쓰도록 보존합니다.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

InputConstant

모델에 저장된 상수를 활성화 텐서로 제공합니다.

피연산자가 없으며, 결과는 원소 타입 dtype, shape shape인 저장된 constant입니다.

out[0] = constant

입력

없음.

속성

이름 타입 기본값 설명
constant Weight 필수 상수 값.
dtype str "" 상수의 원소 타입 이름. 예를 들어 float32, int64.
shape int32[] [] 상수의 shape이며 out[0]의 shape입니다.

출력

이름 형상 설명
out[0] shape 출력 활성화 텐서.

InstanceNormalization

채널마다 H, W에 대해 정규화합니다.

배치 항목의 모든 채널을 H, W에 대해 평균 0, 분산 1로 정규화한 뒤 채널별 scale과 bias를 적용합니다. 분산은 모집단 분산입니다. 여러 채널이 통계를 공유하는 정규화(num_groups가 -1이 아닌 경우)는 GroupNormalization으로 표현합니다.

mu[n, c]  = mean(in[0][n, :, :, c])
var[n, c] = mean((in[0][n, :, :, c] - mu[n, c])^2)
out[0][n, h, w, c] = (in[0][n, h, w, c] - mu[n, c]) / sqrt(var[n, c] + epsilon)
                     * scale[c] + bias[c]

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
scale Weight 필수 scale(gamma).
bias Weight 선택 bias(beta). shape은 scale과 같습니다. 없으면 0.
epsilon Weight 필수 수치 안정성을 위해 분산에 더하는 scalar.
channel_last bool true NPU에서는 NHWC 포맷을 사용하기 때문에 true여야 합니다.
num_groups int32 -1 항상 -1. 채널을 묶어 정규화하는 경우는 GroupNormalization입니다.
group_order int32 -1 항상 -1. 사용하지 않습니다.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

InverseSigmoid

sigmoid의 역함수 log(x / (1 - x)). eps로 유한한 값을 유지합니다.

in[0]을 [0, 1]로 제한한 뒤 x / (1 - x)의 분자와 분모를 eps 이상으로 유지하므로, 0과 1 및 그 바깥의 입력에서도 결과가 유한합니다.

x1 = max(clamp(in[0], 0, 1), eps)
x2 = max(1 - x1, eps)
out[0] = log(x1 / x2)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
eps float32 1e-05 분자와 분모에 적용하는 하한.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

L1Normalization

지정한 축에 대한 절댓값 합으로 나눕니다.

in[0]을 norm_axis 방향 절댓값의 합이 1이 되도록 나누며, 나머지 축의 위치마다 따로 계산합니다. 나누는 값의 하한은 1e-12입니다.

s      = sum(abs(in[0]), norm_axis, keep_dims=true)
out[0] = in[0] / max(s, 1e-12)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
norm_axis int32[] 필수 정규화할 축. in[0]의 실제 배치 순서에 대한 index이며, 음수는 마지막 축부터 셉니다.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

L2Normalization

지정한 축에 대한 Euclidean norm으로 나눕니다.

in[0]을 norm_axis 방향 L2 norm이 1이 되도록 나누며, 나머지 축의 위치마다 따로 계산합니다. 0으로 나누지 않도록 norm의 하한을 epsilon으로 둡니다.

r      = sqrt(sum(in[0]^2, norm_axis, keep_dims=true))
out[0] = in[0] / max(r, epsilon)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
norm_axis int32[] 필수 정규화할 축. in[0]의 실제 배치 순서에 대한 index이며, 음수는 마지막 축부터 셉니다.
epsilon Weight 선택 norm의 하한. 없으면 1e-12.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

LayerNormalization

마지막 축들에 대해 정규화한 뒤 scale과 bias를 적용합니다.

in[0]의 마지막 len(normalized_shape)개 축에 대해 평균 0, 분산 1로 정규화한 뒤 원소별 affine scale, bias를 적용합니다. 평균과 분산은 나머지 앞쪽 축의 위치마다 따로 구하며, 분산은 편향(모집단) 분산입니다.

axes   = the last len(normalized_shape) axes of in[0]
mu     = mean(in[0], axes)
var    = mean((in[0] - mu)^2, axes)
out[0] = (in[0] - mu) / sqrt(var + epsilon) * scale + bias

입력

이름 형상 설명
in[0] [..., *normalized_shape] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
normalized_shape int64[] [] 정규화할 마지막 축들의 shape. 예를 들어 NHWC 활성화 텐서의 채널 축을 정규화하면 [C].
scale Weight 필수 원소별 scale(gamma). shape은 normalized_shape.
bias Weight 선택 원소별 bias(beta). shape은 normalized_shape. 없으면 0.
epsilon Weight 필수 수치 안정성을 위해 분산에 더하는 scalar.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

LeakyRelu

음수 입력에 scalar 기울기 leaky_alpha를 주는 ReLU.

음수 원소에 scalar 기울기 하나를 곱합니다.

out[0] = in[0]                 if in[0] >= 0
         leaky_alpha * in[0]   otherwise

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
leaky_alpha float32 필수 음수 입력의 기울기.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Log

원소별 자연로그.

out[0] = ln(in[0])

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

MatMul

두 활성화 텐서의 마지막 두 축에 대한 batch 행렬 곱.

in[0]과 in[1]을 마지막 두 축에 대한 행렬로 보고 곱합니다. 앞쪽 축은 모두 batch 축이며 broadcast합니다. 4-D NHWC 활성화 텐서에서는 [W, C]가 행렬이고 N, H가 batch 축입니다.

a = in[0],  b = in[1]
repeat = [0, R]:  a = repeat_interleave(a, R, axis=1)
repeat = [1, R]:  b = repeat_interleave(b, R, axis=1)
  where repeat_interleave(x, R, axis=1)[n, h, ...] = x[n, floor(h / R), ...]
out[0][..., m, p] = sum_k a[..., m, k] * b[..., k, p]

입력

이름 형상 설명
in[0] [..., M, K] 입력 활성화 텐서.
in[1] [..., K, P] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
constant Weight 선택 사용하지 않는 속성으로 항상 -1입니다. 상수 행렬은 InputConstant에서 나온 활성화 텐서로 전달합니다.
is_const_first bool false 사용하지 않는 속성으로 항상 false입니다.
repeat int32[2] [-1, -1] [operand, R]. 곱하기 전에 operand번 피연산자(0 = in[0], 1 = in[1])를 축 1(H)을 따라 R번 반복하며, 각 H slice를 제자리에서 R번 되풀이합니다(h0 h1 h0 h1 ...이 아니라 h0 h0 h1 h1 ...). [-1, -1]이면 반복하지 않습니다.

출력

이름 형상 설명
out[0] [앞쪽 축의 broadcast 결과, M, P] 출력 활성화 텐서.

Mish

self-gated 활성화 텐서 x * tanh(softplus(x)).

out[0] = in[0] * tanh(log(1 + exp(in[0])))

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Multiply

두 활성화 텐서의 원소별 곱.

두 활성화 텐서를 원소별로 곱합니다.

out[0] = in[0] * in[1]

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.
in[1] in[0]과 broadcast 가능 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] broadcast(in[0], in[1]) 출력 활성화 텐서.

MultiplyConstant

활성화 텐서에 상수 텐서를 곱합니다.

활성화 텐서 하나에 모델에 저장된 상수를 곱합니다. 상수는 scalar, 채널별 벡터, 전체 텐서 중 어느 것이든 될 수 있습니다.

out[0] = constant * in[0]   if is_const_first
         in[0] * constant   otherwise

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
constant Weight 필수 상수 피연산자. in[0]에 맞춰 broadcast합니다.
is_const_first bool false 상수가 왼쪽 피연산자이면 true.
shape int32[] [] 저장된 constant를 (예를 들어 채널별 벡터로) 축약하기 전, 상수 피연산자의 shape. 출력 shape은 broadcast(shape(in[0]), shape)입니다. 기본값 []은 텐서의 shape을 따로 적지 않은 경우이며 필수는 아닙니다.

출력

이름 형상 설명
out[0] broadcast(in[0], shape) 출력 활성화 텐서.

OrderedPatchify

H x W를 window로 나누고 픽셀을 window 단위로 재배치합니다.

[1, H, W, C] map을 h_kernel x w_kernel window의 gh x gw 격자로 자르고 H, W 위의 2-D 배치로 펼치는 reshape-transpose-reshape를 하나의 연산으로 표현합니다. order=0은 window마다 한 행이며 그 픽셀을 raster 순서로 담습니다. order=1은 이를 H/W 전치한 것으로 window 내 픽셀 위치마다 한 행입니다. order=2는 order=1을 되돌립니다. 채널은 통째로 옮겨지며 섞이지 않습니다.

gh = H / h_kernel,  gw = W / w_kernel
x = reshape(in[0], [1, gh, h_kernel, gw, w_kernel, C])
order 0: out[0] = reshape(transpose(x, 0,1,3,2,4,5), [1, gh*gw, h_kernel*w_kernel, C])
order 1: out[0] = reshape(transpose(x, 0,2,4,1,3,5), [1, h_kernel*w_kernel, gh*gw, C])
order 2: out[0] = reshape(transpose(x, 0,3,1,4,2,5), [1, gw*gh, w_kernel*h_kernel, C])
Element map, p < gh, q < h_kernel, u < gw, v < w_kernel:
  in[0][0, p*h_kernel + q, u*w_kernel + v, c] =
    order 0: out[0][0, p*gw + u, q*w_kernel + v, c]
    order 1: out[0][0, q*w_kernel + v, p*gw + u, c]
    order 2: out[0][0, u*gh + p, v*h_kernel + q, c]

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
h_kernel int32 필수 window 높이. H를 나누어떨어지게 합니다.
w_kernel int32 필수 window 너비. W를 나누어떨어지게 합니다.
order int32 0 배치 방식. 0은 window마다 한 행, 1은 window 내 위치마다 한 행(0의 전치), 2는 1의 역변환입니다. formula를 참고합니다.

출력

이름 형상 설명
out[0] order 0, 2는 [1, ghgw, h_kernelw_kernel, C], order 1은 [1, h_kernelw_kernel, ghgw, C] 출력 활성화 텐서.

Output

활성화 텐서를 그래프 출력으로 지정합니다.

in[0]을 그래프가 반환함을 나타냅니다. 피연산자와 결과가 같은 활성화 텐서이므로 계산은 없으며, 그 활성화 텐서를 그래프 출력으로 지정할 뿐입니다.

out[0] = in[0]      (the same activation)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
orig_name str "" 원본 모델에서 이 출력의 사용자용 이름. 컴파일된 모델이 같은 출력 이름을 쓰도록 보존합니다.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Pad

NHWC 활성화 텐서의 H, W 축을 상수 또는 reflection으로 padding합니다.

in[0]의 위에 north_padding, 아래에 south_padding, 왼쪽에 west_padding, 오른쪽에 east_padding만큼 padding을 덧붙입니다. batch 축과 채널 축은 padding하지 않습니다.

H_out = north_padding + H + south_padding
W_out = west_padding  + W + east_padding
out[0][n, north_padding + i, west_padding + j, c] = in[0][n, i, j, c]
other cells:
  constant:  constant
  reflect:   in[0] mirrored about its first/last row and column, edge not
             repeated (the row above row 0 is row 1)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
west_padding int32 -1 W 시작(왼쪽)에 추가하는 열 수.
east_padding int32 -1 W 끝(오른쪽)에 추가하는 열 수.
south_padding int32 -1 H 끝(아래쪽)에 추가하는 행 수.
north_padding int32 -1 H 시작(위쪽)에 추가하는 행 수.
pad_mode str 필수 constant이면 새 칸을 constant로 채우고, reflect이면 가장자리 행이나 열을 반복하지 않고 경계를 기준으로 in[0]을 거울상으로 채웁니다.
constant float32 0.0 pad_mode = constant일 때 채우는 값.
padding_list int32[] 선택 같은 padding을 모든 축에 대해 [x1_begin, x2_begin, ..., x1_end, x2_end, ...]로 적은 값으로, NHWC에서는 [0, top, left, 0, 0, bottom, right, 0]입니다. 참고용이며 계산에는 네 *_padding 속성을 씁니다.
channel_last bool true NPU에서는 NHWC 포맷을 사용하기 때문에 true여야 합니다.

출력

이름 형상 설명
out[0] [1, H_out, W_out, C] 출력 활성화 텐서.

Pooling

NHWC 활성화 텐서의 슬라이딩 window에 대한 2-D max 또는 average pooling.

in[0]을 *_padding 속성만큼 pad_mode가 정한 값으로 padding한 뒤, stride만큼 이동하고 dilation만큼 벌어진 h_kernel x w_kernel window마다 최댓값(MaxPool) 또는 평균(AvgPool)을 구합니다. 채널은 서로 독립적으로 pooling합니다.

xp = pad(in[0], top=north_padding, bottom=south_padding,
                left=west_padding, right=east_padding)    (fill per pad_mode)
win(n, y, x, c) = { xp[n, y*h_stride + ky*h_dilation, x*w_stride + kx*w_dilation, c]
                    : ky < h_kernel, kx < w_kernel }
MaxPool:  out[0][n, y, x, c] = max(win(n, y, x, c))
AvgPool:  out[0][n, y, x, c] = sum(win(n, y, x, c)) / cnt
          cnt = h_kernel * w_kernel                    if is_include_pad
                number of window cells inside in[0]    otherwise

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
h_kernel int32 필수 window 높이.
w_kernel int32 필수 window 너비.
h_stride int32 필수 H 방향 stride.
w_stride int32 필수 W 방향 stride.
h_dilation int32 1 H 방향 dilation.
w_dilation int32 1 W 방향 dilation.
west_padding int32 필수 W 시작(왼쪽)의 padding.
east_padding int32 필수 W 끝(오른쪽)의 padding.
north_padding int32 필수 H 시작(위쪽)의 padding.
south_padding int32 필수 H 끝(아래쪽)의 padding.
padding_list int32[] [] 원래 2-D padding [top, left, bottom, right]. 참고용이며 비어 있을 수 있습니다. 계산에는 네 *_padding 속성을 씁니다.
pool_type str 필수 window 최댓값이면 MaxPool, window 평균이면 AvgPool.
pad_mode str 필수 padding 영역을 채우는 값. constant(0), -inf(음의 무한대로, padding이 최댓값이 되지 않음), reflect(가장자리를 반복하지 않는 경계 기준 거울상) 중 하나입니다. -inf는 AvgPool과 is_include_pad = true 조합에 쓰지 않습니다.
is_ceil_mode bool false 원래 pooling이 출력 크기를 올림했음을 기록합니다. 참고용이며, 출력 크기는 항상 아래의 내림 공식을 따르므로 올림한 크기는 south_padding(아래쪽), east_padding(오른쪽)의 추가 padding으로 표현됩니다.
is_include_pad bool false AvgPool에만 적용합니다. true이면 padding 칸을 포함한 전체 window 크기 h_kernel * w_kernel로 나누고, false이면 window 중 in[0] 안에 있는 칸 수로 나눕니다.
channel_last bool true NPU에서는 NHWC 포맷을 사용하기 때문에 true여야 합니다.

출력

이름 형상 설명
out[0] [1, H_out, W_out, C] 출력 활성화 텐서.

Pow

각 원소를 상수 scalar 지수로 거듭제곱합니다.

in[0]의 모든 원소를 같은 지수로 거듭제곱합니다.

out[0] = in[0] ^ exponent

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
exponent float32 필수 scalar 지수.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

PRelu

음수 기울기가 상수 텐서인 leaky ReLU.

음수 원소에 모델에 저장된 텐서 기울기 leaky_alpha를 곱합니다. 기울기는 in[0]에 마지막 축부터 맞춰 broadcast합니다.

out[0] = in[0]                 if in[0] >= 0
         leaky_alpha * in[0]   otherwise   (leaky_alpha broadcast to in[0])

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
leaky_alpha Weight 필수 음수 입력의 기울기. in[0]에 broadcast 가능해야 합니다.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

QuickGelu

GELU의 sigmoid 근사, x * sigmoid(1.702 * x).

sigmoid(1.702 * x)를 gate로 써서 Gelu를 근사합니다.

out[0] = in[0] * sigmoid(1.702 * in[0])

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

ReduceMax

지정한 축에 대한 최댓값.

in[0]의 reduce_axes 축에서 가장 큰 원소를 고르며, 나머지 축의 위치마다 따로 구합니다.

out[0] = max(in[0], reduce_axes, keep_dims)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
keep_dims bool 필수 true이면 축약한 축을 크기 1로 남기고, false이면 제거합니다.
reduce_axes int32[] 필수 축약할 축. in[0]의 실제 배치 순서에 대한 index이며(NHWC 활성화 텐서에서 3이 채널 축), 음수는 마지막 축부터 셉니다.
noop_with_empty_axes int32 필수 reduce_axes가 비어 있을 때만 의미가 있습니다. 1이면 in[0]을 그대로 돌려주고, 0이면 모든 축을 축약합니다. IR은 보통 축약할 축을 명시합니다.

출력

이름 형상 설명
out[0] in[0]에서 축약한 축을 1로 두거나 제거한 shape 출력 활성화 텐서.

ReduceMean

지정한 축에 대한 산술 평균.

in[0]을 reduce_axes 축에 대해 평균하며, 나머지 축의 위치마다 따로 구합니다.

out[0] = sum(in[0], reduce_axes, keep_dims) / (product of in[0]'s sizes on reduce_axes)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
keep_dims bool 필수 true이면 축약한 축을 크기 1로 남기고, false이면 제거합니다.
reduce_axes int32[] 필수 축약할 축. in[0]의 실제 배치 순서에 대한 index이며(NHWC 활성화 텐서에서 3이 채널 축), 음수는 마지막 축부터 셉니다.
noop_with_empty_axes int32 필수 reduce_axes가 비어 있을 때만 의미가 있습니다. 1이면 in[0]을 그대로 돌려주고, 0이면 모든 축을 축약합니다. IR은 보통 축약할 축을 명시합니다.

출력

이름 형상 설명
out[0] in[0]에서 축약한 축을 1로 두거나 제거한 shape 출력 활성화 텐서.

ReduceMin

지정한 축에 대한 최솟값.

in[0]의 reduce_axes 축에서 가장 작은 원소를 고르며, 나머지 축의 위치마다 따로 구합니다.

out[0] = min(in[0], reduce_axes, keep_dims)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
keep_dims bool 필수 true이면 축약한 축을 크기 1로 남기고, false이면 제거합니다.
reduce_axes int32[] 필수 축약할 축. in[0]의 실제 배치 순서에 대한 index이며(NHWC 활성화 텐서에서 3이 채널 축), 음수는 마지막 축부터 셉니다.
noop_with_empty_axes int32 필수 reduce_axes가 비어 있을 때만 의미가 있습니다. 1이면 in[0]을 그대로 돌려주고, 0이면 모든 축을 축약합니다. IR은 보통 축약할 축을 명시합니다.

출력

이름 형상 설명
out[0] in[0]에서 축약한 축을 1로 두거나 제거한 shape 출력 활성화 텐서.

ReduceSum

지정한 축에 대한 합.

in[0]의 reduce_axes 축 원소를 모두 더하며, 나머지 축의 위치마다 따로 구합니다.

out[0] = sum(in[0], reduce_axes, keep_dims)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
keep_dims bool 필수 true이면 축약한 축을 크기 1로 남기고, false이면 제거합니다.
reduce_axes int32[] 필수 축약할 축. in[0]의 실제 배치 순서에 대한 index이며(NHWC 활성화 텐서에서 3이 채널 축), 음수는 마지막 축부터 셉니다.
noop_with_empty_axes int32 필수 reduce_axes가 비어 있을 때만 의미가 있습니다. 1이면 in[0]을 그대로 돌려주고, 0이면 모든 축을 축약합니다. IR은 보통 축약할 축을 명시합니다.

출력

이름 형상 설명
out[0] in[0]에서 축약한 축을 1로 두거나 제거한 shape 출력 활성화 텐서.

RelShift

relative offset attention score를 absolute key 위치로 재배열합니다.

Transformer-XL 방식 attention의 relative position shift입니다. in[0]의 행 i는 query i의 2Q - 1개 relative offset score를 담으며, 열 k는 query - key = Q - 1 - k를 뜻합니다. 행 i를 왼쪽으로 Q - 1 - i만큼 밀고 Q개 열만 남기므로 결과의 열 j는 key j에 대한 score입니다.

out[0][n, h, i, j] = in[0][n, h, i, Q - 1 - i + j],   i, j < Q
Equivalent sequence on [1, H, Q, P], P = 2Q - 1:
  pad one zero at the start of axis 3   -> [1, H, Q, P+1]
  reshape                               -> [1, H, P+1, Q]
  drop the first row of axis 2          -> [1, H, P, Q]
  reshape                               -> [1, H, Q, P]
  slice axis 3 to [0, Q)                -> [1, H, Q, Q]

입력

이름 형상 설명
in[0] [1, H, Q, 2Q-1] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] [1, H, Q, Q] 출력 활성화 텐서.

Relu

rectified linear unit, max(x, 0).

out[0] = max(in[0], 0)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Reshape

원소 순서를 바꾸지 않고 활성화 텐서의 shape만 바꿉니다.

in[0]을 new_shape shape으로 바꿔 반환합니다. 원소는 row-major 순서(마지막 축이 가장 빠름)를 그대로 유지합니다.

out[0] = reshape(in[0], new_shape)
flatten(out[0]) == flatten(in[0])   (same elements, row-major order)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
new_shape int32[] 선택 목표 shape. 한 항목은 -1일 수 있으며, 원소 수가 같도록 추론합니다. 0 항목은 allowzero에 따라 해석하며, graph builder가 명시적인 크기를 기록하므로 보통 0은 나타나지 않습니다.
allowzero int32 0 new_shape의 0을 해석하는 방식. 0이면 같은 위치의 in[0] 크기를 복사하고, 1이면 길이 0인 축이 됩니다.
is_const_first bool false 계산에 쓰이지 않습니다. in[0]이 항상 데이터입니다.

출력

이름 형상 설명
out[0] -1을 계산한 new_shape 출력 활성화 텐서.

Resize

nearest, bilinear, bicubic 보간으로 공간 축의 크기를 바꿉니다.

in[0]을 새 H x W로 다시 샘플링합니다. sizes와 scales는 in[0]의 축 순서대로 축마다 값 하나를 가지며, 입력과 달라질 수 있는 축은 두 공간 축뿐입니다.

shape(out[0]) = sizes                     if sizes is given
                shape(in[0]) * scales     otherwise, axis by axis
s_h = H_out / H,  s_w = W_out / W         (or the matching scales entries)
nearest:  out[0][n, y, x, c] = in[0][n, floor(y / s_h), floor(x / s_w), c]
linear:   bilinear blend of the 2 x 2 input pixels around (ys, xs)
cubic:    bicubic blend of the 4 x 4 input pixels around (ys, xs)
where the source row ys of output row y follows transform_mode
(columns likewise with x, W, W_out, s_w):
  half_pixel:     ys = (y + 0.5) / s_h - 0.5
  align_corners:  ys = y * (H - 1) / (H_out - 1)
  asymmetric:     ys = y / s_h
source positions outside the input are clamped to the border

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
resize_type str 선택 보간 방식. nearest, linear(H, W에 대한 bilinear), cubic(bicubic) 중 하나입니다.
resize_mode str 선택 그래프를 만들 때 기록한 보간 방식. 값은 resize_type과 같으며 없을 수도 있습니다. 계산에는 resize_type을 씁니다.
nearest_mode str 선택 원래 모델이 nearest에 쓰던 반올림 규칙(round_prefer_floor, round_prefer_ceil, floor, ceil). 기록용이며, nearest는 formula처럼 항상 내림합니다.
transform_mode str 선택 linear와 cubic에서 출력 좌표를 입력 좌표로 옮기는 방식. half_pixel(픽셀 중심 정렬. 그 밖의 기록값도 이 방식을 따름), align_corners(모서리 픽셀 정렬), asymmetric(출력 인덱스를 배율로 나눔) 중 하나이며, 식은 formula를 따릅니다. nearest는 항상 asymmetric 방식을 씁니다.
roi int32[] 선택 crop-and-resize의 관심 영역. 기록용이며 계산에 쓰지 않습니다.
scales float32[] 선택 in[0]의 축별 배율. 크기가 그대로인 축은 1.0입니다. 예를 들어 [1, 2, 2, 1]은 NHWC 텐서의 H와 W를 두 배로 늘립니다.
sizes int32[] 선택 출력 shape. in[0]의 축마다 값 하나를 가집니다.
cubic_coeff_a float32 선택 cubic의 cubic kernel 계수 a. 기록용이며 계산에 쓰지 않습니다.
exclude_outside int32 선택 cubic에서 1이면 입력 밖의 kernel tap을 버리고 나머지 가중치를 다시 정규화합니다. 기록용이며 계산에 쓰지 않습니다.
extrapolation_value float32 선택 crop-and-resize에서 원본 위치가 입력 밖인 출력 픽셀의 값. 기록용이며 계산에 쓰지 않습니다.
antialias int32 선택 1이면 linear나 cubic으로 축소할 때 저역 통과(antialiasing) 필터를 적용하고, 0이거나 없으면 적용하지 않습니다.
axes int32[] 선택 원래 resize가 배율이나 크기를 지정한 축. 기록용이며, IR의 scales와 sizes는 항상 모든 축을 다룹니다.
keep_aspect_ratio_policy str 선택 원래 resize가 종횡비를 지키며 목표 크기를 맞춘 방식(stretch, not_larger, not_smaller). 기록용이며 계산에 쓰지 않습니다.

출력

이름 형상 설명
out[0] [1, H_out, W_out, C] 출력 활성화 텐서.

RmsNormalization

마지막 축들에 대한 root mean square로 나눈 뒤 scale을 곱합니다.

in[0]을 마지막 len(normalized_shape)개 축에 대한 root mean square로 나누고 scale을 곱합니다. rms_center가 있으면 RMS는 in[0] - rms_center로 구하지만 분자는 in[0] 그대로입니다.

axes   = the last len(normalized_shape) axes of in[0]
center = rms_center if present, else 0
rms    = sqrt(mean((in[0] - center)^2, axes, keep_dims=true) + epsilon)
out[0] = in[0] / rms * scale

입력

이름 형상 설명
in[0] [..., *normalized_shape] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
normalized_shape int64[] [] 정규화할 마지막 축들의 shape. 보통 NHWC 활성화 텐서의 채널 축인 [C]입니다.
epsilon Weight 필수 수치 안정성을 위해 제곱 평균에 더하는 scalar.
scale Weight 필수 원소별 scale(gamma). shape은 normalized_shape.
rms_center Weight 선택 RMS 안에서만 in[0]에서 빼는 채널별 offset. 없으면 0.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Sigmoid

입력 배율 alpha를 둘 수 있는 logistic sigmoid.

1 / (1 + exp(-alpha * x))를 계산합니다.

out[0] = 1 / (1 + exp(-alpha * in[0]))

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
alpha float32 1.0 sigmoid 전에 입력에 곱하는 배율.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Sin

원소별 sine.

out[0] = sin(in[0])

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Slice

하나 이상의 축을 따라 일정 간격의 부분 구간을 잘라냅니다.

나열된 각 축에서 start부터 end 직전까지 step 간격으로 원소를 남기고, 나머지 축은 그대로 둡니다. 목록은 위치별로 대응하므로 start, end, step의 k번째 항목이 axis[k] 축에 적용됩니다.

for each k, along axis a = axis[k] with length D = in[0].shape[a]:
    s = start[k] (+ D if negative), clamped to [0, D]
    e = end[k]   (+ D if negative), clamped to [0, D]
    keep indices s, s + step[k], s + 2*step[k], ... while < e
out[0] = in[0] restricted to the kept indices on every listed axis

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
axis int32[] 필수 자를 축 목록. 음수는 마지막 축부터 셉니다.
start int64[] 필수 각 축에서 남길 첫 인덱스(포함).
end int64[] 필수 각 축의 끝 인덱스(제외). 축 길이를 넘는 값은 축 길이로 맞추므로 2147483647처럼 큰 값은 "끝까지"를 뜻합니다.
step int64[] 선택 각 축의 간격. 없으면 모든 축에서 1.

출력

이름 형상 설명
out[0] 자른 축만 줄어든 in[0] shape 출력 활성화 텐서.

Softmax

한 축을 따라 지수값을 합이 1이 되도록 정규화합니다.

in[0]의 axis 축에 대해 softmax를 계산하며, 필요하면 먼저 입력에 beta를 곱합니다.

z = beta * in[0]
out[0] = exp(z) / sum(exp(z), axis)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
beta float32 1.0 지수 전에 입력에 곱하는 배율. 0이면 안 됩니다.
axis int32 필수 정규화할 축. 음수는 마지막 축부터 셉니다.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Softplus

부드러운 ReLU log(1 + exp(beta * x)) / beta. threshold 위에서는 선형입니다.

beta * x가 threshold를 넘는 곳에서는 출력이 x 자체입니다.

out[0] = in[0]                               if beta * in[0] > threshold
         log(1 + exp(beta * in[0])) / beta   otherwise

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
beta float32 1.0 곡선의 날카로움. 클수록 ReLU에 가까워집니다.
threshold float32 20.0 출력이 선형으로 바뀌는 beta * x의 경계값.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Sqrt

원소별 제곱근.

out[0] = sqrt(in[0])

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

StaggeredPadding

각 행렬의 r번째 행을 r열만큼 밀고 0으로 채운 뒤 잘라냅니다.

[1, H, W, C]의 마지막 두 축을 길이 C인 행 W개로 보고, 각 행을 행 번호만큼 밀어 0으로 채운 행에 놓아 계단 형태를 만듭니다. reverse=false는 행 r을 오른쪽으로 r만큼 밀고 양쪽에서 window_size열을 잘라냅니다. reverse=true는 행 r마다 열 r을 중심으로 한 2*window_size + 1개 열을 읽습니다.

x[n, h, r, k] = in[0][n, h, r, k] for 0 <= k < C, and 0 for any other k
reverse = false:
  o = 0 if window_size = -1, else window_size
  out[0][n, h, r, j] = x[n, h, r, j + o - r],        j < W + C - 1 - 2*o
reverse = true:
  out[0][n, h, r, j] = x[n, h, r, r + j - window_size],   j < 2*window_size + 1
Equivalent sequence for reverse = false:
  [1, H, W, C] -pad axis 3 end by W-> [1, H, W, C+W] -reshape-> [1, H, W*(C+W)]
  -drop the last W-> -reshape-> [1, H, W, W+C-1] -slice axis 3 [o, W+C-1-o)

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
axis int32 3 원소를 이동하는 축. 3(마지막 축)만 정의되어 있으며, 행은 축 2를 따라 놓입니다.
reverse bool false false이면 행 r이 열 r에서 시작합니다(오른쪽 아래로 내려가는 계단). true이면 행 r이 열 W - 1 - r에서 시작하고(왼쪽 아래로 내려가는 계단), 결과를 폭 2*window_size + 1의 band로 잘라냅니다.
window_size int32 -1 reverse=false에서는 양쪽에서 잘라낼 열 수이며, -1이면 전체 폭 W + C - 1을 유지합니다. reverse=true에서는 band의 반폭이며 반드시 지정해야 하고(-1 불가), W와 C는 각각 window_size + 1 이상입니다.

출력

이름 형상 설명
out[0] reverse=false는 [1, H, W, W + C - 1 - 2o], reverse=true는 [1, H, W, 2window_size + 1] 출력 활성화 텐서.

StatefulAttentionMaskWrapper

attention score에 causal, sliding-window 또는 주어진 mask를 더합니다.

attention score에 mask를 적용합니다. causal_mask에서는 Q개 query를 K개 key 위치 중 마지막 Q개로 보고 score shape만으로 bias를 만듭니다. custom_mask에서는 bias를 두 번째 입력으로 받습니다.

custom_mask:
  out[0] = in[0] + in[1]
causal_mask:
  qp(i) = K - Q + i                        key position of query i
  masked(i, j) = j > qp(i)  or  (is_sliding and j <= qp(i) - sliding_window)
  out[0][..., i, j] = -inf if masked(i, j) else in[0][..., i, j]

입력

이름 형상 설명
in[0] [1, heads, Q, K] 입력 활성화 텐서.
in[1] in[0]과 broadcast 가능 입력 활성화 텐서.

속성

이름 타입 기본값 설명
past_seqlen int32 0 graph를 trace할 때 query 앞에 있던 cache 위치 수. 참고용이며 mask는 실행 시 Q와 K를 따릅니다.
is_sliding bool false true이면 query보다 sliding_window 이상 앞선 key도 가립니다(causal_mask 전용).
sliding_window int32 1024 is_sliding일 때 query가 볼 수 있는 가장 최근 key 위치 수(query 자신 포함).
mask_type str "causal_mask" causal_mask는 위치로 mask를 만들며 입력이 하나입니다. custom_mask는 in[1]을 더하며 입력이 둘입니다.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

StatefulCachedStack

이전 호출에서 보관한 마지막 원소들을 한 축 앞에 붙입니다.

axis 방향 마지막 cache_len개 원소를 호출 사이에 보관하고 새 입력 앞에 붙입니다. 첫 호출에서는 0이 붙고, 이후 호출에서는 앞선 입력의 끝부분이 붙습니다. 보관하는 window는 연산이 가진 상태이며 피연산자가 아닙니다.

state: entries of shape in[0] with axis extent cache_len, initially zeros
out[0] = concat(state, in[0], axis)
state  = last cache_len entries of out[0] along axis
cache_len = 0:  out[0] = in[0]

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
axis int32 2 이어 붙이는 축. 기본값 2는 NHWC의 sequence 축 W입니다. 음수는 마지막 축부터 셉니다.
cache_len int32 0 보관해서 앞에 붙이는 원소 수. 0이면 identity입니다.
cache_name str 필수 보관하는 window의 이름.

출력

이름 형상 설명
out[0] in[0]에서 axis 크기 + cache_len 출력 활성화 텐서.

StatefulGRUWrapper

시퀀스에 GRU를 적용해 단계별 출력과 최종 hidden state를 반환합니다.

in[0]의 시간 축을 따라 상수 weight W, R, B로 GRU recurrence를 한 방향 또는 양방향으로 계산합니다. 어떤 피연산자가 있는지는 input_mask로 나타내며, 결과는 항상 out[0] (모든 step의 hidden state)과 out[1] (최종 hidden state)입니다.

batch_first = true; T = steps; @ = matrix product, * = element-wise product
for each direction d (0 = forward, 1 = backward):
  act_f, act_g = activations[2d .. 2d+1]          (activations[0..1] if only 2)
  Wz, Wr, Wh = W[d] split into 3 row blocks;  Rz, Rr, Rh = R[d] likewise
  Wbz, Wbr, Wbh, Rbz, Rbr, Rbh = B[d] split into 6   (zero if no B)
  h = in[h][:, 0, d, :]                              (zero if absent)
  for t = 0 .. T-1 (forward) or t = T-1 .. 0 (backward):
    x = in[0][:, 0, t, :]
    z = act_f(x @ Wz^T + h @ Rz^T + Wbz + Rbz)
    r = act_f(x @ Wr^T + h @ Rr^T + Wbr + Rbr)
    n = act_g(x @ Wh^T + Wbh + (r * h) @ Rh^T + Rbh)   if not linear_before_reset
        act_g(x @ Wh^T + Wbh + r * (h @ Rh^T + Rbh))   if linear_before_reset
    h = (1 - z) * n + z * h
    out[0][:, d, t, :] = h
  out[1][:, 0, d, :] = h

입력

이름 형상 설명
in[0] [1, 1, T, input_size] 입력 활성화 텐서.
in[s] any 입력 활성화 텐서.
in[h] [1, 1, num_directions, hidden_size] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
W Weight 필수 입력 weight, [num_directions, 3*hidden_size, input_size]. gate 블록 순서는 z(update), r(reset), h(candidate)입니다.
R Weight 필수 recurrent weight, [num_directions, 3*hidden_size, hidden_size]. gate 순서는 z, r, h입니다.
B Weight 선택 bias, [num_directions, 6*hidden_size]. 입력 bias(z, r, h) 다음에 recurrent bias(z, r, h)가 옵니다. 없으면 0입니다.
input_mask str 필수 있는 피연산자를 순서대로 나타내는 문자열. i 입력 시퀀스(항상 처음), s 시퀀스 길이, h 초기 hidden state입니다. 예를 들어 ih이면 in[0]이 시퀀스, in[1]이 hidden state입니다.
output_mask str 필수 o, h 중 실제로 쓰이는 결과(out[0], out[1])를 나타내는 문자열. 두 결과의 위치는 바뀌지 않습니다.
direction str "forward" forward, backward(reverse도 같음), bidirectional 중 하나. bidirectional은 두 방향을 모두 계산해 방향 축에 forward(index 0), backward(index 1)로 쌓으므로 num_directions가 2이고, 나머지는 1입니다.
batch_first bool false 여기 표기한 shape인 batch 우선 배치이면 true. false는 시간 우선 배치로, in[0]이 [T, 1, input_size], state가 [num_directions, 1, hidden_size], out[0]이 [T, num_directions, 1, hidden_size]입니다.
hidden_size int32 필수 방향별 hidden unit 수.
hidden_state_name str 필수 out[1]과 cell subgraph의 state 출력의 이름.
subgraph str 필수 step 입력과 이전 hidden state로 한 time step을 계산하는 cell subgraph의 이름.
activation_alpha float32[] 선택 activations의 함수에 쓰는 alpha 계수. 순서가 같습니다. sigmoid와 tanh는 계수를 쓰지 않습니다.
activation_beta float32[] 선택 activations의 함수에 쓰는 beta 계수. 순서가 같습니다. sigmoid와 tanh는 계수를 쓰지 않습니다.
activations str[] 선택 gate 함수 [act_f, act_g]. 보통 [sigmoid, tanh]입니다. bidirectional에서 4개를 주면 forward, backward 순서이고, 2개를 주면 두 방향에 같이 씁니다. 기준 구현은 sigmoid와 tanh를 정의합니다.
clip float32 선택 cell clip 임계값. 값이 있으면 gate 입력을 활성화 전에 [-clip, clip]로 제한하며, 없으면 제한하지 않습니다.
linear_before_reset bool false false이면 recurrent 곱 전에 이전 state에 reset gate를 곱하고, true이면 곱한 결과 h @ Rh^T + Rbh에 reset gate를 곱합니다.

출력

이름 형상 설명
out[0] [1, num_directions, T, hidden_size] 출력 활성화 텐서.
out[1] [1, 1, num_directions, hidden_size] 출력 활성화 텐서.

StatefulKVCacheWrapper

새 key 또는 value state를 유지되는 cache에 추가하고 cache를 반환합니다.

한 layer의 key 또는 value cache를 호출 사이에 유지합니다. 매 호출마다 in[0]의 새 state S개를 해당 token의 절대 위치에 기록하고, 현재 attention이 볼 수 있는 모든 state를 위치 순서로 반환합니다. cache와 token 위치는 실행 시 상태이며 IR 피연산자가 아닙니다.

pos = absolute positions of the S new tokens (from the runtime), p0 = pos[0]
the cache holds the states of earlier calls by position; in[0] is stored at pos
is_sliding = false:
  out[0] = states of positions 0 .. pos[S-1], concatenated on axis 2
is_sliding = true:
  out[0] = states of positions max(0, p0 - (sliding_window - 1)) .. pos[S-1]
  only the last sliding_window positions stay stored for later calls

입력

이름 형상 설명
in[0] [1, heads, S, D] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
cache_name str 필수 이 연산이 읽고 쓰는 cache 상태의 이름.
past_seqlen int32 0 graph를 trace할 때 cache에 이미 있던 token 수. 정적 출력 길이는 S + past_seqlen이며 0이 아니면 dynamic 크기가 됩니다. 실행 시 길이는 token 위치를 따릅니다. is_sliding이면 sliding_window - 1 이하입니다.
is_sliding bool false true이면 가장 최근 sliding_window개 위치만 유지합니다(sliding-window attention).
sliding_window int32 1024 is_sliding일 때 token 단위 window 길이. 양수이며 max_cache_len 이하입니다.
max_cache_len int32 8192 token 단위 cache 용량.

출력

이름 형상 설명
out[0] [1, heads, P + S, D]. P는 보이는 과거 token 수(p0, sliding이면 min(p0, sliding_window - 1)) 출력 활성화 텐서.

StatefulLSTMWrapper

시퀀스에 LSTM을 적용해 단계별 출력과 최종 hidden/cell state를 반환합니다.

in[0]의 시간 축을 따라 상수 weight W, R, B와 선택적 peephole P로 LSTM recurrence를 한 방향 또는 양방향으로 계산합니다. 어떤 피연산자가 있는지는 input_mask로 나타내며, 결과는 항상 out[0] (모든 step의 hidden state), out[1] (최종 hidden state), out[2] (최종 cell state)입니다.

batch_first = true; T = steps; @ = matrix product, * = element-wise product
for each direction d (0 = forward, 1 = backward):
  act_f, act_g, act_h = activations[3d .. 3d+2]   (activations[0..2] if only 3)
  Wi, Wo, Wf, Wc = W[d] split into 4 row blocks;  Ri, Ro, Rf, Rc = R[d] likewise
  Wbi, Wbo, Wbf, Wbc, Rbi, Rbo, Rbf, Rbc = B[d] split into 8   (zero if no B)
  Pi, Po, Pf = P[d] split into 3                                (zero if no P)
  h = in[h][:, 0, d, :],  c = in[c][:, 0, d, :]                 (zero if absent)
  for t = 0 .. T-1 (forward) or t = T-1 .. 0 (backward):
    x = in[0][:, 0, t, :]
    i = act_f(x @ Wi^T + h @ Ri^T + Wbi + Rbi + Pi * c)
    f = act_f(x @ Wf^T + h @ Rf^T + Wbf + Rbf + Pf * c)
    g = act_g(x @ Wc^T + h @ Rc^T + Wbc + Rbc)
    c = f * c + i * g
    o = act_f(x @ Wo^T + h @ Ro^T + Wbo + Rbo + Po * c)
    h = o * act_h(c)
    out[0][:, d, t, :] = h
  out[1][:, 0, d, :] = h
  out[2][:, 0, d, :] = c

입력

이름 형상 설명
in[0] [1, 1, T, input_size] 입력 활성화 텐서.
in[s] any 입력 활성화 텐서.
in[h] [1, 1, num_directions, hidden_size] 입력 활성화 텐서.
in[c] [1, 1, num_directions, hidden_size] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
W Weight 필수 입력 weight, [num_directions, 4*hidden_size, input_size]. gate 블록 순서는 i, o, f, c입니다.
R Weight 필수 recurrent weight, [num_directions, 4*hidden_size, hidden_size]. gate 순서는 i, o, f, c입니다.
B Weight 선택 bias, [num_directions, 8*hidden_size]. 입력 bias(i, o, f, c) 다음에 recurrent bias(i, o, f, c)가 옵니다. 없으면 0입니다.
input_mask str 필수 있는 피연산자를 순서대로 나타내는 문자열. i 입력 시퀀스(항상 처음), s 시퀀스 길이, h 초기 hidden state, c 초기 cell state입니다. 예를 들어 ihc이면 in[0..2]가 시퀀스, hidden state, cell state입니다.
output_mask str 필수 o, h, c 중 실제로 쓰이는 결과(out[0], out[1], out[2])를 나타내는 문자열. 세 결과의 위치는 바뀌지 않습니다.
P Weight 선택 peephole weight, [num_directions, 3*hidden_size]. 순서는 i, o, f입니다. 없으면 peephole을 쓰지 않습니다.
direction str "forward" forward, backward(reverse도 같음), bidirectional 중 하나. bidirectional은 두 방향을 모두 계산해 방향 축에 forward(index 0), backward(index 1)로 쌓으므로 num_directions가 2이고, 나머지는 1입니다.
batch_first bool false 여기 표기한 shape인 batch 우선 배치이면 true. false는 시간 우선 배치로, in[0]이 [T, 1, input_size], state가 [num_directions, 1, hidden_size], out[0]이 [T, num_directions, 1, hidden_size]입니다.
hidden_size int32 필수 방향별 hidden unit 수.
hidden_state_name str 필수 out[1]과 cell subgraph의 hidden state 출력의 이름.
cell_state_name str 필수 out[2]와 cell subgraph의 cell state 출력의 이름.
subgraph str 필수 step 입력과 이전 hidden/cell state로 한 time step을 계산하는 cell subgraph의 이름.
activation_alpha float32[] 선택 activations의 함수에 쓰는 alpha 계수. 순서가 같습니다. sigmoid와 tanh는 계수를 쓰지 않습니다.
activation_beta float32[] 선택 activations의 함수에 쓰는 beta 계수. 순서가 같습니다. sigmoid와 tanh는 계수를 쓰지 않습니다.
activations str[] 선택 gate 함수 [act_f, act_g, act_h]. 보통 [sigmoid, tanh, tanh]입니다. bidirectional에서 6개를 주면 forward, backward 순서이고, 3개를 주면 두 방향에 같이 씁니다. 기준 구현은 sigmoid와 tanh를 정의합니다.
clip float32 선택 cell clip 임계값. 값이 있으면 gate 입력을 활성화 전에 [-clip, clip]로 제한하며, 없으면 제한하지 않습니다.
input_forget bool false true이면 input gate와 forget gate를 결합합니다. 위 수식은 false인 경우입니다.

출력

이름 형상 설명
out[0] [1, num_directions, T, hidden_size] 출력 활성화 텐서.
out[1] [1, 1, num_directions, hidden_size] 출력 활성화 텐서.
out[2] [1, 1, num_directions, hidden_size] 출력 활성화 텐서.

StatefulRNNWrapper

시퀀스에 단순 RNN을 적용해 단계별 출력과 최종 state를 반환합니다.

in[0]의 시간 축을 따라 상수 weight W, R, B로 recurrence h = act_f(x W^T + h R^T + b)를 한 방향 또는 양방향으로 계산합니다. 어떤 피연산자가 있는지는 input_mask로 나타내며, 결과는 항상 out[0] (모든 step의 hidden state)과 out[1] (최종 hidden state)입니다.

batch_first = true; T = steps; @ = matrix product
for each direction d (0 = forward, 1 = backward):
  act_f = activations[d]            (activations[0] if only 1)
  Wb, Rb = B[d] split into 2        (zero if no B)
  h = in[h][:, 0, d, :]             (zero if absent)
  for t = 0 .. T-1 (forward) or t = T-1 .. 0 (backward):
    x = in[0][:, 0, t, :]
    h = act_f(x @ W[d]^T + h @ R[d]^T + Wb + Rb)
    out[0][:, d, t, :] = h
  out[1][:, 0, d, :] = h

입력

이름 형상 설명
in[0] [1, 1, T, input_size] 입력 활성화 텐서.
in[s] any 입력 활성화 텐서.
in[h] [1, 1, num_directions, hidden_size] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
W Weight 필수 입력 weight, [num_directions, hidden_size, input_size].
R Weight 필수 recurrent weight, [num_directions, hidden_size, hidden_size].
B Weight 선택 bias, [num_directions, 2*hidden_size]. 입력 bias 다음에 recurrent bias가 옵니다. 없으면 0입니다.
input_mask str 필수 있는 피연산자를 순서대로 나타내는 문자열. i 입력 시퀀스(항상 처음), s 시퀀스 길이, h 초기 hidden state입니다. 예를 들어 ih이면 in[0]이 시퀀스, in[1]이 hidden state입니다.
output_mask str 필수 o, h 중 실제로 쓰이는 결과(out[0], out[1])를 나타내는 문자열. 두 결과의 위치는 바뀌지 않습니다.
direction str "forward" forward, backward(reverse도 같음), bidirectional 중 하나. bidirectional은 두 방향을 모두 계산해 방향 축에 forward(index 0), backward(index 1)로 쌓으므로 num_directions가 2이고, 나머지는 1입니다.
batch_first bool false 여기 표기한 shape인 batch 우선 배치이면 true. false는 시간 우선 배치로, in[0]이 [T, 1, input_size], state가 [num_directions, 1, hidden_size], out[0]이 [T, num_directions, 1, hidden_size]입니다.
hidden_size int32 필수 방향별 hidden unit 수.
hidden_state_name str 필수 out[1]과 cell subgraph의 state 출력의 이름.
subgraph str 필수 step 입력과 이전 hidden state로 한 time step을 계산하는 cell subgraph의 이름.
activation_alpha float32[] 선택 activations의 함수에 쓰는 alpha 계수. 순서가 같습니다. sigmoid와 tanh는 계수를 쓰지 않습니다.
activation_beta float32[] 선택 activations의 함수에 쓰는 beta 계수. 순서가 같습니다. sigmoid와 tanh는 계수를 쓰지 않습니다.
activations str[] 선택 recurrence 함수 [act_f]. 보통 [tanh]입니다. bidirectional에서 2개를 주면 forward, backward 순서이고, 1개를 주면 두 방향에 같이 씁니다. 기준 구현은 sigmoid와 tanh를 정의합니다.
clip float32 선택 cell clip 임계값. 값이 있으면 활성화 함수의 입력을 [-clip, clip]로 제한하며, 없으면 제한하지 않습니다.

출력

이름 형상 설명
out[0] [1, num_directions, T, hidden_size] 출력 활성화 텐서.
out[1] [1, 1, num_directions, hidden_size] 출력 활성화 텐서.

StatefulRoPEWrapper

query 또는 key에 해당 위치의 rotary position embedding을 적용합니다.

위치에 따른 각도로 query 또는 key tensor의 채널 쌍을 회전합니다. 행 p가 위치 p에 해당하는 미리 계산된 cos/sin 표를 쓰며, 현재 호출 token의 절대 위치로 행을 고릅니다.

x = in[0];  c, s = rows of in[1], in[2] for the S current positions
rot0(y) = concat(-y[..., h:], y[..., :h]),   h = width(y) / 2
rot1(y)[..., 2i] = -y[..., 2i+1],  rot1(y)[..., 2i+1] = y[..., 2i]
rope_type 0:  R = rotary_emb_dim if > 0, else width(c)
              y = x[..., :R]
              out[0] = concat(y * c[..., :R] + rot0(y) * s[..., :R], x[..., R:])
rope_type 1:  out[0] = x * c + rot1(x) * s
rope_type 2:  rope_type 0 with R = width(c)

입력

이름 형상 설명
in[0] [1, heads, S, D] 입력 활성화 텐서.
in[1] [1, 1, L, R] 입력 활성화 텐서.
in[2] [1, 1, L, R] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
rope_type int32 0 채널 짝 방식. 0은 채널 i와 i + R/2를 짝짓고(rotary 채널을 반으로 나눔), 1은 인접한 채널 2i, 2i+1을 짝짓습니다. 2는 rotary 폭을 cos 표에서 가져오는 0입니다.
seqlen int32 0 graph를 만들 때 in[0]의 sequence 길이 S. 참고용이며 계산에는 실행 시 shape을 씁니다.
rotary_emb_dim int32 0 D 중 회전하는 앞쪽 채널 수(partial rotary). 나머지는 그대로 통과합니다. 0이면 cos 표의 폭을 씁니다. rope_type=0에서만 씁니다.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Sub

두 활성화 텐서의 원소별 차.

in[0]에서 in[1]을 원소별로 뺍니다.

out[0] = in[0] - in[1]

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.
in[1] in[0]과 broadcast 가능 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] broadcast(in[0], in[1]) 출력 활성화 텐서.

SubConstant

활성화 텐서에서 상수를 빼거나 상수에서 활성화 텐서를 뺍니다.

피연산자 하나를 모델에 저장된 상수로 하여 뺄셈을 합니다. 상수는 scalar, 채널별 벡터, 전체 텐서 중 어느 것이든 될 수 있습니다. is_const_first가 true이면 constant - in[0], false이면 in[0] - constant를 계산합니다.

out[0] = constant - in[0]   if is_const_first
         in[0] - constant   otherwise

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
constant Weight 필수 상수 피연산자. in[0]에 맞춰 broadcast합니다.
is_const_first bool 필수 상수가 피감수(왼쪽 피연산자)이면 true, 빼는 값이면 false.
shape int32[] [] 저장된 constant를 (예를 들어 채널별 벡터로) 축약하기 전, 상수 피연산자의 shape. 출력 shape은 broadcast(shape(in[0]), shape)입니다. 기본값 []은 텐서의 shape을 따로 적지 않은 경우이며 필수는 아닙니다.

출력

이름 형상 설명
out[0] broadcast(in[0], shape) 출력 활성화 텐서.

Swish

self-gated 활성화 텐서 x * sigmoid(x).

out[0] = in[0] * sigmoid(in[0]) = in[0] / (1 + exp(-in[0]))

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Tan

원소별 tangent.

out[0] = tan(in[0])

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

Tanh

원소별 hyperbolic tangent.

out[0] = tanh(in[0])

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

없음.

출력

이름 형상 설명
out[0] in[0]과 같음 출력 활성화 텐서.

TensorCmp

두 활성화 텐서를 원소별로 비교해 boolean 텐서를 만듭니다.

in[0]과 in[1]을 broadcast한 뒤 kind가 가리키는 관계로 원소별 비교합니다. 출력은 boolean이며 관계가 성립하는 위치가 true입니다.

kind = "eq":   out[0] = (in[0] == in[1])
kind = "neq":  out[0] = (in[0] != in[1])
kind = "lt":   out[0] = (in[0] <  in[1])
kind = "leq":  out[0] = (in[0] <= in[1])
kind = "gt":   out[0] = (in[0] >  in[1])
kind = "geq":  out[0] = (in[0] >= in[1])

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.
in[1] in[0]과 broadcast 가능 입력 활성화 텐서.

속성

이름 타입 기본값 설명
kind str "eq" 비교 관계. eq, neq, lt, leq, gt, geq 중 하나이며 in[0] <kind> in[1]로 읽습니다.

출력

이름 형상 설명
out[0] broadcast(in[0], in[1]) 출력 활성화 텐서.

Transpose

활성화 텐서의 축 순서를 바꿉니다.

out[0]의 i번째 축이 in[0]의 transpose_axes[i]번째 축이 되도록 축 순서를 바꿉니다.

P = transpose_axes
out[0].shape[i] = in[0].shape[P[i]]
out[0][i_0, ..., i_{r-1}] = in[0][j]   where j[P[k]] = i_k

입력

이름 형상 설명
in[0] [1, H, W, C] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
transpose_axes int64[] 필수 0..rank-1의 순열. i번째 항목은 출력의 i번째 축이 될 입력 축 번호입니다.

출력

이름 형상 설명
out[0] [in[0].shape[transpose_axes[i]] for each i] 출력 활성화 텐서.

TransposeConvolution

zero 삽입과 convolution으로 표현한 transposed 2-D convolution.

in[0]의 이웃 픽셀 사이에 0인 행 h_stride - 1개와 0인 열 w_stride - 1개를 끼워 넣어 upsample하고, 그 텐서를 *_padding 속성만큼 zero padding한 뒤 weight로 stride 1, 주어진 dilation의 convolution을 하고 bias를 더합니다. 따라서 weight는 transposed convolution kernel을 H, W 방향으로 뒤집어 convolution 배치 [out_channels, in_channels / group_number, h_kernel, w_kernel]로 저장하며, padding은 출력에서 잘라 내는 양이 아니라 zero 삽입한 텐서에 붙이는 양입니다.

G  = group_number,  Cg = in_channels / G,  Og = out_channels / G   (// : integer division)
z  = zeros([1, (H-1)*h_stride + 1, (W-1)*w_stride + 1, in_channels])
z[n, i*h_stride, j*w_stride, c] = in[0][n, i, j, c]
zp = zero_pad(z, top=north_padding, bottom=south_padding,
                 left=west_padding, right=east_padding)
out[0][n, y, x, o] = bias[o] + sum_{ky, kx, c < Cg}
    weight[o, c, ky, kx]
    * zp[n, y + ky*h_dilation, x + kx*w_dilation, (o // Og)*Cg + c]

입력

이름 형상 설명
in[0] [1, H, W, in_channels] 입력 활성화 텐서.

속성

이름 타입 기본값 설명
in_channels int32 필수 입력 채널 수.
out_channels int32 필수 출력 채널 수.
h_kernel int32 필수 kernel 높이.
w_kernel int32 필수 kernel 너비.
h_stride int32 필수 H 방향 upsampling stride. 입력 행 사이에 0인 행 h_stride - 1개를 넣습니다.
w_stride int32 필수 W 방향 upsampling stride. 입력 열 사이에 0인 열 w_stride - 1개를 넣습니다.
h_dilation int32 필수 H 방향 dilation.
w_dilation int32 필수 W 방향 dilation.
west_padding int32 필수 zero 삽입한 텐서의 W 시작(왼쪽) zero padding.
east_padding int32 필수 zero 삽입한 텐서의 W 끝(오른쪽) zero padding.
north_padding int32 필수 zero 삽입한 텐서의 H 시작(위쪽) zero padding.
south_padding int32 필수 zero 삽입한 텐서의 H 끝(아래쪽) zero padding.
padding_list int32[] [] 원래 transposed convolution padding [top, left, bottom, right](출력에서 덜어 내는 양). 참고용이며 계산에는 네 *_padding 속성을 씁니다.
og_padding_list int32[] [] 원래 transposed convolution padding을 담는 자리. 참고용으로 계산에 쓰지 않으며 보통 비어 있습니다.
og_out_padding_list int32[] [] 원래 transposed convolution의 output padding(출력 끝에 더하는 행과 열)을 담는 자리. 참고용으로 계산에 쓰지 않으며 보통 비어 있습니다.
group_number int32 필수 채널 그룹 수. in_channels와 out_channels를 모두 나누어떨어지게 합니다.
weight Weight 필수 convolution 배치의 필터 [out_channels, in_channels / group_number, h_kernel, w_kernel]. transposed convolution kernel을 H, W 방향으로 뒤집은 값입니다.
bias Weight 선택 bias, [out_channels]. 없으면 0.
channel_last bool true NPU에서는 NHWC 포맷을 사용하기 때문에 true여야 합니다.

출력

이름 형상 설명
out[0] [1, H_out, W_out, out_channels] 출력 활성화 텐서.

그 밖의 Mobilint IR 연산

아래 표는 앞에서 설명하지 않은 연산의 입력·속성 정보를 제공합니다. 표에 있다는 사실만으로 NPU 또는 CPU 오프로딩 지원이 보장되지는 않습니다.

연산 비고
Abs num inputs: 1
num outputs: 1
AddPartial num inputs: 2
num outputs: 1
attributes:
- is_input0_larger: bool
Cast num inputs: 1
num outputs: 1
attributes:
- dtype: str
Ceil num inputs: 1
num outputs: 1
Convolution3d num inputs: 1
num outputs: 1
attributes:
- in_channels: int32
- out_channels: int32
- h_kernel: int32
- w_kernel: int32
- d_kernel: int32
- h_stride: int32
- w_stride: int32
- d_stride: int32
- h_dilation: int32
- w_dilation: int32
- d_dilation: int32
- west_padding: int32
- east_padding: int32
- north_padding: int32
- south_padding: int32
- front_padding: int32
- back_padding: int32
- padding_list: int32[] (default=[])
- group_number: int32
- weight: Weight
- bias: Weight (optional)
- channel_last: bool (default=true)
Crop num inputs: 1
num outputs: 1
attributes:
- w_offset: int32 (default=0)
- h_offset: int32 (default=0)
- crop_width: int32
- crop_height: int32
DeviceBridge num inputs: 1
num outputs: 1
attributes:
- squeeze_axes: int32[]
- unsqueeze_axes: int32[]
- permute_axes: int64[]
- device: str (optional)
Expand num inputs: 1
num outputs: 1
attributes:
- constant: Weight (optional)
- is_const_first: bool
GLU num inputs: 1
num outputs: 1
GridSample num inputs: 2
num outputs: 1
attributes:
- align_corners: int32 (default=0)
- mode: str (default="linear")
- padding_mode: str (default="zeros")

description:
inputs: X, grid
X is in channel-last format.
X: (n, h, w, c)
grid: (n, h_out, w_out, num_spatial_dims). in this case, num_spatial_dims=2.
Hardtanh num inputs: 1
num outputs: 1
attributes:
- min_val: float32 (default=-1.0)
- max_val: float32 (default=1.0)
Hardshrink num inputs: 1
num outputs: 1
attributes:
- lambd: float32 (default=0.5)
Softshrink num inputs: 1
num outputs: 1
attributes:
- lambd: float32 (default=0.5)
Identity num inputs: 1
num outputs: 1
SumNormalization num inputs: 1
num outputs: 1
attributes:
- norm_axis: int32[]
- epsilon: float32 (optional)
LSTM num inputs: variable
num outputs: 1
attributes:
- W: Weight
- R: Weight
- B: Weight (optional)
- lstm_group: str
- input_mask: str
- output_mask: str
- P: Weight (optional)
- direction: str (default="forward")
- batch_first: bool (default=false)
- hidden_size: int32

description:
inputs:[input, sequence_lens, initial_h, initial_c]
outputs:[output] or [hidden_out] or [cell_out]
input_mask: "ishc" or "i", etc,...
output_mask: "o" or "h" or "c"
Logit num inputs: 1
num outputs: 1
attributes:
- eps: float32 (optional)

description:
Compute y = ln(z / (1 - z)). If eps is given, we clamp input z = clamp(z, min=eps, max=1-eps)
RNN num inputs: variable
num outputs: 1
attributes:
- W: Weight
- R: Weight
- B: Weight (optional)
- rnn_group: str
- input_mask: str
- output_mask: str
- direction: str (default="forward")
- batch_first: bool (default=false)
- hidden_size: int32

description:
inputs:[input, sequence_lens, initial_h]
outputs:[output] or [hidden_out]
input_mask: "ish" or "i", etc,...
output_mask: "o" or "h"
GRU num inputs: variable
num outputs: 1
attributes:
- W: Weight
- R: Weight
- B: Weight (optional)
- gru_group: str
- input_mask: str
- output_mask: str
- direction: str (default="forward")
- batch_first: bool (default=false)
- linear_before_reset: bool (default=false)
- hidden_size: int32

description:
inputs:[input, sequence_lens, initial_h]
outputs:[output] or [hidden_out]
input_mask: "ish" or "i", etc,...
output_mask: "o" or "h"
LogSigmoid num inputs: 1
num outputs: 1
MaskSoftmax num inputs: 1
num outputs: 1
attributes:
- beta: float32
- axis: int32
NonMaxSuppression num inputs: 2
num outputs: variable
attributes:
- max_output_size: int64
- iou_threshold: float32
- score_threshold: float32
- soft_nms_sigma: float32
- pad_to_max_output_size: bool
- center_point_box: int32 (default=0)
GlobalAveragePooling num inputs: 1
num outputs: 1
attributes:
- channel_last: bool (default=true)
GlobalResponseNormalization num inputs: 1
num outputs: 1
attributes:
- scale: Weight
- bias: Weight
- epsilon: float32
- channel_last: bool (default=true)
ReduceL2 num inputs: 1
num outputs: 1
attributes:
- keep_dims: bool
- reduce_axes: int32[]
- noop_with_empty_axes: int32
ReduceProd num inputs: 1
num outputs: 1
attributes:
- keep_dims: bool
- reduce_axes: int32[]
- noop_with_empty_axes: int32
ReduceRMS num inputs: 1
num outputs: 1
attributes:
- keep_dims: bool
- reduce_axes: int32[]
- epsilon: float32 (optional)

description:
reduce rms with epsilon if exists. i.e.,sqrt(mean**2 + eps)
we let eps to be optional so that it has more general fusing opportunities.
MeanCentering num inputs: 1
num outputs: 1
attributes:
- axes: int32[]

description:
compute x - mean(x, axes)
ReshapeV2 num inputs: 2
num outputs: 1
attributes:
- allowzero: int32 (default=0)
- is_const_first: bool (default=false)

description:
Reshape with variable shape argument. inputs[1] will be used as a shape.
RotaryEmbedding num inputs: 1
num outputs: 2
attributes:
- inv_freq: Weight
- attention_scaling: float32

description:
following the LlamaRotaryEmbedding of the Huggingface Transformer library.
inputs => (position_ids,), outputs => (cos, sin)
Rsqrt num inputs: 1
num outputs: 1
Rstd num inputs: 1
num outputs: 1
attributes:
- reduce_axes: int32[]
- epsilon: Weight
- num_groups: int32 (default=1)

description:
computes 1/std(x). if gruops > 1, then activation is grouped along channel axis.
Gather num inputs: 2
num outputs: 1
attributes:
- axis: int32 (default=0)
GatherElements num inputs: 2
num outputs: 1
attributes:
- axis: int32 (default=0)
ScatterND num inputs: variable
num outputs: 1
attributes:
- constant_data: Weight (optional)
- constant_indices: Weight (optional)
Selu num inputs: 1
num outputs: 1
Shape num inputs: 1
num outputs: 1
attributes:
- start: int32 (optional)
- end: int32 (optional)
LogSoftmax num inputs: 1
num outputs: 1
attributes:
- axis: int32
Softsign num inputs: 1
num outputs: 1
Unsqueeze num inputs: 1
num outputs: 1
attributes:
- axes: int32[]
DynamicSliceInputConst num inputs: 1
num outputs: 1
attributes:
- mod: int32
- start: int64[]
- end: int64[]
- axis: int64[]
- step: int64[] (optional)
MeloTTSPiecewiseRationalQuadraticTransform num inputs: 2
num outputs: 1
attributes:
- num_bins: int32
- filter_channels: int32
- tail_bound: float32
- reverse: bool

description:
helper function for parsing melotts model.
Neg num inputs: 1
num outputs: 1
Einsum num inputs: variable
num outputs: 1
attributes:
- equation: str
- constant: Weight (optional)
- is_const_first: bool (default=false)
Where num inputs: 3
num outputs: 1


description:
condition,X,Y, if cond == True: else y
Logical num inputs: variable
num outputs: 1
attributes:
- kind: str (default="and")

description:
this function represents the logical operation of two inputs.
single input if kind is "not" else two inputs
kind: and, or, xor, not
MaskedFill num inputs: 2
num outputs: 1
attributes:
- value: float32

description:
inputs: (x, mask)
SubgraphCall num inputs: variable
num outputs: variable
attributes:
- subgraph: str
- scope: str
- kind: str
MoeDispatcher num inputs: 2
num outputs: 2
attributes:
- top_k: int32
- norm_top_k_prob: bool (default=true)

description:
inputs: (hidden_states, router_logits)
outputs: (hidden_states, top_k_logits)
if norm_top_k_prob is true
topk_vals, topk_idx = torch.topk(
routing_weights, self.top_k, dim=-1
) # (18,8), (18,8)
weight_new = torch.zeros_like(routing_weights)
weight_new.scatter_(1, topk_idx, topk_vals)
routing_weights = weight_new
routing_weights /= routing_weights.sum(dim=1, keepdim=True)
MoeAggregator num inputs: variable
num outputs: 1


description:
inputs: (router_weights, experts_output0, expert_output1, ...)
TopKValues num inputs: 1
num outputs: 1
attributes:
- axis: int32
- k: int32 (default=1)
- largest: bool (default=true)
- sorted: bool (default=true)
TopKIndices num inputs: 1
num outputs: 1
attributes:
- axis: int32
- k: int32 (default=1)
- largest: bool (default=true)
- sorted: bool (default=true)