Mobilint IR 연산 형식¶
이 페이지는 Mobilint IR 연산의 동작, 입력·출력 형상과 속성을 설명합니다. 형식 목록에 있다는 사실만으로 NPU 또는 CPU 오프로딩 실행이 보장되지는 않습니다. 실행 범위는 NPU 연산 지원 범위와 CPU 오프로딩을 확인하세요.
연산 정의 읽는 법¶
- 4차원 활성화 텐서는 NHWC 순서입니다.
N은 배치,H는 높이,W는 너비,C는 채널이며 아래 형상의 배치 크기는 1입니다. - 입력과 출력은 위치에 따라
in[0],out[0]처럼 표기합니다. Weight속성은 텐서 값이 아니라 텐서 인덱스(TensorIndex)를 저장합니다. 이 인덱스는 상수 텐서의 이름, 자료형, 형상, 저장 위치가 기록된 서브그래프 텐서 표를 가리킵니다.-1은 텐서가 없음을 뜻하며, 생략한 선택적 텐서 속성에도 사용합니다.- 속성 표에서 필수는 반드시 지정해야 하는 값, 선택은 생략할 수 있는 값입니다.
연산별 상세 정의¶
Adding¶
두 활성화 텐서의 원소별 합.
두 활성화 텐서를 원소별로 더합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
in[1] |
in[0]과 broadcast 가능 | 입력 활성화 텐서. |
속성¶
없음.
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
broadcast(in[0], in[1]) |
출력 활성화 텐서. |
AddingConstant¶
활성화 텐서에 상수 텐서를 더합니다.
모델에 저장된 상수를 활성화 텐서 하나에 더합니다. 상수는 scalar, 채널별 벡터, 전체 텐서 중 어느 것이든 될 수 있습니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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로 포화하는 지수 함수로 바꿉니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
| 이름 | 타입 | 기본값 | 설명 |
|---|---|---|---|
alpha |
float32 |
필수 | 음수 구간의 포화값이자 지수의 나눗수. |
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
Clip¶
각 원소를 [clip_min_value, clip_max_value] 범위로 제한합니다.
모든 원소를 주어진 경계 안으로 제한합니다. 경계는 하나만 둘 수 있으며, 없는 쪽은 제한하지 않습니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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]로 원소별로 나눕니다(실수 나눗셈).
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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를 계산합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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)로 바꿉니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
| 이름 | 타입 | 기본값 | 설명 |
|---|---|---|---|
leaky_alpha |
float32 |
필수 | ELU의 alpha. 음수 구간의 배율. |
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
Erf¶
원소별 Gauss 오차 함수(erf).
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
없음.
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
Exp¶
원소별 자연 지수 함수.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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를 씁니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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]이 그래프 밖에서 공급됨을 나타냅니다. 피연산자와 결과가 같은 활성화 텐서이므로 계산은 없으며, 그 활성화 텐서를 그래프 입력으로 지정할 뿐입니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
| 이름 | 타입 | 기본값 | 설명 |
|---|---|---|---|
orig_name |
str |
"" |
원본 모델에서 이 입력의 사용자용 이름. 컴파일된 모델이 같은 입력 이름을 쓰도록 보존합니다. |
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
InputConstant¶
모델에 저장된 상수를 활성화 텐서로 제공합니다.
피연산자가 없으며, 결과는 원소 타입 dtype, shape shape인 저장된 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 및 그 바깥의 입력에서도 결과가 유한합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
| 이름 | 타입 | 기본값 | 설명 |
|---|---|---|---|
eps |
float32 |
1e-05 |
분자와 분모에 적용하는 하한. |
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
L1Normalization¶
지정한 축에 대한 절댓값 합으로 나눕니다.
in[0]을 norm_axis 방향 절댓값의 합이 1이 되도록 나누며, 나머지 축의 위치마다 따로 계산합니다. 나누는 값의 하한은 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으로 둡니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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 기울기 하나를 곱합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
| 이름 | 타입 | 기본값 | 설명 |
|---|---|---|---|
leaky_alpha |
float32 |
필수 | 음수 입력의 기울기. |
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
Log¶
원소별 자연로그.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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)).
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
없음.
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
Multiply¶
두 활성화 텐서의 원소별 곱.
두 활성화 텐서를 원소별로 곱합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
in[1] |
in[0]과 broadcast 가능 | 입력 활성화 텐서. |
속성¶
없음.
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
broadcast(in[0], in[1]) |
출력 활성화 텐서. |
MultiplyConstant¶
활성화 텐서에 상수 텐서를 곱합니다.
활성화 텐서 하나에 모델에 저장된 상수를 곱합니다. 상수는 scalar, 채널별 벡터, 전체 텐서 중 어느 것이든 될 수 있습니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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]을 그래프가 반환함을 나타냅니다. 피연산자와 결과가 같은 활성화 텐서이므로 계산은 없으며, 그 활성화 텐서를 그래프 출력으로 지정할 뿐입니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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]의 모든 원소를 같은 지수로 거듭제곱합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
| 이름 | 타입 | 기본값 | 설명 |
|---|---|---|---|
exponent |
float32 |
필수 | scalar 지수. |
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
PRelu¶
음수 기울기가 상수 텐서인 leaky ReLU.
음수 원소에 모델에 저장된 텐서 기울기 leaky_alpha를 곱합니다. 기울기는 in[0]에 마지막 축부터 맞춰 broadcast합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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를 근사합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
없음.
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
ReduceMax¶
지정한 축에 대한 최댓값.
in[0]의 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 | 출력 활성화 텐서. |
ReduceMean¶
지정한 축에 대한 산술 평균.
in[0]을 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 축에서 가장 작은 원소를 고르며, 나머지 축의 위치마다 따로 구합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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 축 원소를 모두 더하며, 나머지 축의 위치마다 따로 구합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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).
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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))를 계산합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
| 이름 | 타입 | 기본값 | 설명 |
|---|---|---|---|
alpha |
float32 |
1.0 |
sigmoid 전에 입력에 곱하는 배율. |
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
Sin¶
원소별 sine.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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를 곱합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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 자체입니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
| 이름 | 타입 | 기본값 | 설명 |
|---|---|---|---|
beta |
float32 |
1.0 |
곡선의 날카로움. 클수록 ReLU에 가까워집니다. |
threshold |
float32 |
20.0 |
출력이 선형으로 바뀌는 beta * x의 경계값. |
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
Sqrt¶
원소별 제곱근.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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]을 원소별로 뺍니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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를 계산합니다.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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).
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
없음.
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
Tan¶
원소별 tangent.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
in[0] |
[1, H, W, C] |
입력 활성화 텐서. |
속성¶
없음.
출력¶
| 이름 | 형상 | 설명 |
|---|---|---|
out[0] |
in[0]과 같음 | 출력 활성화 텐서. |
Tanh¶
원소별 hyperbolic tangent.
입력¶
| 이름 | 형상 | 설명 |
|---|---|---|
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) |